@gearbox-protocol/sdk 2.1.33 → 3.0.0-next.1

package/lib/strategies/uniswapV2.js

@@ -1,44 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.UniswapV2Multicaller = exports.UniswapV2Calls = void 0;
-const types_1 = require("../types");
-class UniswapV2Calls {
-    static swapExactTokensForTokens(amountIn, amountOutMin, path, to, deadline) {
-        return types_1.IUniswapV2Adapter__factory.createInterface().encodeFunctionData("swapExactTokensForTokens", [amountIn, amountOutMin, path, to, deadline]);
-    }
-    static swapTokensForExactTokens(amountOut, amountInMax, path, to, deadline) {
-        return types_1.IUniswapV2Adapter__factory.createInterface().encodeFunctionData("swapTokensForExactTokens", [amountOut, amountInMax, path, to, deadline]);
-    }
-    static swapAllTokensForTokens(rateMinRAY, path, deadline) {
-        return types_1.IUniswapV2Adapter__factory.createInterface().encodeFunctionData("swapAllTokensForTokens", [rateMinRAY, path, deadline]);
-    }
-}
-exports.UniswapV2Calls = UniswapV2Calls;
-class UniswapV2Multicaller {
-    _address;
-    constructor(address) {
-        this._address = address;
-    }
-    static connect(address) {
-        return new UniswapV2Multicaller(address);
-    }
-    swapExactTokensForTokens(amountIn, amountOutMin, path, to, deadline) {
-        return {
-            target: this._address,
-            callData: UniswapV2Calls.swapExactTokensForTokens(amountIn, amountOutMin, path, to, deadline),
-        };
-    }
-    swapTokensForExactTokens(amountOut, amountInMax, path, to, deadline) {
-        return {
-            target: this._address,
-            callData: UniswapV2Calls.swapExactTokensForTokens(amountOut, amountInMax, path, to, deadline),
-        };
-    }
-    swapAllTokensForTokens(rateMinRAY, path, deadline) {
-        return {
-            target: this._address,
-            callData: UniswapV2Calls.swapAllTokensForTokens(rateMinRAY, path, deadline),
-        };
-    }
-}
-exports.UniswapV2Multicaller = UniswapV2Multicaller;

package/lib/strategies/uniswapV3.d.ts

@@ -1,21 +0,0 @@
-import { ISwapRouter, IUniswapV3Adapter } from "../types";
-import { MultiCallStruct } from "../types/@gearbox-protocol/router/contracts/interfaces/IClosePathResolver";
-export declare class UniswapV3Calls {
-    static exactInputSingle(params: ISwapRouter.ExactInputSingleParamsStructOutput): string;
-    static exactAllInputSingle(params: IUniswapV3Adapter.ExactAllInputSingleParamsStructOutput): string;
-    static exactInput(params: ISwapRouter.ExactInputParamsStructOutput): string;
-    static exactAllInput(params: IUniswapV3Adapter.ExactAllInputParamsStructOutput): string;
-    static exactOutputSingle(params: ISwapRouter.ExactOutputSingleParamsStructOutput): string;
-    static exactOutput(params: ISwapRouter.ExactOutputParamsStructOutput): string;
-}
-export declare class UniswapV3Multicaller {
-    private readonly _address;
-    constructor(address: string);
-    static connect(address: string): UniswapV3Multicaller;
-    exactInputSingle(params: ISwapRouter.ExactInputSingleParamsStructOutput): MultiCallStruct;
-    exactAllInputSingle(params: IUniswapV3Adapter.ExactAllInputSingleParamsStructOutput): MultiCallStruct;
-    exactInput(params: ISwapRouter.ExactInputParamsStructOutput): MultiCallStruct;
-    exactAllInput(params: IUniswapV3Adapter.ExactAllInputParamsStructOutput): MultiCallStruct;
-    exactOutputSingle(params: ISwapRouter.ExactOutputSingleParamsStructOutput): MultiCallStruct;
-    exactOutput(params: ISwapRouter.ExactOutputParamsStructOutput): MultiCallStruct;
-}

package/lib/strategies/uniswapV3.js

