@gearbox-protocol/sdk 0.0.100 → 0.0.103

package/src/pathfinder/contracts.ts

@@ -1,17 +1,19 @@
-import {NetworkType} from "../core/constants";
+import { NetworkType } from "../core/constants";
 
 export type PathFinderContracts = "PATH_FINDER" | "CONVEX_PATH_FINDER";
 
-export const pathFindersByNetwork: Record<NetworkType,
-    Record<PathFinderContracts, string>> = {
-    Mainnet: {
-        // PATH_FINDER
-        PATH_FINDER: "",
-        CONVEX_PATH_FINDER: ""
-    },
-    Kovan: {
-        // PATH_FINDER
-        PATH_FINDER: "",
-        CONVEX_PATH_FINDER: ""
-    }
+export const pathFindersByNetwork: Record<
+  NetworkType,
+  Record<PathFinderContracts, string>
+> = {
+  Mainnet: {
+    // PATH_FINDER
+    PATH_FINDER: "",
+    CONVEX_PATH_FINDER: ""
+  },
+  Kovan: {
+    // PATH_FINDER
+    PATH_FINDER: "",
+    CONVEX_PATH_FINDER: ""
+  }
 };

package/src/pathfinder/convexLP.ts

@@ -1,33 +1,37 @@
-import {LPWithdrawPathFinder, Path} from "./path";
-import {ConvexLPToken, convexTokens} from "../tokens/convex";
+import { convexTokens } from "../tokens/convex";
+import { objectEntries } from "../utils/mappers";
+import type { LPWithdrawPathFinder, Path } from "./path";
 
 export class ConvexLPPathFinder implements LPWithdrawPathFinder {
-    async findWithdrawPaths(p: Path): Promise<Array<Path>> {
-        const pids = new Set<number>();
-
-        for (let [cvxToken, tokenData] of Object.entries(convexTokens)) {
-            const currentBalance = p.popBalance(cvxToken as ConvexLPToken);
-            if (currentBalance.gt(1)) {
-                pids.add(tokenData.pid);
-            }
+  // eslint-disable-next-line class-methods-use-this
+  async findWithdrawPaths(p: Path): Promise<Array<Path>> {
+    const pids = objectEntries(convexTokens).reduce(
+      (acc, [cvxToken, tokenData]) => {
+        const currentBalance = p.popBalance(cvxToken);
+        if (currentBalance.gt(1)) {
+          pids.add(tokenData.pid);
         }
+        return acc;
+      },
+      new Set<number>()
+    );
 
-        // const convexPathFinder = ConvexPathFinder__factory.connect(
-        //     pathFindersByNetwork[p.networkType].CONVEX_PATH_FINDER,
-        //     p.provider
-        // );
+    // const convexPathFinder = ConvexPathFinder__factory.connect(
+    //     pathFindersByNetwork[p.networkType].CONVEX_PATH_FINDER,
+    //     p.provider
+    // );
 
-        // const tokenBalances = await convexPathFinder.calcRewards(
-        //     p.creditAccount.addr,
-        //     Array.from(pids)
-        // );
+    // const tokenBalances = await convexPathFinder.calcRewards(
+    //     p.creditAccount.addr,
+    //     Array.from(pids)
+    // );
 
-        // for (let balance of tokenBalances) {
-        //     p.balances[balance.token] = p.balances[balance.token].add(
-        //         balance.balance
-        //     );
-        // }
+    // for (let balance of tokenBalances) {
+    //     p.balances[balance.token] = p.balances[balance.token].add(
+    //         balance.balance
+    //     );
+    // }
 
-        return await p.withdrawTokens();
-    }
+    return p.withdrawTokens();
+  }
 }

package/src/pathfinder/curveLP.ts

@@ -1,71 +1,75 @@
-import {LPWithdrawPathFinder, Path} from "./path";
-import {CurveLPToken, curveTokens} from "../tokens/curveLP";
-import {contractParams, contractsByAddress, CurveParams, CurvePoolContract} from "../contracts/contracts";
-import {TradeType} from "./tradeTypes";
-import {CallData, MultiCallContract} from "../utils/multicall";
-import {ICurvePool__factory} from "../types";
-import {ICurvePoolInterface} from "../types/contracts/integrations/curve/ICurvePool";
-import {BigNumber} from "ethers";
+import { BigNumber } from "ethers";
+import type { LPWithdrawPathFinder, Path } from "./path";
+import { CurveLPToken, curveTokens } from "../tokens/curveLP";
+import {
+  contractParams,
+  contractsByAddress,
+  CurveParams,
+  CurvePoolContract
+} from "../contracts/contracts";
+import { TradeType } from "./tradeTypes";
+import { CallData, MultiCallContract } from "../utils/multicall";
+import { ICurvePool__factory } from "../types";
+import { ICurvePoolInterface } from "../types/contracts/integrations/curve/ICurvePool";
 
 export class CurvePathFinder implements LPWithdrawPathFinder {
-    lpToken: CurveLPToken;
-    contract: CurvePoolContract;
+  lpToken: CurveLPToken;
 
-    constructor(token: CurveLPToken) {
-        this.lpToken = token;
-        const curvePools = curveTokens[this.lpToken].lpActions.filter(
-            a => a.type == TradeType.CurveWithdrawLP
-        );
+  contract: CurvePoolContract;
 
-        if (curvePools.length !== 1) throw new Error("Cant find Withdrawer");
+  constructor(token: CurveLPToken) {
+    this.lpToken = token;
+    const curvePools = curveTokens[this.lpToken].lpActions.filter(
+      a => a.type === TradeType.CurveWithdrawLP
+    );
 
-        this.contract = curvePools[0].contract as CurvePoolContract;
+    if (curvePools.length !== 1) throw new Error("Cant find Withdrawer");
 
-        const wrapper = (contractParams[curvePools[0].contract] as CurveParams)
-            .wrapper;
+    this.contract = curvePools[0].contract as CurvePoolContract;
 
-        if (wrapper) {
-            this.contract = wrapper;
-        }
-    }
+    const { wrapper } = contractParams[curvePools[0].contract] as CurveParams;
 
-    async findWithdrawPaths(p: Path): Promise<Array<Path>> {
-        const coins = (contractParams[this.contract] as CurveParams).tokens;
-        const nCoins = coins.length;
+    if (wrapper) {
+      this.contract = wrapper;
+    }
+  }
 
-        const lpBalance = p.popBalance(this.lpToken);
+  async findWithdrawPaths(p: Path): Promise<Array<Path>> {
+    const coins = (contractParams[this.contract] as CurveParams).tokens;
+    const nCoins = coins.length;
 
-        const multiCallContract = new MultiCallContract(
-            contractsByAddress[this.contract],
-            ICurvePool__factory.createInterface(),
-            p.provider
-        );
+    const lpBalance = p.popBalance(this.lpToken);
 
-        const data: Array<CallData<ICurvePoolInterface>> = [];
+    const multiCallContract = new MultiCallContract(
+      contractsByAddress[this.contract],
+      ICurvePool__factory.createInterface(),
+      p.provider
+    );
 
-        for (let i = 0; i < nCoins; i++) {
-            data.push({
-                // @ts-ignore
-                method: "calc_withdraw_one_coin(uint256,int128)",
-                params: [lpBalance, i]
-            });
-        }
+    const data: Array<CallData<ICurvePoolInterface>> = [];
 
-        const balances = await multiCallContract.call<Array<BigNumber>>(data);
+    for (let i = 0; i < nCoins; i += 1) {
+      data.push({
+        method: "calc_withdraw_one_coin(uint256,int128)",
+        params: [lpBalance, i]
+      });
+    }
 
-        console.log(balances)
+    const balances = await multiCallContract.call<Array<BigNumber>>(data);
 
-        const paths: Array<Path> = [];
-        for (let i = 0; i < nCoins; i++) {
-            const newPath = p.clone();
-            // newPath.balances[coins[i]] = newPath.balances[coins[i]].add(balances[i]);
-            // newPath.calls.push({
-            //     targetContract: contractsByNetwork[p.networkType][this.contract],
-            //     callData: ICurveV1Adapter__factory.createInterface().encodeFunctionData("remove_all_liquidity_one_coin", [i])
-            // })
-            paths.push(newPath);
-        }
+    console.debug(balances);
 
-        return paths;
+    const paths: Array<Path> = [];
+    for (let i = 0; i < nCoins; i += 1) {
+      const newPath = p.clone();
+      // newPath.balances[coins[i]] = newPath.balances[coins[i]].add(balances[i]);
+      // newPath.calls.push({
+      //     targetContract: contractsByNetwork[p.networkType][this.contract],
+      //     callData: ICurveV1Adapter__factory.createInterface().encodeFunctionData("remove_all_liquidity_one_coin", [i])
+      // })
+      paths.push(newPath);
     }
+
+    return paths;
+  }
 }

package/src/pathfinder/path.ts

@@ -1,166 +1,174 @@
-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 popBalance(token: SupportedToken): BigNumber {
-        const currentBalance = this.balances[token];
+  public readonly balances: PartialRecord<SupportedToken, BigNumber>;
 
-        if (currentBalance === undefined || currentBalance.gt(1))
-            return BigNumber.from(0);
+  public readonly underlying: SupportedToken;
 
-        this.balances[token] = BigNumber.from(1);
-        return currentBalance.sub(1);
-    }
+  public readonly creditManager: CreditManagerData;
 
-    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;
-    }
+  public readonly creditAccount: CreditAccountData;
 
-    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();
-    }
+  public readonly networkType: NetworkType;
 
-    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);
-    }
+  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];
 
