@gearbox-protocol/sdk 1.3.3 → 1.5.0

package/lib/parsers/uniV3AdapterParser.spec.js

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var solidity_1 = require("@ethersproject/solidity");
+var chai_1 = require("chai");
+var ethers_1 = require("ethers");
+var constants_1 = require("../core/constants");
+var token_1 = require("../tokens/token");
+var types_1 = require("../types");
+var uniV3AdapterParser_1 = require("./uniV3AdapterParser");
+var pathToUniV3Path = function (path) {
+    var pathWithFees = [];
+    var types = [];
+    path.forEach(function (p, num) {
+        pathWithFees.push(p);
+        types.push("address");
+        if (num !== path.length - 1) {
+            pathWithFees.push(3000);
+            types.push("uint24");
+        }
+    });
+    return (0, solidity_1.pack)(types, pathWithFees);
+};
+describe("UniswapV3AdapterParser test", function () {
+    it("swap functions works well", function () {
+        var parser = new uniV3AdapterParser_1.UniswapV3AdapterParser("UNISWAP_V3_ROUTER", false);
+        var ifc = types_1.IUniswapV3Adapter__factory.createInterface();
+        var parsed = parser.parse(ifc.encodeFunctionData("exactInputSingle", [
+            {
+                tokenIn: token_1.tokenDataByNetwork.Goerli["1INCH"],
+                tokenOut: token_1.tokenDataByNetwork.Goerli["3Crv"],
+                fee: 3000,
+                recipient: constants_1.DUMB_ADDRESS,
+                deadline: 12300,
+                amountIn: constants_1.WAD.mul(1299000),
+                amountOutMinimum: constants_1.WAD.mul(10200),
+                sqrtPriceLimitX96: 0,
+            },
+        ]));
+        (0, chai_1.expect)(parsed).to.be.eq("UniswapV3Adapter[UNISWAP_V3_ROUTER].exactInputSingle(amountIn: 1.29M [1299000000000000000000000], amountOutMinimum: 10.20K [10200000000000000000000],  path: 1INCH ==(fee: 3000)==> 3Crv)", "Incorrect parse swapExactTokensForTokens");
+        parsed = parser.parse(ifc.encodeFunctionData("exactInput", [
+            {
+                path: pathToUniV3Path([
+                    token_1.tokenDataByNetwork.Mainnet.AAVE,
+                    token_1.tokenDataByNetwork.Mainnet.LINK,
+                    token_1.tokenDataByNetwork.Mainnet.USDC,
+                ]),
+                recipient: constants_1.DUMB_ADDRESS,
+                deadline: 1232131,
+                amountIn: constants_1.WAD.mul(12399),
+                amountOutMinimum: ethers_1.BigNumber.from(1e6).mul(122),
+            },
+        ]));
+        (0, chai_1.expect)(parsed).to.be.eq("UniswapV3Adapter[UNISWAP_V3_ROUTER].exactInput(amountIn: 12.39K [12399000000000000000000], amountOutMinimum: 122.00 [122000000],  path: AAVE ==(fee: 3000)==> LINK ==(fee: 3000)==> USDC", "Incorrect parse swapExactTokensForTokens");
+        parsed = parser.parse(ifc.encodeFunctionData("exactOutputSingle", [
+            {
+                tokenIn: token_1.tokenDataByNetwork.Goerli["1INCH"],
+                tokenOut: token_1.tokenDataByNetwork.Goerli.USDC,
+                fee: 10000,
+                recipient: constants_1.DUMB_ADDRESS,
+                deadline: 12300,
+                amountInMaximum: constants_1.WAD.mul(149).div(1000),
+                amountOut: 102e6,
+                sqrtPriceLimitX96: 0,
+            },
+        ]));
+        (0, chai_1.expect)(parsed).to.be.eq("UniswapV3Adapter[UNISWAP_V3_ROUTER].exactOutputSingle(amountInMaximum: 0.14 [149000000000000000], amountOut: 102.00 [102000000],  path: 1INCH ==(fee: 10000)==> USDC)", "Incorrect parse swapExactTokensForTokens");
+        parsed = parser.parse(ifc.encodeFunctionData("exactOutput", [
+            {
+                path: pathToUniV3Path([
+                    token_1.tokenDataByNetwork.Mainnet.AAVE,
+                    token_1.tokenDataByNetwork.Mainnet.LINK,
+                    token_1.tokenDataByNetwork.Mainnet.USDC,
+                ]),
+                recipient: constants_1.DUMB_ADDRESS,
+                deadline: 1232131,
+                amountInMaximum: 123e6,
+                amountOut: constants_1.WAD.mul(122),
+            },
+        ]));
+        (0, chai_1.expect)(parsed).to.be.eq("UniswapV3Adapter[UNISWAP_V3_ROUTER].exactOutput(amountInMaximum: 123.00 [123000000], amountOut: 122.00 [122000000000000000000],  path: USDC ==(fee: 3000)==> LINK ==(fee: 3000)==> AAVE", "Incorrect parse swapExactTokensForTokens");
+    });
+});

