@bitpay-labs/bitcore-wallet-service 11.5.2

package/src/lib/fiatrateproviders/bitpay.ts

@@ -0,0 +1,20 @@
+import { IProvider, IRates } from './provider';
+
+export const BitPay: IProvider = {
+  name: 'BitPay',
+  getUrl(coin): string {
+    return `https://bitpay.com/api/rates/${coin.toUpperCase()}?p=bws`;
+  },
+  parseFn(raw) {
+    const rates: Array<IRates> = [];
+    for (const d of raw) {
+      if (d.code && d.rate) {
+        rates.push({
+          code: d.code,
+          value: +d.rate
+        });
+      }
+    }
+    return rates;
+  }
+};

package/src/lib/fiatrateproviders/bitstamp.ts

@@ -0,0 +1,16 @@
+import { IProvider, IRates } from './provider';
+
+export const Bitstamp: IProvider = {
+  name: 'Bitstamp',
+  getUrl(coin): string {
+    return `https://www.bitstamp.net/api/ticker/${coin}`;
+  },
+  parseFn(raw): Array<IRates> {
+    return [
+      {
+        code: 'USD',
+        value: parseFloat(raw.last)
+      }
+    ];
+  }
+};

package/src/lib/fiatrateproviders/index.ts

@@ -0,0 +1,8 @@
+import { BitPay } from './bitpay';
+import { IProvider } from './provider';
+// import { Bitstamp } from './bitstamp';
+
+
+export const providers: IProvider[] = [
+  BitPay // the first in the array is the default rate source
+];

package/src/lib/fiatrateproviders/provider.d.ts

@@ -0,0 +1,10 @@
+export interface IProvider {
+  name: string;
+  getUrl: (code: string) => string;
+  parseFn: (raw: any) => Array<IRates>;
+}
+
+export interface IRates {
+  code: string;
+  value: number;
+}

package/src/lib/fiatrateservice.ts

