Merge pull request #431 from keep-network/apy-calc

Connect new Keep website staking information

Author: Battenfield

jest.config.js

@@ -0,0 +1,9 @@
+/*
+ * For a detailed explanation regarding each configuration property, visit:
+ * https://jestjs.io/docs/en/configuration.html
+ */
+
+module.exports = {
+  testEnvironment: "node",
+  testRegex: "(src/__tests__/.*|(\\.|/)(test|spec))\\.[jt]sx?$",
+}

package-lock.json

@@ -6,8 +6,10 @@
   "dependencies": {
     "aos": "^2.3.4",
     "axios": "^0.21.1",
+    "bignumber.js": "^9.0.1",
     "bootstrap-css-only": "^4.4.1",
     "bulma": "^0.8.0",
+    "ethers": "^5.1.4",
     "gatsby": "^2.13.31",
     "gatsby-image": "^2.0.23",
     "gatsby-plugin-favicon": "^3.1.6",
@@ -23,6 +25,7 @@
     "gatsby-source-filesystem": "^2.0.26",
     "gatsby-transformer-remark": "^2.6.9",
     "gatsby-transformer-sharp": "^2.1.9",
+    "jest": "^26.6.3",
     "lodash": "^4.17.19",
     "lodash-webpack-plugin": "^0.11.4",
     "netlify-cms-app": "^2.9.6",
@@ -55,7 +58,7 @@
     "build:prefixed": "npm run clean && gatsby build --prefix-paths",
     "develop": "npm run clean && gatsby develop",
     "format": "prettier --trailing-comma es5 --no-semi --single-quote --write \"{gatsby-*.js,src/**/*.js}\"",
-    "test": "echo \"Error: no test specified\" && exit 1",
+    "test": "jest",
     "lint": "eslint src/ gatsby-*.js",
     "lint:fix": "eslint --fix src/ gatsby-*.js"
   },
