Merge pull request #50 from pancakeswap/fix-supply-api

fix supply api

api/supply.ts

@@ -1,56 +1,55 @@
 import { NowRequest, NowResponse } from "@vercel/node";
 import {
-  getBurnedSupply,
+  getDeadSupply,
   getLockedCake,
-  getTotalSupply,
+  getTotalMint,
   planetFinanceBurnedTokensWei,
   maxSupply,
   getVeCakeLocked,
 } from "../utils/supply";
 import formatNumber from "../utils/formatNumber";
-import BigNumber from "bignumber.js";
 
 export default async (req: NowRequest, res: NowResponse): Promise<void> => {
-  let totalSupply = await getTotalSupply();
-  totalSupply = totalSupply.div(1e18);
+  let totalMint = await getTotalMint();
+  totalMint = totalMint.div(1e18);
 
-  let burnedSupply = await getBurnedSupply();
-  burnedSupply = burnedSupply.div(1e18);
+  let deadSupply = await getDeadSupply();
+  deadSupply = deadSupply.div(1e18);
 
   let lockedCakePool = await getLockedCake();
   lockedCakePool = lockedCakePool.div(1e18);
 
   let lockedVeCake = await getVeCakeLocked();
   lockedVeCake = lockedVeCake.div(1e18);
 
-  let lockedCake = lockedCakePool.plus(lockedVeCake);
+  let totalLockedCake = lockedCakePool.plus(lockedVeCake);
 
   const planetFinanceBurnedTokens = planetFinanceBurnedTokensWei.div(1e18);
 
-  const totalBurnedTokens = burnedSupply.plus(planetFinanceBurnedTokens);
+  const totalBurnedTokens = deadSupply.plus(planetFinanceBurnedTokens);
 
-  const burnedAndLockedTokens = totalBurnedTokens.plus(lockedCake);
+  const burnedAndLockedTokens = totalBurnedTokens.plus(totalLockedCake);
 
-  const unburntCake = totalSupply.minus(totalBurnedTokens);
+  const totalSupply = totalMint.minus(totalBurnedTokens);
 
-  const circulatingSupply = totalSupply.minus(burnedAndLockedTokens);
+  const circulatingSupply = totalMint.minus(burnedAndLockedTokens);
 
   if (req.query?.q === "totalSupply") {
-    res.json(unburntCake.toNumber());
+    res.json(totalSupply.toNumber());
   } else if (req.query?.q === "circulatingSupply") {
     res.json(circulatingSupply.toNumber());
   } else if (req.query?.verbose) {
     res.json({
-      totalMinted: formatNumber(totalSupply.toNumber()),
-      totalSupply: formatNumber(unburntCake.toNumber()),
-      burnedSupply: formatNumber(burnedSupply.toNumber()),
+      totalMinted: formatNumber(totalMint.toNumber()),
+      totalSupply: formatNumber(totalSupply.toNumber()),
+      burnedSupply: formatNumber(totalBurnedTokens.toNumber()),
       circulatingSupply: formatNumber(circulatingSupply.toNumber()),
-      lockedCake: formatNumber(lockedCake.toNumber()),
+      lockedCake: formatNumber(totalLockedCake.toNumber()),
       maxSupply: formatNumber(maxSupply),
     });
   } else {
     res.json({
-      totalSupply: unburntCake.toNumber(),
+      totalSupply: totalSupply.toNumber(),
       burnedSupply: totalBurnedTokens.toNumber(),
       circulatingSupply: circulatingSupply.toNumber(),
     });

utils/abis/veCake.json

@@ -0,0 +1,15 @@
+[
+  {
+    "inputs": [],
+    "name": "supply",
+    "outputs": [
+      {
+        "internalType": "uint256",
+        "name": "",
+        "type": "uint256"
+      }
+    ],
+    "stateMutability": "view",
+    "type": "function"
+  }
+]

utils/supply.ts

@@ -3,18 +3,20 @@ import { getContract } from "./web3";
 import { CAKE, DEAD, LOCKED_CAKE_POOL, VECAKE } from "./constants";
 import bep20 from "./abis/bep20.json";
 import lockedCakePool from "./abis/lockedCakePool.json";
+import veCake from "./abis/veCake.json";
 
-const contract = getContract(bep20, CAKE);
+const cakeContract = getContract(bep20, CAKE);
+const veCakeContract = getContract(veCake, VECAKE);
 const lockedCakePoolContract = getContract(lockedCakePool, LOCKED_CAKE_POOL);
 
-export const getTotalSupply = async (): Promise<BigNumber> => {
-  const supply = await contract.methods.totalSupply().call();
+export const getTotalMint = async (): Promise<BigNumber> => {
+  const supply = await cakeContract.methods.totalSupply().call();
 
   return new BigNumber(supply);
 };
 
-export const getBurnedSupply = async (): Promise<BigNumber> => {
-  const balance = await contract.methods.balanceOf(DEAD).call();
+export const getDeadSupply = async (): Promise<BigNumber> => {
+  const balance = await cakeContract.methods.balanceOf(DEAD).call();
 
   return new BigNumber(balance);
 };
@@ -25,7 +27,7 @@ export const getLockedCake = async (): Promise<BigNumber> => {
 };
 
 export const getVeCakeLocked = async (): Promise<BigNumber> => {
-  const balance = await contract.methods.balanceOf(VECAKE).call();
+  const balance = await veCakeContract.methods.supply().call();
   return new BigNumber(balance);
 };