@@ -1,71 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.UniswapV3Multicaller = exports.UniswapV3Calls = void 0;
-const types_1 = require("../types");
-class UniswapV3Calls {
-    static exactInputSingle(params) {
-        return types_1.IUniswapV3Adapter__factory.createInterface().encodeFunctionData("exactInputSingle", [params]);
-    }
-    static exactAllInputSingle(params) {
-        return types_1.IUniswapV3Adapter__factory.createInterface().encodeFunctionData("exactAllInputSingle", [params]);
-    }
-    static exactInput(params) {
-        return types_1.IUniswapV3Adapter__factory.createInterface().encodeFunctionData("exactInput", [params]);
-    }
-    static exactAllInput(params) {
-        return types_1.IUniswapV3Adapter__factory.createInterface().encodeFunctionData("exactAllInput", [params]);
-    }
-    static exactOutputSingle(params) {
-        return types_1.IUniswapV3Adapter__factory.createInterface().encodeFunctionData("exactOutputSingle", [params]);
-    }
-    static exactOutput(params) {
-        return types_1.IUniswapV3Adapter__factory.createInterface().encodeFunctionData("exactOutput", [params]);
-    }
-}
-exports.UniswapV3Calls = UniswapV3Calls;
-class UniswapV3Multicaller {
-    _address;
-    constructor(address) {
-        this._address = address;
-    }
-    static connect(address) {
-        return new UniswapV3Multicaller(address);
-    }
-    exactInputSingle(params) {
-        return {
-            target: this._address,
-            callData: UniswapV3Calls.exactInputSingle(params),
-        };
-    }
-    exactAllInputSingle(params) {
-        return {
-            target: this._address,
-            callData: UniswapV3Calls.exactAllInputSingle(params),
-        };
-    }
-    exactInput(params) {
-        return {
-            target: this._address,
-            callData: UniswapV3Calls.exactInput(params),
-        };
-    }
-    exactAllInput(params) {
-        return {
-            target: this._address,
-            callData: UniswapV3Calls.exactAllInput(params),
-        };
-    }
-    exactOutputSingle(params) {
-        return {
-            target: this._address,
-            callData: UniswapV3Calls.exactOutputSingle(params),
-        };
-    }
-    exactOutput(params) {
-        return {
-            target: this._address,
-            callData: UniswapV3Calls.exactOutput(params),
-        };
-    }
-}
-exports.UniswapV3Multicaller = UniswapV3Multicaller;

package/lib/strategies/yearn.d.ts

@@ -1,20 +0,0 @@
-import { BigNumberish } from "ethers";
-import { YearnVaultContract } from "../contracts/contracts";
-import { NetworkType } from "../core/chains";
-import { CreditManagerData } from "../core/creditManager";
-import { MultiCallStruct } from "../types/@gearbox-protocol/router/contracts/interfaces/IClosePathResolver";
-export declare class YearnV2Calls {
-    static deposit(amount?: BigNumberish, recipient?: string): string;
-    static withdraw(maxShares?: BigNumberish, recipient?: string, maxLoss?: BigNumberish): string;
-}
-export declare class YearnV2Multicaller {
-    private readonly _address;
-    constructor(address: string);
-    static connect(address: string): YearnV2Multicaller;
-    deposit(amount?: BigNumberish, recipient?: string): MultiCallStruct;
-    withdraw(maxShares?: BigNumberish, recipient?: string, maxLoss?: BigNumberish): MultiCallStruct;
-}
-export declare class YearnV2Strategies {
-    static underlyingToYearn(data: CreditManagerData, network: NetworkType, yearnVault: YearnVaultContract, underlyingAmount: BigNumberish): MultiCallStruct[];
-    static yearnToUnderlying(data: CreditManagerData, network: NetworkType, yearnVault: YearnVaultContract, yearnSharesAmount: BigNumberish): MultiCallStruct[];
-}

package/lib/strategies/yearn.js