package/lib/parsers/yearnAdapterParser.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/parsers/yearnAdapterParser.spec.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var chai_1 = require("chai");
+var constants_1 = require("../core/constants");
+var yearn_1 = require("../types/factories/contracts/interfaces/adapters/yearn");
+var yearnV2AdapterParser_1 = require("./yearnV2AdapterParser");
+describe("YearnV2AdapterParser test", function () {
+    it("deposit / withdraw functions works well", function () {
+        var parser = new yearnV2AdapterParser_1.YearnV2AdapterParser("YEARN_CURVE_STETH_VAULT", false);
+        var ifc = yearn_1.IYearnV2Adapter__factory.createInterface();
+        var parsed = parser.parse(ifc.encodeFunctionData("deposit()"));
+        (0, chai_1.expect)(parsed).to.be.eq("YearnV2Adapter[YEARN_CURVE_STETH_VAULT].deposit()", "Incorrect parse deposit()");
+        parsed = parser.parse(ifc.encodeFunctionData("deposit(uint256)", [constants_1.WAD.mul(19000)]));
+        (0, chai_1.expect)(parsed).to.be.eq("YearnV2Adapter[YEARN_CURVE_STETH_VAULT].deposit(amount: 19.00K [19000000000000000000000])", "Incorrect parse deposit(amount)");
+        parsed = parser.parse(ifc.encodeFunctionData("deposit(uint256,address)", [
+            constants_1.WAD.mul(19000),
+            constants_1.DUMB_ADDRESS,
+        ]));
+        (0, chai_1.expect)(parsed).to.be.eq("YearnV2Adapter[YEARN_CURVE_STETH_VAULT].deposit(amount: 19.00K [19000000000000000000000], address: ".concat(constants_1.DUMB_ADDRESS, ")"), "Incorrect parse deposit(amount,address)");
+        parsed = parser.parse(ifc.encodeFunctionData("withdraw()"));
+        (0, chai_1.expect)(parsed).to.be.eq("YearnV2Adapter[YEARN_CURVE_STETH_VAULT].withdraw()", "Incorrect parse withdraw()");
+        parsed = parser.parse(ifc.encodeFunctionData("withdraw(uint256)", [constants_1.WAD.mul(19000)]));
+        (0, chai_1.expect)(parsed).to.be.eq("YearnV2Adapter[YEARN_CURVE_STETH_VAULT].withdraw(amount: 19.00K [19000000000000000000000])", "Incorrect parse withdraw(amount)");
+        parsed = parser.parse(ifc.encodeFunctionData("withdraw(uint256,address)", [
+            constants_1.WAD.mul(19000),
+            constants_1.DUMB_ADDRESS,
+        ]));
+        (0, chai_1.expect)(parsed).to.be.eq("YearnV2Adapter[YEARN_CURVE_STETH_VAULT].withdraw(amount: 19.00K [19000000000000000000000], address: ".concat(constants_1.DUMB_ADDRESS, ")"), "Incorrect parse withdraw(amount,address)");
+        parsed = parser.parse(ifc.encodeFunctionData("withdraw(uint256,address,uint256)", [
+            constants_1.WAD.mul(19000),
+            constants_1.DUMB_ADDRESS,
+            555,
+        ]));
+        (0, chai_1.expect)(parsed).to.be.eq("YearnV2Adapter[YEARN_CURVE_STETH_VAULT].withdraw(amount: 19.00K [19000000000000000000000], address: ".concat(constants_1.DUMB_ADDRESS, ", maxLoss: 555)"), "Incorrect parse withdraw(amount,address,uint256)");
+    });
+});

package/lib/parsers/yearnV2AdapterParser.d.ts

@@ -0,0 +1,7 @@
+import { SupportedContract } from "../contracts/contracts";
+import { AbstractParser } from "./abstractParser";
+import { IParser } from "./iParser";
+export declare class YearnV2AdapterParser extends AbstractParser implements IParser {
+    constructor(contract: SupportedContract, isContract: boolean);
+    parse(calldata: string): string;
+}