@@ -0,0 +1,338 @@
+import * as async from 'async';
+import preconditions from 'preconditions';
+import * as request from 'request';
+import { Common } from './common';
+import { providers } from './fiatrateproviders';
+import logger from './logger';
+import { Storage } from './storage';
+
+const $ = preconditions.singleton();
+
+const Defaults = Common.Defaults;
+const Constants = Common.Constants;
+
+export class FiatRateService {
+  request: request.RequestAPI<any, any, any>;
+  defaultProvider: any;
+  providers: any[];
+  storage: Storage;
+  init(opts, cb) {
+    opts = opts || {};
+
+    this.request = opts.request || request;
+    this.defaultProvider = opts.defaultProvider || Defaults.FIAT_RATE_PROVIDER;
+
+    async.parallel(
+      [
+        done => {
+          if (opts.storage) {
+            this.storage = opts.storage;
+            done();
+          } else {
+            this.storage = new Storage();
+            this.storage.connect(opts.storageOpts, done);
+          }
+        }
+      ],
+      err => {
+        if (err) {
+          logger.error('%o', err);
+        }
+        return cb(err);
+      }
+    );
+  }
+
+  startCron(opts, cb) {
+    opts = opts || {};
+
+    this.providers = providers;
+    const interval = opts.fetchInterval || Defaults.FIAT_RATE_FETCH_INTERVAL;
+    if (interval) {
+      this._fetch();
+      setInterval(() => {
+        this._fetch();
+      }, interval * 60 * 1000);
+    }
+
+    return cb();
+  }
+
+  _fetch(cb?) {
+    cb = cb || function() {};
+    const coins = Object.values(Constants.BITPAY_SUPPORTED_COINS);
+    const provider = this.providers[0];
+
+    async.each(
+      coins,
+      (coin, next2) => {
+        this._retrieve(provider, coin, (err, res) => {
+          if (err) {
+            logger.warn('Error retrieving data for %o->%o: %o', provider.name, coin, err);
+            return next2();
+          }
+          this.storage.storeFiatRate(coin, res, err => {
+            if (err) {
+              logger.warn('Error storing data for %o: %o', provider.name, err);
+            }
+            return next2();
+          });
+        });
+      },
+      cb
+    );
+  }
+
+  _retrieve(provider, coin, cb) {
+    logger.debug(`Fetching data for ${provider.name} / ${coin}`);
+    const coinUC = coin.toUpperCase();
+
+    const handleCoinsRates = (err, res) => {
+      if (err || !res || res.error) {
+        return cb(err || new Error('Unable to fetch rates data for ' + provider.name + ' / ' + coin + ': ' + res?.error));
+      }
+
+      logger.debug(`Data for ${provider.name} / ${coin} fetched successfully`);
+
+      if (!provider.parseFn) {
+        return cb(new Error('No parse function for provider ' + provider.name));
+      }
+      try {
+        const rates = provider.parseFn(res)?.filter(x => Defaults.FIAT_CURRENCIES.some(c => c.code == x.code)) || [];
+        return cb(null, rates);
+      } catch (e) {
+        return cb(e);
+      }
+    };
+
+    const ts = Date.now();
+    if (Constants.BITPAY_USD_STABLECOINS[coinUC]) {
+      return this.getRatesForStablecoin({ code: 'USD', ts }, handleCoinsRates);
+    }
+
+    if (Constants.BITPAY_EUR_STABLECOINS[coinUC]) {
+      return this.getRatesForStablecoin({ code: 'EUR', ts }, handleCoinsRates);
+    }
+    this.request.get(
+      {
+        url: provider.getUrl(coinUC),
+        json: true
+      },
+      (err, res, body) => handleCoinsRates(err, body)
+    );
+  }
+
+  getRate(opts, cb) {
+    $.shouldBeFunction(cb, 'Failed state: type error (cb not a function) at <getRate()>');
+
+    opts = opts || {};
+
+    const now = Date.now();
+    let coin = opts.coin || 'btc';
+    //    const provider = opts.provider || this.defaultProvider;
+    const ts = !isNaN(opts.ts) || Array.isArray(opts.ts) ? opts.ts : now;
+
+    async.map(
+      [].concat(ts),
+      (ts, cb) => {
+        if (coin === 'wbtc') {
+          logger.info('Using btc for wbtc rate.');
+          coin = 'btc';
+        }
+        if (coin === 'weth') {
+          logger.info('Using eth for weth rate.');
+          coin = 'eth';
+        }
+        this.storage.fetchFiatRate(coin, opts.code, ts, (err, rate) => {
+          if (err) return cb(err);
+          if (rate && ts - rate.ts > Defaults.FIAT_RATE_MAX_LOOK_BACK_TIME * 60 * 1000) rate = null;
+
+          return cb(null, {
+            ts: +ts,
+            rate: rate?.value,
+            fetchedOn: rate?.ts
+          });
+        });
+      },
+      (err, res: any) => {
+        if (err) return cb(err);
+        if (!Array.isArray(ts)) res = res[0];
+        return cb(null, res);
+      }
+    );
+  }
+
+  getRates(opts, cb) {
+    $.shouldBeFunction(cb, 'Failed state: type error (cb not a function) at <getRates()>');
+
+    opts = opts || {};
+
+    const now = Date.now();
+    const ts = opts.ts ? opts.ts : now;
+    let fiatFiltered: Array<typeof Defaults.FIAT_CURRENCIES[number]> = [];
+    const rates = [];
+
+    if (opts.code) {
+      fiatFiltered = Defaults.FIAT_CURRENCIES.filter(c => c.code === opts.code);
+      if (!fiatFiltered.length) return cb(opts.code + ' is not supported');
+    }
+    const currencies = fiatFiltered.length ? fiatFiltered : Defaults.FIAT_CURRENCIES;
+
+    async.map(
+      Object.values(Constants.BITPAY_SUPPORTED_COINS),
+      (coin, cb) => {
+        rates[coin] = [];
+        async.map(
+          currencies as any,
+          (currency: typeof Defaults.FIAT_CURRENCIES[number], cb) => {
+            let c = coin.split('_')[0];
+            if (c === 'wbtc') {
+              logger.info('Using btc for wbtc rate.');
+              c = 'btc';
+            }
+            if (c === 'weth') {
+              logger.info('Using eth for weth rate.');
+              c = 'eth';
+            }
+            this.storage.fetchFiatRate(c, currency.code, ts, (err, rate) => {
+              if (err) return cb(err);
+              if (rate && ts - rate.ts > Defaults.FIAT_RATE_MAX_LOOK_BACK_TIME * 60 * 1000) rate = null;
+              return cb(null, {
+                ts: +ts,
+                rate: rate?.value,
+                fetchedOn: rate?.ts,
+                code: currency.code,
+                name: currency.name
+              });
+            });
+          },
+          (err, res: any) => {
+            if (err) return cb(err);
+            const obj = {};
+            obj[coin] = res;
+            return cb(null, obj);
+          }
+        );
+      },
+      (err, res: any) => {
+        if (err) return cb(err);
+        return cb(null, Object.assign({}, ...res));
+      }
+    );
+  }
+
+  getRatesByCoin(opts, cb) {
+    $.shouldBeFunction(cb, 'Failed state: type error (cb not a function) at <getRatesByCoin()>');
+
+    let { coin } = opts;
+    const { code } = opts;
+    const ts = opts.ts || Date.now();
+
+    if (Constants.BITPAY_USD_STABLECOINS[coin.toUpperCase()]) {
+      return this.getRatesForStablecoin({ code: 'USD', ts }, cb);
+    }
+
+    if (Constants.BITPAY_EUR_STABLECOINS[coin.toUpperCase()]) {
+      return this.getRatesForStablecoin({ code: 'EUR', ts }, cb);
+    }
+
+    let fiatFiltered: Array<typeof Defaults.FIAT_CURRENCIES[number]> = [];
+
+    if (code) {
+      fiatFiltered = Defaults.FIAT_CURRENCIES.filter(c => c.code === opts.code);
+      if (!fiatFiltered.length) return cb(opts.code + ' is not supported');
+    }
+
+    const currencies = fiatFiltered.length ? fiatFiltered : Defaults.FIAT_CURRENCIES;
+
+    async.map(
+      currencies as any,
+      (currency: typeof Defaults.FIAT_CURRENCIES[number], cb) => {
+        if (coin === 'wbtc') {
+          logger.info('Using btc for wbtc rate.');
+          coin = 'btc';
+        }
+        if (coin === 'weth') {
+          logger.info('Using eth for weth rate.');
+          coin = 'eth';
+        }
+        this.storage.fetchFiatRate(coin, currency.code, ts, (err, rate) => {
+          if (err) return cb(err);
+          if (rate && ts - rate.ts > Defaults.FIAT_RATE_MAX_LOOK_BACK_TIME * 60 * 1000) rate = null;
+          return cb(null, {
+            ts: +ts,
+            rate: rate?.value,
+            fetchedOn: rate?.ts,
+            code: currency.code,
+            name: currency.name
+          });
+        });
+      },
+      cb
+    );
+  }
+
+  getHistoricalRates(opts, cb) {
+    $.shouldBeFunction(cb);
+
+    opts = opts || {};
+    const historicalRates = {};
+
+    // Oldest date in timestamp range in epoch number ex. 24 hours ago
+    const now = Date.now() - Defaults.FIAT_RATE_FETCH_INTERVAL * 60 * 1000;
+    const ts = !isNaN(opts.ts) ? opts.ts : now;
+    const coins = ['btc', 'bch', 'eth', 'matic', 'xrp', 'doge', 'ltc', 'shib', 'ape', 'sol'];
+
+    async.map(
+      coins,
+      (coin: string, cb) => {
+        this.storage.fetchHistoricalRates(coin, opts.code, ts, (err, rates) => {
+          if (err) return cb(err);
+          if (!rates) return cb();
+          for (const rate of rates) {
+            rate.rate = rate.value;
+            delete rate['_id'];
+            delete rate['code'];
+            delete rate['value'];
+            delete rate['coin'];
+          }
+          historicalRates[coin] = rates;
+          return cb(null, historicalRates);
+        });
+      },
+      (err, res: any) => {
+        if (err) return cb(err);
+        return cb(null, res[0]);
+      }
+    );
+  }
+
+  /**
+   * @description calculates fiat rates for a stablecoin
+   * @param {String} [opts.coin] crypto to base the fiat rates on (defaults to 'btc')
+   * @param {String} opts.code code for fiat currency that the stablecoin is pegged to
+   * @param {Number} [opts.ts] timestamp (defaults to now)
+   * @param {Function} cb
+   */
+  getRatesForStablecoin(opts, cb) {
+    $.shouldBeFunction(cb, 'Failed state: type error (cb not a function) at <getRatesForStablecoin()>');
+
+    const { coin = 'btc', code } = opts;
+    const ts = opts.ts || Date.now();
+
+    this.getRatesByCoin({ coin, ts }, (err, rates) => {
+      if (err) return cb(err);
+
+      const fiatRate = rates.find(rate => rate.code === code);
+      if (!fiatRate || !fiatRate.rate) return cb(null, []);
+
+      return cb(
+        null,
+        rates.map(({ rate, ...obj }) => ({
+          ...obj,
+          rate: parseFloat((rate / fiatRate.rate).toFixed(2))
+        }))
+      );
+    });
+  }
+}

