es6 migration

1 files changed, 556 insertions, 633 deletions

diff --git a/routes/users.js b/routes/users.js
index d9ab92d5..2222741f 100644
--- a/routes/users.js
+++ b/routes/users.js
@@ -1,20 +1,21 @@
+import app from "../app.js";
+import { auth, optionalAuth } from "../lib/passport.js";
 import { getUser } from "../lib/utils.js";
-import axios from 'axios';
-import bcrypt from 'bcrypt';
-import jwt from 'jsonwebtoken';
-import { authenticator } from 'otplib';
-import getAccount from '../lib/account.js';
-import Sequelize from '@sequelize/core';
-import bitcoin from 'bitcoinjs-lib';
+import axios from "axios";
+import bcrypt from "bcrypt";
+import jwt from "jsonwebtoken";
+import { authenticator } from "otplib";
+import getAccount from "../lib/account.js";
+import Sequelize from "@sequelize/core";
+import bitcoin from "bitcoinjs-lib";
 // import liquid from 'liquidjs-lib';
-import { fromBase58, fromPrivateKey } from 'bip32';
-import { Mutex } from 'async-mutex';
-import bip32 from 'bip32';
+import { fromBase58, fromPrivateKey } from "bip32";
+import { Mutex } from "async-mutex";
+import bip32 from "bip32";
 import whitelist from "../lib/whitelist.js";
 
 const pick = (O, ...K) => K.reduce((o, k) => ((o[k] = O[k]), o), {});
 