@@ -1,128 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.YearnV2Strategies = exports.YearnV2Multicaller = exports.YearnV2Calls = void 0;
-const contracts_1 = require("../contracts/contracts");
-const constants_1 = require("../core/constants");
-const token_1 = require("../tokens/token");
-const tokenType_1 = require("../tokens/tokenType");
-const types_1 = require("../types");
-const curve_1 = require("./curve");
-const uniswapV2_1 = require("./uniswapV2");
-class YearnV2Calls {
-    static deposit(amount, recipient) {
-        const contractInterface = types_1.IYVault__factory.createInterface();
-        if (amount && recipient) {
-            return contractInterface.encodeFunctionData("deposit(uint256,address)", [
-                amount,
-                recipient,
-            ]);
-        }
-        if (amount) {
-            return contractInterface.encodeFunctionData("deposit(uint256)", [amount]);
-        }
-        return contractInterface.encodeFunctionData("deposit()");
-    }
-    static withdraw(maxShares, recipient, maxLoss) {
-        const contractInterface = types_1.IYVault__factory.createInterface();
-        if (maxShares && recipient && maxLoss) {
-            return contractInterface.encodeFunctionData("withdraw(uint256,address,uint256)", [maxShares, recipient, maxLoss]);
-        }
-        if (maxShares && recipient) {
-            return contractInterface.encodeFunctionData("withdraw(uint256,address)", [
-                maxShares,
-                recipient,
-            ]);
-        }
-        if (maxShares) {
-            return contractInterface.encodeFunctionData("withdraw(uint256)", [
-                maxShares,
-            ]);
-        }
-        return contractInterface.encodeFunctionData("withdraw()");
-    }
-}
-exports.YearnV2Calls = YearnV2Calls;
-class YearnV2Multicaller {
-    _address;
-    constructor(address) {
-        this._address = address;
-    }
-    static connect(address) {
-        return new YearnV2Multicaller(address);
-    }
-    deposit(amount, recipient) {
-        return {
-            target: this._address,
-            callData: YearnV2Calls.deposit(amount, recipient),
-        };
-    }
-    withdraw(maxShares, recipient, maxLoss) {
-        return {
-            target: this._address,
-            callData: YearnV2Calls.withdraw(maxShares, recipient, maxLoss),
-        };
-    }
-}
-exports.YearnV2Multicaller = YearnV2Multicaller;
-class YearnV2Strategies {
-    static underlyingToYearn(data, network, yearnVault, underlyingAmount) {
-        let calls = [];
-        const vaultParams = contracts_1.contractParams[yearnVault];
-        const yearnToken = vaultParams.shareToken;
-        const yearnParams = token_1.supportedTokens[yearnToken];
-        if (yearnParams.type === tokenType_1.TokenType.YEARN_ON_NORMAL_TOKEN) {
-            if (data.underlyingToken.toLowerCase() !==
-                token_1.tokenDataByNetwork[network][yearnParams.underlying].toLowerCase()) {
-                // This should be a pathfinder call
-                calls.push(uniswapV2_1.UniswapV2Multicaller.connect(data.adapters[contracts_1.contractsByNetwork[network].UNISWAP_V2_ROUTER.toLowerCase()]).swapExactTokensForTokens(underlyingAmount, 0, [
-                    data.underlyingToken,
-                    token_1.tokenDataByNetwork[network][yearnParams.underlying],
-                ], constants_1.ADDRESS_0X0, Math.floor(new Date().getTime() / 1000) + 3600));
-            }
-            else {
-                calls.push(YearnV2Multicaller.connect(data.adapters[contracts_1.contractsByNetwork[network][yearnVault].toLowerCase()]).deposit(underlyingAmount));
-                return calls;
-            }
-        }
-        else if (yearnParams.type === tokenType_1.TokenType.YEARN_ON_CURVE_TOKEN) {
-            const curveTokenParams = token_1.supportedTokens[yearnParams.underlying];
-            const curvePool = curveTokenParams.pool;
-            calls = curve_1.CurveStrategies.underlyingToCurveLP(data, network, curvePool, underlyingAmount);
-        }
-        else {
-            throw new Error("Yearn vault type unknown");
-        }
-        calls.push(YearnV2Multicaller.connect(data.adapters[contracts_1.contractsByNetwork[network][yearnVault].toLowerCase()]).deposit());
-        return calls;
-    }
-    static yearnToUnderlying(data, network, yearnVault, yearnSharesAmount) {
-        let calls = [];
-        const vaultParams = contracts_1.contractParams[yearnVault];
-        const yearnToken = vaultParams.shareToken;
-        const yearnParams = token_1.supportedTokens[yearnToken];
-        calls.push(YearnV2Multicaller.connect(data.adapters[contracts_1.contractsByNetwork[network][yearnVault].toLowerCase()]).withdraw(yearnSharesAmount));
-        if (yearnParams.type === tokenType_1.TokenType.YEARN_ON_NORMAL_TOKEN) {
-            if (data.underlyingToken.toLowerCase() !==
-                token_1.tokenDataByNetwork[network][yearnParams.underlying].toLowerCase()) {
-                // This should be a pathfinder call
-                calls.push(uniswapV2_1.UniswapV2Multicaller.connect(data.adapters[contracts_1.contractsByNetwork[network].UNISWAP_V2_ROUTER.toLowerCase()]).swapAllTokensForTokens(0, [
-                    token_1.tokenDataByNetwork[network][yearnParams.underlying],
-                    data.underlyingToken,
-                ], Math.floor(new Date().getTime() / 1000) + 3600));
-            }
-        }
-        else if (yearnParams.type === tokenType_1.TokenType.YEARN_ON_CURVE_TOKEN) {
-            const curveTokenParams = token_1.supportedTokens[yearnParams.underlying];
-            const curvePool = curveTokenParams.pool;
-            calls = [
-                ...calls,
-                ...curve_1.CurveStrategies.allCurveLPToUnderlying(data, network, curvePool),
-            ];
-        }
-        else {
-            throw new Error("Yearn vault type unknown");
-        }
-        return calls;
-    }
-}
-exports.YearnV2Strategies = YearnV2Strategies;

