target.ts

import client, { Gauge, register } from "prom-client";
client.collectDefaultMetrics();

import express from "express";
import fetch from "node-fetch";

import Fuse from "./fuse.node.commonjs2.js";

const fuse = new Fuse(
  "https://eth-mainnet.alchemyapi.io/v2/dBZwIrYUWCOiGx_fbA-s1xp4gABRir5A"
);
const alcxStakingAccount = "0x5ea4a9a7592683bf0bc187d6da706c6c4770976f";
const alcxStakingContract = new fuse.web3.eth.Contract(
  require("../abis/StakingPools.json"),
  "0xab8e74017a8cc7c15ffccd726603790d26d7deca"
);

let twaps = new Gauge({
  name: "fuse_twaps",
  help: "Stores if Fuse TWAPs need updating. 0 indicates no, 1 indicates yes.",
  labelNames: ["ticker"] as const
});

let poolAssetsInterestRate = new Gauge({
  name: "fuse_pool_assets_interest_rate",
  help: "Stores the interest rates of each asset in each pool.",
  // Side: borrow, supply
  labelNames: ["id", "symbol", "side"] as const
});

let poolRSS = new Gauge({
  name: "fuse_pool_rss",
  help: "Stores the RSS score of each pool.",
  labelNames: ["id"] as const
});

let poolSuppliedAssetsAmount = new Gauge({
  name: "fuse_pool_assets_supply_amount",
  help: "Stores how much of each asset is supplied in each pool.",
  labelNames: ["id", "symbol"] as const
});

let poolBorrowedAssetsAmount = new Gauge({
  name: "fuse_pool_assets_borrow_amount",
  help: "Stores how much of each asset is borrowed in each pool.",
  labelNames: ["id", "symbol"] as const
});

let poolSuppliedAssetsUSD = new Gauge({
  name: "fuse_pool_assets_supply_usd",
  help: "Stores how much of each asset is supplied in each pool.",
  labelNames: ["id", "symbol"] as const
});

let poolBorrowedAssetsUSD = new Gauge({
  name: "fuse_pool_assets_borrow_usd",
  help: "Stores how much of each asset is borrowed in each pool.",
  labelNames: ["id", "symbol"] as const
});

let poolAssetLiquidations = new Gauge({
  name: "fuse_pool_assets_liquidations",
  help: "Stores how many liquidations have been performed on each asset in a each pool.",
  labelNames: ["id", "symbol"] as const
});

let poolAssetsReservesAmount = new Gauge({
  name: "fuse_pool_assets_reserves_amount",
  help: "Stores how much of each asset is in reserves in each pool.",
  labelNames: ["id", "symbol"] as const
});

let poolAssetsReservesUSD = new Gauge({
  name: "fuse_pool_assets_reserves_usd",
  help: "Stores how much of each asset is in reserves in each pool.",
  labelNames: ["id", "symbol"] as const
});

let poolAssetsFeesAmount = new Gauge({
  name: "fuse_pool_assets_fees_amount",
  help: "Stores how much of each asset has been taken as fees in each pool.",
  labelNames: ["id", "symbol"] as const
});

let poolAssetsFeesUSD = new Gauge({
  name: "fuse_pool_assets_fees_usd",
  help: "Stores how much of each asset has been taken as fees in each pool.",
  labelNames: ["id", "symbol"] as const
});

let stakedALCXUSD = new Gauge({
  name: "fuse_staked_alcx_usd",
  help: "Stores how much protocol controlled ALCX is currently being staked."
});

let stakedALCXUnclaimedUSD = new Gauge({
  name: "fuse_staked_alcx_unclaimed_usd",
  help: "Stores how much protocol controlled ALCX is claimable from staking."
});

let stakedALCXAmount = new Gauge({
  name: "fuse_staked_alcx_amount",
  help: "Stores how much protocol controlled ALCX is currently being staked."
});

let stakedALCXUnclaimedAmount = new Gauge({
  name: "fuse_staked_alcx_unclaimed_amount",
  help: "Stores how much protocol controlled ALCX is claimable from staking."
});

export interface FuseAsset {
  cToken: string;

