@venusprotocol/protocol-reserve 1.3.0 → 1.4.0-dev.1

package/contracts/Test/Mocks/MockACM.sol

@@ -0,0 +1,94 @@
+// SPDX-License-Identifier: BSD-3-Clause
+pragma solidity 0.8.13;
+
+import { AccessControl } from "@openzeppelin/contracts/access/AccessControl.sol";
+
+contract MockACM is AccessControl {
+    /// @notice Emitted when an account is given a permission to a certain contract function
+    /// @dev If contract address is 0x000..0 this means that the account is a default admin of this function and
+    /// can call any contract function with this signature
+    event PermissionGranted(address account, address contractAddress, string functionSig);
+
+    /// @notice Emitted when an account is revoked a permission to a certain contract function
+    event PermissionRevoked(address account, address contractAddress, string functionSig);
+
+    constructor() {
+        // Grant the contract deployer the default admin role: it will be able
+        // to grant and revoke any roles
+        _setupRole(DEFAULT_ADMIN_ROLE, msg.sender);
+    }
+
+    /**
+     * @notice Gives a function call permission to one single account
+     * @dev this function can be called only from Role Admin or DEFAULT_ADMIN_ROLE
+     * @param contractAddress address of contract for which call permissions will be granted
+     * @dev if contractAddress is zero address, the account can access the specified function
+     *      on **any** contract managed by this ACL
+     * @param functionSig signature e.g. "functionName(uint256,bool)"
+     * @param accountToPermit account that will be given access to the contract function
+     * @custom:event Emits a {RoleGranted} and {PermissionGranted} events.
+     */
+    function giveCallPermission(
+        address contractAddress,
+        string memory functionSig,
+        address accountToPermit
+    ) public {
+        bytes32 role = keccak256(abi.encodePacked(contractAddress, functionSig));
+        grantRole(role, accountToPermit);
+        emit PermissionGranted(accountToPermit, contractAddress, functionSig);
+    }
+
+    /**
+     * @notice Revokes an account's permission to a particular function call
+     * @dev this function can be called only from Role Admin or DEFAULT_ADMIN_ROLE
+     * 		May emit a {RoleRevoked} event.
+     * @param contractAddress address of contract for which call permissions will be revoked
+     * @param functionSig signature e.g. "functionName(uint256,bool)"
+     * @custom:event Emits {RoleRevoked} and {PermissionRevoked} events.
+     */
+    function revokeCallPermission(
+        address contractAddress,
+        string memory functionSig,
+        address accountToRevoke
+    ) public {
+        bytes32 role = keccak256(abi.encodePacked(contractAddress, functionSig));
+        revokeRole(role, accountToRevoke);
+        emit PermissionRevoked(accountToRevoke, contractAddress, functionSig);
+    }
+
+    /**
+     * @notice Verifies if the given account can call a contract's guarded function
+     * @dev Since restricted contracts using this function as a permission hook, we can get contracts address with msg.sender
+     * @param account for which call permissions will be checked
+     * @param functionSig restricted function signature e.g. "functionName(uint256,bool)"
+     * @return false if the user account cannot call the particular contract function
+     *
+     */
+    function isAllowedToCall(address account, string memory functionSig) public view returns (bool) {
+        bytes32 role = keccak256(abi.encodePacked(msg.sender, functionSig));
+
+        if (hasRole(role, account)) {
+            return true;
+        } else {
+            role = keccak256(abi.encodePacked(address(0), functionSig));
+            return hasRole(role, account);
+        }
+    }
+
+    /**
+     * @notice Verifies if the given account can call a contract's guarded function
+     * @dev This function is used as a view function to check permissions rather than contract hook for access restriction check.
+     * @param account for which call permissions will be checked against
+     * @param contractAddress address of the restricted contract
+     * @param functionSig signature of the restricted function e.g. "functionName(uint256,bool)"
+     * @return false if the user account cannot call the particular contract function
+     */
+    function hasPermission(
+        address account,
+        address contractAddress,
+        string memory functionSig
+    ) public view returns (bool) {
+        bytes32 role = keccak256(abi.encodePacked(contractAddress, functionSig));
+        return hasRole(role, account);
+    }
+}

package/contracts/Test/Mocks/MockArraySorter.sol

@@ -0,0 +1,14 @@
+// SPDX-License-Identifier: BSD-3-Clause
+pragma solidity ^0.8.10;
+import { sort } from "../../Utils/ArrayHelpers.sol";
+
+contract MockArraySorter {
+    function sortArray(uint256[] memory balances, address[] memory addrs)
+        external
+        view
+        returns (address[] memory, uint256[] memory)
+    {
+        sort(balances, addrs);
+        return (addrs, balances);
+    }
+}

package/contracts/Test/Mocks/MockConverter.sol

