@gearbox-protocol/sdk 0.0.53 → 0.0.56

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/core/transactions.ts

@@ -77,7 +77,7 @@ export class TxAddLiquidity extends EVMTx {
   }
 
   toString(tokenData: Record<string, TokenData>): string {
-    const token = tokenData[this.underlyingToken];
+    const token = tokenData[this.underlyingToken.toLowerCase()];
     return `${getContractName(this.pool)}: Deposit ${formatBN(
       this.amount,
       token?.decimals || 18
@@ -115,7 +115,7 @@ export class TxRemoveLiquidity extends EVMTx {
   }
 
   toString(tokenData: Record<string, TokenData>): string {
-    const dtoken = tokenData[this.dieselToken];
+    const dtoken = tokenData[this.dieselToken.toLowerCase()];
     return `${getContractName(this.pool)}: Withdraw ${formatBN(
       this.amount,
       dtoken?.decimals || 18
@@ -165,11 +165,11 @@ export class TXSwap extends EVMTx {
   }
 
   toString(tokenData: Record<string, TokenData>): string {
-    const tokenFrom = tokenData[this.tokenFrom];
+    const tokenFrom = tokenData[this.tokenFrom.toLowerCase()];
 
     let toPart = "";
     if (this.tokenTo && this.amountTo) {
-      const tokenTo = tokenData[this.tokenTo];
+      const tokenTo = tokenData[this.tokenTo.toLowerCase()];
       toPart = ` ⇒  ${formatBN(this.amountTo, tokenTo?.decimals || 18)} ${
         tokenTo?.symbol || ""
       }`;
@@ -213,7 +213,7 @@ export class TxAddCollateral extends EVMTx {
   }
 
   toString(tokenData: Record<string, TokenData>): string {
-    const addedToken = tokenData[this.addedToken];
+    const addedToken = tokenData[this.addedToken.toLowerCase()];
     return `Credit account ${getContractName(
       this.creditManager
     )}: Added ${formatBN(this.amount, addedToken.decimals)} ${
@@ -252,7 +252,7 @@ export class TxIncreaseBorrowAmount extends EVMTx {
   }
 
   toString(tokenData: Record<string, TokenData>): string {
-    const token = tokenData[this.underlyingToken];
+    const token = tokenData[this.underlyingToken.toLowerCase()];
     return `Credit account ${getContractName(
       this.creditManager
     )}: Borrowed amount was increased for ${formatBN(
@@ -295,7 +295,7 @@ export class TxOpenAccount extends EVMTx {
   }
 
   toString(tokenData: Record<string, TokenData>): string {
-    const token = tokenData[this.underlyingToken];
+    const token = tokenData[this.underlyingToken.toLowerCase()];
     return `Credit account ${getContractName(
       this.creditManager
     )}: opening ${formatBN(this.amount, token?.decimals || 18)} ${
@@ -333,7 +333,7 @@ export class TxRepayAccount extends EVMTx {
     this.creditManager = opts.creditManager;
   }
 
-  toString(_tokenData: Record<string, TokenData>): string {
+  toString(_: Record<string, TokenData>): string {
     return `Credit account ${getContractName(
       this.creditManager
     )}: Repaying account`;
@@ -363,7 +363,7 @@ export class TxCloseAccount extends EVMTx {
     this.creditManager = opts.creditManager;
   }
 
-  toString(_tokenData: Record<string, TokenData>): string {
+  toString(_: Record<string, TokenData>): string {
     return `Credit account ${getContractName(
       this.creditManager
     )}: Closing account`;
@@ -394,7 +394,7 @@ export class TxApprove extends EVMTx {
   }
 
   toString(tokenData: Record<string, TokenData>): string {
-    const token = tokenData[this.token];
+    const token = tokenData[this.token.toLowerCase()];
     return `Approve ${token?.symbol}`;
   }
 

package/src/index.ts

@@ -6,6 +6,7 @@ export * from "./core/contracts";
 export * from "./core/events";
 export * from "./core/errors";
 export * from "./core/pool";
+export * from "./core/protocols";
 export * from "./core/priceFeeds";
 export * from "./core/operations";
 export * from "./core/oracles";
@@ -43,3 +44,4 @@ export { MultiCallContract } from "./utils/multicall";
 export { callRepeater } from "./utils/repeater";
 export { getContractName } from "./core/contractsRegister";
 export { AdapterInterface } from "./core/adapters";
+export { objectEntries, swapKeyValue, keyToLowercase } from "./utils/mappers";

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

package/src/pathfinder/path.ts

@@ -0,0 +1,259 @@
+import {BigNumber, ethers} from "ethers";
+import {CreditManagerData} from "../core/creditManager";
+import {MultiCall} from "../core/multicall";
+import {
+    Curve3CrvUnderlyingTokenIndex, NormalToken,
+    priority,
+    SupportedToken,
+    supportedTokens,
+    TokenType
+} from "../core/token";
+import {NetworkType} from "../core/constants";
+import {CreditAccountData} from "../core/creditAccount";
+import {ConnectorPathAsset} from "./connectorPathAsset";
+import {YearnVaultPathAsset} from "./yearnVaultPathAsset";
+import {ConvexLPTokenPathAsset} from "./convexLPTokenPathAsset";
+import {CurveLPPathAsset} from "./curveLPPathAsset";
+import {MetaCurveLPPathAsset} from "./metaCurveLPPathAsset";
+import {NormalTokenPathAsset} from "./normalTokenPathAsset";
+import {YearnVaultOfCurveLPPathAsset} from "./yearnVaultOfCurveLPPathAsset";
+import {YearnVaultOfMetaCurveLPPathAsset} from "./yearnVaultOfMetaCurveLPPathAsset";
+import {
+    CurveV1Adapter__factory,
+    IQuoter__factory,
+    UniswapV2Adapter__factory,
+    UniswapV3Adapter__factory, YearnAdapter__factory
+} from "../types";
+import {contractsByNetwork, SupportedContract, UNISWAP_V3_QUOTER} from "../core/contracts";
+import {TradeAction, TradeType} from "../core/tradeTypes";
+
+
+export class Path {
+    public readonly calls: Array<MultiCall> = [];
+    public readonly balances: Record<SupportedToken, BigNumber>;
+    public readonly pool: SupportedToken;
+    public readonly creditManager: CreditManagerData;
+    public readonly creditAccount: CreditAccountData;
+    public readonly networkType: NetworkType;
+    public readonly provider: ethers.providers.Provider;
+    public readonly totalGasLimit: BigNumber;
+
+
+    // Path is for selling all assets in the credit account, it will return the calls data to sell all the assets, the amount of pool token will got after selling and the total gas limit for all the calls.
+    // This is an example to describe how to use Path:
+    // 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;
+    //
+    // balances: the balance of each asset in the credit account
+    // pool: the pool token
+    // creditManager: credit manager data
+    // creditAccount: credit account data
+    // networkType: network type (Mainnet, Kovan)
+    // provider: ehters rpc provider
+    // totalGasLimit: the base gas limit, you can pass zero for not adding any base gas limit
+
+    constructor(opts: {
+        balances: Record<SupportedToken, BigNumber>;
+        pool: SupportedToken;
+        creditManager: CreditManagerData;
+        creditAccount: CreditAccountData;
+        networkType: NetworkType;
+        provider: ethers.providers.Provider;
+        totalGasLimit: BigNumber;
+    }) {
+        this.balances = opts.balances;
+        this.pool = opts.pool;
+        this.creditManager = opts.creditManager;
+        this.creditAccount = opts.creditAccount;
+        this.networkType = opts.networkType;
+        this.provider = opts.provider;
+        this.totalGasLimit = opts.totalGasLimit;
+    }
+
+    private comparedByPriority([tokenA, _balanceA]: [string, BigNumber], [tokenB, _balanceB]: [string, BigNumber]): number {
+        const priorityTokenA = priority[supportedTokens[tokenA as SupportedToken].type];
+        const priorityTokenB = priority[supportedTokens[tokenB as SupportedToken].type];
+
+        if (priorityTokenA > priorityTokenB) {
+            return -1;
+        } else if (priorityTokenA < priorityTokenB) {
+            return 1;
+        }
+        return 0;
+    }
+
+    async getBestPath(): Promise<Path> {
+        const existingTokens = Object.entries(this.balances).filter(([_token, balance]) => balance.gt(1)).sort(this.comparedByPriority);
+
+        if (existingTokens.length == 1) {
+            return this;
+        }
+
+        const nextToken = existingTokens.at(0)![0] as SupportedToken;
+        let pathAsset: PathAsset;
+        // Get balances and keep non-zero only
+        // Find token with highest priority
+        // Get token type of this token
+        switch (supportedTokens[nextToken].type) {
+            case TokenType.CONNECTOR:
+                pathAsset = new ConnectorPathAsset();
+                break;
+
+            case TokenType.YEARN_VAULT:
+                pathAsset = new YearnVaultPathAsset();
+                break;
+
+            case TokenType.CONVEX_LP_TOKEN:
+                pathAsset = new ConvexLPTokenPathAsset();
+                break;
+
+            case TokenType.CURVE_LP:
+                pathAsset = new CurveLPPathAsset();
+                break;
+
+            case TokenType.META_CURVE_LP:
+                pathAsset = new MetaCurveLPPathAsset();
+                break;
+
+            case TokenType.NORMAL_TOKEN:
+                pathAsset = new NormalTokenPathAsset();
+                break;
+
+            case TokenType.YEARN_VAULT_OF_CURVE_LP:
+                pathAsset = new YearnVaultOfCurveLPPathAsset();
+                break;
+
+            case TokenType.YEARN_VAULT_OF_META_CURVE_LP:
+                pathAsset = new YearnVaultOfMetaCurveLPPathAsset();
+                break;
+
+            default:
+                throw new Error("Token type not supported yet");
+        }
+
+        return await pathAsset.getBestPath(nextToken, this);
+    }
+}
+
+export interface ActionData {
+    callData: MultiCall;
+    amountOut: BigNumber;
+    gasLimit: BigNumber;
+};
+
+export abstract class PathAsset {
+    abstract getBestPath(currentToken: SupportedToken, p: Path): Promise<Path>;
+
+
+    async getUniswapV2SwapData(adapterAddress: string, currentTokenAddress: string, currentBalance: BigNumber, nextTokenAddress: string, p: Path): Promise<ActionData> {
+
+        const deadline = Math.floor(Date.now() / 1000) + 1200;
+        const uniswapV2Adapter = UniswapV2Adapter__factory.connect(adapterAddress, p.provider);
+        const path: Array<string> = [currentTokenAddress, nextTokenAddress];
+        const amountsOut: Array<BigNumber> = await uniswapV2Adapter.getAmountsOut(currentBalance, path);
+
+        const amountOut: BigNumber = amountsOut[amountsOut.length - 1];
+        const gasLimit: BigNumber = await uniswapV2Adapter.estimateGas.swapExactTokensForTokens(currentBalance, amountOut, path, p.creditAccount.addr, deadline);
+        const call: MultiCall = {
+            targetContract: adapterAddress,
+            callData: UniswapV2Adapter__factory.createInterface().encodeFunctionData("swapExactTokensForTokens", [currentBalance, amountOut, path, p.creditAccount.addr, deadline])
+        }
+
+        return { callData: call, amountOut: amountOut, gasLimit: gasLimit };
+    }
+
+    async getUniswapV3SwapData(adapterAddress: string, currentTokenAddress: string, currentBalance: BigNumber, nextTokenAddress: string, p: Path): Promise<ActionData> {
+        const uniswapV3Adapter = UniswapV3Adapter__factory.connect(adapterAddress, p.provider);
+        const iQuoter = IQuoter__factory.connect(UNISWAP_V3_QUOTER, p.provider);
+        const amountOut: BigNumber = await iQuoter.callStatic.quoteExactInputSingle(currentTokenAddress, nextTokenAddress, 3000, currentBalance, 0);
+        const deadline = Math.floor(Date.now() / 1000) + 1200;
+        const exactInputSingleOrder = {
+            "tokenIn": currentTokenAddress,
+            "tokenOut": nextTokenAddress,
+            "fee": 3000,
+            "recipient": p.creditAccount.addr,
+            "amountIn": currentBalance,
+            "amountOutMinimum": amountOut,
+            "deadline": deadline,
+            "sqrtPriceLimitX96": 0
+        };
+        const call: MultiCall = {
+            targetContract: adapterAddress,
+            callData: UniswapV3Adapter__factory.createInterface().encodeFunctionData("exactInputSingle", [exactInputSingleOrder])
+        }
+        const gasLimit: BigNumber = await uniswapV3Adapter.estimateGas.exactInputSingle(exactInputSingleOrder);
+
+        return { callData: call, amountOut: amountOut, gasLimit: gasLimit };
+    }
+
+    async getCurveActionData(adapterAddress: string, currentToken: SupportedToken, currentBalance: BigNumber, nextToken: SupportedToken, p: Path): Promise<ActionData> {
+        const curve3CrvPool = CurveV1Adapter__factory.connect(adapterAddress, p.provider);
+        const currentIndex: BigNumber = Curve3CrvUnderlyingTokenIndex[currentToken]!;
+        const outputIndex: BigNumber = Curve3CrvUnderlyingTokenIndex[nextToken]!;
+
+        const amountOut: BigNumber = await curve3CrvPool.get_dy_underlying(currentIndex, outputIndex, currentBalance);
+        const gasLimit: BigNumber = await curve3CrvPool.estimateGas.exchange_underlying(currentIndex, outputIndex, currentBalance, amountOut);
+        const call: MultiCall = {
+            targetContract: adapterAddress,
+            callData: CurveV1Adapter__factory.createInterface().encodeFunctionData("exchange_underlying", [currentIndex, outputIndex, currentBalance, amountOut])
+        };
+
+        return { callData: call, amountOut: amountOut, gasLimit: gasLimit };
+    }
+
+    async getActionData(swapAction: TradeAction, currentTokenAddress: string, currentToken: SupportedToken, currentBalance: BigNumber, nextTokenAddress: string, nextToken: SupportedToken, p: Path): Promise<ActionData> {
+        const actionType: TradeType = swapAction.type;
+        const actionContract: SupportedContract = swapAction.contract;
+        const actionContractAddress: string = contractsByNetwork[p.networkType][actionContract];
+        const adapterAddress: string = p.creditManager.adapters[actionContractAddress];
+
+        switch (actionType) {
+            case TradeType.UniswapV2Swap:
+                return await this.getUniswapV2SwapData(adapterAddress, currentTokenAddress, currentBalance, nextTokenAddress, p);
+
+            case TradeType.UniswapV3Swap:
+                return await this.getUniswapV3SwapData(adapterAddress, currentTokenAddress, currentBalance, nextTokenAddress, p);
+
+            case TradeType.CurveExchange:
+                if (swapAction.tokenOut!.includes(p.pool as NormalToken)) {
+                    return await this.getCurveActionData(adapterAddress, currentToken, currentBalance, nextToken, p);
+                } else {
+                    return {
+                        callData: {
+                            targetContract: "",
+                            callData: ""
+                        },
+                        amountOut: BigNumber.from(0),
+                        gasLimit: BigNumber.from(0)
+                    };
+                }
+
+            default:
+                throw Error(`TradeType not supported. ${actionType}`);
+        }
+    }
+
+    async getYearnActionData(lpAction: TradeAction, currentBalance: BigNumber, p: Path): Promise<ActionData> {
+        // Yearn Vault only has one lp action
+        const actionContract: SupportedContract = lpAction.contract;
+        const allowedContract: string = contractsByNetwork[p.networkType][actionContract];
+        // For Yearn Vault the token address is the contract to withdraw
+        const adapterAddress = p.creditManager.adapters[allowedContract];
+        const call: MultiCall = {
+            targetContract: adapterAddress,
+            callData: YearnAdapter__factory.createInterface().encodeFunctionData('withdraw', [currentBalance, p.creditAccount.addr])
+        };
+
+        const IYVault = YearnAdapter__factory.connect(allowedContract, p.provider);
+        const price: BigNumber = await IYVault.pricePerShare(); // get price
+        const gasLimit: BigNumber = await IYVault.estimateGas["withdraw(uint256,address)"](currentBalance, p.creditAccount.addr);
+        return {
+            callData: call,
+            amountOut: currentBalance.mul(price),
+            gasLimit: gasLimit
+        }
+    }
+}

package/src/pathfinder/yearnVaultOfCurveLPPathAsset.ts

@@ -0,0 +1,22 @@
+import {SupportedToken, supportedTokens, TokenDataI, TokenType} from "../core/token";
+import {ActionData, Path, PathAsset} from "./path";
+import {BigNumber} from "ethers";
+
+export class YearnVaultOfCurveLPPathAsset extends PathAsset {
+    async getBestPath(currentToken: SupportedToken, p: Path): Promise<Path> {
+        const currentBalance: BigNumber = p.balances[currentToken].sub(1);
+        type YearnVaultOfMetaCurveDataI = Extract<TokenDataI, { type: TokenType.YEARN_VAULT_OF_CURVE_LP }>;
+        const currentTokenData = supportedTokens[currentToken] as YearnVaultOfMetaCurveDataI;
+
+        // Yearn Vault only has one lp action
+        const outputToken: SupportedToken = currentTokenData.lpActions[0].tokenOut as SupportedToken;
+        const yearnActionData: ActionData = await this.getYearnActionData(currentTokenData.lpActions[0], currentBalance, p);
+
+        p.balances[outputToken].add(yearnActionData.amountOut);
+        p.balances[currentToken] = BigNumber.from(1);
+        p.totalGasLimit.add(yearnActionData.gasLimit);
+        p.calls.push(yearnActionData.callData);
+
+        return await p.getBestPath();
+    }
+}

package/src/pathfinder/yearnVaultOfMetaCurveLPPathAsset.ts

@@ -0,0 +1,22 @@
+import {SupportedToken, supportedTokens, TokenDataI, TokenType} from "../core/token";
+import {ActionData, Path, PathAsset} from "./path";
+import {BigNumber} from "ethers";
+
+export class YearnVaultOfMetaCurveLPPathAsset extends PathAsset {
+    async getBestPath(currentToken: SupportedToken, p: Path): Promise<Path> {
+        const currentBalance: BigNumber = p.balances[currentToken].sub(1);
+        type YearnVaultOfMetaCurveDataI = Extract<TokenDataI, { type: TokenType.YEARN_VAULT_OF_META_CURVE_LP }>;
+        const currentTokenData = supportedTokens[currentToken] as YearnVaultOfMetaCurveDataI;
+
+        // Yearn Vault only has one lp action
+        const outputToken: SupportedToken = currentTokenData.lpActions[0].tokenOut as SupportedToken;
+        const yearnActionData: ActionData = await this.getYearnActionData(currentTokenData.lpActions[0], currentBalance, p);
+
+        p.balances[outputToken].add(yearnActionData.amountOut);
+        p.balances[currentToken] = BigNumber.from(1);
+        p.totalGasLimit.add(yearnActionData.gasLimit);
+        p.calls.push(yearnActionData.callData);
+
+        return await p.getBestPath();
+    }
+}

package/src/pathfinder/yearnVaultPathAsset.ts

@@ -0,0 +1,27 @@
+import {BigNumber} from "ethers";
+import {
+    SupportedToken,
+    supportedTokens,
+    TokenDataI,
+    TokenType
+} from "../core/token";
+import {ActionData, Path, PathAsset} from "./path";
+
+export class YearnVaultPathAsset extends PathAsset {
+    async getBestPath(currentToken: SupportedToken, p: Path): Promise<Path> {
+        const currentBalance: BigNumber = p.balances[currentToken].sub(1);
+        type YearnVaultDataI = Extract<TokenDataI, { type: TokenType.YEARN_VAULT }>;
+        const currentTokenData = supportedTokens[currentToken] as YearnVaultDataI;
+
+        // Yearn Vault only has one lp action
+        const outputToken: SupportedToken = currentTokenData.lpActions[0].tokenOut as SupportedToken;
+        const yearnActionData: ActionData = await this.getYearnActionData(currentTokenData.lpActions[0], currentBalance, p);
+
+        p.balances[outputToken].add(yearnActionData.amountOut);
+        p.balances[currentToken] = BigNumber.from(1);
+        p.totalGasLimit.add(yearnActionData.gasLimit);
+        p.calls.push(yearnActionData.callData);
+
+        return await p.getBestPath();
+    }
+}

package/src/utils/mappers.ts

@@ -0,0 +1,23 @@
+type SupportedValue = string | number;
+
+const objectEntries = <K extends SupportedValue, T>(
+  o: Record<K, T>
+): Array<[K, T]> => Object.entries(o) as Array<[K, T]>;
+
+const swapKeyValue = <K extends SupportedValue, T extends SupportedValue>(
+  o: Record<K, T>
+): Record<T, K> =>
+  objectEntries(o).reduce((sum, [key, value]) => {
+    return { ...sum, [value]: key };
+  }, {} as Record<T, K>);
+
+const keyToLowercase = <K extends SupportedValue, T extends SupportedValue>(
+  o: Record<K, T>
+): Record<K, T> =>
+  objectEntries(o).reduce((sum, [key, value]) => {
+    const keyTransformed = typeof key === "string" ? key.toLowerCase() : key;
+    return { ...sum, [keyTransformed]: value };
+  }, {} as Record<K, T>);
+
+export type { SupportedValue };
+export { objectEntries, swapKeyValue, keyToLowercase };

package/src/utils/types.ts

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