package/src/lib/iconsconfig.ts

@@ -0,0 +1,31 @@
+import config from '../config';
+
+interface IconMap {
+  [key: string]: string;
+}
+
+const iconMap: IconMap = {
+  new_copayer: 'person-plus.png',
+  new_incoming_tx: 'down-arrow-green.png',
+  new_incoming_tx_testnet: 'down-arrow-green.png',
+  new_outgoing_tx: 'up-arrow-gray.png',
+  new_tx_proposal: 'writing-gray.png',
+  new_zero_outgoing_tx: 'up-arrow-gray.png',
+  tx_confirmation: 'green-check.png',
+  tx_confirmation_receiver: 'green-check.png',
+  tx_confirmation_sender: 'green-check.png',
+  txp_finally_rejected: 'failed-icon.png',
+  wallet_complete: 'green-check.png'
+};
+
+export const getIconHtml = (templateName: string, _sendEmail?: boolean): string | null => {
+  const iconFile = iconMap[templateName];
+  if (!iconFile) {
+    return null;
+  }
+
+  const staticUrl = config.baseUrl || 'https://bws.bitpay.com';
+  const iconUrl = `${staticUrl}/bws/static/images/${iconFile}`;
+  
+  return `<img src="${iconUrl}" alt="${templateName} icon" style="width: 50px; height: 50px;" />`;
+}; 

