@gearbox-protocol/sdk 0.0.101 → 0.0.104

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

@@ -23,12 +23,19 @@ 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: {
@@ -59,9 +66,9 @@ export class Path {
     return currentBalance.sub(1);
   }
 
-  private comparedByPriority(
-    [tokenA, _balanceA]: [string, BigNumber],
-    [tokenB, _balanceB]: [string, BigNumber]
+  private static comparedByPriority(
+    [tokenA]: [string, BigNumber],
+    [tokenB]: [string, BigNumber]
   ): number {
     const priorityTokenA =
       priority[supportedTokens[tokenA as SupportedToken].type];
@@ -70,7 +77,8 @@ export class Path {
 
     if (priorityTokenA > priorityTokenB) {
       return -1;
-    } else if (priorityTokenA < priorityTokenB) {
+    }
+    if (priorityTokenA < priorityTokenB) {
       return 1;
     }
     return 0;
@@ -110,15 +118,15 @@ export class Path {
       provider
     );
 
-    console.log(lpPaths);
-    console.log(pathFinder);
+    console.debug(lpPaths);
+    console.debug(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);
+      .filter(([, balance]) => balance.gt(1))
+      .sort(Path.comparedByPriority);
 
     // TODO: Add checks for lenght
     if (existingTokens.length === 0)
@@ -153,7 +161,7 @@ export class Path {
         throw new Error("Token type not supported yet");
     }
 
-    return await lpPathFinder.findWithdrawPaths(this);
+    return lpPathFinder.findWithdrawPaths(this);
   }
 
   clone(): 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
 };

package/src/pathfinder/trade.ts

@@ -1,83 +1,90 @@
-import {BigNumber} from "ethers";
-import {BytesLike} from "@ethersproject/bytes";
-import {PERCENTAGE_FACTOR, WAD} from "../core/constants";
-import {SwapType} from "./tradeTypes";
+import { BigNumber, BytesLike } from "ethers";
+import { PERCENTAGE_FACTOR, WAD } from "../core/constants";
+import { SwapType } from "./tradeTypes";
 
 export interface CloseTradePath {
-    path: Array<string>;
-    amountOutMin: BigNumber;
+  path: Array<string>;
+  amountOutMin: BigNumber;
 }
 
 export class TradePath {
-    public readonly swapType: SwapType;
-    public readonly amount: BigNumber;
-    public readonly rate: BigNumber;
-    public readonly path: Array<string>;
-    public readonly expectedAmount: BigNumber;
-    public readonly pathUniV3: BytesLike | undefined;
-    public readonly i: number | undefined;
-    public readonly j: number | undefined;
-    public readonly operationName: string | undefined;
-
-    constructor(params: {
-        swapType: SwapType;
-        amount: BigNumber;
-        path: Array<string>;
-        expectedAmount: BigNumber;
-        pathUniV3?: BytesLike;
-        i?: number;
-        j?: number;
-        operationName?: string;
-    }) {
-        this.swapType = params.swapType;
-        this.amount = params.amount;
-        this.path = params.path;
-        this.expectedAmount = params.expectedAmount;
-        this.pathUniV3 = params.pathUniV3;
-        this.rate =
-            params.swapType !== SwapType.ExactInput
-                ? params.expectedAmount.mul(WAD).div(params.amount)
-                : WAD.mul(params.amount).div(params.expectedAmount);
-        this.i = params.i;
-        this.j = params.j;
-        this.operationName = params.operationName;
-    }
-
-    getExpectedAmountWithSlippage(slippage: number): BigNumber {
-        return this.swapType === SwapType.ExactInput
-            ? this.getAmountOutMin(slippage)
-            : this.getAmountInMax(slippage);
-    }
-
-    getAmountInMax(slippage: number): BigNumber {
-        return this.expectedAmount
-            .mul(PERCENTAGE_FACTOR + slippage)
-            .div(PERCENTAGE_FACTOR);
-    }
-
-    getAmountOutMin(slippage: number): BigNumber {
-        return this.expectedAmount
-            .mul(PERCENTAGE_FACTOR)
-            .div(PERCENTAGE_FACTOR + slippage);
-    }
-
-    public get from(): string {
-        return this.path[0];
-    }
-
-    public get to(): string {
-        return this.path[this.path.length - 1];
-    }
-
-    getFromAmount(slippage: number): BigNumber {
-        return this.swapType === SwapType.ExactInput
-            ? this.amount
-            : this.getExpectedAmountWithSlippage(slippage);
-    }
-
-    getToAmount(slippage: number): BigNumber {
-        return this.swapType === SwapType.ExactOutput
-            ? this.amount
-            : this.getExpectedAmountWithSlippage(slippage);
-    }
+  public readonly swapType: SwapType;
+
+  public readonly amount: BigNumber;
+
+  public readonly rate: BigNumber;
+
+  public readonly path: Array<string>;
+
+  public readonly expectedAmount: BigNumber;
+
+  public readonly pathUniV3: BytesLike | undefined;
+
+  public readonly i: number | undefined;
+
+  public readonly j: number | undefined;
+
+  public readonly operationName: string | undefined;
+
+  constructor(params: {
+    swapType: SwapType;
+    amount: BigNumber;
+    path: Array<string>;
+    expectedAmount: BigNumber;
+    pathUniV3?: BytesLike;
+    i?: number;
+    j?: number;
+    operationName?: string;
+  }) {
+    this.swapType = params.swapType;
+    this.amount = params.amount;
+    this.path = params.path;
+    this.expectedAmount = params.expectedAmount;
+    this.pathUniV3 = params.pathUniV3;
+    this.rate =
+      params.swapType !== SwapType.ExactInput
+        ? params.expectedAmount.mul(WAD).div(params.amount)
+        : WAD.mul(params.amount).div(params.expectedAmount);
+    this.i = params.i;
+    this.j = params.j;
+    this.operationName = params.operationName;
+  }
+
+  getExpectedAmountWithSlippage(slippage: number): BigNumber {
+    return this.swapType === SwapType.ExactInput
+      ? this.getAmountOutMin(slippage)
+      : this.getAmountInMax(slippage);
+  }
+
+  getAmountInMax(slippage: number): BigNumber {
+    return this.expectedAmount
+      .mul(PERCENTAGE_FACTOR + slippage)
+      .div(PERCENTAGE_FACTOR);
+  }
+
+  getAmountOutMin(slippage: number): BigNumber {
+    return this.expectedAmount
+      .mul(PERCENTAGE_FACTOR)
+      .div(PERCENTAGE_FACTOR + slippage);
+  }
+
+  public get from(): string {
+    return this.path[0];
+  }
+
+  public get to(): string {
+    return this.path[this.path.length - 1];
+  }
+
+  getFromAmount(slippage: number): BigNumber {
+    return this.swapType === SwapType.ExactInput
+      ? this.amount
+      : this.getExpectedAmountWithSlippage(slippage);
+  }
+
+  getToAmount(slippage: number): BigNumber {
+    return this.swapType === SwapType.ExactOutput
+      ? this.amount
+      : this.getExpectedAmountWithSlippage(slippage);
+  }
 }