@@ -0,0 +1,70 @@
+// SPDX-License-Identifier: BSD-3-Clause
+pragma solidity ^0.8.10;
+
+import { SafeERC20Upgradeable } from "@openzeppelin/contracts-upgradeable/token/ERC20/utils/SafeERC20Upgradeable.sol";
+import { IERC20Upgradeable } from "@openzeppelin/contracts-upgradeable/token/ERC20/IERC20Upgradeable.sol";
+import { ResilientOracle } from "@venusprotocol/oracle/contracts/ResilientOracle.sol";
+
+import { AbstractTokenConverter } from "../../TokenConverter/AbstractTokenConverter.sol";
+import { IRiskFundGetters } from "../../Interfaces/IRiskFund.sol";
+
+contract MockConverter is AbstractTokenConverter {
+    using SafeERC20Upgradeable for IERC20Upgradeable;
+
+    /// @notice Store the previous state for the asset transferred to ProtocolShareReserve combined(for all pools)
+    mapping(address => uint256) public assetsReserves;
+
+    /// @notice Store the asset's reserve per pool in the ProtocolShareReserve
+    /// @dev Comptroller(pool) -> Asset -> amount
+    mapping(address => mapping(address => uint256)) public poolsAssetsReserves;
+
+    /// @notice Emitted after updating of the assets reserves
+    /// amount -> reserve increased by amount
+    event AssetsReservesUpdated(address indexed comptroller, address indexed asset, uint256 amount);
+
+    function mockPrivateConversion(
+        address comptroller,
+        address tokenAddressOut,
+        uint256 balanceDiff
+    ) external {
+        _privateConversion(comptroller, tokenAddressOut, balanceDiff);
+    }
+
+    function AbstractTokenConverter_init(
+        address accessControlManager_,
+        ResilientOracle priceOracle_,
+        address destinationAddress_,
+        uint256 minAmountToConvert_
+    ) public initializer {
+        __AbstractTokenConverter_init(accessControlManager_, priceOracle_, destinationAddress_, minAmountToConvert_);
+    }
+
+    function balanceOf(address tokenAddress) public view override returns (uint256 tokenBalance) {
+        IERC20Upgradeable token = IERC20Upgradeable(tokenAddress);
+        tokenBalance = token.balanceOf(address(this));
+    }
+
+    function _postPrivateConversionHook(
+        address comptroller,
+        address tokenAddressIn,
+        uint256 convertedTokenInBalance,
+        address tokenAddressOut,
+        uint256 convertedTokenOutBalance
+    ) internal override {
+        if (convertedTokenInBalance > 0) {
+            assetsReserves[tokenAddressIn] += convertedTokenInBalance;
+            poolsAssetsReserves[comptroller][tokenAddressIn] += convertedTokenInBalance;
+            emit AssetsReservesUpdated(comptroller, tokenAddressIn, convertedTokenInBalance);
+        }
+        if (convertedTokenOutBalance > 0) {
+            assetsReserves[tokenAddressOut] += convertedTokenOutBalance;
+            poolsAssetsReserves[comptroller][tokenAddressOut] += convertedTokenOutBalance;
+            emit AssetsReservesUpdated(comptroller, tokenAddressOut, convertedTokenOutBalance);
+        }
+    }
+
+    /// @notice Get base asset address
+    function _getDestinationBaseAsset() internal view override returns (address) {
+        return IRiskFundGetters(destinationAddress).convertibleBaseAsset();
+    }
+}

package/contracts/Test/Mocks/MockDeflationaryToken.sol

