@venusprotocol/venus-protocol 5.1.0-dev.2 → 5.1.0-dev.3

package/contracts/Liquidator/BUSDLiquidator.sol

@@ -0,0 +1,184 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.13;
+
+import { SafeERC20Upgradeable, IERC20Upgradeable } from "@openzeppelin/contracts-upgradeable/token/ERC20/utils/SafeERC20Upgradeable.sol";
+import { ReentrancyGuardUpgradeable } from "@openzeppelin/contracts-upgradeable/security/ReentrancyGuardUpgradeable.sol";
+import { Ownable2StepUpgradeable } from "@openzeppelin/contracts-upgradeable/access/Ownable2StepUpgradeable.sol";
+
+import { MANTISSA_ONE } from "./constants.sol";
+import { ensureNonzeroAddress } from "./zeroAddress.sol";
+import { approveOrRevert } from "./approveOrRevert.sol";
+import { ILiquidator, IComptroller, IVToken, IVBep20, IVBNB, IVAIController } from "./Interfaces.sol";
+
+/**
+ * @title BUSDLiquidator
+ * @author Venus
+ * @notice A custom contract for force-liquidating BUSD debts
+ */
+contract BUSDLiquidator is Ownable2StepUpgradeable, ReentrancyGuardUpgradeable {
+    using SafeERC20Upgradeable for IERC20Upgradeable;
+    using SafeERC20Upgradeable for IVToken;
+
+    /// @custom:oz-upgrades-unsafe-allow state-variable-immutable
+    IVBep20 public immutable vBUSD;
+
+    /// @custom:oz-upgrades-unsafe-allow state-variable-immutable
+    IComptroller public immutable comptroller;
+
+    /// @custom:oz-upgrades-unsafe-allow state-variable-immutable
+    address public immutable treasury;
+
+    /// @notice The liquidator's share, scaled by 1e18 (e.g. 1.02 * 1e18 for 102% of the debt covered)
+    uint256 public liquidatorShareMantissa;
+
+    /// @notice Thrown if trying to set liquidator's share lower than 100% of the debt covered
+    error LiquidatorShareTooLow(uint256 liquidatorShareMantissa_);
+
+    /// @notice Thrown if trying to set liquidator's share larger than this contract can receive from a liquidation
+    error LiquidatorShareTooHigh(uint256 maxLiquidatorShareMantissa, uint256 liquidatorShareMantissa_);
+
+    /// @notice Emitted when the liquidator's share is set
+    event NewLiquidatorShare(uint256 oldLiquidatorShareMantissa, uint256 newLiquidatorShareMantissa);
+
+    /// @notice Constructor for the implementation contract. Sets immutable variables.
+    /// @param comptroller_ The address of the Comptroller contract
+    /// @param vBUSD_ The address of the VBNB
+    /// @param treasury_ The address of Venus treasury
+    /// @custom:oz-upgrades-unsafe-allow constructor
+    constructor(address comptroller_, address vBUSD_, address treasury_) {
+        ensureNonzeroAddress(vBUSD_);
+        ensureNonzeroAddress(comptroller_);
+        ensureNonzeroAddress(treasury_);
+        vBUSD = IVBep20(vBUSD_);
+        comptroller = IComptroller(comptroller_);
+        treasury = treasury_;
+        _disableInitializers();
+    }
+
+    /// @notice Initializer for the implementation contract.
+    /// @param liquidatorShareMantissa_ Liquidator's share, scaled by 1e18 (e.g. 1.01 * 1e18 for 101%)
+    /// @custom:error LiquidatorShareTooHigh is thrown if trying to set liquidator percent larger than the liquidation profit
+    function initialize(uint256 liquidatorShareMantissa_) external virtual initializer {
+        __Ownable2Step_init();
+        __ReentrancyGuard_init();
+        _validateLiquidatorShareMantissa(liquidatorShareMantissa_);
+        liquidatorShareMantissa = liquidatorShareMantissa_;
+    }
+
+    /// @notice Liquidate the entire BUSD debt of a borrower, seizing vTokenCollateral
+    /// @param borrower The borrower whose debt should be liquidated
+    /// @param vTokenCollateral The collateral to seize from the borrower
+    function liquidateEntireBorrow(address borrower, IVToken vTokenCollateral) external nonReentrant {
+        uint256 repayAmount = vBUSD.borrowBalanceCurrent(borrower);
+        _unpauseAndLiquidate(borrower, repayAmount, vTokenCollateral);
+    }
+
+    /// @notice Liquidate a BUSD borrow, repaying the repayAmount of BUSD
+    /// @param borrower The borrower whose debt should be liquidated
+    /// @param repayAmount The amount to repay
+    /// @param vTokenCollateral The collateral to seize from the borrower
+    function liquidateBorrow(address borrower, uint256 repayAmount, IVToken vTokenCollateral) external nonReentrant {
+        _unpauseAndLiquidate(borrower, repayAmount, vTokenCollateral);
+    }
+
+    /// @notice Allows Governance to set the liquidator's share
+    /// @param liquidatorShareMantissa_ Liquidator's share, scaled by 1e18 (e.g. 1.01 * 1e18 for 101%)
+    /// @custom:access Only Governance
+    function setLiquidatorShare(uint256 liquidatorShareMantissa_) external onlyOwner {
+        _validateLiquidatorShareMantissa(liquidatorShareMantissa_);
+        uint256 oldLiquidatorShareMantissa = liquidatorShareMantissa;
+        liquidatorShareMantissa = liquidatorShareMantissa_;
+        emit NewLiquidatorShare(oldLiquidatorShareMantissa, liquidatorShareMantissa_);
+    }
+
+    /// @notice Allows to recover token accidentally sent to this contract by sending the entire balance to Governance
+    /// @param token The address of the token to recover
+    /// @custom:access Only Governance
+    function sweepToken(IERC20Upgradeable token) external onlyOwner {
+        token.safeTransfer(msg.sender, token.balanceOf(address(this)));
+    }
+
+    /// @dev Unpauses the liquidation on the BUSD market, liquidates the borrower's debt,
+    /// and pauses the liquidations back
+    /// @param borrower The borrower whose debt should be liquidated
+    /// @param repayAmount The amount to repay
+    /// @param vTokenCollateral The collateral to seize from the borrower
+    function _unpauseAndLiquidate(address borrower, uint256 repayAmount, IVToken vTokenCollateral) internal {
+        address[] memory vTokens = new address[](1);
+        vTokens[0] = address(vBUSD);
+        IComptroller.Action[] memory actions = new IComptroller.Action[](1);
+        actions[0] = IComptroller.Action.LIQUIDATE;
+
+        comptroller._setActionsPaused(vTokens, actions, false);
+        _liquidateBorrow(borrower, repayAmount, vTokenCollateral);
+        comptroller._setActionsPaused(vTokens, actions, true);
+    }
+
+    /// @dev Performs the actual liquidation, transferring BUSD from the sender to this contract,
+    /// repaying the debt, and transferring the seized collateral to the sender and the treasury
+    /// @param borrower The borrower whose debt should be liquidated
+    /// @param repayAmount The amount to repay
+    /// @param vTokenCollateral The collateral to seize from the borrower
+    function _liquidateBorrow(address borrower, uint256 repayAmount, IVToken vTokenCollateral) internal {
+        ILiquidator liquidatorContract = ILiquidator(comptroller.liquidatorContract());
+        IERC20Upgradeable busd = IERC20Upgradeable(vBUSD.underlying());
+
+        uint256 actualRepayAmount = _transferIn(busd, msg.sender, repayAmount);
+        approveOrRevert(busd, address(liquidatorContract), actualRepayAmount);
+        uint256 balanceBefore = vTokenCollateral.balanceOf(address(this));
+        liquidatorContract.liquidateBorrow(address(vBUSD), borrower, actualRepayAmount, vTokenCollateral);
+        uint256 receivedAmount = vTokenCollateral.balanceOf(address(this)) - balanceBefore;
+        approveOrRevert(busd, address(liquidatorContract), 0);
+
+        (uint256 liquidatorAmount, uint256 treasuryAmount) = _computeShares(receivedAmount);
+        vTokenCollateral.safeTransfer(msg.sender, liquidatorAmount);
+        vTokenCollateral.safeTransfer(treasury, treasuryAmount);
+    }
+
+    /// @dev Transfers tokens to this contract and returns the actual transfer amount
+    /// @param token The token to transfer
+    /// @param from The account to transfer from
+    /// @param amount The amount to transfer
+    /// @return The actual amount transferred
+    function _transferIn(IERC20Upgradeable token, address from, uint256 amount) internal returns (uint256) {
+        uint256 prevBalance = token.balanceOf(address(this));
+        token.safeTransferFrom(from, address(this), amount);
+        return token.balanceOf(address(this)) - prevBalance;
+    }
+
+    /// @dev Computes the liquidator's and treasury's shares of the received amount
+    /// @param receivedAmount The amount received from the liquidation
+    /// @return liquidatorAmount The liquidator's share
+    /// @return treasuryAmount The treasury's share
+    function _computeShares(
+        uint256 receivedAmount
+    ) internal view returns (uint256 liquidatorAmount, uint256 treasuryAmount) {
+        uint256 denominator = _getDenominator();
+        liquidatorAmount = (receivedAmount * liquidatorShareMantissa) / denominator;
+        treasuryAmount = receivedAmount - liquidatorAmount;
+    }
+
+    /// @dev Returns (liquidation incentive - treasury percent), the value used as the denominator
+    /// when calculating the liquidator's share
+    /// @return The denominator for the seized amount used when calculating the liquidator's share
+    function _getDenominator() internal view returns (uint256) {
+        uint256 totalPercentageToDistribute = comptroller.liquidationIncentiveMantissa();
+        uint256 regularTreasuryPercent = ILiquidator(comptroller.liquidatorContract()).treasuryPercentMantissa();
+        uint256 denominator = totalPercentageToDistribute - regularTreasuryPercent;
+        return denominator;
+    }
+
+    /// @dev Checks if the liquidator's share is more than 100% of the debt covered and less
+    /// than (liquidation incentive - treasury percent)
+    /// @param liquidatorShareMantissa_ Liquidator's share, scaled by 1e18 (e.g. 1.01 * 1e18 for 101%)
+    function _validateLiquidatorShareMantissa(uint256 liquidatorShareMantissa_) internal view {
+        uint256 maxLiquidatorShareMantissa = _getDenominator();
+        if (liquidatorShareMantissa_ < MANTISSA_ONE) {
+            revert LiquidatorShareTooLow(liquidatorShareMantissa_);
+        }
+
+        if (liquidatorShareMantissa_ > maxLiquidatorShareMantissa) {
+            revert LiquidatorShareTooHigh(maxLiquidatorShareMantissa, liquidatorShareMantissa_);
+        }
+    }
+}