package/lib/tokens/aave.d.ts

@@ -1,23 +0,0 @@
-import type { AaveV2PoolContract } from "../contracts/contracts";
-import { TradeAction } from "../pathfinder/tradeTypes";
-import { NormalToken } from "./normal";
-import type { TokenBase } from "./token";
-import { TokenType } from "./tokenType";
-export type AaveV2LPToken = "aDAI" | "aUSDC" | "aWETH" | "aUSDT";
-export type WrappedAaveV2LPToken = "waDAI" | "waUSDC" | "waWETH" | "waUSDT";
-export type AaveV2PoolTokenData = {
-    symbol: AaveV2LPToken;
-    type: TokenType.AAVE_V2_A_TOKEN;
-    underlying: NormalToken;
-    lpActions: Array<TradeAction>;
-    pool: AaveV2PoolContract;
-} & TokenBase;
-export type WrappedAaveV2PoolTokenData = {
-    symbol: WrappedAaveV2LPToken;
-    type: TokenType.WRAPPED_AAVE_V2_TOKEN;
-    underlying: AaveV2LPToken;
-    lpActions: Array<TradeAction>;
-} & TokenBase;
-export declare const aaveV2Tokens: Record<AaveV2LPToken, AaveV2PoolTokenData>;
-export declare const wrappedAaveV2Tokens: Record<WrappedAaveV2LPToken, WrappedAaveV2PoolTokenData>;
-export declare const isAaveV2LPToken: (t: unknown) => t is AaveV2LPToken;

package/lib/tokens/aave.js

