@gearbox-protocol/sdk 0.0.101 → 0.0.104

package/src/strategies/convex.ts

@@ -1,233 +1,407 @@
 import { BigNumberish } from "ethers";
+import {
+  contractParams,
+  contractsByNetwork,
+  ConvexPoolContract,
+  ConvexPoolParams
+} from "src/contracts/contracts";
+import { NetworkType } from "src/core/constants";
+import { CreditManagerData } from "src/core/creditManager";
+import { ConvexPhantomTokenData } from "src/tokens/convex";
+import { CurveLPTokenData } from "src/tokens/curveLP";
+import { supportedTokens, tokenDataByNetwork } from "src/tokens/token";
 
 import {
-    ConvexV1BoosterAdapter__factory,
-    ConvexV1BaseRewardPoolAdapter__factory,
-    ConvexV1ClaimZapAdapter__factory
-} from "../types"
+  ConvexV1BoosterAdapter__factory,
+  ConvexV1BaseRewardPoolAdapter__factory,
+  ConvexV1ClaimZapAdapter__factory
+} from "../types";
 
 import { MultiCallStruct } from "../types/contracts/interfaces/ICreditFacade.sol/ICreditFacade";
+import { CurveStrategies } from "./curve";
+import { UniswapV2Multicaller } from "./uniswapV2";
 
 export class ConvexBoosterCalls {
-    public static deposit(pid: BigNumberish, amount: BigNumberish, stake: boolean) {
-        return ConvexV1BoosterAdapter__factory.createInterface().encodeFunctionData(
-            "deposit",
-            [pid, amount, stake]
-        );
-    }
+  public static deposit(
+    pid: BigNumberish,
+    amount: BigNumberish,
+    stake: boolean
+  ) {
+    return ConvexV1BoosterAdapter__factory.createInterface().encodeFunctionData(
+      "deposit",
+      [pid, amount, stake]
+    );
+  }
 
-    public static depositAll(pid: BigNumberish, stake: boolean) {
-        return ConvexV1BoosterAdapter__factory.createInterface().encodeFunctionData(
-            "depositAll",
-            [pid, stake]
-        );
-    }
+  public static depositAll(pid: BigNumberish, stake: boolean) {
+    return ConvexV1BoosterAdapter__factory.createInterface().encodeFunctionData(
+      "depositAll",
+      [pid, stake]
+    );
+  }
 
-    public static withdraw(pid: BigNumberish, amount: BigNumberish) {
-        return ConvexV1BoosterAdapter__factory.createInterface().encodeFunctionData(
-            "withdraw",
-            [pid, amount]
-        );
-    }
+  public static withdraw(pid: BigNumberish, amount: BigNumberish) {
+    return ConvexV1BoosterAdapter__factory.createInterface().encodeFunctionData(
+      "withdraw",
+      [pid, amount]
+    );
+  }
 
-    public static withdrawAll(pid: BigNumberish) {
-        return ConvexV1BoosterAdapter__factory.createInterface().encodeFunctionData(
-            "withdrawAll",
-            [pid]
-        );
-    }
+  public static withdrawAll(pid: BigNumberish) {
+    return ConvexV1BoosterAdapter__factory.createInterface().encodeFunctionData(
+      "withdrawAll",
+      [pid]
+    );
+  }
 }
 
 export class ConvexPoolCalls {
-    public static stake(amount: BigNumberish) {
-        return ConvexV1BaseRewardPoolAdapter__factory.createInterface().encodeFunctionData(
-            "stake",
-            [amount]
-        );
-    }
+  public static stake(amount: BigNumberish) {
+    return ConvexV1BaseRewardPoolAdapter__factory.createInterface().encodeFunctionData(
+      "stake",
+      [amount]
+    );
+  }
 
-    public static stakeAll() {
-        return ConvexV1BaseRewardPoolAdapter__factory.createInterface().encodeFunctionData(
-            "stakeAll"
-        );
-    }
+  public static stakeAll() {
+    return ConvexV1BaseRewardPoolAdapter__factory.createInterface().encodeFunctionData(
+      "stakeAll"
+    );
+  }
 
-    public static withdraw(amount: BigNumberish, claim: boolean) {
-        return ConvexV1BaseRewardPoolAdapter__factory.createInterface().encodeFunctionData(
-            "withdraw",
-            [amount, claim]
-        );
-    }
+  public static withdraw(amount: BigNumberish, claim: boolean) {
+    return ConvexV1BaseRewardPoolAdapter__factory.createInterface().encodeFunctionData(
+      "withdraw",
+      [amount, claim]
+    );
+  }
 
-    public static withdrawAll(claim: boolean) {
-        return ConvexV1BaseRewardPoolAdapter__factory.createInterface().encodeFunctionData(
-            "withdrawAll",
-            [claim]
-        );
-    }
+  public static withdrawAll(claim: boolean) {
+    return ConvexV1BaseRewardPoolAdapter__factory.createInterface().encodeFunctionData(
+      "withdrawAll",
+      [claim]
+    );
+  }
 
-    public static withdrawAndUnwrap(amount: BigNumberish, claim: boolean) {
-        return ConvexV1BaseRewardPoolAdapter__factory.createInterface().encodeFunctionData(
-            "withdrawAndUnwrap",
-            [amount, claim]
-        );
-    }
+  public static withdrawAndUnwrap(amount: BigNumberish, claim: boolean) {
+    return ConvexV1BaseRewardPoolAdapter__factory.createInterface().encodeFunctionData(
+      "withdrawAndUnwrap",
+      [amount, claim]
+    );
+  }
 
-    public static withdrawAllAndUnwrap(claim: boolean) {
-        return ConvexV1BaseRewardPoolAdapter__factory.createInterface().encodeFunctionData(
-            "withdrawAllAndUnwrap",
-            [claim]
-        );
-    }
+  public static withdrawAllAndUnwrap(claim: boolean) {
+    return ConvexV1BaseRewardPoolAdapter__factory.createInterface().encodeFunctionData(
+      "withdrawAllAndUnwrap",
+      [claim]
+    );
+  }
 }
 