package/lib/parsers/yearnV2AdapterParser.js

@@ -0,0 +1,54 @@
+"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 __());
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.YearnV2AdapterParser = void 0;
+var contracts_1 = require("../contracts/contracts");
+var types_1 = require("../types");
+var abstractParser_1 = require("./abstractParser");
+var YearnV2AdapterParser = /** @class */ (function (_super) {
+    __extends(YearnV2AdapterParser, _super);
+    function YearnV2AdapterParser(contract, isContract) {
+        var _this = _super.call(this, contract) || this;
+        _this.ifc = types_1.IYVault__factory.createInterface();
+        if (!isContract)
+            _this.adapterName = "YearnV2Adapter";
+        return _this;
+    }
+    YearnV2AdapterParser.prototype.parse = function (calldata) {
+        var _a = this.parseSelector(calldata), functionFragment = _a.functionFragment, functionName = _a.functionName;
+        switch (functionFragment.name) {
+            case "deposit":
+            case "withdraw":
+            case "deposit(uint256)":
+            case "withdraw(uint256)":
+            case "withdraw(uint256,address,uint256)": {
+                var _b = this.decodeFunctionData(functionFragment, calldata), amount = _b[0], address = _b[1], maxLoss = _b[2];
+                var yvSym = this.tokenSymbol(contracts_1.contractsByNetwork.Mainnet[this.contract]);
+                var amountStr = amount
+                    ? "amount: ".concat(this.formatBN(amount, yvSym))
+                    : "";
+                var addressStr = address ? ", address: ".concat(address) : "";
+                var maxLossStr = maxLoss ? ", maxLoss: ".concat(maxLoss) : "";
+                return "".concat(functionName, "(").concat(amountStr).concat(addressStr).concat(maxLossStr, ")");
+            }
+            default:
+                return "".concat(functionName, ": Unknown operation ").concat(functionFragment.name, " with calldata ").concat(calldata);
+        }
+    };
+    return YearnV2AdapterParser;
+}(abstractParser_1.AbstractParser));
+exports.YearnV2AdapterParser = YearnV2AdapterParser;

package/lib/tokens/convex.d.ts

@@ -1,7 +1,7 @@
-import type { ConvexPoolContract } from "../contracts/contracts";
+import type { ConvexPoolContract, SupportedContract } from "../contracts/contracts";
 import { TradeAction } from "../pathfinder/tradeTypes";
 import type { CurveLPToken } from "./curveLP";
-import type { TokenBase } from "./token";
+import type { SupportedToken, TokenBase } from "./token";
 import { TokenType } from "./tokenType";
 export declare type ConvexLPToken = "cvx3Crv" | "cvxsteCRV" | "cvxFRAX3CRV" | "cvxLUSD3CRV" | "cvxcrvPlain3andSUSD" | "cvxgusd3CRV";
 export declare type ConvexStakedPhantomToken = "stkcvx3Crv" | "stkcvxsteCRV" | "stkcvxFRAX3CRV" | "stkcvxLUSD3CRV" | "stkcvxcrvPlain3andSUSD" | "stkcvxgusd3CRV";
@@ -25,4 +25,6 @@ export declare const convexTokens: Record<ConvexLPToken | ConvexStakedPhantomTok
 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 {};

package/lib/tokens/convex.js