-    clone(): Path {
-        return Object.assign(Object.create(Object.getPrototypeOf(this)), this);
+    if (currentBalance === undefined || currentBalance.gt(1))
+      return BigNumber.from(0);
+
+    this.balances[token] = BigNumber.from(1);
+    return currentBalance.sub(1);
+  }
+
+  private static comparedByPriority(
+    [tokenA]: [string, BigNumber],
+    [tokenB]: [string, BigNumber]
+  ): number {
+    const priorityTokenA =
+      priority[supportedTokens[tokenA as SupportedToken].type];
+    const priorityTokenB =
+      priority[supportedTokens[tokenB as SupportedToken].type];
+
+    if (priorityTokenA > priorityTokenB) {
+      return -1;
+    }
+    if (priorityTokenA < priorityTokenB) {
+      return 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.debug(lpPaths);
+    console.debug(pathFinder);
+    // const bestPath = await pathFinder.bestPath();
+  }
+
+  async withdrawTokens(): Promise<Array<Path>> {
+    const existingTokens = Object.entries(this.balances)
+      .filter(([, balance]) => balance.gt(1))
+      .sort(Path.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");
+    }
+
+    return lpPathFinder.findWithdrawPaths(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>>;
 }

package/src/pathfinder/priority.ts

@@ -1,14 +1,14 @@
-import {TokenType} from "../tokens/tokenType";
+import { TokenType } from "../tokens/tokenType";
 
 export const priority: Record<TokenType, number> = {
-    [TokenType.CONNECTOR]: 1,
-    [TokenType.NORMAL_TOKEN]: 2,
-    [TokenType.CURVE_LP]: 3,
-    [TokenType.YEARN_VAULT]: 3,
-    [TokenType.META_CURVE_LP]: 4,
-    [TokenType.YEARN_VAULT_OF_CURVE_LP]: 4,
-    [TokenType.CONVEX_LP_TOKEN]: 5,
-    [TokenType.YEARN_VAULT_OF_META_CURVE_LP]: 5,
-    [TokenType.CONVEX_STAKED_PHANTOM_TOKEN]: 5,
-    [TokenType.DIESEL_LP_TOKEN]: 6
+  [TokenType.CONNECTOR]: 1,
+  [TokenType.NORMAL_TOKEN]: 2,
+  [TokenType.CURVE_LP]: 3,
+  [TokenType.YEARN_VAULT]: 3,
+  [TokenType.META_CURVE_LP]: 4,
+  [TokenType.YEARN_VAULT_OF_CURVE_LP]: 4,
+  [TokenType.CONVEX_LP_TOKEN]: 5,
+  [TokenType.YEARN_VAULT_OF_META_CURVE_LP]: 5,
+  [TokenType.CONVEX_STAKED_PHANTOM_TOKEN]: 5,
+  [TokenType.DIESEL_LP_TOKEN]: 6
 };