@glowlabs-org/utils 0.0.9 → 0.1.1

package/src/lib/create-weekly-report/index.ts

@@ -0,0 +1,691 @@
+import axios from "axios";
+import { formatUnits, parseUnits } from "viem";
+import { MerkleTree } from "merkletreejs";
+import { BigNumber, ethers } from "ethers";
+import { greaterThanMaxDeviation } from "./utils/greater-than-max-deviation";
+import { customToFixed } from "./utils/custom-to-fixed";
+import { HUB_URL } from "../../constants/urls";
+import Decimal from "decimal.js";
+import { multiplyBigIntByDecimalPercentage } from "./utils/multiply-bigInt-by-decimal-percentage";
+import { toBigInt } from "./utils/to-bigint";
+import { fromBigInt } from "./utils/from-bigint";
+import { fetchFarmsForWeek } from "./utils/fetch-farms-for-week";
+import { accumulateLeafWeights } from "./utils/accumulate-leaf-weights";
+import { FinalizedLeaf, MerkleLeaf } from "./types/merkle";
+import { Audit } from "./types/Audit";
+import { NUMERIC_REGEX } from "../../constants/regex";
+import {
+  GLOW_WEIGHT_DECIMAL_PRECISION,
+  MAX_WEIGHT,
+  USDG_WEIGHT_DECIMAL_PRECISION,
+} from "../../constants/weights";
+import { hashLeaf } from "./utils/hashLeaf";
+
+export type MerkleLeafIntermediary = {
+  wallet: string;
+  glowWeight: bigint;
+  usdgWeight: bigint;
+};
+
+export type FinalLeaf = {
+  wallet: string;
+  glowWeight: string;
+  usdgWeight: string;
+};
+
+export type CreateWeeklyReportArgs = {
+  week: number;
+  gcaUrls: string[];
+  apiUrl: string;
+};
+
+async function createWeeklyReportLegacy(args: CreateWeeklyReportArgs) {
+  const mapLegacy = new Map<string, MerkleLeafIntermediary>();
+
+  function addValueToMapLegacy(
+    key: string,
+    value: MerkleLeafIntermediary,
+    map: Map<string, MerkleLeafIntermediary>
+  ) {
+    if (map.has(key)) {
+      const existingValue = map.get(key)!;
+      existingValue.glowWeight += value.glowWeight;
+      existingValue.usdgWeight += value.usdgWeight;
+      if (
+        existingValue.glowWeight > MAX_WEIGHT ||
+        existingValue.usdgWeight > MAX_WEIGHT
+      ) {
+        throw new Error(`Accumulated weight overflow on wallet ${key}`);
+      }
+      map.set(key, existingValue);
+    } else {
+      if (value.glowWeight > MAX_WEIGHT || value.usdgWeight > MAX_WEIGHT) {
+        throw new Error(`Initial weight overflow on wallet ${key}`);
+      }
+      map.set(key, value);
+    }
+  }
+
+  const apiResposne = await fetchFarmsForWeek(
+    args.week,
+    args.gcaUrls,
+    args.apiUrl
+  );
+  const farms = apiResposne.filteredFarms;
+  const rawData = apiResposne.rawData;
+  let totalCreditsProduced: bigint = BigInt(0);
+
+  for (const farm of farms) {
+    if (farm.status === "Unassigned") {
+      throw new Error(`Farm ${farm.shortId} is unassigned`);
+    }
+
+    if (farm.carbonCreditsProduced < 0) {
+      console.log(
+        `Farm: ${farm.shortId} has ${farm.carbonCreditsProduced} carbon credits produced`
+      );
+      throw new Error("Carbon credits produced is less than 0");
+    }
+    totalCreditsProduced += parseUnits(
+      customToFixed(farm.carbonCreditsProduced, 18),
+      18
+    );
+
+    if (!farm.rewardSplits)
+      throw new Error(`No reward splits for farm ${farm.shortId}`);
+
+    const sumOfRewardSplitsGlowWeight = farm.rewardSplits.reduce(
+      (acc, rewardSplit) => acc + rewardSplit.glowSplitPercent,
+      0
+    );
+    const sumOfRewardSplitsUSDGWeight = farm.rewardSplits.reduce(
+      (acc, rewardSplit) => acc + rewardSplit.usdgSplitPercent,
+      0
+    );
+    const percentTolerance = 1e-12;
+    if (Math.abs(sumOfRewardSplitsGlowWeight - 1) > percentTolerance)
+      throw new Error(
+        `Glow weight splits do not add up to 1 for farm ${farm.shortId}`
+      );
+    if (Math.abs(sumOfRewardSplitsUSDGWeight - 1) > percentTolerance)
+      throw new Error(
+        `USDG weight splits do not add up to 1 for farm ${farm.shortId}`
+      );
+
+    for (const rewardSplit of farm.rewardSplits) {
+      const glowBigInt: bigint = BigInt(
+        parseUnits(
+          customToFixed(farm.weeklyPayment, GLOW_WEIGHT_DECIMAL_PRECISION),
+          GLOW_WEIGHT_DECIMAL_PRECISION
+        )
+      );
+      const usdgBigInt: bigint = BigInt(
+        parseUnits(
+          customToFixed(
+            farm.carbonCreditsProduced,
+            USDG_WEIGHT_DECIMAL_PRECISION
+          ),
+          USDG_WEIGHT_DECIMAL_PRECISION
+        )
+      );
+      const glowWeight = multiplyBigIntByDecimalPercentage(
+        glowBigInt,
+        GLOW_WEIGHT_DECIMAL_PRECISION,
+        rewardSplit.glowSplitPercent
+      );
+      const usdgWeight = multiplyBigIntByDecimalPercentage(
+        usdgBigInt,
+        USDG_WEIGHT_DECIMAL_PRECISION,
+        rewardSplit.usdgSplitPercent
+      );
+      const value: MerkleLeafIntermediary = {
+        wallet: rewardSplit.walletAddress,
+        glowWeight,
+        usdgWeight,
+      };
+      //Make sure the usdgWeight and the glowWeight are > 0 if the number is > 0
+      if (
+        farm.carbonCreditsProduced > 0 &&
+        usdgWeight <= 0 &&
+        rewardSplit.usdgSplitPercent > 0
+      ) {
+        console.log(
+          farm.carbonCreditsProduced,
+          usdgWeight,
+          rewardSplit.usdgSplitPercent
+        );
+        throw new Error(
+          "USDG weight is less than 0 and carbon credits produced is greater than 0"
+        );
+      }
+      if (
+        farm.weeklyPayment > 0 &&
+        glowWeight <= 0 &&
+        rewardSplit.glowSplitPercent > 0
+      ) {
+        console.log(
+          farm.weeklyPayment,
+          glowWeight,
+          rewardSplit.glowSplitPercent
+        );
+        throw new Error(
+          "Glow weight is less than 0 and weekly payment is greater than 0"
+        );
+      }
+
+      if (
+        farm.carbonCreditsProduced > 0 &&
+        usdgWeight <= 0 &&
+        rewardSplit.usdgSplitPercent > 0
+      ) {
+        console.log(
+          farm.carbonCreditsProduced,
+          usdgWeight.toString(),
+          rewardSplit.usdgSplitPercent
+        );
+        throw new Error(
+          `USDG weight is less than or equal to 0 and carbon credits produced is greater than 0 for farm ${farm.shortId}`
+        );
+      }
+      if (
+        farm.weeklyPayment > 0 &&
+        glowWeight <= 0 &&
+        rewardSplit.glowSplitPercent > 0
+      ) {
+        console.log(
+          farm.weeklyPayment,
+          glowWeight.toString(),
+          rewardSplit.glowSplitPercent
+        );
+        throw new Error(
+          `Glow weight is less than or equal to 0 and weekly payment is greater than 0 for farm ${farm.shortId}`
+        );
+      }
+
+      addValueToMapLegacy(rewardSplit.walletAddress, value, mapLegacy);
+    }
+  }
+
+  const merkleLeaves = Array.from(mapLegacy.values());
+  const finalLeaves: FinalLeaf[] = merkleLeaves.map(
+    ({ wallet, glowWeight, usdgWeight }) => ({
+      wallet,
+      glowWeight: glowWeight.toString(),
+      usdgWeight: usdgWeight.toString(),
+    })
+  );
+  const leaves = finalLeaves.map((leaf) =>
+    hashLeaf({
+      address: leaf.wallet,
+      glowWeight: leaf.glowWeight,
+      usdcWeight: leaf.usdgWeight,
+    })
+  );
+
+  const tree = new MerkleTree(leaves, ethers.utils.keccak256, { sort: true });
+  const root = tree.getHexRoot();
+
+  const totalGlowWeightFinalizedLeavesSum = finalLeaves.reduce(
+    (acc, { glowWeight }) => acc.add(glowWeight),
+    ethers.BigNumber.from(0)
+  );
+  const totalGCCWeightFinalizedLeavesSum = finalLeaves.reduce(
+    (acc, { usdgWeight }) => acc.add(usdgWeight),
+    ethers.BigNumber.from(0)
+  );
+
+  if (totalGlowWeightFinalizedLeavesSum.toBigInt() > MAX_WEIGHT) {
+    throw new Error("Total glow weight is greater than max weight");
+  }
+  if (totalGCCWeightFinalizedLeavesSum.toBigInt() > MAX_WEIGHT) {
+    throw new Error("Total gcc weight is greater than max weight");
+  }
+
+  const headlineStats = {
+    weekNumber: args.week,
+    totalCreditsProduced: formatUnits(totalCreditsProduced, 18),
+    totalCreditsProducedBN: totalCreditsProduced.toString(),
+    totalGlowWeightInFinalized: totalGlowWeightFinalizedLeavesSum.toString(),
+    totalGlowWeightHuman: formatUnits(
+      BigInt(totalGlowWeightFinalizedLeavesSum.toString()),
+      GLOW_WEIGHT_DECIMAL_PRECISION
+    ).toString(),
+    totalUSDGWeightInFinalized: totalGCCWeightFinalizedLeavesSum.toString(),
+    totalUSDGWeightHuman: formatUnits(
+      BigInt(totalGCCWeightFinalizedLeavesSum.toString()),
+      USDG_WEIGHT_DECIMAL_PRECISION
+    ).toString(),
+    root: root,
+    glowWeightDecimals: GLOW_WEIGHT_DECIMAL_PRECISION,
+    usdgWeightDecimals: USDG_WEIGHT_DECIMAL_PRECISION,
+  };
+
+  const farmsWithMerkleProofs = finalLeaves.map((leaf) => {
+    const hashedLeaf = hashLeaf({
+      address: leaf.wallet,
+      glowWeight: leaf.glowWeight,
+      usdcWeight: leaf.usdgWeight,
+    });
+    const proof = tree.getHexProof(hashedLeaf);
+    const isValid = tree.verify(proof, hashedLeaf, root);
+    if (!isValid) {
+      throw new Error(`Invalid proof for wallet ${leaf.wallet}`);
+    }
+    return {
+      ...leaf,
+      proof,
+    };
+  });
+
+  let forLoopedGlowWeightSum: ethers.BigNumber = ethers.BigNumber.from(0);
+  for (const leafProof of farmsWithMerkleProofs) {
+    forLoopedGlowWeightSum = forLoopedGlowWeightSum.add(
+      BigNumber.from(leafProof.glowWeight)
+    );
+  }
+
+  if (!forLoopedGlowWeightSum.eq(totalGlowWeightFinalizedLeavesSum)) {
+    console.error("Glow Weight Sum Mismatch:");
+    console.error("Sum from loop:", forLoopedGlowWeightSum.toString());
+    console.error(
+      "Sum from reduce:",
+      totalGlowWeightFinalizedLeavesSum.toString()
+    );
+    throw new Error("Glow weight sum is not equal");
+  }
+
+  let forLoopedGCCWeightSum: ethers.BigNumber = ethers.BigNumber.from(0);
+  for (const leafProof of farmsWithMerkleProofs) {
+    forLoopedGCCWeightSum = forLoopedGCCWeightSum.add(
+      BigNumber.from(leafProof.usdgWeight)
+    );
+  }
+
+  if (!forLoopedGCCWeightSum.eq(totalGCCWeightFinalizedLeavesSum)) {
+    console.error("USDG Weight Sum Mismatch:");
+    console.error("Sum from loop:", forLoopedGCCWeightSum.toString());
+    console.error(
+      "Sum from reduce:",
+      totalGCCWeightFinalizedLeavesSum.toString()
+    );
+    throw new Error("GCC weight sum is not equal");
+  }
+
+  {
+    const totalCreditsProducedNumber = Number(
+      headlineStats.totalCreditsProduced
+    );
+    const totalUSDGWeightNumber = Number(headlineStats.totalUSDGWeightHuman);
+    const maxDeviation = 0.001;
+    if (
+      greaterThanMaxDeviation(
+        totalCreditsProducedNumber,
+        totalUSDGWeightNumber,
+        maxDeviation
+      )
+    ) {
+      console.error("Deviation Check Failed: Credits Produced vs USDG Weight");
+      console.error("Total Credits Produced:", totalCreditsProducedNumber);
+      console.error("Total USDG Weight:", totalUSDGWeightNumber);
+      console.error("Allowed Deviation:", maxDeviation);
+      throw new Error(
+        "Total credits produced and total usdg weight deviation > 0.1%"
+      );
+    }
+  }
+
+  {
+    const totalGlowWeightNumber = Number(headlineStats.totalGlowWeightHuman);
+    const totalProtocolFeePayments = farms.reduce(
+      (acc, farm) => acc + farm.weeklyPayment,
+      0
+    );
+    const maxDeviation = 0.001;
+    if (
+      greaterThanMaxDeviation(
+        totalGlowWeightNumber,
+        totalProtocolFeePayments,
+        maxDeviation
+      )
+    ) {
+      console.error("Deviation Check Failed: Glow Weight vs Protocol Fees");
+      console.error("Total Glow Weight:", totalGlowWeightNumber);
+      console.error("Total Protocol Fees:", totalProtocolFeePayments);
+      console.error("Allowed Deviation:", maxDeviation);
+      throw new Error(
+        "Total glow weight and total protocol fee payments deviation > 0.1%"
+      );
+    }
+  }
+
+  return {
+    headlineStats,
+    finalLeaves,
+    farmsWithMerkleProofs,
+    farms,
+    rawData,
+  };
+}
+
+export async function createWeeklyReport({
+  week,
+  gcaUrls,
+  apiUrl,
+}: CreateWeeklyReportArgs) {
+  if (week < 72) {
+    return createWeeklyReportLegacy({ week, gcaUrls, apiUrl });
+  }
+
+  const map = new Map<string, MerkleLeaf>();
+
+  const [apiResponse, auditsRes] = await Promise.all([
+    fetchFarmsForWeek(week, gcaUrls, apiUrl),
+    axios.get<Audit[]>(
+      `${HUB_URL}/api/audits?omitDocuments=true&weekNumber=${week}`
+    ),
+  ]);
+
+  const farms = apiResponse.filteredFarms;
+  const audits = auditsRes.data;
+  const rawData = apiResponse.rawData;
+
+  const shortIdToAdjustedCredit = new Map<string, bigint>();
+
+  for (const audit of audits) {
+    const activeShortIds = audit.activeShortIds ?? [];
+    const adjustedCredit =
+      audit.summary?.carbonFootprintAndProduction?.adjustedWeeklyCarbonCredit?.trim();
+
+    if (!adjustedCredit || !NUMERIC_REGEX.test(adjustedCredit))
+      throw new Error(
+        `Invalid adjustedWeeklyCarbonCredit for audit ${audit.id}`
+      );
+    if (activeShortIds.length === 0)
+      throw new Error(`audit ${audit.id} has empty activeShortIds`);
+
+    const splitValue = new Decimal(adjustedCredit).div(activeShortIds.length);
+    if (splitValue.isZero())
+      throw new Error(
+        `Zero adjustedWeeklyCarbonCredit split in audit ${audit.id}`
+      );
+
+    const splitBigInt = toBigInt(splitValue, USDG_WEIGHT_DECIMAL_PRECISION);
+    for (const sid of activeShortIds)
+      shortIdToAdjustedCredit.set(String(sid), splitBigInt);
+  }
+
+  const farmShortIds = new Set(farms.map((f: any) => String(f.shortId)));
+  audits.forEach((audit: any) =>
+    audit.activeShortIds?.forEach((sid: string | number) => {
+      if (!farmShortIds.has(String(sid)))
+        throw new Error(
+          `activeShortId ${sid} from audit ${audit.id} missing in filteredFarms`
+        );
+    })
+  );
+
+  let totalCreditsProduced18dp = BigInt(0);
+
+  for (const farm of farms) {
+    if (farm.status === "Unassigned") {
+      throw new Error(`farm ${farm.shortId} is unassigned`);
+    }
+
+    if (!farm.rewardSplits)
+      throw new Error(`farm ${farm.shortId} has no rewardSplits`);
+
+    if (farm.carbonCreditsProduced < 0) {
+      console.log(
+        `Farm: ${farm.shortId} has ${farm.carbonCreditsProduced} carbon credits produced`
+      );
+      throw new Error("Carbon credits produced is less than 0");
+    }
+
+    totalCreditsProduced18dp += parseUnits(
+      customToFixed(farm.carbonCreditsProduced, 18),
+      18
+    );
+
+    const sumGlow = farm.rewardSplits.reduce(
+      (acc: number, r: any) => acc + r.glowSplitPercent,
+      0
+    );
+    const sumUSDG = farm.rewardSplits.reduce(
+      (acc: number, r: any) => acc + r.usdgSplitPercent,
+      0
+    );
+    const percentTolerance = 1e-12;
+    if (Math.abs(sumGlow - 1) > percentTolerance)
+      throw new Error(`Glow splits ≠1 for farm ${farm.shortId}`);
+    if (Math.abs(sumUSDG - 1) > percentTolerance)
+      throw new Error(`USDG splits ≠1 for farm ${farm.shortId}`);
+
+    const glowBase = parseUnits(
+      customToFixed(farm.weeklyPayment, GLOW_WEIGHT_DECIMAL_PRECISION),
+      GLOW_WEIGHT_DECIMAL_PRECISION
+    );
+
+    const adjustedCreditBigInt =
+      shortIdToAdjustedCredit.get(String(farm.shortId)) ?? BigInt(0);
+
+    for (const split of farm.rewardSplits) {
+      const glowWeight = multiplyBigIntByDecimalPercentage(
+        glowBase,
+        GLOW_WEIGHT_DECIMAL_PRECISION,
+        split.glowSplitPercent
+      );
+      const usdgWeight = multiplyBigIntByDecimalPercentage(
+        adjustedCreditBigInt,
+        USDG_WEIGHT_DECIMAL_PRECISION,
+        split.usdgSplitPercent
+      );
+
+      if (
+        split.usdgSplitPercent > 0 &&
+        adjustedCreditBigInt > BigInt(0) &&
+        usdgWeight === BigInt(0)
+      )
+        throw new Error(`USDG dust lost for farm ${farm.shortId}`);
+      if (
+        split.glowSplitPercent > 0 &&
+        glowBase > BigInt(0) &&
+        glowWeight === BigInt(0)
+      )
+        throw new Error(`Glow dust lost for farm ${farm.shortId}`);
+
+      if (glowWeight > MAX_WEIGHT || usdgWeight > MAX_WEIGHT)
+        throw new Error(
+          `Leaf weight overflow on wallet ${split.walletAddress}`
+        );
+
+      accumulateLeafWeights(
+        split.walletAddress,
+        { wallet: split.walletAddress, glowWeight, usdgWeight },
+        map
+      );
+    }
+  }
+
+  const finalizedLeaves: FinalizedLeaf[] = Array.from(map.values()).map(
+    ({ wallet, glowWeight, usdgWeight }) => ({
+      wallet,
+      glowWeight: glowWeight.toString(),
+      usdgWeight: usdgWeight.toString(),
+    })
+  );
+
+  const hashedLeaves = finalizedLeaves.map((leaf) =>
+    hashLeaf({
+      address: leaf.wallet,
+      glowWeight: leaf.glowWeight,
+      usdcWeight: leaf.usdgWeight,
+    })
+  );
+
+  const merkleTree = new MerkleTree(hashedLeaves, ethers.utils.keccak256, {
+    sort: true,
+  });
+  const merkleRoot = merkleTree.getHexRoot();
+
+  const totalGlowWeight = finalizedLeaves.reduce(
+    (acc, { glowWeight }) => acc.add(glowWeight),
+    ethers.BigNumber.from(0)
+  );
+  const totalUSDGWeight = finalizedLeaves.reduce(
+    (acc, { usdgWeight }) => acc.add(usdgWeight),
+    ethers.BigNumber.from(0)
+  );
+
+  if (totalGlowWeight.toBigInt() > MAX_WEIGHT)
+    throw new Error("Total glow weight overflow");
+  if (totalUSDGWeight.toBigInt() > MAX_WEIGHT)
+    throw new Error("Total USDG weight overflow");
+
+  const leavesWithProofs = finalizedLeaves.map((leaf) => {
+    const hashed = hashLeaf({
+      address: leaf.wallet,
+      glowWeight: leaf.glowWeight,
+      usdcWeight: leaf.usdgWeight,
+    });
+    const proof = merkleTree.getHexProof(hashed);
+    if (!merkleTree.verify(proof, hashed, merkleRoot))
+      throw new Error("Invalid proof for " + leaf.wallet);
+    return { ...leaf, proof };
+  });
+
+  const glowSumProofLoop = leavesWithProofs.reduce(
+    (acc, l) => acc.add(l.glowWeight),
+    ethers.BigNumber.from(0)
+  );
+  if (!glowSumProofLoop.eq(totalGlowWeight)) {
+    console.error("Glow Weight Sum Mismatch (Post-73):");
+    console.error("Sum from loop:", glowSumProofLoop.toString());
+    console.error("Sum from reduce:", totalGlowWeight.toString());
+    throw new Error("Glow sum mismatch");
+  }
+
+  const usdgSumProofLoop = leavesWithProofs.reduce(
+    (acc, l) => acc.add(l.usdgWeight),
+    ethers.BigNumber.from(0)
+  );
+  if (!usdgSumProofLoop.eq(totalUSDGWeight)) {
+    console.error("USDG Weight Sum Mismatch (Post-73):");
+    console.error("Sum from loop:", usdgSumProofLoop.toString());
+    console.error("Sum from reduce:", totalUSDGWeight.toString());
+    throw new Error("USDG sum mismatch");
+  }
+
+  const totalExpectedCredits = farms.reduce((acc: Decimal, f: any) => {
+    const adj = shortIdToAdjustedCredit.get(String(f.shortId)) ?? BigInt(0);
+    return acc.plus(fromBigInt(adj, USDG_WEIGHT_DECIMAL_PRECISION));
+  }, new Decimal(0));
+
+  const totalUSDGWeightHuman = new Decimal(
+    formatUnits(
+      BigInt(totalUSDGWeight.toString()),
+      USDG_WEIGHT_DECIMAL_PRECISION
+    )
+  );
+  if (
+    greaterThanMaxDeviation(
+      totalExpectedCredits.toNumber(),
+      totalUSDGWeightHuman.toNumber(),
+      0.001
+    )
+  ) {
+    console.error(
+      "Deviation Check Failed (Post-73): Expected Credits vs USDG Weight"
+    );
+    console.error("Total Expected Credits:", totalExpectedCredits.toNumber());
+    console.error("Total USDG Weight:", totalUSDGWeightHuman.toNumber());
+    console.error("Allowed Deviation:", 0.001);
+    throw new Error("totalExpectedCredits vs USDG weight deviation >0.1% ");
+  }
+
+  const totalGlowWeightHuman = new Decimal(
+    formatUnits(
+      BigInt(totalGlowWeight.toString()),
+      GLOW_WEIGHT_DECIMAL_PRECISION
+    )
+  );
+  const totalProtocolFeePayments = farms.reduce(
+    (acc: number, f: any) => acc + f.weeklyPayment,
+    0
+  );
+  if (
+    greaterThanMaxDeviation(
+      totalGlowWeightHuman.toNumber(),
+      totalProtocolFeePayments,
+      0.001
+    )
+  ) {
+    console.error(
+      "Deviation Check Failed (Post-73): Glow Weight vs Protocol Fees"
+    );
+    console.error("Total Glow Weight:", totalGlowWeightHuman.toNumber());
+    console.error("Total Protocol Fees:", totalProtocolFeePayments);
+    console.error("Allowed Deviation:", 0.001);
+    throw new Error("totalGlowWeight vs protocol fees deviation >0.1% ");
+  }
+
+  const headlineStats = {
+    weekNumber: week,
+    totalCreditsProduced: formatUnits(totalCreditsProduced18dp, 18),
+    totalCreditsProducedBN: totalCreditsProduced18dp.toString(),
+    totalGlowWeightInFinalized: totalGlowWeight.toString(),
+    totalGlowWeightHuman: totalGlowWeightHuman.toString(),
+    totalUSDGWeightInFinalized: totalUSDGWeight.toString(),
+    totalUSDGWeightHuman: totalUSDGWeightHuman.toString(),
+    root: merkleRoot,
+    glowWeightDecimals: GLOW_WEIGHT_DECIMAL_PRECISION,
+    usdgWeightDecimals: USDG_WEIGHT_DECIMAL_PRECISION,
+  };
+
+  const shortIdAdjustedList = Array.from(shortIdToAdjustedCredit.entries()).map(
+    ([shortId, creditBigInt]) => ({
+      shortId,
+      adjustedCredit: fromBigInt(
+        creditBigInt,
+        USDG_WEIGHT_DECIMAL_PRECISION
+      ).toString(),
+    })
+  );
+
+  const creditsDeviationList = farms.map((farm: any) => {
+    const adj = shortIdToAdjustedCredit.get(String(farm.shortId)) ?? BigInt(0);
+    const adjusted = fromBigInt(adj, USDG_WEIGHT_DECIMAL_PRECISION);
+    const produced = new Decimal(farm.carbonCreditsProduced);
+    let deviation: Decimal;
+    let absDeviation: Decimal;
+    let deviationPercent: Decimal;
+    if (produced.isZero() && adjusted.isZero()) {
+      deviation = new Decimal(0);
+      absDeviation = new Decimal(0);
+      deviationPercent = new Decimal(0);
+    } else {
+      deviation = produced.minus(adjusted);
+      absDeviation = deviation.abs();
+      deviationPercent = deviation
+        .div(produced.isZero() ? 1 : produced)
+        .mul(100);
+    }
+    return {
+      shortId: String(farm.shortId),
+      carbonCreditsProduced: produced.toNumber(),
+      adjustedWeeklyCarbonCredit: adjusted.toNumber(),
+      deviation: deviation.toNumber(),
+      absDeviation: absDeviation.toNumber(),
+      deviationPercent: deviationPercent.toNumber(),
+    };
+  });
+
+  return {
+    headlineStats,
+    finalizedLeaves,
+    leavesWithProofs,
+    farms,
+    rawData,
+    shortIdAdjustedList,
+    creditsDeviationList,
+  };
+}