@@ -1,119 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.isAaveV2LPToken = exports.wrappedAaveV2Tokens = exports.aaveV2Tokens = void 0;
-const tradeTypes_1 = require("../pathfinder/tradeTypes");
-const tokenType_1 = require("./tokenType");
-exports.aaveV2Tokens = {
-    aDAI: {
-        name: "AaveV2 aDAI",
-        symbol: "aDAI",
-        type: tokenType_1.TokenType.AAVE_V2_A_TOKEN,
-        underlying: "DAI",
-        pool: "AAVE_V2_DAI_POOL",
-        lpActions: [
-            {
-                type: tradeTypes_1.TradeType.AaveV2Withdraw,
-                contract: "AAVE_V2_DAI_POOL",
-                tokenOut: "DAI",
-            },
-        ],
-    },
-    aUSDC: {
-        name: "AaveV2 aUSDC",
-        symbol: "aUSDC",
-        type: tokenType_1.TokenType.AAVE_V2_A_TOKEN,
-        underlying: "USDC",
-        pool: "AAVE_V2_USDC_POOL",
-        lpActions: [
-            {
-                type: tradeTypes_1.TradeType.AaveV2Withdraw,
-                contract: "AAVE_V2_USDC_POOL",
-                tokenOut: "USDC",
-            },
-        ],
-    },
-    aUSDT: {
-        name: "AaveV2 aUSDT",
-        symbol: "aUSDT",
-        type: tokenType_1.TokenType.AAVE_V2_A_TOKEN,
-        underlying: "USDT",
-        pool: "AAVE_V2_USDT_POOL",
-        lpActions: [
-            {
-                type: tradeTypes_1.TradeType.AaveV2Withdraw,
-                contract: "AAVE_V2_USDT_POOL",
-                tokenOut: "USDT",
-            },
-        ],
-    },
-    aWETH: {
-        name: "AaveV2 aWETH",
-        symbol: "aWETH",
-        type: tokenType_1.TokenType.AAVE_V2_A_TOKEN,
-        underlying: "WETH",
-        pool: "AAVE_V2_WETH_POOL",
-        lpActions: [
-            {
-                type: tradeTypes_1.TradeType.AaveV2Withdraw,
-                contract: "AAVE_V2_WETH_POOL",
-                tokenOut: "WETH",
-            },
-        ],
-    },
-};
-exports.wrappedAaveV2Tokens = {
-    waDAI: {
-        name: "Wrapped AaveV2 aDAI",
-        symbol: "waDAI",
-        type: tokenType_1.TokenType.WRAPPED_AAVE_V2_TOKEN,
-        underlying: "aDAI",
-        lpActions: [
-            {
-                type: tradeTypes_1.TradeType.AaveV2Withdraw,
-                contract: "AAVE_V2_DAI_POOL",
-                tokenOut: "DAI",
-            },
-        ],
-    },
-    waUSDC: {
-        name: "Wrapped AaveV2 aUSDC",
-        symbol: "waUSDC",
-        type: tokenType_1.TokenType.WRAPPED_AAVE_V2_TOKEN,
-        underlying: "aUSDC",
-        lpActions: [
-            {
-                type: tradeTypes_1.TradeType.AaveV2Withdraw,
-                contract: "AAVE_V2_USDC_POOL",
-                tokenOut: "USDC",
-            },
-        ],
-    },
-    waUSDT: {
-        name: "Wrapped AaveV2 aUSDT",
-        symbol: "waUSDT",
-        type: tokenType_1.TokenType.WRAPPED_AAVE_V2_TOKEN,
-        underlying: "aUSDT",
-        lpActions: [
-            {
-                type: tradeTypes_1.TradeType.AaveV2Withdraw,
-                contract: "AAVE_V2_USDT_POOL",
-                tokenOut: "USDT",
-            },
-        ],
-    },
-    waWETH: {
-        name: "Wrapped AaveV2 aWETH",
-        symbol: "waWETH",
-        type: tokenType_1.TokenType.WRAPPED_AAVE_V2_TOKEN,
-        underlying: "aWETH",
-        lpActions: [
-            {
-                type: tradeTypes_1.TradeType.AaveV2Withdraw,
-                contract: "AAVE_V2_WETH_POOL",
-                tokenOut: "WETH",
-            },
-        ],
-    },
-};
-const isAaveV2LPToken = (t) => typeof t === "string" && !!exports.aaveV2Tokens[t];
-exports.isAaveV2LPToken = isAaveV2LPToken;

package/lib/tokens/balancer.d.ts

@@ -1,22 +0,0 @@
-import { TradeType } from "../pathfinder/tradeTypes";
-import { NormalToken } from "./normal";
-import type { TokenBase } from "./token";
-import { TokenType } from "./tokenType";
-export type BalancerLPToken = "50OHM_50DAI" | "50OHM_50WETH" | "OHM_wstETH" | "USDC_DAI_USDT";
-export type BalancerLpTokenData = {
-    symbol: BalancerLPToken;
-    type: TokenType.BALANCER_LP_TOKEN;
-    underlying: Array<NormalToken | BalancerLPToken>;
-    lpActions: Array<{
-        type: TradeType.BalancerJoin;
-        contract: "BALANCER_VAULT";
-        tokenOut: BalancerLPToken;
-    } | {
-        type: TradeType.BalancerExit;
-        contract: "BALANCER_VAULT";
-        tokenOut: Array<NormalToken | BalancerLPToken>;
-    }>;
-    poolId: string;
-} & TokenBase;
-export declare const balancerLpTokens: Record<BalancerLPToken, BalancerLpTokenData>;
-export declare const isBalancerLPToken: (t: unknown) => t is BalancerLPToken;

package/lib/tokens/balancer.js