@@ -65,7 +68,10 @@
     "not op_mini all"
   ],
   "devDependencies": {
+    "@babel/core": "^7.14.3",
+    "@babel/preset-env": "^7.14.2",
     "babel-eslint": "^10.1.0",
+    "babel-jest": "^26.6.3",
     "eslint": "^6.8.0",
     "eslint-config-keep": "git+https://github.com/keep-network/eslint-config-keep.git#0.3.0",
     "eslint-plugin-react": "^7.19.0",

package.json

@@ -0,0 +1,68 @@
+import { useEffect, useState } from "react"
+
+import LiquidityRewardsFactory, {
+  SUPPORTED_LIQUIDITY_POOLS,
+} from "../lib/liquidity-rewards"
+
+const liquidityRewardsKEEPETH = LiquidityRewardsFactory.create(
+  SUPPORTED_LIQUIDITY_POOLS.KEEP_ETH
+)
+const liquidityRewardsTBTCSaddle = LiquidityRewardsFactory.create(
+  SUPPORTED_LIQUIDITY_POOLS.TBTC_SADDLE
+)
+
+const liquidityRewardsTBTCETH = LiquidityRewardsFactory.create(
+  SUPPORTED_LIQUIDITY_POOLS.TBTC_ETH
+)
+const liquidityRewardsKEEP = LiquidityRewardsFactory.create(
+  SUPPORTED_LIQUIDITY_POOLS.KEEP
+)
+
+const useLiquidityRewardsAPY = () => {
+  const [isFetching, setIsFetching] = useState(true)
+  const [liquidityRewardsAPYs, setLiquidityRewardsAPYs] = useState([])
+  const [error, setError] = useState(null)
+
+  useEffect(() => {
+    let shouldSetState = true
+
+    setIsFetching(true)
+    Promise.all([
+      liquidityRewardsKEEPETH.calculateAPY(),
+      liquidityRewardsTBTCSaddle.calculateAPY(),
+      liquidityRewardsTBTCETH.calculateAPY(),
+      liquidityRewardsKEEP.calculateAPY(),
+    ])
+      .then(([apyKEEPETH, apyTBTCSaddle, apyTBTCETH, apyKEEP]) => {
+        if (shouldSetState) {
+          setLiquidityRewardsAPYs(
+            [
+              { value: apyKEEPETH, pool: "KEEP/ETH" },
+              { value: apyTBTCSaddle, pool: "TBTC/SADDLE" },
+              { value: apyTBTCETH, pool: "TBTC/ETH" },
+              { value: apyKEEP, pool: "KEEP" },
+            ].sort((a, b) => b.value - a.value)
+          )
+          setIsFetching(false)
+        }
+      })
+      .catch((error) => {
+        if (shouldSetState) {
+          setIsFetching(false)
+          setError(error)
+        }
+        console.log(
+          "Unexpected error while fetching liquidity rewards APY:",
+          error
+        )
+      })
+
+    return () => {
+      shouldSetState = false
+    }
+  }, [])
+
+  return [liquidityRewardsAPYs, isFetching, error]
+}
+
+export default useLiquidityRewardsAPY

src/hooks/useLiquidityRewardsAPY.js

@@ -0,0 +1,103 @@
+import axios from "axios"
+import BigNumber from "bignumber.js"
+
+import {
+  BaseExchangeService,
+  UniswapExchangeService,
+} from "../exchange-service"
+
+jest.mock("axios")
+
+describe("Test exchange service", () => {
+  describe("Test BaseExchangeService", () => {
+    const exchange = new BaseExchangeService()
+    exchange._getUniswapPairData = jest.fn()
+    exchange._getKeepTokenPriceInUSD = jest.fn()
+    exchange._getBTCPriceInUSD = jest.fn()
+    const mockedPairId = 1
+
+    test("should call function that implements fetching uniswap pair data", () => {
+      exchange.getUniswapPairData(mockedPairId)
+
+      expect(exchange._getUniswapPairData).toHaveBeenCalledWith(mockedPairId)
+    })
+
+    test("should call function that implements fetching KEEP token price", () => {
+      exchange.getKeepTokenPriceInUSD()
+
+      expect(exchange._getKeepTokenPriceInUSD).toHaveBeenCalled()
+    })
+
+    test("should call function that implements fetching BTC price", () => {
+      exchange.getBTCPriceInUSD()
+
+      expect(exchange._getBTCPriceInUSD).toHaveBeenCalled()
+    })
+  })
+
+  describe("Test UniswapExchangeService", () => {
+    const exchange = new UniswapExchangeService()
+    const mockedPairId = 1
+
+    const mockedResponse = {
+      data: {
+        data: {
+          pair: {
+            reserveUSD: 30000,
+            reserveETH: 1000,
+            token0: {
+              derivedETH: 0.2,
+            },
+          },
+        },
+      },
+    }
+
+    test("should fetch uniswap pair data correctly", async () => {
+      axios.post.mockResolvedValue(mockedResponse)
+
+      const result = await exchange.getUniswapPairData(mockedPairId)
+
+      const mockCalls = axios.post.mock.calls
+      expect(axios.post).toHaveBeenCalled()
+      expect(mockCalls[0][0]).toEqual(exchange.UNISWAP_API_URL)
+      expect(
+        mockCalls[0][1].query.toString().includes(mockedPairId)
+      ).toBeTruthy()
+
+      expect(result).toStrictEqual(mockedResponse.data.data.pair)
+    })
+
+    test("should fetch keep token price correctly", async () => {
+      const spy = jest.spyOn(exchange, "_getTokenPriceInUSD")
+      const getUniswapPairDataSpy = jest.spyOn(exchange, "_getUniswapPairData")
+      axios.post.mockResolvedValue(mockedResponse)
+      const pairData = mockedResponse.data.data.pair
+      const expectedPrice = new BigNumber(pairData.reserveUSD)
+        .div(pairData.reserveETH)
+        .multipliedBy(pairData.token0.derivedETH)
+
+      const result = await exchange.getKeepTokenPriceInUSD()
+
+      expect(spy).toHaveBeenCalledWith(
+        "0xe6f19dab7d43317344282f803f8e8d240708174a"
+      )
+      expect(getUniswapPairDataSpy).toHaveBeenCalledWith(
+        "0xe6f19dab7d43317344282f803f8e8d240708174a"
+      )
+      expect(result).toEqual(expectedPrice)
+    })
+
+    test("should fetch BTC price correctly", () => {
+      const spy = jest
+        .spyOn(exchange, "_getTokenPriceInUSD")
+        .mockResolvedValue("300")
+
+      exchange.getBTCPriceInUSD()
+
+      expect(spy).toHaveBeenCalledWith(
+        "0xe6f19dab7d43317344282f803f8e8d240708174a"
+      )
+    })
+  })
+})

src/lib/liquidity-rewards/__tests__/exchange-service.test.js

@@ -0,0 +1,100 @@
+import { Contract, providers } from "ethers"
+import BigNumber from "bignumber.js"
+
+import {
+  LiquidityRewards,
+  LiquidityRewardsFactory,
+  LiquidityRewardsUniswap,
+} from "../liquidity-rewards"
+import { Token } from "../utils"
+import LPRewardsKEEPETH from "../abis/LPRewardsKEEPETH.json"
+import { UniswapExchangeService } from "../exchange-service"
+
+jest.mock("ethers")
+
+jest.mock("../abis/LPRewardsKEEPETH.json", () => ({
+  abi: [],
+  networks: {
+    1: {
+      address: "0x0",
+    },
+  },
+}))
+
+describe("Test LiquidityRewards", () => {
+  describe("Test base LiquidityRewards", () => {
+    const liquidityRewards = new LiquidityRewards(
+      {},
+      { getKeepTokenPriceInUSD: () => {} }
+    )
+    const mockedTotalSupply = Token.fromTokenUnit(100000)
+    const mockedRewarPoolPerWeek = "30000"
+    const mockedTotalSupplyInUSD = "50000"
+    const mockedKeepTokenPriceInUSD = new BigNumber("0.55")
+    liquidityRewards._totalSupply = jest
+      .fn()
+      .mockResolvedValue(mockedTotalSupply)
+    liquidityRewards._rewardPoolPerWeek = jest
+      .fn()
+      .mockResolvedValue(mockedRewarPoolPerWeek)
+    liquidityRewards._totalSupplyInUSD = jest
+      .fn()
+      .mockResolvedValue(mockedTotalSupplyInUSD)
+
+    const exchangeSpy = jest
+      .spyOn(liquidityRewards.exchangeSercvice, "getKeepTokenPriceInUSD")
+      .mockResolvedValue(mockedKeepTokenPriceInUSD)
+    const calculateRSpy = jest.spyOn(liquidityRewards, "_calculateR")
+    const calculateAPYSpy = jest.spyOn(liquidityRewards, "_calculateAPY")
+
+    test("should correctly calculate APY", async () => {
+      const result = await liquidityRewards.calculateAPY()
+
+      expect(liquidityRewards._totalSupply).toHaveBeenCalled()
+      expect(liquidityRewards._rewardPoolPerWeek).toHaveBeenCalled()
+      expect(liquidityRewards._totalSupplyInUSD).toHaveBeenCalledWith(
+        mockedTotalSupply.toString()
+      )
+      expect(exchangeSpy).toHaveBeenCalled()
+      expect(calculateRSpy).toHaveBeenCalledWith(
+        mockedKeepTokenPriceInUSD,
+        mockedRewarPoolPerWeek,
+        mockedTotalSupplyInUSD
+      )
+
+      const expectedR = new BigNumber(mockedKeepTokenPriceInUSD)
+        .multipliedBy(mockedRewarPoolPerWeek)
+        .div(mockedTotalSupplyInUSD)
+
+      expect(calculateAPYSpy).toHaveBeenCalledWith(expectedR, 52)
+
+      const expectedAPY = expectedR
+        .plus(1)
+        .pow(52)
+        .minus(1)
+        .multipliedBy(100)
+        .decimalPlaces(2, BigNumber.ROUND_DOWN)
+        .toString()
+
+      expect(result).toEqual(expectedAPY)
+    })
+  })
+
+  describe("Test LiquidityRewards factory", () => {
+    test("should create the liquidity rewards pool wrapper correctly", () => {
+      const liquidityRewards = LiquidityRewardsFactory.create("KEEP_ETH")
+      const mockContractCalls = Contract.mock.calls
+      expect(Contract).toHaveBeenCalled()
+      expect(mockContractCalls[0][0]).toEqual(
+        LPRewardsKEEPETH.networks[1].address
+      )
+      expect(mockContractCalls[0][1]).toEqual(LPRewardsKEEPETH.abi)
+
+      expect(liquidityRewards).toBeInstanceOf(LiquidityRewardsUniswap)
+      expect(liquidityRewards.exchangeSercvice).toBeInstanceOf(
+        UniswapExchangeService
+      )
+      expect(liquidityRewards.contract).toBeInstanceOf(Contract)
+    })
+  })
+})