@gearbox-protocol/sdk 0.0.98 → 0.0.101

package/src/core/multicall.ts

@@ -1,6 +1,6 @@
 import { BytesLike } from "ethers";
 
 export interface MultiCall {
-  targetContract: string;
+  target: string;
   callData: BytesLike;
 }

package/src/core/pool.ts

@@ -1,64 +1,69 @@
-import {BigNumber, Signer} from "ethers";
-import {IPoolService, IPoolService__factory} from "../types";
-import {PoolDataPayload} from "../payload/pool";
-import {rayToNumber} from "../utils/formatter";
+import { BigNumber, Signer } from "ethers";
+
+import { PoolDataPayload } from "../payload/pool";
+import { rayToNumber } from "../utils/formatter";
+
+import { IPoolService, IPoolService__factory } from "../types";
+
+import { PERCENTAGE_DECIMALS } from "./constants";
 
 export class PoolData {
-    public readonly id: string;
-    public readonly address: string;
+  public readonly id: string;
+  public readonly address: string;
 
-    public readonly underlyingToken: string;
-    public readonly dieselToken: string;
-    public readonly isWETH: boolean;
+  public readonly underlyingToken: string;
+  public readonly dieselToken: string;
+  public readonly isWETH: boolean;
 
-    // Information
-    public readonly expectedLiquidity: BigNumber;
-    public readonly expectedLiquidityLimit: BigNumber;
-    public readonly availableLiquidity: BigNumber;
-    public readonly totalBorrowed: BigNumber;
-    public readonly depositAPY: number;
-    public readonly borrowAPY: number;
-    public readonly borrowAPYRay: BigNumber;
-    public readonly dieselRate: number;
-    public readonly dieselRateRay: BigNumber;
-    public readonly withdrawFee: number;
-    public readonly timestampLU: BigNumber;
-    public readonly cumulativeIndex_RAY: BigNumber;
+  // Information
+  public readonly expectedLiquidity: BigNumber;
+  public readonly expectedLiquidityLimit: BigNumber;
+  public readonly availableLiquidity: BigNumber;
+  public readonly totalBorrowed: BigNumber;
+  public readonly depositAPY: number;
+  public readonly borrowAPY: number;
+  public readonly borrowAPYRay: BigNumber;
+  public readonly dieselRate: number;
+  public readonly dieselRateRay: BigNumber;
+  public readonly withdrawFee: number;
+  public readonly timestampLU: BigNumber;
+  public readonly cumulativeIndex_RAY: BigNumber;
 
-    constructor(payload: PoolDataPayload) {
-        this.id = payload.addr;
-        this.address = payload.addr;
-        this.underlyingToken = payload.underlyingToken || "";
-        this.dieselToken = payload.dieselToken || "";
+  constructor(payload: PoolDataPayload) {
+    this.id = payload.addr;
+    this.address = payload.addr;
+    this.underlyingToken = payload.underlying || "";
+    this.dieselToken = payload.dieselToken || "";
 
-        this.isWETH = payload.isWETH || false;
+    this.isWETH = payload.isWETH || false;
 
-        this.expectedLiquidity = BigNumber.from(payload.expectedLiquidity);
-        this.expectedLiquidityLimit = BigNumber.from(
-            payload.expectedLiquidityLimit || 0
-        );
-        this.availableLiquidity = BigNumber.from(payload.availableLiquidity);
-        this.totalBorrowed = BigNumber.from(payload.totalBorrowed);
-        this.depositAPY = rayToNumber(payload.depositAPY_RAY) * 100;
-        this.borrowAPY = rayToNumber(payload.borrowAPY_RAY) * 100;
-        this.borrowAPYRay = BigNumber.from(payload.borrowAPY_RAY);
-        this.dieselRate = rayToNumber(payload.dieselRate_RAY);
-        this.dieselRateRay = BigNumber.from(payload.dieselRate_RAY);
-        this.withdrawFee = BigNumber.from(payload.withdrawFee).toNumber() / 100;
-        this.timestampLU = BigNumber.from(payload.timestampLU || 0);
-        this.cumulativeIndex_RAY = BigNumber.from(payload.cumulativeIndex_RAY || 0);
-    }
+    this.expectedLiquidity = BigNumber.from(payload.expectedLiquidity);
+    this.expectedLiquidityLimit = BigNumber.from(
+      payload.expectedLiquidityLimit || 0
+    );
+    this.availableLiquidity = BigNumber.from(payload.availableLiquidity);
+    this.totalBorrowed = BigNumber.from(payload.totalBorrowed);
+    this.depositAPY = rayToNumber(payload.depositAPY_RAY) * PERCENTAGE_DECIMALS;
+    this.borrowAPY = rayToNumber(payload.borrowAPY_RAY) * PERCENTAGE_DECIMALS;
+    this.borrowAPYRay = BigNumber.from(payload.borrowAPY_RAY);
+    this.dieselRate = rayToNumber(payload.dieselRate_RAY);
+    this.dieselRateRay = BigNumber.from(payload.dieselRate_RAY);
+    this.withdrawFee =
+      BigNumber.from(payload.withdrawFee).toNumber() / PERCENTAGE_DECIMALS;
+    this.timestampLU = BigNumber.from(payload.timestampLU || 0);
+    this.cumulativeIndex_RAY = BigNumber.from(payload.cumulativeIndex_RAY || 0);
+  }
 
-    getContractETH(signer: Signer): IPoolService {
-        return IPoolService__factory.connect(this.address, signer);
-    }
+  getContractETH(signer: Signer): IPoolService {
+    return IPoolService__factory.connect(this.address, signer);
+  }
 
-    get isPaused(): boolean {
-        return false;
-    }
+  get isPaused(): boolean {
+    return false;
+  }
 }
 
 export interface PoolsStat {
-    tvl: number;
-    totalBorrowed: number;
+  tvl: number;
+  totalBorrowed: number;
 }

