@gearbox-protocol/sdk 0.0.100 → 0.0.103

package/src/apy/convexAPY.ts

@@ -0,0 +1,250 @@
+import { BigNumber, providers } from "ethers";
+import axios from "axios";
+import {
+  ConvexPoolContract,
+  ConvexPoolParams,
+  contractsByNetwork,
+  contractParams,
+  CurvePoolContract
+} from "../contracts/contracts";
+
+import { tokenDataByNetwork, supportedTokens } from "../tokens/token";
+import { CurveLPToken } from "../tokens/curveLP";
+import { ConvexPhantomTokenData } from "../tokens/convex";
+
+import {
+  IBaseRewardPool__factory,
+  IBaseRewardPool,
+  IConvexToken__factory,
+  IConvexToken,
+  CurveV1AdapterStETH,
+  CurveV1AdapterStETH__factory
+} from "../types";
+
+import { multicall, MCall } from "../utils/multicall";
+import { toBN } from "../utils/formatter";
+import { AwaitedRes } from "../utils/types";
+
+import {
+  SECONDS_PER_YEAR,
+  WAD,
+  WAD_DECIMALS_POW,
+  NetworkType,
+  PRICE_DECIMALS
+} from "../core/constants";
+
+type SupportedPools = Extract<
+  ConvexPoolContract,
+  | "CONVEX_3CRV_POOL"
+  | "CONVEX_FRAX3CRV_POOL"
+  | "CONVEX_LUSD3CRV_POOL"
+  | "CONVEX_GUSD_POOL"
+  | "CONVEX_SUSD_POOL"
+>;
+
+type SupportedConvex = Extract<
+  CurvePoolContract,
+  | "CURVE_3CRV_POOL"
+  | "CURVE_FRAX_POOL"
+  | "CURVE_LUSD_POOL"
+  | "CURVE_GUSD_POOL"
+  | "CURVE_SUSD_POOL"
+>;
+
+const curveSwapByPool: Record<SupportedPools, SupportedConvex> = {
+  CONVEX_3CRV_POOL: "CURVE_3CRV_POOL",
+  CONVEX_FRAX3CRV_POOL: "CURVE_FRAX_POOL",
+  CONVEX_LUSD3CRV_POOL: "CURVE_LUSD_POOL",
+  CONVEX_GUSD_POOL: "CURVE_GUSD_POOL",
+  CONVEX_SUSD_POOL: "CURVE_SUSD_POOL"
+};
+
+export async function getConvexApy(
+  pool: SupportedPools,
+  provider: providers.Provider,
+  networkType: NetworkType,
+  getTokenPrice: (tokenAddress: string) => BigNumber
+) {
+  const tokenList = tokenDataByNetwork[networkType];
+  const contractsList = contractsByNetwork[networkType];
+
+  const poolParams = contractParams[pool] as ConvexPoolParams;
+  const stakedTokenParams = supportedTokens[
+    poolParams.stakedToken
+  ] as ConvexPhantomTokenData;
+
+  const { underlying } = stakedTokenParams;
+  const basePoolAddress = contractsList[pool];
+  const swapPoolAddress = contractsList[curveSwapByPool[pool]];
+  const cvxAddress = tokenList.CVX;
+
+  const extraPoolAddresses = poolParams.extraRewards.map(
+    d => d.poolAddress[networkType]
+  );
+
+  const [basePoolRate, basePoolSupply, vPrice, cvxSupply, ...extra] =
+    await getPoolData(
+      basePoolAddress,
+      swapPoolAddress,
+      cvxAddress,
+      extraPoolAddresses,
+      provider
+    );
+
+  const cvxPrice = getTokenPrice(tokenList.CVX);
+  const crvPrice = getTokenPrice(tokenList.CRV);
+
+  const crvPerSecond = basePoolRate;
+  const virtualSupply = basePoolSupply.mul(vPrice).div(WAD);
+  const crvPerUnderlying = crvPerSecond.mul(WAD).div(virtualSupply);
+
+  const crvPerYear = crvPerUnderlying.mul(SECONDS_PER_YEAR);
+  const cvxPerYear = getCVXMintAmount(crvPerYear, cvxSupply);
+
+  const crvAPY = crvPerYear.mul(cvxPrice).div(PRICE_DECIMALS);
+  const cvxAPY = cvxPerYear.mul(crvPrice).div(PRICE_DECIMALS);
+
+  const extraAPRs = await Promise.all(
+    extraPoolAddresses.map(async (_, index) => {
+      const extraRewardSymbol = poolParams.extraRewards[index].rewardToken;
+      const extraPoolRate = extra[index];
+
+      const perUnderlying = extraPoolRate.mul(WAD).div(virtualSupply);
+      const perYear = perUnderlying.mul(SECONDS_PER_YEAR);
+
+      const extraPrise = getTokenPrice(tokenList[extraRewardSymbol]);
+
+      const extraAPY = perYear.mul(extraPrise).div(PRICE_DECIMALS);
+
+      return extraAPY;
+    })
+  );
+
+  const extraAPYTotal = extraAPRs.reduce(
+    (acc, apy) => acc.add(apy),
+    BigNumber.from(0)
+  );
+
+  const baseApyRAY = await getCurveBaseApy(underlying);
+
+  return baseApyRAY.add(crvAPY).add(cvxAPY).add(extraAPYTotal);
+}
+
+const CVX_MAX_SUPPLY = WAD.mul(100000000);
+const CVX_REDUCTION_PER_CLIFF = BigNumber.from(100000);
+const CVX_TOTAL_CLIFFS = WAD.mul(1000);
+
+function getCVXMintAmount(crvAmount: BigNumber, cvxSupply: BigNumber) {
+  const currentCliff = cvxSupply.div(CVX_REDUCTION_PER_CLIFF);
+
+  if (currentCliff.lt(CVX_TOTAL_CLIFFS)) {
+    const remainingCliffs = CVX_TOTAL_CLIFFS.sub(currentCliff);
+
+    const mintedAmount = crvAmount.mul(remainingCliffs).div(CVX_TOTAL_CLIFFS);
+
+    const amountTillMax = CVX_MAX_SUPPLY.sub(cvxSupply);
+
+    return mintedAmount.gt(amountTillMax) ? amountTillMax : mintedAmount;
+  }
+
+  return BigNumber.from(0);
+}
+
+type IBaseRewardPoolInterface = IBaseRewardPool["interface"];
+type IConvexTokenInterface = IConvexToken["interface"];
+type CurveV1AdapterStETHInterface = CurveV1AdapterStETH["interface"];
+
+async function getPoolData(
+  basePoolAddress: string,
+  underlying: string,
+  cvxAddress: string,
+  extraPoolAddresses: string[],
+  provider: providers.Provider
+) {
+  const calls: [
+    MCall<IBaseRewardPoolInterface>,
+    MCall<IBaseRewardPoolInterface>,
+    MCall<CurveV1AdapterStETHInterface>,
+    MCall<IConvexTokenInterface>,
+    ...Array<MCall<IBaseRewardPoolInterface>>
+  ] = [
+    {
+      address: basePoolAddress,
+      interface: IBaseRewardPool__factory.createInterface(),
+      method: "rewardRate()"
+    },
+    {
+      address: basePoolAddress,
+      interface: IBaseRewardPool__factory.createInterface(),
+      method: "totalSupply()"
+    },
+    {
+      address: underlying,
+      interface: CurveV1AdapterStETH__factory.createInterface(),
+      method: "get_virtual_price()"
+    },
+    {
+      address: cvxAddress,
+      interface: IConvexToken__factory.createInterface(),
+      method: "totalSupply()"
+    },
+    ...extraPoolAddresses.map(
+      (extraPoolAddress): MCall<IBaseRewardPoolInterface> => ({
+        address: extraPoolAddress,
+        interface: IBaseRewardPool__factory.createInterface(),
+        method: "rewardRate()"
+      })
+    )
+  ];
+
+  return multicall<
+    [
+      AwaitedRes<IBaseRewardPool["rewardRate"]>,
+      AwaitedRes<IBaseRewardPool["totalSupply"]>,
+      AwaitedRes<CurveV1AdapterStETH["get_virtual_price"]>,
+      AwaitedRes<IConvexToken["totalSupply"]>,
+      ...Array<AwaitedRes<IBaseRewardPool["rewardRate"]>>
+    ]
+  >(calls, provider);
+}
+
+interface CurveAPRData {
+  baseApy: number;
+  crvApy: number;
+  crvBoost: number;
+  crvPrice: number;
+}
+
+interface APYResponse {
+  apys: Record<string, CurveAPRData>;
+}
+
+const curveLPTokenToPoolName: Record<CurveLPToken, string> = {
+  "3Crv": "3pool",
+  FRAX3CRV: "frax",
+  gusd3CRV: "gusd",
+  LUSD3CRV: "lusd",
+  crvPlain3andSUSD: "susdv2",
+  steCRV: "steth"
+};
+
+const RESPONSE_DECIMALS = 100;
+
+// https://www.convexfinance.com/api/curve-apys
+
+export async function getCurveBaseApy(
+  curveLPToken: CurveLPToken
+): Promise<BigNumber> {
+  const poolName = curveLPTokenToPoolName[curveLPToken];
+
+  try {
+    const url = "https://www.convexfinance.com/api/curve-apys";
+    const result = await axios.get<APYResponse>(url);
+
+    const { baseApy = 0 } = result.data.apys[poolName] || {};
+
+    return toBN((baseApy / RESPONSE_DECIMALS).toString(), WAD_DECIMALS_POW);
+  } catch (e) {
+    return BigNumber.from(0);
+  }
+}

