@gearbox-protocol/sdk 0.0.100 → 0.0.103

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);
+  }
 }

package/src/pathfinder/tradeTypes.ts

@@ -1,101 +1,105 @@
-import {ConvexPoolContract, CurvePoolContract, UniswapV2Contract, YearnVaultContract} from "../contracts/contracts";
-import {NormalToken} from "../tokens/normal";
-import {CurveLPToken} from "../tokens/curveLP";
-import {YearnLPToken} from "../tokens/yearn";
-import {ConvexLPToken, ConvexStakedPhantomToken} from "../tokens/convex";
-
+import type {
+  ConvexPoolContract,
+  CurvePoolContract,
+  UniswapV2Contract,
+  YearnVaultContract
+} from "../contracts/contracts";
+import type { NormalToken } from "../tokens/normal";
+import type { CurveLPToken } from "../tokens/curveLP";
+import type { YearnLPToken } from "../tokens/yearn";
+import type { ConvexLPToken, ConvexStakedPhantomToken } from "../tokens/convex";
 
 export enum TradeType {
-    UniswapV2Swap,
-    UniswapV3Swap,
-    CurveExchange,
-    CurveExchangeUnderlying,
-    CurveDepositLP,
-    CurveWithdrawLP,
-    YearnDeposit,
-    YearnWithdraw,
-    LidoStake,
-    ConvexDepositLP,
-    ConvexStake,
-    ConvexDepositLPAndStake,
-    ConvexWithdrawLP,
-    ConvexWithdraw,
-    ConvexWithdrawAndUnwrap
+  UniswapV2Swap,
+  UniswapV3Swap,
+  CurveExchange,
+  CurveExchangeUnderlying,
+  CurveDepositLP,
+  CurveWithdrawLP,
+  YearnDeposit,
+  YearnWithdraw,
+  LidoStake,
+  ConvexDepositLP,
+  ConvexStake,
+  ConvexDepositLPAndStake,
+  ConvexWithdrawLP,
+  ConvexWithdraw,
+  ConvexWithdrawAndUnwrap
 }
 
 export type TradeAction =
