@gearbox-protocol/sdk 0.0.101 → 0.0.104

package/src/strategies/lido.ts

@@ -1,46 +1,84 @@
-import { BigNumberish } from "ethers"
+import { BigNumberish } from "ethers";
+import { CreditManagerData } from "src/core/creditManager";
+import { ADDRESS_0X0, NetworkType } from "src/core/constants";
 
-
-import {
-    LidoV1Adapter__factory
-} from "../types";
+import { contractsByNetwork } from "src/contracts/contracts";
+import { tokenDataByNetwork } from "src/tokens/token";
+import { LidoV1Adapter__factory } from "../types";
 
 import { MultiCallStruct } from "../types/contracts/interfaces/ICreditFacade.sol/ICreditFacade";
-
+import { UniswapV2Multicaller } from "./uniswapV2";
 
 export class LidoCalls {
-    public static submit(amount: BigNumberish) {
-        return LidoV1Adapter__factory.createInterface().encodeFunctionData(
-            "submit",
-            [amount]
-        )
-    }
+  public static submit(amount: BigNumberish) {
+    return LidoV1Adapter__factory.createInterface().encodeFunctionData(
+      "submit",
+      [amount]
+    );
+  }
 
-    public static submitAll() {
-        return LidoV1Adapter__factory.createInterface().encodeFunctionData(
-            "submitAll"
-        )
-    }
+  public static submitAll() {
+    return LidoV1Adapter__factory.createInterface().encodeFunctionData(
+      "submitAll"
+    );
+  }
 }
 
 export class LidoMulticaller {
-    private readonly _address: string;
+  private readonly _address: string;
 
-    constructor(address: string) {
-        this._address = address;
-    }
+  constructor(address: string) {
+    this._address = address;
+  }
 
-    submit(amount: BigNumberish): MultiCallStruct {
-        return {
-            target: this._address,
-            callData: LidoCalls.submit(amount)
-        }
-    }
+  static connect(address: string) {
+    return new LidoMulticaller(address);
+  }
 
-    submitAll(): MultiCallStruct {
-        return {
-            target: this._address,
-            callData: LidoCalls.submitAll()
-        }
+  submit(amount: BigNumberish): MultiCallStruct {
+    return {
+      target: this._address,
+      callData: LidoCalls.submit(amount)
+    };
+  }
+
+  submitAll(): MultiCallStruct {
+    return {
+      target: this._address,
+      callData: LidoCalls.submitAll()
+    };
+  }
+}
+
+export class LidoStrategies {
+  static mintSteth(
+    data: CreditManagerData,
+    network: NetworkType,
+    underlyingAmount: BigNumberish
+  ) {
+    const calls: Array<MultiCallStruct> = [];
+
+    // This should be a pathfinder call
+    if (!data.isWETH) {
+      calls.push(
+        UniswapV2Multicaller.connect(
+          data.adapters[contractsByNetwork[network].UNISWAP_V2_ROUTER]
+        ).swapExactTokensForTokens(
+          underlyingAmount,
+          0,
+          [data.underlyingToken, tokenDataByNetwork[network].WETH],
+          ADDRESS_0X0,
+          Math.floor(new Date().getTime() / 1000) + 3600
+        )
+      );
     }
+
+    calls.push(
+      LidoMulticaller.connect(
+        data.adapters[contractsByNetwork[network].LIDO_STETH_GATEWAY]
+      ).submitAll()
+    );
+
+    return calls;
+  }
 }

package/src/strategies/uniswapV2.ts

@@ -1,127 +1,109 @@
-import { BigNumberish } from "ethers"
+import { BigNumberish } from "ethers";
 
-
-import {
-    UniswapV2Adapter__factory
-} from "../types";
+import { UniswapV2Adapter__factory } from "../types";
 
 import { MultiCallStruct } from "../types/contracts/interfaces/ICreditFacade.sol/ICreditFacade";
 
 export class UniswapV2Calls {
-    public static swapExactTokensForTokens(
-        amountIn: BigNumberish,
-        amountOutMin: BigNumberish,
-        path: Array<string>,
-        to: string,
-        deadline: BigNumberish
-    ) {
-        return UniswapV2Adapter__factory.createInterface().encodeFunctionData(
-            "swapExactTokensForTokens",
-            [
-                amountIn,
-                amountOutMin,
-                path,
-                to,
-                deadline
-            ]
-        )
-    }
-
-    public static swapTokensForExactTokens(
-        amountOut: BigNumberish,
-        amountInMax: BigNumberish,
-        path: Array<string>,
-        to: string,
-        deadline: BigNumberish
-    ) {
-        return UniswapV2Adapter__factory.createInterface().encodeFunctionData(
-            "swapTokensForExactTokens",
-            [
-                amountOut,
-                amountInMax,
-                path,
-                to,
-                deadline
-            ]
-        )
-    }
+  public static swapExactTokensForTokens(
+    amountIn: BigNumberish,
+    amountOutMin: BigNumberish,
+    path: Array<string>,
+    to: string,
+    deadline: BigNumberish
+  ) {
+    return UniswapV2Adapter__factory.createInterface().encodeFunctionData(
+      "swapExactTokensForTokens",
+      [amountIn, amountOutMin, path, to, deadline]
+    );
+  }
 
-    public static swapAllTokensForTokens(
-        rateMinRAY: BigNumberish,
-        path: Array<string>,
-        deadline: BigNumberish
-    ) {
-        return UniswapV2Adapter__factory.createInterface().encodeFunctionData(
-            "swapAllTokensForTokens",
-            [
-                rateMinRAY,
-                path,
-                deadline
-            ]
-        )
-    }
+  public static swapTokensForExactTokens(
+    amountOut: BigNumberish,
+    amountInMax: BigNumberish,
+    path: Array<string>,
+    to: string,
+    deadline: BigNumberish
+  ) {
+    return UniswapV2Adapter__factory.createInterface().encodeFunctionData(
+      "swapTokensForExactTokens",
+      [amountOut, amountInMax, path, to, deadline]
+    );
+  }
 
+  public static swapAllTokensForTokens(
+    rateMinRAY: BigNumberish,
+    path: Array<string>,
+    deadline: BigNumberish
+  ) {
+    return UniswapV2Adapter__factory.createInterface().encodeFunctionData(
+      "swapAllTokensForTokens",
+      [rateMinRAY, path, deadline]
+    );
+  }
 }
 
 export class UniswapV2Multicaller {
-    private readonly _address: string;
-
-    constructor(address: string) {
-        this._address = address;
-    }
+  private readonly _address: string;
 
-    swapExactTokensForTokens(
-        amountIn: BigNumberish,
-        amountOutMin: BigNumberish,
-        path: Array<string>,
-        to: string,
-        deadline: BigNumberish
-    ): MultiCallStruct {
+  constructor(address: string) {
+    this._address = address;
+  }
 
-        return {
-            target: this._address,
-            callData: UniswapV2Calls.swapExactTokensForTokens(
-                amountIn,
-                amountOutMin,
-                path,
-                to,
-                deadline
-            )
-        }
-    }
+  static connect(address: string) {
+    return new UniswapV2Multicaller(address);
+  }
 
-    swapTokensForExactTokens(
-        amountOut: BigNumberish,
-        amountInMax: BigNumberish,
-        path: Array<string>,
-        to: string,
-        deadline: BigNumberish
-    ): MultiCallStruct {
-        return {
-            target: this._address,
-            callData: UniswapV2Calls.swapExactTokensForTokens(
-                amountOut,
-                amountInMax,
-                path,
-                to,
-                deadline
-            )
-        }
-    }
+  swapExactTokensForTokens(
+    amountIn: BigNumberish,
+    amountOutMin: BigNumberish,
+    path: Array<string>,
+    to: string,
+    deadline: BigNumberish
+  ): MultiCallStruct {
+    return {
+      target: this._address,
+      callData: UniswapV2Calls.swapExactTokensForTokens(
+        amountIn,
+        amountOutMin,
+        path,
+        to,
+        deadline
+      )
+    };
+  }
 
-    swapAllTokensForTokens(
-        rateMinRAY: BigNumberish,
-        path: Array<string>,
-        deadline: BigNumberish
-    ): MultiCallStruct {
-        return {
-            target: this._address,
-            callData: UniswapV2Calls.swapAllTokensForTokens(
-                rateMinRAY,
-                path,
-                deadline
-            )
-        }
-    }
+  swapTokensForExactTokens(
+    amountOut: BigNumberish,
+    amountInMax: BigNumberish,
+    path: Array<string>,
+    to: string,
+    deadline: BigNumberish
+  ): MultiCallStruct {
+    return {
+      target: this._address,
+      callData: UniswapV2Calls.swapExactTokensForTokens(
+        amountOut,
+        amountInMax,
+        path,
+        to,
+        deadline
+      )
+    };
+  }
 
+  swapAllTokensForTokens(
+    rateMinRAY: BigNumberish,
+    path: Array<string>,
+    deadline: BigNumberish
+  ): MultiCallStruct {
+    return {
+      target: this._address,
+      callData: UniswapV2Calls.swapAllTokensForTokens(
+        rateMinRAY,
+        path,
+        deadline
+      )
+    };
+  }
 }

package/src/strategies/uniswapV3.ts

@@ -1,100 +1,127 @@
-//import { BigNumberish } from "ethers";
+// import { BigNumberish } from "ethers";
 
-
-import { UniswapV3Adapter__factory } from "../types"
-import { ISwapRouter, IUniswapV3Adapter } from "../types/contracts/adapters/uniswap/UniswapV3.sol/UniswapV3Adapter";
+import { UniswapV3Adapter__factory } from "../types";
+import {
+  ISwapRouter,
+  IUniswapV3Adapter
+} from "../types/contracts/adapters/uniswap/UniswapV3.sol/UniswapV3Adapter";
 
 import { MultiCallStruct } from "../types/contracts/interfaces/ICreditFacade.sol/ICreditFacade";
 
 export class UniswapV3Calls {
-    public static exactInputSingle(params: ISwapRouter.ExactInputSingleParamsStructOutput) {
-        return UniswapV3Adapter__factory.createInterface().encodeFunctionData(
-            "exactInputSingle",
-            [params]
-        )
-    }
-
-    public static exactAllInputSingle(params: IUniswapV3Adapter.ExactAllInputSingleParamsStructOutput) {
-        return UniswapV3Adapter__factory.createInterface().encodeFunctionData(
-            "exactAllInputSingle",
-            [params]
-        )
-    }
-
-    public static exactInput(params: ISwapRouter.ExactInputParamsStructOutput) {
-        return UniswapV3Adapter__factory.createInterface().encodeFunctionData(
-            "exactInput",
-            [params]
-        )
-    }
-
-    public static exactAllInput(params: IUniswapV3Adapter.ExactAllInputParamsStructOutput) {
-        return UniswapV3Adapter__factory.createInterface().encodeFunctionData(
-            "exactAllInput",
-            [params]
-        )
-    }
-
-    public static exactOutputSingle(params: ISwapRouter.ExactOutputSingleParamsStructOutput) {
-        return UniswapV3Adapter__factory.createInterface().encodeFunctionData(
-            "exactOutputSingle",
-            [params]
-        )
-    }
-
-    public static exactOutput(params: ISwapRouter.ExactOutputParamsStructOutput) {
-        return UniswapV3Adapter__factory.createInterface().encodeFunctionData(
-            "exactOutput",
-            [params]
-        )
-    }
+  public static exactInputSingle(
+    params: ISwapRouter.ExactInputSingleParamsStructOutput
+  ) {
+    return UniswapV3Adapter__factory.createInterface().encodeFunctionData(
+      "exactInputSingle",
+      [params]
+    );
+  }
+
+  public static exactAllInputSingle(
+    params: IUniswapV3Adapter.ExactAllInputSingleParamsStructOutput
+  ) {
+    return UniswapV3Adapter__factory.createInterface().encodeFunctionData(
+      "exactAllInputSingle",
+      [params]
+    );
+  }
+
+  public static exactInput(params: ISwapRouter.ExactInputParamsStructOutput) {
+    return UniswapV3Adapter__factory.createInterface().encodeFunctionData(
+      "exactInput",
+      [params]
+    );
+  }
+
+  public static exactAllInput(
+    params: IUniswapV3Adapter.ExactAllInputParamsStructOutput
+  ) {
+    return UniswapV3Adapter__factory.createInterface().encodeFunctionData(
+      "exactAllInput",
+      [params]
+    );
+  }
+
+  public static exactOutputSingle(
+    params: ISwapRouter.ExactOutputSingleParamsStructOutput
+  ) {
+    return UniswapV3Adapter__factory.createInterface().encodeFunctionData(
+      "exactOutputSingle",
+      [params]
+    );
+  }
+
+  public static exactOutput(params: ISwapRouter.ExactOutputParamsStructOutput) {
+    return UniswapV3Adapter__factory.createInterface().encodeFunctionData(
+      "exactOutput",
+      [params]
+    );
+  }
 }
 
 export class UniswapV3Multicaller {
-    private readonly _address: string;
-
-    constructor(address: string) {
-        this._address = address;
-    }
-
-    exactInputSingle(params: ISwapRouter.ExactInputSingleParamsStructOutput): MultiCallStruct {
-        return {
-            target: this._address,
-            callData: UniswapV3Calls.exactInputSingle(params)
-        }
-    }
-
-    exactAllInputSingle(params: IUniswapV3Adapter.ExactAllInputSingleParamsStructOutput): MultiCallStruct {
-        return {
-            target: this._address,
-            callData: UniswapV3Calls.exactAllInputSingle(params)
-        }
-    }
-    exactInput(params: ISwapRouter.ExactInputParamsStructOutput): MultiCallStruct {
-        return {
-            target: this._address,
-            callData: UniswapV3Calls.exactInput(params)
-        }
-    }
-
-    exactAllInput(params: IUniswapV3Adapter.ExactAllInputParamsStructOutput): MultiCallStruct {
-        return {
-            target: this._address,
-            callData: UniswapV3Calls.exactAllInput(params)
-        }
-    }
-
-    exactOutputSingle(params: ISwapRouter.ExactOutputSingleParamsStructOutput): MultiCallStruct {
-        return {
-            target: this._address,
-            callData: UniswapV3Calls.exactOutputSingle(params)
-        }
-    }
-
-    exactOutput(params: ISwapRouter.ExactOutputParamsStructOutput): MultiCallStruct {
-        return {
-            target: this._address,
-            callData: UniswapV3Calls.exactOutput(params)
-        }
-    }
+  private readonly _address: string;
+
+  constructor(address: string) {
+    this._address = address;
+  }
+
+  static connect(address: string) {
+    return new UniswapV3Multicaller(address);
+  }
+
+  exactInputSingle(
+    params: ISwapRouter.ExactInputSingleParamsStructOutput
+  ): MultiCallStruct {
+    return {
+      target: this._address,
+      callData: UniswapV3Calls.exactInputSingle(params)
+    };
+  }
+
+  exactAllInputSingle(
+    params: IUniswapV3Adapter.ExactAllInputSingleParamsStructOutput
+  ): MultiCallStruct {
+    return {
+      target: this._address,
+      callData: UniswapV3Calls.exactAllInputSingle(params)
+    };
+  }
+
+  exactInput(
+    params: ISwapRouter.ExactInputParamsStructOutput
+  ): MultiCallStruct {
+    return {
+      target: this._address,
+      callData: UniswapV3Calls.exactInput(params)
+    };
+  }
+
+  exactAllInput(
+    params: IUniswapV3Adapter.ExactAllInputParamsStructOutput
+  ): MultiCallStruct {
+    return {
+      target: this._address,
+      callData: UniswapV3Calls.exactAllInput(params)
+    };
+  }
+
+  exactOutputSingle(
+    params: ISwapRouter.ExactOutputSingleParamsStructOutput
+  ): MultiCallStruct {
+    return {
+      target: this._address,
+      callData: UniswapV3Calls.exactOutputSingle(params)
+    };
+  }
+
+  exactOutput(
+    params: ISwapRouter.ExactOutputParamsStructOutput
+  ): MultiCallStruct {
+    return {
+      target: this._address,
+      callData: UniswapV3Calls.exactOutput(params)
+    };
+  }
 }