package/src/apy/lidoAPY.ts

@@ -0,0 +1,89 @@
+import { providers } from "ethers";
+
+import { multicall, MCall } from "../utils/multicall";
+import { contractParams, LidoParams } from "../contracts/contracts";
+import { tokenDataByNetwork } from "../tokens/token";
+
+import { WAD, SECONDS_PER_YEAR, NetworkType } from "../core/constants";
+
+import {
+  ILidoOracle__factory,
+  ILidoOracle,
+  IstETH__factory,
+  IstETH
+} from "../types";
+
+type ILidoOracleInterface = ILidoOracle["interface"];
+
+type IstETHInterface = IstETH["interface"];
+
+const lidoOracles = (contractParams.LIDO_STETH_GATEWAY as LidoParams).oracle;
+
+const lidoStEth: Record<NetworkType, string> = {
+  Mainnet: tokenDataByNetwork.Mainnet.STETH,
+  Kovan: tokenDataByNetwork.Kovan.STETH
+};
+
+export async function getLidoApy(
+  provider: providers.Provider,
+  networkType: NetworkType
+) {
+  if (!lidoOracles[networkType]) {
+    throw new Error(
+      `No Lido APR oracle found on current network: ${networkType}`
+    );
+  }
+  if (!lidoStEth[networkType]) {
+    throw new Error(`No Lido stETH found on current network: ${networkType}`);
+  }
+
+  const [{ postTotalPooledEther, preTotalPooledEther, timeElapsed }, fee] =
+    await geLidoData(
+      lidoOracles[networkType],
+      lidoStEth[networkType],
+      provider,
+      networkType
+    );
+
+  const lidoAPRRay = postTotalPooledEther
+    .sub(preTotalPooledEther)
+    .mul(SECONDS_PER_YEAR)
+    .mul(WAD)
+    .div(preTotalPooledEther.mul(timeElapsed));
+
+  return [lidoAPRRay, fee] as const;
+}
+
+export const LIDO_FEE_DECIMALS = 10000;
+
+async function geLidoData(
+  lidoOracleAddress: string,
+  stETHAddress: string,
+  provider: providers.Provider,
+  network: NetworkType
+) {
+  const calls: [MCall<ILidoOracleInterface>, ...Array<MCall<IstETHInterface>>] =
+    [
+      {
+        address: lidoOracleAddress,
+        interface: ILidoOracle__factory.createInterface(),
+        method: "getLastCompletedReportDelta()"
+      }
+    ];
+
+  if (network !== "Kovan")
+    calls.push({
+      address: stETHAddress,
+      interface: IstETH__factory.createInterface(),
+      method: "getFee()"
+    });
+
+  const [stats, fee = Math.floor(LIDO_FEE_DECIMALS / 10)] = await multicall<
+    [
+      Awaited<ReturnType<ILidoOracle["getLastCompletedReportDelta"]>>,
+      Awaited<ReturnType<IstETH["getFee"]>>
+    ]
+  >(calls, provider);
+
+  return [stats, fee] as const;
+}

