fix: FolksFinance xAlgo circulating supply calculation (DefiLlama#13365)

Author: moshenskyDV

projects/folks-xalgo/constants.js

@@ -0,0 +1,12 @@
+const xAlgoAssetId = 1134696561;
+const algoAssetId = 0;
+
+const oracleAppId = 1040271396;
+const oracleDecimals = 14;
+
+module.exports = {
+  xAlgoAssetId,
+  algoAssetId,
+  oracleAppId,
+  oracleDecimals,
+};

projects/folks-xalgo/index.js

@@ -1,13 +1,19 @@
 const { getAssetInfo } = require("../helper/chain/algorand");
-
-const xAlgoAssetId = 1134696561;
+const { getCachedPrices } = require('./prices');
+const { xAlgoAssetId, algoAssetId } = require('./constants');
 
 module.exports = {
   timetravel: false,
   algorand: {
-    tvl: async (api) => {
+    tvl: async () => {
+      const prices = await getCachedPrices();
+      const xAlgoPrice = prices[xAlgoAssetId];
+      const algoPrice = prices[algoAssetId];
+
       const info = await getAssetInfo(xAlgoAssetId);
-      api.add(xAlgoAssetId+'', info.circulatingSupply)
+      const totalXAlgo = info.circulatingSupply / 10 ** info.decimals;
+      const totalAlgo = totalXAlgo * xAlgoPrice / algoPrice;
+      return { algorand: totalAlgo };
     },
   },
 };

projects/folks-xalgo/prices.js

@@ -0,0 +1,92 @@
+const { oracleAppId, oracleDecimals } = require("./constants");
+const {
+  getAppState,
+  getParsedValueFromState,
+  fromIntToBytes8Hex,
+  parseOracleValue,
+} = require("./utils");
+
+function decodeUint64(data, decodingMode = "safe") {
+  if (
+    decodingMode !== "safe" &&
+    decodingMode !== "mixed" &&
+    decodingMode !== "bigint"
+  ) {
+    throw new Error(`Unknown decodingMode option: ${decodingMode}`);
+  }
+
+  if (data.byteLength === 0 || data.byteLength > 8) {
+    throw new Error(
+      `Data has unacceptable length. Expected length is between 1 and 8, got ${data.byteLength}`
+    );
+  }
+
+  // insert 0s at the beginning if data is smaller than 8 bytes
+  const padding = Buffer.allocUnsafe(8 - data.byteLength);
+  padding.fill(0);
+
+  const buf = Buffer.concat([padding, Buffer.from(data)]);
+
+  const num = buf.readBigUInt64BE();
+  const isBig = num > Number.MAX_SAFE_INTEGER;
+
+  if (decodingMode === "safe") {
+    if (isBig) {
+      throw new Error(
+        `Integer exceeds maximum safe integer: ${num.toString()}. Try decoding with "mixed" or "safe" decodingMode.`
+      );
+    }
+    return Number(num);
+  }
+
+  if (decodingMode === "mixed" && !isBig) {
+    return Number(num);
+  }
+
+  return num;
+}
+
+let pricesCache;
+
+async function getCachedPrices() {
+  if (!pricesCache) pricesCache = getPrices();
+  return pricesCache;
+}
+
+/* Get prices from oracle */
+async function getPrices() {
+  const oracleState = await getAppState(oracleAppId);
+
+  const prices = {};
+
+  // get the assets for which we need to retrieve their prices
+  const assets = oracleState
+    .filter(({ key }) => {
+      // remove non asset ids global state
+      key = Buffer.from(key, "base64").toString("utf8");
+      return (
+        key !== "updater_addr" &&
+        key !== "admin" &&
+        key !== "tinyman_validator_app_id"
+      );
+    })
+    .map(({ key }) => {
+      // convert key to asset id
+      return decodeUint64(Buffer.from(key, "base64"), "safe");
+    });
+
+  // retrieve asset prices
+  assets.forEach((assetId) => {
+    const assetPrice = parseOracleValue(
+      String(
+        getParsedValueFromState(oracleState, fromIntToBytes8Hex(assetId), "hex")
+      )
+    );
+
+    prices[assetId] = Number(assetPrice) / 10 ** oracleDecimals;
+  });
+
+  return prices;
+}
+
+module.exports = { getCachedPrices };

projects/folks-xalgo/utils.js

@@ -0,0 +1,39 @@
+const { lookupApplications } = require("../helper/chain/algorand");
+
+function fromIntToBytes8Hex(num) {
+  return num.toString(16).padStart(16, "0");
+}
+
+function encodeToBase64(str, encoding = "utf8") {
+  return Buffer.from(str, encoding).toString("base64");
+}
+
+function parseOracleValue(base64Value) {
+  const value = Buffer.from(base64Value, "base64").toString("hex");
+  // first 8 bytes are the price
+  const price = BigInt("0x" + value.slice(0, 16));
+
+  return price;
+}
+
+function getParsedValueFromState(state, key, encoding = "utf8") {
+  const encodedKey = encoding ? encodeToBase64(key, encoding) : key;
+  const keyValue = state.find((entry) => entry.key === encodedKey);
+  if (keyValue === undefined) return;
+  const { value } = keyValue;
+  if (value.type === 1) return value.bytes;
+  if (value.type === 2) return BigInt(value.uint);
+  return;
+}
+
+async function getAppState(appId) {
+  const res = await lookupApplications(appId);
+  return res.application.params["global-state"];
+}
+
+module.exports = {
+  fromIntToBytes8Hex,
+  parseOracleValue,
+  getParsedValueFromState,
+  getAppState,
+};