add regtest fund docs - coinos-server.git - coinos server — legacy coinos.io backend (Lightning, on-chain, Liquid)

about summary refs log tree commit diff stats

path: root/apidoc/vendor/webfontloader.js

diff options

author	Muhammad Abdullah Abid <[email protected]>	2022-02-15 16:29:07 -0800
committer	Muhammad Abdullah Abid <[email protected]>	2022-02-15 16:29:07 -0800
commit	1efcea585979cb7deec292554260360c83fb516b (patch)
tree	8cf61a56b62d212106bccf0ff7724a268c0b1083 /apidoc/vendor/webfontloader.js
parent	46bc3fdc3d5c5da1c7f6ecb27e949da7687398b7 (diff)
download	coinos-server-1efcea585979cb7deec292554260360c83fb516b.tar.gz coinos-server-1efcea585979cb7deec292554260360c83fb516b.zip

add regtest fund docsreadme-update

Diffstat (limited to 'apidoc/vendor/webfontloader.js')

0 files changed, 0 insertions, 0 deletions

5' href='#n105'>105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137

const reverse = require("buffer-reverse");
const zmq = require("zeromq");
const { Op } = require("sequelize");
const bitcoin = require("elementsjs-lib");

const zmqRawBlock = zmq.socket("sub");
zmqRawBlock.connect(config.liquid.zmqrawblock);
zmqRawBlock.subscribe("rawblock");

const zmqRawTx = zmq.socket("sub");
zmqRawTx.connect("tcp://127.0.0.1:18603");
zmqRawTx.subscribe("rawtx");

let NETWORK = bitcoin.networks[config.bitcoin.network === "mainnet" ? "bitcoin" : config.bitcoin.network];

zmqRawTx.on("message", async (topic, message, sequence) => {
  const hex = message.toString("hex");
  const unblinded = await lq.unblindRawTransaction(hex);
  const tx = await lq.decodeRawTransaction(unblinded.hex);
  const blinded = await lq.decodeRawTransaction(hex);
  if (payments.includes(blinded.txid)) return;

  Promise.all(
    tx.vout.map(async o => {
      if (!(o.scriptPubKey && o.scriptPubKey.addresses)) return;
      const value = toSats(o.value);
      const address = o.scriptPubKey.addresses[0];

      if (Object.keys(addresses).includes(address)) {
        let user = await db.User.findOne({
          where: {
            username: addresses[address]
          }
        });

        let invoices = await db.Payment.findAll({
          limit: 1,
          where: {
            address,
            received: null,
            amount: {
              [Op.gt]: 0
            }
          },
          order: [["id", "DESC"]]
        });

        let tip = null;
        if (invoices.length) tip = invoices[0].tip;

        let confirmed = 0;

        user.pending += value;
        user.confidential = await lq.getNewAddress();
        user.liquid = (await lq.getAddressInfo(user.confidential)).unconfidential;

        await user.save();
        emit(user.username, "user", user);

        addresses[user.liquid] = user.username;

        const payment = await db.Payment.create({
          user_id: user.id,
          hash: blinded.txid,
          amount: value,
          currency: user.currency,
          rate: app.get("rates")[user.currency],
          received: true,
          tip,
          confirmed,
          address,
          asset: 'LBTC',
        });
        payments.push(blinded.txid);

        l.info("liquid detected", user.username, value);
        emit(user.username, "payment", payment);
      }
    })
  );
});

let queue = {};

zmqRawBlock.on("message", async (topic, message, sequence) => {
  const payments = await db.Payment.findAll({
    where: { confirmed: 0 }
  });

  const hashes = payments.map(p => p.hash);

  const block = bitcoin.Block.fromHex(message.toString("hex"), true);
  const hash = await lq.getBlockHash(block.height);
  const json = await lq.getBlock(hash, 2);

  json.tx.map(tx => {
    if (hashes.includes(tx.txid)) queue[tx.txid] = 1;
  });
});

setInterval(async () => {
  let arr = Object.keys(queue);

  for (let i = 0; i < arr.length; i++) {
    let hash = arr[i];

    let p = await db.Payment.findOne({
      include: [{ model: db.User, as: "user" }],
      where: { hash, confirmed: 0, received: 1 }
    })

    p.confirmed = 1;

    let user = await p.getUser();
    user.balance += p.amount;
    user.pending -= Math.min(user.pending, p.amount);
    l.info("liquid confirmed", user.username, p.amount);
    emit(user.username, "user", user);

    await user.save();
    await p.save();

    let payments = await db.Payment.findAll({
      where: { 
        user_id: user.id,
        received: { 
          [Op.ne]: null
        },
      },
      order: [['id', 'DESC']],
      limit: 12
    });

    emit(user.username, "payments", payments);
    delete queue[hash];
  }
}, 1000);