@bitpay-labs/bitcore-wallet-service 11.5.2

package/ts_build/src/lib/pushnotificationsservice.js

@@ -0,0 +1,721 @@
+"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 });
+exports.PushNotificationsService = void 0;
+const fs = __importStar(require("fs"));
+const path_1 = __importDefault(require("path"));
+const async = __importStar(require("async"));
+const lodash_1 = __importDefault(require("lodash"));
+require("source-map-support/register");
+const mustache_1 = __importDefault(require("mustache"));
+const request_1 = __importDefault(require("request"));
+const sjcl_1 = __importDefault(require("sjcl"));
+const config_1 = __importDefault(require("../config"));
+const common_1 = require("./common");
+const logger_1 = __importDefault(require("./logger"));
+const messagebroker_1 = require("./messagebroker");
+const storage_1 = require("./storage");
+const Utils = common_1.Common.Utils;
+const Defaults = common_1.Common.Defaults;
+const Constants = common_1.Common.Constants;
+const PUSHNOTIFICATIONS_TYPES = {
+    NewCopayer: {
+        filename: 'new_copayer'
+    },
+    WalletComplete: {
+        filename: 'wallet_complete'
+    },
+    NewTxProposal: {
+        filename: 'new_tx_proposal'
+    },
+    NewOutgoingTx: {
+        filename: ['new_outgoing_tx', 'new_zero_outgoing_tx']
+    },
+    NewIncomingTx: {
+        filename: ['new_incoming_tx']
+    },
+    TxProposalFinallyRejected: {
+        filename: 'txp_finally_rejected'
+    },
+    TxConfirmation: {
+        filename: ['tx_confirmation_sender', 'tx_confirmation_receiver']
+    },
+    NewAddress: {
+        dataOnly: true
+    },
+    ScanFinished: {
+        dataOnly: true,
+        broadcastToActiveUsers: true
+    },
+    NewBlock: {
+        dataOnly: true,
+        broadcastToActiveUsers: true
+    },
+    TxProposalAcceptedBy: {
+        dataOnly: true
+    },
+    TxProposalFinallyAccepted: {
+        dataOnly: true
+    },
+    TxProposalRejectedBy: {
+        dataOnly: true
+    },
+    TxProposalRemoved: {
+        dataOnly: true
+    }
+};
+class PushNotificationsService {
+    request;
+    templatePath;
+    defaultLanguage;
+    defaultUnit;
+    subjectPrefix;
+    pushServerUrl;
+    pushServerUrlBraze;
+    availableLanguages;
+    authorizationKey;
+    authorizationKeyBraze;
+    storage;
+    messageBroker;
+    start(opts, cb) {
+        opts = opts || {};
+        this.request = opts.request || request_1.default;
+        const _readDirectories = (basePath, cb) => {
+            fs.readdir(basePath, (err, files) => {
+                if (err)
+                    return cb(err);
+                async.filter(files, (file, next) => {
+                    fs.stat(path_1.default.join(basePath, file), (err, stats) => {
+                        return next(!err && stats.isDirectory());
+                    });
+                }, dirs => {
+                    return cb(null, dirs);
+                });
+            });
+        };
+        this.templatePath = path_1.default.normalize((opts.pushNotificationsOpts.templatePath || __dirname + '../../templates') + '/');
+        this.defaultLanguage = opts.pushNotificationsOpts.defaultLanguage || 'en';
+        this.defaultUnit = opts.pushNotificationsOpts.defaultUnit || 'btc';
+        this.subjectPrefix = opts.pushNotificationsOpts.subjectPrefix || '';
+        this.pushServerUrl = opts.pushNotificationsOpts.pushServerUrl;
+        this.authorizationKey = opts.pushNotificationsOpts.authorizationKey;
+        this.pushServerUrlBraze = opts.pushNotificationsOpts.pushServerUrlBraze;
+        this.authorizationKeyBraze = opts.pushNotificationsOpts.authorizationKeyBraze;
+        if (!this.authorizationKey && !this.authorizationKeyBraze)
+            return cb(new Error('Missing authorizationKey attribute in configuration.'));
+        async.parallel([
+            done => {
+                _readDirectories(this.templatePath, (err, res) => {
+                    this.availableLanguages = res;
+                    done(err);
+                });
+            },
+            done => {
+                if (opts.storage) {
+                    this.storage = opts.storage;
+                    done();
+                }
+                else {
+                    this.storage = new storage_1.Storage();
+                    this.storage.connect(opts.storageOpts, done);
+                }
+            },
+            done => {
+                this.messageBroker = opts.messageBroker || new messagebroker_1.MessageBroker(opts.messageBrokerOpts);
+                this.messageBroker.onMessage(lodash_1.default.bind(this._sendPushNotifications, this));
+                done();
+            }
+        ], err => {
+            if (err) {
+                logger_1.default.error('ERROR:' + err);
+            }
+            return cb(err);
+        });
+    }
+    _sendPushNotifications(notification, cb) {
+        cb = cb || function () { };
+        const notifType = lodash_1.default.cloneDeep(PUSHNOTIFICATIONS_TYPES[notification?.type]);
+        if (!notifType)
+            return cb();
+        if (notification.type === 'NewIncomingTx') {
+            notifType.filename = notifType.filename[0];
+            if (notification.data.network && notification.data.network !== 'mainnet') {
+                notification.data.networkStr = ' on ' + notification.data.network;
+            }
+            else {
+                notification.data.networkStr = '';
+            }
+        }
+        else if (notification.type === 'NewOutgoingTx') {
+            notifType.filename = notification.data.amount !== 0 ? notifType.filename[0] : notifType.filename[1];
+        }
+        else if (notification.type === 'TxConfirmation') {
+            if (notification.data && !notification.data.amount) {
+                notifType.filename = 'tx_confirmation';
+            }
+            else {
+                notifType.filename = notification.isCreator ? notifType.filename[0] : notifType.filename[1];
+            }
+        }
+        logger_1.default.debug('Notification received: ' + notification.type);
+        logger_1.default.debug(JSON.stringify(notification));
+        this._checkShouldSendNotif(notification, (err, should) => {
+            if (err)
+                return cb(err);
+            logger_1.default.debug('Should send notification: ' + should);
+            if (!should)
+                return cb();
+            this._getRecipientsList(notification, notifType, (err, recipientsList) => {
+                if (err)
+                    return cb(err);
+                async.waterfall([
+                    next => {
+                        this._readAndApplyTemplates(notification, notifType, recipientsList, next);
+                    },
+                    (contents, next) => {
+                        this._getSubscriptions(notification, notifType, recipientsList, contents, next);
+                    },
+                    (subs, next) => {
+                        const notifications = lodash_1.default.map(subs, sub => {
+                            if (notification.type === 'NewTxProposal' && sub.copayerId === notification.creatorId)
+                                return;
+                            const tokenAddress = notification.data && notification.data.tokenAddress ? notification.data.tokenAddress : null;
+                            const multisigContractAddress = notification.data && notification.data.multisigContractAddress
+                                ? notification.data.multisigContractAddress
+                                : null;
+                            let notificationData;
+                            const walletId = sjcl_1.default.codec.hex.fromBits(sjcl_1.default.hash.sha256.hash(notification.walletId || sub.walletId));
+                            const copayerId = sjcl_1.default.codec.hex.fromBits(sjcl_1.default.hash.sha256.hash(sub.copayerId));
+                            const notification_type = notification.type;
+                            const chain = notification?.data?.chain || notification?.data?.coin;
+                            const coin = chain;
+                            const network = notification?.data?.network ? Utils.getNetworkName(chain, notification.data.network) : null;
+                            if (sub.token) {
+                                notificationData = {
+                                    to: sub.token,
+                                    priority: 'high',
+                                    restricted_package_name: sub.packageName,
+                                    data: {
+                                        walletId,
+                                        tokenAddress,
+                                        multisigContractAddress,
+                                        copayerId,
+                                        notification_type,
+                                        coin,
+                                        chain,
+                                        network
+                                    }
+                                };
+                                if (!notifType.dataOnly) {
+                                    notificationData.data.title = sub?.plain?.subject;
+                                    notificationData.data.body = sub?.plain?.body;
+                                    notificationData.notification = {
+                                        title: sub?.plain?.subject,
+                                        body: sub?.plain?.body,
+                                        sound: 'default',
+                                        click_action: 'FCM_PLUGIN_ACTIVITY',
+                                        icon: 'fcm_push_icon'
+                                    };
+                                }
+                            }
+                            if (sub.externalUserId) {
+                                const title = sub?.plain?.subject;
+                                const body = sub?.plain?.body;
+                                const extras = {
+                                    walletId,
+                                    copayerId,
+                                    notification_type,
+                                    coin,
+                                    chain,
+                                    network,
+                                    tokenAddress,
+                                    multisigContractAddress,
+                                    title,
+                                    body
+                                };
+                                const custom_uri = `bitpay://wallet?walletId=${walletId}&tokenAddress=${tokenAddress}&multisigContractAddress=${multisigContractAddress}&copayerId=${copayerId}&coin=${coin}&chain=${chain}&network=${network}&notification_type=${notification_type}&title=${title}&body=${body}`;
+                                notificationData = {
+                                    external_user_ids: [sub.externalUserId],
+                                    messages: {
+                                        apple_push: {
+                                            alert: {
+                                                title,
+                                                body
+                                            },
+                                            extra: extras,
+                                            custom_uri
+                                        },
+                                        android_push: {
+                                            alert: body,
+                                            title,
+                                            extra: extras,
+                                            custom_uri
+                                        }
+                                    }
+                                };
+                                if (notifType.dataOnly) {
+                                    notificationData.messages.apple_push['content-available'] = true;
+                                    notificationData.messages.android_push['send_to_sync'] = true;
+                                }
+                            }
+                            return notificationData;
+                        });
+                        if (notifications &&
+                            notifications[0] &&
+                            notifications[0].notification &&
+                            subs.length > Defaults.PUSH_NOTIFICATION_LIMIT) {
+                            logger_1.default.warn(`The recipient list for this push notification is greater than the established limit (${Defaults.PUSH_NOTIFICATION_LIMIT})`);
+                        }
+                        return next(err, notifications);
+                    },
+                    (notifications, next) => {
+                        async.each(notifications, (notification, next) => {
+                            if (notification && notification.external_user_ids) {
+                                this._makeBrazeRequest(notification, (err, response) => {
+                                    if (err)
+                                        logger_1.default.error('An error occurred making a braze push notification request:' + err);
+                                    if (response) {
+                                    }
+                                    next();
+                                });
+                            }
+                            else if (notification && notification.to) {
+                                this._makeRequest(notification, (err, response) => {
+                                    if (err)
+                                        logger_1.default.error('An error occurred making a firebase push notification request:' + err);
+                                    if (response) {
+                                    }
+                                    next();
+                                });
+                            }
+                        }, err => {
+                            return next(err);
+                        });
+                    }
+                ], err => {
+                    if (err) {
+                        logger_1.default.error('An error ocurred generating notification:' + err);
+                    }
+                    return cb(err);
+                });
+            });
+        });
+    }
+    _checkShouldSendNotif(notification, cb) {
+        if (notification.type != 'NewTxProposal')
+            return cb(null, true);
+        this.storage.fetchWallet(notification.walletId, (err, wallet) => {
+            return cb(err, wallet && wallet.m > 1);
+        });
+    }
+    _getRecipientsList(notification, notificationType, cb) {
+        if (notificationType.broadcastToActiveUsers)
+            return cb(null, []);
+        this.storage.fetchWallet(notification.walletId, (err, wallet) => {
+            if (err)
+                return cb(err);
+            if (!wallet)
+                return cb(null, []);
+            let unit;
+            if (wallet.coin != Defaults.COIN) {
+                switch (wallet.coin) {
+                    case 'pax':
+                        unit = 'usdp';
+                        break;
+                    default:
+                        unit = wallet.coin;
+                }
+            }
+            this.storage.fetchPreferences(notification.walletId, null, (err, preferences) => {
+                if (err)
+                    logger_1.default.error('%o', err);
+                if (lodash_1.default.isEmpty(preferences))
+                    preferences = [];
+                const recipientPreferences = lodash_1.default.compact(lodash_1.default.map(preferences, p => {
+                    if (!lodash_1.default.includes(this.availableLanguages, p.language)) {
+                        if (p.language)
+                            logger_1.default.warn('Language for notifications "' + p.language + '" not available.');
+                        p.language = this.defaultLanguage;
+                    }
+                    return {
+                        copayerId: p.copayerId,
+                        language: p.language || this.defaultLanguage,
+                        unit: unit || p.unit || this.defaultUnit
+                    };
+                }));
+                const copayers = lodash_1.default.keyBy(recipientPreferences, 'copayerId');
+                const recipientsList = lodash_1.default.compact(lodash_1.default.map(wallet.copayers, copayer => {
+                    const p = copayers[copayer.id] || {
+                        language: this.defaultLanguage,
+                        unit: this.defaultUnit
+                    };
+                    return {
+                        walletId: notification.walletId,
+                        copayerId: copayer.id,
+                        language: p.language || this.defaultLanguage,
+                        unit: unit || p.unit || this.defaultUnit
+                    };
+                }));
+                return cb(null, recipientsList);
+            });
+        });
+    }
+    _readAndApplyTemplates(notification, notifType, recipientsList, cb) {
+        if (!notifType.filename)
+            return cb(null, []);
+        async.map(recipientsList, (recipient, next) => {
+            async.waterfall([
+                next => {
+                    this._getDataForTemplate(notification, recipient, next);
+                },
+                (data, next) => {
+                    async.map(['plain', 'html'], (type, next) => {
+                        this._loadTemplate(notifType, recipient, '.' + type, (err, template) => {
+                            if (err && type == 'html')
+                                return next();
+                            if (err)
+                                return next(err);
+                            this._applyTemplate(template, data, (err, res) => {
+                                return next(err, [type, res]);
+                            });
+                        });
+                    }, (err, res) => {
+                        return next(err, lodash_1.default.fromPairs(res.filter(Boolean)));
+                    });
+                },
+                (result, next) => {
+                    next(null, result);
+                }
+            ], (err, res) => {
+                next(err, [recipient.language, res]);
+            });
+        }, (err, res) => {
+            return cb(err, lodash_1.default.fromPairs(res.filter(Boolean)));
+        });
+    }
+    async _getDataForTemplate(notification, recipient, cb) {
+        const UNIT_LABELS = {
+            btc: 'BTC',
+            bit: 'bits',
+            bch: 'BCH',
+            eth: 'ETH',
+            matic: 'MATIC',
+            xrp: 'XRP',
+            doge: 'DOGE',
+            ltc: 'LTC',
+            usdc: 'USDC',
+            pyusd: 'PYUSD',
+            usdp: 'USDP',
+            gusd: 'GUSD',
+            busd: 'BUSD',
+            dai: 'DAI',
+            wbtc: 'WBTC',
+            shib: 'SHIB',
+            ape: 'APE',
+            euroc: 'EUROC',
+            usdt: 'USDT',
+            weth: 'WETH',
+            'usdc.e': 'USDC.e',
+            sol: 'SOL'
+        };
+        const data = lodash_1.default.cloneDeep(notification.data);
+        data.subjectPrefix = lodash_1.default.trim(this.subjectPrefix + ' ');
+        if (data.amount) {
+            try {
+                let unit = recipient.unit.toLowerCase();
+                let label = UNIT_LABELS[unit];
+                const opts = {};
+                if (data.tokenAddress) {
+                    const tokenAddress = data.tokenAddress.toLowerCase();
+                    if (Constants.ETH_TOKEN_OPTS[tokenAddress]) {
+                        unit = Constants.ETH_TOKEN_OPTS[tokenAddress].symbol.toLowerCase();
+                        label = UNIT_LABELS[unit];
+                    }
+                    else if (Constants.MATIC_TOKEN_OPTS[tokenAddress]) {
+                        unit = Constants.MATIC_TOKEN_OPTS[tokenAddress].symbol.toLowerCase();
+                        label = UNIT_LABELS[unit];
+                    }
+                    else if (Constants.ARB_TOKEN_OPTS[tokenAddress]) {
+                        unit = Constants.ARB_TOKEN_OPTS[tokenAddress].symbol.toLowerCase();
+                        label = UNIT_LABELS[unit];
+                    }
+                    else if (Constants.OP_TOKEN_OPTS[tokenAddress]) {
+                        unit = Constants.OP_TOKEN_OPTS[tokenAddress].symbol.toLowerCase();
+                        label = UNIT_LABELS[unit];
+                    }
+                    else if (Constants.BASE_TOKEN_OPTS[tokenAddress]) {
+                        unit = Constants.BASE_TOKEN_OPTS[tokenAddress].symbol.toLowerCase();
+                        label = UNIT_LABELS[unit];
+                    }
+                    else if (Constants.SOL_TOKEN_OPTS[tokenAddress]) {
+                        unit = Constants.SOL_TOKEN_OPTS[tokenAddress].symbol.toLowerCase();
+                        label = UNIT_LABELS[unit];
+                    }
+                    else {
+                        let customTokensData;
+                        let tokenData;
+                        try {
+                            customTokensData = await this.getTokenData(data.address.coin);
+                            tokenData = customTokensData.find(t => t.address === tokenAddress);
+                        }
+                        catch {
+                            return cb(new Error('Could not get custom tokens data'));
+                        }
+                        if (tokenData) {
+                            unit = tokenData.symbol.toLowerCase();
+                            label = unit.toUpperCase();
+                            opts.toSatoshis = 10 ** tokenData.decimals;
+                            opts.decimals = {
+                                maxDecimals: 6,
+                                minDecimals: 2
+                            };
+                        }
+                        else {
+                            return cb(new Error(`Push notifications for unsupported tokens are not allowed: ${tokenAddress}`));
+                        }
+                    }
+                }
+                data.amount = Utils.formatAmount(+data.amount, unit, opts) + ' ' + label;
+            }
+            catch (ex) {
+                return cb(new Error('Could not format amount' + ex));
+            }
+        }
+        this.storage.fetchWallet(notification.walletId, (err, wallet) => {
+            if (err || !wallet)
+                return cb(err);
+            data.walletId = wallet.id;
+            data.walletName = wallet.name;
+            data.walletM = wallet.m;
+            data.walletN = wallet.n;
+            const copayer = wallet.copayers.find(c => c.id === notification.creatorId);
+            if (copayer) {
+                data.copayerId = copayer.id;
+                data.copayerName = copayer.name;
+            }
+            if (notification.type == 'TxProposalFinallyRejected' && data.rejectedBy) {
+                const rejectors = lodash_1.default.map(data.rejectedBy, copayerId => {
+                    return wallet.copayers.find(c => c.id === copayerId).name;
+                });
+                data.rejectorsNames = rejectors.join(', ');
+            }
+            return cb(null, data);
+        });
+    }
+    _applyTemplate(template, data, cb) {
+        if (!data)
+            return cb(new Error('Could not apply template to empty data'));
+        let error;
+        const result = lodash_1.default.mapValues(template, t => {
+            try {
+                return mustache_1.default.render(t, data);
+            }
+            catch (e) {
+                logger_1.default.error('Could not apply data to template: %o', e);
+                error = e;
+            }
+        });
+        if (error)
+            return cb(error);
+        return cb(null, result);
+    }
+    _loadTemplate(notifType, recipient, extension, cb) {
+        this._readTemplateFile(recipient.language, notifType.filename + extension, (err, template) => {
+            if (err)
+                return cb(err);
+            return cb(null, this._compileTemplate(template, extension));
+        });
+    }
+    _readTemplateFile(language, filename, cb) {
+        const fullFilename = path_1.default.join(this.templatePath, language, filename);
+        fs.readFile(fullFilename, 'utf8', (err, template) => {
+            if (err) {
+                return cb(new Error('Could not read template file ' + fullFilename + err));
+            }
+            return cb(null, template);
+        });
+    }
+    _compileTemplate(template, extension) {
+        const lines = template.split('\n');
+        if (extension == '.html') {
+            lines.unshift('');
+        }
+        return {
+            subject: lines[0],
+            body: lodash_1.default.tail(lines).join('\n')
+        };
+    }
+    _getSubscriptions(notification, notifType, recipientsList, contents, cb) {
+        if (notifType.broadcastToActiveUsers) {
+            this.storage.fetchLatestPushNotificationSubs((err, subs) => {
+                if (err)
+                    return cb(err);
+                const allSubsWithToken = lodash_1.default.uniqBy(lodash_1.default.reject(subs, sub => !sub.walletId || sub.externalUserId), 'token');
+                const allSubsWithExternalId = lodash_1.default.uniqBy(lodash_1.default.reject(subs, sub => !sub.walletId || sub.token), 'externalUserId');
+                const allSubs = allSubsWithExternalId.length > 0 ? allSubsWithExternalId : allSubsWithToken;
+                const chainOrCoin = notification.data.chain || notification.data.coin;
+                const networkInfo = notification.data.network;
+                const hasChainNetworkInfo = chainOrCoin && networkInfo;
+                const chainNetworkMessage = hasChainNetworkInfo ? ` [${chainOrCoin}/${networkInfo}]` : '';
+                logger_1.default.info(`Sending ${notification.type}${chainNetworkMessage} notifications to: ${allSubs.length} devices`);
+                return cb(null, allSubs);
+            });
+        }
+        else {
+            async.map(recipientsList, (recipient, next) => {
+                const content = contents ? contents[recipient.language] : null;
+                this.storage.fetchPushNotificationSubs(recipient.copayerId, (err, subs) => {
+                    if (err)
+                        return next(err);
+                    const subscriptions = subs && subs.length ? subs.map(obj => ({ ...obj, plain: content?.plain })) : subs;
+                    const allSubsWithToken = lodash_1.default.uniqBy(lodash_1.default.reject(subscriptions, sub => !sub.walletId || sub.externalUserId), 'token');
+                    const allSubsWithExternalId = lodash_1.default.uniqBy(lodash_1.default.reject(subscriptions, sub => !sub.walletId || sub.token), 'externalUserId');
+                    const allSubs = allSubsWithExternalId.length > 0 ? allSubsWithExternalId : allSubsWithToken;
+                    return next(err, allSubs);
+                });
+            }, (err, allSubs) => {
+                if (err)
+                    return cb(err);
+                return cb(null, lodash_1.default.flatten(allSubs));
+            });
+        }
+    }
+    _makeRequest(opts, cb) {
+        this.request({
+            url: this.pushServerUrl + '/send',
+            method: 'POST',
+            json: true,
+            headers: {
+                'Content-Type': 'application/json',
+                Authorization: 'key=' + this.authorizationKey
+            },
+            body: opts
+        }, cb);
+    }
+    _makeBrazeRequest(opts, cb) {
+        this.request({
+            url: this.pushServerUrlBraze + '/messages/send',
+            method: 'POST',
+            json: true,
+            headers: {
+                'Content-Type': 'application/json',
+                Authorization: 'Bearer ' + this.authorizationKeyBraze
+            },
+            body: opts
+        }, cb);
+    }
+    coinGeckoGetCredentials() {
+        if (!config_1.default.coinGecko)
+            throw new Error('coinGecko missing credentials');
+        const credentials = {
+            API: config_1.default.coinGecko.api,
+            API_KEY: config_1.default.coinGecko.apiKey,
+        };
+        return credentials;
+    }
+    getTokenData(chain) {
+        return new Promise((resolve, reject) => {
+            const cacheKey = `cgTokenList:${chain}`;
+            const credentials = this.coinGeckoGetCredentials();
+            this.storage.checkAndUseGlobalCache(cacheKey, Defaults.COIN_GECKO_CACHE_DURATION, (err, values, oldvalues) => {
+                if (err)
+                    logger_1.default.warn('Cache check failed', err);
+                if (values)
+                    return resolve(values);
+                const assetPlatformMap = {
+                    eth: 'ethereum',
+                    matic: 'polygon-pos',
+                    pol: 'polygon-pos',
+                    arb: 'arbitrum-one',
+                    base: 'base',
+                    op: 'optimistic-ethereum',
+                    sol: 'solana',
+                };
+                const assetId = assetPlatformMap[chain];
+                if (!assetId)
+                    return reject(new Error(`Unsupported chain '${chain}'`));
+                const URL = `${credentials.API}/v3/token_lists/${assetId}/all.json`;
+                const headers = {
+                    'Content-Type': 'application/json',
+                    'Accept': 'application/json',
+                    'x-cg-pro-api-key': credentials.API_KEY
+                };
+                this.request.get(URL, {
+                    headers,
+                    json: true
+                }, (err, data) => {
+                    const tokens = data?.body?.tokens;
+                    const status = data?.body?.status;
+                    if (err) {
+                        logger_1.default.warn('An error occured while retrieving the token list', err);
+                        if (oldvalues) {
+                            logger_1.default.warn('Using old cached values');
+                            return resolve(oldvalues);
+                        }
+                        return reject(err.body ?? err);
+                    }
+                    else if (status?.error_code === 429 && oldvalues) {
+                        return resolve(oldvalues);
+                    }
+                    else {
+                        if (!tokens) {
+                            if (oldvalues) {
+                                logger_1.default.warn('No token list available... using old cached values');
+                                return resolve(oldvalues);
+                            }
+                            return reject(new Error(`Could not get tokens list. Code: ${status?.error_code}. Error: ${status?.error_message || 'Unknown error'}`));
+                        }
+                        const updatedTokens = tokens.map(token => {
+                            if (token.logoURI?.includes('/thumb/')) {
+                                token.logoURI = token.logoURI.replace('/thumb/', '/large/');
+                            }
+                            return token;
+                        });
+                        this.storage.storeGlobalCache(cacheKey, updatedTokens, storeErr => {
+                            if (storeErr)
+                                logger_1.default.warn('Could not cache token list', storeErr);
+                            return resolve(updatedTokens);
+                        });
+                    }
+                });
+            });
+        });
+    }
+}
+exports.PushNotificationsService = PushNotificationsService;
+//# sourceMappingURL=pushnotificationsservice.js.map