package/src/config.ts

@@ -1 +1,2 @@
-export const STATIC_TOKEN = "https://static.gearbox.fi/tokens/"
+export const STATIC_TOKEN = "https://static.gearbox.fi/tokens/";
+export const MULTICALL_ADDRESS = "0x5ba1e12693dc8f9c48aad8770482f4739beed696";

package/src/contracts/contracts.ts

@@ -3,14 +3,19 @@
  * Gearbox. Generalized leverage protocol, which allows to take leverage and then use it across other DeFi protocols and platforms in a composable way.
  * (c) Gearbox.fi, 2021
  */
-import { keyToLowercase, objectEntries, swapKeyValue } from "../utils/mappers";
+import {
+  keyToLowercase,
+  objectEntries,
+  swapKeyValue,
+  filterEmptyKeys
+} from "../utils/mappers";
 import { AdapterInterface } from "./adapters";
 import { NetworkType } from "../core/constants";
 import { Protocols } from "./protocols";
 import { tokenDataByNetwork } from "../tokens/token";
-import { ConvexStakedPhantomToken } from "../tokens/convex";
-import { CurveLPToken } from "../tokens/curveLP";
-import { NormalToken } from "../tokens/normal";
+import type { ConvexStakedPhantomToken } from "../tokens/convex";
+import type { CurveLPToken } from "../tokens/curveLP";
+import type { NormalToken } from "../tokens/normal";
 
 export type UniswapV2Contract = "UNISWAP_V2_ROUTER" | "SUSHISWAP_ROUTER";
 