@@ -1,65 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.isBalancerLPToken = exports.balancerLpTokens = void 0;
-const tradeTypes_1 = require("../pathfinder/tradeTypes");
-const tokenType_1 = require("./tokenType");
-exports.balancerLpTokens = {
-    "50OHM_50DAI": {
-        name: "Balancer 50OHM_50DAI",
-        symbol: "50OHM_50DAI",
-        type: tokenType_1.TokenType.BALANCER_LP_TOKEN,
-        underlying: ["OHM", "DAI"],
-        poolId: "0x76fcf0e8c7ff37a47a799fa2cd4c13cde0d981c90002000000000000000003d2",
-        lpActions: [
-            {
-                type: tradeTypes_1.TradeType.BalancerExit,
-                contract: "BALANCER_VAULT",
-                tokenOut: ["OHM", "DAI"],
-            },
-        ],
-    },
-    "50OHM_50WETH": {
-        name: "Balancer 50OHM_50WETH",
-        symbol: "50OHM_50WETH",
-        type: tokenType_1.TokenType.BALANCER_LP_TOKEN,
-        underlying: ["OHM", "WETH"],
-        poolId: "0xd1ec5e215e8148d76f4460e4097fd3d5ae0a35580002000000000000000003d3",
-        lpActions: [
-            {
-                type: tradeTypes_1.TradeType.BalancerExit,
-                contract: "BALANCER_VAULT",
-                tokenOut: ["OHM", "WETH"],
-            },
-        ],
-    },
-    OHM_wstETH: {
-        name: "Balancer OHM_wstETH",
-        symbol: "OHM_wstETH",
-        type: tokenType_1.TokenType.BALANCER_LP_TOKEN,
-        underlying: ["OHM", "wstETH"],
-        poolId: "0xd4f79ca0ac83192693bce4699d0c10c66aa6cf0f00020000000000000000047e",
-        lpActions: [
-            {
-                type: tradeTypes_1.TradeType.BalancerExit,
-                contract: "BALANCER_VAULT",
-                tokenOut: ["OHM", "wstETH"],
-            },
-        ],
-    },
-    USDC_DAI_USDT: {
-        name: "Balancer USDC_DAI_USDT",
-        symbol: "USDC_DAI_USDT",
-        type: tokenType_1.TokenType.BALANCER_LP_TOKEN,
-        underlying: ["USDC", "DAI", "USDT"],
-        poolId: "0x79c58f70905f734641735bc61e45c19dd9ad60bc0000000000000000000004e7",
-        lpActions: [
-            {
-                type: tradeTypes_1.TradeType.BalancerExit,
-                contract: "BALANCER_VAULT",
-                tokenOut: ["USDC", "DAI", "USDT"],
-            },
-        ],
-    },
-};
-const isBalancerLPToken = (t) => typeof t === "string" && !!exports.balancerLpTokens[t];
-exports.isBalancerLPToken = isBalancerLPToken;

package/lib/tokens/compound.d.ts

@@ -1,13 +0,0 @@
-import { TradeAction } from "../pathfinder/tradeTypes";
-import { NormalToken } from "./normal";
-import type { TokenBase } from "./token";
-import { TokenType } from "./tokenType";
-export type CompoundV2LPToken = "cDAI" | "cUSDC" | "cETH" | "cUSDT" | "cLINK";
-export type CompoundV2PoolTokenData = {
-    symbol: CompoundV2LPToken;
-    type: TokenType.COMPOUND_V2_C_TOKEN;
-    underlying: NormalToken;
-    lpActions: Array<TradeAction>;
-} & TokenBase;
-export declare const compoundV2Tokens: Record<CompoundV2LPToken, CompoundV2PoolTokenData>;
-export declare const isCompoundV2LPToken: (t: unknown) => t is CompoundV2LPToken;

package/lib/tokens/compound.js