package/src/core/price.ts

@@ -0,0 +1,16 @@
+import { BigNumber } from "ethers";
+import { TokenData } from "../tokens/tokenData";
+
+export const PRICE_DECIMALS = 1000;
+
+export const priceCalc = (
+  price: number,
+  amount: BigNumber,
+  token: TokenData | undefined
+) => {
+  const { decimals = 18 } = token || {};
+
+  return amount
+    .mul(Math.floor(PRICE_DECIMALS * price))
+    .div(BigNumber.from(10).pow(decimals));
+};

package/src/core/strategy.ts

@@ -0,0 +1,123 @@
+import { LEVERAGE_DECIMALS } from "../core/constants";
+
+export interface StrategyPayload {
+  apy?: number;
+
+  name: string;
+  lpToken: string;
+  pools: Array<string>;
+
+  unleveragableCollateral: Array<string>;
+  leveragableCollateral: Array<string>;
+
+  baseAssets: Array<string>;
+}
+
+interface PoolStats {
+  borrowRate: number;
+}
+
+type PoolList = Record<string, PoolStats>;
+
+export class Strategy {
+  apy: number | undefined;
+
+  name: string;
+  lpToken: string;
+  pools: Array<string>;
+
+  unleveragableCollateral: Array<string>;
+  leveragableCollateral: Array<string>;
+
+  baseAssets: Array<string>;
+
+  constructor(payload: StrategyPayload) {
+    this.apy = payload.apy;
+
+    this.name = payload.name;
+    this.lpToken = payload.lpToken;
+    this.pools = payload.pools;
+    this.unleveragableCollateral = payload.unleveragableCollateral;
+    this.leveragableCollateral = payload.leveragableCollateral;
+    this.baseAssets = payload.baseAssets;
+  }
+
+  public roiMax(apy: number, maxLeverage: number, poolApy: PoolList) {
+    const minApy = this.minBorrowApy(poolApy);
+
+    return this.roi(apy, maxLeverage, maxLeverage - LEVERAGE_DECIMALS, minApy);
+  }
+
+  public overallAPY(
+    apy: number,
+    leverage: number,
+    depositCollateral: string,
+    borrowAPY: number
+  ) {
+    const farmLev = this.farmLev(leverage, depositCollateral);
+
+    return this.roi(apy, farmLev, leverage - LEVERAGE_DECIMALS, borrowAPY);
+  }
+
+  public liquidationPrice(
+    leverage: number,
+
+    ltStrategy: number,
+    ltCollateral: number,
+
+    depositCollateral: string
+  ) {
+    const farmLev = this.farmLev(leverage, depositCollateral);
+
+    return (
+      1 -
+      (leverage - LEVERAGE_DECIMALS - ltCollateral * (leverage - farmLev)) /
+        (ltStrategy * farmLev)
+    );
+  }
+
+  public ltStrategyLP(maxLeverage: number) {
+    return 1 - LEVERAGE_DECIMALS / maxLeverage;
+  }
+
+  public maxLeverage(ltStrategyLP: number) {
+    const leverage = Math.floor(1 / (1 - ltStrategyLP));
+    return Math.floor(leverage * LEVERAGE_DECIMALS);
+  }
+
+  private roi(
+    apy: number,
+    farmLev: number,
+    debtLev: number,
+    borrowAPY: number
+  ) {
+    return (apy * farmLev - borrowAPY * debtLev) / LEVERAGE_DECIMALS;
+  }
+
+  private minBorrowApy(poolApy: PoolList) {
+    const apys = Object.values(poolApy).sort(
+      (a, b) => a.borrowRate - b.borrowRate
+    );
+
+    return apys.length > 0 ? apys[0].borrowRate : 0;
+  }
+
+  private farmLev(leverage: number, depositCollateral: string) {
+    return this.inBaseAssets(depositCollateral) ||
+      this.inLeveragableAssets(depositCollateral)
+      ? leverage
+      : leverage - LEVERAGE_DECIMALS;
+  }
+
+  private inBaseAssets(depositCollateral: string) {
+    return this.baseAssets.some(
+      c => c.toLowerCase() === depositCollateral.toLowerCase()
+    );
+  }
+
+  private inLeveragableAssets(depositCollateral: string) {
+    return this.leveragableCollateral.some(
+      c => c.toLowerCase() === depositCollateral.toLowerCase()
+    );
+  }
+}

