public constructor(
    private readonly db: AngularFire2DatabaseAdaptor,
  ) {
    this.profitabilityStats = db.list(validPathForList(['v2', 'pool', 'latest']))
      .publishReplay(1)
      .refCount();

    this.profitabilityTimeseriesCache = {};
  }

 (uid) => {
   const path = validPathForList(['v2', 'user', uid, 'bookmarks', 'pools']);
   return Observable.fromPromise(
     // tslint:disable-next-line:no-any
     this.db.insertObject(path, newBookmark as any),
   );
 },

 (uid) => this.db.object(validPath(['v2', 'user', uid, 'rig-profile', profileUuid]))
   .switchMap(
     (profile) => profile != null ?
       Observable.of(profile) :
       // If the RigProfile isn't found in the users set of profiles, fallback to globally
       // defined rig profiles.
       this.db.object(validPath(['v2', 'rig-profile', profileUuid])),
 ),

        ([uid, bookmarks]) => {
          const index = Object.keys(bookmarks.pools)
            .find(key => bookmarks.pools[key] === bookmark);

          if (index == null) {
            throw new Error('Can\'t find bookmark to remove');
          }

          const path = validPath(['v2', 'user', uid, 'bookmarks', 'pools', index]);
          return Observable.fromPromise(
            this.db.removeObject(path),
          );
        },

  private watchProfitability<
    K extends keyof PoolProfitability,
    Z extends keyof PoolProfitability[K],
    T extends PoolProfitability[K][Z]
  >(
    p: PoolCurrentWithKey,
    granularityKey: K,
    convertFn: (multiplier: number) => (data: T) => TimeseriesDataPoint,
    limit = 120,
    rigProfile: Observable<RigProfile>,
  ): Observable<PoolAlgoData> {
    let limitMinutes = limit;
    switch (granularityKey) {
      case 'per-day':
        limitMinutes = limit * 24 * 60;
        break;
      case 'per-hour':
        limitMinutes = limit * 60;
        break;
      default:
    }

    const listKey: ValidPathForList<T> = isCoinPoolCurrent(p) ?
      validPathForList([
        'v2', 'pool', 'coin', p.pool, p.coin, p.algo, 'profitability', granularityKey,
      ]) :
      validPathForList([
        'v2', 'pool', 'algo', p.pool, p.algo, 'profitability', granularityKey,
      ]);

    const listResult = this.db.list(
      listKey,
      { limitToLast: limit, orderByPriority: true },
    );
    return listResult
      .combineLatest(
        rigProfile.map(profile => convertFn(this.multiplier(p.pool, p.algo, profile))),
      )
      .map(
        ([data, convertFnInstance]): PoolAlgoData => {
          const timeLimit = (Date.now() - limitMinutes * 60 * 1000);

          const mostRecent = data.reduce(
            (newest, next) => {
              if (newest.timestamp < next.timestamp) {
                return next;
              }
              return newest;
            },
            data[0],
          );

          return {
            algo: p.algo,
            key: p.key,
            mostRecent: mostRecent != null ? convertFnInstance(mostRecent) : undefined,
            name: `${p.pool} - ${p.algo}`,
            pool: p.pool,
            series: data
              .map(convertFnInstance)
              .filter(point => {
                if (typeof point.name === 'string') {
                  return true;
                }
                return point.name.getTime() > timeLimit;
              }),
          };
        },
    );
  }

 (uid) => this.db.object(validPath(['v2', 'user', uid, 'bookmarks'])),

 .switchMap((uid) => db.object(validPath(['v2', 'user', uid, 'pool-wallet'])))

 (uid) => {
   const path = validPath(['v2', 'user', uid, 'rig-profile', profileUuid]);
   return Observable.fromPromise(
     this.db.setObject(path, profile),
   );
 },