package/contracts/Liquidator/Interfaces.sol

@@ -1,8 +1,13 @@
+// SPDX-License-Identifier: BSD-3-Clause
 pragma solidity 0.8.13;
 
 import { IERC20Upgradeable } from "@openzeppelin/contracts-upgradeable/token/ERC20/utils/SafeERC20Upgradeable.sol";
 
-interface IVToken is IERC20Upgradeable {}
+interface IVToken is IERC20Upgradeable {
+    function borrowBalanceCurrent(address borrower) external returns (uint256);
+
+    function transfer(address dst, uint256 amount) external returns (bool);
+}
 
 interface IVBep20 is IVToken {
     function underlying() external view returns (address);
@@ -29,7 +34,44 @@ interface IVAIController {
 }
 
 interface IComptroller {
+    enum Action {
+        MINT,
+        REDEEM,
+        BORROW,
+        REPAY,
+        SEIZE,
+        LIQUIDATE,
+        TRANSFER,
+        ENTER_MARKET,
+        EXIT_MARKET
+    }
+
+    function _setActionsPaused(address[] calldata markets_, Action[] calldata actions_, bool paused_) external;
+
     function liquidationIncentiveMantissa() external view returns (uint256);
 
     function vaiController() external view returns (IVAIController);
+
+    function liquidatorContract() external view returns (address);
+}
+
+interface ILiquidator {
+    function restrictLiquidation(address borrower) external;
+
+    function unrestrictLiquidation(address borrower) external;
+
+    function addToAllowlist(address borrower, address liquidator) external;
+
+    function removeFromAllowlist(address borrower, address liquidator) external;
+
+    function liquidateBorrow(
+        address vToken,
+        address borrower,
+        uint256 repayAmount,
+        IVToken vTokenCollateral
+    ) external payable;
+
+    function setTreasuryPercent(uint256 newTreasuryPercentMantissa) external;
+
+    function treasuryPercentMantissa() external view returns (uint256);
 }

package/contracts/Liquidator/Liquidator.sol

@@ -5,14 +5,15 @@ import "@openzeppelin/contracts-upgradeable/token/ERC20/utils/SafeERC20Upgradeab
 import "@openzeppelin/contracts-upgradeable/security/ReentrancyGuardUpgradeable.sol";
 import "@openzeppelin/contracts-upgradeable/access/Ownable2StepUpgradeable.sol";
 
-import { IComptroller, IVToken, IVBep20, IVBNB, IVAIController } from "./Interfaces.sol";
+import { ensureNonzeroAddress } from "./zeroAddress.sol";
+import { ILiquidator, IComptroller, IVToken, IVBep20, IVBNB, IVAIController } from "./Interfaces.sol";
 
 /**
  * @title Liquidator
  * @author Venus
  * @notice The Liquidator contract is responsible for liquidating underwater accounts.
  */
-contract Liquidator is Ownable2StepUpgradeable, ReentrancyGuardUpgradeable {
+contract Liquidator is ILiquidator, Ownable2StepUpgradeable, ReentrancyGuardUpgradeable {
     /// @notice Address of vBNB contract.
     /// @custom:oz-upgrades-unsafe-allow state-variable-immutable
     IVBNB public immutable vBnb;
@@ -95,9 +96,6 @@ contract Liquidator is Ownable2StepUpgradeable, ReentrancyGuardUpgradeable {
     ///         intended BNB repayment
     error WrongTransactionAmount(uint256 expected, uint256 actual);
 
-    /// @notice Thrown if the argument is a zero address because probably it is a mistake
-    error UnexpectedZeroAddress();
-
     /// @notice Thrown if trying to set treasury percent larger than the liquidation profit
     error TreasuryPercentTooHigh(uint256 maxTreasuryPercentMantissa, uint256 treasuryPercentMantissa_);
 
@@ -307,12 +305,6 @@ contract Liquidator is Ownable2StepUpgradeable, ReentrancyGuardUpgradeable {
         revert LiquidationFailed(errCode);
     }
 
-    function ensureNonzeroAddress(address address_) internal pure {
-        if (address_ == address(0)) {
-            revert UnexpectedZeroAddress();
-        }
-    }
-
     function checkRestrictions(address borrower, address liquidator) internal view {
         if (liquidationRestricted[borrower] && !allowedLiquidatorsByAccount[borrower][liquidator]) {
             revert LiquidationNotAllowed(borrower, liquidator);

package/contracts/Liquidator/approveOrRevert.sol

@@ -0,0 +1,28 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity 0.8.13;
+
+import { IERC20Upgradeable } from "@openzeppelin/contracts-upgradeable/token/ERC20/IERC20Upgradeable.sol";
+
+/// @notice Thrown if a contract is unable to approve a transfer
+error ApproveFailed();
+
+/// @notice Approves a transfer, ensuring that it is successful. This function supports non-compliant
+/// tokens like the ones that don't return a boolean value on success. Thus, such approve call supports
+/// three different kinds of tokens:
+///   * Compliant tokens that revert on failure
+///   * Compliant tokens that return false on failure
+///   * Non-compliant tokens that don't return a value
+/// @param token The contract address of the token which will be transferred
+/// @param spender The spender contract address
+/// @param amount The value of the transfer
+function approveOrRevert(IERC20Upgradeable token, address spender, uint256 amount) {
+    bytes memory callData = abi.encodeCall(token.approve, (spender, amount));
+
+    // solhint-disable-next-line avoid-low-level-calls
+    (bool success, bytes memory result) = address(token).call(callData);
+
+    if (!success || (result.length != 0 && !abi.decode(result, (bool)))) {
+        revert ApproveFailed();
+    }
+}

package/contracts/Liquidator/constants.sol

@@ -0,0 +1,5 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity 0.8.13;
+
+uint256 constant MANTISSA_ONE = 1e18;

package/contracts/Liquidator/zeroAddress.sol

@@ -0,0 +1,11 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.13;
+
+/// @notice Thrown if the argument is a zero address because probably it is a mistake
+error UnexpectedZeroAddress();
+
+function ensureNonzeroAddress(address address_) pure {
+    if (address_ == address(0)) {
+        revert UnexpectedZeroAddress();
+    }
+}

package/dist/typechain/contracts/Liquidator/BUSDLiquidator.d.ts

@@ -0,0 +1,264 @@
+import type { TypedEventFilter, TypedEvent, TypedListener, OnEvent, PromiseOrValue } from "../../common";
+import type { FunctionFragment, Result, EventFragment } from "@ethersproject/abi";
+import type { Listener, Provider } from "@ethersproject/providers";
+import type { BaseContract, BigNumber, BigNumberish, BytesLike, CallOverrides, ContractTransaction, Overrides, PopulatedTransaction, Signer, utils } from "ethers";
+export interface BUSDLiquidatorInterface extends utils.Interface {
+    functions: {
+        "acceptOwnership()": FunctionFragment;
+        "comptroller()": FunctionFragment;
+        "initialize(uint256)": FunctionFragment;
+        "liquidateBorrow(address,uint256,address)": FunctionFragment;
+        "liquidateEntireBorrow(address,address)": FunctionFragment;
+        "liquidatorShareMantissa()": FunctionFragment;
+        "owner()": FunctionFragment;
+        "pendingOwner()": FunctionFragment;
+        "renounceOwnership()": FunctionFragment;
+        "setLiquidatorShare(uint256)": FunctionFragment;
+        "sweepToken(address)": FunctionFragment;
+        "transferOwnership(address)": FunctionFragment;
+        "treasury()": FunctionFragment;
+        "vBUSD()": FunctionFragment;
+    };
+    getFunction(nameOrSignatureOrTopic: "acceptOwnership" | "comptroller" | "initialize" | "liquidateBorrow" | "liquidateEntireBorrow" | "liquidatorShareMantissa" | "owner" | "pendingOwner" | "renounceOwnership" | "setLiquidatorShare" | "sweepToken" | "transferOwnership" | "treasury" | "vBUSD"): FunctionFragment;
+    encodeFunctionData(functionFragment: "acceptOwnership", values?: undefined): string;
+    encodeFunctionData(functionFragment: "comptroller", values?: undefined): string;
+    encodeFunctionData(functionFragment: "initialize", values: [PromiseOrValue<BigNumberish>]): string;
+    encodeFunctionData(functionFragment: "liquidateBorrow", values: [
+        PromiseOrValue<string>,
+        PromiseOrValue<BigNumberish>,
+        PromiseOrValue<string>
+    ]): string;
+    encodeFunctionData(functionFragment: "liquidateEntireBorrow", values: [PromiseOrValue<string>, PromiseOrValue<string>]): string;
+    encodeFunctionData(functionFragment: "liquidatorShareMantissa", values?: undefined): string;
+    encodeFunctionData(functionFragment: "owner", values?: undefined): string;
+    encodeFunctionData(functionFragment: "pendingOwner", values?: undefined): string;
+    encodeFunctionData(functionFragment: "renounceOwnership", values?: undefined): string;
+    encodeFunctionData(functionFragment: "setLiquidatorShare", values: [PromiseOrValue<BigNumberish>]): string;
+    encodeFunctionData(functionFragment: "sweepToken", values: [PromiseOrValue<string>]): string;
+    encodeFunctionData(functionFragment: "transferOwnership", values: [PromiseOrValue<string>]): string;
+    encodeFunctionData(functionFragment: "treasury", values?: undefined): string;
+    encodeFunctionData(functionFragment: "vBUSD", values?: undefined): string;
+    decodeFunctionResult(functionFragment: "acceptOwnership", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "comptroller", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "initialize", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "liquidateBorrow", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "liquidateEntireBorrow", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "liquidatorShareMantissa", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "owner", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "pendingOwner", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "renounceOwnership", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "setLiquidatorShare", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "sweepToken", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "transferOwnership", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "treasury", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "vBUSD", data: BytesLike): Result;
+    events: {
+        "Initialized(uint8)": EventFragment;
+        "NewLiquidatorShare(uint256,uint256)": EventFragment;
+        "OwnershipTransferStarted(address,address)": EventFragment;
+        "OwnershipTransferred(address,address)": EventFragment;
+    };
+    getEvent(nameOrSignatureOrTopic: "Initialized"): EventFragment;
+    getEvent(nameOrSignatureOrTopic: "NewLiquidatorShare"): EventFragment;
+    getEvent(nameOrSignatureOrTopic: "OwnershipTransferStarted"): EventFragment;
+    getEvent(nameOrSignatureOrTopic: "OwnershipTransferred"): EventFragment;
+}
+export interface InitializedEventObject {
+    version: number;
+}
+export type InitializedEvent = TypedEvent<[number], InitializedEventObject>;
+export type InitializedEventFilter = TypedEventFilter<InitializedEvent>;
+export interface NewLiquidatorShareEventObject {
+    oldLiquidatorShareMantissa: BigNumber;
+    newLiquidatorShareMantissa: BigNumber;
+}
+export type NewLiquidatorShareEvent = TypedEvent<[
+    BigNumber,
+    BigNumber
+], NewLiquidatorShareEventObject>;
+export type NewLiquidatorShareEventFilter = TypedEventFilter<NewLiquidatorShareEvent>;
+export interface OwnershipTransferStartedEventObject {
+    previousOwner: string;
+    newOwner: string;
+}
+export type OwnershipTransferStartedEvent = TypedEvent<[
+    string,
+    string
+], OwnershipTransferStartedEventObject>;
+export type OwnershipTransferStartedEventFilter = TypedEventFilter<OwnershipTransferStartedEvent>;
+export interface OwnershipTransferredEventObject {
+    previousOwner: string;
+    newOwner: string;
+}
+export type OwnershipTransferredEvent = TypedEvent<[
+    string,
+    string
+], OwnershipTransferredEventObject>;
+export type OwnershipTransferredEventFilter = TypedEventFilter<OwnershipTransferredEvent>;
+export interface BUSDLiquidator extends BaseContract {
+    connect(signerOrProvider: Signer | Provider | string): this;
+    attach(addressOrName: string): this;
+    deployed(): Promise<this>;
+    interface: BUSDLiquidatorInterface;
+    queryFilter<TEvent extends TypedEvent>(event: TypedEventFilter<TEvent>, fromBlockOrBlockhash?: string | number | undefined, toBlock?: string | number | undefined): Promise<Array<TEvent>>;
+    listeners<TEvent extends TypedEvent>(eventFilter?: TypedEventFilter<TEvent>): Array<TypedListener<TEvent>>;
+    listeners(eventName?: string): Array<Listener>;
+    removeAllListeners<TEvent extends TypedEvent>(eventFilter: TypedEventFilter<TEvent>): this;
+    removeAllListeners(eventName?: string): this;
+    off: OnEvent<this>;
+    on: OnEvent<this>;
+    once: OnEvent<this>;
+    removeListener: OnEvent<this>;
+    functions: {
+        acceptOwnership(overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<ContractTransaction>;
+        comptroller(overrides?: CallOverrides): Promise<[string]>;
+        initialize(liquidatorShareMantissa_: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<ContractTransaction>;
+        liquidateBorrow(borrower: PromiseOrValue<string>, repayAmount: PromiseOrValue<BigNumberish>, vTokenCollateral: PromiseOrValue<string>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<ContractTransaction>;
+        liquidateEntireBorrow(borrower: PromiseOrValue<string>, vTokenCollateral: PromiseOrValue<string>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<ContractTransaction>;
+        liquidatorShareMantissa(overrides?: CallOverrides): Promise<[BigNumber]>;
+        owner(overrides?: CallOverrides): Promise<[string]>;
+        pendingOwner(overrides?: CallOverrides): Promise<[string]>;
+        renounceOwnership(overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<ContractTransaction>;
+        setLiquidatorShare(liquidatorShareMantissa_: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<ContractTransaction>;
+        sweepToken(token: PromiseOrValue<string>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<ContractTransaction>;
+        transferOwnership(newOwner: PromiseOrValue<string>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<ContractTransaction>;
+        treasury(overrides?: CallOverrides): Promise<[string]>;
+        vBUSD(overrides?: CallOverrides): Promise<[string]>;
+    };
+    acceptOwnership(overrides?: Overrides & {
+        from?: PromiseOrValue<string>;
+    }): Promise<ContractTransaction>;
+    comptroller(overrides?: CallOverrides): Promise<string>;
+    initialize(liquidatorShareMantissa_: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+        from?: PromiseOrValue<string>;
+    }): Promise<ContractTransaction>;
+    liquidateBorrow(borrower: PromiseOrValue<string>, repayAmount: PromiseOrValue<BigNumberish>, vTokenCollateral: PromiseOrValue<string>, overrides?: Overrides & {
+        from?: PromiseOrValue<string>;
+    }): Promise<ContractTransaction>;
+    liquidateEntireBorrow(borrower: PromiseOrValue<string>, vTokenCollateral: PromiseOrValue<string>, overrides?: Overrides & {
+        from?: PromiseOrValue<string>;
+    }): Promise<ContractTransaction>;
+    liquidatorShareMantissa(overrides?: CallOverrides): Promise<BigNumber>;
+    owner(overrides?: CallOverrides): Promise<string>;
+    pendingOwner(overrides?: CallOverrides): Promise<string>;
+    renounceOwnership(overrides?: Overrides & {
+        from?: PromiseOrValue<string>;
+    }): Promise<ContractTransaction>;
+    setLiquidatorShare(liquidatorShareMantissa_: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+        from?: PromiseOrValue<string>;
+    }): Promise<ContractTransaction>;
+    sweepToken(token: PromiseOrValue<string>, overrides?: Overrides & {
+        from?: PromiseOrValue<string>;
+    }): Promise<ContractTransaction>;
+    transferOwnership(newOwner: PromiseOrValue<string>, overrides?: Overrides & {
+        from?: PromiseOrValue<string>;
+    }): Promise<ContractTransaction>;
+    treasury(overrides?: CallOverrides): Promise<string>;
+    vBUSD(overrides?: CallOverrides): Promise<string>;
+    callStatic: {
+        acceptOwnership(overrides?: CallOverrides): Promise<void>;
+        comptroller(overrides?: CallOverrides): Promise<string>;
+        initialize(liquidatorShareMantissa_: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<void>;
+        liquidateBorrow(borrower: PromiseOrValue<string>, repayAmount: PromiseOrValue<BigNumberish>, vTokenCollateral: PromiseOrValue<string>, overrides?: CallOverrides): Promise<void>;
+        liquidateEntireBorrow(borrower: PromiseOrValue<string>, vTokenCollateral: PromiseOrValue<string>, overrides?: CallOverrides): Promise<void>;
+        liquidatorShareMantissa(overrides?: CallOverrides): Promise<BigNumber>;
+        owner(overrides?: CallOverrides): Promise<string>;
+        pendingOwner(overrides?: CallOverrides): Promise<string>;
+        renounceOwnership(overrides?: CallOverrides): Promise<void>;
+        setLiquidatorShare(liquidatorShareMantissa_: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<void>;
+        sweepToken(token: PromiseOrValue<string>, overrides?: CallOverrides): Promise<void>;
+        transferOwnership(newOwner: PromiseOrValue<string>, overrides?: CallOverrides): Promise<void>;
+        treasury(overrides?: CallOverrides): Promise<string>;
+        vBUSD(overrides?: CallOverrides): Promise<string>;
+    };
+    filters: {
+        "Initialized(uint8)"(version?: null): InitializedEventFilter;
+        Initialized(version?: null): InitializedEventFilter;
+        "NewLiquidatorShare(uint256,uint256)"(oldLiquidatorShareMantissa?: null, newLiquidatorShareMantissa?: null): NewLiquidatorShareEventFilter;
+        NewLiquidatorShare(oldLiquidatorShareMantissa?: null, newLiquidatorShareMantissa?: null): NewLiquidatorShareEventFilter;
+        "OwnershipTransferStarted(address,address)"(previousOwner?: PromiseOrValue<string> | null, newOwner?: PromiseOrValue<string> | null): OwnershipTransferStartedEventFilter;
+        OwnershipTransferStarted(previousOwner?: PromiseOrValue<string> | null, newOwner?: PromiseOrValue<string> | null): OwnershipTransferStartedEventFilter;
+        "OwnershipTransferred(address,address)"(previousOwner?: PromiseOrValue<string> | null, newOwner?: PromiseOrValue<string> | null): OwnershipTransferredEventFilter;
+        OwnershipTransferred(previousOwner?: PromiseOrValue<string> | null, newOwner?: PromiseOrValue<string> | null): OwnershipTransferredEventFilter;
+    };
+    estimateGas: {
+        acceptOwnership(overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<BigNumber>;
+        comptroller(overrides?: CallOverrides): Promise<BigNumber>;
+        initialize(liquidatorShareMantissa_: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<BigNumber>;
+        liquidateBorrow(borrower: PromiseOrValue<string>, repayAmount: PromiseOrValue<BigNumberish>, vTokenCollateral: PromiseOrValue<string>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<BigNumber>;
+        liquidateEntireBorrow(borrower: PromiseOrValue<string>, vTokenCollateral: PromiseOrValue<string>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<BigNumber>;
+        liquidatorShareMantissa(overrides?: CallOverrides): Promise<BigNumber>;
+        owner(overrides?: CallOverrides): Promise<BigNumber>;
+        pendingOwner(overrides?: CallOverrides): Promise<BigNumber>;
+        renounceOwnership(overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<BigNumber>;
+        setLiquidatorShare(liquidatorShareMantissa_: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<BigNumber>;
+        sweepToken(token: PromiseOrValue<string>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<BigNumber>;
+        transferOwnership(newOwner: PromiseOrValue<string>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<BigNumber>;
+        treasury(overrides?: CallOverrides): Promise<BigNumber>;
+        vBUSD(overrides?: CallOverrides): Promise<BigNumber>;
+    };
+    populateTransaction: {
+        acceptOwnership(overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<PopulatedTransaction>;
+        comptroller(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        initialize(liquidatorShareMantissa_: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<PopulatedTransaction>;
+        liquidateBorrow(borrower: PromiseOrValue<string>, repayAmount: PromiseOrValue<BigNumberish>, vTokenCollateral: PromiseOrValue<string>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<PopulatedTransaction>;
+        liquidateEntireBorrow(borrower: PromiseOrValue<string>, vTokenCollateral: PromiseOrValue<string>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<PopulatedTransaction>;
+        liquidatorShareMantissa(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        owner(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        pendingOwner(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        renounceOwnership(overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<PopulatedTransaction>;
+        setLiquidatorShare(liquidatorShareMantissa_: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<PopulatedTransaction>;
+        sweepToken(token: PromiseOrValue<string>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<PopulatedTransaction>;
+        transferOwnership(newOwner: PromiseOrValue<string>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<PopulatedTransaction>;
+        treasury(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        vBUSD(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+    };
+}

package/dist/typechain/contracts/Liquidator/BUSDLiquidator.js

@@ -0,0 +1,3 @@
+"use strict";
+/* Autogenerated file. Do not edit manually. */
+Object.defineProperty(exports, "__esModule", { value: true });