package/src/index.ts

@@ -1,8 +1,10 @@
 export * from "./core/constants";
+export * from "./core/price";
 export * from "./core/creditAccount";
 export * from "./core/creditManager";
 export * from "./core/creditSession";
 export * from "./contracts/contracts";
+export * from "./core/eventOrTx";
 export * from "./core/events";
 export * from "./core/errors";
 export * from "./core/pool";
@@ -26,6 +28,7 @@ export * from "./utils/events";
 export * from "./utils/math";
 export * from "./payload/graphPayload";
 export * from "./types/index";
+export * from "./core/strategy";
 
 export type { IDataCompressor, IWETHGateway } from "./types";
 
@@ -40,8 +43,12 @@ export * from "./tokens/gear";
 export * from "./tokens/normal";
 export * from "./tokens/yearn";
 
+export * from "./apy/lidoAPY";
+export * from "./apy/convexAPY";
+
 export * from "./core/history";
-export { MultiCallContract } from "./utils/multicall";
+export * from "./utils/multicall";
+export * from "./utils/types";
 export { callRepeater } from "./utils/repeater";
 export { getContractName } from "./contracts/contractsRegister";
 export { AdapterInterface } from "./contracts/adapters";

package/src/pathfinder/path.ts

@@ -1,166 +1,166 @@
-import {BigNumber, ethers} from "ethers";
-import {CreditManagerData} from "../core/creditManager";
-import {MultiCall} from "../core/multicall";
+import { BigNumber, ethers } from "ethers";
+import { CreditManagerData } from "../core/creditManager";
+import { MultiCall } from "../core/multicall";
 import {
-    SupportedToken,
-    supportedTokens,
-    tokenSymbolByAddress
+  SupportedToken,
+  supportedTokens,
+  tokenSymbolByAddress
 } from "../tokens/token";