@@ -1,74 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.isCompoundV2LPToken = exports.compoundV2Tokens = void 0;
-const tradeTypes_1 = require("../pathfinder/tradeTypes");
-const tokenType_1 = require("./tokenType");
-exports.compoundV2Tokens = {
-    cDAI: {
-        name: "CompoundV2 cDAI",
-        symbol: "cDAI",
-        type: tokenType_1.TokenType.COMPOUND_V2_C_TOKEN,
-        underlying: "DAI",
-        lpActions: [
-            {
-                type: tradeTypes_1.TradeType.CompoundV2Withdraw,
-                contract: "COMPOUND_V2_DAI_POOL",
-                tokenOut: "DAI",
-            },
-        ],
-    },
-    cUSDC: {
-        name: "CompoundV2 cUSDC",
-        symbol: "cUSDC",
-        type: tokenType_1.TokenType.COMPOUND_V2_C_TOKEN,
-        underlying: "USDC",
-        lpActions: [
-            {
-                type: tradeTypes_1.TradeType.CompoundV2Withdraw,
-                contract: "COMPOUND_V2_USDC_POOL",
-                tokenOut: "USDC",
-            },
-        ],
-    },
-    cUSDT: {
-        name: "CompoundV2 cUSDT",
-        symbol: "cUSDT",
-        type: tokenType_1.TokenType.COMPOUND_V2_C_TOKEN,
-        underlying: "USDT",
-        lpActions: [
-            {
-                type: tradeTypes_1.TradeType.CompoundV2Withdraw,
-                contract: "COMPOUND_V2_USDT_POOL",
-                tokenOut: "USDT",
-            },
-        ],
-    },
-    cETH: {
-        name: "CompoundV2 cETH",
-        symbol: "cETH",
-        type: tokenType_1.TokenType.COMPOUND_V2_C_TOKEN,
-        underlying: "WETH",
-        lpActions: [
-            {
-                type: tradeTypes_1.TradeType.CompoundV2Withdraw,
-                contract: "COMPOUND_V2_ETH_POOL",
-                tokenOut: "WETH",
-            },
-        ],
-    },
-    cLINK: {
-        name: "CompoundV2 cLINK",
-        symbol: "cLINK",
-        type: tokenType_1.TokenType.COMPOUND_V2_C_TOKEN,
-        underlying: "LINK",
-        lpActions: [
-            {
-                type: tradeTypes_1.TradeType.CompoundV2Withdraw,
-                contract: "COMPOUND_V2_LINK_POOL",
-                tokenOut: "LINK",
-            },
-        ],
-    },
-};
-const isCompoundV2LPToken = (t) => typeof t === "string" && !!exports.compoundV2Tokens[t];
-exports.isCompoundV2LPToken = isCompoundV2LPToken;

package/lib/tokens/convex.d.ts

@@ -1,30 +0,0 @@
-import type { ConvexPoolContract, SupportedContract } from "../contracts/contracts";
-import { TradeAction } from "../pathfinder/tradeTypes";
-import type { CurveLPToken } from "./curveLP";
-import type { SupportedToken, TokenBase } from "./token";
-import { TokenType } from "./tokenType";
-export type ConvexLPToken = "cvx3Crv" | "cvxcrvFRAX" | "cvxsteCRV" | "cvxFRAX3CRV" | "cvxLUSD3CRV" | "cvxcrvPlain3andSUSD" | "cvxgusd3CRV" | "cvxOHMFRAXBP" | "cvxMIM_3LP3CRV" | "cvxcrvCRVETH" | "cvxcrvCVXETH" | "cvxcrvUSDTWBTCWETH" | "cvxLDOETH";
-export type ConvexStakedPhantomToken = "stkcvx3Crv" | "stkcvxcrvFRAX" | "stkcvxsteCRV" | "stkcvxFRAX3CRV" | "stkcvxLUSD3CRV" | "stkcvxcrvPlain3andSUSD" | "stkcvxgusd3CRV" | "stkcvxOHMFRAXBP" | "stkcvxMIM_3LP3CRV" | "stkcvxcrvCRVETH" | "stkcvxcrvCVXETH" | "stkcvxcrvUSDTWBTCWETH" | "stkcvxLDOETH";
-type BaseConvexToken = {
-    pool: ConvexPoolContract;
-    pid: number;
-    underlying: CurveLPToken;
-    lpActions: Array<TradeAction>;
-} & TokenBase;
-export type ConvexLPTokenData = {
-    symbol: ConvexLPToken;
-    type: TokenType.CONVEX_LP_TOKEN;
-    stakedToken: ConvexStakedPhantomToken;
-} & BaseConvexToken;
-export type ConvexPhantomTokenData = {
-    symbol: ConvexStakedPhantomToken;
-    type: TokenType.CONVEX_STAKED_TOKEN;
-    lpToken: ConvexLPToken;
-} & BaseConvexToken;
-export declare const convexTokens: Record<ConvexLPToken | ConvexStakedPhantomToken, ConvexLPTokenData | ConvexPhantomTokenData>;
-export declare const isConvexToken: (t: unknown) => t is ConvexLPToken | ConvexStakedPhantomToken;
-export declare const isConvexLPToken: (t: unknown) => t is ConvexLPToken;
-export declare const isConvexStakedPhantomToken: (t: unknown) => t is ConvexStakedPhantomToken;
-export declare const convexPoolByPid: Record<number, SupportedContract>;
-export declare const convexLpTokenByPid: Record<number, SupportedToken>;
-export {};