package/src/lib/lock.ts

@@ -0,0 +1,112 @@
+import { Common } from './common';
+import { Errors } from './errors/errordefinitions';
+import { Storage } from './storage';
+
+const Defaults = Common.Defaults;
+const ACQUIRE_RETRY_STEP = 50; // ms
+
+interface ILockOptions {
+  /** 
+   * Maximum time (in ms) to hold the lock after which it'll automatically release.
+   * Default: Defaults.LOCK_EXE_TIME (ms)
+   */
+  lockTime?: number;
+  /**
+   * Time (in ms) you're willing to wait if a lock is already held by someone else.
+   * Default: 50
+   */
+  waitTime?: number;
+};
+
+type LockOpts = ILockOptions | null | undefined;
+
+export class Lock {
+  storage: Storage;
+
+  constructor(storage: Storage) {
+    this.storage = storage;
+  }
+
+  /**
+   * Acquire a database lock for a given token
+   * @param {string} token The key to lock on
+   * @param {ILockOptions | null | undefined} opts Options for the lock
+   * @param {Function} cb Callback function that takes an error and a lock release (LR) function. The LR function itself takes an optional callback
+   * @param {number} [timeLeft] Internal parameter to track time left when retrying to acquire the lock
+   * 
+   * @example
+   * lock.acquire('mylock', null, function(err, release) {
+   *   // We have the lock! Do stuff...
+   *   
+   *   release(function() {
+   *     // Lock released. Carry on...
+   *  
+   *   });
+   * });
+   */
+  acquire(token: string, opts: LockOpts, cb: (err: any, release?: (cb?: () => void) => void) => void, timeLeft?: number) {
+    opts = opts || {};
+
+    opts.lockTime = opts.lockTime || Defaults.LOCK_EXE_TIME;
+
+    this.storage.acquireLock(token, Date.now() + opts.lockTime, err => {
+      if (err) {
+        // Lock already exists?
+        if (err.message?.indexOf('E11000 ') !== -1) {
+          // Existing lock expired?
+          this.storage.clearExpiredLock(token, () => {});
+          // Waiting time for lock has expired
+          if (timeLeft < 0) {
+            return cb('LOCKED');
+          }
+
+          if (opts.waitTime != null) {
+            timeLeft = timeLeft == null ? opts.waitTime : (timeLeft - ACQUIRE_RETRY_STEP);
+          }
+
+          return setTimeout(this.acquire.bind(this, token, opts, cb, timeLeft), ACQUIRE_RETRY_STEP);
+        }
+        // Actual DB error
+        return cb(err);
+      }
+      // Lock available
+      return cb(null, /* release function: */ icb => {
+        if (!icb) icb = () => {};
+        this.storage.releaseLock(token, icb);
+      });
+    });
+  }
+
+  /**
+   * Run a function while holding a lock and automatically release the lock when the callback is finished
+   * @param {string} token The key to lock on
+   * @param {ILockOptions | null | undefined} opts Options for the lock
+   * @param {Function} cb Callback function that take an error and a lock release function
+   * @param {Function} task The function to run while holding the lock
+   * 
+   * @example
+   * lock.runLocked('mylock', null, function(err) {
+   *     // Uh-oh, lock could not be acquired. Short circuit.
+   *   }, function(done) {
+   *    // We have the lock! Do stuff...
+   *    
+   *    done();
+   *   }
+   * });
+   */
+  runLocked(token: string, opts: LockOpts, cb: (...args: any) => void, task: (cb: (...args: any) => void) => void) {
+    if (!token) {
+      return cb(new Error('Failed state: token undefined at <runLocked()>'));
+    }
+
+    this.acquire(token, opts, (err, release) => {
+      if (err == 'LOCKED') return cb(Errors.WALLET_BUSY);
+      if (err) return cb(err);
+
+      task(function(...args) {
+        cb(...args);
+        release();
+      });
+    });
+  }
+}