-import {NetworkType} from "../core/constants";
-import {CreditAccountData} from "../core/creditAccount";
-
-import {PathFinder__factory} from "../types";
-import {priority} from "./priority";
-import {YearnLPToken} from "../tokens/yearn";
-import {YearnVaultPathFinder} from "./yVault";
-import {ConvexLPPathFinder} from "./convexLP";
-import {CurvePathFinder} from "./curveLP";
-import {CurveLPToken} from "../tokens/curveLP";
-import {PartialRecord} from "../utils/types";
-import {detectNetwork} from "../utils/network";
-import {pathFindersByNetwork} from "./contracts";
-import {TokenType} from "../tokens/tokenType";
+import { NetworkType } from "../core/constants";
+import { CreditAccountData } from "../core/creditAccount";
+
+import { PathFinder__factory } from "../types";
+import { priority } from "./priority";
+import { YearnLPToken } from "../tokens/yearn";
+import { YearnVaultPathFinder } from "./yVault";
+import { ConvexLPPathFinder } from "./convexLP";
+import { CurvePathFinder } from "./curveLP";
+import { CurveLPToken } from "../tokens/curveLP";
+import { PartialRecord } from "../utils/types";
+import { detectNetwork } from "../utils/network";
+import { pathFindersByNetwork } from "./contracts";
+import { TokenType } from "../tokens/tokenType";
 
 export class Path {
-    public readonly calls: Array<MultiCall> = [];
-    public readonly balances: PartialRecord<SupportedToken, BigNumber>;
-    public readonly underlying: SupportedToken;
-    public readonly creditManager: CreditManagerData;
-    public readonly creditAccount: CreditAccountData;
-    public readonly networkType: NetworkType;
-    public readonly provider: ethers.providers.Provider;
-    public totalGasLimit: number;
-
-    constructor(opts: {
-        balances: PartialRecord<SupportedToken, BigNumber>;
-        underlying: SupportedToken;
-        creditManager: CreditManagerData;
-        creditAccount: CreditAccountData;
-        networkType: NetworkType;
-        provider: ethers.providers.Provider;
-        totalGasLimit: number;
-    }) {
-        this.balances = opts.balances;
-        this.underlying = opts.underlying;
-        this.creditManager = opts.creditManager;
-        this.creditAccount = opts.creditAccount;
-        this.networkType = opts.networkType;
-        this.provider = opts.provider;
-        this.totalGasLimit = opts.totalGasLimit;
+  public readonly calls: Array<MultiCall> = [];
+  public readonly balances: PartialRecord<SupportedToken, BigNumber>;
+  public readonly underlying: SupportedToken;
+  public readonly creditManager: CreditManagerData;
+  public readonly creditAccount: CreditAccountData;
+  public readonly networkType: NetworkType;
+  public readonly provider: ethers.providers.Provider;
+  public totalGasLimit: number;
+
+  constructor(opts: {
+    balances: PartialRecord<SupportedToken, BigNumber>;
+    underlying: SupportedToken;
+    creditManager: CreditManagerData;
+    creditAccount: CreditAccountData;
+    networkType: NetworkType;
+    provider: ethers.providers.Provider;
+    totalGasLimit: number;
+  }) {
+    this.balances = opts.balances;
+    this.underlying = opts.underlying;
+    this.creditManager = opts.creditManager;
+    this.creditAccount = opts.creditAccount;
+    this.networkType = opts.networkType;
+    this.provider = opts.provider;
+    this.totalGasLimit = opts.totalGasLimit;
+  }
+
+  public popBalance(token: SupportedToken): BigNumber {
+    const currentBalance = this.balances[token];
+
+    if (currentBalance === undefined || currentBalance.gt(1))
+      return BigNumber.from(0);
+
+    this.balances[token] = BigNumber.from(1);
+    return currentBalance.sub(1);
+  }
+
+  private comparedByPriority(
+    [tokenA, _balanceA]: [string, BigNumber],
+    [tokenB, _balanceB]: [string, BigNumber]
+  ): number {
+    const priorityTokenA =
+      priority[supportedTokens[tokenA as SupportedToken].type];
+    const priorityTokenB =
+      priority[supportedTokens[tokenB as SupportedToken].type];
+
+    if (priorityTokenA > priorityTokenB) {
+      return -1;
+    } else if (priorityTokenA < priorityTokenB) {
+      return 1;
     }
-
-    public popBalance(token: SupportedToken): BigNumber {
-        const currentBalance = this.balances[token];
-
-        if (currentBalance === undefined || currentBalance.gt(1))
-            return BigNumber.from(0);
-
-        this.balances[token] = BigNumber.from(1);
-        return currentBalance.sub(1);
+    return 0;
+  }
+
+  static async findBestPath(
+    creditAccount: CreditAccountData,
+    creditManager: CreditManagerData,
+    provider: ethers.providers.Provider
+  ) {
+    const networkType = await detectNetwork(provider);
+
+    const balances = Object.entries(creditAccount.balances)
+      .map(([address, balance]) => ({
+        token: tokenSymbolByAddress[address.toLowerCase()],
+        balance
+      }))
+      .filter(t => t.balance.gt(1))
+      .reduce(
+        (obj, curValue) => ({ ...obj, [curValue.token]: curValue.balance }),
+        {}
+      );
+
+    const initialPath = new Path({
+      balances,
+      creditAccount,
+      creditManager,
+      networkType,
+      provider,
+      underlying: "DAI", // creditManager.underlyingToken
+      totalGasLimit: 0
+    });
+
+    const lpPaths = await initialPath.withdrawTokens();
+    const pathFinder = PathFinder__factory.connect(
+      pathFindersByNetwork[networkType].PATH_FINDER,
+      provider
+    );
+
+    console.log(lpPaths);
+    console.log(pathFinder);
+    // const bestPath = await pathFinder.bestPath();
+  }
+
+  async withdrawTokens(): Promise<Array<Path>> {
+    const existingTokens = Object.entries(this.balances)
+      .filter(([_token, balance]) => balance.gt(1))
+      .sort(this.comparedByPriority);
+
+    // TODO: Add checks for lenght
+    if (existingTokens.length === 0)
+      throw new Error("No tokens with balance >1");
+
+    const nextToken = existingTokens[0][0] as SupportedToken;
+    let lpPathFinder: LPWithdrawPathFinder;
+    // Get balances and keep non-zero only
+    // Find token with highest priority
+    // Get token type of this token
+    switch (supportedTokens[nextToken].type) {
+      case TokenType.NORMAL_TOKEN:
+      case TokenType.CONNECTOR:
+        return [this];
+
+      case TokenType.YEARN_VAULT_OF_CURVE_LP:
+      case TokenType.YEARN_VAULT_OF_META_CURVE_LP:
+      case TokenType.YEARN_VAULT:
+        lpPathFinder = new YearnVaultPathFinder(nextToken as YearnLPToken);
+        break;
+
+      case TokenType.CONVEX_LP_TOKEN:
+        lpPathFinder = new ConvexLPPathFinder();
+        break;
+
+      case TokenType.META_CURVE_LP:
+      case TokenType.CURVE_LP:
+        lpPathFinder = new CurvePathFinder(nextToken as CurveLPToken);
+        break;
+
+      default:
+        throw new Error("Token type not supported yet");
     }
 
-    private comparedByPriority(
-        [tokenA, _balanceA]: [string, BigNumber],
-        [tokenB, _balanceB]: [string, BigNumber]
-    ): number {
-        const priorityTokenA =
-            priority[supportedTokens[tokenA as SupportedToken].type];
-        const priorityTokenB =
-            priority[supportedTokens[tokenB as SupportedToken].type];
-
-        if (priorityTokenA > priorityTokenB) {
-            return -1;
-        } else if (priorityTokenA < priorityTokenB) {
-            return 1;
-        }
-        return 0;
-    }
+    return await lpPathFinder.findWithdrawPaths(this);
+  }
 
-    static async findBestPath(
-        creditAccount: CreditAccountData,
-        creditManager: CreditManagerData,
-        provider: ethers.providers.Provider
-    ) {
-        const networkType = await detectNetwork(provider);
-
-        const balances = Object.entries(creditAccount.balances)
-            .map(([address, balance]) => ({
-                token: tokenSymbolByAddress[address.toLowerCase()],
-                balance
-            }))
-            .filter(t => t.balance.gt(1))
-            .reduce(
-                (obj, curValue) => ({...obj, [curValue.token]: curValue.balance}),
-                {}
-            );
-
-        const initialPath = new Path({
-            balances,
-            creditAccount,
-            creditManager,
-            networkType,
-            provider,
-            underlying: "DAI", // creditManager.underlyingToken
-            totalGasLimit: 0
-        });
-
-        const lpPaths = await initialPath.withdrawTokens();
-        const pathFinder = PathFinder__factory.connect(
-            pathFindersByNetwork[networkType].PATH_FINDER,
-            provider
-        );
-
-        console.log(lpPaths);
-        console.log(pathFinder);
-        // const bestPath = await pathFinder.bestPath();
-    }
-
-    async withdrawTokens(): Promise<Array<Path>> {
-        const existingTokens = Object.entries(this.balances)
-            .filter(([_token, balance]) => balance.gt(1))
-            .sort(this.comparedByPriority);
-
-        // TODO: Add checks for lenght
-        if (existingTokens.length === 0)
-            throw new Error("No tokens with balance >1");
-
-        const nextToken = existingTokens.at(0)![0] as SupportedToken;
-        let lpPathFinder: LPWithdrawPathFinder;
-        // Get balances and keep non-zero only
-        // Find token with highest priority
-        // Get token type of this token
-        switch (supportedTokens[nextToken].type) {
-            case TokenType.NORMAL_TOKEN:
-            case TokenType.CONNECTOR:
-                return [this];
-
-            case TokenType.YEARN_VAULT_OF_CURVE_LP:
-            case TokenType.YEARN_VAULT_OF_META_CURVE_LP:
-            case TokenType.YEARN_VAULT:
-                lpPathFinder = new YearnVaultPathFinder(nextToken as YearnLPToken);
-                break;
-
-            case TokenType.CONVEX_LP_TOKEN:
-                lpPathFinder = new ConvexLPPathFinder();
-                break;
-
-            case TokenType.META_CURVE_LP:
-            case TokenType.CURVE_LP:
-                lpPathFinder = new CurvePathFinder(nextToken as CurveLPToken);
-                break;
-
-            default:
-                throw new Error("Token type not supported yet");
-        }
-
-        return await lpPathFinder.findWithdrawPaths(this);
-    }
-
-    clone(): Path {
-        return Object.assign(Object.create(Object.getPrototypeOf(this)), this);
-    }
+  clone(): Path {
+    return Object.assign(Object.create(Object.getPrototypeOf(this)), this);
+  }
 }
 
 export interface LPWithdrawPathFinder {
-    findWithdrawPaths(p: Path): Promise<Array<Path>>;
+  findWithdrawPaths(p: Path): Promise<Array<Path>>;
 }