-/*
 const twofa = (req, res, next) => {
   let {
     user,
@@ -27,293 +28,255 @@ const twofa = (req, res, next) => {
   ) {
     return res.status(401).send("2fa required");
   } else next();
-}
+};
 
-app.get(
-  "/me",
-  auth,
-  async (req, res) => {
-    let user = req.user.get({ plain: true });
-    let payments = await req.user.getPayments({
-      where: {
-        account_id: user.account_id
+app.get("/me", auth, async (req, res) => {
+  let user = req.user.get({ plain: true });
+  let payments = await req.user.getPayments({
+    where: {
+      account_id: user.account_id
+    },
+    order: [["id", "DESC"]],
+    limit: 12,
+    include: [
+      {
+        model: db.Account,
+        as: "account"
       },
-      order: [["id", "DESC"]],
-      limit: 12,
-      include: [
-        {
-          model: db.Account,
-          as: "account"
-        },
-        {
-          model: db.Payment,
-          as: "fee_payment"
-        }
-      ]
-    });
-    user.accounts = await req.user.getAccounts();
-    user.payments = payments;
-    res.send(user);
-  })
+      {
+        model: db.Payment,
+        as: "fee_payment"
+      }
+    ]
+  });
+  user.accounts = await req.user.getAccounts();
+  user.payments = payments;
+  res.send(user);
+});
 
-app.get(
-  "/users/:username",
-  async (req, res) => {
-    const { username } = req.params;
+app.get("/users/:username", async (req, res) => {
+  const { username } = req.params;
 
-    const user = await db.User.findOne({
-      attributes: ["username"],
-      where: Sequelize.where(
-        Sequelize.fn("lower", Sequelize.col("username")),
-        username.toLowerCase()
-      )
-    });
+  const user = await db.User.findOne({
+    attributes: ["username"],
+    where: Sequelize.where(
+      Sequelize.fn("lower", Sequelize.col("username")),
+      username.toLowerCase()
+    )
+  });
 
-    if (user) res.send(user);
-    else res.status(500).send("User not found");
-  })
+  if (user) res.send(user);
+  else res.status(500).send("User not found");
+});
 
-app.post(
-  "/register",
-  async (req, res) => {
-    try {
-      const ip = req.headers["x-forwarded-for"] || req.connection.remoteAddress;
-      const user = await register(req.body.user, ip, false);
-      res.send(pick(user, ...whitelist));
-    } catch (e) {
-      res.status(500).send(e.message);
-    }
-  })
+app.post("/register", async (req, res) => {
+  try {
+    const ip = req.headers["x-forwarded-for"] || req.connection.remoteAddress;
+    const user = await register(req.body.user, ip, false);
+    res.send(pick(user, ...whitelist));
+  } catch (e) {
+    res.status(500).send(e.message);
+  }
+});
 
-app.post(
-  "/disable2fa",
-  auth,
-  twofa,
-  async (req, res) => {
-    let { user } = req;
-    user.twofa = false;
-    await user.save();
-    emit(user.username, "user", user);
-    emit(user.username, "otpsecret", user.otpsecret);
-    l("disabled 2fa", user.username);
-    res.send({});
-  })
+app.post("/disable2fa", auth, twofa, async (req, res) => {
+  let { user } = req;
+  user.twofa = false;
+  await user.save();
+  emit(user.username, "user", user);
+  emit(user.username, "otpsecret", user.otpsecret);
+  l("disabled 2fa", user.username);
+  res.send({});
+});
 
-app.get(
-  "/otpsecret",
-  auth,
-  twofa,
-  async (req, res) => {
-    let { user } = req;
-    emit(user.username, "otpsecret", user.otpsecret);
-    res.end();
-  })
+app.get("/otpsecret", auth, twofa, async (req, res) => {
+  let { user } = req;
+  emit(user.username, "otpsecret", user.otpsecret);
+  res.end();
+});
 
-app.post(
-  "/2fa",
-  auth,
-  async (req, res) => {
-    let { user } = req;
-    try {
-      const isValid = authenticator.check(req.body.token, req.user.otpsecret);
-      if (isValid) {
-        user.twofa = true;
-        user.save();
-        emit(user.username, "user", req.user);
-      } else {
-        return res.status(500).send("Invalid token");
-      }
-    } catch (e) {
-      err("error setting up 2fa", e);
+app.post("/2fa", auth, async (req, res) => {
+  let { user } = req;
+  try {
+    const isValid = authenticator.check(req.body.token, req.user.otpsecret);
+    if (isValid) {
+      user.twofa = true;
+      user.save();
+      emit(user.username, "user", req.user);
+    } else {
+      return res.status(500).send("Invalid token");
     }
+  } catch (e) {
+    err("error setting up 2fa", e);
+  }
 
-    l("enabled 2fa", user.username);
-    res.send({});
-  })
-
-app.get(
-  "/exists",
-  async (req, res) => {
-    let exists = await db.User.findOne({
-      where: { username: req.query.username }
-    });
+  l("enabled 2fa", user.username);
+  res.send({});
+});
 
-    res.send(!!exists);
-  })
+app.get("/exists", async (req, res) => {
+  let exists = await db.User.findOne({
+    where: { username: req.query.username }
+  });
 
-app.post(
-  "/user",
-  auth,
-  async (req, res) => {
-    try {
-      let { user } = req;
-      let {
-        address,
-        confirm,
-        currencies,
-        currency,
-        email,
-        fiat,
-        password,
-        pin,
-        seed,
-        tokens,
-        twofa,
-        unit,
-        username
-      } = req.body;
+  res.send(!!exists);
+});
 
-      let exists = await db.User.findOne({
-        where: { username }
-      });
+app.post("/user", auth, async (req, res) => {
+  try {
+    let { user } = req;
+    let {
+      address,
+      confirm,
+      currencies,
+      currency,
+      email,
+      fiat,
+      password,
+      pin,
+      seed,
+      tokens,
+      twofa,
+      unit,
+      username
+    } = req.body;
 
-      let token;
-      if (user.username !== username && exists) {
-        err("username taken", username, user.username, exists.username);
-        return res.status(500).send("Username taken");
-      } else {
-        sockets[username] = sockets[user.username];
-        if (user.username !== username)
-          l("changing username", user.username, username);
-        user.username = username;
+    let exists = await db.User.findOne({
+      where: { username }
+    });
 
-        token = jwt.sign({ username }, config.jwt);
-        res.cookie("token", token, {
-          expires: new Date(Date.now() + 432000000)
-        });
-      }
+    let token;
+    if (user.username !== username && exists) {
+      err("username taken", username, user.username, exists.username);
+      return res.status(500).send("Username taken");
+    } else {
+      sockets[username] = sockets[user.username];
+      if (user.username !== username)
+        l("changing username", user.username, username);
+      user.username = username;
 
-      if (unit) user.unit = unit;
-      user.currency = currency;
-      user.currencies = currencies;
+      token = jwt.sign({ username }, config.jwt);
+      res.cookie("token", token, {
+        expires: new Date(Date.now() + 432000000)
+      });
+    }
 
-      user.tokens = tokens;
-      user.twofa = twofa;
-      user.pin = pin;
-      user.seed = seed;
-      user.fiat = fiat;
-      user.email = email;
-      user.address = address;
+    if (unit) user.unit = unit;
+    user.currency = currency;
+    user.currencies = currencies;
 
-      if (password && password === confirm) {
-        user.password = await bcrypt.hash(password, 1);
-      }
+    user.tokens = tokens;
+    user.twofa = twofa;
+    user.pin = pin;
+    user.seed = seed;
+    user.fiat = fiat;
+    user.email = email;
+    user.address = address;
 
-      await user.save();
-      emit(user.username, "user", user);
-      res.send({ user, token });
-    } catch (e) {
-      err("error updating user", e.message);
+    if (password && password === confirm) {
+      user.password = await bcrypt.hash(password, 1);
     }
-  })
 
-app.post(
-  "/keys",
-  auth,
-  async (req, res) => {
-    const { key: hex } = req.body;
-    const key = await db.Key.create({
-      user_id: req.user.id,
-      hex
-    });
-    emit(req.user.username, "key", key);
-    res.send(key);
-  })
+    await user.save();
+    emit(user.username, "user", user);
+    res.send({ user, token });
+  } catch (e) {
+    err("error updating user", e.message);
+  }
+});
 
-app.post(
-  "/keys/delete",
-  auth,
-  async (req, res) => {
-    const { hex } = req.body;
-    (
-      await db.Key.findOne({
-        where: {
-          user_id: req.user.id,
-          hex
-        }
-      })
-    ).destroy();
-  })
+app.post("/keys", auth, async (req, res) => {
+  const { key: hex } = req.body;
+  const key = await db.Key.create({
+    user_id: req.user.id,
+    hex
+  });
+  emit(req.user.username, "key", key);
+  res.send(key);
+});
 
-app.post(
-  "/updateSeeds",
-  auth,
-  async (req, res) => {
-    let { user } = req;
-    let { seeds } = req.body;
-    let keys = Object.keys(seeds);
+app.post("/keys/delete", auth, async (req, res) => {
+  const { hex } = req.body;
+  (
+    await db.Key.findOne({
+      where: {
+        user_id: req.user.id,
+        hex
+      }
+    })
+  ).destroy();
+});
 
-    for (let i = 0; i < keys.length; i++) {
-      let id = keys[i];
-      let seed = seeds[id];
-      await db.Account.update(
-        { seed },
-        {
-          where: { id, user_id: user.id }
-        }
-      );
+app.post("/updateSeeds", auth, async (req, res) => {
+  let { user } = req;
+  let { seeds } = req.body;
+  let keys = Object.keys(seeds);
 
-      const account = await db.Account.findOne({
-        where: { id }
-      });
+  for (let i = 0; i < keys.length; i++) {
+    let id = keys[i];
+    let seed = seeds[id];
+    await db.Account.update(
+      { seed },
+      {
+        where: { id, user_id: user.id }
+      }
+    );
 
-      emit(user.username, "account", account);
-    }
+    const account = await db.Account.findOne({
+      where: { id }
+    });
 
-    res.end();
-  })
+    emit(user.username, "account", account);
+  }
 
-app.post(
-  "/accounts/delete",
-  auth,
-  async (req, res) => {
-    const { id } = req.body;
-    const account = await db.Account.findOne({ where: { id } });
-    if (account) await account.destroy();
-    res.end();
-  })
+  res.end();
+});
 
-app.post(
-  "/accounts",
-  auth,
-  async (req, res) => {
-    const {
-      name,
-      seed,
-      pubkey,
-      ticker,
-      precision,
-      path,
-      privkey,
-      network
-    } = req.body;
-    const { user } = req;
+app.post("/accounts/delete", auth, async (req, res) => {
+  const { id } = req.body;
+  const account = await db.Account.findOne({ where: { id } });
+  if (account) await account.destroy();
+  res.end();
+});
 
-    let account = await db.Account.create({
-      user_id: user.id,
-      asset: config.liquid.btcasset,
-      balance: 0,
-      pending: 0,
-      name,
-      ticker,
-      precision,
-      pubkey,
-      privkey,
-      seed,
-      path,
-      network
-    });
+app.post("/accounts", auth, async (req, res) => {
+  const {
+    name,
+    seed,
+    pubkey,
+    ticker,
+    precision,
+    path,
+    privkey,
+    network
+  } = req.body;
+  const { user } = req;
 
-    emit(user.username, "account", account);
+  let account = await db.Account.create({
+    user_id: user.id,
+    asset: config.liquid.btcasset,
+    balance: 0,
+    pending: 0,
+    name,
+    ticker,
+    precision,
+    pubkey,
+    privkey,
+    seed,
+    path,
+    network
+  });
 
-    if (pubkey) user.index++;
-    user.account_id = account.id;
-    await user.save();
-    user.account = account;
-    emit(user.username, "user", user);
+  emit(user.username, "account", account);
+
+  if (pubkey) user.index++;
+  user.account_id = account.id;
+  await user.save();
+  user.account = account;
+  emit(user.username, "user", user);
 
-    res.send(account);
-  })
+  res.send(account);
+});
 
 let login = async (req, res) => {
   try {
@@ -372,453 +335,413 @@ let login = async (req, res) => {
     err("login error", e.message, req.connection.remoteAddress);
     res.status(401).end();
   }
+};
 
 app.post("/login", login);
 app.post("/taboggan", login);
 app.post("/doggin", login);
 
-app.post(
-  "/logout",
-  optionalAuth,
-  async (req, res) => {
-    let { subscription } = req.body;
-    if (!subscription) return res.end();
+app.post("/logout", optionalAuth, async (req, res) => {
+  let { subscription } = req.body;
+  if (!subscription) return res.end();
 
-    const { username } = req.user;
+  const { username } = req.user;
 
-    if (username) {
-      l("logging out", username);
-      let i = req.user.subscriptions.findIndex(
-        s => JSON.stringify(s) === subscription
-      );
-      if (i > -1) {
-        req.user.subscriptions.splice(i, 1);
-      }
-      await req.user.save();
-      Object.keys(logins).map(
-        k => logins[k]["username"] === username && delete logins[k]
-      );
+  if (username) {
+    l("logging out", username);
+    let i = req.user.subscriptions.findIndex(
+      s => JSON.stringify(s) === subscription
+    );
+    if (i > -1) {
+      req.user.subscriptions.splice(i, 1);
     }
+    await req.user.save();
+    Object.keys(logins).map(
+      k => logins[k]["username"] === username && delete logins[k]
+    );
+  }
 
-    res.end();
-  })
+  res.end();
+});
 
-app.get(
-  "/address",
-  async (req, res) => {
-    let { network, type } = req.query;
-    let address, confidentialAddress;
+app.get("/address", async (req, res) => {
+  let { network, type } = req.query;
+  let address, confidentialAddress;
 
-    let paymentType = {
-      bech32: "p2wpkh",
-      "p2sh-segwit": "p2sh",
-      legacy: "p2pkh"
-    }[type];
-    if (!paymentType) paymentType = "p2wpkh";
+  let paymentType = {
+    bech32: "p2wpkh",
+    "p2sh-segwit": "p2sh",
+    legacy: "p2pkh"
+  }[type];
+  if (!paymentType) paymentType = "p2wpkh";
 
-    let hd, i, p, n;
-    const mutex = new Mutex();
-    const release = await mutex.acquire();
-    try {
-      if (network === "bitcoin") {
-        if (!config.bitcoin)
-          return res.status(500).send("Bitcoin not configured");
+  let hd, i, p, n;
+  const mutex = new Mutex();
+  const release = await mutex.acquire();
+  try {
+    if (network === "bitcoin") {
+      if (!config.bitcoin)
+        return res.status(500).send("Bitcoin not configured");
 
-        address = await bc.getNewAddress("", type);
-        app.set("bcAddressIndex", i + 1);
-        return res.send({ address });
+      address = await bc.getNewAddress("", type);
+      bcAddressIndex = i + 1;
+      return res.send({ address });
 
-        p = bitcoin.payments;
-        n = prod ? bitcoin.networks["bitcoin"] : bitcoin.networks["regtest"];
+      p = bitcoin.payments;
+      n = prod ? bitcoin.networks["bitcoin"] : bitcoin.networks["regtest"];
 
-        i = parseInt(app.get("bcAddressIndex"));
-        hd = fromBase58(config.bitcoin.masterkey, n).derivePath(
-          `m/0'/0'/${i}'`
-        );
+      i = parseInt(app.get("bcAddressIndex"));
+      hd = fromBase58(config.bitcoin.masterkey, n).derivePath(`m/0'/0'/${i}'`);
 
-        // async request to node to bump its internal index but don't use result
-        bc.getNewAddress().catch(console.error);
-        res.send({ address, confidentialAddress });
+      // async request to node to bump its internal index but don't use result
+      bc.getNewAddress().catch(console.error);
+      res.send({ address, confidentialAddress });
 
-        app.set("bcAddressIndex", i + 1);
-      } else if (network === "liquid") {
-        p = liquid.payments;
-        n =
-          liquid.networks[
-            config.liquid.network === "mainnet"
-              ? "liquid"
-              : config.liquid.network
-          ];
-        paymentType = "p2sh";
+      bcAddressIndex = i + 1;
+    } else if (network === "liquid") {
+      p = liquid.payments;
+      n =
+        liquid.networks[
+          config.liquid.network === "mainnet" ? "liquid" : config.liquid.network
+        ];
+      paymentType = "p2sh";
 
-        // async request to node to bump its internal index but don't use result
-        lq.getNewAddress().catch(e =>
-          warn("Problem bumping liquid address index", e.message)
-        );
+      // async request to node to bump its internal index but don't use result
+      lq.getNewAddress().catch(e =>
+        warn("Problem bumping liquid address index", e.message)
+      );
 
-        i = parseInt(app.get("lqAddressIndex"));
+      i = parseInt(app.get("lqAddressIndex"));
 
-        if (!i) {
-          const { hdkeypath } = await lq.getAddressInfo(
-            await lq.getNewAddress()
-          );
-          const parts = hdkeypath.split("/");
-          i = parseInt(parts[parts.length - 1].slice(0, -1));
-        }
+      if (!i) {
+        const { hdkeypath } = await lq.getAddressInfo(await lq.getNewAddress());
+        const parts = hdkeypath.split("/");
+        i = parseInt(parts[parts.length - 1].slice(0, -1));
+      }
 
-        l("liquid address index", i);
-        if (!i) throw new Error("Problem generating address");
+      l("liquid address index", i);
+      if (!i) throw new Error("Problem generating address");
 
-        hd = fromBase58(config.liquid.masterkey, n).derivePath(`m/0'/0'/${i}'`);
-        app.set("lqAddressIndex", i + 1);
-      } else {
-        throw new Error("Unsupported network");
-      }
-    } finally {
-      release();
+      hd = fromBase58(config.liquid.masterkey, n).derivePath(`m/0'/0'/${i}'`);
+      lqAddressIndex = i + 1;
+    } else {
+      throw new Error("Unsupported network");
     }
+  } finally {
+    release();
+  }
 
-    if (paymentType !== "p2sh") {
-      ({ address } = p[paymentType]({
+  if (paymentType !== "p2sh") {
+    ({ address } = p[paymentType]({
+      pubkey: hd.publicKey,
+      network: n
+    }));
+  } else {
+    if (network === "liquid") {
+      const p2wpkh = p.p2wpkh({
         pubkey: hd.publicKey,
         network: n
-      }));
-    } else {
-      if (network === "liquid") {
-        const p2wpkh = p.p2wpkh({
-          pubkey: hd.publicKey,
-          network: n
-        });
+      });
 
-        const blindkey = fromPrivateKey(
-          Buffer.from(config.liquid.blindkey, "hex"),
-          hd.chainCode,
-          n
-        );
+      const blindkey = fromPrivateKey(
+        Buffer.from(config.liquid.blindkey, "hex"),
+        hd.chainCode,
+        n
+      );
 
-        ({ address, confidentialAddress } = p[paymentType]({
-          redeem: p2wpkh,
-          network: n,
-          blindkey: blindkey.publicKey
-        }));
+      ({ address, confidentialAddress } = p[paymentType]({
+        redeem: p2wpkh,
+        network: n,
+        blindkey: blindkey.publicKey
+      }));
 
-        lq.importBlindingKey(
-          confidentialAddress,
-          blindkey.privateKey.toString("hex")
-        );
-      } else {
-        ({ address } = p[paymentType]({
-          redeem: p.p2wpkh({
-            pubkey: hd.publicKey,
-            network: n
-          }),
+      lq.importBlindingKey(
+        confidentialAddress,
+        blindkey.privateKey.toString("hex")
+      );
+    } else {
+      ({ address } = p[paymentType]({
+        redeem: p.p2wpkh({
+          pubkey: hd.publicKey,
           network: n
-        }));
-      }
+        }),
+        network: n
+      }));
     }
+  }
 
-    res.send({ address, confidentialAddress });
-  })
-
-app.post(
-  "/account",
-  auth,
-  async (req, res) => {
-    const { user } = req;
-    const {
-      id,
-      name,
-      ticker,
-      precision,
-      domain,
-      seed,
-      pubkey,
-      privkey,
-      path,
-      hide,
-      index
-    } = req.body;
+  res.send({ address, confidentialAddress });
+});
 
-    try {
-      await db.transaction(async transaction => {
-        let account = await db.Account.findOne({
-          where: { id, user_id: user.id },
-          lock: transaction.LOCK.UPDATE,
-          transaction
-        });
+app.post("/account", auth, async (req, res) => {
+  const { user } = req;
+  const {
+    id,
+    name,
+    ticker,
+    precision,
+    domain,
+    seed,
+    pubkey,
+    privkey,
+    path,
+    hide,
+    index
+  } = req.body;
 
-        let params = {
-          name,
-          ticker,
-          precision,
-          domain,
-          seed,
-          pubkey,
-          path,
-          hide,
-          index,
-          privkey
-        };
+  try {
+    await db.transaction(async transaction => {
+      let account = await db.Account.findOne({
+        where: { id, user_id: user.id },
+        lock: transaction.LOCK.UPDATE,
+        transaction
+      });
 
-        if (!account || (account.pubkey && !pubkey)) delete params.pubkey;
+      let params = {
+        name,
+        ticker,
+        precision,
+        domain,
+        seed,
+        pubkey,
+        path,
+        hide,
+        index,
+        privkey
+      };
 
-        await db.Account.update(params, {
-          where: { id, user_id: user.id },
-          transaction
-        });
+      if (!account || (account.pubkey && !pubkey)) delete params.pubkey;
 
-        await account.reload({ transaction });
-        emit(user.username, "account", account);
-        res.end();
+      await db.Account.update(params, {
+        where: { id, user_id: user.id },
+        transaction
       });
-    } catch (e) {
-      err("problem updating account", e.message);
-      return res.status(500).send("There was a problem updating the account");
-    }
-  })
 
-app.post(
-  "/shiftAccount",
-  auth,
-  async (req, res) => {
-    let { user } = req;
-    let { id } = req.body;
+      await account.reload({ transaction });
+      emit(user.username, "account", account);
+      res.end();
+    });
+  } catch (e) {
+    err("problem updating account", e.message);
+    return res.status(500).send("There was a problem updating the account");
+  }
+});
 
-    try {
-      const account = await db.Account.findOne({
-        where: { id }
-      });
+app.post("/shiftAccount", auth, async (req, res) => {
+  let { user } = req;
+  let { id } = req.body;
 
-      if (account.user_id !== user.id)
-        return res.status(500).send("Failed to open wallet");
+  try {
+    const account = await db.Account.findOne({
+      where: { id }
+    });
 
-      user.account_id = account.id;
-      await user.save();
-      let payments = await db.Payment.findAll({
-        where: {
-          account_id: id
-        },
-        order: [["id", "DESC"]],
-        limit: 12,
-        include: {
-          model: db.Account,
-          as: "account"
-        }
-      });
+    if (account.user_id !== user.id)
+      return res.status(500).send("Failed to open wallet");
 
-      user = user.get({ plain: true });
-      user.payments = payments;
-      user.account = account.get({ plain: true });
+    user.account_id = account.id;
+    await user.save();
+    let payments = await db.Payment.findAll({
+      where: {
+        account_id: id
+      },
+      order: [["id", "DESC"]],
+      limit: 12,
+      include: {
+        model: db.Account,
+        as: "account"
+      }
+    });
 
-      emit(user.username, "account", user.account);
-      emit(user.username, "user", user);
+    user = user.get({ plain: true });
+    user.payments = payments;
+    user.account = account.get({ plain: true });
 
-      res.send(user);
-    } catch (e) {
-      err("problem switching account", e.message);
-      return res.status(500).send("There was a problem switching accounts");
-    }
-  })
+    emit(user.username, "account", user.account);
+    emit(user.username, "user", user);
+
+    res.send(user);
+  } catch (e) {
+    err("problem switching account", e.message);
+    return res.status(500).send("There was a problem switching accounts");
+  }
+});
 
 app.get("/vapidPublicKey", function(req, res) {
   res.send(config.vapid.publicKey);
 });
 
-app.post(
-  "/subscribe",
-  auth,
-  async function(req, res) {
-    let { subscriptions } = req.user;
-    let { subscription } = req.body;
-    if (!subscriptions) subscriptions = [];
-    if (
-      !subscriptions.find(
-        s => JSON.stringify(s) === JSON.stringify(subscription)
-      )
-    )
-      subscriptions.push(subscription);
-    req.user.subscriptions = subscriptions;
-    l("subscribing", req.user.username);
-    await req.user.save();
-    res.sendStatus(201);
-  })
+app.post("/subscribe", auth, async function(req, res) {
+  let { subscriptions } = req.user;
+  let { subscription } = req.body;
+  if (!subscriptions) subscriptions = [];
+  if (
+    !subscriptions.find(s => JSON.stringify(s) === JSON.stringify(subscription))
+  )
+    subscriptions.push(subscription);
+  req.user.subscriptions = subscriptions;
+  l("subscribing", req.user.username);
+  await req.user.save();
+  res.sendStatus(201);
+});
 
 let redeeming = {};
-app.post(
-  "/redeem",
-  optionalAuth,
-  async function(req, res) {
-    const { redeemcode } = req.body;
-    try {
-      await db.transaction(async transaction => {
-        if (redeeming[redeemcode]) fail("redemption in progress");
-        redeeming[redeemcode] = true;
-        if (!redeemcode) fail("no code provided");
+app.post("/redeem", optionalAuth, async function(req, res) {
+  const { redeemcode } = req.body;
+  try {
+    await db.transaction(async transaction => {
+      if (redeeming[redeemcode]) fail("redemption in progress");
+      redeeming[redeemcode] = true;
+      if (!redeemcode) fail("no code provided");
 
-        let { user } = req;
+      let { user } = req;
 
-        const source = await db.Payment.findOne({
-          where: {
-            redeemcode: req.body.redeemcode
-          },
-          include: {
-            model: db.Account,
-            as: "account"
-          },
-          lock: transaction.LOCK.UPDATE,
-          transaction
-        });
+      const source = await db.Payment.findOne({
+        where: {
+          redeemcode: req.body.redeemcode
+        },
+        include: {
+          model: db.Account,
+          as: "account"
+        },
+        lock: transaction.LOCK.UPDATE,
+        transaction
+      });
 
-        l("redeeming", redeemcode);
+      l("redeeming", redeemcode);
 
-        if (!source) fail("Invalid code");
-        if (source.redeemed) fail("Voucher has already been redeemed");
-        let { amount } = source;
-        amount = -amount;
+      if (!source) fail("Invalid code");
+      if (source.redeemed) fail("Voucher has already been redeemed");
+      let { amount } = source;
+      amount = -amount;
 
-        if (!user) {
-          const ip =
-            req.headers["x-forwarded-for"] || req.connection.remoteAddress;
+      if (!user) {
+        const ip =
+          req.headers["x-forwarded-for"] || req.connection.remoteAddress;
 
-          user = await register(
-            {
-              username: redeemcode.substr(0, 8),
-              password: ""
-            },
-            ip,
-            false
-          );
+        user = await register(
+          {
+            username: redeemcode.substr(0, 8),
+            password: ""
+          },
+          ip,
+          false
+        );
 
-          let payload = { username: user.username };
-          let token = jwt.sign(payload, config.jwt);
-          res.cookie("token", token, {
-            expires: new Date(Date.now() + 432000000)
-          });
+        let payload = { username: user.username };
+        let token = jwt.sign(payload, config.jwt);
+        res.cookie("token", token, {
+          expires: new Date(Date.now() + 432000000)
+        });
 
-          delete redeeming[redeemcode];
-          return res.send({ user });
-        }
+        delete redeeming[redeemcode];
+        return res.send({ user });
+      }
 
-        let account = await getAccount(source.account.asset, user, transaction);
-        let { hash, memo, confirmed, fee, network } = source;
+      let account = await getAccount(source.account.asset, user, transaction);
+      let { hash, memo, confirmed, fee, network } = source;
 
-        source.redeemed = true;
-        await source.save({ transaction });
+      source.redeemed = true;
+      await source.save({ transaction });
 
-        let payment = await db.Payment.create(
-          {
-            amount,
-            account_id: account.id,
-            user_id: user.id,
-            hash: "Voucher " + redeemcode,
-            memo,
-            rate: rates[user.currency],
-            currency: user.currency,
-            confirmed,
-            network,
-            received: true,
-            fee
-          },
-          { transaction }
-        );
+      let payment = await db.Payment.create(
+        {
+          amount,
+          account_id: account.id,
+          user_id: user.id,
+          hash: "Voucher " + redeemcode,
+          memo,
+          rate: store.rates[user.currency],
+          currency: user.currency,
+          confirmed,
+          network,
+          received: true,
+          fee
+        },
+        { transaction }
+      );
 
-        await account.increment({ balance: amount }, { transaction });
-        await account.reload({ transaction });
+      await account.increment({ balance: amount }, { transaction });
+      await account.reload({ transaction });
 
-        payment = payment.get({ plain: true });
-        payment.account = account.get({ plain: true });
-        emit(user.username, "payment", payment);
-        emit(user.username, "account", account);
+      payment = payment.get({ plain: true });
+      payment.account = account.get({ plain: true });
+      emit(user.username, "payment", payment);
+      emit(user.username, "account", account);
 
-        res.send({ payment });
-      });
-    } catch (e) {
-      delete redeeming[redeemcode];
-      err("problem redeeming", e.message);
-      return res.status(500).send("There was a problem redeeming the voucher");
-    }
-  })
+      res.send({ payment });
+    });
+  } catch (e) {
+    delete redeeming[redeemcode];
+    err("problem redeeming", e.message);
+    return res.status(500).send("There was a problem redeeming the voucher");
+  }
+});
 
-app.post(
-  "/checkRedeemCode",
-  auth,
-  async function(req, res) {
-    const { redeemcode } = req.body;
+app.post("/checkRedeemCode", auth, async function(req, res) {
+  const { redeemcode } = req.body;
 
-    const payment = await db.Payment.findOne({ where: { redeemcode } });
-    res.send(payment);
-  })
+  const payment = await db.Payment.findOne({ where: { redeemcode } });
+  res.send(payment);
+});
 
-app.post(
-  "/password",
-  auth,
-  async function(req, res) {
-    const { user } = req;
-    const { password } = req.body;
+app.post("/password", auth, async function(req, res) {
+  const { user } = req;
+  const { password } = req.body;
 
-    if (!user.password) return res.send(true);
-    res.send(await bcrypt.compare(password, user.password));
-  })
+  if (!user.password) return res.send(true);
+  res.send(await bcrypt.compare(password, user.password));
+});
 
-app.get(
-  "/isInternal",
-  auth,
-  async function(req, res) {
-    let { user } = req;
-    let { address } = req.query;
-    if (!address) throw new Error("Address not provided");
+app.get("/isInternal", auth, async function(req, res) {
+  let { user } = req;
+  let { address } = req.query;
+  if (!address) throw new Error("Address not provided");
 
-    let invoice = await db.Invoice.findOne({
-      where: { address },
-      include: {
-        attributes: ["username"],
-        model: db.User,
-        as: "user"
-      }
-    });
+  let invoice = await db.Invoice.findOne({
+    where: { address },
+    include: {
+      attributes: ["username"],
+      model: db.User,
+      as: "user"
+    }
+  });
 
-    if (invoice) {
-      let info;
-      try {
-        info = await bc.getAddressInfo(address);
-      } catch (e) {
-        info = await lq.getAddressInfo(address);
-      }
-      if (info.ismine) {
-        emit(user.username, "to", invoice.user);
-        return res.send(true);
-      }
+  if (invoice) {
+    let info;
+    try {
+      info = await bc.getAddressInfo(address);
+    } catch (e) {
+      info = await lq.getAddressInfo(address);
+    }
+    if (info.ismine) {
+      emit(user.username, "to", invoice.user);
+      return res.send(true);
     }
+  }
 
-    res.send(false);
-  })
+  res.send(false);
+});
 
-app.get(
-  "/invoices",
-  auth,
-  async function(req, res) {
-    let invoices = await db.Invoice.findAll({
-      where: { user_id: req.user.id }
-    });
-    res.send(invoices);
+app.get("/invoices", auth, async function(req, res) {
+  let invoices = await db.Invoice.findAll({
+    where: { user_id: req.user.id }
   });
+  res.send(invoices);
+});
 
-app.post(
-  "/signMessage",
-  auth,
-  async function(req, res) {
-    let { address, message } = req.body;
+app.post("/signMessage", auth, async function(req, res) {
+  let { address, message } = req.body;
 
-    let invoices = await db.Invoice.findAll({
-      where: { user_id: req.user.id }
-    });
+  let invoices = await db.Invoice.findAll({
+    where: { user_id: req.user.id }
+  });
 
-    if (invoices.find(i => i.address === address)) {
-      if (config.bitcoin.walletpass)
-        await bc.walletPassphrase(config.bitcoin.walletpass, 300);
-      return res.send(await bc.signMessage(address, message));
-    }
+  if (invoices.find(i => i.address === address)) {
+    if (config.bitcoin.walletpass)
+      await bc.walletPassphrase(config.bitcoin.walletpass, 300);
+    return res.send(await bc.signMessage(address, message));
+  }
 
-    res.status(500).send("Address not found for user");
-  })
-  */
+  res.status(500).send("Address not found for user");
+});