-    | {
-    type: TradeType.UniswapV2Swap;
-    contract: UniswapV2Contract;
-    tokenOut?: NormalToken;
-}
-    | {
-    type: TradeType.UniswapV3Swap;
-    contract: "UNISWAP_V3_ROUTER";
-    tokenOut?: NormalToken;
-}
-    | {
-    type: TradeType.CurveExchange;
-    contract: CurvePoolContract;
-    tokenOut: Array<NormalToken | CurveLPToken>;
-}
-    | {
-    type: TradeType.CurveDepositLP;
-    contract: CurvePoolContract;
-    tokenOut: CurveLPToken;
-}
-    | {
-    type: TradeType.CurveWithdrawLP;
-    contract: CurvePoolContract;
-    tokenOut: Array<CurveLPToken | NormalToken>;
-}
-    | {
-    type: TradeType.YearnDeposit;
-    contract: YearnVaultContract;
-    tokenOut: YearnLPToken;
-}
-    | {
-    type: TradeType.YearnWithdraw;
-    contract: YearnVaultContract;
-    tokenOut: NormalToken | CurveLPToken;
-}
-    | {
-    type: TradeType.LidoStake;
-    contract: "LIDO_STETH_GATEWAY";
-    tokenOut: NormalToken;
-}
-    | {
-    type: TradeType.ConvexDepositLP;
-    contract: "CONVEX_BOOSTER";
-    tokenOut: ConvexLPToken;
-}
-    | {
-    type: TradeType.ConvexStake;
-    contract: ConvexPoolContract;
-    tokenOut: ConvexStakedPhantomToken;
-}
-    | {
-    type: TradeType.ConvexDepositLPAndStake;
-    contract: "CONVEX_BOOSTER";
-    tokenOut: ConvexStakedPhantomToken;
-}
-    | {
-    type: TradeType.ConvexWithdrawLP;
-    contract: "CONVEX_BOOSTER";
-    tokenOut: CurveLPToken;
-}
-    | {
-    type: TradeType.ConvexWithdraw;
-    contract: ConvexPoolContract;
-    tokenOut: ConvexLPToken;
-}
-    | {
-    type: TradeType.ConvexWithdrawAndUnwrap;
-    contract: ConvexPoolContract;
-    tokenOut: CurveLPToken;
-};
+  | {
+      type: TradeType.UniswapV2Swap;
+      contract: UniswapV2Contract;
+      tokenOut?: NormalToken;
+    }
+  | {
+      type: TradeType.UniswapV3Swap;
+      contract: "UNISWAP_V3_ROUTER";
+      tokenOut?: NormalToken;
+    }
+  | {
+      type: TradeType.CurveExchange;
+      contract: CurvePoolContract;
+      tokenOut: Array<NormalToken | CurveLPToken>;
+    }
+  | {
+      type: TradeType.CurveDepositLP;
+      contract: CurvePoolContract;
+      tokenOut: CurveLPToken;
+    }
+  | {
+      type: TradeType.CurveWithdrawLP;
+      contract: CurvePoolContract;
+      tokenOut: Array<CurveLPToken | NormalToken>;
+    }
+  | {
+      type: TradeType.YearnDeposit;
+      contract: YearnVaultContract;
+      tokenOut: YearnLPToken;
+    }
+  | {
+      type: TradeType.YearnWithdraw;
+      contract: YearnVaultContract;
+      tokenOut: NormalToken | CurveLPToken;
+    }
+  | {
+      type: TradeType.LidoStake;
+      contract: "LIDO_STETH_GATEWAY";
+      tokenOut: NormalToken;
+    }
+  | {
+      type: TradeType.ConvexDepositLP;
+      contract: "CONVEX_BOOSTER";
+      tokenOut: ConvexLPToken;
+    }
+  | {
+      type: TradeType.ConvexStake;
+      contract: ConvexPoolContract;
+      tokenOut: ConvexStakedPhantomToken;
+    }
+  | {
+      type: TradeType.ConvexDepositLPAndStake;
+      contract: "CONVEX_BOOSTER";
+      tokenOut: ConvexStakedPhantomToken;
+    }
+  | {
+      type: TradeType.ConvexWithdrawLP;
+      contract: "CONVEX_BOOSTER";
+      tokenOut: CurveLPToken;
+    }
+  | {
+      type: TradeType.ConvexWithdraw;
+      contract: ConvexPoolContract;
+      tokenOut: ConvexLPToken;
+    }
+  | {
+      type: TradeType.ConvexWithdrawAndUnwrap;
+      contract: ConvexPoolContract;
+      tokenOut: CurveLPToken;
+    };
 
 export enum SwapType {
-    ExactInput = 1,
-    ExactOutput = 2,
-}
+  ExactInput = 1,
+  ExactOutput = 2
+}

package/src/pathfinder/yVault.ts

