@gearbox-protocol/sdk 0.0.55 → 0.0.56

package/lib/pathfinder/yearnVaultOfMetaCurveLPPathAsset.js

@@ -0,0 +1,87 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.YearnVaultOfMetaCurveLPPathAsset = void 0;
+var token_1 = require("../core/token");
+var path_1 = require("./path");
+var ethers_1 = require("ethers");
+var YearnVaultOfMetaCurveLPPathAsset = /** @class */ (function (_super) {
+    __extends(YearnVaultOfMetaCurveLPPathAsset, _super);
+    function YearnVaultOfMetaCurveLPPathAsset() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    YearnVaultOfMetaCurveLPPathAsset.prototype.getBestPath = function (currentToken, p) {
+        return __awaiter(this, void 0, void 0, function () {
+            var currentBalance, currentTokenData, outputToken, yearnActionData;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        currentBalance = p.balances[currentToken].sub(1);
+                        currentTokenData = token_1.supportedTokens[currentToken];
+                        outputToken = currentTokenData.lpActions[0].tokenOut;
+                        return [4 /*yield*/, this.getYearnActionData(currentTokenData.lpActions[0], currentBalance, p)];
+                    case 1:
+                        yearnActionData = _a.sent();
+                        p.balances[outputToken].add(yearnActionData.amountOut);
+                        p.balances[currentToken] = ethers_1.BigNumber.from(1);
+                        p.totalGasLimit.add(yearnActionData.gasLimit);
+                        p.calls.push(yearnActionData.callData);
+                        return [4 /*yield*/, p.getBestPath()];
+                    case 2: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    return YearnVaultOfMetaCurveLPPathAsset;
+}(path_1.PathAsset));
+exports.YearnVaultOfMetaCurveLPPathAsset = YearnVaultOfMetaCurveLPPathAsset;

package/lib/pathfinder/yearnVaultPathAsset.d.ts

@@ -0,0 +1,5 @@
+import { SupportedToken } from "../core/token";
+import { Path, PathAsset } from "./path";
+export declare class YearnVaultPathAsset extends PathAsset {
+    getBestPath(currentToken: SupportedToken, p: Path): Promise<Path>;
+}

package/lib/pathfinder/yearnVaultPathAsset.js

@@ -0,0 +1,87 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.YearnVaultPathAsset = void 0;
+var ethers_1 = require("ethers");
+var token_1 = require("../core/token");
+var path_1 = require("./path");
+var YearnVaultPathAsset = /** @class */ (function (_super) {
+    __extends(YearnVaultPathAsset, _super);
+    function YearnVaultPathAsset() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    YearnVaultPathAsset.prototype.getBestPath = function (currentToken, p) {
+        return __awaiter(this, void 0, void 0, function () {
+            var currentBalance, currentTokenData, outputToken, yearnActionData;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        currentBalance = p.balances[currentToken].sub(1);
+                        currentTokenData = token_1.supportedTokens[currentToken];
+                        outputToken = currentTokenData.lpActions[0].tokenOut;
+                        return [4 /*yield*/, this.getYearnActionData(currentTokenData.lpActions[0], currentBalance, p)];
+                    case 1:
+                        yearnActionData = _a.sent();
+                        p.balances[outputToken].add(yearnActionData.amountOut);
+                        p.balances[currentToken] = ethers_1.BigNumber.from(1);
+                        p.totalGasLimit.add(yearnActionData.gasLimit);
+                        p.calls.push(yearnActionData.callData);
+                        return [4 /*yield*/, p.getBestPath()];
+                    case 2: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    return YearnVaultPathAsset;
+}(path_1.PathAsset));
+exports.YearnVaultPathAsset = YearnVaultPathAsset;

package/lib/utils/types.d.ts

@@ -0,0 +1,3 @@
+export declare type PartialRecord<K extends keyof any, T> = {
+    [P in K]?: T;
+};

package/lib/utils/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gearbox-protocol/sdk",
-  "version": "0.0.55",
+  "version": "0.0.56",
   "description": "Gearbox SDK",
   "main": "./lib/index.js",
   "types": "./lib/index.d.ts",

package/src/core/contracts.ts

@@ -22,6 +22,7 @@ export type CurvePoolContract =
   | "CURVE_FRAX_POOL"
   | "CURVE_LUSD_POOL"
   | "CURVE_GUSD_POOL"
+  | "CURVE_SUSD_DEPOSIT"
   | "CURVE_SUSD_POOL";
 
 export type YearnVaultContract =
@@ -64,6 +65,7 @@ export const contractsByNetwork: Record<
     CURVE_FRAX_POOL: tokenDataByNetwork.Mainnet.FRAX3CRV,
     CURVE_LUSD_POOL: tokenDataByNetwork.Mainnet.LUSD3CRV,
     CURVE_SUSD_POOL: "0xA5407eAE9Ba41422680e2e00537571bcC53efBfD", // SEPARATE TOKEN
+    CURVE_SUSD_DEPOSIT: "0xFCBa3E75865d2d561BE8D220616520c171F12851",
     CURVE_GUSD_POOL: "0x4f062658EaAF2C1ccf8C8e36D6824CDf41167956", // SEPARATE TOKEN
 
     // YEARN
@@ -97,6 +99,7 @@ export const contractsByNetwork: Record<
     CURVE_FRAX_POOL: "",
     CURVE_LUSD_POOL: tokenDataByNetwork.Kovan.LUSD3CRV,
     CURVE_SUSD_POOL: "0x032f1cE00865F3499C0052ceBA5F2348842416DB", // SEPARATE TOKEN
+    CURVE_SUSD_DEPOSIT: "",
     CURVE_GUSD_POOL: "",
 
     // YEARN
@@ -247,12 +250,19 @@ export const contractParams: Record<SupportedContract, ContractParams> = {
     lpToken: "crvPlain3andSUSD",
     tokens: ["DAI", "USDC", "USDT", "sUSD"]
   },
+  CURVE_SUSD_DEPOSIT: {
+      name: "Curve SUSD Deposit",
+      protocol: Protocols.Curve,
+      type: AdapterInterface.CURVE_V1_4ASSETS,
+      lpToken: "crvPlain3andSUSD",
+      tokens: ["DAI", "USDC", "USDT", "sUSD"]
+  },
   CURVE_GUSD_POOL: {
     name: "Curve GUSD",
     protocol: Protocols.Curve,
     type: AdapterInterface.CURVE_V1_2ASSETS,
     lpToken: "gusd3CRV",
-    tokens: ["3Crv", "FRAX"]
+    tokens: ["3Crv", "GUSD"]
   },
 
   YEARN_DAI_VAULT: {

package/src/core/token.ts

@@ -2,6 +2,8 @@ import { objectEntries, keyToLowercase, swapKeyValue } from "../utils/mappers";
 import { NetworkType } from "./constants";
 import { ConvexPoolContract } from "./contracts";
 import { TradeAction, TradeType } from "./tradeTypes";
+import { PartialRecord } from "../utils/types";
+import { BigNumber } from "ethers";
 
 export enum TokenType {
   CONNECTOR,
@@ -29,6 +31,14 @@ export const priority: Record<TokenType, number> = {
   [TokenType.DIESEL_LP_TOKEN]: 6
 };
 
+export const Curve3CrvUnderlyingTokenIndex: PartialRecord<SupportedToken, BigNumber> = {
+  DAI: BigNumber.from(0),
+  USDC: BigNumber.from(1),
+  USDT: BigNumber.from(2)
+}
+
+export const ConnectorTokens: Array<SupportedToken> = ["DAI", "USDC", "WETH", "WBTC"];
+
 export type NormalToken =
   | "1INCH"
   | "AAVE"
@@ -182,6 +192,7 @@ type DieselTokenData = {
 
 type GearboxTokenData = {
   symbol: GearboxToken;
+  swapActions?: Array<TradeAction>;
   type: TokenType.NORMAL_TOKEN;
 } & TokenBase;
 
@@ -199,6 +210,7 @@ export type TokenDataI =
   | GearboxTokenData;
 
 export const supportedTokens: Record<SupportedToken, TokenDataI> = {
+
   "1INCH": {
     name: "1INCH",
     decimals: 18,

package/src/core/tradeTypes.ts

@@ -34,10 +34,12 @@ export type TradeAction =
   | {
       type: TradeType.UniswapV2Swap;
       contract: UniswapV2Contract;
+      tokenOut?: NormalToken;
     }
   | {
       type: TradeType.UniswapV3Swap;
       contract: "UNISWAP_V3_ROUTER";
+      tokenOut?: NormalToken;
     }
   | {
       type: TradeType.CurveExchange;

package/src/pathfinder/connectorPathAsset.ts

@@ -0,0 +1,69 @@
+import {BigNumber} from "ethers";
+import {
+    SupportedToken,
+    supportedTokens,
+    tokenDataByNetwork,
+    TokenDataI,
+    TokenType
+} from "../core/token";
+import {Path, PathAsset, ActionData} from "./path";
+
+export class ConnectorPathAsset extends PathAsset {
+    async getBestPath(currentToken: SupportedToken, p: Path): Promise<Path> {
+        type ConnectorDataI = Extract<TokenDataI, { type: TokenType.CONNECTOR }>;
+
+        const currentBalance: BigNumber = p.balances[currentToken].sub(1);
+        const currentTokenAddress: string = tokenDataByNetwork[p.networkType][currentToken];
+        const currentTokenData: TokenDataI = supportedTokens[currentToken] as ConnectorDataI;
+        // connector token will only swap to pool
+        const nextToken: SupportedToken = p.pool;
+        const nextTokenAddress: string = tokenDataByNetwork[p.networkType][nextToken];
+
+        let actionData: ActionData = {
+            callData: {
+                targetContract: "",
+                callData: ""
+            },
+            amountOut: BigNumber.from(0),
+            gasLimit: BigNumber.from(0),
+        };
+        for (let swapAction of currentTokenData.swapActions) {
+            const tmpActionData: ActionData = await this.getActionData(swapAction, currentTokenAddress, currentToken, currentBalance, nextTokenAddress, nextToken, p);
+
+            if (tmpActionData.amountOut > actionData.amountOut) {
+                actionData = tmpActionData;
+            }
+        }
+
+        if (actionData.callData.targetContract != "") {
+            p.balances[nextToken].add(actionData.amountOut);
+            p.balances[currentToken] = BigNumber.from(1);
+            p.totalGasLimit.add(actionData.gasLimit);
+            p.calls.push(actionData.callData);
+        }
+
+        return await p.getBestPath();
+    }
+
+    // Only compute the maximum amount of pool token output, will not modify path.
+    async getMaxPoolAmount(currentToken: SupportedToken, currentBalance: BigNumber, p: Path): Promise<BigNumber> {
+        type ConnectorDataI = Extract<TokenDataI, { type: TokenType.CONNECTOR }>;
+
+        const currentTokenAddress: string = tokenDataByNetwork[p.networkType][currentToken];
+        const currentTokenData: TokenDataI = supportedTokens[currentToken] as ConnectorDataI;
+        // connector token will only swap to pool
+        const nextToken: SupportedToken = p.pool;
+        const nextTokenAddress: string = tokenDataByNetwork[p.networkType][nextToken];
+
+        let maxAmountOut: BigNumber = BigNumber.from(0);
+        for (let swapAction of currentTokenData.swapActions) {
+            const actionData: ActionData = await this.getActionData(swapAction, currentTokenAddress, currentToken, currentBalance, nextTokenAddress, nextToken, p);
+
+            if (actionData.amountOut > maxAmountOut) {
+                maxAmountOut = actionData.amountOut;
+            }
+        }
+
+        return maxAmountOut;
+    }
+}

package/src/pathfinder/convexLPTokenPathAsset.ts

@@ -0,0 +1,33 @@
+import {BigNumber} from "ethers";
+import {
+    SupportedToken,
+    supportedTokens,
+    TokenDataI,
+    TokenType
+} from "../core/token";
+import {contractsByNetwork} from "../core/contracts";
+import {TradeType} from "../core/tradeTypes";
+import {Path, PathAsset} from "./path";
+
+export class ConvexLPTokenPathAsset extends PathAsset {
+    async getBestPath(currentToken: SupportedToken, p: Path): Promise<Path> {
+        throw Error("Implementation not finished!");
+        const currentBalance: BigNumber = p.balances[currentToken].sub(1);
+        type ConvexLPTokenDataI = Extract<TokenDataI, { type: TokenType.CONVEX_LP_TOKEN }>;
+        const currentTokenData: ConvexLPTokenDataI = supportedTokens[currentToken] as ConvexLPTokenDataI;
+
+        for (let lpAction of currentTokenData.lpActions) {
+            if (lpAction.type == TradeType.ConvexWithdrawLP) {
+                const actionContractAddress: string = contractsByNetwork[p.networkType][lpAction.contract];
+                const adapterAddress: string = p.creditManager.adapters[actionContractAddress];
+                const outputToken: SupportedToken = lpAction.tokenOut as SupportedToken;
+                console.log(currentBalance);
+                console.log(adapterAddress);
+                console.log(outputToken);
+                // TODO(byli) wait convex adapter types
+            }
+        }
+
+        return await p.getBestPath();
+    }
+}

package/src/pathfinder/curveLPPathAsset.ts

@@ -0,0 +1,10 @@
+import {SupportedToken} from "../core/token";
+import {Path, PathAsset} from "./path";
+
+export class CurveLPPathAsset extends PathAsset {
+    async getBestPath(currentToken: SupportedToken, p: Path): Promise<Path> {
+        console.log(currentToken);
+        console.log(p);
+        throw Error("Not implemented yet.");
+    }
+}

package/src/pathfinder/metaCurveLPPathAsset.ts

@@ -0,0 +1,12 @@
+import {
+    SupportedToken,
+} from "../core/token";
+import {Path, PathAsset} from "./path";
+
+export class MetaCurveLPPathAsset extends PathAsset {
+    async getBestPath(currentToken: SupportedToken, p: Path): Promise<Path> {
+        console.log(currentToken);
+        console.log(p);
+        throw Error("Not implemented yet.");
+    }
+}

package/src/pathfinder/normalTokenPathAsset.ts

@@ -0,0 +1,68 @@
+import {BigNumber} from "ethers";
+import {
+    ConnectorTokens,
+    SupportedToken,
+    supportedTokens,
+    tokenDataByNetwork,
+    TokenDataI,
+    TokenType
+} from "../core/token";
+import {ActionData, Path, PathAsset} from "./path";
+import {ConnectorPathAsset} from "./connectorPathAsset";
+
+export class NormalTokenPathAsset extends PathAsset {
+    async getBestPath(currentToken: SupportedToken, p: Path): Promise<Path> {
+        type ConnectorDataI = Extract<TokenDataI, { type: TokenType.NORMAL_TOKEN }>;
+
+        const currentBalance: BigNumber = p.balances[currentToken].sub(1);
+        const currentTokenAddress: string = tokenDataByNetwork[p.networkType][currentToken];
+        const currentTokenData: TokenDataI = supportedTokens[currentToken] as ConnectorDataI;
+
+        let actionData: ActionData = {
+            callData: {
+                targetContract: "",
+                callData: ""
+            },
+            amountOut: BigNumber.from(0),
+            gasLimit: BigNumber.from(0),
+        };
+        let nextToken: SupportedToken = p.pool;
+        let maxPoolAmountOut: BigNumber = BigNumber.from(0);
+
+        // enumerate connector token and find a best one
+        for (let connToken of ConnectorTokens) {
+            const connTokenAddress: string = tokenDataByNetwork[p.networkType][connToken];
+
+            for (let swapAction of currentTokenData.swapActions!) {
+               const tmpActionData: ActionData = await this.getActionData(swapAction, currentTokenAddress, currentToken, currentBalance, connTokenAddress, connToken, p);
+
+                // compute connToken to pool token
+                if (connToken != p.pool) {
+                    const connectorPathAsset = new ConnectorPathAsset();
+                    const poolAmountOut: BigNumber = await connectorPathAsset.getMaxPoolAmount(connToken, actionData.amountOut, p);
+                    if (poolAmountOut > maxPoolAmountOut) {
+                        maxPoolAmountOut = poolAmountOut;
+
+                        actionData = tmpActionData;
+                        nextToken = connToken;
+                    }
+                } else {
+                   if (actionData.amountOut > maxPoolAmountOut) {
+                       maxPoolAmountOut = actionData.amountOut;
+
+                       actionData = tmpActionData;
+                       nextToken = p.pool;
+                   }
+                }
+            }
+        }
+
+        if (actionData.callData.targetContract != "") {
+            p.balances[nextToken].add(actionData.amountOut);
+            p.balances[currentToken] = BigNumber.from(1);
+            p.totalGasLimit.add(actionData.gasLimit);
+            p.calls.push(actionData.callData);
+        }
+        return await p.getBestPath();
+    }
+}