  borrowBalance: number;
  supplyBalance: number;
  liquidity: number;

  membership: boolean;

  underlyingName: string;
  underlyingSymbol: string;
  underlyingToken: string;
  underlyingDecimals: number;
  underlyingPrice: number;

  collateralFactor: number;
  reserveFactor: number;

  adminFee: number;
  fuseFee: number;

  borrowRatePerBlock: number;
  supplyRatePerBlock: number;

  totalBorrow: number;
  totalSupply: number;
}

type Task =
  | "rss"
  | "liquidations"
  | "user_leverage"
  | "reserves_fees"
  | "staked_alcx"
  | "borrowers";

let lastRun: { [key in Task]: number } = {
  rss: 0,
  liquidations: 0,
  user_leverage: 0,
  borrowers: 0,
  reserves_fees: 0,
  staked_alcx: 0
};

function runEvery(key: Task, seconds: number, instantLastRunUpdate?: boolean) {
  const ms = seconds * 1000;

  const now = Date.now();

  const msPassed = Date.now() - lastRun[key];

  if (msPassed >= ms) {
    if (instantLastRunUpdate) {
      lastRun[key] = now;
    } else {
      setTimeout(() => {
        lastRun[key] = now;
      }, 10_000);
    }

    return true;
  }
}

async function eventLoop() {
  const [{ 0: ids, 1: fusePools }, ethPrice] = await Promise.all([
    fuse.contracts.FusePoolLens.methods
      .getPublicPoolsByVerificationWithData(true)
      .call({ gas: 1e18 }),
    fuse.web3.utils.fromWei(await fuse.getEthUsdPriceBN()) as number
  ]);

  for (let i = 0; i < ids.length; i++) {
    const id = ids[i];

    if (id == 4) {
      // Pool 4 is broken, we'll just skip it for now.
      continue;
    }

    ///////////////////// Assets /////////////////////

    fuse.contracts.FusePoolLens.methods
      .getPoolAssetsWithData(fusePools[i].comptroller)
      .call({
        from: "0x0000000000000000000000000000000000000000",
        gas: 1e18
      })
      .then((assets: FuseAsset[]) => {
        for (const asset of assets) {
          ////////////////// USD //////////////////

          const usdTVL =
            ((asset.totalSupply * asset.underlyingPrice) / 1e36) * ethPrice;

          const usdTVB =
            ((asset.totalBorrow * asset.underlyingPrice) / 1e36) * ethPrice;

          // If no one is lending the asset,
          // we don't need to fetch anything else.
          if (usdTVL == 0) {
            continue;
          }

          poolSuppliedAssetsUSD.set(
            { id, symbol: asset.underlyingSymbol },
            usdTVL
          );

          poolBorrowedAssetsUSD.set(
            { id, symbol: asset.underlyingSymbol },
            usdTVB
          );

          ////////////////// Amount //////////////////

          poolSuppliedAssetsAmount.set(
            { id, symbol: asset.underlyingSymbol },
            asset.totalSupply / 10 ** asset.underlyingDecimals
          );

          poolBorrowedAssetsAmount.set(
            { id, symbol: asset.underlyingSymbol },
            asset.totalBorrow / 10 ** asset.underlyingDecimals
          );

          // If no one is borrowing the asset,
          // we don't need to fetch anything else.
          if (usdTVB == 0) {
            continue;
          }

          ////////////// Interest Rates ///////////////

          const supplyAPY =
            (Math.pow(
              (asset.supplyRatePerBlock / 1e18) * (4 * 60 * 24) + 1,
              365
            ) -
              1) *
            100;

          const borrowAPY =
            (Math.pow(
              (asset.borrowRatePerBlock / 1e18) * (4 * 60 * 24) + 1,
              365
            ) -
              1) *
            100;

          poolAssetsInterestRate.set(
            { id, symbol: asset.underlyingSymbol, side: "supply" },
            supplyAPY
          );

          poolAssetsInterestRate.set(
            { id, symbol: asset.underlyingSymbol, side: "borrow" },
            borrowAPY
          );

          ////////////// Fees And Reserves ///////////////

          if (runEvery("reserves_fees", 600 /* 10 minutes */)) {
            const cToken = new fuse.web3.eth.Contract(
              JSON.parse(
                fuse.compoundContracts[
                  "contracts/CEtherDelegate.sol:CEtherDelegate"
                ].abi
              ),
              asset.cToken
            );

            cToken.methods
              .totalReserves()
              .call()
              .then(reserves => {
                poolAssetsReservesAmount.set(
                  { symbol: asset.underlyingSymbol, id },
                  reserves / 10 ** asset.underlyingDecimals
                );

                poolAssetsReservesUSD.set(
                  { symbol: asset.underlyingSymbol, id },
                  ((reserves * asset.underlyingPrice) / 1e36) * ethPrice
                );
              });

            cToken.methods
              .totalFuseFees()
              .call()
              .then(fuseFees => {
                poolAssetsFeesAmount.set(
                  { symbol: asset.underlyingSymbol, id },
                  fuseFees / 10 ** asset.underlyingDecimals
                );

                poolAssetsFeesUSD.set(
                  { symbol: asset.underlyingSymbol, id },
                  ((fuseFees * asset.underlyingPrice) / 1e36) * ethPrice
                );
              });
          }

          ///////////////// Liquidations /////////////////

          if (runEvery("liquidations", 600 /* 10 minutes */)) {
            const cToken = new fuse.web3.eth.Contract(
              JSON.parse(
                fuse.compoundContracts[
                  "contracts/CEtherDelegate.sol:CEtherDelegate"
                ].abi
              ),
              asset.cToken
            );

            cToken
              .getPastEvents("LiquidateBorrow", {
                fromBlock: 12060000,
                toBlock: "latest"
              })
              .then(events => {
                if (events.length != 0) {
                  poolAssetLiquidations.set(
                    { id, symbol: asset.underlyingSymbol },
                    events.length
                  );
                }
              });
          }

          //////////////// Staked ALCX ////////////////

          if (
            asset.underlyingToken.toLowerCase() ===
              "0xdbdb4d16eda451d0503b854cf79d55697f90c8df".toLowerCase() &&
            runEvery("staked_alcx", 600 /* 10 minutes */, true)
          ) {
            alcxStakingContract.methods
              .getStakeTotalDeposited(alcxStakingAccount, "1")
              .call()
              .then(staked => {
                stakedALCXUSD.set(
                  ((staked * asset.underlyingPrice) / 1e36) * ethPrice
                );
                stakedALCXAmount.set(staked / 1e18);
              });

            alcxStakingContract.methods
              .getStakeTotalUnclaimed(alcxStakingAccount, "1")
              .call()
              .then(unclaimed => {
                stakedALCXUnclaimedUSD.set(
                  ((unclaimed * asset.underlyingPrice) / 1e36) * ethPrice
                );
                stakedALCXUnclaimedAmount.set(unclaimed / 1e18);
              });
          }
        }
      });

    /////////////////////// RSS /////////////////////

    if (runEvery("rss", 600 /* 10 mins */)) {
      fetch(`https://app.rari.capital/api/rss?poolID=${id}`)
        .then(res => res.json())
        .then(data => {
          poolRSS.set({ id }, data.totalScore);
        });
    }

    /////////////////// TWAPS //////////////////

    fetch(`https://api.rari.capital/fuse/twaps`)
      .then(res => res.json())
      .then(data => {
        for (const twap of Object.values(data) as {
          ticker: string;
          workable: boolean;
        }[]) {
          twaps.set({ ticker: twap.ticker }, twap.workable ? 1 : 0);
        }
      });
  }
}

// Event loop (every 60 seconds)
setInterval(eventLoop, 60_000);

// Run instantly the first time.
eventLoop();

const app = express();
const port = 1336;

let lastRestart = Date.now();

app.get("/metrics", async (_, res) => {
  res.set("Content-Type", register.contentType);
  res.end(await register.metrics());
});

app.get("/ops", async (_, res) => {
  res.json({ lastRestart });
});

app.listen(port, () => {
  console.log(`Target server started at http://localhost:${port}/metrics`);
});