package/src/lib/logger.ts

@@ -0,0 +1,77 @@
+import path from 'path';
+import * as winston from 'winston';
+
+// const logLevel = args.DEBUG ? 'debug' : 'info';
+const logLevel = process.env.BWS_LOG_LEVEL || 'debug';
+
+export const transports: winston.transport[] = [
+  new winston.transports.Console({
+    level: logLevel,
+    format: winston.format.combine(
+      winston.format.colorize(),
+      winston.format.prettyPrint(),
+      winston.format.splat(),
+      winston.format.simple(),
+      winston.format.printf(function(info) {
+        // fallback in case the above formatters don't work.
+        // eg: logger.log({ some: 'object' })
+        if (typeof info.message === 'object') {
+          info.message = JSON.stringify(info.message, null, 4);
+        }
+        return `${info.level} :: ${new Date().toISOString()} :: ${info.message}`;
+      })
+    ),
+  })
+];
+
+if (process.env.BWS_LOG_HTTP_HOST) {
+  transports.push(new winston.transports.Http({
+    level: process.env.BWS_LOG_HTTP_LEVEL || logLevel,
+    host: process.env.BWS_LOG_HTTP_HOST,
+    port: parseInt(process.env.BWS_LOG_HTTP_PORT) || undefined,
+    path: process.env.BWS_LOG_HTTP_PATH || ('bws.' + path.parse(process.argv[1]).name),
+    headers: {
+      'Content-Type': 'application/json'
+    },
+    format: winston.format.combine(
+      winston.format.splat(),
+      winston.format.simple(),
+      winston.format.printf(info => {
+        // fallback in case the above formatters don't work.
+        // eg: logger.log({ some: 'object' })
+        if (typeof info.message === 'object') {
+          info.message = JSON.stringify(info.message, null, 4);
+        }
+        return JSON.stringify({
+          tag: process.env.BWS_LOG_HTTP_TAG || ('bws.' + path.parse(process.argv[1]).name),
+          ...info
+        });
+      }),
+    )
+  }));
+}
+
+export const logger = winston.createLogger({ transports });
+
+export const formatTimestamp = (date: Date): string =>
+  `${date.getFullYear()}-${(date.getMonth() + 1).toString().padStart(2, '0')}-${date
+    .getDate()
+    .toString()
+    .padStart(2, '0')} ${date
+    .getHours()
+    .toString()
+    .padStart(2, '0')}:${date
+    .getMinutes()
+    .toString()
+    .padStart(2, '0')}:${date
+    .getSeconds()
+    .toString()
+    .padStart(2, '0')}.${date
+    .getMilliseconds()
+    .toString()
+    // .padEnd(3, '0')} ${timezone}`;
+    .padEnd(3, '0')}`;
+
+export const timestamp = () => formatTimestamp(new Date());
+
+export default logger;

package/src/lib/messagebroker.ts

@@ -0,0 +1,42 @@
+import { EventEmitter } from 'events';
+import * as io from 'socket.io-client';
+import 'source-map-support/register';
+import logger from './logger';
+
+export class MessageBroker extends EventEmitter {
+  remote: boolean;
+  mq: io.Socket;
+  constructor(opts) {
+    super();
+
+    opts = opts || {};
+    if (opts.messageBrokerServer) {
+      const url = opts.messageBrokerServer.url;
+
+      this.remote = true;
+      this.mq = io.connect(url);
+      this.mq.on('connect', () => {});
+      this.mq.on('connect_error', () => {
+        logger.warn('Error connecting to message broker server @ ' + url);
+      });
+
+      this.mq.on('msg', data => {
+        this.emit('msg', data);
+      });
+
+      logger.info('Using message broker server at ' + url);
+    }
+  }
+
+  send(data) {
+    if (this.remote) {
+      this.mq.emit('msg', data);
+    } else {
+      this.emit('msg', data);
+    }
+  }
+
+  onMessage(handler) {
+    this.on('msg', handler);
+  }
+}