aboutsummaryrefslogtreecommitdiffstats
path: root/scripts/check.js
blob: f14a313a6b32da33de0bdbeff4984f01b4f1d488 (plain) (blame)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
let config = require('./config');
let fs = require('fs');

let mailgun = require('mailgun-js')({apiKey: config.mailgun, domain: config.domain });
 
let data = {
  ...config.mail,
  subject: 'User Documents',
  text: 'Documents uploaded',
};

fs.readdir('./uploads', (err, files) => {
  files.forEach(file => {
    console.log(file);
    data.text = file;
    fs.rename(file, '../verified' + file);
    mailgun.messages().send(data, function (error, body) {
      console.log(body);
    });
  });
});
 
.highlight .bp { color: #038 } /* Name.Builtin.Pseudo */ .highlight .fm { color: #06B; font-weight: bold } /* Name.Function.Magic */ .highlight .vc { color: #369 } /* Name.Variable.Class */ .highlight .vg { color: #D70 } /* Name.Variable.Global */ .highlight .vi { color: #33B } /* Name.Variable.Instance */ .highlight .vm { color: #369 } /* Name.Variable.Magic */ .highlight .il { color: #00D; font-weight: bold } /* Literal.Number.Integer.Long */
import config from "$config";
import db from "$db";
import sequelize from "@sequelize/core";
import { fromBase58 } from "bip32";
import { payments as bcPayments, networks as bcNetworks } from "bitcoinjs-lib";
import { payments as lqPayments, networks as lqNetworks } from "liquidjs-lib";
import { createInvoice } from "lightning";
import lnd from "$lib/lnd";
import ln from "$lib/ln";

const { Op } = sequelize;

export const requirePin = async ({ body, user }) => {
  if (user && user.pin && user.pin !== body.pin)
    throw new Error("Invalid pin");
};

export const getUser = async (username, transaction) => {
  let params = {
    include: [
      {
        model: db.Account,
        as: "account"
      }
    ],
    where: {
      username: { [Op.or]: [username, username.replace(/ /g, "")] }
    }
  };

  if (transaction) {
    params.lock = transaction.LOCK.UPDATE;
    params.transaction = transaction;
  }

  let user = await db.User.findOne(params);
  if (!user) throw new Error(`User ${username} not found`);

  user.haspin = !!user.pin;

  return user;
};

export const getUserById = async (id, transaction) => {
  let params = {
    include: [
      {
        model: db.Account,
        as: "account"
      }
    ],
    where: { id }
  };

  if (transaction) {
    params.lock = transaction.LOCK.UPDATE;
    params.transaction = transaction;
  }

  let user = await db.User.findOne(params);
  if (!user) throw new Error("User not found");

  return user;
};

export const prod = process.env.NODE_ENV === "production";
export const fail = msg => {
  throw new Error(msg);
};

export const SATS = 100000000;
export const toSats = n => Math.round(n * SATS);

export const getBlockHeight = message => {
  let buffer = Buffer.from(message, "hex");
  if (buffer.length < 80) throw new Error("Buffer too small (< 80 bytes)");

  let offset = 0;
  const readSlice = n => {
    offset += n;
    return buffer.slice(offset - n, offset);
  };

  const readUInt32 = () => {
    const i = buffer.readUInt32LE(offset);
    offset += 4;
    return i;
  };

  const readUInt8 = () => {
    const i = buffer.readUInt8(offset);
    offset += 1;
    return i;
  };

  const readVarInt = () => {
    const vi = varuint.decode(buffer, offset);
    offset += varuint.decode.bytes;
    return vi;
  };

  readUInt32();
  readSlice(32);
  readSlice(32);
  readUInt32();
  return readUInt32();
};

export const deriveAddress = async (account, type) => {
  let { index, pubkey, path, network } = account;
  let n = { bitcoin: bcNetworks, liquid: lqNetworks }[network][
    prod ? "bitcoin" : "regtest"
  ];
  let p = { bitcoin: bcPayments, liquid: lqPayments }[network];
  let root = fromBase58(pubkey, n);
  let parts = path.split("/");
  let hd = root.derive(parseInt(parts[parts.length - 1]));

  type = {
    bech32: "p2wpkh",
    "p2sh-segwit": "p2sh",
    legacy: "p2pkh"
  }[type];

  console.log("TYPE", type);

  let r;
  if (type !== "p2sh") {
    r = p[type]({
      pubkey: hd.publicKey,
      network: n
    });
  } else {
    r = p[type]({
      redeem: p.p2wpkh({
        pubkey: hd.publicKey,
        network: n
      }),
      network: n
    });
  }

  index++;
  account.index = index;
  account.address = r.address;
  await account.save();

  return r;
};

export const bip21 = ({ address, amount, memo, tip, network }, { asset }) => {
  if (network === "liquid") network = "liquidnetwork";

  let url = amount || memo ? `${network}:${address}?` : address;
  if (amount)
    url += `amount=${((amount + tip) / SATS).toFixed(8)}${memo ? "&" : ""}`;
  if (memo) url += `message=${memo}`;

  if (network === "liquidnetwork" && amount) {
    url += `&asset=${asset}`;
  }

  return url;
};

export const derivePayRequest = async ({ amount, memo, tip }) => {
  if (!tip) tip = 0;
  let value = amount + tip;

  if (config.lna.clightning) {
    if (!memo) memo = "coinos";
    return (
      await ln.invoice(value ? `${value}sat` : "any", new Date(), memo, 360)
    ).bolt11;
  } else {
    return (
      await createInvoice({
        lnd,
        tokens: value,
        description: memo
      })
    ).request;
  }
};