-
 export class ConvexClaimZapCalls {
-    public static claimRewards(
-        rewardContracts: Array<string>,
-        extraRewardContracts: Array<string>,
-        tokenRewardContracts: Array<string>,
-        tokenRewardTokens: Array<string>,
-        depositCrvMaxAmount: BigNumberish,
-        minAmountOut: BigNumberish,
-        depositCvxMaxAmount: BigNumberish,
-        spendCvxAmount: BigNumberish,
-        options: BigNumberish
-    ) {
-        return ConvexV1ClaimZapAdapter__factory.createInterface().encodeFunctionData(
-            "claimRewards",
-            [
-                rewardContracts,
-                extraRewardContracts,
-                tokenRewardContracts,
-                tokenRewardTokens,
-                depositCrvMaxAmount,
-                minAmountOut,
-                depositCvxMaxAmount,
-                spendCvxAmount,
-                options
-            ]
-        );
-    }
+  public static claimRewards(
+    rewardContracts: Array<string>,
+    extraRewardContracts: Array<string>,
+    tokenRewardContracts: Array<string>,
+    tokenRewardTokens: Array<string>,
+    depositCrvMaxAmount: BigNumberish,
+    minAmountOut: BigNumberish,
+    depositCvxMaxAmount: BigNumberish,
+    spendCvxAmount: BigNumberish,
+    options: BigNumberish
+  ) {
+    return ConvexV1ClaimZapAdapter__factory.createInterface().encodeFunctionData(
+      "claimRewards",
+      [
+        rewardContracts,
+        extraRewardContracts,
+        tokenRewardContracts,
+        tokenRewardTokens,
+        depositCrvMaxAmount,
+        minAmountOut,
+        depositCvxMaxAmount,
+        spendCvxAmount,
+        options
+      ]
+    );
+  }
 }
 
 export class ConvexBoosterMulticaller {
-    private readonly _address: string;
+  private readonly _address: string;
 
-    constructor(address: string) {
-        this._address = address;
-    }
+  constructor(address: string) {
+    this._address = address;
+  }
 
-    deposit(pid: BigNumberish, amount: BigNumberish, stake: boolean): MultiCallStruct {
-        return {
-            target: this._address,
-            callData: ConvexBoosterCalls.deposit(pid, amount, stake)
-        }
-    }
+  static connect(address: string) {
+    return new ConvexBoosterMulticaller(address);
+  }
 
-    depositAll(pid: BigNumberish, stake: boolean): MultiCallStruct {
-        return {
-            target: this._address,
-            callData: ConvexBoosterCalls.depositAll(pid, stake)
-        }
-    }
+  deposit(
+    pid: BigNumberish,
+    amount: BigNumberish,
+    stake: boolean
+  ): MultiCallStruct {
+    return {
+      target: this._address,
+      callData: ConvexBoosterCalls.deposit(pid, amount, stake)
+    };
+  }
 
-    withdraw(pid: BigNumberish, amount: BigNumberish): MultiCallStruct {
-        return {
-            target: this._address,
-            callData: ConvexBoosterCalls.withdraw(pid, amount)
-        }
-    }
+  depositAll(pid: BigNumberish, stake: boolean): MultiCallStruct {
+    return {
+      target: this._address,
+      callData: ConvexBoosterCalls.depositAll(pid, stake)
+    };
+  }
 
-    withdrawAll(pid: BigNumberish): MultiCallStruct {
-        return {
-            target: this._address,
-            callData: ConvexBoosterCalls.withdrawAll(pid)
-        }
-    }
+  withdraw(pid: BigNumberish, amount: BigNumberish): MultiCallStruct {
+    return {
+      target: this._address,
+      callData: ConvexBoosterCalls.withdraw(pid, amount)
+    };
+  }
+
+  withdrawAll(pid: BigNumberish): MultiCallStruct {
+    return {
+      target: this._address,
+      callData: ConvexBoosterCalls.withdrawAll(pid)
+    };
+  }
 }
 
 export class ConvexPoolMulticaller {
-    private readonly _address: string;
+  private readonly _address: string;
 
-    constructor(address: string) {
-        this._address = address;
-    }
+  constructor(address: string) {
+    this._address = address;
+  }
 
-    stake(amount: BigNumberish): MultiCallStruct {
-        return {
-            target: this._address,
-            callData: ConvexPoolCalls.stake(amount)
-        }
-    }
+  static connect(address: string) {
+    return new ConvexPoolMulticaller(address);
+  }
 
-    stakeAll(): MultiCallStruct {
-        return {
-            target: this._address,
-            callData: ConvexPoolCalls.stakeAll()
-        }
-    }
+  stake(amount: BigNumberish): MultiCallStruct {
+    return {
+      target: this._address,
+      callData: ConvexPoolCalls.stake(amount)
+    };
+  }
 
-    withdraw(amount: BigNumberish, claim: boolean): MultiCallStruct {
-        return {
-            target: this._address,
-            callData: ConvexPoolCalls.withdraw(amount, claim)
-        }
-    }
+  stakeAll(): MultiCallStruct {
+    return {
+      target: this._address,
+      callData: ConvexPoolCalls.stakeAll()
+    };
+  }
 
-    withdrawAll(claim: boolean): MultiCallStruct {
-        return {
-            target: this._address,
-            callData: ConvexPoolCalls.withdrawAll(claim)
-        }
-    }
+  withdraw(amount: BigNumberish, claim: boolean): MultiCallStruct {
+    return {
+      target: this._address,
+      callData: ConvexPoolCalls.withdraw(amount, claim)
+    };
+  }
 
-    withdrawAndUnwrap(amount: BigNumberish, claim: boolean): MultiCallStruct {
-        return {
-            target: this._address,
-            callData: ConvexPoolCalls.withdrawAndUnwrap(amount, claim)
-        }
-    }
+  withdrawAll(claim: boolean): MultiCallStruct {
+    return {
+      target: this._address,
+      callData: ConvexPoolCalls.withdrawAll(claim)
+    };
+  }
 
-    withdrawAllAndUnwrap(claim: boolean) {
-        return {
-            target: this._address,
-            callData: ConvexPoolCalls.withdrawAllAndUnwrap(claim)
-        }
-    }
+  withdrawAndUnwrap(amount: BigNumberish, claim: boolean): MultiCallStruct {
+    return {
+      target: this._address,
+      callData: ConvexPoolCalls.withdrawAndUnwrap(amount, claim)
+    };
+  }
+
+  withdrawAllAndUnwrap(claim: boolean) {
+    return {
+      target: this._address,
+      callData: ConvexPoolCalls.withdrawAllAndUnwrap(claim)
+    };
+  }
 }
 
 export class ConvexClaimZapMulticaller {
-    private readonly _address: string;
+  private readonly _address: string;
+
+  constructor(address: string) {
+    this._address = address;
+  }
+
+  static connect(address: string) {
+    return new ConvexClaimZapMulticaller(address);
+  }
+
+  claimRewards(
+    rewardContracts: Array<string>,
+    extraRewardContracts: Array<string>,
+    tokenRewardContracts: Array<string>,
+    tokenRewardTokens: Array<string>,
+    depositCrvMaxAmount: BigNumberish,
+    minAmountOut: BigNumberish,
+    depositCvxMaxAmount: BigNumberish,
+    spendCvxAmount: BigNumberish,
+    options: BigNumberish
+  ): MultiCallStruct {
+    return {
+      target: this._address,
+      callData: ConvexClaimZapCalls.claimRewards(
+        rewardContracts,
+        extraRewardContracts,
+        tokenRewardContracts,
+        tokenRewardTokens,
+        depositCrvMaxAmount,
+        minAmountOut,
+        depositCvxMaxAmount,
+        spendCvxAmount,
+        options
+      )
+    };
+  }
+}
+
+export class ConvexStrategies {
+  static underlyingToStakedConvex(
+    data: CreditManagerData,
+    network: NetworkType,
+    convexPool: ConvexPoolContract,
+    underlyingAmount: BigNumberish
+  ) {
+    let calls: Array<MultiCallStruct> = [];
+    const convexParams = contractParams[convexPool] as ConvexPoolParams;
+    const { stakedToken } = convexParams;
+    const stakedTokenParams = supportedTokens[
+      stakedToken
+    ] as ConvexPhantomTokenData;
+    const curveLpToken = stakedTokenParams.underlying;
+    const curveLpTokenData = supportedTokens[curveLpToken] as CurveLPTokenData;
+    const curvePool = curveLpTokenData.pool;
+
+    calls = CurveStrategies.underlyingToCurveLP(
+      data,
+      network,
+      curvePool,
+      underlyingAmount
+    );
+
+    calls.push(
+      ConvexBoosterMulticaller.connect(
+        data.adapters[contractsByNetwork[network].CONVEX_BOOSTER]
+      ).depositAll(stakedTokenParams.pid, true)
+    );
+
+    return calls;
+  }
+
+  static stakedConvexToUnderlying(
+    data: CreditManagerData,
+    network: NetworkType,
+    convexPool: ConvexPoolContract,
+    convexLpAmount: BigNumberish,
+    sellRewards: boolean
+  ) {
+    const calls: Array<MultiCallStruct> = [];
+    const convexParams = contractParams[convexPool] as ConvexPoolParams;
+    const { stakedToken } = convexParams;
+    const stakedTokenParams = supportedTokens[
+      stakedToken
+    ] as ConvexPhantomTokenData;
+    const curveLpToken = stakedTokenParams.underlying;
+    const curveLpTokenData = supportedTokens[curveLpToken] as CurveLPTokenData;
+    const curvePool = curveLpTokenData.pool;
 
-    constructor(address: string) {
-        this._address = address;
+    calls.push(
+      ConvexPoolMulticaller.connect(
+        data.adapters[contractsByNetwork[network][convexPool]]
+      ).withdrawAndUnwrap(convexLpAmount, true)
+    );
+
+    calls.push(
+      ...CurveStrategies.allCurveLPToUnderlying(data, network, curvePool)
+    );
+
+    if (sellRewards) {
+      calls.push(...ConvexStrategies.sellRewards(data, network, convexPool));
     }
 
-    claimRewards(
-        rewardContracts: Array<string>,
-        extraRewardContracts: Array<string>,
-        tokenRewardContracts: Array<string>,
-        tokenRewardTokens: Array<string>,
-        depositCrvMaxAmount: BigNumberish,
-        minAmountOut: BigNumberish,
-        depositCvxMaxAmount: BigNumberish,
-        spendCvxAmount: BigNumberish,
-        options: BigNumberish
-    ): MultiCallStruct {
-        return {
-            target: this._address,
-            callData: ConvexClaimZapCalls.claimRewards(
-                rewardContracts,
-                extraRewardContracts,
-                tokenRewardContracts,
-                tokenRewardTokens,
-                depositCrvMaxAmount,
-                minAmountOut,
-                depositCvxMaxAmount,
-                spendCvxAmount,
-                options
-            )
-        }
+    return calls;
+  }
+
+  static allStakedConvexToUnderlying(
+    data: CreditManagerData,
+    network: NetworkType,
+    convexPool: ConvexPoolContract,
+    sellRewards: boolean
+  ) {
+    const calls: Array<MultiCallStruct> = [];
+    const convexParams = contractParams[convexPool] as ConvexPoolParams;
+    const { stakedToken } = convexParams;
+    const stakedTokenParams = supportedTokens[
+      stakedToken
+    ] as ConvexPhantomTokenData;
+    const curveLpToken = stakedTokenParams.underlying;
+    const curveLpTokenData = supportedTokens[curveLpToken] as CurveLPTokenData;
+    const curvePool = curveLpTokenData.pool;
+
+    calls.push(
+      ConvexPoolMulticaller.connect(
+        data.adapters[contractsByNetwork[network][convexPool]]
+      ).withdrawAllAndUnwrap(true)
+    );
+
+    calls.push(
+      ...CurveStrategies.allCurveLPToUnderlying(data, network, curvePool)
+    );
+
+    if (sellRewards) {
+      calls.push(...ConvexStrategies.sellRewards(data, network, convexPool));
     }
+
+    return calls;
+  }
+
+  static sellRewards(
+    data: CreditManagerData,
+    network: NetworkType,
+    convexPool: ConvexPoolContract
+  ) {
+    const calls: Array<MultiCallStruct> = [];
+    const convexParams = contractParams[convexPool] as ConvexPoolParams;
+
+    calls.push(
+      UniswapV2Multicaller.connect(
+        data.adapters[contractsByNetwork[network].UNISWAP_V2_ROUTER]
+      ).swapAllTokensForTokens(
+        0,
+        [tokenDataByNetwork[network].CRV, data.underlyingToken],
+        Math.floor(new Date().getTime() / 1000) + 3600
+      ),
+      UniswapV2Multicaller.connect(
+        data.adapters[contractsByNetwork[network].UNISWAP_V2_ROUTER]
+      ).swapAllTokensForTokens(
+        0,
+        [tokenDataByNetwork[network].CVX, data.underlyingToken],
+        Math.floor(new Date().getTime() / 1000) + 3600
+      )
+    );
+
+    convexParams.extraRewards.forEach(extraReward => {
+      UniswapV2Multicaller.connect(
+        data.adapters[contractsByNetwork[network].UNISWAP_V2_ROUTER]
+      ).swapAllTokensForTokens(
+        0,
+        [
+          tokenDataByNetwork[network][extraReward.rewardToken],
+          data.underlyingToken
+        ],
+        Math.floor(new Date().getTime() / 1000) + 3600
+      );
+    });
+
+    return calls;
+  }
 }