index : coinos-server.git	ark2 assets base build bun-elysia cashreq changeDefaultPass cjs classic cln-rest conversions dChanges dev logging master masterZ no-challenge notifications prod rJuly19 readme-update readmeUpdate regtest-fulcrum retransmit setup-updates square stageUpdate stageUpdate2 staging taxi tdex test tickets v1.0.0 vue withdraw
	coinos server — legacy coinos.io backend (Lightning, on-chain, Liquid)	coinos

aboutsummaryrefslogtreecommitdiffstats

log msg author committer range

path: root/passport.js

	Commit message (Expand)	Author	Age	Files	Lines
*	stop using dotenv for config	Adam Soltys	2019-02-11	1	-3/+2
*	upgrade passport-jwt and use auth header extractor	Adam Soltys	2018-11-26	1	-1/+1
*	move register function out of graphql, fix socket cookies	Adam Soltys	2018-03-19	1	-1/+1
*	authenticate sockets and only emit to specific subscribers	Adam Soltys	2018-03-02	1	-2/+7
*	keep track of users' invoices	Adam Soltys	2018-02-20	1	-27/+25
*	jwt auth	Adam Soltys	2018-01-29	1	-5/+7
*	use dotenv for config	Adam Soltys	2017-10-21	1	-0/+3
*	use dotenv for config	Adam Soltys	2017-09-09	1	-1/+2
*	cookie extractor	Adam Soltys	2017-04-17	1	-5/+11
*	jwt login	Adam Soltys	2017-04-17	1	-5/+9
*	server refactor and jwt auth	Adam Soltys	2017-04-14	1	-43/+15
*	Make usernames case insensitive (closes #14)	Adam Soltys	2016-02-14	1	-4/+4
*	Use bcryptjs instead of bcrypt	Adam Soltys	2015-11-13	1	-1/+1
*	Precompile all coffeescript	Adam Soltys	2014-07-20	1	-0/+45

generated by cgit v1.2.3 (git 2.51.0) at 2026-11-12 01:07:29 +0000

import config from "$config";
import db from "$db";
import { emit } from "$lib/sockets";
import store from "$lib/store";
import { callWebhook } from "$lib/webhooks";
import axios from "axios";
import { v4 } from "uuid";
import { notify } from "$lib/notifications";
import { sendLiquid } from "$routes/liquid/send";
import { l, err } from "$lib/logging";
import { fail } from "$lib/utils";

const { HOSTNAME: hostname } = process.env;

export default async (
  { amount, address, payreq, unconfidential, asset, memo, username, tip },
  user
) => {
  amount = parseInt(amount);

  if (!asset) asset = config.liquid.btcasset;

  if (!amount || amount < 0) fail("Amount must be greater than zero");

  return db.transaction(async transaction => {
    let account;
    if (user.account.asset === asset && !user.account.pubkey) {
      account = await db.Account.findOne({
        where: {
          id: user.account.id,
          pubkey: null
        },
        lock: transaction.LOCK.UPDATE,
        transaction
      });
    } else {
      account = await db.Account.findOne({
        where: {
          user_id: user.id,
          asset,
          pubkey: null
        },
        lock: transaction.LOCK.UPDATE,
        transaction
      });
    }

    if (!account) throw new Error("Account not found");

    if (account.balance < amount) {
      throw new Error("Insufficient funds");
    }

    let fee = 0;

    await account.decrement({ balance: amount }, { transaction });
    await account.reload({ transaction });

    let params, recipient, payment;

    if (username) {
      recipient = await db.User.findOne(
        {
          where: { username },
          include: {
            model: db.Account,
            as: "account"
          }
        },
        { transaction }
      );

      params = {
        where: { user_id: recipient.id },
        order: [["id", "DESC"]]
      };
      if (address) params.where.address = address;
      else if (payreq) params.where.text = payreq;
      let invoice = (address || payreq) && (await db.Invoice.findOne(params));

      let a2;
      let acc = {
        user_id: recipient.id,
        asset,
        pubkey: null
      };

      if (recipient.account.asset === asset && !recipient.account.pubkey)
        a2 = recipient.account;
      else {
        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;

        if (store.assets[asset]) {
          ({ domain, ticker, precision, name } = store.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 });
      }

      params = {
        amount,
        account_id: a2.id,
        user_id: recipient.id,
        rate: store.rates[recipient.currency],
        currency: recipient.currency,
        confirmed: true,
        hash: `#${v4().substr(0, 6)} Payment from ${user.username}`,
        memo,
        network: "COINOS",
        received: true,
        with_id: user.id
      };

      if (invoice) {
        let { tip } = invoice;
        params.invoice_id = invoice.id;
        if (tip) {
          params.tip = tip;
          params.amount -= tip;
        } 

        await invoice.increment({ received: amount }, { transaction });
        await invoice.reload({ transaction });

        let c = store.convert[invoice.text];
        if (c) {
          l(
            "internal payment detected for conversion",
            invoice.text,
            c.address,
            recipient.username
          );

          recipient.account = a2;

          sendLiquid({
            address: c.address,
            amount: amount - 100,
            user: recipient,
            limit: amount
          }).catch(console.log);
        }
      }

      let p2 = await db.Payment.create(params, { transaction });

      p2 = p2.get({ plain: true });
      p2.account = a2.get({ plain: true });
      if (invoice) p2.invoice = invoice.get({ plain: true });

      emit(recipient.username, "payment", p2);
      emit(recipient.username, "account", p2.account);

      l("received internal", recipient.username, amount);
      notify(recipient, `Received ${amount} ${a2.ticker} sats`);
      callWebhook(invoice, p2);
    }

    params = {
      amount: -amount,
      account_id: account.id,
      memo,
      user_id: user.id,
      rate: store.rates[user.currency],
      currency: user.currency,
      confirmed: true,
      with_id: recipient && recipient.id,
      hash: `#${v4().substr(0, 6)} ${
        username ? `Payment to ${username}` : "Internal Transfer"
      }`,
      network: "COINOS",
    };

    if (!username) {
      l("creating redeemable payment");
      params.redeemcode = v4();
      params.hash = `${hostname}/redeem/${params.redeemcode}`;
    }

    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);

    return payment;
  });
};