@@ -0,0 +1,113 @@
+pragma solidity 0.8.13;
+
+contract MockDeflatingToken {
+    string public constant NAME = "Deflating Test Token";
+    string public constant SYMBOL = "DTT";
+    uint8 public constant DECIMALS = 18;
+    uint256 public totalSupply;
+    mapping(address => uint256) public balanceOf;
+    mapping(address => mapping(address => uint256)) public allowance;
+
+    bytes32 public immutable DOMAIN_SEPARATOR;
+    // keccak256("Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)");
+    bytes32 public constant PERMIT_TYPEHASH = 0x6e71edae12b1b97f4d1f60370fef10105fa2faae0126114a169c64845d6126c9;
+    mapping(address => uint256) public nonces;
+
+    event Approval(address indexed owner, address indexed spender, uint256 value);
+    event Transfer(address indexed from, address indexed to, uint256 value);
+
+    constructor(uint256 _totalSupply) {
+        uint256 chainId;
+        assembly {
+            chainId := chainid()
+        }
+        DOMAIN_SEPARATOR = keccak256(
+            abi.encode(
+                keccak256("EIP712Domain(string NAME,string version,uint256 chainId,address verifyingContract)"),
+                keccak256(bytes(NAME)),
+                keccak256(bytes("1")),
+                chainId,
+                address(this)
+            )
+        );
+        _mint(msg.sender, _totalSupply);
+    }
+
+    function approve(address spender, uint256 value) external returns (bool) {
+        _approve(msg.sender, spender, value);
+        return true;
+    }
+
+    function transfer(address to, uint256 value) external returns (bool) {
+        _transfer(msg.sender, to, value);
+        return true;
+    }
+
+    function transferFrom(
+        address from,
+        address to,
+        uint256 value
+    ) external returns (bool) {
+        if (allowance[from][msg.sender] != type(uint256).max) {
+            allowance[from][msg.sender] = allowance[from][msg.sender] - value;
+        }
+        _transfer(from, to, value);
+        return true;
+    }
+
+    function permit(
+        address owner,
+        address spender,
+        uint256 value,
+        uint256 deadline,
+        uint8 v,
+        bytes32 r,
+        bytes32 s
+    ) external {
+        require(deadline >= block.timestamp, "EXPIRED");
+        bytes32 digest = keccak256(
+            abi.encodePacked(
+                "\x19\x01",
+                DOMAIN_SEPARATOR,
+                keccak256(abi.encode(PERMIT_TYPEHASH, owner, spender, value, nonces[owner]++, deadline))
+            )
+        );
+        address recoveredAddress = ecrecover(digest, v, r, s);
+        require(recoveredAddress != address(0) && recoveredAddress == owner, "INVALID_SIGNATURE");
+        _approve(owner, spender, value);
+    }
+
+    function _mint(address to, uint256 value) internal {
+        totalSupply = totalSupply + value;
+        balanceOf[to] = balanceOf[to] + value;
+        emit Transfer(address(0), to, value);
+    }
+
+    function _burn(address from, uint256 value) internal {
+        balanceOf[from] = balanceOf[from] - value;
+        totalSupply = totalSupply - value;
+        emit Transfer(from, address(0), value);
+    }
+
+    function _approve(
+        address owner,
+        address spender,
+        uint256 value
+    ) private {
+        allowance[owner][spender] = value;
+        emit Approval(owner, spender, value);
+    }
+
+    function _transfer(
+        address from,
+        address to,
+        uint256 value
+    ) private {
+        uint256 burnAmount = value / 100;
+        _burn(from, burnAmount);
+        uint256 transferAmount = value - burnAmount;
+        balanceOf[from] = balanceOf[from] - transferAmount;
+        balanceOf[to] = balanceOf[to] + transferAmount;
+        emit Transfer(from, to, transferAmount);
+    }
+}

package/contracts/Test/Mocks/MockRiskFundConverter.sol

@@ -0,0 +1,45 @@
+// SPDX-License-Identifier: BSD-3-Clause
+pragma solidity 0.8.13;
+
+import { RiskFundConverter } from "../../TokenConverter/RiskFundConverter.sol";
+
+contract MockRiskFundConverter is RiskFundConverter {
+    constructor(
+        address corePoolComptroller_,
+        address vBNB_,
+        address nativeWrapped_
+    ) RiskFundConverter(corePoolComptroller_, vBNB_, nativeWrapped_) {}
+
+    function postConversionHookMock(
+        address tokenInAddress,
+        address tokenOutAddress,
+        uint256 amountIn,
+        uint256 amountOut
+    ) external {
+        super._postConversionHook(tokenInAddress, tokenOutAddress, amountIn, amountOut);
+    }
+
+    function preTransferHookMock(address tokenOutAddress, uint256 amountOut) external {
+        super._preTransferHook(tokenOutAddress, amountOut);
+    }
+
+    function setAssetsReserves(address asset, uint256 amount) external {
+        assetsReserves[asset] = amount;
+    }
+
+    function setPoolsAssetsReserves(
+        address comptroller,
+        address asset,
+        uint256 amount
+    ) external {
+        poolsAssetsReserves[comptroller][asset] = amount;
+    }
+
+    function getPoolsAssetsReserves(address comptroller, address asset) external view returns (uint256) {
+        return poolsAssetsReserves[comptroller][asset];
+    }
+
+    function getAssetsReserves(address asset) external view returns (uint256) {
+        return assetsReserves[asset];
+    }
+}

package/contracts/Test/Mocks/MockToken.sol

@@ -20,6 +20,10 @@ contract MockToken is ERC20 {
         _mint(msg.sender, amount);
     }
 
+    function allocateTo(address owner, uint256 amount) external {
+        _mint(owner, amount);
+    }
+
     function decimals() public view virtual override returns (uint8) {
         return _decimals;
     }

package/contracts/Test/imports.sol

@@ -0,0 +1,11 @@
+// SPDX-License-Identifier: BSD-3-Clause
+pragma solidity 0.8.13;
+
+// This file is needed to make hardhat and typechain generate artifacts for
+// contracts we depend on (e.g. in tests or deployments) but not use directly.
+// Another way to do this would be to use hardhat-dependency-compiler, but
+// since we only have a couple of dependencies, installing a separate package
+// seems an overhead.
+
+import { UpgradeableBeacon } from "@openzeppelin/contracts/proxy/beacon/UpgradeableBeacon.sol";
+import { BeaconProxy } from "@openzeppelin/contracts/proxy/beacon/BeaconProxy.sol";