@venusprotocol/protocol-reserve 1.0.0-converters.1

package/contracts/ProtocolReserve/RiskFundV2.sol

@@ -0,0 +1,220 @@
+// SPDX-License-Identifier: BSD-3-Clause
+pragma solidity 0.8.13;
+
+import { IERC20Upgradeable } from "@openzeppelin/contracts-upgradeable/token/ERC20/IERC20Upgradeable.sol";
+import { AccessControlledV8 } from "@venusprotocol/governance-contracts/contracts/Governance/AccessControlledV8.sol";
+import { SafeERC20Upgradeable } from "@openzeppelin/contracts-upgradeable/token/ERC20/utils/SafeERC20Upgradeable.sol";
+
+import { IRiskFund } from "../Interfaces/IRiskFund.sol";
+import { IRiskFundConverter } from "../Interfaces/IRiskFundConverter.sol";
+
+import { ensureNonzeroAddress, ensureNonzeroValue } from "../Utils/Validators.sol";
+import { EXP_SCALE } from "../Utils/Constants.sol";
+
+import { RiskFundV2Storage } from "./RiskFundStorage.sol";
+
+/// @title RiskFundV2
+/// @author Venus
+/// @notice Contract with basic features to hold base asset for different Comptrollers
+/// @dev This contract does not support BNB
+/// @custom:security-contact https://github.com/VenusProtocol/protocol-reserve#discussion
+contract RiskFundV2 is AccessControlledV8, RiskFundV2Storage, IRiskFund {
+    using SafeERC20Upgradeable for IERC20Upgradeable;
+
+    /// @notice Emitted when convertible base asset address is updated
+    event ConvertibleBaseAssetUpdated(address indexed oldConvertibleBaseAsset, address indexed newConvertibleBaseAsset);
+
+    /// @notice Emitted when risk fund converter address is updated
+    event RiskFundConverterUpdated(address indexed oldRiskFundConverter, address indexed newRiskFundConverter);
+
+    /// @notice Emitted when shortfall contract address is updated
+    event ShortfallContractUpdated(address indexed oldShortfallContract, address indexed newShortfallContract);
+
+    /// @notice Emitted when reserves are transferred for auction
+    event TransferredReserveForAuction(address indexed comptroller, uint256 amount);
+
+    /// @notice Emitted when pool asset states is updated with amount transferred to this contract
+    event PoolAssetsIncreased(address indexed comptroller, address indexed asset, uint256 amount);
+
+    /// @notice Emitted when pool asset states is updated with amount transferred from this contract on sweeping tokens
+    event PoolAssetsDecreased(address indexed comptroller, address indexed asset, uint256 amount);
+
+    /// @notice Event emitted when tokens are swept
+    event SweepToken(address indexed token, address indexed to, uint256 amount);
+
+    /// @notice Error is thrown when updatePoolState is not called by riskFundConverter
+    error InvalidRiskFundConverter();
+
+    /// @notice Error is thrown when transferReserveForAuction is called by non shortfall address
+    error InvalidShortfallAddress();
+
+    /// @notice thrown when amount entered is greater than balance
+    error InsufficientBalance();
+
+    /// @notice Error is thrown when pool reserve is less than the amount needed
+    error InsufficientPoolReserve(address comptroller, uint256 amount, uint256 poolReserve);
+
+    /// @dev Convertible base asset setter
+    /// @param convertibleBaseAsset_ Address of the convertible base asset
+    /// @custom:event ConvertibleBaseAssetUpdated emit on success
+    /// @custom:error ZeroAddressNotAllowed is thrown when convertible base asset address is zero
+    /// @custom:access Only Governance
+    function setConvertibleBaseAsset(address convertibleBaseAsset_) external onlyOwner {
+        ensureNonzeroAddress(convertibleBaseAsset_);
+        emit ConvertibleBaseAssetUpdated(convertibleBaseAsset, convertibleBaseAsset_);
+        convertibleBaseAsset = convertibleBaseAsset_;
+    }
+
+    /// @dev Risk fund converter setter
+    /// @param riskFundConverter_ Address of the risk fund converter
+    /// @custom:event RiskFundConverterUpdated emit on success
+    /// @custom:error ZeroAddressNotAllowed is thrown when risk fund converter address is zero
+    /// @custom:access Only Governance
+    function setRiskFundConverter(address riskFundConverter_) external onlyOwner {
+        ensureNonzeroAddress(riskFundConverter_);
+        emit RiskFundConverterUpdated(riskFundConverter, riskFundConverter_);
+        riskFundConverter = riskFundConverter_;
+    }
+
+    /// @dev Shortfall contract address setter
+    /// @param shortfallContractAddress_ Address of the auction contract
+    /// @custom:event ShortfallContractUpdated emit on success
+    /// @custom:error ZeroAddressNotAllowed is thrown when shortfall contract address is zero
+    /// @custom:access Only Governance
+    function setShortfallContractAddress(address shortfallContractAddress_) external onlyOwner {
+        ensureNonzeroAddress(shortfallContractAddress_);
+        emit ShortfallContractUpdated(shortfall, shortfallContractAddress_);
+        shortfall = shortfallContractAddress_;
+    }
+
+    /// @dev Transfer tokens for auction to shortfall contract
+    /// @param comptroller Comptroller of the pool
+    /// @param amount Amount to be transferred to the shortfall
+    /// @return Amount of tokens transferred to the shortfall
+    /// @custom:event TransferredReserveForAuction emit on success
+    /// @custom:error InvalidShortfallAddress is thrown when caller is not shortfall contract
+    /// @custom:error InsufficientPoolReserve is thrown when pool reserve is less than the amount needed
+    /// @custom:access Only Shortfall contract
+    function transferReserveForAuction(address comptroller, uint256 amount)
+        external
+        override
+        nonReentrant
+        returns (uint256)
+    {
+        uint256 poolReserve = poolAssetsFunds[comptroller][convertibleBaseAsset];
+
+        if (msg.sender != shortfall) {
+            revert InvalidShortfallAddress();
+        }
+        if (amount > poolReserve) {
+            revert InsufficientPoolReserve(comptroller, amount, poolReserve);
+        }
+
+        unchecked {
+            poolAssetsFunds[comptroller][convertibleBaseAsset] = poolReserve - amount;
+        }
+
+        IERC20Upgradeable(convertibleBaseAsset).safeTransfer(shortfall, amount);
+        emit TransferredReserveForAuction(comptroller, amount);
+
+        return amount;
+    }
+
+    /// @notice Function to sweep baseAsset for pool, Tokens are sent to address(to)
+    /// @param tokenAddress Address of the asset(token)
+    /// @param to Address to which assets will be transferred
+    /// @param amount Amount need to sweep for the pool
+    /// @custom:event Emits SweepToken event on success
+    /// @custom:error ZeroAddressNotAllowed is thrown when tokenAddress/to address is zero
+    /// @custom:access Only Governance
+    function sweepToken(
+        address tokenAddress,
+        address to,
+        uint256 amount
+    ) external onlyOwner nonReentrant {
+        ensureNonzeroAddress(tokenAddress);
+        ensureNonzeroAddress(to);
+        ensureNonzeroValue(amount);
+
+        IERC20Upgradeable token = IERC20Upgradeable(tokenAddress);
+        preSweepToken(tokenAddress, amount);
+        token.safeTransfer(to, amount);
+
+        emit SweepToken(tokenAddress, to, amount);
+    }
+
+    /**
+     * @notice Get the Amount of the Base asset in the risk fund for the specific pool.
+     * @param comptroller  Comptroller address(pool).
+     * @return Base Asset's reserve in risk fund.
+     */
+    function getPoolsBaseAssetReserves(address comptroller) external view returns (uint256) {
+        return poolAssetsFunds[comptroller][convertibleBaseAsset];
+    }
+
+    /// @dev Update the reserve of the asset for the specific pool after transferring to risk fund
+    /// @param comptroller Comptroller address (pool)
+    /// @param asset Address of the asset(token)
+    /// @param amount Amount transferred for the pool
+    /// @custom:event PoolAssetsIncreased emits on success
+    /// @custom:error InvalidRiskFundConverter is thrown if caller is not riskFundConverter contract
+    /// @custom:access Only RiskFundConverter contract
+    function updatePoolState(
+        address comptroller,
+        address asset,
+        uint256 amount
+    ) public {
+        if (msg.sender != riskFundConverter) {
+            revert InvalidRiskFundConverter();
+        }
+
+        poolAssetsFunds[comptroller][asset] += amount;
+        emit PoolAssetsIncreased(comptroller, asset, amount);
+    }
+
+    /// @notice Operations to perform before sweeping tokens
+    /// @param tokenAddress Address of the token
+    /// @param amount Amount transferred to address(to)
+    /// @custom:error InsufficientBalance is thrown when amount entered is greater than balance
+    function preSweepToken(address tokenAddress, uint256 amount) internal {
+        uint256 balance = IERC20Upgradeable(tokenAddress).balanceOf(address(this));
+        if (amount > balance) revert InsufficientBalance();
+
+        address[] memory pools = IRiskFundConverter(riskFundConverter).getPools(tokenAddress);
+
+        uint256 assetReserves;
+        uint256 poolsLength = pools.length;
+        for (uint256 i; i < poolsLength; ) {
+            assetReserves += poolAssetsFunds[pools[i]][tokenAddress];
+            unchecked {
+                ++i;
+            }
+        }
+
+        uint256 balanceDiff = balance - assetReserves;
+
+        if (balanceDiff < amount) {
+            uint256 amountDiff;
+            unchecked {
+                amountDiff = amount - balanceDiff;
+            }
+            uint256 distributedShare;
+            for (uint256 i; i < poolsLength; ) {
+                if (poolAssetsFunds[pools[i]][tokenAddress] != 0) {
+                    uint256 poolAmountShare;
+                    if (i < (poolsLength - 1)) {
+                        poolAmountShare = (poolAssetsFunds[pools[i]][tokenAddress] * amount) / assetReserves;
+                        distributedShare += poolAmountShare;
+                    } else {
+                        poolAmountShare = amountDiff - distributedShare;
+                    }
+                    poolAssetsFunds[pools[i]][tokenAddress] -= poolAmountShare;
+                    emit PoolAssetsDecreased(pools[i], tokenAddress, poolAmountShare);
+                }
+                unchecked {
+                    ++i;
+                }
+            }
+        }
+    }
+}