@@ -1,74 +1,90 @@
-import {BigNumber} from "ethers";
-import {IYVault__factory} from "../types";
-import {Path, LPWithdrawPathFinder} from "./path";
-import {YearnLPToken, yearnTokens} from "../tokens/yearn";
-import {NormalToken} from "../tokens/normal";
-import {CurveLPToken} from "../tokens/curveLP";
-import {SupportedToken, tokenDataByNetwork} from "../tokens/token";
-import {PartialRecord} from "../utils/types";
-import {MCall, multicall} from "../utils/multicall";
-import {IYVaultInterface} from "../types/contracts/integrations/yearn/IYVault";
+import { BigNumber } from "ethers";
+
+import { YearnLPToken, yearnTokens } from "../tokens/yearn";
+import { NormalToken } from "../tokens/normal";
+import { CurveLPToken } from "../tokens/curveLP";
+import { SupportedToken, tokenDataByNetwork } from "../tokens/token";
+
+import { PartialRecord } from "../utils/types";
+import { MCall, multicall } from "../utils/multicall";
+import { objectEntries } from "../utils/mappers";
+
+import { IYVault__factory } from "../types";
+import { IYVaultInterface } from "../types/contracts/integrations/yearn/IYVault";
+
+import type { Path, LPWithdrawPathFinder } from "./path";
 
 interface WithdrawBalance {
-    token: SupportedToken;
-    balance: BigNumber;
+  token: SupportedToken;
+  balance: BigNumber;
 }
 
 export class YearnVaultPathFinder implements LPWithdrawPathFinder {
-    _vault: YearnLPToken;
-    token: NormalToken | CurveLPToken;
+  _vault: YearnLPToken;
 
-    constructor(vault: YearnLPToken) {
-        this._vault = vault;
+  token: NormalToken | CurveLPToken;
 
-        const currentTokenData = yearnTokens[vault];
+  constructor(vault: YearnLPToken) {
+    this._vault = vault;
 
-        // Yearn Vault only has one lp action
-        this.token = currentTokenData.underlying;
-    }
+    const currentTokenData = yearnTokens[vault];
+
+    // Yearn Vault only has one lp action
+    this.token = currentTokenData.underlying;
+  }
+
+  // eslint-disable-next-line class-methods-use-this
+  async findWithdrawPaths(path: Path): Promise<Array<Path>> {
+    // make path copy
+    const p: Path = Object.assign(
+      Object.create(Object.getPrototypeOf(path)),
+      path
+    );
+
+    const vaultBalances = objectEntries(yearnTokens).reduce<
+      PartialRecord<SupportedToken, WithdrawBalance>
+    >((acc, [yVault, tokenData]) => {
+      const typedVault = yVault;
+      const currentBalance = p.popBalance(typedVault);
+      if (currentBalance.gt(1)) {
+        acc[typedVault] = {
+          token: tokenData.underlying,
+          balance: currentBalance
+        };
+      }
+      return acc;
+    }, {});
 
-    async findWithdrawPaths(p: Path): Promise<Array<Path>> {
-        let vaultBalances: PartialRecord<SupportedToken, WithdrawBalance> = {};
-
-        for (let [yVault, tokenData] of Object.entries(yearnTokens)) {
-            const currentBalance = p.popBalance(yVault as YearnLPToken);
-            if (currentBalance.gt(1)) {
-                vaultBalances[yVault as YearnLPToken] = {
-                    token: tokenData.underlying,
-                    balance: currentBalance
-                };
-            }
-        }
-
-        const vaultList = Object.keys(vaultBalances) as Array<SupportedToken>;
-
-        // Yearn Vault only has one lp action
-        const multicallData: Array<MCall<IYVaultInterface>> = vaultList
-            .map(t => tokenDataByNetwork[p.networkType][t as SupportedToken])
-            .map(addr => ({
-                address: addr,
-                interface: IYVault__factory.createInterface(),
-                method: "pricePerShare()"
-            }));
-
-        const prices = await multicall<Array<BigNumber>>(multicallData, p.provider);
-
-        for (let i = 0; i < vaultList.length; i++) {
-            const vault = vaultList[i];
-            const vb = vaultBalances[vault];
-
-            p.balances[vb!.token] = (p.balances[vb!.token] || BigNumber.from(0)).add(
-                BigNumber.from(vb?.balance || 0).mul(prices[i])
-            );
-
-            p.calls.push({
-                targetContract:
-                    p.creditManager.adapters[tokenDataByNetwork[p.networkType][vault]],
-                callData:
-                    IYVault__factory.createInterface().encodeFunctionData("withdraw()")
-            });
-        }
-
-        return await p.withdrawTokens();
+    const vaultList = Object.keys(vaultBalances) as Array<SupportedToken>;
+
+    // Yearn Vault only has one lp action
+    const multicallData: Array<MCall<IYVaultInterface>> = vaultList
+      .map(t => tokenDataByNetwork[p.networkType][t as SupportedToken])
+      .map(addr => ({
+        address: addr,
+        interface: IYVault__factory.createInterface(),
+        method: "pricePerShare()"
+      }));
+
+    const prices = await multicall<Array<BigNumber>>(multicallData, p.provider);
+
+    for (let i = 0; i < vaultList.length; i += 1) {
+      const vault = vaultList[i];
+      const vb = vaultBalances[vault];
+
+      p.balances[vb!.token] = (p.balances[vb!.token] || BigNumber.from(0)).add(
+        BigNumber.from(vb?.balance || 0).mul(prices[i])
+      );
+
+      const tokenAddress = tokenDataByNetwork[p.networkType][vault];
+      const adapterAddress = p.creditManager.adapters[tokenAddress];
+
+      const callData =
+        IYVault__factory.createInterface().encodeFunctionData("withdraw()");
+
+      p.calls.push({ target: adapterAddress, callData });
     }
+
+    return p.withdrawTokens();
+  }
 }

package/src/payload/creditAccount.ts

@@ -1,29 +1,7 @@
-import {BigNumberish} from "ethers";
+import { CreditAccountDataStruct } from "../types/contracts/core/DataCompressor";
 
-export interface TokenBalancePayload {
-  token: string;
-  balance: BigNumberish;
-  isAllowed: boolean;
-}
+export type TokenBalancePayload = CreditAccountDataStruct["balances"];
 
-export interface CreditAccountDataPayload {
-  addr: string;
-  borrower: string;
-  inUse: boolean;
-  creditManager: string;
-  underlyingToken: string;
-  borrowedAmountPlusInterest: BigNumberish;
-  totalValue: BigNumberish;
-  healthFactor: BigNumberish;
-  borrowRate: BigNumberish;
-  balances?: Array<TokenBalancePayload>;
-}
+export type CreditAccountDataPayload = CreditAccountDataStruct;
 
-export interface CreditAccountDataExtendedPayload extends CreditAccountDataPayload {
-  repayAmount: BigNumberish;
-  liquidationAmount: BigNumberish;
-  canBeClosed?: boolean;
-  borrowedAmount: BigNumberish;
-  cumulativeIndexAtOpen: BigNumberish;
-  since: BigNumberish;
-}
+export type CreditAccountDataExtendedPayload = CreditAccountDataStruct;

package/src/payload/creditManager.ts

@@ -1,36 +1,14 @@
 import { BigNumberish } from "ethers";
+import { CreditManagerDataStruct } from "../types/contracts/interfaces/IDataCompressor.sol/IDataCompressor";
 
 export interface AdapterPayload {
   allowedContract: string;
-  adapter: string
+  adapter: string;
 }
 
-export interface CreditManagerDataPayload {
-  addr: string;
-  hasAccount?: boolean;
-  underlyingToken?: string;
-  isWETH?: boolean;
-  canBorrow?: boolean;
-  borrowRate?: BigNumberish;
-  minAmount?: BigNumberish;
-  maxAmount?: BigNumberish;
-  maxLeverageFactor?: BigNumberish;
-  availableLiquidity?: BigNumberish;
-  allowedTokens?: Array<string>;
-  adapters?: Array<AdapterPayload>;
-}
+export type CreditManagerDataPayload = CreditManagerDataStruct;
 
-export interface CreditManagerStatPayload {
-  addr: string;
-  underlyingToken?: string;
-  isWETH?: boolean;
-  canBorrow?: boolean;
-  borrowRate?: BigNumberish;
-  minAmount?: BigNumberish;
-  maxAmount?: BigNumberish;
-  maxLeverageFactor?: BigNumberish;
-  availableLiquidity?: BigNumberish;
-  allowedTokens?: Array<string>;
+export interface CreditManagerStatPayload extends CreditManagerDataPayload {
   allowedContracts?: Array<string>;
   uniqueUsers: number;
   openedAccountsCount?: number;

package/src/payload/pool.ts

@@ -1,20 +1,3 @@
-import {BigNumberish} from "ethers";
+import { PoolDataStruct } from "../types/contracts/interfaces/IDataCompressor.sol/IDataCompressor";
 
-export interface PoolDataPayload {
-  addr: string;
-  underlyingToken: string;
-  dieselToken: string;
-  isWETH: boolean;
-  expectedLiquidity: BigNumberish;
-  expectedLiquidityLimit?: BigNumberish;
-  availableLiquidity: BigNumberish;
-  totalBorrowed: BigNumberish;
-  depositAPY_RAY: BigNumberish;
-  borrowAPY_RAY: BigNumberish;
-  dieselRate_RAY: BigNumberish;
-  withdrawFee: BigNumberish;
-  timestampLU?: BigNumberish;
-  cumulativeIndex_RAY?: BigNumberish
-}
-
-//
+export type PoolDataPayload = PoolDataStruct;

package/src/payload/token.ts

@@ -1,5 +1,5 @@
 export interface TokenDataPayload {
-    addr: string;
-    symbol: string;
-    decimals: number;
+  addr: string;
+  symbol: string;
+  decimals: number;
 }