@@ -179,10 +184,16 @@ type ConvexParams = {
     | AdapterInterface.CONVEX_V1_CLAIM_ZAP;
 } & BaseContractParams;
 
-type ConvexPoolParams = {
+type ConvexExtraPoolParams = {
+  rewardToken: NormalToken;
+  poolAddress: Record<NetworkType, string>;
+};
+
+export type ConvexPoolParams = {
   protocol: Protocols.Convex;
   type: AdapterInterface.CONVEX_V1_BASE_REWARD_POOL;
   stakedToken: ConvexStakedPhantomToken;
+  extraRewards: Array<ConvexExtraPoolParams>;
 } & BaseContractParams;
 
 export type LidoParams = {
@@ -314,46 +325,85 @@ export const contractParams: Record<SupportedContract, ContractParams> = {
     protocol: Protocols.Convex,
     type: AdapterInterface.CONVEX_V1_BOOSTER
   },
+  CONVEX_CLAIM_ZAP: {
+    name: "Convex ZAP",
+    protocol: Protocols.Convex,
+    type: AdapterInterface.CONVEX_V1_CLAIM_ZAP
+  },
+
   CONVEX_3CRV_POOL: {
     name: "Convex 3crv",
     protocol: Protocols.Convex,
     type: AdapterInterface.CONVEX_V1_BASE_REWARD_POOL,
-    stakedToken: "stkcvx3Crv"
+    stakedToken: "stkcvx3Crv",
+    extraRewards: []
   },
   CONVEX_GUSD_POOL: {
     name: "Convex GUSD",
     protocol: Protocols.Convex,
     type: AdapterInterface.CONVEX_V1_BASE_REWARD_POOL,
-    stakedToken: "stkcvxgusd3CRV"
+    stakedToken: "stkcvxgusd3CRV",
+    extraRewards: []
   },
   CONVEX_SUSD_POOL: {
     name: "Convex SUSD",
     protocol: Protocols.Convex,
     type: AdapterInterface.CONVEX_V1_BASE_REWARD_POOL,
-    stakedToken: "stkcvxcrvPlain3andSUSD"
+    stakedToken: "stkcvxcrvPlain3andSUSD",
+    extraRewards: [
+      {
+        rewardToken: "SNX",
+        poolAddress: {
+          Mainnet: "0x81fCe3E10D12Da6c7266a1A169c4C96813435263",
+          Kovan: "0x26a535146557FA58FA37e3078FEAc523b554939C"
+        }
+      }
+    ]
   },
   CONVEX_STECRV_POOL: {
     name: "Convex STECRV",
     protocol: Protocols.Convex,
     type: AdapterInterface.CONVEX_V1_BASE_REWARD_POOL,
-    stakedToken: "stkcvxsteCRV"
+    stakedToken: "stkcvxsteCRV",
+    extraRewards: [
+      {
+        rewardToken: "LDO",
+        poolAddress: {
+          Mainnet: "0x008aEa5036b819B4FEAEd10b2190FBb3954981E8",
+          Kovan: "0xd0B1CC3B4839363b1eC92F35eF45794CB07B1183"
+        }
+      }
+    ]
   },
   CONVEX_FRAX3CRV_POOL: {
     name: "Convex FRAX3CRV",
     protocol: Protocols.Convex,
     type: AdapterInterface.CONVEX_V1_BASE_REWARD_POOL,
-    stakedToken: "stkcvxFRAX3CRV"
+    stakedToken: "stkcvxFRAX3CRV",
+    extraRewards: [
+      {
+        rewardToken: "FXS",
+        poolAddress: {
+          Mainnet: "0xcDEC6714eB482f28f4889A0c122868450CDBF0b0",
+          Kovan: "0x89869c2e79FC6EFf51e714F1239D53702B5CDFCD"
+        }
+      }
+    ]
   },
   CONVEX_LUSD3CRV_POOL: {
     name: "Convex LUSD3CRV",
     protocol: Protocols.Convex,
     type: AdapterInterface.CONVEX_V1_BASE_REWARD_POOL,
-    stakedToken: "stkcvxLUSD3CRV"
-  },
-  CONVEX_CLAIM_ZAP: {
-    name: "Convex ZAP",
-    protocol: Protocols.Convex,
-    type: AdapterInterface.CONVEX_V1_CLAIM_ZAP
+    stakedToken: "stkcvxLUSD3CRV",
+    extraRewards: [
+      {
+        rewardToken: "LQTY",
+        poolAddress: {
+          Mainnet: "0x55d59b791f06dc519B176791c4E037E8Cf2f6361",
+          Kovan: ""
+        }
+      }
+    ]
   },
 
   LIDO_STETH_GATEWAY: {
@@ -370,6 +420,10 @@ export const contractParams: Record<SupportedContract, ContractParams> = {
 
 export const contractsByAddress = objectEntries(contractsByNetwork).reduce<
   Record<string, SupportedContract>
->((sum, [_, contracts]) => {
-  return { ...sum, ...keyToLowercase(swapKeyValue(contracts)) };
-}, {});
+>(
+  (acc, [, contracts]) => ({
+    ...acc,
+    ...filterEmptyKeys(keyToLowercase(swapKeyValue(contracts)))
+  }),
+  {}
+);

package/src/contracts/contractsRegister.ts

@@ -27,19 +27,34 @@ export const deployedContracts: Record<string, string> = {
   "0xe04b4db67127d1930D36f16B51653120C4285708": "WBTC",
   "0x600073357c29d169aAF3E543A4519749830553F1": "WETH",
   "0xdBAd1361d9A03B81Be8D3a54Ef0dc9e39a1bA5b3": "USDC",
-  "0x50d1fA47b0D88BA0D108148B8481b4A762eFB99e": "DAI"
+  "0x50d1fA47b0D88BA0D108148B8481b4A762eFB99e": "DAI",
   // [YEARN_DAI_VAULT_KOVAN_MOCK]: "Yearn DAI",
   // [YEARN_USDC_VAULT_KOVAN_MOCK]: "Yearn USDC",
   // [SUSHISWAP_KOVAN]: "Sushiswap"
+
+  "0x94cd5F09727ae04d7D6fd36A9c9DD96D0d54646B": "DAI",
+  "0x53B4a7389EA369a9299DfF524f916EC3cB77ffF4": "USDC",
+  "0xE6631f7b18744651A385a02ea2C89634d20D7819": "WETH",
+  "0x4d2cBA0E43Ad3B3E1C3B1922fe6E8e910b8C3ae0": "WBTC",
+
+  "0x6Ae9Ed829AF469Df9526FA7443E876bfaBC79eff": "DAI V2",
+  "0x8E0a874E3475de1C16490E386b7E2904CdC03086": "USDC V2",
+  "0x816a74B75D60839247C848518545fb17cedDC460": "WETH V2",
+
+  // pools
+  "0xA7b1C8f322596C40A04dBd3DffaE37a0849B8b59": "DAI",
+  "0xb8ecDB926F07FCbd870eafE72d116413A0BEb236": "USDC",
+  "0xAda6b2747295b2ba6ba52ce2d0D5e681D25D63D8": "WETH",
+  "0x85c54CCCf27466eEa1C74a73F75CbE385C271EE4": "WBTC"
 };
 
 const contractNames = Object.entries(contractsByAddress).reduce<
   Record<string, string>
->((sum, [addr, cSymbol]) => {
+>((acc, [addr, cSymbol]) => {
   const params = contractParams[cSymbol];
-  if (!params) return sum;
+  if (!params) return acc;
 
-  return { ...sum, [addr]: params.name };
+  return { ...acc, [addr]: params.name };
 }, {});
 
 const contractsFullList = {

package/src/core/constants.ts

@@ -22,12 +22,18 @@ export const getNetworkType = (chainId: number): NetworkType => {
   }
 };
 
-export const RAY = BigNumber.from(10).pow(27);
+export const RAY_DECIMALS_POW = 27;
+export const RAY = BigNumber.from(10).pow(RAY_DECIMALS_POW);
 export const halfRAY = RAY.div(2);
-export const WAD = BigNumber.from(10).pow(18);
+export const WAD_DECIMALS_POW = 18;
+export const WAD = BigNumber.from(10).pow(WAD_DECIMALS_POW);
+
+export const PRICE_DECIMALS_POW = 8;
+export const PRICE_DECIMALS = BigNumber.from(10).pow(PRICE_DECIMALS_POW);
 
 export const SECONDS_PER_YEAR = 365 * 24 * 3600;
 
+export const PERCENTAGE_DECIMALS = 100;
 export const PERCENTAGE_FACTOR = 1e4;
 export const LIQUIDATION_DISCOUNTED_SUM = 9500;
 export const UNDERLYING_TOKEN_LIQUIDATION_THRESHOLD = 9300;
@@ -37,8 +43,9 @@ export const timeRanges: Record<string, number> = {
   "1D": 3600 * 24,
   "1W": 3600 * 24 * 7,
   "1M": 3600 * 24 * 30,
-  "1Y": 3600 * 24 * 365,
+  "1Y": 3600 * 24 * 365
 };
 
 export const LEVERAGE_DECIMALS = 100;
-export const ADDRESS_0x0 = "0x0000000000000000000000000000000000000000";
+export const SLIPPAGE_DECIMALS = 100;
+export const ADDRESS_0X0 = "0x0000000000000000000000000000000000000000";