tech debt jubilee

1 files changed, 0 insertions, 536 deletions

diff --git a/routes/assets.js b/routes/assets.js
deleted file mode 100644
index ed0d3036..00000000
--- a/routes/assets.js
+++ /dev/null
@@ -1,536 +0,0 @@
-import { emit } from "$lib/sockets";
-import store from "$lib/store";
-import db from "$db";
-import config from "$config";
-import app from "$app";
-import { auth } from "$lib/passport";
-import axios from "axios";
-import crypto from "crypto";
-import fs from "fs";
-import { err, l } from "$lib/logging";
-import lq from "$lib/liquid";
-import { SATS } from "$lib/utils";
-
-let fetchAssets;
-(fetchAssets = async () => {
-  try {
-    const { data } = await axios.get("https://assets.blockstream.info/");
-
-    store.assets = data;
-  } catch (e) {
-    var liquid_assets = JSON.parse(fs.readFileSync("/app/assets.json"));
-    if (liquid_assets) {
-      store.assets = liquid_assets;
-      console.debug("using static assets..." + e.message);
-    } else {
-      err("error fetching assets", e.message);
-      res.code(500).send("error fetching assets");
-    }
-  }
-
-  setTimeout(fetchAssets, 7200000);
-})();
-
-app.get("/assets", async (req, res) => {
-  if (store.assets) {
-    const accounts = await db.Account.findAll({
-      // group: ["asset"]
-    });
-    Object.keys(store.assets).map(a => {
-      store.assets[a].registered = true;
-      if (!store.assets[a].asset)
-        store.assets[a].asset = store.assets[a].asset_id;
-      if (
-        (store.assets[a].ticker === "BTC" &&
-          store.assets[a].asset !== config.liquid.btcasset) ||
-        (store.assets[a].ticker === "EUR" &&
-          store.assets[a].asset !== config.liquid.eurasset) ||
-        (store.assets[a].ticker === "CAD" &&
-          store.assets[a].asset !== config.liquid.cadasset) ||
-        (store.assets[a].ticker === "USDt" &&
-          store.assets[a].asset !== config.liquid.usdtasset)
-      )
-        delete store.assets[a];
-    });
-    accounts.map(({ asset, name, domain, ticker, precision }) => {
-      if (!store.assets[asset])
-        store.assets[asset] = {
-          asset,
-          name,
-          domain,
-          ticker,
-          precision
-        };
-    });
-
-    res.send(store.assets);
-  } else {
-    console.log("error getting blockstream assets");
-    res.code(500).send("Problem fetching blockstream asset registry data");
-  }
-});
-
-app.post("/assets", auth, async (req, res) => {
-  try {
-    const sha256 = crypto.createHash("sha256");
-    const { id: user_id } = req.user;
-    const blind = false;
-
-    if (!user_id) throw new Error("unauthorized");
-
-    const {
-      address,
-      domain,
-      name,
-      asset_amount,
-      filename,
-      token_amount,
-      precision,
-      pubkey,
-      ticker
-    } = req.body;
-
-    const asset_address = address
-      ? address
-      : await lq.getNewAddress("", "legacy");
-
-    const token_address =
-      token_amount && (await lq.getNewAddress("", "legacy"));
-
-    const issuer_pubkey = pubkey
-      ? pubkey
-      : (await lq.getAddressInfo(asset_address)).pubkey;
-    const version = 0;
-
-    let contract = {
-      entity: { domain },
-      issuer_pubkey,
-      name,
-      precision,
-      version
-    };
-
-    if (filename) contract.file = filename;
-    if (ticker) contract.ticker = ticker;
-
-    contract = Object.keys(contract)
-      .sort()
-      .reduce((r, k) => ((r[k] = contract[k]), r), {});
-
-    l(
-      "attempting issuance",
-      req.user.username,
-      JSON.stringify(contract),
-      "address",
-      address,
-      "pubkey",
-      pubkey
-    );
-
-    sha256.update(JSON.stringify(contract));
-    const hash = sha256.digest("hex");
-    const contract_hash = hash
-      .match(/[a-f0-9]{2}/g)
-      .reverse()
-      .join("");
-    const rawtx = await lq.createRawTransaction([], [{ data: "00" }]);
-    const funded = await lq.fundRawTransaction(rawtx, { feeRate: 0.000002 });
-    const params = {
-      asset_amount,
-      asset_address,
-      blind,
-      contract_hash
-    };
-
-    params.asset_amount = asset_amount / (SATS / 10 ** precision);
-
-    if (token_amount) {
-      params.token_amount = token_amount;
-      params.token_address = token_address;
-      params.token_amount = parseInt(params.token_amount);
-    }
-
-    let ria;
-    try {
-      ria = await lq.rawIssueAsset(funded.hex, [params]);
-    } catch (e) {
-      l(asset_amount, token_amount, params);
-      throw new Error(e.message);
-    }
-
-    const { asset, hex, token } = ria[0];
-    const brt = await lq.blindRawTransaction(hex, true, [], false);
-    const srt = await lq.signRawTransactionWithWallet(brt);
-    const allowed = (await lq.testMempoolAccept([srt.hex]))[0].allowed;
-    if (!allowed) throw new Error("issuance rejected by mempool", srt.hex);
-    const txid = await lq.sendRawTransaction(srt.hex);
-
-    await db.transaction(async transaction => {
-      let account = await db.Account.findOne({
-        where: {
-          user_id,
-          asset: config.liquid.btcasset,
-          pubkey: null
-        },
-        include: {
-          model: db.User,
-          as: "user"
-        },
-        order: [["balance", "DESC"]],
-        lock: transaction.LOCK.UPDATE,
-        transaction
-      });
-
-      let { user } = account;
-
-      if (Math.round(funded.fee * SATS) > account.balance) {
-        err(
-          "amount exceeds balance",
-          asset_amount,
-          funded.fee,
-          account.balance
-        );
-        throw new Error(`Insufficient funds to pay fee of ${funded.fee} BTC`);
-      }
-
-      await account.decrement(
-        { balance: Math.round(funded.fee * SATS) },
-        { transaction }
-      );
-      await account.reload({ transaction });
-      emit(user.username, "account", account);
-
-      let invoice;
-      let recipient = user;
-      if (address) {
-        invoice = await db.Invoice.findOne({
-          where: { address },
-          include: {
-            model: db.User,
-            as: "user"
-          }
-        });
-        recipient = invoice.user;
-      }
-
-      if (!invoice) {
-        invoice = await db.Invoice.create(
-          {
-            account_id: account.id,
-            user_id,
-            amount: Math.round(params.asset_amount * SATS),
-            address: asset_address,
-            currency: user.currency,
-            rate: store.rates[user.currency],
-            network: "liquid"
-          },
-          { transaction }
-        );
-      }
-
-      account = await db.Account.create(
-        {
-          asset,
-          contract,
-          domain,
-          user_id: invoice.user_id,
-          ticker,
-          precision,
-          name,
-          balance: 0,
-          network: "liquid",
-          pending: Math.round(params.asset_amount * SATS)
-        },
-        { transaction }
-      );
-
-      emit(recipient.username, "account", account);
-      l(
-        "issued asset",
-        user.username,
-        params.asset_amount,
-        ticker,
-        name,
-        account.id
-      );
-
-      const asset_payment = await db.Payment.create(
-        {
-          account_id: account.id,
-          user_id: invoice.user_id,
-          invoice_id: invoice.id,
-          hash: txid,
-          amount: Math.round(params.asset_amount * SATS),
-          received: true,
-          confirmed: false,
-          address: asset_address,
-          network: "liquid"
-        },
-        { transaction }
-      );
-      emit(recipient.username, "payment", asset_payment);
-
-      if (invoice.user_id !== user.id) {
-        const asset_send = await db.Payment.create(
-          {
-            account_id: account.id,
-            user_id,
-            hash: txid,
-            amount: -Math.round(params.asset_amount * SATS),
-            received: false,
-            confirmed: false,
-            address,
-            network: "liquid"
-          },
-          { transaction }
-        );
-        emit(recipient.username, "payment", asset_send);
-      }
-
-      store.issuances[txid] = {
-        user_id,
-        asset,
-        asset_amount: params.asset_amount,
-        asset_payment_id: asset_payment.id
-      };
-
-      if (token_amount) {
-        invoice = null;
-        recipient = user;
-
-        if (address) {
-          invoice = await db.Invoice.findOne({
-            where: { address },
-            include: {
-              model: db.User,
-              as: "user"
-            }
-          });
-          recipient = invoice.user;
-        }
-
-        if (!invoice) {
-          invoice = await db.Invoice.create(
-            {
-              account_id: account.id,
-              user_id,
-              amount: Math.round(params.token_amount * SATS),
-              address: token_address,
-              currency: user.currency,
-              rate: store.rates[user.currency],
-              network: "liquid"
-            },
-            { transaction }
-          );
-        }
-
-        account = await db.Account.create(
-          {
-            asset: token,
-            user_id: invoice.user_id,
-            domain,
-            ticker: `${ticker}REISSUANCETOKEN`,
-            precision: 8,
-            name: `${name} Reissuance Token`,
-            balance: 0,
-            pending: address ? 0 : Math.round(token_amount * SATS)
-          },
-          { transaction }
-        );
-        emit(recipient.username, "account", account);
-
-        const token_payment = await db.Payment.create(
-          {
-            account_id: account.id,
-            invoice_id: invoice.id,
-            user_id,
-            hash: txid,
-            amount: Math.round(token_amount * SATS),
-            received: true,
-            confirmed: false,
-            address: token_address,
-            network: "liquid"
-          },
-          { transaction }
-        );
-        emit(recipient.username, "payment", token_payment);
-
-        if (invoice.user_id !== user.id) {
-          const token_send = await db.Payment.create(
-            {
-              account_id: account.id,
-              invoice_id: invoice.id,
-              user_id,
-              hash: txid,
-              amount: -Math.round(token_amount * SATS),
-              received: false,
-              confirmed: false,
-              address,
-              network: "liquid"
-            },
-            { transaction }
-          );
-          emit(recipient.username, "payment", token_send);
-        }
-
-        store.issuances[txid].token = token;
-        store.issuances[txid].token_amount = token_amount;
-        store.issuances[txid].token_payment_id = token_payment.id;
-      }
-    });
-
-    res.send(store.issuances[txid] ? store.issuances[txid] : { asset });
-  } catch (e) {
-    err("asset issuance failed", e.message, e.stack);
-    res.code(500).send(e.message);
-  }
-});
-
-app.post("/assets/register", auth, async (req, res) => {
-  const { asset } = req.body;
-  const account = await db.Account.findOne({
-    where: {
-      user_id: req.user.id,
-      asset
-    }
-  });
-
-  l("registering", asset, account.contract);
-
-  try {
-    const { data: result } = await axios.post(
-      "https://assets.blockstream.info/",
-      {
-        asset_id: asset,
-        contract: account.contract
-      }
-    );
-    l("register asset result", req.user.username, result);
-    res.send(result);
-  } catch (e) {
-    err("asset registration failed", e.message);
-    res.code(500).send(e.message);
-  }
-});
-
-app.post("/loadFaucet", auth, async (req, res) => {
-  return res.code(500).send("Faucet feature temporarily disabled");
-
-  const { user } = req;
-  let { asset, amount } = req.body;
-  amount = parseInt(amount);
-
-  try {
-    if (amount <= 0) throw new Error("Amount to load cannot be negative");
-
-    await db.transaction(async transaction => {
-      let account = await getAccount(config.liquid.btcasset, user, transaction);
-
-      if (account.asset !== config.liquid.btcasset)
-        throw new Error(
-          "Faucet has to be funded with bitcoin. Try sending from another wallet."
-        );
-      if (account.balance < amount) throw new Error("Insufficient funds");
-
-      let fee = 0;
-
-      await account.decrement({ balance: amount }, { transaction });
-      await account.reload({ transaction });
-
-      let a2;
-      let acc = {
-        user_id: null,
-        asset
-      };
-
-      a2 = await db.Account.findOne({
-        where: acc,
-        lock: transaction.LOCK.UPDATE,
-        transaction
-      });
-
-      if (a2) {
-        await a2.increment({ balance: amount }, { transaction });
-        await a2.reload({ transaction });
-      } else {
-        let name = asset.substr(0, 6);
-        let domain;
-        let ticker = asset.substr(0, 3).toUpperCase();
-        let precision = 8;
-
-        const assets = assets;
-
-        if (assets[asset]) {
-          ({ domain, ticker, precision, name } = assets[asset]);
-        } else {
-          const existing = await db.Account.findOne({
-            where: {
-              asset
-            },
-            order: [["id", "ASC"]],
-            limit: 1,
-            lock: transaction.LOCK.UPDATE,
-            transaction
-          });
-
-          if (existing) {
-            ({ domain, ticker, precision, name } = existing);
-          }
-        }
-
-        acc = { ...acc, ...{ domain, ticker, precision, name } };
-        acc.balance = amount;
-        acc.pending = 0;
-        acc.network = "liquid";
-        a2 = await db.Account.create(acc, { transaction });
-      }
-
-      let params = {
-        amount: -amount,
-        account_id: account.id,
-        user_id: user.id,
-        rate: store.rates[user.currency],
-        currency: user.currency,
-        confirmed: true,
-        hash: `Loaded Faucet - ${a2.ticker}`,
-        network: "COINOS"
-      };
-
-      let payment = await db.Payment.create(params, { transaction });
-
-      payment = payment.get({ plain: true });
-      payment.account = account.get({ plain: true });
-
-      l("sent internal", user.username, -payment.amount);
-
-      emit(user.username, "payment", payment);
-      emit(user.username, "account", account);
-      emit(user.username, "user", user);
-
-      l("loaded faucet", asset, amount);
-      res.send({});
-    });
-  } catch (e) {
-    err("problem loading faucet", user.username, e.message);
-    return res.code(500).send(e.message);
-  }
-});
-
-app.get("/faucet", auth, async (req, res) => {
-  let { asset } = req.query;
-  let faucet = await db.Account.findOne({
-    where: {
-      asset,
-      user_id: null
-    }
-  });
-
-  if (!faucet)
-    faucet = {
-      asset,
-      balance: 0,
-      ticker: "Unknown"
-    };
-
-  res.send(faucet);
-});