package/contracts/ProtocolReserve/XVSVaultTreasury.sol

@@ -0,0 +1,95 @@
+// SPDX-License-Identifier: BSD-3-Clause
+pragma solidity 0.8.13;
+
+import { SafeERC20Upgradeable } from "@openzeppelin/contracts-upgradeable/token/ERC20/utils/SafeERC20Upgradeable.sol";
+import { IERC20Upgradeable } from "@openzeppelin/contracts-upgradeable/token/ERC20/IERC20Upgradeable.sol";
+import { AccessControlledV8 } from "@venusprotocol/governance-contracts/contracts/Governance/AccessControlledV8.sol";
+import { ReentrancyGuardUpgradeable } from "@openzeppelin/contracts-upgradeable/security/ReentrancyGuardUpgradeable.sol";
+
+import { ensureNonzeroAddress, ensureNonzeroValue } from "../Utils/Validators.sol";
+import { IXVSVault } from "../Interfaces/IXVSVault.sol";
+
+/// @title XVSVaultTreasury
+/// @author Venus
+/// @notice XVSVaultTreasury stores the tokens sent by SingleTokenConverter(XVS) and funds XVSVault
+/// @custom:security-contact https://github.com/VenusProtocol/protocol-reserve#discussion
+contract XVSVaultTreasury is AccessControlledV8, ReentrancyGuardUpgradeable {
+    using SafeERC20Upgradeable for IERC20Upgradeable;
+
+    /// @notice The xvs token address
+    /// @custom:oz-upgrades-unsafe-allow state-variable-immutable
+    address public immutable XVS_ADDRESS;
+
+    /// @notice The xvsvault address
+    address public xvsVault;
+
+    /// @notice Emitted when XVS vault address is updated
+    event XVSVaultUpdated(address indexed oldXVSVault, address indexed newXVSVault);
+
+    /// @notice Emitted when funds transferred to XVSStore address
+    event FundsTransferredToXVSStore(address indexed xvsStore, uint256 amountMantissa);
+
+    /// @notice Thrown when given input amount is zero
+    error InsufficientBalance();
+
+    /// @custom:oz-upgrades-unsafe-allow constructor
+    /// @param xvsAddress_ XVS token address
+    constructor(address xvsAddress_) {
+        ensureNonzeroAddress(xvsAddress_);
+        XVS_ADDRESS = xvsAddress_;
+
+        // Note that the contract is upgradeable. Use initialize() or reinitializers
+        // to set the state variables.
+        _disableInitializers();
+    }
+
+    /// @param accessControlManager_ Access control manager contract address
+    /// @param xvsVault_ XVSVault address
+    /// @custom:event XVSVaultUpdated emits on success
+    /// @custom:error ZeroAddressNotAllowed is thrown when XVS vault address is zero
+    function initialize(address accessControlManager_, address xvsVault_) public initializer {
+        __AccessControlled_init(accessControlManager_);
+        __ReentrancyGuard_init();
+        _setXVSVault(xvsVault_);
+    }
+
+    /// @dev XVS vault setter
+    /// @param xvsVault_ Address of the XVS vault
+    /// @custom:event XVSVaultUpdated emits on success
+    /// @custom:error ZeroAddressNotAllowed is thrown when XVS vault address is zero
+    function setXVSVault(address xvsVault_) external onlyOwner {
+        _setXVSVault(xvsVault_);
+    }
+
+    /// @notice This function transfers funds to the XVS vault
+    /// @param amountMantissa Amount to be sent to XVS vault
+    /// @custom:event FundsTransferredToXVSStore emits on success
+    /// @custom:error InsufficientBalance is thrown when amount entered is greater than balance
+    /// @custom:access Restricted by ACM
+    function fundXVSVault(uint256 amountMantissa) external nonReentrant {
+        _checkAccessAllowed("fundXVSVault(uint256)");
+        ensureNonzeroValue(amountMantissa);
+
+        uint256 balance = IERC20Upgradeable(XVS_ADDRESS).balanceOf(address(this));
+
+        if (balance < amountMantissa) {
+            revert InsufficientBalance();
+        }
+
+        address xvsStore = IXVSVault(xvsVault).xvsStore();
+        ensureNonzeroAddress(xvsStore);
+        IERC20Upgradeable(XVS_ADDRESS).safeTransfer(xvsStore, amountMantissa);
+
+        emit FundsTransferredToXVSStore(xvsStore, amountMantissa);
+    }
+
+    /// @dev XVS vault setter
+    /// @param xvsVault_ Address of the XVS vault
+    /// @custom:event XVSVaultUpdated emits on success
+    /// @custom:error ZeroAddressNotAllowed is thrown when XVS vault address is zero
+    function _setXVSVault(address xvsVault_) internal {
+        ensureNonzeroAddress(xvsVault_);
+        emit XVSVaultUpdated(xvsVault, xvsVault_);
+        xvsVault = xvsVault_;
+    }
+}

package/contracts/Test/Mocks/MockACM.sol

@@ -0,0 +1,93 @@
+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,69 @@
+// 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_
+    ) public initializer {
+        __AbstractTokenConverter_init(accessControlManager_, priceOracle_, destinationAddress_);
+    }
+
+    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

@@ -0,0 +1,30 @@
+// SPDX-License-Identifier: MIT
+// OpenZeppelin Contracts (last updated v4.6.0) (token/ERC20/ERC20.sol)
+
+pragma solidity ^0.8.0;
+
+import { ERC20 } from "@openzeppelin/contracts/token/ERC20/ERC20.sol";
+
+contract MockToken is ERC20 {
+    uint8 private immutable _decimals;
+
+    constructor(
+        string memory name_,
+        string memory symbol_,
+        uint8 decimals_
+    ) ERC20(name_, symbol_) {
+        _decimals = decimals_;
+    }
+
+    function faucet(uint256 amount) external {
+        _mint(msg.sender, amount);
+    }
+
+    function allocateTo(address owner, uint256 amount) external {
+        _mint(owner, amount);
+    }
+
+    function decimals() public view virtual override returns (uint8) {
+        return _decimals;
+    }
+}