npm - @gearbox-protocol/sdk - Versions diffs - 0.0.38 → 0.0.39 - Mend

@gearbox-protocol/sdk 0.0.38 → 0.0.39

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (7) hide show

package/lib/core/pathfinder.d.ts CHANGED Viewed

@@ -2,12 +2,18 @@ import { BigNumber } from "ethers";
 import { CreditManagerData } from "./creditManager";
 import { MultiCall } from "./multicall";
 import { SupportedTokens } from "./token";
-export interface Path {
-    calls: Array<MultiCall>;
-    balances: Record<SupportedTokens, BigNumber>;
-    gasUsed: number;
-    pool: SupportedTokens;
-    creditManager: CreditManagerData;
+export declare class Path {
+    readonly calls: Array<MultiCall>;
+    readonly balances: Record<SupportedTokens, BigNumber>;
+    protected _gasUsed: number;
+    readonly pool: SupportedTokens;
+    readonly creditManager: CreditManagerData;
+    constructor(opts: {
+        gasUsed: number;
+        balances: Record<SupportedTokens, BigNumber>;
+        pool: SupportedTokens;
+        creditManager: CreditManagerData;
+    });
     getBestPath(): Promise<Path>;
 }
 export interface PathAsset {

package/lib/core/pathfinder.js CHANGED Viewed

@@ -1,16 +1,129 @@
 "use strict";
+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.ConnectorPathAsset = void 0;
+exports.ConnectorPathAsset = exports.Path = void 0;
+// const path = new Path({gasUsed:0, balances: creditAccount.balances, })
+// const closurePath = await path.getBestPath();
+// closurePath.calls -> multicalls (!)
+// closurePath.balances[path.pool] = (X)
+// closurePath.balances[!path.pool] = 0 / 1;
+//
+// [0,0,0, 100]
+// [ 12, 12, 12, 0]
+var Path = /** @class */ (function () {
+    function Path(opts) {
+        this.calls = [];
+        this._gasUsed = opts.gasUsed;
+        this.balances = opts.balances;
+        this.pool = opts.pool;
+        this.creditManager = opts.creditManager;
+    }
+    Path.prototype.getBestPath = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                //  const nextToken = Object.entries(this.balances).filter(([token, balance]) => balance.gt(1) ) //.sort((a,b) => {})
+                //  if (nextToken.length ===1 ) {
+                //  }
+                // Get balances and keep non-zero only
+                // Find token with highest priority
+                // Get token type of this token
+                // switch (type) {
+                //  case TokenType.YearnValut:
+                //     const assetPathClass = new Path(tokenData);
+                //     return assetPathClass.getBestPath(this);
+                //     ...
+                //}
+                throw new Error("Not implmented");
+            });
+        });
+    };
+    return Path;
+}());
+exports.Path = Path;
 var ConnectorPathAsset = /** @class */ (function () {
     function ConnectorPathAsset() {
     }
     ConnectorPathAsset.prototype.getBestPath = function (p) {
         console.log(p);
-        // How to unwrap
+        // How to unwrap
         // set balance of current token to 0
-        // add balnace what we get
+        // add balnace what we get
         // add call
         // create new Paths
+        // 3CRV:
+        // coinst balance3crv = p.balance["3rcv"];
+        // const p.balance["3rcv"] = 0;
+        // DAI
+        // const daiPath = {...p};
+        // const daiPath["Dai"] = await curve.getAmount(t balance3crv);
+        // const pathDai = new Path(daiPath)
+        // ...
+        // const bestPath = pathDai.balance[0] > pathUSDC.balance(0) ? pathDai : pathUsdc;
+        //   --- DAI
+        // --|
+        //   --- USDC
+        //
+        // NORMAL TOKEN
+        // ============
+        //
+        // - NORMAL -> POOL (1 pair) => #1
+        // for(let conn of connectors) {
+        //   const result = getAmount([NORMAL, conn, pool])
+        // }
+        // => best Path to get max Pool tokens
+        // const resultInConnector = getAmount([NORMAL, conn]);
+        // calls.push("Uniswap.swap(NORMAL, conn)");
+        // CRV => CRV -> USDC -> DAI
+        // LINK => LINK -> USDC -> DAI
+        //
+        // [UniV2.swap("CRV", "USDC"),
+        //  UniV3.swap("LINK", "USDC"),
+        //  Curve.exchange("USDC", "DAI")]
+        //
+        // Below is not optimal:
+        // [ UniV2.swap("CRV -> USDC -> DAI"),
+        // UniV2.swap("LINK -> USDC -> DAI")]
+        //
+        //
+        // [ UniV2.swap("CRV -> USDC")
+        // UniV2.swap("USDC -> DAI"),
+        // UniV2.swap("LINK -> USDC"),
+        // UniV2.swap("USDC -> DAI") ]
         // return maxValuable(new Paths.getBestPath())
         throw new Error("Method not implemented.");
     };

package/lib/core/token.d.ts CHANGED Viewed

@@ -19,6 +19,7 @@ export declare type TokenDataI = {
     type: TokenType.CURVE_LP;
 } | {
     type: TokenType.YEARN_VAULT;
+    underlying: SupportedTokens;
 } | {
     type: TokenType.META_CURVE_LP;
 } | {

package/lib/core/token.js CHANGED Viewed

@@ -113,16 +113,20 @@ exports.supportedTokens = {
     },
     // YEARN TOKENS
     yvDAI: {
-        type: TokenType.YEARN_VAULT
+        type: TokenType.YEARN_VAULT,
+        underlying: "DAI",
     },
     yvUSDC: {
-        type: TokenType.YEARN_VAULT
+        type: TokenType.YEARN_VAULT,
+        underlying: "USDC"
     },
     yvWETH: {
-        type: TokenType.YEARN_VAULT
+        type: TokenType.YEARN_VAULT,
+        underlying: "WETH",
     },
     yvWBTC: {
-        type: TokenType.YEARN_VAULT
+        type: TokenType.YEARN_VAULT,
+        underlying: "WBTC"
     },
     // CURVE LP TOKENS
     "3Crv": {

package/package.json CHANGED Viewed

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

package/src/core/pathfinder.ts CHANGED Viewed

@@ -3,24 +3,54 @@ import { CreditManagerData } from "./creditManager";
 import { MultiCall } from "./multicall";
 import { SupportedTokens } from "./token";
-export interface Path {
-  calls: Array<MultiCall>;
-  balances: Record<SupportedTokens, BigNumber>;
-//   usedTokens: Array<SupportedTokens>;
-  gasUsed: number;
-  pool: SupportedTokens;
-  creditManager: CreditManagerData;
-  getBestPath(): Promise<Path>;
-  // Get balances and keep non-zero only
-  // Find token with highest priority
-  // Get token type of this token
-  // switch (type) {
-  //  case TokenType.YearnValut:
-  //     const assetPathClass = new YearnVaultPathAsset(tokenData);
-  //     return assetPathClass.getBestPath(this);
-  //     ...
-  //}
+// const path = new Path({gasUsed:0, balances: creditAccount.balances, })
+// const closurePath = await path.getBestPath();
+// closurePath.calls -> multicalls (!)
+// closurePath.balances[path.pool] = (X)
+// closurePath.balances[!path.pool] = 0 / 1;
+//
+// [0,0,0, 100]
+// [ 12, 12, 12, 0]
+export class Path {
+  public readonly calls: Array<MultiCall> = [];
+  public readonly balances: Record<SupportedTokens, BigNumber>;
+  //   usedTokens: Array<SupportedTokens>;
+  protected _gasUsed: number;
+  public readonly pool: SupportedTokens;
+  public readonly creditManager: CreditManagerData;
+  constructor(opts: {
+    gasUsed: number;
+    balances: Record<SupportedTokens, BigNumber>;
+    pool: SupportedTokens;
+    creditManager: CreditManagerData;
+  }) {
+    this._gasUsed = opts.gasUsed;
+    this.balances = opts.balances;
+    this.pool = opts.pool;
+    this.creditManager = opts.creditManager;
+  }
+  async getBestPath(): Promise<Path> {
+    //  const nextToken = Object.entries(this.balances).filter(([token, balance]) => balance.gt(1) ) //.sort((a,b) => {})
+    //  if (nextToken.length ===1 ) {
+    //  }
+    // Get balances and keep non-zero only
+    // Find token with highest priority
+    // Get token type of this token
+    // switch (type) {
+    //  case TokenType.YearnValut:
+    //     const assetPathClass = new Path(tokenData);
+    //     return assetPathClass.getBestPath(this);
+    //     ...
+    //}
+    throw new Error("Not implmented");
+  }
 }
 export interface PathAsset {
@@ -30,11 +60,55 @@ export interface PathAsset {
 export class ConnectorPathAsset implements PathAsset {
   getBestPath(p: Path): Promise<Path> {
     console.log(p);
-    // How to unwrap
+    // How to unwrap
     // set balance of current token to 0
-    // add balnace what we get
+    // add balnace what we get
     // add call
     // create new Paths
+    // 3CRV:
+    // coinst balance3crv = p.balance["3rcv"];
+    // const p.balance["3rcv"] = 0;
+    // DAI
+    // const daiPath = {...p};
+    // const daiPath["Dai"] = await curve.getAmount(t balance3crv);
+    // const pathDai = new Path(daiPath)
+    // ...
+    // const bestPath = pathDai.balance[0] > pathUSDC.balance(0) ? pathDai : pathUsdc;
+    //   --- DAI
+    // --|
+    //   --- USDC
+    //
+    // NORMAL TOKEN
+    // ============
+    //
+    // - NORMAL -> POOL (1 pair) => #1
+    // for(let conn of connectors) {
+    //   const result = getAmount([NORMAL, conn, pool])
+    // }
+    // => best Path to get max Pool tokens
+    // const resultInConnector = getAmount([NORMAL, conn]);
+    // calls.push("Uniswap.swap(NORMAL, conn)");
+    // CRV => CRV -> USDC -> DAI
+    // LINK => LINK -> USDC -> DAI
+    //
+    // [UniV2.swap("CRV", "USDC"),
+    //  UniV3.swap("LINK", "USDC"),
+    //  Curve.exchange("USDC", "DAI")]
+    //
+    // Below is not optimal:
+    // [ UniV2.swap("CRV -> USDC -> DAI"),
+    // UniV2.swap("LINK -> USDC -> DAI")]
+    //
+    //
+    // [ UniV2.swap("CRV -> USDC")
+    // UniV2.swap("USDC -> DAI"),
+    // UniV2.swap("LINK -> USDC"),
+    // UniV2.swap("USDC -> DAI") ]
     // return maxValuable(new Paths.getBestPath())
     throw new Error("Method not implemented.");
   }

package/src/core/token.ts CHANGED Viewed

@@ -36,6 +36,7 @@ export type TokenDataI =
     }
   | {
       type: TokenType.YEARN_VAULT;
+      underlying: SupportedTokens,
     }
   | {
       type: TokenType.META_CURVE_LP;
@@ -222,19 +223,23 @@ export const supportedTokens: Record<SupportedTokens, TokenDataI> = {
   // YEARN TOKENS
   yvDAI: {
-    type: TokenType.YEARN_VAULT
+    type: TokenType.YEARN_VAULT,
+    underlying: "DAI",
   },
   yvUSDC: {
-    type: TokenType.YEARN_VAULT
+    type: TokenType.YEARN_VAULT,
+    underlying: "USDC"
   },
   yvWETH: {
-    type: TokenType.YEARN_VAULT
+    type: TokenType.YEARN_VAULT,
+    underlying: "WETH",
   },
   yvWBTC: {
-    type: TokenType.YEARN_VAULT
+    type: TokenType.YEARN_VAULT,
+    underlying: "WBTC"
   },
   // CURVE LP TOKENS