@@ -11,7 +11,7 @@ var __assign = (this && this.__assign) || function () {
     return __assign.apply(this, arguments);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isConvexStakedPhantomToken = exports.isConvexLPToken = exports.isConvexToken = exports.convexTokens = void 0;
+exports.convexLpTokenByPid = exports.convexPoolByPid = exports.isConvexStakedPhantomToken = exports.isConvexLPToken = exports.isConvexToken = exports.convexTokens = void 0;
 var tradeTypes_1 = require("../pathfinder/tradeTypes");
 var tokenType_1 = require("./tokenType");
 var convexLpTokens = {
@@ -297,3 +297,12 @@ var isConvexStakedPhantomToken = function (t) {
         !!convexStakedPhantomTokens[t];
 };
 exports.isConvexStakedPhantomToken = isConvexStakedPhantomToken;
+exports.convexPoolByPid = Object.values(convexLpTokens).reduce(function (acc, value) {
+    acc[value.pid] = value.pool;
+    return acc;
+}, {});
+exports.convexLpTokenByPid = Object.entries(convexLpTokens).reduce(function (acc, _a) {
+    var token = _a[0], data = _a[1];
+    acc[data.pid] = token;
+    return acc;
+}, {});

package/lib/tokens/decimals.d.ts

@@ -0,0 +1,2 @@
+import { SupportedToken } from "./token";
+export declare const decimals: Record<SupportedToken, number>;

package/lib/tokens/decimals.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.decimals = void 0;
+exports.decimals = {
+    "1INCH": 18,
+    AAVE: 18,
+    COMP: 18,
+    CRV: 18,
+    DAI: 18,
+    DPI: 18,
+    FEI: 18,
+    LINK: 18,
+    SNX: 18,
+    SUSHI: 18,
+    UNI: 18,
+    USDC: 6,
+    USDT: 6,
+    WBTC: 8,
+    WETH: 18,
+    YFI: 18,
+    STETH: 18,
+    FTM: 18,
+    CVX: 18,
+    FRAX: 18,
+    FXS: 18,
+    LDO: 18,
+    SPELL: 18,
+    LUSD: 18,
+    sUSD: 18,
+    GUSD: 2,
+    LUNA: 18,
+    LQTY: 18,
+    "3Crv": 18,
+    steCRV: 18,
+    crvPlain3andSUSD: 18,
+    FRAX3CRV: 18,
+    LUSD3CRV: 18,
+    gusd3CRV: 18,
+    cvx3Crv: 18,
+    cvxsteCRV: 18,
+    cvxFRAX3CRV: 18,
+    cvxLUSD3CRV: 18,
+    cvxcrvPlain3andSUSD: 18,
+    cvxgusd3CRV: 18,
+    stkcvx3Crv: 18,
+    stkcvxsteCRV: 18,
+    stkcvxFRAX3CRV: 18,
+    stkcvxLUSD3CRV: 18,
+    stkcvxcrvPlain3andSUSD: 18,
+    stkcvxgusd3CRV: 18,
+    yvDAI: 18,
+    yvUSDC: 6,
+    yvWETH: 18,
+    yvWBTC: 8,
+    yvCurve_stETH: 18,
+    yvCurve_FRAX: 18,
+    dDAI: 18,
+    dUSDC: 6,
+    dWBTC: 8,
+    dWETH: 18,
+    GEAR: 18,
+};

package/lib/tokens/tokenType.d.ts

@@ -1,11 +1,12 @@
 export declare enum TokenType {
-    NORMAL_TOKEN = 0,
-    CURVE_LP_TOKEN = 1,
-    YEARN_ON_NORMAL_TOKEN = 2,
-    YEARN_ON_CURVE_TOKEN = 3,
-    CONVEX_LP_TOKEN = 4,
-    CONVEX_STAKED_TOKEN = 5,
-    DIESEL_LP_TOKEN = 6,
-    GEAR_TOKEN = 7,
-    C_TOKEN = 8
+    NO_TOKEN = 0,
+    NORMAL_TOKEN = 1,
+    CURVE_LP_TOKEN = 2,
+    YEARN_ON_NORMAL_TOKEN = 3,
+    YEARN_ON_CURVE_TOKEN = 4,
+    CONVEX_LP_TOKEN = 5,
+    CONVEX_STAKED_TOKEN = 6,
+    DIESEL_LP_TOKEN = 7,
+    GEAR_TOKEN = 8,
+    C_TOKEN = 9
 }

package/lib/tokens/tokenType.js

@@ -3,13 +3,14 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.TokenType = void 0;
 var TokenType;
 (function (TokenType) {
-    TokenType[TokenType["NORMAL_TOKEN"] = 0] = "NORMAL_TOKEN";
-    TokenType[TokenType["CURVE_LP_TOKEN"] = 1] = "CURVE_LP_TOKEN";
-    TokenType[TokenType["YEARN_ON_NORMAL_TOKEN"] = 2] = "YEARN_ON_NORMAL_TOKEN";
-    TokenType[TokenType["YEARN_ON_CURVE_TOKEN"] = 3] = "YEARN_ON_CURVE_TOKEN";
-    TokenType[TokenType["CONVEX_LP_TOKEN"] = 4] = "CONVEX_LP_TOKEN";
-    TokenType[TokenType["CONVEX_STAKED_TOKEN"] = 5] = "CONVEX_STAKED_TOKEN";
-    TokenType[TokenType["DIESEL_LP_TOKEN"] = 6] = "DIESEL_LP_TOKEN";
-    TokenType[TokenType["GEAR_TOKEN"] = 7] = "GEAR_TOKEN";
-    TokenType[TokenType["C_TOKEN"] = 8] = "C_TOKEN";
+    TokenType[TokenType["NO_TOKEN"] = 0] = "NO_TOKEN";
+    TokenType[TokenType["NORMAL_TOKEN"] = 1] = "NORMAL_TOKEN";
+    TokenType[TokenType["CURVE_LP_TOKEN"] = 2] = "CURVE_LP_TOKEN";
+    TokenType[TokenType["YEARN_ON_NORMAL_TOKEN"] = 3] = "YEARN_ON_NORMAL_TOKEN";
+    TokenType[TokenType["YEARN_ON_CURVE_TOKEN"] = 4] = "YEARN_ON_CURVE_TOKEN";
+    TokenType[TokenType["CONVEX_LP_TOKEN"] = 5] = "CONVEX_LP_TOKEN";
+    TokenType[TokenType["CONVEX_STAKED_TOKEN"] = 6] = "CONVEX_STAKED_TOKEN";
+    TokenType[TokenType["DIESEL_LP_TOKEN"] = 7] = "DIESEL_LP_TOKEN";
+    TokenType[TokenType["GEAR_TOKEN"] = 8] = "GEAR_TOKEN";
+    TokenType[TokenType["C_TOKEN"] = 9] = "C_TOKEN";
 })(TokenType = exports.TokenType || (exports.TokenType = {}));

package/lib/types/contracts/interfaces/ICreditFacade.sol/ICreditFacadeExtended.d.ts

@@ -1,4 +1,4 @@
-import type { BaseContract, BigNumber, BigNumberish, BytesLike, CallOverrides, ContractTransaction, Overrides, PopulatedTransaction, Signer, utils } from "ethers";
+import type { BaseContract, BigNumber, BigNumberish, BytesLike, CallOverrides, ContractTransaction, Overrides, PayableOverrides, PopulatedTransaction, Signer, utils } from "ethers";
 import type { FunctionFragment, Result } from "@ethersproject/abi";
 import type { Listener, Provider } from "@ethersproject/providers";
 import type { TypedEventFilter, TypedEvent, TypedListener, OnEvent } from "../../../common";
@@ -12,13 +12,25 @@ export declare type BalanceStructOutput = [string, BigNumber] & {
 };
 export interface ICreditFacadeExtendedInterface extends utils.Interface {
     functions: {
+        "addCollateral(address,address,uint256)": FunctionFragment;
+        "decreaseDebt(uint256)": FunctionFragment;
         "disableToken(address)": FunctionFragment;
+        "enableToken(address)": FunctionFragment;
+        "increaseDebt(uint256)": FunctionFragment;
         "revertIfReceivedLessThan((address,uint256)[])": FunctionFragment;
     };
-    getFunction(nameOrSignatureOrTopic: "disableToken" | "revertIfReceivedLessThan"): FunctionFragment;
+    getFunction(nameOrSignatureOrTopic: "addCollateral" | "decreaseDebt" | "disableToken" | "enableToken" | "increaseDebt" | "revertIfReceivedLessThan"): FunctionFragment;
+    encodeFunctionData(functionFragment: "addCollateral", values: [string, string, BigNumberish]): string;
+    encodeFunctionData(functionFragment: "decreaseDebt", values: [BigNumberish]): string;
     encodeFunctionData(functionFragment: "disableToken", values: [string]): string;
+    encodeFunctionData(functionFragment: "enableToken", values: [string]): string;
+    encodeFunctionData(functionFragment: "increaseDebt", values: [BigNumberish]): string;
     encodeFunctionData(functionFragment: "revertIfReceivedLessThan", values: [BalanceStruct[]]): string;
+    decodeFunctionResult(functionFragment: "addCollateral", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "decreaseDebt", data: BytesLike): Result;
     decodeFunctionResult(functionFragment: "disableToken", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "enableToken", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "increaseDebt", data: BytesLike): Result;
     decodeFunctionResult(functionFragment: "revertIfReceivedLessThan", data: BytesLike): Result;
     events: {};
 }
@@ -37,36 +49,88 @@ export interface ICreditFacadeExtended extends BaseContract {
     once: OnEvent<this>;
     removeListener: OnEvent<this>;
     functions: {
+        addCollateral(onBehalfOf: string, token: string, amount: BigNumberish, overrides?: PayableOverrides & {
+            from?: string | Promise<string>;
+        }): Promise<ContractTransaction>;
+        decreaseDebt(amount: BigNumberish, overrides?: Overrides & {
+            from?: string | Promise<string>;
+        }): Promise<ContractTransaction>;
         disableToken(token: string, overrides?: Overrides & {
             from?: string | Promise<string>;
         }): Promise<ContractTransaction>;
+        enableToken(token: string, overrides?: Overrides & {
+            from?: string | Promise<string>;
+        }): Promise<ContractTransaction>;
+        increaseDebt(amount: BigNumberish, overrides?: Overrides & {
+            from?: string | Promise<string>;
+        }): Promise<ContractTransaction>;
         revertIfReceivedLessThan(expected: BalanceStruct[], overrides?: Overrides & {
             from?: string | Promise<string>;
         }): Promise<ContractTransaction>;
     };
+    addCollateral(onBehalfOf: string, token: string, amount: BigNumberish, overrides?: PayableOverrides & {
+        from?: string | Promise<string>;
+    }): Promise<ContractTransaction>;
+    decreaseDebt(amount: BigNumberish, overrides?: Overrides & {
+        from?: string | Promise<string>;
+    }): Promise<ContractTransaction>;
     disableToken(token: string, overrides?: Overrides & {
         from?: string | Promise<string>;
     }): Promise<ContractTransaction>;
+    enableToken(token: string, overrides?: Overrides & {
+        from?: string | Promise<string>;
+    }): Promise<ContractTransaction>;
+    increaseDebt(amount: BigNumberish, overrides?: Overrides & {
+        from?: string | Promise<string>;
+    }): Promise<ContractTransaction>;
     revertIfReceivedLessThan(expected: BalanceStruct[], overrides?: Overrides & {
         from?: string | Promise<string>;
     }): Promise<ContractTransaction>;
     callStatic: {
+        addCollateral(onBehalfOf: string, token: string, amount: BigNumberish, overrides?: CallOverrides): Promise<void>;
+        decreaseDebt(amount: BigNumberish, overrides?: CallOverrides): Promise<void>;
         disableToken(token: string, overrides?: CallOverrides): Promise<void>;
+        enableToken(token: string, overrides?: CallOverrides): Promise<void>;
+        increaseDebt(amount: BigNumberish, overrides?: CallOverrides): Promise<void>;
         revertIfReceivedLessThan(expected: BalanceStruct[], overrides?: CallOverrides): Promise<void>;
     };
     filters: {};
     estimateGas: {
+        addCollateral(onBehalfOf: string, token: string, amount: BigNumberish, overrides?: PayableOverrides & {
+            from?: string | Promise<string>;
+        }): Promise<BigNumber>;
+        decreaseDebt(amount: BigNumberish, overrides?: Overrides & {
+            from?: string | Promise<string>;
+        }): Promise<BigNumber>;
         disableToken(token: string, overrides?: Overrides & {
             from?: string | Promise<string>;
         }): Promise<BigNumber>;
+        enableToken(token: string, overrides?: Overrides & {
+            from?: string | Promise<string>;
+        }): Promise<BigNumber>;
+        increaseDebt(amount: BigNumberish, overrides?: Overrides & {
+            from?: string | Promise<string>;
+        }): Promise<BigNumber>;
         revertIfReceivedLessThan(expected: BalanceStruct[], overrides?: Overrides & {
             from?: string | Promise<string>;
         }): Promise<BigNumber>;
     };
     populateTransaction: {
+        addCollateral(onBehalfOf: string, token: string, amount: BigNumberish, overrides?: PayableOverrides & {
+            from?: string | Promise<string>;
+        }): Promise<PopulatedTransaction>;
+        decreaseDebt(amount: BigNumberish, overrides?: Overrides & {
+            from?: string | Promise<string>;
+        }): Promise<PopulatedTransaction>;
         disableToken(token: string, overrides?: Overrides & {
             from?: string | Promise<string>;
         }): Promise<PopulatedTransaction>;
+        enableToken(token: string, overrides?: Overrides & {
+            from?: string | Promise<string>;
+        }): Promise<PopulatedTransaction>;
+        increaseDebt(amount: BigNumberish, overrides?: Overrides & {
+            from?: string | Promise<string>;
+        }): Promise<PopulatedTransaction>;
         revertIfReceivedLessThan(expected: BalanceStruct[], overrides?: Overrides & {
             from?: string | Promise<string>;
         }): Promise<PopulatedTransaction>;