@venusprotocol/venus-protocol 10.2.0-dev.1 → 10.2.0-dev.2

package/deployments/bsctestnet/solcInputs/4830490d5bbb3729e823e66b6f3540b0.json

@@ -0,0 +1,222 @@
+{
+  "language": "Solidity",
+  "sources": {
+    "@venusprotocol/governance-contracts/contracts/Governance/AccessControlledV5.sol": {
+      "content": "// SPDX-License-Identifier: BSD-3-Clause\npragma solidity 0.5.16;\n\nimport \"./IAccessControlManagerV5.sol\";\n\n/**\n * @title AccessControlledV5\n * @author Venus\n * @notice This contract is helper between access control manager and actual contract. This contract further inherited by other contract (using solidity 0.5.16)\n * to integrate access controlled mechanism. It provides initialise methods and verifying access methods.\n */\ncontract AccessControlledV5 {\n    /// @notice Access control manager contract\n    IAccessControlManagerV5 private _accessControlManager;\n\n    /**\n     * @dev This empty reserved space is put in place to allow future versions to add new\n     * variables without shifting down storage in the inheritance chain.\n     * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps\n     */\n    uint256[49] private __gap;\n\n    /// @notice Emitted when access control manager contract address is changed\n    event NewAccessControlManager(address oldAccessControlManager, address newAccessControlManager);\n\n    /**\n     * @notice Returns the address of the access control manager contract\n     */\n    function accessControlManager() external view returns (IAccessControlManagerV5) {\n        return _accessControlManager;\n    }\n\n    /**\n     * @dev Internal function to set address of AccessControlManager\n     * @param accessControlManager_ The new address of the AccessControlManager\n     */\n    function _setAccessControlManager(address accessControlManager_) internal {\n        require(address(accessControlManager_) != address(0), \"invalid acess control manager address\");\n        address oldAccessControlManager = address(_accessControlManager);\n        _accessControlManager = IAccessControlManagerV5(accessControlManager_);\n        emit NewAccessControlManager(oldAccessControlManager, accessControlManager_);\n    }\n\n    /**\n     * @notice Reverts if the call is not allowed by AccessControlManager\n     * @param signature Method signature\n     */\n    function _checkAccessAllowed(string memory signature) internal view {\n        bool isAllowedToCall = _accessControlManager.isAllowedToCall(msg.sender, signature);\n\n        if (!isAllowedToCall) {\n            revert(\"Unauthorized\");\n        }\n    }\n}\n"
+    },
+    "@venusprotocol/governance-contracts/contracts/Governance/GovernorBravoDelegate.sol": {
+      "content": "pragma solidity ^0.5.16;\npragma experimental ABIEncoderV2;\n\nimport \"./GovernorBravoInterfaces.sol\";\n\n/**\n * @title GovernorBravoDelegate\n * @notice Venus Governance latest on chain governance includes several new features including variable proposal routes and fine grained pause control.\n * Variable routes for proposals allows for governance paramaters such as voting threshold and timelocks to be customized based on the risk level and\n * impact of the proposal. Added granularity to the pause control mechanism allows governance to pause individual actions on specific markets,\n * which reduces impact on the protocol as a whole. This is particularly useful when applied to isolated pools.\n *\n * The goal of **Governance** is to increase governance efficiency, while mitigating and eliminating malicious or erroneous proposals.\n *\n * ## Details\n *\n * Governance has **3 main contracts**: **GovernanceBravoDelegate, XVSVault, XVS** token.\n *\n * - XVS token is the protocol token used for protocol users to cast their vote on submitted proposals.\n * - XVSVault is the main staking contract for XVS. Users first stake their XVS in the vault and receive voting power proportional to their staked\n * tokens that they can use to vote on proposals. Users also can choose to delegate their voting power to other users.\n *\n * # Governor Bravo\n *\n * `GovernanceBravoDelegate` is main Venus Governance contract. Users interact with it to:\n * - Submit new proposal\n * - Vote on a proposal\n * - Cancel a proposal\n * - Queue a proposal for execution with a timelock executor contract.\n * `GovernanceBravoDelegate` uses the XVSVault to get restrict certain actions based on a user's voting power. The governance rules it inforces are:\n * - A user's voting power must be greater than the `proposalThreshold` to submit a proposal\n * - If a user's voting power drops below certain amount, anyone can cancel the the proposal. The governance guardian and proposal creator can also\n * cancel a proposal at anytime before it is queued for execution.\n *\n * ## Venus Improvement Proposal\n *\n * Venus Governance allows for Venus Improvement Proposals (VIPs) to be categorized based on their impact and risk levels. This allows for optimizing proposals\n * execution to allow for things such as expediting interest rate changes and quickly updating risk parameters, while moving slower on other types of proposals\n * that can prevent a larger risk to the protocol and are not urgent. There are three different types of VIPs with different proposal paramters:\n *\n * - `NORMAL`\n * - `FASTTRACK`\n * - `CRITICAL`\n *\n * When initializing the `GovernorBravo` contract, the parameters for the three routes are set. The parameters are:\n *\n * - `votingDelay`: The delay in blocks between submitting a proposal and when voting begins\n * - `votingPeriod`: The number of blocks where voting will be open\n * - `proposalThreshold`: The number of votes required in order submit a proposal\n *\n * There is also a separate timelock executor contract for each route, which is used to dispatch the VIP for execution, giving even more control over the\n * flow of each type of VIP.\n *\n * ## Voting\n *\n * After a VIP is proposed, voting is opened after the `votingDelay` has passed. For example, if `votingDelay = 0`, then voting will begin in the next block\n * after the proposal has been submitted. After the delay, the proposal state is `ACTIVE` and users can cast their vote `for`, `against`, or `abstain`,\n * weighted by their total voting power (tokens + delegated voting power). Abstaining from a voting allows for a vote to be cast and optionally include a\n * comment, without the incrementing for or against vote count. The total voting power for the user is obtained by calling XVSVault's `getPriorVotes`.\n *\n * `GovernorBravoDelegate` also accepts [EIP-712](https://eips.ethereum.org/EIPS/eip-712) signatures for voting on proposals via the external function\n * `castVoteBySig`.\n *\n * ## Delegating\n *\n * A users voting power includes the amount of staked XVS the have staked as well as the votes delegate to them. Delegating is the process of a user loaning\n * their voting power to another, so that the latter has the combined voting power of both users. This is an important feature because it allows for a user\n * to let another user who they trust propose or vote in their place.\n *\n * The delegation of votes happens through the `XVSVault` contract by calling the `delegate` or `delegateBySig` functions. These same functions can revert\n * vote delegation by calling the same function with a value of `0`.\n */\ncontract GovernorBravoDelegate is GovernorBravoDelegateStorageV3, GovernorBravoEvents {\n    /// @notice The name of this contract\n    string public constant name = \"Venus Governor Bravo\";\n\n    /// @notice The minimum setable proposal threshold\n    uint public constant MIN_PROPOSAL_THRESHOLD = 150000e18; // 150,000 Xvs\n\n    /// @notice The maximum setable proposal threshold\n    uint public constant MAX_PROPOSAL_THRESHOLD = 300000e18; //300,000 Xvs\n\n    /// @notice The number of votes in support of a proposal required in order for a quorum to be reached and for a vote to succeed\n    uint public constant quorumVotes = 600000e18; // 600,000 = 2% of Xvs\n\n    /// @notice The EIP-712 typehash for the contract's domain\n    bytes32 public constant DOMAIN_TYPEHASH =\n        keccak256(\"EIP712Domain(string name,uint256 chainId,address verifyingContract)\");\n\n    /// @notice The EIP-712 typehash for the ballot struct used by the contract\n    bytes32 public constant BALLOT_TYPEHASH = keccak256(\"Ballot(uint256 proposalId,uint8 support)\");\n\n    /**\n     * @notice Used to initialize the contract during delegator contructor\n     * @param xvsVault_ The address of the XvsVault\n     * @param proposalConfigs_ Governance configs for each governance route\n     * @param timelocks Timelock addresses for each governance route\n     */\n    function initialize(\n        address xvsVault_,\n        ValidationParams memory validationParams_,\n        ProposalConfig[] memory proposalConfigs_,\n        TimelockInterface[] memory timelocks,\n        address guardian_\n    ) public {\n        require(address(proposalTimelocks[0]) == address(0), \"GovernorBravo::initialize: cannot initialize twice\");\n        require(msg.sender == admin, \"GovernorBravo::initialize: admin only\");\n        require(xvsVault_ != address(0), \"GovernorBravo::initialize: invalid xvs vault address\");\n        require(guardian_ != address(0), \"GovernorBravo::initialize: invalid guardian\");\n        require(\n            timelocks.length == getGovernanceRouteCount(),\n            \"GovernorBravo::initialize:number of timelocks should match number of governance routes\"\n        );\n        require(\n            proposalConfigs_.length == getGovernanceRouteCount(),\n            \"GovernorBravo::initialize:number of proposal configs should match number of governance routes\"\n        );\n\n        xvsVault = XvsVaultInterface(xvsVault_);\n        proposalMaxOperations = 10;\n        guardian = guardian_;\n\n        // Set parameters for each Governance Route\n        setValidationParams(validationParams_);\n        setProposalConfigs(proposalConfigs_);\n\n        uint256 arrLength = timelocks.length;\n        for (uint256 i; i < arrLength; ++i) {\n            require(address(timelocks[i]) != address(0), \"GovernorBravo::initialize:invalid timelock address\");\n            proposalTimelocks[i] = timelocks[i];\n        }\n    }\n\n    /**\n     ** @notice Sets the validation parameters for voting delay and voting period\n     ** @param newValidationParams Struct containing new minimum and maximum voting period and delay\n     */\n    function setValidationParams(ValidationParams memory newValidationParams) public {\n        require(msg.sender == admin, \"GovernorBravo::setValidationParams: admin only\");\n        require(\n            newValidationParams.minVotingPeriod > 0 &&\n                newValidationParams.minVotingDelay > 0 &&\n                newValidationParams.minVotingDelay < newValidationParams.maxVotingDelay &&\n                newValidationParams.minVotingPeriod < newValidationParams.maxVotingPeriod,\n            \"GovernorBravo::setValidationParams: invalid params\"\n        );\n        emit SetValidationParams(\n            validationParams.minVotingPeriod,\n            newValidationParams.minVotingPeriod,\n            validationParams.maxVotingPeriod,\n            newValidationParams.maxVotingPeriod,\n            validationParams.minVotingDelay,\n            newValidationParams.minVotingDelay,\n            validationParams.maxVotingDelay,\n            newValidationParams.maxVotingDelay\n        );\n        validationParams = newValidationParams;\n    }\n\n    /**\n     ** @notice Sets the configuration for different proposal types\n     ** @dev Requires validationParams to be configured before also it will set proposal config for all proposal types\n     ** @param proposalConfigs_ Array of proposal configuration structs to update\n     */\n    function setProposalConfigs(ProposalConfig[] memory proposalConfigs_) public {\n        require(msg.sender == admin, \"GovernorBravo::setProposalConfigs: admin only\");\n        require(\n            validationParams.minVotingPeriod > 0 &&\n                validationParams.maxVotingPeriod > 0 &&\n                validationParams.minVotingDelay > 0 &&\n                validationParams.maxVotingDelay > 0,\n            \"GovernorBravo::setProposalConfigs: validation params not configured yet\"\n        );\n        uint256 arrLength = proposalConfigs_.length;\n        require(\n            arrLength == getGovernanceRouteCount(),\n            \"GovernorBravo::setProposalConfigs: invalid proposal config length\"\n        );\n        for (uint256 i; i < arrLength; ++i) {\n            require(\n                proposalConfigs_[i].votingPeriod >= validationParams.minVotingPeriod,\n                \"GovernorBravo::setProposalConfigs: invalid min voting period\"\n            );\n            require(\n                proposalConfigs_[i].votingPeriod <= validationParams.maxVotingPeriod,\n                \"GovernorBravo::setProposalConfigs: invalid max voting period\"\n            );\n            require(\n                proposalConfigs_[i].votingDelay >= validationParams.minVotingDelay,\n                \"GovernorBravo::setProposalConfigs: invalid min voting delay\"\n            );\n            require(\n                proposalConfigs_[i].votingDelay <= validationParams.maxVotingDelay,\n                \"GovernorBravo::setProposalConfigs: invalid max voting delay\"\n            );\n            require(\n                proposalConfigs_[i].proposalThreshold >= MIN_PROPOSAL_THRESHOLD,\n                \"GovernorBravo::setProposalConfigs: invalid min proposal threshold\"\n            );\n            require(\n                proposalConfigs_[i].proposalThreshold <= MAX_PROPOSAL_THRESHOLD,\n                \"GovernorBravo::setProposalConfigs: invalid max proposal threshold\"\n            );\n\n            proposalConfigs[i] = proposalConfigs_[i];\n            emit SetProposalConfigs(\n                proposalConfigs_[i].votingPeriod,\n                proposalConfigs_[i].votingDelay,\n                proposalConfigs_[i].proposalThreshold\n            );\n        }\n    }\n\n    /**\n     * @notice Function used to propose a new proposal. Sender must have delegates above the proposal threshold.\n     * targets, values, signatures, and calldatas must be of equal length\n     * @dev NOTE: Proposals with duplicate set of actions can not be queued for execution. If the proposals consists\n     *  of duplicate actions, it's recommended to split those actions into separate proposals\n     * @param targets Target addresses for proposal calls\n     * @param values BNB values for proposal calls\n     * @param signatures Function signatures for proposal calls\n     * @param calldatas Calldatas for proposal calls\n     * @param description String description of the proposal\n     * @param proposalType the type of the proposal (e.g NORMAL, FASTTRACK, CRITICAL)\n     * @return Proposal id of new proposal\n     */\n    function propose(\n        address[] memory targets,\n        uint[] memory values,\n        string[] memory signatures,\n        bytes[] memory calldatas,\n        string memory description,\n        ProposalType proposalType\n    ) public returns (uint) {\n        // Reject proposals before initiating as Governor\n        require(initialProposalId != 0, \"GovernorBravo::propose: Governor Bravo not active\");\n        require(\n            xvsVault.getPriorVotes(msg.sender, sub256(block.number, 1)) >=\n                proposalConfigs[uint8(proposalType)].proposalThreshold,\n            \"GovernorBravo::propose: proposer votes below proposal threshold\"\n        );\n        require(\n            targets.length == values.length &&\n                targets.length == signatures.length &&\n                targets.length == calldatas.length,\n            \"GovernorBravo::propose: proposal function information arity mismatch\"\n        );\n        require(targets.length != 0, \"GovernorBravo::propose: must provide actions\");\n        require(targets.length <= proposalMaxOperations, \"GovernorBravo::propose: too many actions\");\n\n        uint latestProposalId = latestProposalIds[msg.sender];\n        if (latestProposalId != 0) {\n            ProposalState proposersLatestProposalState = state(latestProposalId);\n            require(\n                proposersLatestProposalState != ProposalState.Active,\n                \"GovernorBravo::propose: one live proposal per proposer, found an already active proposal\"\n            );\n            require(\n                proposersLatestProposalState != ProposalState.Pending,\n                \"GovernorBravo::propose: one live proposal per proposer, found an already pending proposal\"\n            );\n        }\n\n        uint startBlock = add256(block.number, proposalConfigs[uint8(proposalType)].votingDelay);\n        uint endBlock = add256(startBlock, proposalConfigs[uint8(proposalType)].votingPeriod);\n\n        proposalCount++;\n        Proposal memory newProposal = Proposal({\n            id: proposalCount,\n            proposer: msg.sender,\n            eta: 0,\n            targets: targets,\n            values: values,\n            signatures: signatures,\n            calldatas: calldatas,\n            startBlock: startBlock,\n            endBlock: endBlock,\n            forVotes: 0,\n            againstVotes: 0,\n            abstainVotes: 0,\n            canceled: false,\n            executed: false,\n            proposalType: uint8(proposalType)\n        });\n\n        proposals[newProposal.id] = newProposal;\n        latestProposalIds[newProposal.proposer] = newProposal.id;\n\n        emit ProposalCreated(\n            newProposal.id,\n            msg.sender,\n            targets,\n            values,\n            signatures,\n            calldatas,\n            startBlock,\n            endBlock,\n            description,\n            uint8(proposalType)\n        );\n        return newProposal.id;\n    }\n\n    /**\n     * @notice Queues a proposal of state succeeded\n     * @param proposalId The id of the proposal to queue\n     */\n    function queue(uint proposalId) external {\n        require(\n            state(proposalId) == ProposalState.Succeeded,\n            \"GovernorBravo::queue: proposal can only be queued if it is succeeded\"\n        );\n        Proposal storage proposal = proposals[proposalId];\n        uint eta = add256(block.timestamp, proposalTimelocks[uint8(proposal.proposalType)].delay());\n        for (uint i; i < proposal.targets.length; ++i) {\n            queueOrRevertInternal(\n                proposal.targets[i],\n                proposal.values[i],\n                proposal.signatures[i],\n                proposal.calldatas[i],\n                eta,\n                uint8(proposal.proposalType)\n            );\n        }\n        proposal.eta = eta;\n        emit ProposalQueued(proposalId, eta);\n    }\n\n    function queueOrRevertInternal(\n        address target,\n        uint value,\n        string memory signature,\n        bytes memory data,\n        uint eta,\n        uint8 proposalType\n    ) internal {\n        require(\n            !proposalTimelocks[proposalType].queuedTransactions(\n                keccak256(abi.encode(target, value, signature, data, eta))\n            ),\n            \"GovernorBravo::queueOrRevertInternal: identical proposal action already queued at eta\"\n        );\n        proposalTimelocks[proposalType].queueTransaction(target, value, signature, data, eta);\n    }\n\n    /**\n     * @notice Executes a queued proposal if eta has passed\n     * @param proposalId The id of the proposal to execute\n     */\n    function execute(uint proposalId) external {\n        require(\n            state(proposalId) == ProposalState.Queued,\n            \"GovernorBravo::execute: proposal can only be executed if it is queued\"\n        );\n        Proposal storage proposal = proposals[proposalId];\n        proposal.executed = true;\n        for (uint i; i < proposal.targets.length; ++i) {\n            proposalTimelocks[uint8(proposal.proposalType)].executeTransaction(\n                proposal.targets[i],\n                proposal.values[i],\n                proposal.signatures[i],\n                proposal.calldatas[i],\n                proposal.eta\n            );\n        }\n        emit ProposalExecuted(proposalId);\n    }\n\n    /**\n     * @notice Cancels a proposal only if sender is the proposer, or proposer delegates dropped below proposal threshold\n     * @param proposalId The id of the proposal to cancel\n     */\n    function cancel(uint proposalId) external {\n        require(state(proposalId) != ProposalState.Executed, \"GovernorBravo::cancel: cannot cancel executed proposal\");\n\n        Proposal storage proposal = proposals[proposalId];\n        require(\n            msg.sender == guardian ||\n                msg.sender == proposal.proposer ||\n                xvsVault.getPriorVotes(proposal.proposer, sub256(block.number, 1)) <\n                proposalConfigs[proposal.proposalType].proposalThreshold,\n            \"GovernorBravo::cancel: proposer above threshold\"\n        );\n\n        proposal.canceled = true;\n        for (uint i = 0; i < proposal.targets.length; i++) {\n            proposalTimelocks[proposal.proposalType].cancelTransaction(\n                proposal.targets[i],\n                proposal.values[i],\n                proposal.signatures[i],\n                proposal.calldatas[i],\n                proposal.eta\n            );\n        }\n\n        emit ProposalCanceled(proposalId);\n    }\n\n    /**\n     * @notice Gets actions of a proposal\n     * @param proposalId the id of the proposal\n     * @return targets, values, signatures, and calldatas of the proposal actions\n     */\n    function getActions(\n        uint proposalId\n    )\n        external\n        view\n        returns (address[] memory targets, uint[] memory values, string[] memory signatures, bytes[] memory calldatas)\n    {\n        Proposal storage p = proposals[proposalId];\n        return (p.targets, p.values, p.signatures, p.calldatas);\n    }\n\n    /**\n     * @notice Gets the receipt for a voter on a given proposal\n     * @param proposalId the id of proposal\n     * @param voter The address of the voter\n     * @return The voting receipt\n     */\n    function getReceipt(uint proposalId, address voter) external view returns (Receipt memory) {\n        return proposals[proposalId].receipts[voter];\n    }\n\n    /**\n     * @notice Gets the state of a proposal\n     * @param proposalId The id of the proposal\n     * @return Proposal state\n     */\n    function state(uint proposalId) public view returns (ProposalState) {\n        require(\n            proposalCount >= proposalId && proposalId > initialProposalId,\n            \"GovernorBravo::state: invalid proposal id\"\n        );\n        Proposal storage proposal = proposals[proposalId];\n        if (proposal.canceled) {\n            return ProposalState.Canceled;\n        } else if (block.number <= proposal.startBlock) {\n            return ProposalState.Pending;\n        } else if (block.number <= proposal.endBlock) {\n            return ProposalState.Active;\n        } else if (proposal.forVotes <= proposal.againstVotes || proposal.forVotes < quorumVotes) {\n            return ProposalState.Defeated;\n        } else if (proposal.eta == 0) {\n            return ProposalState.Succeeded;\n        } else if (proposal.executed) {\n            return ProposalState.Executed;\n        } else if (\n            block.timestamp >= add256(proposal.eta, proposalTimelocks[uint8(proposal.proposalType)].GRACE_PERIOD())\n        ) {\n            return ProposalState.Expired;\n        } else {\n            return ProposalState.Queued;\n        }\n    }\n\n    /**\n     * @notice Cast a vote for a proposal\n     * @param proposalId The id of the proposal to vote on\n     * @param support The support value for the vote. 0=against, 1=for, 2=abstain\n     */\n    function castVote(uint proposalId, uint8 support) external {\n        emit VoteCast(msg.sender, proposalId, support, castVoteInternal(msg.sender, proposalId, support), \"\");\n    }\n\n    /**\n     * @notice Cast a vote for a proposal with a reason\n     * @param proposalId The id of the proposal to vote on\n     * @param support The support value for the vote. 0=against, 1=for, 2=abstain\n     * @param reason The reason given for the vote by the voter\n     */\n    function castVoteWithReason(uint proposalId, uint8 support, string calldata reason) external {\n        emit VoteCast(msg.sender, proposalId, support, castVoteInternal(msg.sender, proposalId, support), reason);\n    }\n\n    /**\n     * @notice Cast a vote for a proposal by signature\n     * @dev External function that accepts EIP-712 signatures for voting on proposals.\n     * @param proposalId The id of the proposal to vote on\n     * @param support The support value for the vote. 0=against, 1=for, 2=abstain\n     * @param v recovery id of ECDSA signature\n     * @param r part of the ECDSA sig output\n     * @param s part of the ECDSA sig output\n     */\n    function castVoteBySig(uint proposalId, uint8 support, uint8 v, bytes32 r, bytes32 s) external {\n        bytes32 domainSeparator = keccak256(\n            abi.encode(DOMAIN_TYPEHASH, keccak256(bytes(name)), getChainIdInternal(), address(this))\n        );\n        bytes32 structHash = keccak256(abi.encode(BALLOT_TYPEHASH, proposalId, support));\n        bytes32 digest = keccak256(abi.encodePacked(\"\\x19\\x01\", domainSeparator, structHash));\n        address signatory = ecrecover(digest, v, r, s);\n        require(signatory != address(0), \"GovernorBravo::castVoteBySig: invalid signature\");\n        emit VoteCast(signatory, proposalId, support, castVoteInternal(signatory, proposalId, support), \"\");\n    }\n\n    /**\n     * @notice Internal function that caries out voting logic\n     * @param voter The voter that is casting their vote\n     * @param proposalId The id of the proposal to vote on\n     * @param support The support value for the vote. 0=against, 1=for, 2=abstain\n     * @return The number of votes cast\n     */\n    function castVoteInternal(address voter, uint proposalId, uint8 support) internal returns (uint96) {\n        require(state(proposalId) == ProposalState.Active, \"GovernorBravo::castVoteInternal: voting is closed\");\n        require(support <= 2, \"GovernorBravo::castVoteInternal: invalid vote type\");\n        Proposal storage proposal = proposals[proposalId];\n        Receipt storage receipt = proposal.receipts[voter];\n        require(receipt.hasVoted == false, \"GovernorBravo::castVoteInternal: voter already voted\");\n        uint96 votes = xvsVault.getPriorVotes(voter, proposal.startBlock);\n\n        if (support == 0) {\n            proposal.againstVotes = add256(proposal.againstVotes, votes);\n        } else if (support == 1) {\n            proposal.forVotes = add256(proposal.forVotes, votes);\n        } else if (support == 2) {\n            proposal.abstainVotes = add256(proposal.abstainVotes, votes);\n        }\n\n        receipt.hasVoted = true;\n        receipt.support = support;\n        receipt.votes = votes;\n\n        return votes;\n    }\n\n    /**\n     * @notice Sets the new governance guardian\n     * @param newGuardian the address of the new guardian\n     */\n    function _setGuardian(address newGuardian) external {\n        require(msg.sender == guardian || msg.sender == admin, \"GovernorBravo::_setGuardian: admin or guardian only\");\n        require(newGuardian != address(0), \"GovernorBravo::_setGuardian: cannot live without a guardian\");\n        address oldGuardian = guardian;\n        guardian = newGuardian;\n\n        emit NewGuardian(oldGuardian, newGuardian);\n    }\n\n    /**\n     * @notice Initiate the GovernorBravo contract\n     * @dev Admin only. Sets initial proposal id which initiates the contract, ensuring a continuous proposal id count\n     * @param governorAlpha The address for the Governor to continue the proposal id count from\n     */\n    function _initiate(address governorAlpha) external {\n        require(msg.sender == admin, \"GovernorBravo::_initiate: admin only\");\n        require(initialProposalId == 0, \"GovernorBravo::_initiate: can only initiate once\");\n        proposalCount = GovernorAlphaInterface(governorAlpha).proposalCount();\n        initialProposalId = proposalCount;\n        for (uint256 i; i < getGovernanceRouteCount(); ++i) {\n            proposalTimelocks[i].acceptAdmin();\n        }\n    }\n\n    /**\n     * @notice Set max proposal operations\n     * @dev Admin only.\n     * @param proposalMaxOperations_ Max proposal operations\n     */\n    function _setProposalMaxOperations(uint proposalMaxOperations_) external {\n        require(msg.sender == admin, \"GovernorBravo::_setProposalMaxOperations: admin only\");\n        uint oldProposalMaxOperations = proposalMaxOperations;\n        proposalMaxOperations = proposalMaxOperations_;\n\n        emit ProposalMaxOperationsUpdated(oldProposalMaxOperations, proposalMaxOperations_);\n    }\n\n    /**\n     * @notice Begins transfer of admin rights. The newPendingAdmin must call `_acceptAdmin` to finalize the transfer.\n     * @dev Admin function to begin change of admin. The newPendingAdmin must call `_acceptAdmin` to finalize the transfer.\n     * @param newPendingAdmin New pending admin.\n     */\n    function _setPendingAdmin(address newPendingAdmin) external {\n        // Check caller = admin\n        require(msg.sender == admin, \"GovernorBravo:_setPendingAdmin: admin only\");\n\n        // Save current value, if any, for inclusion in log\n        address oldPendingAdmin = pendingAdmin;\n\n        // Store pendingAdmin with value newPendingAdmin\n        pendingAdmin = newPendingAdmin;\n\n        // Emit NewPendingAdmin(oldPendingAdmin, newPendingAdmin)\n        emit NewPendingAdmin(oldPendingAdmin, newPendingAdmin);\n    }\n\n    /**\n     * @notice Accepts transfer of admin rights. msg.sender must be pendingAdmin\n     * @dev Admin function for pending admin to accept role and update admin\n     */\n    function _acceptAdmin() external {\n        // Check caller is pendingAdmin and pendingAdmin ≠ address(0)\n        require(\n            msg.sender == pendingAdmin && msg.sender != address(0),\n            \"GovernorBravo:_acceptAdmin: pending admin only\"\n        );\n\n        // Save current values for inclusion in log\n        address oldAdmin = admin;\n        address oldPendingAdmin = pendingAdmin;\n\n        // Store admin with value pendingAdmin\n        admin = pendingAdmin;\n\n        // Clear the pending value\n        pendingAdmin = address(0);\n\n        emit NewAdmin(oldAdmin, admin);\n        emit NewPendingAdmin(oldPendingAdmin, pendingAdmin);\n    }\n\n    function add256(uint256 a, uint256 b) internal pure returns (uint) {\n        uint c = a + b;\n        require(c >= a, \"addition overflow\");\n        return c;\n    }\n\n    function sub256(uint256 a, uint256 b) internal pure returns (uint) {\n        require(b <= a, \"subtraction underflow\");\n        return a - b;\n    }\n\n    function getChainIdInternal() internal pure returns (uint) {\n        uint chainId;\n        assembly {\n            chainId := chainid()\n        }\n        return chainId;\n    }\n\n    function getGovernanceRouteCount() internal pure returns (uint8) {\n        return uint8(ProposalType.CRITICAL) + 1;\n    }\n}\n"
+    },
+    "@venusprotocol/governance-contracts/contracts/Governance/GovernorBravoInterfaces.sol": {
+      "content": "pragma solidity ^0.5.16;\npragma experimental ABIEncoderV2;\n\n/**\n * @title GovernorBravoEvents\n * @author Venus\n * @notice Set of events emitted by the GovernorBravo contracts.\n */\ncontract GovernorBravoEvents {\n    /// @notice An event emitted when a new proposal is created\n    event ProposalCreated(\n        uint id,\n        address proposer,\n        address[] targets,\n        uint[] values,\n        string[] signatures,\n        bytes[] calldatas,\n        uint startBlock,\n        uint endBlock,\n        string description,\n        uint8 proposalType\n    );\n\n    /// @notice An event emitted when a vote has been cast on a proposal\n    /// @param voter The address which casted a vote\n    /// @param proposalId The proposal id which was voted on\n    /// @param support Support value for the vote. 0=against, 1=for, 2=abstain\n    /// @param votes Number of votes which were cast by the voter\n    /// @param reason The reason given for the vote by the voter\n    event VoteCast(address indexed voter, uint proposalId, uint8 support, uint votes, string reason);\n\n    /// @notice An event emitted when a proposal has been canceled\n    event ProposalCanceled(uint id);\n\n    /// @notice An event emitted when a proposal has been queued in the Timelock\n    event ProposalQueued(uint id, uint eta);\n\n    /// @notice An event emitted when a proposal has been executed in the Timelock\n    event ProposalExecuted(uint id);\n\n    /// @notice An event emitted when the voting delay is set\n    event VotingDelaySet(uint oldVotingDelay, uint newVotingDelay);\n\n    /// @notice An event emitted when the voting period is set\n    event VotingPeriodSet(uint oldVotingPeriod, uint newVotingPeriod);\n\n    /// @notice Emitted when implementation is changed\n    event NewImplementation(address oldImplementation, address newImplementation);\n\n    /// @notice Emitted when proposal threshold is set\n    event ProposalThresholdSet(uint oldProposalThreshold, uint newProposalThreshold);\n\n    /// @notice Emitted when pendingAdmin is changed\n    event NewPendingAdmin(address oldPendingAdmin, address newPendingAdmin);\n\n    /// @notice Emitted when pendingAdmin is accepted, which means admin is updated\n    event NewAdmin(address oldAdmin, address newAdmin);\n\n    /// @notice Emitted when the new guardian address is set\n    event NewGuardian(address oldGuardian, address newGuardian);\n\n    /// @notice Emitted when the maximum number of operations in one proposal is updated\n    event ProposalMaxOperationsUpdated(uint oldMaxOperations, uint newMaxOperations);\n\n    /// @notice Emitted when the new validation params are set\n    event SetValidationParams(\n        uint256 oldMinVotingPeriod,\n        uint256 newMinVotingPeriod,\n        uint256 oldmaxVotingPeriod,\n        uint256 newmaxVotingPeriod,\n        uint256 oldminVotingDelay,\n        uint256 newminVotingDelay,\n        uint256 oldmaxVotingDelay,\n        uint256 newmaxVotingDelay\n    );\n\n    /// @notice Emitted when new Proposal configs added\n    event SetProposalConfigs(uint256 votingPeriod, uint256 votingDelay, uint256 proposalThreshold);\n}\n\n/**\n * @title GovernorBravoDelegatorStorage\n * @author Venus\n * @notice Storage layout of the `GovernorBravoDelegator` contract\n */\ncontract GovernorBravoDelegatorStorage {\n    /// @notice Administrator for this contract\n    address public admin;\n\n    /// @notice Pending administrator for this contract\n    address public pendingAdmin;\n\n    /// @notice Active brains of Governor\n    address public implementation;\n}\n\n/**\n * @title GovernorBravoDelegateStorageV1\n * @dev For future upgrades, do not change GovernorBravoDelegateStorageV1. Create a new\n * contract which implements GovernorBravoDelegateStorageV1 and following the naming convention\n * GovernorBravoDelegateStorageVX.\n */\ncontract GovernorBravoDelegateStorageV1 is GovernorBravoDelegatorStorage {\n    /// @notice DEPRECATED The delay before voting on a proposal may take place, once proposed, in blocks\n    uint public votingDelay;\n\n    /// @notice DEPRECATED The duration of voting on a proposal, in blocks\n    uint public votingPeriod;\n\n    /// @notice DEPRECATED The number of votes required in order for a voter to become a proposer\n    uint public proposalThreshold;\n\n    /// @notice Initial proposal id set at become\n    uint public initialProposalId;\n\n    /// @notice The total number of proposals\n    uint public proposalCount;\n\n    /// @notice The address of the Venus Protocol Timelock\n    TimelockInterface public timelock;\n\n    /// @notice The address of the Venus governance token\n    XvsVaultInterface public xvsVault;\n\n    /// @notice The official record of all proposals ever proposed\n    mapping(uint => Proposal) public proposals;\n\n    /// @notice The latest proposal for each proposer\n    mapping(address => uint) public latestProposalIds;\n\n    struct Proposal {\n        /// @notice Unique id for looking up a proposal\n        uint id;\n        /// @notice Creator of the proposal\n        address proposer;\n        /// @notice The timestamp that the proposal will be available for execution, set once the vote succeeds\n        uint eta;\n        /// @notice the ordered list of target addresses for calls to be made\n        address[] targets;\n        /// @notice The ordered list of values (i.e. msg.value) to be passed to the calls to be made\n        uint[] values;\n        /// @notice The ordered list of function signatures to be called\n        string[] signatures;\n        /// @notice The ordered list of calldata to be passed to each call\n        bytes[] calldatas;\n        /// @notice The block at which voting begins: holders must delegate their votes prior to this block\n        uint startBlock;\n        /// @notice The block at which voting ends: votes must be cast prior to this block\n        uint endBlock;\n        /// @notice Current number of votes in favor of this proposal\n        uint forVotes;\n        /// @notice Current number of votes in opposition to this proposal\n        uint againstVotes;\n        /// @notice Current number of votes for abstaining for this proposal\n        uint abstainVotes;\n        /// @notice Flag marking whether the proposal has been canceled\n        bool canceled;\n        /// @notice Flag marking whether the proposal has been executed\n        bool executed;\n        /// @notice Receipts of ballots for the entire set of voters\n        mapping(address => Receipt) receipts;\n        /// @notice The type of the proposal\n        uint8 proposalType;\n    }\n\n    /// @notice Ballot receipt record for a voter\n    struct Receipt {\n        /// @notice Whether or not a vote has been cast\n        bool hasVoted;\n        /// @notice Whether or not the voter supports the proposal or abstains\n        uint8 support;\n        /// @notice The number of votes the voter had, which were cast\n        uint96 votes;\n    }\n\n    /// @notice Possible states that a proposal may be in\n    enum ProposalState {\n        Pending,\n        Active,\n        Canceled,\n        Defeated,\n        Succeeded,\n        Queued,\n        Expired,\n        Executed\n    }\n\n    /// @notice The maximum number of actions that can be included in a proposal\n    uint public proposalMaxOperations;\n\n    /// @notice A privileged role that can cancel any proposal\n    address public guardian;\n}\n\n/**\n * @title GovernorBravoDelegateStorageV2\n * @dev For future upgrades, do not change GovernorBravoDelegateStorageV2. Create a new\n * contract which implements GovernorBravoDelegateStorageV2 and following the naming convention\n * GovernorBravoDelegateStorageVX.\n */\ncontract GovernorBravoDelegateStorageV2 is GovernorBravoDelegateStorageV1 {\n    enum ProposalType {\n        NORMAL,\n        FASTTRACK,\n        CRITICAL\n    }\n\n    struct ProposalConfig {\n        /// @notice The delay before voting on a proposal may take place, once proposed, in blocks\n        uint256 votingDelay;\n        /// @notice The duration of voting on a proposal, in blocks\n        uint256 votingPeriod;\n        /// @notice The number of votes required in order for a voter to become a proposer\n        uint256 proposalThreshold;\n    }\n\n    /// @notice mapping containing configuration for each proposal type\n    mapping(uint => ProposalConfig) public proposalConfigs;\n\n    /// @notice mapping containing Timelock addresses for each proposal type\n    mapping(uint => TimelockInterface) public proposalTimelocks;\n}\n\n/**\n * @title GovernorBravoDelegateStorageV3\n * @dev For future upgrades, do not change GovernorBravoDelegateStorageV3. Create a new\n * contract which implements GovernorBravoDelegateStorageV3 and following the naming convention\n * GovernorBravoDelegateStorageVX.\n */\ncontract GovernorBravoDelegateStorageV3 is GovernorBravoDelegateStorageV2 {\n    struct ValidationParams {\n        uint256 minVotingPeriod;\n        uint256 maxVotingPeriod;\n        uint256 minVotingDelay;\n        uint256 maxVotingDelay;\n    }\n    /// @notice Stores the current minimum and maximum values of voting delay and voting period\n    ValidationParams public validationParams;\n}\n\n/**\n * @title TimelockInterface\n * @author Venus\n * @notice Interface implemented by the Timelock contract.\n */\ninterface TimelockInterface {\n    function delay() external view returns (uint);\n\n    function GRACE_PERIOD() external view returns (uint);\n\n    function acceptAdmin() external;\n\n    function queuedTransactions(bytes32 hash) external view returns (bool);\n\n    function queueTransaction(\n        address target,\n        uint value,\n        string calldata signature,\n        bytes calldata data,\n        uint eta\n    ) external returns (bytes32);\n\n    function cancelTransaction(\n        address target,\n        uint value,\n        string calldata signature,\n        bytes calldata data,\n        uint eta\n    ) external;\n\n    function executeTransaction(\n        address target,\n        uint value,\n        string calldata signature,\n        bytes calldata data,\n        uint eta\n    ) external payable returns (bytes memory);\n}\n\ninterface XvsVaultInterface {\n    function getPriorVotes(address account, uint blockNumber) external view returns (uint96);\n}\n\ninterface GovernorAlphaInterface {\n    /// @notice The total number of proposals\n    function proposalCount() external returns (uint);\n}\n"
+    },
+    "@venusprotocol/governance-contracts/contracts/Governance/IAccessControlManagerV5.sol": {
+      "content": "// SPDX-License-Identifier: BSD-3-Clause\npragma solidity 0.5.16;\n\n/**\n * @title IAccessControlManagerV5\n * @author Venus\n * @notice Interface implemented by the `AccessControlManagerV5` contract.\n */\ninterface IAccessControlManagerV5 {\n    /**\n     * @dev Emitted when `newAdminRole` is set as ``role``'s admin role, replacing `previousAdminRole`\n     *\n     * `DEFAULT_ADMIN_ROLE` is the starting admin for all roles, despite\n     * {RoleAdminChanged} not being emitted signaling this.\n     *\n     */\n    event RoleAdminChanged(bytes32 indexed role, bytes32 indexed previousAdminRole, bytes32 indexed newAdminRole);\n\n    /**\n     * @dev Emitted when `account` is granted `role`.\n     *\n     * `sender` is the account that originated the contract call, an admin role\n     * bearer except when using {AccessControl-_setupRole}.\n     */\n    event RoleGranted(bytes32 indexed role, address indexed account, address indexed sender);\n\n    /**\n     * @dev Emitted when `account` is revoked `role`.\n     *\n     * `sender` is the account that originated the contract call:\n     *   - if using `revokeRole`, it is the admin role bearer\n     *   - if using `renounceRole`, it is the role bearer (i.e. `account`)\n     */\n    event RoleRevoked(bytes32 indexed role, address indexed account, address indexed sender);\n\n    /**\n     * @dev Returns `true` if `account` has been granted `role`.\n     */\n    function hasRole(bytes32 role, address account) external view returns (bool);\n\n    /**\n     * @dev Returns the admin role that controls `role`. See {grantRole} and\n     * {revokeRole}.\n     *\n     * To change a role's admin, use {AccessControl-_setRoleAdmin}.\n     */\n    function getRoleAdmin(bytes32 role) external view returns (bytes32);\n\n    /**\n     * @dev Grants `role` to `account`.\n     *\n     * If `account` had not been already granted `role`, emits a {RoleGranted}\n     * event.\n     *\n     * Requirements:\n     *\n     * - the caller must have ``role``'s admin role.\n     */\n    function grantRole(bytes32 role, address account) external;\n\n    /**\n     * @dev Revokes `role` from `account`.\n     *\n     * If `account` had been granted `role`, emits a {RoleRevoked} event.\n     *\n     * Requirements:\n     *\n     * - the caller must have ``role``'s admin role.\n     */\n    function revokeRole(bytes32 role, address account) external;\n\n    /**\n     * @dev Revokes `role` from the calling account.\n     *\n     * Roles are often managed via {grantRole} and {revokeRole}: this function's\n     * purpose is to provide a mechanism for accounts to lose their privileges\n     * if they are compromised (such as when a trusted device is misplaced).\n     *\n     * If the calling account had been granted `role`, emits a {RoleRevoked}\n     * event.\n     *\n     * Requirements:\n     *\n     * - the caller must be `account`.\n     */\n    function renounceRole(bytes32 role, address account) external;\n\n    /**\n     * @notice Gives a function call permission to one single account\n     * @dev this function can be called only from Role Admin or DEFAULT_ADMIN_ROLE\n     * \t\tMay emit a {RoleGranted} event.\n     * @param contractAddress address of contract for which call permissions will be granted\n     * @param functionSig signature e.g. \"functionName(uint,bool)\"\n     */\n    function giveCallPermission(address contractAddress, string calldata functionSig, address accountToPermit) external;\n\n    /**\n     * @notice Revokes an account's permission to a particular function call\n     * @dev this function can be called only from Role Admin or DEFAULT_ADMIN_ROLE\n     * \t\tMay emit a {RoleRevoked} event.\n     * @param contractAddress address of contract for which call permissions will be revoked\n     * @param functionSig signature e.g. \"functionName(uint,bool)\"\n     */\n    function revokeCallPermission(\n        address contractAddress,\n        string calldata functionSig,\n        address accountToRevoke\n    ) external;\n\n    /**\n     * @notice Verifies if the given account can call a praticular contract's function\n     * @dev Since the contract is calling itself this function, we can get contracts address with msg.sender\n     * @param account address (eoa or contract) for which call permissions will be checked\n     * @param functionSig signature e.g. \"functionName(uint,bool)\"\n     * @return false if the user account cannot call the particular contract function\n     *\n     */\n    function isAllowedToCall(address account, string calldata functionSig) external view returns (bool);\n\n    function hasPermission(\n        address account,\n        address contractAddress,\n        string calldata functionSig\n    ) external view returns (bool);\n}\n"
+    },
+    "@venusprotocol/solidity-utilities/contracts/TimeManagerV5.sol": {
+      "content": "// SPDX-License-Identifier: BSD-3-Clause\npragma solidity 0.5.16;\n\n/**\n * @title TimeManagerV5\n * @dev THIS CONTRACT IS NOT MEANT TO BE DEPLOYED DIRECTLY.\n * It should only be used through inheritance by other contracts.\n */\ncontract TimeManagerV5 {\n    /// @dev The approximate number of seconds per year\n    uint256 public constant SECONDS_PER_YEAR = 31_536_000;\n\n    /// @notice Number of blocks per year or seconds per year\n    uint256 public blocksOrSecondsPerYear;\n\n    /// @dev Sets true when block timestamp is used\n    bool public isTimeBased;\n\n    /// @dev Sets true when contract is initialized\n    bool private isInitialized;\n\n    /// @notice Deprecated slot for _getCurrentSlot function pointer\n    bytes8 private __deprecatedSlot1;\n\n    /**\n     * @dev This empty reserved space is put in place to allow future versions to add new\n     * variables without shifting down storage in the inheritance chain\n     * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps\n     *\n     * Storage layout explanation:\n     * - blocksOrSecondsPerYear (uint256): Occupies slot 0 (full 32 bytes)\n     * - Slot 1 has the following variables packed from right to left (low to high):\n     *   - isTimeBased (bool): 1 byte at lowest position\n     *   - isInitialized (bool): 1 byte\n     *   - __deprecatedSlot1 (bytes8): 8 bytes\n     *\n     * Total used slots: 2\n     * Therefore __gap size is 48 (50 - 2 = 48)\n     */\n\n    uint256[48] private __gap;\n\n    /// @notice Emitted once Time Manager is initialized with timebased and blocksOrSecondsPerYear\n    event InitializeTimeManager(bool indexed timebased, uint256 indexed blocksOrSecondsPerYear);\n\n    /// @notice Emitted When blocks per year is updated for block based network\n    event SetBlocksPerYear(uint256 indexed prevBlocksPerYear, uint256 indexed newBlocksPerYear);\n\n    /**\n     * @dev Function to simply retrieve block number or block timestamp\n     * @return Current block number or block timestamp\n     */\n    function getBlockNumberOrTimestamp() public view returns (uint256) {\n        return isTimeBased ? _getBlockTimestamp() : _getBlockNumber();\n    }\n\n    /**\n     * @dev Initializes the contract to use either blocks or seconds\n     * @param timeBased_ A boolean indicating whether the contract is based on time or block\n     * If timeBased is true than blocksPerYear_ param is ignored as blocksOrSecondsPerYear is set to SECONDS_PER_YEAR\n     * @param blocksPerYear_ The number of blocks per year\n     */\n    function _initializeTimeManager(bool timeBased_, uint256 blocksPerYear_) internal {\n        if (isInitialized) revert(\"Already initialized TimeManager\");\n\n        if (!timeBased_ && blocksPerYear_ == 0) {\n            revert(\"Invalid blocks per year\");\n        }\n        if (timeBased_ && blocksPerYear_ != 0) {\n            revert(\"Invalid time based configuration\");\n        }\n\n        isInitialized = true;\n        isTimeBased = timeBased_;\n        blocksOrSecondsPerYear = timeBased_ ? SECONDS_PER_YEAR : blocksPerYear_;\n        emit InitializeTimeManager(isTimeBased, blocksOrSecondsPerYear);\n    }\n\n    /**\n     * @dev Set blocks per year for block based network\n     * @param blocksPerYear_ The number of blocks per year\n     */\n    function _setBlocksPerYear(uint256 blocksPerYear_) internal {\n        if (blocksPerYear_ == 0) {\n            revert(\"Blocks per year cannot be zero\");\n        }\n\n        if (isTimeBased) {\n            revert(\"Cannot update for time based network\");\n        }\n        emit SetBlocksPerYear(blocksOrSecondsPerYear, blocksPerYear_);\n        blocksOrSecondsPerYear = blocksPerYear_;\n    }\n\n    /**\n     * @dev Returns the current timestamp in seconds\n     * @return The current timestamp\n     */\n    function _getBlockTimestamp() private view returns (uint256) {\n        return block.timestamp;\n    }\n\n    /**\n     * @dev Returns the current block number\n     * @return The current block number\n     */\n    function _getBlockNumber() private view returns (uint256) {\n        return block.number;\n    }\n}\n"
+    },
+    "contracts/Governance/VTreasury.sol": {
+      "content": "pragma solidity ^0.5.16;\n\nimport \"../Utils/IBEP20.sol\";\nimport \"../Utils/SafeBEP20.sol\";\nimport \"../Utils/Ownable.sol\";\n\n/**\n * @title VTreasury\n * @author Venus\n * @notice Protocol treasury that holds tokens owned by Venus\n */\ncontract VTreasury is Ownable {\n    using SafeMath for uint256;\n    using SafeBEP20 for IBEP20;\n\n    // WithdrawTreasuryBEP20 Event\n    event WithdrawTreasuryBEP20(address tokenAddress, uint256 withdrawAmount, address withdrawAddress);\n\n    // WithdrawTreasuryBNB Event\n    event WithdrawTreasuryBNB(uint256 withdrawAmount, address withdrawAddress);\n\n    /**\n     * @notice To receive BNB\n     */\n    function() external payable {}\n\n    /**\n     * @notice Withdraw Treasury BEP20 Tokens, Only owner call it\n     * @param tokenAddress The address of treasury token\n     * @param withdrawAmount The withdraw amount to owner\n     * @param withdrawAddress The withdraw address\n     */\n    function withdrawTreasuryBEP20(\n        address tokenAddress,\n        uint256 withdrawAmount,\n        address withdrawAddress\n    ) external onlyOwner {\n        uint256 actualWithdrawAmount = withdrawAmount;\n        // Get Treasury Token Balance\n        uint256 treasuryBalance = IBEP20(tokenAddress).balanceOf(address(this));\n\n        // Check Withdraw Amount\n        if (withdrawAmount > treasuryBalance) {\n            // Update actualWithdrawAmount\n            actualWithdrawAmount = treasuryBalance;\n        }\n\n        // Transfer BEP20 Token to withdrawAddress\n        IBEP20(tokenAddress).safeTransfer(withdrawAddress, actualWithdrawAmount);\n\n        emit WithdrawTreasuryBEP20(tokenAddress, actualWithdrawAmount, withdrawAddress);\n    }\n\n    /**\n     * @notice Withdraw Treasury BNB, Only owner call it\n     * @param withdrawAmount The withdraw amount to owner\n     * @param withdrawAddress The withdraw address\n     */\n    function withdrawTreasuryBNB(uint256 withdrawAmount, address payable withdrawAddress) external payable onlyOwner {\n        uint256 actualWithdrawAmount = withdrawAmount;\n        // Get Treasury BNB Balance\n        uint256 bnbBalance = address(this).balance;\n\n        // Check Withdraw Amount\n        if (withdrawAmount > bnbBalance) {\n            // Update actualWithdrawAmount\n            actualWithdrawAmount = bnbBalance;\n        }\n        // Transfer BNB to withdrawAddress\n        withdrawAddress.transfer(actualWithdrawAmount);\n\n        emit WithdrawTreasuryBNB(actualWithdrawAmount, withdrawAddress);\n    }\n}\n"
+    },
+    "contracts/InterestRateModels/InterestRateModel.sol": {
+      "content": "// SPDX-License-Identifier: BSD-3-Clause\npragma solidity ^0.5.16;\n\n/**\n * @title Venus's InterestRateModel Interface\n * @author Venus\n */\ncontract InterestRateModel {\n    /// @notice Indicator that this is an InterestRateModel contract (for inspection)\n    bool public constant isInterestRateModel = true;\n\n    /**\n     * @notice Calculates the current borrow interest rate per block\n     * @param cash The total amount of cash the market has\n     * @param borrows The total amount of borrows the market has outstanding\n     * @param reserves The total amnount of reserves the market has\n     * @return The borrow rate per block (as a percentage, and scaled by 1e18)\n     */\n    function getBorrowRate(uint cash, uint borrows, uint reserves) external view returns (uint);\n\n    /**\n     * @notice Calculates the current supply interest rate per block\n     * @param cash The total amount of cash the market has\n     * @param borrows The total amount of borrows the market has outstanding\n     * @param reserves The total amnount of reserves the market has\n     * @param reserveFactorMantissa The current reserve factor the market has\n     * @return The supply rate per block (as a percentage, and scaled by 1e18)\n     */\n    function getSupplyRate(\n        uint cash,\n        uint borrows,\n        uint reserves,\n        uint reserveFactorMantissa\n    ) external view returns (uint);\n}\n"
+    },
+    "contracts/InterestRateModels/JumpRateModel.sol": {
+      "content": "// SPDX-License-Identifier: BSD-3-Clause\npragma solidity ^0.5.16;\n\nimport \"../Utils/SafeMath.sol\";\nimport \"./InterestRateModel.sol\";\n\n/**\n * @title Venus's JumpRateModel Contract\n * @author Venus\n */\ncontract JumpRateModel is InterestRateModel {\n    using SafeMath for uint;\n\n    event NewInterestParams(uint baseRatePerBlock, uint multiplierPerBlock, uint jumpMultiplierPerBlock, uint kink);\n\n    /**\n     * @notice The approximate number of blocks per year that is assumed by the interest rate model\n     */\n    uint public blocksPerYear;\n\n    /**\n     * @notice The multiplier of utilization rate that gives the slope of the interest rate\n     */\n    uint public multiplierPerBlock;\n\n    /**\n     * @notice The base interest rate which is the y-intercept when utilization rate is 0\n     */\n    uint public baseRatePerBlock;\n\n    /**\n     * @notice The multiplierPerBlock after hitting a specified utilization point\n     */\n    uint public jumpMultiplierPerBlock;\n\n    /**\n     * @notice The utilization point at which the jump multiplier is applied\n     */\n    uint public kink;\n\n    /**\n     * @notice Construct an interest rate model\n     * @param baseRatePerYear The approximate target base APR, as a mantissa (scaled by 1e18)\n     * @param multiplierPerYear The rate of increase in interest rate wrt utilization (scaled by 1e18)\n     * @param jumpMultiplierPerYear The multiplierPerBlock after hitting a specified utilization point\n     * @param kink_ The utilization point at which the jump multiplier is applied\n     * @param blocksPerYear_ The approximate number of blocks per year to assume\n     */\n    constructor(\n        uint baseRatePerYear,\n        uint multiplierPerYear,\n        uint jumpMultiplierPerYear,\n        uint kink_,\n        uint blocksPerYear_\n    ) public {\n        blocksPerYear = blocksPerYear_;\n        baseRatePerBlock = baseRatePerYear.div(blocksPerYear_);\n        multiplierPerBlock = multiplierPerYear.div(blocksPerYear_);\n        jumpMultiplierPerBlock = jumpMultiplierPerYear.div(blocksPerYear_);\n        kink = kink_;\n\n        emit NewInterestParams(baseRatePerBlock, multiplierPerBlock, jumpMultiplierPerBlock, kink);\n    }\n\n    /**\n     * @notice Calculates the utilization rate of the market: `borrows / (cash + borrows - reserves)`\n     * @param cash The amount of cash in the market\n     * @param borrows The amount of borrows in the market\n     * @param reserves The amount of reserves in the market (currently unused)\n     * @return The utilization rate as a mantissa between [0, 1e18]\n     */\n    function utilizationRate(uint cash, uint borrows, uint reserves) public pure returns (uint) {\n        // Utilization rate is 0 when there are no borrows\n        if (borrows == 0) {\n            return 0;\n        }\n\n        return borrows.mul(1e18).div(cash.add(borrows).sub(reserves));\n    }\n\n    /**\n     * @notice Calculates the current borrow rate per block, with the error code expected by the market\n     * @param cash The amount of cash in the market\n     * @param borrows The amount of borrows in the market\n     * @param reserves The amount of reserves in the market\n     * @return The borrow rate percentage per block as a mantissa (scaled by 1e18)\n     */\n    function getBorrowRate(uint cash, uint borrows, uint reserves) public view returns (uint) {\n        uint util = utilizationRate(cash, borrows, reserves);\n\n        if (util <= kink) {\n            return util.mul(multiplierPerBlock).div(1e18).add(baseRatePerBlock);\n        } else {\n            uint normalRate = kink.mul(multiplierPerBlock).div(1e18).add(baseRatePerBlock);\n            uint excessUtil = util.sub(kink);\n            return excessUtil.mul(jumpMultiplierPerBlock).div(1e18).add(normalRate);\n        }\n    }\n\n    /**\n     * @notice Calculates the current supply rate per block\n     * @param cash The amount of cash in the market\n     * @param borrows The amount of borrows in the market\n     * @param reserves The amount of reserves in the market\n     * @param reserveFactorMantissa The current reserve factor for the market\n     * @return The supply rate percentage per block as a mantissa (scaled by 1e18)\n     */\n    function getSupplyRate(\n        uint cash,\n        uint borrows,\n        uint reserves,\n        uint reserveFactorMantissa\n    ) public view returns (uint) {\n        uint oneMinusReserveFactor = uint(1e18).sub(reserveFactorMantissa);\n        uint borrowRate = getBorrowRate(cash, borrows, reserves);\n        uint rateToPool = borrowRate.mul(oneMinusReserveFactor).div(1e18);\n        return utilizationRate(cash, borrows, reserves).mul(rateToPool).div(1e18);\n    }\n}\n"
+    },
+    "contracts/InterestRateModels/WhitePaperInterestRateModel.sol": {
+      "content": "// SPDX-License-Identifier: BSD-3-Clause\npragma solidity ^0.5.16;\n\nimport \"../Utils/SafeMath.sol\";\nimport \"./InterestRateModel.sol\";\n\n/**\n * @title Venus's WhitePaperInterestRateModel Contract\n * @author Venus\n * @notice The parameterized model described in section 2.4 of the original Venus Protocol whitepaper\n */\ncontract WhitePaperInterestRateModel is InterestRateModel {\n    using SafeMath for uint;\n\n    event NewInterestParams(uint baseRatePerBlock, uint multiplierPerBlock);\n\n    /**\n     * @notice The approximate number of blocks per year that is assumed by the interest rate model\n     */\n    uint public blocksPerYear;\n\n    /**\n     * @notice The multiplier of utilization rate that gives the slope of the interest rate\n     */\n    uint public multiplierPerBlock;\n\n    /**\n     * @notice The base interest rate which is the y-intercept when utilization rate is 0\n     */\n    uint public baseRatePerBlock;\n\n    /**\n     * @notice Construct an interest rate model\n     * @param baseRatePerYear The approximate target base APR, as a mantissa (scaled by 1e18)\n     * @param multiplierPerYear The rate of increase in interest rate wrt utilization (scaled by 1e18)\n     * @param blocksPerYear_ The approximate number of blocks per year to assume\n     */\n    constructor(uint baseRatePerYear, uint multiplierPerYear, uint blocksPerYear_) public {\n        blocksPerYear = blocksPerYear_;\n        baseRatePerBlock = baseRatePerYear.div(blocksPerYear_);\n        multiplierPerBlock = multiplierPerYear.div(blocksPerYear_);\n\n        emit NewInterestParams(baseRatePerBlock, multiplierPerBlock);\n    }\n\n    /**\n     * @notice Calculates the utilization rate of the market: `borrows / (cash + borrows - reserves)`\n     * @param cash The amount of cash in the market\n     * @param borrows The amount of borrows in the market\n     * @param reserves The amount of reserves in the market (currently unused)\n     * @return The utilization rate as a mantissa between [0, 1e18]\n     */\n    function utilizationRate(uint cash, uint borrows, uint reserves) public pure returns (uint) {\n        // Utilization rate is 0 when there are no borrows\n        if (borrows == 0) {\n            return 0;\n        }\n\n        return borrows.mul(1e18).div(cash.add(borrows).sub(reserves));\n    }\n\n    /**\n     * @notice Calculates the current borrow rate per block, with the error code expected by the market\n     * @param cash The amount of cash in the market\n     * @param borrows The amount of borrows in the market\n     * @param reserves The amount of reserves in the market\n     * @return The borrow rate percentage per block as a mantissa (scaled by 1e18)\n     */\n    function getBorrowRate(uint cash, uint borrows, uint reserves) public view returns (uint) {\n        uint ur = utilizationRate(cash, borrows, reserves);\n        return ur.mul(multiplierPerBlock).div(1e18).add(baseRatePerBlock);\n    }\n\n    /**\n     * @notice Calculates the current supply rate per block\n     * @param cash The amount of cash in the market\n     * @param borrows The amount of borrows in the market\n     * @param reserves The amount of reserves in the market\n     * @param reserveFactorMantissa The current reserve factor for the market\n     * @return The supply rate percentage per block as a mantissa (scaled by 1e18)\n     */\n    function getSupplyRate(\n        uint cash,\n        uint borrows,\n        uint reserves,\n        uint reserveFactorMantissa\n    ) public view returns (uint) {\n        uint oneMinusReserveFactor = uint(1e18).sub(reserveFactorMantissa);\n        uint borrowRate = getBorrowRate(cash, borrows, reserves);\n        uint rateToPool = borrowRate.mul(oneMinusReserveFactor).div(1e18);\n        return utilizationRate(cash, borrows, reserves).mul(rateToPool).div(1e18);\n    }\n}\n"
+    },
+    "contracts/Oracle/PriceOracle.sol": {
+      "content": "// SPDX-License-Identifier: BSD-3-Clause\npragma solidity ^0.5.16;\n\ncontract PriceOracle {\n    /// @notice Indicator that this is a PriceOracle contract (for inspection)\n    bool public constant isPriceOracle = true;\n\n    /**\n     * @notice Get the underlying price of a vToken asset\n     * @param vToken The vToken to get the underlying price of\n     * @return The underlying asset price mantissa (scaled by 1e18).\n     *  Zero means the price is unavailable.\n     */\n    function getUnderlyingPrice(address vToken) external view returns (uint);\n}\n"
+    },
+    "contracts/test/BEP20.sol": {
+      "content": "pragma solidity ^0.5.16;\n\nimport \"../Utils/SafeMath.sol\";\n\n// Mock import\nimport { GovernorBravoDelegate } from \"@venusprotocol/governance-contracts/contracts/Governance/GovernorBravoDelegate.sol\";\n\ninterface BEP20Base {\n    event Approval(address indexed owner, address indexed spender, uint256 value);\n    event Transfer(address indexed from, address indexed to, uint256 value);\n\n    function totalSupply() external view returns (uint256);\n\n    function allowance(address owner, address spender) external view returns (uint256);\n\n    function approve(address spender, uint256 value) external returns (bool);\n\n    function balanceOf(address who) external view returns (uint256);\n}\n\ncontract BEP20 is BEP20Base {\n    function transfer(address to, uint256 value) external returns (bool);\n\n    function transferFrom(address from, address to, uint256 value) external returns (bool);\n}\n\ncontract BEP20NS is BEP20Base {\n    function transfer(address to, uint256 value) external;\n\n    function transferFrom(address from, address to, uint256 value) external;\n}\n\n/**\n * @title Standard BEP20 token\n * @dev Implementation of the basic standard token.\n *  See https://github.com/ethereum/EIPs/issues/20\n */\ncontract StandardToken is BEP20 {\n    using SafeMath for uint256;\n\n    string public name;\n    string public symbol;\n    uint8 public decimals;\n    uint256 public totalSupply;\n    mapping(address => mapping(address => uint256)) public allowance;\n    mapping(address => uint256) public balanceOf;\n\n    constructor(\n        uint256 _initialAmount,\n        string memory _tokenName,\n        uint8 _decimalUnits,\n        string memory _tokenSymbol\n    ) public {\n        totalSupply = _initialAmount;\n        balanceOf[msg.sender] = _initialAmount;\n        name = _tokenName;\n        symbol = _tokenSymbol;\n        decimals = _decimalUnits;\n    }\n\n    function transfer(address dst, uint256 amount) external returns (bool) {\n        balanceOf[msg.sender] = balanceOf[msg.sender].sub(amount, \"Insufficient balance\");\n        balanceOf[dst] = balanceOf[dst].add(amount, \"Balance overflow\");\n        emit Transfer(msg.sender, dst, amount);\n        return true;\n    }\n\n    function transferFrom(address src, address dst, uint256 amount) external returns (bool) {\n        allowance[src][msg.sender] = allowance[src][msg.sender].sub(amount, \"Insufficient allowance\");\n        balanceOf[src] = balanceOf[src].sub(amount, \"Insufficient balance\");\n        balanceOf[dst] = balanceOf[dst].add(amount, \"Balance overflow\");\n        emit Transfer(src, dst, amount);\n        return true;\n    }\n\n    function approve(address _spender, uint256 amount) external returns (bool) {\n        allowance[msg.sender][_spender] = amount;\n        emit Approval(msg.sender, _spender, amount);\n        return true;\n    }\n}\n\n/**\n * @title Non-Standard BEP20 token\n * @dev Version of BEP20 with no return values for `transfer` and `transferFrom`\n *  See https://medium.com/coinmonks/missing-return-value-bug-at-least-130-tokens-affected-d67bf08521ca\n */\ncontract NonStandardToken is BEP20NS {\n    using SafeMath for uint256;\n\n    string public name;\n    uint8 public decimals;\n    string public symbol;\n    uint256 public totalSupply;\n    mapping(address => mapping(address => uint256)) public allowance;\n    mapping(address => uint256) public balanceOf;\n\n    constructor(\n        uint256 _initialAmount,\n        string memory _tokenName,\n        uint8 _decimalUnits,\n        string memory _tokenSymbol\n    ) public {\n        totalSupply = _initialAmount;\n        balanceOf[msg.sender] = _initialAmount;\n        name = _tokenName;\n        symbol = _tokenSymbol;\n        decimals = _decimalUnits;\n    }\n\n    function transfer(address dst, uint256 amount) external {\n        balanceOf[msg.sender] = balanceOf[msg.sender].sub(amount, \"Insufficient balance\");\n        balanceOf[dst] = balanceOf[dst].add(amount, \"Balance overflow\");\n        emit Transfer(msg.sender, dst, amount);\n    }\n\n    function transferFrom(address src, address dst, uint256 amount) external {\n        allowance[src][msg.sender] = allowance[src][msg.sender].sub(amount, \"Insufficient allowance\");\n        balanceOf[src] = balanceOf[src].sub(amount, \"Insufficient balance\");\n        balanceOf[dst] = balanceOf[dst].add(amount, \"Balance overflow\");\n        emit Transfer(src, dst, amount);\n    }\n\n    function approve(address _spender, uint256 amount) external returns (bool) {\n        allowance[msg.sender][_spender] = amount;\n        emit Approval(msg.sender, _spender, amount);\n        return true;\n    }\n}\n\ncontract BEP20Harness is StandardToken {\n    // To support testing, we can specify addresses for which transferFrom should fail and return false\n    mapping(address => bool) public failTransferFromAddresses;\n\n    // To support testing, we allow the contract to always fail `transfer`.\n    mapping(address => bool) public failTransferToAddresses;\n\n    constructor(\n        uint256 _initialAmount,\n        string memory _tokenName,\n        uint8 _decimalUnits,\n        string memory _tokenSymbol\n    ) public StandardToken(_initialAmount, _tokenName, _decimalUnits, _tokenSymbol) {}\n\n    function harnessSetFailTransferFromAddress(address src, bool _fail) public {\n        failTransferFromAddresses[src] = _fail;\n    }\n\n    function harnessSetFailTransferToAddress(address dst, bool _fail) public {\n        failTransferToAddresses[dst] = _fail;\n    }\n\n    function harnessSetBalance(address _account, uint _amount) public {\n        balanceOf[_account] = _amount;\n    }\n\n    function transfer(address dst, uint256 amount) external returns (bool success) {\n        // Added for testing purposes\n        if (failTransferToAddresses[dst]) {\n            return false;\n        }\n        balanceOf[msg.sender] = balanceOf[msg.sender].sub(amount, \"Insufficient balance\");\n        balanceOf[dst] = balanceOf[dst].add(amount, \"Balance overflow\");\n        emit Transfer(msg.sender, dst, amount);\n        return true;\n    }\n\n    function transferFrom(address src, address dst, uint256 amount) external returns (bool success) {\n        // Added for testing purposes\n        if (failTransferFromAddresses[src]) {\n            return false;\n        }\n        allowance[src][msg.sender] = allowance[src][msg.sender].sub(amount, \"Insufficient allowance\");\n        balanceOf[src] = balanceOf[src].sub(amount, \"Insufficient balance\");\n        balanceOf[dst] = balanceOf[dst].add(amount, \"Balance overflow\");\n        emit Transfer(src, dst, amount);\n        return true;\n    }\n}\n"
+    },
+    "contracts/test/EvilToken.sol": {
+      "content": "pragma solidity ^0.5.16;\n\nimport \"./FaucetToken.sol\";\n\n/**\n * @title The Venus Evil Test Token\n * @author Venus\n * @notice A simple test token that fails certain operations\n */\ncontract EvilToken is FaucetToken {\n    bool public fail;\n\n    constructor(\n        uint256 _initialAmount,\n        string memory _tokenName,\n        uint8 _decimalUnits,\n        string memory _tokenSymbol\n    ) public FaucetToken(_initialAmount, _tokenName, _decimalUnits, _tokenSymbol) {\n        fail = true;\n    }\n\n    function setFail(bool _fail) external {\n        fail = _fail;\n    }\n\n    function transfer(address dst, uint256 amount) external returns (bool) {\n        if (fail) {\n            return false;\n        }\n        balanceOf[msg.sender] = balanceOf[msg.sender].sub(amount);\n        balanceOf[dst] = balanceOf[dst].add(amount);\n        emit Transfer(msg.sender, dst, amount);\n        return true;\n    }\n\n    function transferFrom(address src, address dst, uint256 amount) external returns (bool) {\n        if (fail) {\n            return false;\n        }\n        balanceOf[src] = balanceOf[src].sub(amount);\n        balanceOf[dst] = balanceOf[dst].add(amount);\n        allowance[src][msg.sender] = allowance[src][msg.sender].sub(amount);\n        emit Transfer(src, dst, amount);\n        return true;\n    }\n}\n"
+    },
+    "contracts/test/Fauceteer.sol": {
+      "content": "pragma solidity ^0.5.16;\n\nimport \"../Tokens/EIP20NonStandardInterface.sol\";\n\n/**\n * @title Fauceteer\n * @author Venus\n * @notice First computer program to be part of The Giving Pledge\n */\ncontract Fauceteer {\n    /**\n     * @notice Drips some tokens to caller\n     * @dev We send 0.01% of our tokens to the caller. Over time, the amount will tend toward and eventually reach zero.\n     * @param token The token to drip. Note: if we have no balance in this token, function will revert.\n     */\n    function drip(EIP20NonStandardInterface token) public {\n        uint tokenBalance = token.balanceOf(address(this));\n        require(tokenBalance > 0, \"Fauceteer is empty\");\n        token.transfer(msg.sender, tokenBalance / 10000); // 0.01%\n\n        bool success;\n        assembly {\n            switch returndatasize()\n            case 0 {\n                // This is a non-standard BEP-20\n                success := not(0) // set success to true\n            }\n            case 32 {\n                // This is a compliant BEP-20\n                returndatacopy(0, 0, 32)\n                success := mload(0) // Set `success = returndata` of external call\n            }\n            default {\n                // This is an excessively non-compliant BEP-20, revert.\n                revert(0, 0)\n            }\n        }\n\n        require(success, \"Transfer returned false.\");\n    }\n}\n"
+    },
+    "contracts/test/FaucetToken.sol": {
+      "content": "pragma solidity ^0.5.16;\n\nimport \"./BEP20.sol\";\n\n/**\n * @title The Venus Faucet Test Token\n * @author Venus\n * @notice A simple test token that lets anyone get more of it.\n */\ncontract FaucetToken is StandardToken {\n    constructor(\n        uint256 _initialAmount,\n        string memory _tokenName,\n        uint8 _decimalUnits,\n        string memory _tokenSymbol\n    ) public StandardToken(_initialAmount, _tokenName, _decimalUnits, _tokenSymbol) {}\n\n    function allocateTo(address _owner, uint256 value) public {\n        balanceOf[_owner] += value;\n        totalSupply += value;\n        emit Transfer(address(this), _owner, value);\n    }\n}\n\n/**\n * @title The Venus Faucet Test Token (non-standard)\n * @author Venus\n * @notice A simple test token that lets anyone get more of it.\n */\ncontract FaucetNonStandardToken is NonStandardToken {\n    constructor(\n        uint256 _initialAmount,\n        string memory _tokenName,\n        uint8 _decimalUnits,\n        string memory _tokenSymbol\n    ) public NonStandardToken(_initialAmount, _tokenName, _decimalUnits, _tokenSymbol) {}\n\n    function allocateTo(address _owner, uint256 value) public {\n        balanceOf[_owner] += value;\n        totalSupply += value;\n        emit Transfer(address(this), _owner, value);\n    }\n}\n\n/**\n * @title The Venus Faucet Re-Entrant Test Token\n * @author Venus\n * @notice A test token that is malicious and tries to re-enter callers\n */\ncontract FaucetTokenReEntrantHarness {\n    using SafeMath for uint256;\n\n    event Transfer(address indexed from, address indexed to, uint256 value);\n    event Approval(address indexed owner, address indexed spender, uint256 value);\n\n    string public name;\n    string public symbol;\n    uint8 public decimals;\n    uint256 internal totalSupply_;\n    mapping(address => mapping(address => uint256)) internal allowance_;\n    mapping(address => uint256) internal balanceOf_;\n\n    bytes public reEntryCallData;\n    string public reEntryFun;\n\n    constructor(\n        uint256 _initialAmount,\n        string memory _tokenName,\n        uint8 _decimalUnits,\n        string memory _tokenSymbol,\n        bytes memory _reEntryCallData,\n        string memory _reEntryFun\n    ) public {\n        totalSupply_ = _initialAmount;\n        balanceOf_[msg.sender] = _initialAmount;\n        name = _tokenName;\n        symbol = _tokenSymbol;\n        decimals = _decimalUnits;\n        reEntryCallData = _reEntryCallData;\n        reEntryFun = _reEntryFun;\n    }\n\n    modifier reEnter(string memory funName) {\n        string memory _reEntryFun = reEntryFun;\n        if (compareStrings(_reEntryFun, funName)) {\n            reEntryFun = \"\"; // Clear re-entry fun\n            (bool success, bytes memory returndata) = msg.sender.call(reEntryCallData);\n            assembly {\n                if eq(success, 0) {\n                    revert(add(returndata, 0x20), returndatasize())\n                }\n            }\n        }\n\n        _;\n    }\n\n    function compareStrings(string memory a, string memory b) internal pure returns (bool) {\n        return keccak256(abi.encodePacked((a))) == keccak256(abi.encodePacked((b)));\n    }\n\n    function allocateTo(address _owner, uint256 value) public {\n        balanceOf_[_owner] += value;\n        totalSupply_ += value;\n        emit Transfer(address(this), _owner, value);\n    }\n\n    function totalSupply() public reEnter(\"totalSupply\") returns (uint256) {\n        return totalSupply_;\n    }\n\n    function allowance(address owner, address spender) public reEnter(\"allowance\") returns (uint256 remaining) {\n        return allowance_[owner][spender];\n    }\n\n    function approve(address spender, uint256 amount) public reEnter(\"approve\") returns (bool success) {\n        _approve(msg.sender, spender, amount);\n        return true;\n    }\n\n    function balanceOf(address owner) public reEnter(\"balanceOf\") returns (uint256 balance) {\n        return balanceOf_[owner];\n    }\n\n    function transfer(address dst, uint256 amount) public reEnter(\"transfer\") returns (bool success) {\n        _transfer(msg.sender, dst, amount);\n        return true;\n    }\n\n    function transferFrom(\n        address src,\n        address dst,\n        uint256 amount\n    ) public reEnter(\"transferFrom\") returns (bool success) {\n        _transfer(src, dst, amount);\n        _approve(src, msg.sender, allowance_[src][msg.sender].sub(amount));\n        return true;\n    }\n\n    function _approve(address owner, address spender, uint256 amount) internal {\n        require(spender != address(0), \"sender should be valid address\");\n        require(owner != address(0), \"owner should be valid address\");\n        allowance_[owner][spender] = amount;\n        emit Approval(owner, spender, amount);\n    }\n\n    function _transfer(address src, address dst, uint256 amount) internal {\n        require(dst != address(0), \"dst should be valid address\");\n        balanceOf_[src] = balanceOf_[src].sub(amount);\n        balanceOf_[dst] = balanceOf_[dst].add(amount);\n        emit Transfer(src, dst, amount);\n    }\n}\n"
+    },
+    "contracts/test/FeeToken.sol": {
+      "content": "pragma solidity ^0.5.16;\n\nimport \"./FaucetToken.sol\";\n\n/**\n * @title Fee Token\n * @author Venus\n * @notice A simple test token that charges fees on transfer. Used to mock USDT.\n */\ncontract FeeToken is FaucetToken {\n    uint public basisPointFee;\n    address public owner;\n\n    constructor(\n        uint256 _initialAmount,\n        string memory _tokenName,\n        uint8 _decimalUnits,\n        string memory _tokenSymbol,\n        uint _basisPointFee,\n        address _owner\n    ) public FaucetToken(_initialAmount, _tokenName, _decimalUnits, _tokenSymbol) {\n        basisPointFee = _basisPointFee;\n        owner = _owner;\n    }\n\n    function transfer(address dst, uint amount) public returns (bool) {\n        uint fee = amount.mul(basisPointFee).div(10000);\n        uint net = amount.sub(fee);\n        balanceOf[owner] = balanceOf[owner].add(fee);\n        balanceOf[msg.sender] = balanceOf[msg.sender].sub(amount);\n        balanceOf[dst] = balanceOf[dst].add(net);\n        emit Transfer(msg.sender, dst, amount);\n        return true;\n    }\n\n    function transferFrom(address src, address dst, uint amount) public returns (bool) {\n        uint fee = amount.mul(basisPointFee).div(10000);\n        uint net = amount.sub(fee);\n        balanceOf[owner] = balanceOf[owner].add(fee);\n        balanceOf[src] = balanceOf[src].sub(amount);\n        balanceOf[dst] = balanceOf[dst].add(net);\n        allowance[src][msg.sender] = allowance[src][msg.sender].sub(amount);\n        emit Transfer(src, dst, amount);\n        return true;\n    }\n}\n"
+    },
+    "contracts/test/FixedPriceOracle.sol": {
+      "content": "pragma solidity ^0.5.16;\n\nimport \"../Oracle/PriceOracle.sol\";\n\ncontract FixedPriceOracle is PriceOracle {\n    uint public price;\n\n    constructor(uint _price) public {\n        price = _price;\n    }\n\n    function getUnderlyingPrice(address vToken) public view returns (uint) {\n        vToken;\n        return price;\n    }\n\n    function assetPrices(address asset) public view returns (uint) {\n        asset;\n        return price;\n    }\n}\n"
+    },
+    "contracts/test/InterestRateModelHarness.sol": {
+      "content": "pragma solidity ^0.5.16;\n\nimport \"../InterestRateModels/InterestRateModel.sol\";\n\n/**\n * @title An Interest Rate Model for tests that can be instructed to return a failure instead of doing a calculation\n * @author Venus\n */\ncontract InterestRateModelHarness is InterestRateModel {\n    uint public constant opaqueBorrowFailureCode = 20;\n    bool public failBorrowRate;\n    uint public borrowRate;\n\n    constructor(uint borrowRate_) public {\n        borrowRate = borrowRate_;\n    }\n\n    function setFailBorrowRate(bool failBorrowRate_) public {\n        failBorrowRate = failBorrowRate_;\n    }\n\n    function setBorrowRate(uint borrowRate_) public {\n        borrowRate = borrowRate_;\n    }\n\n    function getBorrowRate(uint _cash, uint _borrows, uint _reserves) public view returns (uint) {\n        _cash; // unused\n        _borrows; // unused\n        _reserves; // unused\n        require(!failBorrowRate, \"INTEREST_RATE_MODEL_ERROR\");\n        return borrowRate;\n    }\n\n    function getSupplyRate(\n        uint _cash,\n        uint _borrows,\n        uint _reserves,\n        uint _reserveFactor\n    ) external view returns (uint) {\n        _cash; // unused\n        _borrows; // unused\n        _reserves; // unused\n        return borrowRate * (1 - _reserveFactor);\n    }\n}\n"
+    },
+    "contracts/test/MockDeflationaryToken.sol": {
+      "content": "pragma solidity ^0.5.16;\n\nimport \"../Utils/SafeMath.sol\";\n\ncontract DeflatingERC20 {\n    using SafeMath for uint;\n\n    string public constant name = \"Deflating Test Token\";\n    string public constant symbol = \"DTT\";\n    uint8 public constant decimals = 18;\n    uint public totalSupply;\n    mapping(address => uint) public balanceOf;\n    mapping(address => mapping(address => uint)) public allowance;\n\n    bytes32 public DOMAIN_SEPARATOR;\n    // keccak256(\"Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)\");\n    bytes32 public constant PERMIT_TYPEHASH = 0x6e71edae12b1b97f4d1f60370fef10105fa2faae0126114a169c64845d6126c9;\n    mapping(address => uint) public nonces;\n\n    event Approval(address indexed owner, address indexed spender, uint value);\n    event Transfer(address indexed from, address indexed to, uint value);\n\n    constructor(uint _totalSupply) public {\n        uint chainId;\n        assembly {\n            chainId := chainid()\n        }\n        DOMAIN_SEPARATOR = keccak256(\n            abi.encode(\n                keccak256(\"EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)\"),\n                keccak256(bytes(name)),\n                keccak256(bytes(\"1\")),\n                chainId,\n                address(this)\n            )\n        );\n        _mint(msg.sender, _totalSupply);\n    }\n\n    function _mint(address to, uint value) internal {\n        totalSupply = totalSupply.add(value);\n        balanceOf[to] = balanceOf[to].add(value);\n        emit Transfer(address(0), to, value);\n    }\n\n    function _burn(address from, uint value) internal {\n        balanceOf[from] = balanceOf[from].sub(value);\n        totalSupply = totalSupply.sub(value);\n        emit Transfer(from, address(0), value);\n    }\n\n    function _approve(address owner, address spender, uint value) private {\n        allowance[owner][spender] = value;\n        emit Approval(owner, spender, value);\n    }\n\n    function _transfer(address from, address to, uint value) private {\n        uint burnAmount = value / 100;\n        _burn(from, burnAmount);\n        uint transferAmount = value.sub(burnAmount);\n        balanceOf[from] = balanceOf[from].sub(transferAmount);\n        balanceOf[to] = balanceOf[to].add(transferAmount);\n        emit Transfer(from, to, transferAmount);\n    }\n\n    function approve(address spender, uint value) external returns (bool) {\n        _approve(msg.sender, spender, value);\n        return true;\n    }\n\n    function transfer(address to, uint value) external returns (bool) {\n        _transfer(msg.sender, to, value);\n        return true;\n    }\n\n    function transferFrom(address from, address to, uint value) external returns (bool) {\n        if (allowance[from][msg.sender] != uint(-1)) {\n            allowance[from][msg.sender] = allowance[from][msg.sender].sub(value);\n        }\n        _transfer(from, to, value);\n        return true;\n    }\n\n    function permit(address owner, address spender, uint value, uint deadline, uint8 v, bytes32 r, bytes32 s) external {\n        require(deadline >= block.timestamp, \"EXPIRED\");\n        bytes32 digest = keccak256(\n            abi.encodePacked(\n                \"\\x19\\x01\",\n                DOMAIN_SEPARATOR,\n                keccak256(abi.encode(PERMIT_TYPEHASH, owner, spender, value, nonces[owner]++, deadline))\n            )\n        );\n        address recoveredAddress = ecrecover(digest, v, r, s);\n        require(recoveredAddress != address(0) && recoveredAddress == owner, \"INVALID_SIGNATURE\");\n        _approve(owner, spender, value);\n    }\n}\n"
+    },
+    "contracts/test/VRTConverterHarness.sol": {
+      "content": "pragma solidity ^0.5.16;\n\nimport \"../../contracts/Tokens/VRT/VRTConverter.sol\";\n\ncontract VRTConverterHarness is VRTConverter {\n    constructor() public VRTConverter() {\n        admin = msg.sender;\n    }\n\n    function balanceOfUser() public view returns (uint256, address) {\n        uint256 vrtBalanceOfUser = vrt.balanceOf(msg.sender);\n        return (vrtBalanceOfUser, msg.sender);\n    }\n\n    function setConversionRatio(uint256 _conversionRatio) public onlyAdmin {\n        conversionRatio = _conversionRatio;\n    }\n\n    function setConversionTimeline(uint256 _conversionStartTime, uint256 _conversionPeriod) public onlyAdmin {\n        conversionStartTime = _conversionStartTime;\n        conversionPeriod = _conversionPeriod;\n        conversionEndTime = conversionStartTime.add(conversionPeriod);\n    }\n\n    function getXVSRedeemedAmount(uint256 vrtAmount) public view returns (uint256) {\n        return vrtAmount.mul(conversionRatio).mul(xvsDecimalsMultiplier).div(1e18).div(vrtDecimalsMultiplier);\n    }\n}\n"
+    },
+    "contracts/test/VRTVaultHarness.sol": {
+      "content": "pragma solidity ^0.5.16;\n\nimport \"../../contracts/VRTVault/VRTVault.sol\";\n\ncontract VRTVaultHarness is VRTVault {\n    uint public blockNumber;\n\n    constructor() public VRTVault() {}\n\n    function overrideInterestRatePerBlock(uint256 _interestRatePerBlock) public {\n        interestRatePerBlock = _interestRatePerBlock;\n    }\n\n    function balanceOfUser() public view returns (uint256, address) {\n        uint256 vrtBalanceOfUser = vrt.balanceOf(msg.sender);\n        return (vrtBalanceOfUser, msg.sender);\n    }\n\n    function harnessFastForward(uint256 blocks) public returns (uint256) {\n        blockNumber += blocks;\n        return blockNumber;\n    }\n\n    function setBlockNumber(uint256 number) public {\n        blockNumber = number;\n    }\n\n    function getBlockNumber() public view returns (uint256) {\n        return blockNumber;\n    }\n}\n"
+    },
+    "contracts/test/XVSVaultScenario.sol": {
+      "content": "pragma solidity ^0.5.16;\npragma experimental ABIEncoderV2;\n\nimport \"../XVSVault/XVSVault.sol\";\n\ncontract XVSVaultScenario is XVSVault {\n    using SafeMath for uint256;\n\n    constructor() public {\n        admin = msg.sender;\n    }\n\n    function pushOldWithdrawalRequest(\n        UserInfo storage _user,\n        WithdrawalRequest[] storage _requests,\n        uint _amount,\n        uint _lockedUntil\n    ) internal {\n        uint i = _requests.length;\n        _requests.push(WithdrawalRequest(0, 0, 0));\n        // Keep it sorted so that the first to get unlocked request is always at the end\n        for (; i > 0 && _requests[i - 1].lockedUntil <= _lockedUntil; --i) {\n            _requests[i] = _requests[i - 1];\n        }\n        _requests[i] = WithdrawalRequest(_amount, uint128(_lockedUntil), 0);\n        _user.pendingWithdrawals = _user.pendingWithdrawals.add(_amount);\n    }\n\n    function requestOldWithdrawal(address _rewardToken, uint256 _pid, uint256 _amount) external nonReentrant {\n        _ensureValidPool(_rewardToken, _pid);\n        require(_amount > 0, \"requested amount cannot be zero\");\n        UserInfo storage user = userInfos[_rewardToken][_pid][msg.sender];\n        require(user.amount >= user.pendingWithdrawals.add(_amount), \"requested amount is invalid\");\n\n        PoolInfo storage pool = poolInfos[_rewardToken][_pid];\n        WithdrawalRequest[] storage requests = withdrawalRequests[_rewardToken][_pid][msg.sender];\n        uint lockedUntil = pool.lockPeriod.add(block.timestamp);\n\n        pushOldWithdrawalRequest(user, requests, _amount, lockedUntil);\n\n        // Update Delegate Amount\n        if (_rewardToken == address(xvsAddress)) {\n            _moveDelegates(delegates[msg.sender], address(0), uint96(_amount));\n        }\n\n        emit RequestedWithdrawal(msg.sender, _rewardToken, _pid, _amount);\n    }\n\n    function transferReward(address rewardToken, address user, uint256 amount) external {\n        _transferReward(rewardToken, user, amount);\n    }\n}\n"
+    },
+    "contracts/test/XVSVestingHarness.sol": {
+      "content": "pragma solidity ^0.5.16;\n\nimport \"../../contracts/Tokens/XVS/XVSVesting.sol\";\n\ncontract XVSVestingHarness is XVSVesting {\n    address public constant ZERO_ADDRESS = 0x0000000000000000000000000000000000000000;\n\n    constructor() public XVSVesting() {\n        admin = msg.sender;\n    }\n\n    uint public blockNumber;\n\n    function recoverXVS(address recoveryAddress) public payable {\n        uint256 xvsBalance = xvs.balanceOf(address(this));\n        xvs.safeTransferFrom(address(this), recoveryAddress, xvsBalance);\n    }\n\n    function overWriteVRTConversionAddress() public {\n        vrtConversionAddress = ZERO_ADDRESS;\n    }\n\n    function computeWithdrawableAmount(\n        uint256 amount,\n        uint256 vestingStartTime,\n        uint256 withdrawnAmount\n    ) public view returns (uint256 vestedAmount, uint256 toWithdraw) {\n        (vestedAmount, toWithdraw) = super.calculateWithdrawableAmount(amount, vestingStartTime, withdrawnAmount);\n        return (vestedAmount, toWithdraw);\n    }\n\n    function computeVestedAmount(\n        uint256 vestingAmount,\n        uint256 vestingStartTime,\n        uint256 currentTime\n    ) public view returns (uint256) {\n        return super.calculateVestedAmount(vestingAmount, vestingStartTime, currentTime);\n    }\n\n    function getVestingCount(address beneficiary) public view returns (uint256) {\n        return vestings[beneficiary].length;\n    }\n\n    function getVestedAmount(address recipient) public view nonZeroAddress(recipient) returns (uint256) {\n        VestingRecord[] memory vestingsOfRecipient = vestings[recipient];\n        uint256 vestingCount = vestingsOfRecipient.length;\n        uint256 totalVestedAmount = 0;\n        uint256 currentTime = getCurrentTime();\n\n        for (uint i = 0; i < vestingCount; i++) {\n            VestingRecord memory vesting = vestingsOfRecipient[i];\n            uint256 vestedAmount = calculateVestedAmount(vesting.amount, vesting.startTime, currentTime);\n            totalVestedAmount = totalVestedAmount.add(vestedAmount);\n        }\n\n        return totalVestedAmount;\n    }\n}\n"
+    },
+    "contracts/Tokens/EIP20Interface.sol": {
+      "content": "pragma solidity ^0.5.16;\n\n/**\n * @title BEP 20 Token Standard Interface\n *  https://eips.ethereum.org/EIPS/eip-20\n */\ninterface EIP20Interface {\n    function name() external view returns (string memory);\n\n    function symbol() external view returns (string memory);\n\n    function decimals() external view returns (uint8);\n\n    /**\n     * @notice Get the total number of tokens in circulation\n     * @return The supply of tokens\n     */\n    function totalSupply() external view returns (uint256);\n\n    /**\n     * @notice Gets the balance of the specified address\n     * @param owner The address from which the balance will be retrieved\n     * @return balance\n     */\n    function balanceOf(address owner) external view returns (uint256 balance);\n\n    /**\n     * @notice Transfer `amount` tokens from `msg.sender` to `dst`\n     * @param dst The address of the destination account\n     * @param amount The number of tokens to transfer\n     * @return success whether or not the transfer succeeded\n     */\n    function transfer(address dst, uint256 amount) external returns (bool success);\n\n    /**\n     * @notice Transfer `amount` tokens from `src` to `dst`\n     * @param src The address of the source account\n     * @param dst The address of the destination account\n     * @param amount The number of tokens to transfer\n     * @return success whether or not the transfer succeeded\n     */\n    function transferFrom(address src, address dst, uint256 amount) external returns (bool success);\n\n    /**\n     * @notice Approve `spender` to transfer up to `amount` from `src`\n     * @dev This will overwrite the approval amount for `spender`\n     * @param spender The address of the account which may transfer tokens\n     * @param amount The number of tokens that are approved (-1 means infinite)\n     * @return success whether or not the approval succeeded\n     */\n    function approve(address spender, uint256 amount) external returns (bool success);\n\n    /**\n     * @notice Get the current allowance from `owner` for `spender`\n     * @param owner The address of the account which owns the tokens to be spent\n     * @param spender The address of the account which may transfer tokens\n     * @return remaining The number of tokens allowed to be spent\n     */\n    function allowance(address owner, address spender) external view returns (uint256 remaining);\n\n    event Transfer(address indexed from, address indexed to, uint256 amount);\n    event Approval(address indexed owner, address indexed spender, uint256 amount);\n}\n"
+    },
+    "contracts/Tokens/EIP20NonStandardInterface.sol": {
+      "content": "pragma solidity ^0.5.16;\n\n/**\n * @title EIP20NonStandardInterface\n * @dev Version of BEP20 with no return values for `transfer` and `transferFrom`\n *  See https://medium.com/coinmonks/missing-return-value-bug-at-least-130-tokens-affected-d67bf08521ca\n */\ninterface EIP20NonStandardInterface {\n    /**\n     * @notice Get the total number of tokens in circulation\n     * @return The supply of tokens\n     */\n    function totalSupply() external view returns (uint256);\n\n    /**\n     * @notice Gets the balance of the specified address\n     * @param owner The address from which the balance will be retrieved\n     * @return balance of the owner\n     */\n    function balanceOf(address owner) external view returns (uint256 balance);\n\n    ///\n    /// !!!!!!!!!!!!!!\n    /// !!! NOTICE !!! `transfer` does not return a value, in violation of the BEP-20 specification\n    /// !!!!!!!!!!!!!!\n    ///\n\n    /**\n     * @notice Transfer `amount` tokens from `msg.sender` to `dst`\n     * @param dst The address of the destination account\n     * @param amount The number of tokens to transfer\n     */\n    function transfer(address dst, uint256 amount) external;\n\n    ///\n    /// !!!!!!!!!!!!!!\n    /// !!! NOTICE !!! `transferFrom` does not return a value, in violation of the BEP-20 specification\n    /// !!!!!!!!!!!!!!\n    ///\n\n    /**\n     * @notice Transfer `amount` tokens from `src` to `dst`\n     * @param src The address of the source account\n     * @param dst The address of the destination account\n     * @param amount The number of tokens to transfer\n     */\n    function transferFrom(address src, address dst, uint256 amount) external;\n\n    /**\n     * @notice Approve `spender` to transfer up to `amount` from `src`\n     * @dev This will overwrite the approval amount for `spender`\n     * @param spender The address of the account which may transfer tokens\n     * @param amount The number of tokens that are approved\n     * @return success Whether or not the approval succeeded\n     */\n    function approve(address spender, uint256 amount) external returns (bool success);\n\n    /**\n     * @notice Get the current allowance from `owner` for `spender`\n     * @param owner The address of the account which owns the tokens to be spent\n     * @param spender The address of the account which may transfer tokens\n     * @return remaining The number of tokens allowed to be spent\n     */\n    function allowance(address owner, address spender) external view returns (uint256 remaining);\n\n    event Transfer(address indexed from, address indexed to, uint256 amount);\n    event Approval(address indexed owner, address indexed spender, uint256 amount);\n}\n"
+    },
+    "contracts/Tokens/Prime/IPrimeV5.sol": {
+      "content": "// SPDX-License-Identifier: BSD-3-Clause\npragma solidity ^0.5.16;\npragma experimental ABIEncoderV2;\n\n/**\n * @title IPrimeV5\n * @author Venus\n * @notice Interface for Prime Token\n */\ninterface IPrimeV5 {\n    /**\n     * @notice Executed by XVSVault whenever user's XVSVault balance changes\n     * @param user the account address whose balance was updated\n     */\n    function xvsUpdated(address user) external;\n\n    /**\n     * @notice accrues interest and updates score for an user for a specific market\n     * @param user the account address for which to accrue interest and update score\n     * @param market the market for which to accrue interest and update score\n     */\n    function accrueInterestAndUpdateScore(address user, address market) external;\n\n    /**\n     * @notice Distributes income from market since last distribution\n     * @param vToken the market for which to distribute the income\n     */\n    function accrueInterest(address vToken) external;\n\n    /**\n     * @notice Returns if user is a prime holder\n     * @param isPrimeHolder returns if the user is a prime holder\n     */\n    function isUserPrimeHolder(address user) external view returns (bool isPrimeHolder);\n}\n"
+    },
+    "contracts/Tokens/VRT/VRTConverter.sol": {
+      "content": "pragma solidity ^0.5.16;\n\nimport \"../../Utils/IBEP20.sol\";\nimport \"../../Utils/SafeBEP20.sol\";\nimport \"../XVS/IXVSVesting.sol\";\nimport \"./VRTConverterStorage.sol\";\nimport \"./VRTConverterProxy.sol\";\n\n/**\n * @title Venus's VRTConversion Contract\n * @author Venus\n */\ncontract VRTConverter is VRTConverterStorage {\n    using SafeMath for uint256;\n    using SafeBEP20 for IBEP20;\n\n    address public constant DEAD_ADDRESS = 0x000000000000000000000000000000000000dEaD;\n\n    /// @notice decimal precision for VRT\n    uint256 public constant vrtDecimalsMultiplier = 1e18;\n\n    /// @notice decimal precision for XVS\n    uint256 public constant xvsDecimalsMultiplier = 1e18;\n\n    /// @notice Emitted when an admin set conversion info\n    event ConversionInfoSet(\n        uint256 conversionRatio,\n        uint256 conversionStartTime,\n        uint256 conversionPeriod,\n        uint256 conversionEndTime\n    );\n\n    /// @notice Emitted when token conversion is done\n    event TokenConverted(\n        address reedeemer,\n        address vrtAddress,\n        uint256 vrtAmount,\n        address xvsAddress,\n        uint256 xvsAmount\n    );\n\n    /// @notice Emitted when an admin withdraw converted token\n    event TokenWithdraw(address token, address to, uint256 amount);\n\n    /// @notice Emitted when XVSVestingAddress is set\n    event XVSVestingSet(address xvsVestingAddress);\n\n    constructor() public {}\n\n    function initialize(\n        address _vrtAddress,\n        address _xvsAddress,\n        uint256 _conversionRatio,\n        uint256 _conversionStartTime,\n        uint256 _conversionPeriod\n    ) public {\n        require(msg.sender == admin, \"only admin may initialize the VRTConverter\");\n        require(initialized == false, \"VRTConverter is already initialized\");\n\n        require(_vrtAddress != address(0), \"vrtAddress cannot be Zero\");\n        vrt = IBEP20(_vrtAddress);\n\n        require(_xvsAddress != address(0), \"xvsAddress cannot be Zero\");\n        xvs = IBEP20(_xvsAddress);\n\n        require(_conversionRatio > 0, \"conversionRatio cannot be Zero\");\n        conversionRatio = _conversionRatio;\n\n        require(_conversionStartTime >= block.timestamp, \"conversionStartTime must be time in the future\");\n        require(_conversionPeriod > 0, \"_conversionPeriod is invalid\");\n\n        conversionStartTime = _conversionStartTime;\n        conversionPeriod = _conversionPeriod;\n        conversionEndTime = conversionStartTime.add(conversionPeriod);\n        emit ConversionInfoSet(conversionRatio, conversionStartTime, conversionPeriod, conversionEndTime);\n\n        totalVrtConverted = 0;\n        _notEntered = true;\n        initialized = true;\n    }\n\n    /**\n     * @dev Prevents a contract from calling itself, directly or indirectly.\n     */\n    modifier nonReentrant() {\n        require(_notEntered, \"re-entered\");\n        _notEntered = false;\n        _;\n        _notEntered = true; // get a gas-refund post-Istanbul\n    }\n\n    /**\n     * @notice sets XVSVestingProxy Address\n     * @dev Note: If XVSVestingProxy is not set, then Conversion is not allowed\n     * @param _xvsVestingAddress The XVSVestingProxy Address\n     */\n    function setXVSVesting(address _xvsVestingAddress) public {\n        require(msg.sender == admin, \"only admin may initialize the Vault\");\n        require(_xvsVestingAddress != address(0), \"xvsVestingAddress cannot be Zero\");\n        xvsVesting = IXVSVesting(_xvsVestingAddress);\n        emit XVSVestingSet(_xvsVestingAddress);\n    }\n\n    modifier isInitialized() {\n        require(initialized == true, \"VRTConverter is not initialized\");\n        _;\n    }\n\n    function isConversionActive() public view returns (bool) {\n        uint256 currentTime = block.timestamp;\n        if (currentTime >= conversionStartTime && currentTime <= conversionEndTime) {\n            return true;\n        }\n        return false;\n    }\n\n    modifier checkForActiveConversionPeriod() {\n        uint256 currentTime = block.timestamp;\n        require(currentTime >= conversionStartTime, \"Conversion did not start yet\");\n        require(currentTime <= conversionEndTime, \"Conversion Period Ended\");\n        _;\n    }\n\n    modifier onlyAdmin() {\n        require(msg.sender == admin, \"only admin can\");\n        _;\n    }\n\n    modifier nonZeroAddress(address _address) {\n        require(_address != address(0), \"Address cannot be Zero\");\n        _;\n    }\n\n    /**\n     * @notice Transfer VRT and redeem XVS\n     * @dev Note: If there is not enough XVS, we do not perform the conversion.\n     * @param vrtAmount The amount of VRT\n     */\n    function convert(uint256 vrtAmount) external isInitialized checkForActiveConversionPeriod nonReentrant {\n        require(\n            address(xvsVesting) != address(0) && address(xvsVesting) != DEAD_ADDRESS,\n            \"XVS-Vesting Address is not set\"\n        );\n        require(vrtAmount > 0, \"VRT amount must be non-zero\");\n        totalVrtConverted = totalVrtConverted.add(vrtAmount);\n\n        uint256 redeemAmount = vrtAmount.mul(conversionRatio).mul(xvsDecimalsMultiplier).div(1e18).div(\n            vrtDecimalsMultiplier\n        );\n\n        emit TokenConverted(msg.sender, address(vrt), vrtAmount, address(xvs), redeemAmount);\n        vrt.safeTransferFrom(msg.sender, DEAD_ADDRESS, vrtAmount);\n        xvsVesting.deposit(msg.sender, redeemAmount);\n    }\n\n    /*** Admin Functions ***/\n    function _become(VRTConverterProxy vrtConverterProxy) public {\n        require(msg.sender == vrtConverterProxy.admin(), \"only proxy admin can change brains\");\n        vrtConverterProxy._acceptImplementation();\n    }\n}\n"
+    },
+    "contracts/Tokens/VRT/VRTConverterProxy.sol": {
+      "content": "pragma solidity ^0.5.16;\n\nimport \"./VRTConverterStorage.sol\";\n\ncontract VRTConverterProxy is VRTConverterAdminStorage {\n    /**\n     * @notice Emitted when pendingImplementation is changed\n     */\n    event NewPendingImplementation(address oldPendingImplementation, address newPendingImplementation);\n\n    /**\n     * @notice Emitted when pendingImplementation is accepted, which means VRTConverter implementation is updated\n     */\n    event NewImplementation(address oldImplementation, address newImplementation);\n\n    /**\n     * @notice Emitted when pendingAdmin is changed\n     */\n    event NewPendingAdmin(address oldPendingAdmin, address newPendingAdmin);\n\n    /**\n     * @notice Emitted when pendingAdmin is accepted, which means admin is updated\n     */\n    event NewAdmin(address oldAdmin, address newAdmin);\n\n    constructor(\n        address implementation_,\n        address _vrtAddress,\n        address _xvsAddress,\n        uint256 _conversionRatio,\n        uint256 _conversionStartTime,\n        uint256 _conversionPeriod\n    ) public nonZeroAddress(implementation_) nonZeroAddress(_vrtAddress) nonZeroAddress(_xvsAddress) {\n        // Creator of the contract is admin during initialization\n        admin = msg.sender;\n\n        // New implementations always get set via the settor (post-initialize)\n        _setImplementation(implementation_);\n\n        // First delegate gets to initialize the delegator (i.e. storage contract)\n        delegateTo(\n            implementation_,\n            abi.encodeWithSignature(\n                \"initialize(address,address,uint256,uint256,uint256)\",\n                _vrtAddress,\n                _xvsAddress,\n                _conversionRatio,\n                _conversionStartTime,\n                _conversionPeriod\n            )\n        );\n    }\n\n    modifier nonZeroAddress(address _address) {\n        require(_address != address(0), \"Address cannot be Zero\");\n        _;\n    }\n\n    /**\n     * @notice Called by the admin to update the implementation of the delegator\n     * @param implementation_ The address of the new implementation for delegation\n     */\n    function _setImplementation(address implementation_) public {\n        require(msg.sender == admin, \"VRTConverterProxy::_setImplementation: admin only\");\n        require(implementation_ != address(0), \"VRTConverterProxy::_setImplementation: invalid implementation address\");\n\n        address oldImplementation = implementation;\n        implementation = implementation_;\n\n        emit NewImplementation(oldImplementation, implementation);\n    }\n\n    /**\n     * @notice Internal method to delegate execution to another contract\n     * @dev It returns to the external caller whatever the implementation returns or forwards reverts\n     * @param callee The contract to delegatecall\n     * @param data The raw data to delegatecall\n     * @return The returned bytes from the delegatecall\n     */\n    function delegateTo(address callee, bytes memory data) internal nonZeroAddress(callee) returns (bytes memory) {\n        (bool success, bytes memory returnData) = callee.delegatecall(data);\n        assembly {\n            if eq(success, 0) {\n                revert(add(returnData, 0x20), returndatasize)\n            }\n        }\n        return returnData;\n    }\n\n    /*** Admin Functions ***/\n    function _setPendingImplementation(\n        address newPendingImplementation\n    ) public nonZeroAddress(newPendingImplementation) {\n        require(msg.sender == admin, \"Only admin can set Pending Implementation\");\n\n        address oldPendingImplementation = pendingImplementation;\n\n        pendingImplementation = newPendingImplementation;\n\n        emit NewPendingImplementation(oldPendingImplementation, pendingImplementation);\n    }\n\n    /**\n     * @notice Accepts new implementation of VRTConverter. msg.sender must be pendingImplementation\n     * @dev Admin function for new implementation to accept it's role as implementation\n     * @dev return uint 0=success, otherwise a failure (see ErrorReporter.sol for details)\n     */\n    function _acceptImplementation() public {\n        // Check caller is pendingImplementation\n        require(\n            msg.sender == pendingImplementation,\n            \"only address marked as pendingImplementation can accept Implementation\"\n        );\n\n        // Save current values for inclusion in log\n        address oldImplementation = implementation;\n        address oldPendingImplementation = pendingImplementation;\n\n        implementation = pendingImplementation;\n\n        pendingImplementation = address(0);\n\n        emit NewImplementation(oldImplementation, implementation);\n        emit NewPendingImplementation(oldPendingImplementation, pendingImplementation);\n    }\n\n    /**\n     * @notice Begins transfer of admin rights. The newPendingAdmin must call `_acceptAdmin` to finalize the transfer.\n     * @dev Admin function to begin change of admin. The newPendingAdmin must call `_acceptAdmin` to finalize the transfer.\n     * @param newPendingAdmin New pending admin.\n     * @dev return uint 0=success, otherwise a failure (see ErrorReporter.sol for details)\n     */\n    function _setPendingAdmin(address newPendingAdmin) public nonZeroAddress(newPendingAdmin) {\n        // Check caller = admin\n        require(msg.sender == admin, \"only admin can set pending admin\");\n        require(newPendingAdmin != pendingAdmin, \"New pendingAdmin can not be same as the previous one\");\n\n        // Save current value, if any, for inclusion in log\n        address oldPendingAdmin = pendingAdmin;\n\n        // Store pendingAdmin with value newPendingAdmin\n        pendingAdmin = newPendingAdmin;\n\n        // Emit NewPendingAdmin(oldPendingAdmin, newPendingAdmin)\n        emit NewPendingAdmin(oldPendingAdmin, newPendingAdmin);\n    }\n\n    /**\n     * @notice Accepts transfer of admin rights. msg.sender must be pendingAdmin\n     * @dev Admin function for pending admin to accept role and update admin\n     * @dev return uint 0=success, otherwise a failure (see ErrorReporter.sol for details)\n     */\n    function _acceptAdmin() public {\n        // Check caller is pendingAdmin\n        require(msg.sender == pendingAdmin, \"only address marked as pendingAdmin can accept as Admin\");\n\n        // Save current values for inclusion in log\n        address oldAdmin = admin;\n        address oldPendingAdmin = pendingAdmin;\n\n        // Store admin with value pendingAdmin\n        admin = pendingAdmin;\n\n        // Clear the pending value\n        pendingAdmin = address(0);\n\n        emit NewAdmin(oldAdmin, admin);\n        emit NewPendingAdmin(oldPendingAdmin, pendingAdmin);\n    }\n\n    /**\n     * @dev Delegates execution to an implementation contract.\n     * It returns to the external caller whatever the implementation returns\n     * or forwards reverts.\n     */\n    function() external payable {\n        // delegate all other functions to current implementation\n        (bool success, ) = implementation.delegatecall(msg.data);\n\n        assembly {\n            let free_mem_ptr := mload(0x40)\n            returndatacopy(free_mem_ptr, 0, returndatasize)\n\n            switch success\n            case 0 {\n                revert(free_mem_ptr, returndatasize)\n            }\n            default {\n                return(free_mem_ptr, returndatasize)\n            }\n        }\n    }\n}\n"
+    },
+    "contracts/Tokens/VRT/VRTConverterStorage.sol": {
+      "content": "pragma solidity ^0.5.16;\n\nimport \"../../Utils/SafeMath.sol\";\nimport \"../../Utils/IBEP20.sol\";\nimport \"../XVS/IXVSVesting.sol\";\n\ncontract VRTConverterAdminStorage {\n    /**\n     * @notice Administrator for this contract\n     */\n    address public admin;\n\n    /**\n     * @notice Pending administrator for this contract\n     */\n    address public pendingAdmin;\n\n    /**\n     * @notice Active brains of VRTConverter\n     */\n    address public implementation;\n\n    /**\n     * @notice Pending brains of VRTConverter\n     */\n    address public pendingImplementation;\n}\n\ncontract VRTConverterStorage is VRTConverterAdminStorage {\n    /// @notice Guard variable for re-entrancy checks\n    bool public _notEntered;\n\n    /// @notice indicator to check if the contract is initialized\n    bool public initialized;\n\n    /// @notice The VRT TOKEN!\n    IBEP20 public vrt;\n\n    /// @notice The XVS TOKEN!\n    IBEP20 public xvs;\n\n    /// @notice XVSVesting Contract reference\n    IXVSVesting public xvsVesting;\n\n    /// @notice Conversion ratio from VRT to XVS with decimal 18\n    uint256 public conversionRatio;\n\n    /// @notice total VRT converted to XVS\n    uint256 public totalVrtConverted;\n\n    /// @notice Conversion Start time in EpochSeconds\n    uint256 public conversionStartTime;\n\n    /// @notice ConversionPeriod in Seconds\n    uint256 public conversionPeriod;\n\n    /// @notice Conversion End time in EpochSeconds\n    uint256 public conversionEndTime;\n}\n"
+    },
+    "contracts/Tokens/VTokens/legacy/ComptrollerInterface.sol": {
+      "content": "pragma solidity ^0.5.16;\n\nimport \"./VTokenR1.sol\";\nimport \"../../../Oracle/PriceOracle.sol\";\n\ncontract ComptrollerInterface {\n    enum Action {\n        MINT,\n        REDEEM,\n        BORROW,\n        REPAY,\n        SEIZE,\n        LIQUIDATE,\n        TRANSFER,\n        ENTER_MARKET,\n        EXIT_MARKET\n    }\n\n    /// @notice Indicator that this is a Comptroller contract (for inspection)\n    bool public constant isComptroller = true;\n\n    /*** Assets You Are In ***/\n\n    function enterMarkets(address[] calldata vTokens) external returns (uint[] memory);\n\n    function exitMarket(address vToken) external returns (uint);\n\n    /*** Policy Hooks ***/\n\n    function mintAllowed(address vToken, address minter, uint mintAmount) external returns (uint);\n\n    function mintVerify(address vToken, address minter, uint mintAmount, uint mintTokens) external;\n\n    function redeemAllowed(address vToken, address redeemer, uint redeemTokens) external returns (uint);\n\n    function redeemVerify(address vToken, address redeemer, uint redeemAmount, uint redeemTokens) external;\n\n    function borrowAllowed(address vToken, address borrower, uint borrowAmount) external returns (uint);\n\n    function borrowVerify(address vToken, address borrower, uint borrowAmount) external;\n\n    function repayBorrowAllowed(\n        address vToken,\n        address payer,\n        address borrower,\n        uint repayAmount\n    ) external returns (uint);\n\n    function repayBorrowVerify(\n        address vToken,\n        address payer,\n        address borrower,\n        uint repayAmount,\n        uint borrowerIndex\n    ) external;\n\n    function liquidateBorrowAllowed(\n        address vTokenBorrowed,\n        address vTokenCollateral,\n        address liquidator,\n        address borrower,\n        uint repayAmount\n    ) external returns (uint);\n\n    function liquidateBorrowVerify(\n        address vTokenBorrowed,\n        address vTokenCollateral,\n        address liquidator,\n        address borrower,\n        uint repayAmount,\n        uint seizeTokens\n    ) external;\n\n    function seizeAllowed(\n        address vTokenCollateral,\n        address vTokenBorrowed,\n        address liquidator,\n        address borrower,\n        uint seizeTokens\n    ) external returns (uint);\n\n    function seizeVerify(\n        address vTokenCollateral,\n        address vTokenBorrowed,\n        address liquidator,\n        address borrower,\n        uint seizeTokens\n    ) external;\n\n    function transferAllowed(address vToken, address src, address dst, uint transferTokens) external returns (uint);\n\n    function transferVerify(address vToken, address src, address dst, uint transferTokens) external;\n\n    /*** Liquidity/Liquidation Calculations ***/\n\n    function liquidateCalculateSeizeTokens(\n        address vTokenBorrowed,\n        address vTokenCollateral,\n        uint repayAmount\n    ) external view returns (uint, uint);\n\n    function setMintedVAIOf(address owner, uint amount) external returns (uint);\n\n    function liquidateVAICalculateSeizeTokens(\n        address vTokenCollateral,\n        uint repayAmount\n    ) external view returns (uint, uint);\n\n    function getXVSAddress() public view returns (address);\n\n    function markets(address) external view returns (bool, uint);\n\n    function oracle() external view returns (PriceOracle);\n\n    function getAccountLiquidity(address) external view returns (uint, uint, uint);\n\n    function getAssetsIn(address) external view returns (VTokenR1[] memory);\n\n    function claimVenus(address) external;\n\n    function venusAccrued(address) external view returns (uint);\n\n    function venusSupplySpeeds(address) external view returns (uint);\n\n    function venusBorrowSpeeds(address) external view returns (uint);\n\n    function getAllMarkets() external view returns (VTokenR1[] memory);\n\n    function venusSupplierIndex(address, address) external view returns (uint);\n\n    function venusInitialIndex() external view returns (uint224);\n\n    function venusBorrowerIndex(address, address) external view returns (uint);\n\n    function venusBorrowState(address) external view returns (uint224, uint32);\n\n    function venusSupplyState(address) external view returns (uint224, uint32);\n\n    function approvedDelegates(address borrower, address delegate) external view returns (bool);\n\n    function vaiController() external view returns (address);\n\n    function liquidationIncentiveMantissa() external view returns (uint);\n\n    function protocolPaused() external view returns (bool);\n\n    function actionPaused(address market, Action action) public view returns (bool);\n\n    function mintedVAIs(address user) external view returns (uint);\n\n    function vaiMintRate() external view returns (uint);\n}\n\ninterface IVAIVault {\n    function updatePendingRewards() external;\n}\n\ninterface IComptroller {\n    function liquidationIncentiveMantissa() external view returns (uint);\n\n    /*** Treasury Data ***/\n    function treasuryAddress() external view returns (address);\n\n    function treasuryPercent() external view returns (uint);\n}\n"
+    },
+    "contracts/Tokens/VTokens/legacy/IProtocolShareReserveV5.sol": {
+      "content": "pragma solidity ^0.5.16;\n\ninterface IProtocolShareReserveV5 {\n    enum IncomeType {\n        SPREAD,\n        LIQUIDATION\n    }\n\n    function updateAssetsState(address comptroller, address asset, IncomeType kind) external;\n}\n"
+    },
+    "contracts/Tokens/VTokens/legacy/Utils/CarefulMath.sol": {
+      "content": "pragma solidity ^0.5.16;\n\n/**\n * @title Careful Math\n * @author Venus\n * @notice Derived from OpenZeppelin's SafeMath library\n *         https://github.com/OpenZeppelin/openzeppelin-solidity/blob/master/contracts/math/SafeMath.sol\n */\ncontract CarefulMath {\n    /**\n     * @dev Possible error codes that we can return\n     */\n    enum MathError {\n        NO_ERROR,\n        DIVISION_BY_ZERO,\n        INTEGER_OVERFLOW,\n        INTEGER_UNDERFLOW\n    }\n\n    /**\n     * @dev Multiplies two numbers, returns an error on overflow.\n     */\n    function mulUInt(uint a, uint b) internal pure returns (MathError, uint) {\n        if (a == 0) {\n            return (MathError.NO_ERROR, 0);\n        }\n\n        uint c = a * b;\n\n        if (c / a != b) {\n            return (MathError.INTEGER_OVERFLOW, 0);\n        } else {\n            return (MathError.NO_ERROR, c);\n        }\n    }\n\n    /**\n     * @dev Integer division of two numbers, truncating the quotient.\n     */\n    function divUInt(uint a, uint b) internal pure returns (MathError, uint) {\n        if (b == 0) {\n            return (MathError.DIVISION_BY_ZERO, 0);\n        }\n\n        return (MathError.NO_ERROR, a / b);\n    }\n\n    /**\n     * @dev Subtracts two numbers, returns an error on overflow (i.e. if subtrahend is greater than minuend).\n     */\n    function subUInt(uint a, uint b) internal pure returns (MathError, uint) {\n        if (b <= a) {\n            return (MathError.NO_ERROR, a - b);\n        } else {\n            return (MathError.INTEGER_UNDERFLOW, 0);\n        }\n    }\n\n    /**\n     * @dev Adds two numbers, returns an error on overflow.\n     */\n    function addUInt(uint a, uint b) internal pure returns (MathError, uint) {\n        uint c = a + b;\n\n        if (c >= a) {\n            return (MathError.NO_ERROR, c);\n        } else {\n            return (MathError.INTEGER_OVERFLOW, 0);\n        }\n    }\n\n    /**\n     * @dev add a and b and then subtract c\n     */\n    function addThenSubUInt(uint a, uint b, uint c) internal pure returns (MathError, uint) {\n        (MathError err0, uint sum) = addUInt(a, b);\n\n        if (err0 != MathError.NO_ERROR) {\n            return (err0, 0);\n        }\n\n        return subUInt(sum, c);\n    }\n}\n"
+    },
+    "contracts/Tokens/VTokens/legacy/Utils/ErrorReporter.sol": {
+      "content": "pragma solidity ^0.5.16;\n\ncontract ComptrollerErrorReporter {\n    enum Error {\n        NO_ERROR,\n        UNAUTHORIZED,\n        COMPTROLLER_MISMATCH,\n        INSUFFICIENT_SHORTFALL,\n        INSUFFICIENT_LIQUIDITY,\n        INVALID_CLOSE_FACTOR,\n        INVALID_COLLATERAL_FACTOR,\n        INVALID_LIQUIDATION_INCENTIVE,\n        MARKET_NOT_ENTERED, // no longer possible\n        MARKET_NOT_LISTED,\n        MARKET_ALREADY_LISTED,\n        MATH_ERROR,\n        NONZERO_BORROW_BALANCE,\n        PRICE_ERROR,\n        REJECTION,\n        SNAPSHOT_ERROR,\n        TOO_MANY_ASSETS,\n        TOO_MUCH_REPAY,\n        INSUFFICIENT_BALANCE_FOR_VAI,\n        MARKET_NOT_COLLATERAL\n    }\n\n    enum FailureInfo {\n        ACCEPT_ADMIN_PENDING_ADMIN_CHECK,\n        ACCEPT_PENDING_IMPLEMENTATION_ADDRESS_CHECK,\n        EXIT_MARKET_BALANCE_OWED,\n        EXIT_MARKET_REJECTION,\n        SET_CLOSE_FACTOR_OWNER_CHECK,\n        SET_CLOSE_FACTOR_VALIDATION,\n        SET_COLLATERAL_FACTOR_OWNER_CHECK,\n        SET_COLLATERAL_FACTOR_NO_EXISTS,\n        SET_COLLATERAL_FACTOR_VALIDATION,\n        SET_COLLATERAL_FACTOR_WITHOUT_PRICE,\n        SET_IMPLEMENTATION_OWNER_CHECK,\n        SET_LIQUIDATION_INCENTIVE_OWNER_CHECK,\n        SET_LIQUIDATION_INCENTIVE_VALIDATION,\n        SET_MAX_ASSETS_OWNER_CHECK,\n        SET_PENDING_ADMIN_OWNER_CHECK,\n        SET_PENDING_IMPLEMENTATION_OWNER_CHECK,\n        SET_PRICE_ORACLE_OWNER_CHECK,\n        SUPPORT_MARKET_EXISTS,\n        SUPPORT_MARKET_OWNER_CHECK,\n        SET_PAUSE_GUARDIAN_OWNER_CHECK,\n        SET_VAI_MINT_RATE_CHECK,\n        SET_VAICONTROLLER_OWNER_CHECK,\n        SET_MINTED_VAI_REJECTION,\n        SET_TREASURY_OWNER_CHECK,\n        UNLIST_MARKET_NOT_LISTED\n    }\n\n    /**\n     * @dev `error` corresponds to enum Error; `info` corresponds to enum FailureInfo, and `detail` is an arbitrary\n     * contract-specific code that enables us to report opaque error codes from upgradeable contracts.\n     **/\n    event Failure(uint error, uint info, uint detail);\n\n    /**\n     * @dev use this when reporting a known error from the money market or a non-upgradeable collaborator\n     */\n    function fail(Error err, FailureInfo info) internal returns (uint) {\n        emit Failure(uint(err), uint(info), 0);\n\n        return uint(err);\n    }\n\n    /**\n     * @dev use this when reporting an opaque error from an upgradeable collaborator contract\n     */\n    function failOpaque(Error err, FailureInfo info, uint opaqueError) internal returns (uint) {\n        emit Failure(uint(err), uint(info), opaqueError);\n\n        return uint(err);\n    }\n}\n\ncontract TokenErrorReporter {\n    enum Error {\n        NO_ERROR,\n        UNAUTHORIZED,\n        BAD_INPUT,\n        COMPTROLLER_REJECTION,\n        COMPTROLLER_CALCULATION_ERROR,\n        INTEREST_RATE_MODEL_ERROR,\n        INVALID_ACCOUNT_PAIR,\n        INVALID_CLOSE_AMOUNT_REQUESTED,\n        INVALID_COLLATERAL_FACTOR,\n        MATH_ERROR,\n        MARKET_NOT_FRESH,\n        MARKET_NOT_LISTED,\n        TOKEN_INSUFFICIENT_ALLOWANCE,\n        TOKEN_INSUFFICIENT_BALANCE,\n        TOKEN_INSUFFICIENT_CASH,\n        TOKEN_TRANSFER_IN_FAILED,\n        TOKEN_TRANSFER_OUT_FAILED,\n        TOKEN_PRICE_ERROR\n    }\n\n    /*\n     * Note: FailureInfo (but not Error) is kept in alphabetical order\n     *       This is because FailureInfo grows significantly faster, and\n     *       the order of Error has some meaning, while the order of FailureInfo\n     *       is entirely arbitrary.\n     */\n    enum FailureInfo {\n        ACCEPT_ADMIN_PENDING_ADMIN_CHECK,\n        ACCRUE_INTEREST_ACCUMULATED_INTEREST_CALCULATION_FAILED,\n        ACCRUE_INTEREST_BORROW_RATE_CALCULATION_FAILED,\n        ACCRUE_INTEREST_NEW_BORROW_INDEX_CALCULATION_FAILED,\n        ACCRUE_INTEREST_NEW_TOTAL_BORROWS_CALCULATION_FAILED,\n        ACCRUE_INTEREST_NEW_TOTAL_RESERVES_CALCULATION_FAILED,\n        ACCRUE_INTEREST_SIMPLE_INTEREST_FACTOR_CALCULATION_FAILED,\n        BORROW_ACCUMULATED_BALANCE_CALCULATION_FAILED,\n        BORROW_ACCRUE_INTEREST_FAILED,\n        BORROW_CASH_NOT_AVAILABLE,\n        BORROW_FRESHNESS_CHECK,\n        BORROW_NEW_TOTAL_BALANCE_CALCULATION_FAILED,\n        BORROW_NEW_ACCOUNT_BORROW_BALANCE_CALCULATION_FAILED,\n        BORROW_MARKET_NOT_LISTED,\n        BORROW_COMPTROLLER_REJECTION,\n        LIQUIDATE_ACCRUE_BORROW_INTEREST_FAILED,\n        LIQUIDATE_ACCRUE_COLLATERAL_INTEREST_FAILED,\n        LIQUIDATE_COLLATERAL_FRESHNESS_CHECK,\n        LIQUIDATE_COMPTROLLER_REJECTION,\n        LIQUIDATE_COMPTROLLER_CALCULATE_AMOUNT_SEIZE_FAILED,\n        LIQUIDATE_CLOSE_AMOUNT_IS_UINT_MAX,\n        LIQUIDATE_CLOSE_AMOUNT_IS_ZERO,\n        LIQUIDATE_FRESHNESS_CHECK,\n        LIQUIDATE_LIQUIDATOR_IS_BORROWER,\n        LIQUIDATE_REPAY_BORROW_FRESH_FAILED,\n        LIQUIDATE_SEIZE_BALANCE_INCREMENT_FAILED,\n        LIQUIDATE_SEIZE_BALANCE_DECREMENT_FAILED,\n        LIQUIDATE_SEIZE_COMPTROLLER_REJECTION,\n        LIQUIDATE_SEIZE_LIQUIDATOR_IS_BORROWER,\n        LIQUIDATE_SEIZE_TOO_MUCH,\n        MINT_ACCRUE_INTEREST_FAILED,\n        MINT_COMPTROLLER_REJECTION,\n        MINT_EXCHANGE_CALCULATION_FAILED,\n        MINT_EXCHANGE_RATE_READ_FAILED,\n        MINT_FRESHNESS_CHECK,\n        MINT_NEW_ACCOUNT_BALANCE_CALCULATION_FAILED,\n        MINT_NEW_TOTAL_SUPPLY_CALCULATION_FAILED,\n        MINT_TRANSFER_IN_FAILED,\n        MINT_TRANSFER_IN_NOT_POSSIBLE,\n        REDEEM_ACCRUE_INTEREST_FAILED,\n        REDEEM_COMPTROLLER_REJECTION,\n        REDEEM_EXCHANGE_TOKENS_CALCULATION_FAILED,\n        REDEEM_EXCHANGE_AMOUNT_CALCULATION_FAILED,\n        REDEEM_EXCHANGE_RATE_READ_FAILED,\n        REDEEM_FRESHNESS_CHECK,\n        REDEEM_NEW_ACCOUNT_BALANCE_CALCULATION_FAILED,\n        REDEEM_NEW_TOTAL_SUPPLY_CALCULATION_FAILED,\n        REDEEM_TRANSFER_OUT_NOT_POSSIBLE,\n        REDUCE_RESERVES_ACCRUE_INTEREST_FAILED,\n        REDUCE_RESERVES_ADMIN_CHECK,\n        REDUCE_RESERVES_CASH_NOT_AVAILABLE,\n        REDUCE_RESERVES_FRESH_CHECK,\n        REDUCE_RESERVES_VALIDATION,\n        REPAY_BEHALF_ACCRUE_INTEREST_FAILED,\n        REPAY_BORROW_ACCRUE_INTEREST_FAILED,\n        REPAY_BORROW_ACCUMULATED_BALANCE_CALCULATION_FAILED,\n        REPAY_BORROW_COMPTROLLER_REJECTION,\n        REPAY_BORROW_FRESHNESS_CHECK,\n        REPAY_BORROW_NEW_ACCOUNT_BORROW_BALANCE_CALCULATION_FAILED,\n        REPAY_BORROW_NEW_TOTAL_BALANCE_CALCULATION_FAILED,\n        REPAY_BORROW_TRANSFER_IN_NOT_POSSIBLE,\n        SET_COLLATERAL_FACTOR_OWNER_CHECK,\n        SET_COLLATERAL_FACTOR_VALIDATION,\n        SET_COMPTROLLER_OWNER_CHECK,\n        SET_INTEREST_RATE_MODEL_ACCRUE_INTEREST_FAILED,\n        SET_INTEREST_RATE_MODEL_FRESH_CHECK,\n        SET_INTEREST_RATE_MODEL_OWNER_CHECK,\n        SET_MAX_ASSETS_OWNER_CHECK,\n        SET_ORACLE_MARKET_NOT_LISTED,\n        SET_PENDING_ADMIN_OWNER_CHECK,\n        SET_RESERVE_FACTOR_ACCRUE_INTEREST_FAILED,\n        SET_RESERVE_FACTOR_ADMIN_CHECK,\n        SET_RESERVE_FACTOR_FRESH_CHECK,\n        SET_RESERVE_FACTOR_BOUNDS_CHECK,\n        TRANSFER_COMPTROLLER_REJECTION,\n        TRANSFER_NOT_ALLOWED,\n        TRANSFER_NOT_ENOUGH,\n        TRANSFER_TOO_MUCH,\n        ADD_RESERVES_ACCRUE_INTEREST_FAILED,\n        ADD_RESERVES_FRESH_CHECK,\n        ADD_RESERVES_TRANSFER_IN_NOT_POSSIBLE,\n        TOKEN_GET_UNDERLYING_PRICE_ERROR,\n        REPAY_VAI_COMPTROLLER_REJECTION,\n        REPAY_VAI_FRESHNESS_CHECK,\n        VAI_MINT_EXCHANGE_CALCULATION_FAILED,\n        SFT_MINT_NEW_ACCOUNT_BALANCE_CALCULATION_FAILED\n    }\n\n    /**\n     * @dev `error` corresponds to enum Error; `info` corresponds to enum FailureInfo, and `detail` is an arbitrary\n     * contract-specific code that enables us to report opaque error codes from upgradeable contracts.\n     **/\n    event Failure(uint error, uint info, uint detail);\n\n    /**\n     * @dev use this when reporting a known error from the money market or a non-upgradeable collaborator\n     */\n    function fail(Error err, FailureInfo info) internal returns (uint) {\n        emit Failure(uint(err), uint(info), 0);\n\n        return uint(err);\n    }\n\n    /**\n     * @dev use this when reporting an opaque error from an upgradeable collaborator contract\n     */\n    function failOpaque(Error err, FailureInfo info, uint opaqueError) internal returns (uint) {\n        emit Failure(uint(err), uint(info), opaqueError);\n\n        return uint(err);\n    }\n}\n\ncontract VAIControllerErrorReporter {\n    enum Error {\n        NO_ERROR,\n        UNAUTHORIZED, // The sender is not authorized to perform this action.\n        REJECTION, // The action would violate the comptroller, vaicontroller policy.\n        SNAPSHOT_ERROR, // The comptroller could not get the account borrows and exchange rate from the market.\n        PRICE_ERROR, // The comptroller could not obtain a required price of an asset.\n        MATH_ERROR, // A math calculation error occurred.\n        INSUFFICIENT_BALANCE_FOR_VAI // Caller does not have sufficient balance to mint VAI.\n    }\n\n    enum FailureInfo {\n        SET_PENDING_ADMIN_OWNER_CHECK,\n        SET_PENDING_IMPLEMENTATION_OWNER_CHECK,\n        SET_COMPTROLLER_OWNER_CHECK,\n        ACCEPT_ADMIN_PENDING_ADMIN_CHECK,\n        ACCEPT_PENDING_IMPLEMENTATION_ADDRESS_CHECK,\n        VAI_MINT_REJECTION,\n        VAI_BURN_REJECTION,\n        VAI_LIQUIDATE_ACCRUE_BORROW_INTEREST_FAILED,\n        VAI_LIQUIDATE_ACCRUE_COLLATERAL_INTEREST_FAILED,\n        VAI_LIQUIDATE_COLLATERAL_FRESHNESS_CHECK,\n        VAI_LIQUIDATE_COMPTROLLER_REJECTION,\n        VAI_LIQUIDATE_COMPTROLLER_CALCULATE_AMOUNT_SEIZE_FAILED,\n        VAI_LIQUIDATE_CLOSE_AMOUNT_IS_UINT_MAX,\n        VAI_LIQUIDATE_CLOSE_AMOUNT_IS_ZERO,\n        VAI_LIQUIDATE_FRESHNESS_CHECK,\n        VAI_LIQUIDATE_LIQUIDATOR_IS_BORROWER,\n        VAI_LIQUIDATE_REPAY_BORROW_FRESH_FAILED,\n        VAI_LIQUIDATE_SEIZE_BALANCE_INCREMENT_FAILED,\n        VAI_LIQUIDATE_SEIZE_BALANCE_DECREMENT_FAILED,\n        VAI_LIQUIDATE_SEIZE_COMPTROLLER_REJECTION,\n        VAI_LIQUIDATE_SEIZE_LIQUIDATOR_IS_BORROWER,\n        VAI_LIQUIDATE_SEIZE_TOO_MUCH,\n        MINT_FEE_CALCULATION_FAILED,\n        SET_TREASURY_OWNER_CHECK\n    }\n\n    /**\n     * @dev `error` corresponds to enum Error; `info` corresponds to enum FailureInfo, and `detail` is an arbitrary\n     * contract-specific code that enables us to report opaque error codes from upgradeable contracts.\n     **/\n    event Failure(uint error, uint info, uint detail);\n\n    /**\n     * @dev use this when reporting a known error from the money market or a non-upgradeable collaborator\n     */\n    function fail(Error err, FailureInfo info) internal returns (uint) {\n        emit Failure(uint(err), uint(info), 0);\n\n        return uint(err);\n    }\n\n    /**\n     * @dev use this when reporting an opaque error from an upgradeable collaborator contract\n     */\n    function failOpaque(Error err, FailureInfo info, uint opaqueError) internal returns (uint) {\n        emit Failure(uint(err), uint(info), opaqueError);\n\n        return uint(err);\n    }\n}\n"
+    },
+    "contracts/Tokens/VTokens/legacy/Utils/Exponential.sol": {
+      "content": "pragma solidity ^0.5.16;\n\nimport \"./CarefulMath.sol\";\nimport \"./ExponentialNoError.sol\";\n\n/**\n * @title Exponential module for storing fixed-precision decimals\n * @author Venus\n * @notice Exp is a struct which stores decimals with a fixed precision of 18 decimal places.\n *         Thus, if we wanted to store the 5.1, mantissa would store 5.1e18. That is:\n *         `Exp({mantissa: 5100000000000000000})`.\n */\ncontract Exponential is CarefulMath, ExponentialNoError {\n    /**\n     * @dev Creates an exponential from numerator and denominator values.\n     *      Note: Returns an error if (`num` * 10e18) > MAX_INT,\n     *            or if `denom` is zero.\n     */\n    function getExp(uint num, uint denom) internal pure returns (MathError, Exp memory) {\n        (MathError err0, uint scaledNumerator) = mulUInt(num, expScale);\n        if (err0 != MathError.NO_ERROR) {\n            return (err0, Exp({ mantissa: 0 }));\n        }\n\n        (MathError err1, uint rational) = divUInt(scaledNumerator, denom);\n        if (err1 != MathError.NO_ERROR) {\n            return (err1, Exp({ mantissa: 0 }));\n        }\n\n        return (MathError.NO_ERROR, Exp({ mantissa: rational }));\n    }\n\n    /**\n     * @dev Adds two exponentials, returning a new exponential.\n     */\n    function addExp(Exp memory a, Exp memory b) internal pure returns (MathError, Exp memory) {\n        (MathError error, uint result) = addUInt(a.mantissa, b.mantissa);\n\n        return (error, Exp({ mantissa: result }));\n    }\n\n    /**\n     * @dev Subtracts two exponentials, returning a new exponential.\n     */\n    function subExp(Exp memory a, Exp memory b) internal pure returns (MathError, Exp memory) {\n        (MathError error, uint result) = subUInt(a.mantissa, b.mantissa);\n\n        return (error, Exp({ mantissa: result }));\n    }\n\n    /**\n     * @dev Multiply an Exp by a scalar, returning a new Exp.\n     */\n    function mulScalar(Exp memory a, uint scalar) internal pure returns (MathError, Exp memory) {\n        (MathError err0, uint scaledMantissa) = mulUInt(a.mantissa, scalar);\n        if (err0 != MathError.NO_ERROR) {\n            return (err0, Exp({ mantissa: 0 }));\n        }\n\n        return (MathError.NO_ERROR, Exp({ mantissa: scaledMantissa }));\n    }\n\n    /**\n     * @dev Multiply an Exp by a scalar, then truncate to return an unsigned integer.\n     */\n    function mulScalarTruncate(Exp memory a, uint scalar) internal pure returns (MathError, uint) {\n        (MathError err, Exp memory product) = mulScalar(a, scalar);\n        if (err != MathError.NO_ERROR) {\n            return (err, 0);\n        }\n\n        return (MathError.NO_ERROR, truncate(product));\n    }\n\n    /**\n     * @dev Multiply an Exp by a scalar, truncate, then add an to an unsigned integer, returning an unsigned integer.\n     */\n    function mulScalarTruncateAddUInt(Exp memory a, uint scalar, uint addend) internal pure returns (MathError, uint) {\n        (MathError err, Exp memory product) = mulScalar(a, scalar);\n        if (err != MathError.NO_ERROR) {\n            return (err, 0);\n        }\n\n        return addUInt(truncate(product), addend);\n    }\n\n    /**\n     * @dev Divide an Exp by a scalar, returning a new Exp.\n     */\n    function divScalar(Exp memory a, uint scalar) internal pure returns (MathError, Exp memory) {\n        (MathError err0, uint descaledMantissa) = divUInt(a.mantissa, scalar);\n        if (err0 != MathError.NO_ERROR) {\n            return (err0, Exp({ mantissa: 0 }));\n        }\n\n        return (MathError.NO_ERROR, Exp({ mantissa: descaledMantissa }));\n    }\n\n    /**\n     * @dev Divide a scalar by an Exp, returning a new Exp.\n     */\n    function divScalarByExp(uint scalar, Exp memory divisor) internal pure returns (MathError, Exp memory) {\n        /*\n          We are doing this as:\n          getExp(mulUInt(expScale, scalar), divisor.mantissa)\n\n          How it works:\n          Exp = a / b;\n          Scalar = s;\n          `s / (a / b)` = `b * s / a` and since for an Exp `a = mantissa, b = expScale`\n        */\n        (MathError err0, uint numerator) = mulUInt(expScale, scalar);\n        if (err0 != MathError.NO_ERROR) {\n            return (err0, Exp({ mantissa: 0 }));\n        }\n        return getExp(numerator, divisor.mantissa);\n    }\n\n    /**\n     * @dev Divide a scalar by an Exp, then truncate to return an unsigned integer.\n     */\n    function divScalarByExpTruncate(uint scalar, Exp memory divisor) internal pure returns (MathError, uint) {\n        (MathError err, Exp memory fraction) = divScalarByExp(scalar, divisor);\n        if (err != MathError.NO_ERROR) {\n            return (err, 0);\n        }\n\n        return (MathError.NO_ERROR, truncate(fraction));\n    }\n\n    /**\n     * @dev Multiplies two exponentials, returning a new exponential.\n     */\n    function mulExp(Exp memory a, Exp memory b) internal pure returns (MathError, Exp memory) {\n        (MathError err0, uint doubleScaledProduct) = mulUInt(a.mantissa, b.mantissa);\n        if (err0 != MathError.NO_ERROR) {\n            return (err0, Exp({ mantissa: 0 }));\n        }\n\n        // We add half the scale before dividing so that we get rounding instead of truncation.\n        //  See \"Listing 6\" and text above it at https://accu.org/index.php/journals/1717\n        // Without this change, a result like 6.6...e-19 will be truncated to 0 instead of being rounded to 1e-18.\n        (MathError err1, uint doubleScaledProductWithHalfScale) = addUInt(halfExpScale, doubleScaledProduct);\n        if (err1 != MathError.NO_ERROR) {\n            return (err1, Exp({ mantissa: 0 }));\n        }\n\n        (MathError err2, uint product) = divUInt(doubleScaledProductWithHalfScale, expScale);\n        // The only error `div` can return is MathError.DIVISION_BY_ZERO but we control `expScale` and it is not zero.\n        assert(err2 == MathError.NO_ERROR);\n\n        return (MathError.NO_ERROR, Exp({ mantissa: product }));\n    }\n\n    /**\n     * @dev Multiplies two exponentials given their mantissas, returning a new exponential.\n     */\n    function mulExp(uint a, uint b) internal pure returns (MathError, Exp memory) {\n        return mulExp(Exp({ mantissa: a }), Exp({ mantissa: b }));\n    }\n\n    /**\n     * @dev Multiplies three exponentials, returning a new exponential.\n     */\n    function mulExp3(Exp memory a, Exp memory b, Exp memory c) internal pure returns (MathError, Exp memory) {\n        (MathError err, Exp memory ab) = mulExp(a, b);\n        if (err != MathError.NO_ERROR) {\n            return (err, ab);\n        }\n        return mulExp(ab, c);\n    }\n\n    /**\n     * @dev Divides two exponentials, returning a new exponential.\n     *     (a/scale) / (b/scale) = (a/scale) * (scale/b) = a/b,\n     *  which we can scale as an Exp by calling getExp(a.mantissa, b.mantissa)\n     */\n    function divExp(Exp memory a, Exp memory b) internal pure returns (MathError, Exp memory) {\n        return getExp(a.mantissa, b.mantissa);\n    }\n}\n"
+    },
+    "contracts/Tokens/VTokens/legacy/Utils/ExponentialNoError.sol": {
+      "content": "pragma solidity ^0.5.16;\n\n/**\n * @title Exponential module for storing fixed-precision decimals\n * @author Compound\n * @notice Exp is a struct which stores decimals with a fixed precision of 18 decimal places.\n *         Thus, if we wanted to store the 5.1, mantissa would store 5.1e18. That is:\n *         `Exp({mantissa: 5100000000000000000})`.\n */\ncontract ExponentialNoError {\n    uint internal constant expScale = 1e18;\n    uint internal constant doubleScale = 1e36;\n    uint internal constant halfExpScale = expScale / 2;\n    uint internal constant mantissaOne = expScale;\n\n    struct Exp {\n        uint mantissa;\n    }\n\n    struct Double {\n        uint mantissa;\n    }\n\n    /**\n     * @dev Truncates the given exp to a whole number value.\n     *      For example, truncate(Exp{mantissa: 15 * expScale}) = 15\n     */\n    function truncate(Exp memory exp) internal pure returns (uint) {\n        // Note: We are not using careful math here as we're performing a division that cannot fail\n        return exp.mantissa / expScale;\n    }\n\n    /**\n     * @dev Multiply an Exp by a scalar, then truncate to return an unsigned integer.\n     */\n    function mul_ScalarTruncate(Exp memory a, uint scalar) internal pure returns (uint) {\n        Exp memory product = mul_(a, scalar);\n        return truncate(product);\n    }\n\n    /**\n     * @dev Multiply an Exp by a scalar, truncate, then add an to an unsigned integer, returning an unsigned integer.\n     */\n    function mul_ScalarTruncateAddUInt(Exp memory a, uint scalar, uint addend) internal pure returns (uint) {\n        Exp memory product = mul_(a, scalar);\n        return add_(truncate(product), addend);\n    }\n\n    /**\n     * @dev Checks if first Exp is less than second Exp.\n     */\n    function lessThanExp(Exp memory left, Exp memory right) internal pure returns (bool) {\n        return left.mantissa < right.mantissa;\n    }\n\n    /**\n     * @dev Checks if left Exp <= right Exp.\n     */\n    function lessThanOrEqualExp(Exp memory left, Exp memory right) internal pure returns (bool) {\n        return left.mantissa <= right.mantissa;\n    }\n\n    /**\n     * @dev Checks if left Exp > right Exp.\n     */\n    function greaterThanExp(Exp memory left, Exp memory right) internal pure returns (bool) {\n        return left.mantissa > right.mantissa;\n    }\n\n    /**\n     * @dev returns true if Exp is exactly zero\n     */\n    function isZeroExp(Exp memory value) internal pure returns (bool) {\n        return value.mantissa == 0;\n    }\n\n    function safe224(uint n, string memory errorMessage) internal pure returns (uint224) {\n        require(n < 2 ** 224, errorMessage);\n        return uint224(n);\n    }\n\n    function safe32(uint n, string memory errorMessage) internal pure returns (uint32) {\n        require(n < 2 ** 32, errorMessage);\n        return uint32(n);\n    }\n\n    function add_(Exp memory a, Exp memory b) internal pure returns (Exp memory) {\n        return Exp({ mantissa: add_(a.mantissa, b.mantissa) });\n    }\n\n    function add_(Double memory a, Double memory b) internal pure returns (Double memory) {\n        return Double({ mantissa: add_(a.mantissa, b.mantissa) });\n    }\n\n    function add_(uint a, uint b) internal pure returns (uint) {\n        return add_(a, b, \"addition overflow\");\n    }\n\n    function add_(uint a, uint b, string memory errorMessage) internal pure returns (uint) {\n        uint c = a + b;\n        require(c >= a, errorMessage);\n        return c;\n    }\n\n    function sub_(Exp memory a, Exp memory b) internal pure returns (Exp memory) {\n        return Exp({ mantissa: sub_(a.mantissa, b.mantissa) });\n    }\n\n    function sub_(Double memory a, Double memory b) internal pure returns (Double memory) {\n        return Double({ mantissa: sub_(a.mantissa, b.mantissa) });\n    }\n\n    function sub_(uint a, uint b) internal pure returns (uint) {\n        return sub_(a, b, \"subtraction underflow\");\n    }\n\n    function sub_(uint a, uint b, string memory errorMessage) internal pure returns (uint) {\n        require(b <= a, errorMessage);\n        return a - b;\n    }\n\n    function mul_(Exp memory a, Exp memory b) internal pure returns (Exp memory) {\n        return Exp({ mantissa: mul_(a.mantissa, b.mantissa) / expScale });\n    }\n\n    function mul_(Exp memory a, uint b) internal pure returns (Exp memory) {\n        return Exp({ mantissa: mul_(a.mantissa, b) });\n    }\n\n    function mul_(uint a, Exp memory b) internal pure returns (uint) {\n        return mul_(a, b.mantissa) / expScale;\n    }\n\n    function mul_(Double memory a, Double memory b) internal pure returns (Double memory) {\n        return Double({ mantissa: mul_(a.mantissa, b.mantissa) / doubleScale });\n    }\n\n    function mul_(Double memory a, uint b) internal pure returns (Double memory) {\n        return Double({ mantissa: mul_(a.mantissa, b) });\n    }\n\n    function mul_(uint a, Double memory b) internal pure returns (uint) {\n        return mul_(a, b.mantissa) / doubleScale;\n    }\n\n    function mul_(uint a, uint b) internal pure returns (uint) {\n        return mul_(a, b, \"multiplication overflow\");\n    }\n\n    function mul_(uint a, uint b, string memory errorMessage) internal pure returns (uint) {\n        if (a == 0 || b == 0) {\n            return 0;\n        }\n        uint c = a * b;\n        require(c / a == b, errorMessage);\n        return c;\n    }\n\n    function div_(Exp memory a, Exp memory b) internal pure returns (Exp memory) {\n        return Exp({ mantissa: div_(mul_(a.mantissa, expScale), b.mantissa) });\n    }\n\n    function div_(Exp memory a, uint b) internal pure returns (Exp memory) {\n        return Exp({ mantissa: div_(a.mantissa, b) });\n    }\n\n    function div_(uint a, Exp memory b) internal pure returns (uint) {\n        return div_(mul_(a, expScale), b.mantissa);\n    }\n\n    function div_(Double memory a, Double memory b) internal pure returns (Double memory) {\n        return Double({ mantissa: div_(mul_(a.mantissa, doubleScale), b.mantissa) });\n    }\n\n    function div_(Double memory a, uint b) internal pure returns (Double memory) {\n        return Double({ mantissa: div_(a.mantissa, b) });\n    }\n\n    function div_(uint a, Double memory b) internal pure returns (uint) {\n        return div_(mul_(a, doubleScale), b.mantissa);\n    }\n\n    function div_(uint a, uint b) internal pure returns (uint) {\n        return div_(a, b, \"divide by zero\");\n    }\n\n    function div_(uint a, uint b, string memory errorMessage) internal pure returns (uint) {\n        require(b > 0, errorMessage);\n        return a / b;\n    }\n\n    function fraction(uint a, uint b) internal pure returns (Double memory) {\n        return Double({ mantissa: div_(mul_(a, doubleScale), b) });\n    }\n}\n"
+    },
+    "contracts/Tokens/VTokens/legacy/VBep20DelegateR1.sol": {
+      "content": "pragma solidity ^0.5.16;\n\nimport { VBep20R1 } from \"./VBep20R1.sol\";\nimport { VDelegateInterfaceR1 } from \"./VTokenInterfaceR1.sol\";\n\n/**\n * @title Venus's VBep20Delegate Contract\n * @notice VTokens which wrap an EIP-20 underlying and are delegated to\n * @author Venus\n */\ncontract VBep20DelegateR1 is VBep20R1, VDelegateInterfaceR1 {\n    /**\n     * @notice Construct an empty delegate\n     */\n    constructor() public {}\n\n    /**\n     * @notice Called by the delegator on a delegate to initialize it for duty\n     * @param data The encoded bytes data for any initialization\n     */\n    function _becomeImplementation(bytes memory data) public {\n        // Shh -- currently unused\n        data;\n\n        // Shh -- we don't ever want this hook to be marked pure\n        if (false) {\n            implementation = address(0);\n        }\n\n        require(msg.sender == admin, \"only the admin may call _becomeImplementation\");\n    }\n\n    /**\n     * @notice Called by the delegator on a delegate to forfeit its responsibility\n     */\n    function _resignImplementation() public {\n        // Shh -- we don't ever want this hook to be marked pure\n        if (false) {\n            implementation = address(0);\n        }\n\n        require(msg.sender == admin, \"only the admin may call _resignImplementation\");\n    }\n}\n"
+    },
+    "contracts/Tokens/VTokens/legacy/VBep20DelegatorR1.sol": {
+      "content": "pragma solidity ^0.5.16;\n\nimport { InterestRateModel } from \"../../../InterestRateModels/InterestRateModel.sol\";\nimport { ComptrollerInterface } from \"./ComptrollerInterface.sol\";\nimport { VTokenInterfaceR1, VBep20InterfaceR1, VDelegatorInterfaceR1 } from \"./VTokenInterfaceR1.sol\";\n\n/**\n * @title Venus's VBep20Delegator Contract\n * @notice vTokens which wrap an EIP-20 underlying and delegate to an implementation\n * @author Venus\n */\ncontract VBep20DelegatorR1 is VTokenInterfaceR1, VBep20InterfaceR1, VDelegatorInterfaceR1 {\n    /**\n     * @notice Construct a new money market\n     * @param underlying_ The address of the underlying asset\n     * @param comptroller_ The address of the comptroller\n     * @param interestRateModel_ The address of the interest rate model\n     * @param initialExchangeRateMantissa_ The initial exchange rate, scaled by 1e18\n     * @param name_ BEP-20 name of this token\n     * @param symbol_ BEP-20 symbol of this token\n     * @param decimals_ BEP-20 decimal precision of this token\n     * @param admin_ Address of the administrator of this token\n     * @param implementation_ The address of the implementation the contract delegates to\n     * @param becomeImplementationData The encoded args for becomeImplementation\n     */\n    constructor(\n        address underlying_,\n        ComptrollerInterface comptroller_,\n        InterestRateModel interestRateModel_,\n        uint initialExchangeRateMantissa_,\n        string memory name_,\n        string memory symbol_,\n        uint8 decimals_,\n        address payable admin_,\n        address implementation_,\n        bytes memory becomeImplementationData\n    ) public {\n        // Creator of the contract is admin during initialization\n        admin = msg.sender;\n\n        // First delegate gets to initialize the delegator (i.e. storage contract)\n        delegateTo(\n            implementation_,\n            abi.encodeWithSignature(\n                \"initialize(address,address,address,uint256,string,string,uint8)\",\n                underlying_,\n                comptroller_,\n                interestRateModel_,\n                initialExchangeRateMantissa_,\n                name_,\n                symbol_,\n                decimals_\n            )\n        );\n\n        // New implementations always get set via the settor (post-initialize)\n        _setImplementation(implementation_, false, becomeImplementationData);\n\n        // Set the proper admin now that initialization is done\n        admin = admin_;\n    }\n\n    /**\n     * @notice Delegates execution to an implementation contract\n     * @dev It returns to the external caller whatever the implementation returns or forwards reverts\n     */\n    function() external payable {\n        require(msg.value == 0, \"VBep20Delegator:fallback: cannot send value to fallback\");\n\n        // delegate all other functions to current implementation\n        (bool success, ) = implementation.delegatecall(msg.data);\n\n        assembly {\n            let free_mem_ptr := mload(0x40)\n            returndatacopy(free_mem_ptr, 0, returndatasize)\n\n            switch success\n            case 0 {\n                revert(free_mem_ptr, returndatasize)\n            }\n            default {\n                return(free_mem_ptr, returndatasize)\n            }\n        }\n    }\n\n    /**\n     * @notice Sender supplies assets into the market and receives vTokens in exchange\n     * @dev Accrues interest whether or not the operation succeeds, unless reverted\n     * @param mintAmount The amount of the underlying asset to supply\n     * @return uint Returns 0 on success, otherwise returns a failure code (see ErrorReporter.sol for details).\n     */\n    function mint(uint mintAmount) external returns (uint) {\n        bytes memory data = delegateToImplementation(abi.encodeWithSignature(\"mint(uint256)\", mintAmount));\n        return abi.decode(data, (uint));\n    }\n\n    /**\n     * @notice Sender supplies assets into the market and receiver receives vTokens in exchange\n     * @dev Accrues interest whether or not the operation succeeds, unless reverted\n     * @param mintAmount The amount of the underlying asset to supply\n     * @return uint Returns 0 on success, otherwise returns a failure code (see ErrorReporter.sol for details).\n     */\n    function mintBehalf(address receiver, uint mintAmount) external returns (uint) {\n        bytes memory data = delegateToImplementation(\n            abi.encodeWithSignature(\"mintBehalf(address,uint256)\", receiver, mintAmount)\n        );\n        return abi.decode(data, (uint));\n    }\n\n    /**\n     * @notice Sender redeems vTokens in exchange for the underlying asset\n     * @dev Accrues interest whether or not the operation succeeds, unless reverted\n     * @param redeemTokens The number of vTokens to redeem into underlying asset\n     * @return uint Returns 0 on success, otherwise returns a failure code (see ErrorReporter.sol for details).\n     */\n    function redeem(uint redeemTokens) external returns (uint) {\n        bytes memory data = delegateToImplementation(abi.encodeWithSignature(\"redeem(uint256)\", redeemTokens));\n        return abi.decode(data, (uint));\n    }\n\n    /**\n     * @notice Sender redeems vTokens in exchange for a specified amount of underlying asset\n     * @dev Accrues interest whether or not the operation succeeds, unless reverted\n     * @param redeemAmount The amount of underlying to redeem\n     * @return uint Returns 0 on success, otherwise returns a failure code (see ErrorReporter.sol for details).\n     */\n    function redeemUnderlying(uint redeemAmount) external returns (uint) {\n        bytes memory data = delegateToImplementation(\n            abi.encodeWithSignature(\"redeemUnderlying(uint256)\", redeemAmount)\n        );\n        return abi.decode(data, (uint));\n    }\n\n    /**\n     * @notice Sender borrows assets from the protocol to their own address\n     * @param borrowAmount The amount of the underlying asset to borrow\n     * @return uint Returns 0 on success, otherwise returns a failure code (see ErrorReporter.sol for details).\n     */\n    function borrow(uint borrowAmount) external returns (uint) {\n        bytes memory data = delegateToImplementation(abi.encodeWithSignature(\"borrow(uint256)\", borrowAmount));\n        return abi.decode(data, (uint));\n    }\n\n    /**\n     * @notice Sender repays their own borrow\n     * @param repayAmount The amount to repay\n     * @return uint Returns 0 on success, otherwise returns a failure code (see ErrorReporter.sol for details).\n     */\n    function repayBorrow(uint repayAmount) external returns (uint) {\n        bytes memory data = delegateToImplementation(abi.encodeWithSignature(\"repayBorrow(uint256)\", repayAmount));\n        return abi.decode(data, (uint));\n    }\n\n    /**\n     * @notice Sender repays a borrow belonging to another borrower\n     * @param borrower The account with the debt being payed off\n     * @param repayAmount The amount to repay\n     * @return uint Returns 0 on success, otherwise returns a failure code (see ErrorReporter.sol for details).\n     */\n    function repayBorrowBehalf(address borrower, uint repayAmount) external returns (uint) {\n        bytes memory data = delegateToImplementation(\n            abi.encodeWithSignature(\"repayBorrowBehalf(address,uint256)\", borrower, repayAmount)\n        );\n        return abi.decode(data, (uint));\n    }\n\n    /**\n     * @notice The sender liquidates the borrowers collateral.\n     *  The collateral seized is transferred to the liquidator.\n     * @param borrower The borrower of this vToken to be liquidated\n     * @param vTokenCollateral The market in which to seize collateral from the borrower\n     * @param repayAmount The amount of the underlying borrowed asset to repay\n     * @return uint Returns 0 on success, otherwise returns a failure code (see ErrorReporter.sol for details).\n     */\n    function liquidateBorrow(\n        address borrower,\n        uint repayAmount,\n        VTokenInterfaceR1 vTokenCollateral\n    ) external returns (uint) {\n        bytes memory data = delegateToImplementation(\n            abi.encodeWithSignature(\"liquidateBorrow(address,uint256,address)\", borrower, repayAmount, vTokenCollateral)\n        );\n        return abi.decode(data, (uint));\n    }\n\n    /**\n     * @notice Transfer `amount` tokens from `msg.sender` to `dst`\n     * @param dst The address of the destination account\n     * @param amount The number of tokens to transfer\n     * @return Whether or not the transfer succeeded\n     */\n    function transfer(address dst, uint amount) external returns (bool) {\n        bytes memory data = delegateToImplementation(abi.encodeWithSignature(\"transfer(address,uint256)\", dst, amount));\n        return abi.decode(data, (bool));\n    }\n\n    /**\n     * @notice Transfer `amount` tokens from `src` to `dst`\n     * @param src The address of the source account\n     * @param dst The address of the destination account\n     * @param amount The number of tokens to transfer\n     * @return Whether or not the transfer succeeded\n     */\n    function transferFrom(address src, address dst, uint256 amount) external returns (bool) {\n        bytes memory data = delegateToImplementation(\n            abi.encodeWithSignature(\"transferFrom(address,address,uint256)\", src, dst, amount)\n        );\n        return abi.decode(data, (bool));\n    }\n\n    /**\n     * @notice Approve `spender` to transfer up to `amount` from `src`\n     * @dev This will overwrite the approval amount for `spender`\n     *  and is subject to issues noted [here](https://eips.ethereum.org/EIPS/eip-20#approve)\n     * @param spender The address of the account which may transfer tokens\n     * @param amount The number of tokens that are approved (-1 means infinite)\n     * @return Whether or not the approval succeeded\n     */\n    function approve(address spender, uint256 amount) external returns (bool) {\n        bytes memory data = delegateToImplementation(\n            abi.encodeWithSignature(\"approve(address,uint256)\", spender, amount)\n        );\n        return abi.decode(data, (bool));\n    }\n\n    /**\n     * @notice Get the underlying balance of the `owner`\n     * @dev This also accrues interest in a transaction\n     * @param owner The address of the account to query\n     * @return The amount of underlying owned by `owner`\n     */\n    function balanceOfUnderlying(address owner) external returns (uint) {\n        bytes memory data = delegateToImplementation(abi.encodeWithSignature(\"balanceOfUnderlying(address)\", owner));\n        return abi.decode(data, (uint));\n    }\n\n    /**\n     * @notice Returns the current total borrows plus accrued interest\n     * @return The total borrows with interest\n     */\n    function totalBorrowsCurrent() external returns (uint) {\n        bytes memory data = delegateToImplementation(abi.encodeWithSignature(\"totalBorrowsCurrent()\"));\n        return abi.decode(data, (uint));\n    }\n\n    /**\n     * @notice Accrue interest to updated borrowIndex and then calculate account's borrow balance using the updated borrowIndex\n     * @param account The address whose balance should be calculated after updating borrowIndex\n     * @return The calculated balance\n     */\n    function borrowBalanceCurrent(address account) external returns (uint) {\n        bytes memory data = delegateToImplementation(abi.encodeWithSignature(\"borrowBalanceCurrent(address)\", account));\n        return abi.decode(data, (uint));\n    }\n\n    /**\n     * @notice Transfers collateral tokens (this market) to the liquidator.\n     * @dev Will fail unless called by another vToken during the process of liquidation.\n     *  It's absolutely critical to use msg.sender as the borrowed vToken and not a parameter.\n     * @param liquidator The account receiving seized collateral\n     * @param borrower The account having collateral seized\n     * @param seizeTokens The number of vTokens to seize\n     * @return uint Returns 0 on success, otherwise returns a failure code (see ErrorReporter.sol for details).\n     */\n    function seize(address liquidator, address borrower, uint seizeTokens) external returns (uint) {\n        bytes memory data = delegateToImplementation(\n            abi.encodeWithSignature(\"seize(address,address,uint256)\", liquidator, borrower, seizeTokens)\n        );\n        return abi.decode(data, (uint));\n    }\n\n    /*** Admin Functions ***/\n\n    /**\n     * @notice Begins transfer of admin rights. The newPendingAdmin must call `_acceptAdmin` to finalize the transfer.\n     * @dev Admin function to begin change of admin. The newPendingAdmin must call `_acceptAdmin` to finalize the transfer.\n     * @param newPendingAdmin New pending admin.\n     * @return uint Returns 0 on success, otherwise returns a failure code (see ErrorReporter.sol for details).\n     */\n    function _setPendingAdmin(address payable newPendingAdmin) external returns (uint) {\n        bytes memory data = delegateToImplementation(\n            abi.encodeWithSignature(\"_setPendingAdmin(address)\", newPendingAdmin)\n        );\n        return abi.decode(data, (uint));\n    }\n\n    /**\n     * @notice Accrues interest and sets a new reserve factor for the protocol using _setReserveFactorFresh\n     * @dev Admin function to accrue interest and set a new reserve factor\n     * @return uint Returns 0 on success, otherwise returns a failure code (see ErrorReporter.sol for details).\n     */\n    function _setReserveFactor(uint newReserveFactorMantissa) external returns (uint) {\n        bytes memory data = delegateToImplementation(\n            abi.encodeWithSignature(\"_setReserveFactor(uint256)\", newReserveFactorMantissa)\n        );\n        return abi.decode(data, (uint));\n    }\n\n    /**\n     * @notice Accepts transfer of admin rights. `msg.sender` must be pendingAdmin\n     * @dev Admin function for pending admin to accept role and update admin\n     * @return uint Returns 0 on success, otherwise returns a failure code (see ErrorReporter.sol for details).\n     */\n    function _acceptAdmin() external returns (uint) {\n        bytes memory data = delegateToImplementation(abi.encodeWithSignature(\"_acceptAdmin()\"));\n        return abi.decode(data, (uint));\n    }\n\n    /**\n     * @notice Accrues interest and adds reserves by transferring from admin\n     * @param addAmount Amount of reserves to add\n     * @return uint Returns 0 on success, otherwise returns a failure code (see ErrorReporter.sol for details).\n     */\n    function _addReserves(uint addAmount) external returns (uint) {\n        bytes memory data = delegateToImplementation(abi.encodeWithSignature(\"_addReserves(uint256)\", addAmount));\n        return abi.decode(data, (uint));\n    }\n\n    /**\n     * @notice Accrues interest and reduces reserves by transferring to admin\n     * @param reduceAmount Amount of reduction to reserves\n     * @return uint Returns 0 on success, otherwise returns a failure code (see ErrorReporter.sol for details).\n     */\n    function _reduceReserves(uint reduceAmount) external returns (uint) {\n        bytes memory data = delegateToImplementation(abi.encodeWithSignature(\"_reduceReserves(uint256)\", reduceAmount));\n        return abi.decode(data, (uint));\n    }\n\n    /**\n     * @notice Get cash balance of this vToken in the underlying asset\n     * @return The quantity of underlying asset owned by this contract\n     */\n    function getCash() external view returns (uint) {\n        bytes memory data = delegateToViewImplementation(abi.encodeWithSignature(\"getCash()\"));\n        return abi.decode(data, (uint));\n    }\n\n    /**\n     * @notice Get the current allowance from `owner` for `spender`\n     * @param owner The address of the account which owns the tokens to be spent\n     * @param spender The address of the account which may transfer tokens\n     * @return The number of tokens allowed to be spent (-1 means infinite)\n     */\n    function allowance(address owner, address spender) external view returns (uint) {\n        bytes memory data = delegateToViewImplementation(\n            abi.encodeWithSignature(\"allowance(address,address)\", owner, spender)\n        );\n        return abi.decode(data, (uint));\n    }\n\n    /**\n     * @notice Get the token balance of the `owner`\n     * @param owner The address of the account to query\n     * @return The number of tokens owned by `owner`\n     */\n    function balanceOf(address owner) external view returns (uint) {\n        bytes memory data = delegateToViewImplementation(abi.encodeWithSignature(\"balanceOf(address)\", owner));\n        return abi.decode(data, (uint));\n    }\n\n    /**\n     * @notice Get a snapshot of the account's balances and the cached exchange rate\n     * @dev This is used by comptroller to more efficiently perform liquidity checks.\n     * @param account Address of the account to snapshot\n     * @return (possible error, token balance, borrow balance, exchange rate mantissa)\n     */\n    function getAccountSnapshot(address account) external view returns (uint, uint, uint, uint) {\n        bytes memory data = delegateToViewImplementation(\n            abi.encodeWithSignature(\"getAccountSnapshot(address)\", account)\n        );\n        return abi.decode(data, (uint, uint, uint, uint));\n    }\n\n    /**\n     * @notice Returns the current per-block borrow interest rate for this vToken\n     * @return The borrow interest rate per block, scaled by 1e18\n     */\n    function borrowRatePerBlock() external view returns (uint) {\n        bytes memory data = delegateToViewImplementation(abi.encodeWithSignature(\"borrowRatePerBlock()\"));\n        return abi.decode(data, (uint));\n    }\n\n    /**\n     * @notice Returns the current per-block supply interest rate for this vToken\n     * @return The supply interest rate per block, scaled by 1e18\n     */\n    function supplyRatePerBlock() external view returns (uint) {\n        bytes memory data = delegateToViewImplementation(abi.encodeWithSignature(\"supplyRatePerBlock()\"));\n        return abi.decode(data, (uint));\n    }\n\n    /**\n     * @notice Called by the admin to update the implementation of the delegator\n     * @param implementation_ The address of the new implementation for delegation\n     * @param allowResign Flag to indicate whether to call _resignImplementation on the old implementation\n     * @param becomeImplementationData The encoded bytes data to be passed to _becomeImplementation\n     */\n    // @custom:access Only callable by admin\n    function _setImplementation(\n        address implementation_,\n        bool allowResign,\n        bytes memory becomeImplementationData\n    ) public {\n        require(msg.sender == admin, \"VBep20Delegator::_setImplementation: Caller must be admin\");\n\n        if (allowResign) {\n            delegateToImplementation(abi.encodeWithSignature(\"_resignImplementation()\"));\n        }\n\n        address oldImplementation = implementation;\n        implementation = implementation_;\n\n        delegateToImplementation(abi.encodeWithSignature(\"_becomeImplementation(bytes)\", becomeImplementationData));\n\n        emit NewImplementation(oldImplementation, implementation);\n    }\n\n    /**\n     * @notice Accrue interest then return the up-to-date exchange rate\n     * @return Calculated exchange rate scaled by 1e18\n     */\n    function exchangeRateCurrent() public returns (uint) {\n        bytes memory data = delegateToImplementation(abi.encodeWithSignature(\"exchangeRateCurrent()\"));\n        return abi.decode(data, (uint));\n    }\n\n    /**\n     * @notice Applies accrued interest to total borrows and reserves.\n     * @dev This calculates interest accrued from the last checkpointed block\n     *      up to the current block and writes new checkpoint to storage.\n     */\n    function accrueInterest() public returns (uint) {\n        bytes memory data = delegateToImplementation(abi.encodeWithSignature(\"accrueInterest()\"));\n        return abi.decode(data, (uint));\n    }\n\n    /**\n     * @notice Sets a new comptroller for the market\n     * @dev Admin function to set a new comptroller\n     * @return uint Returns 0 on success, otherwise returns a failure code (see ErrorReporter.sol for details).\n     */\n    function _setComptroller(ComptrollerInterface newComptroller) public returns (uint) {\n        bytes memory data = delegateToImplementation(\n            abi.encodeWithSignature(\"_setComptroller(address)\", newComptroller)\n        );\n        return abi.decode(data, (uint));\n    }\n\n    /**\n     * @notice Accrues interest and updates the interest rate model using `_setInterestRateModelFresh`\n     * @dev Admin function to accrue interest and update the interest rate model\n     * @param newInterestRateModel The new interest rate model to use\n     * @return uint Returns 0 on success, otherwise returns a failure code (see ErrorReporter.sol for details).\n     */\n    function _setInterestRateModel(InterestRateModel newInterestRateModel) public returns (uint) {\n        bytes memory data = delegateToImplementation(\n            abi.encodeWithSignature(\"_setInterestRateModel(address)\", newInterestRateModel)\n        );\n        return abi.decode(data, (uint));\n    }\n\n    /**\n     * @notice Delegates execution to the implementation contract\n     * @dev It returns to the external caller whatever the implementation returns or forwards reverts\n     * @param data The raw data to delegatecall\n     * @return The returned bytes from the delegatecall\n     */\n    function delegateToImplementation(bytes memory data) public returns (bytes memory) {\n        return delegateTo(implementation, data);\n    }\n\n    /**\n     * @notice Delegates execution to an implementation contract\n     * @dev It returns to the external caller whatever the implementation returns or forwards reverts\n     *  There are an additional 2 prefix uints from the wrapper returndata, which we ignore since we make an extra hop.\n     * @param data The raw data to delegatecall\n     * @return The returned bytes from the delegatecall\n     */\n    function delegateToViewImplementation(bytes memory data) public view returns (bytes memory) {\n        (bool success, bytes memory returnData) = address(this).staticcall(\n            abi.encodeWithSignature(\"delegateToImplementation(bytes)\", data)\n        );\n        assembly {\n            if eq(success, 0) {\n                revert(add(returnData, 0x20), returndatasize)\n            }\n        }\n        return abi.decode(returnData, (bytes));\n    }\n\n    /**\n     * @notice Return the borrow balance of account based on stored data\n     * @param account The address whose balance should be calculated\n     * @return The calculated balance\n     */\n    function borrowBalanceStored(address account) public view returns (uint) {\n        bytes memory data = delegateToViewImplementation(\n            abi.encodeWithSignature(\"borrowBalanceStored(address)\", account)\n        );\n        return abi.decode(data, (uint));\n    }\n\n    /**\n     * @notice Calculates the exchange rate from the underlying to the VToken\n     * @dev This function does not accrue interest before calculating the exchange rate\n     * @return Calculated exchange rate scaled by 1e18\n     */\n    function exchangeRateStored() public view returns (uint) {\n        bytes memory data = delegateToViewImplementation(abi.encodeWithSignature(\"exchangeRateStored()\"));\n        return abi.decode(data, (uint));\n    }\n\n    /**\n     * @notice Internal method to delegate execution to another contract\n     * @dev It returns to the external caller whatever the implementation returns or forwards reverts\n     * @param callee The contract to delegatecall\n     * @param data The raw data to delegatecall\n     * @return The returned bytes from the delegatecall\n     */\n    function delegateTo(address callee, bytes memory data) internal returns (bytes memory) {\n        (bool success, bytes memory returnData) = callee.delegatecall(data);\n        assembly {\n            if eq(success, 0) {\n                revert(add(returnData, 0x20), returndatasize)\n            }\n        }\n        return returnData;\n    }\n}\n"
+    },
+    "contracts/Tokens/VTokens/legacy/VBep20R1.sol": {
+      "content": "pragma solidity ^0.5.16;\n\nimport { InterestRateModel } from \"../../../InterestRateModels/InterestRateModel.sol\";\nimport { ComptrollerInterface } from \"./ComptrollerInterface.sol\";\nimport { VBep20InterfaceR1, VTokenInterfaceR1 } from \"./VTokenInterfaceR1.sol\";\nimport { VTokenR1 } from \"./VTokenR1.sol\";\nimport { EIP20Interface } from \"../../EIP20Interface.sol\";\nimport { EIP20NonStandardInterface } from \"../../EIP20NonStandardInterface.sol\";\n\n/**\n * @title Venus's VBep20 Contract\n * @notice vTokens which wrap an EIP-20 underlying\n * @author Venus\n */\ncontract VBep20R1 is VTokenR1, VBep20InterfaceR1 {\n    /*** User Interface ***/\n\n    /**\n     * @notice Sender supplies assets into the market and receives vTokens in exchange\n     * @dev Accrues interest whether or not the operation succeeds, unless reverted\n     * @param mintAmount The amount of the underlying asset to supply\n     * @return uint Returns 0 on success, otherwise returns a failure code (see ErrorReporter.sol for details).\n     */\n    // @custom:event Emits Transfer event\n    // @custom:event Emits Mint event\n    function mint(uint mintAmount) external returns (uint) {\n        (uint err, ) = mintInternal(mintAmount);\n        return err;\n    }\n\n    /**\n     * @notice Sender supplies assets into the market and receiver receives vTokens in exchange\n     * @dev Accrues interest whether or not the operation succeeds, unless reverted\n     * @param receiver The account which is receiving the vTokens\n     * @param mintAmount The amount of the underlying asset to supply\n     * @return uint Returns 0 on success, otherwise returns a failure code (see ErrorReporter.sol for details).\n     */\n    // @custom:event Emits Transfer event\n    // @custom:event Emits MintBehalf event\n    function mintBehalf(address receiver, uint mintAmount) external returns (uint) {\n        (uint err, ) = mintBehalfInternal(receiver, mintAmount);\n        return err;\n    }\n\n    /**\n     * @notice Sender redeems vTokens in exchange for the underlying asset\n     * @dev Accrues interest whether or not the operation succeeds, unless reverted\n     * @param redeemTokens The number of vTokens to redeem into underlying\n     * @return uint Returns 0 on success, otherwise returns a failure code (see ErrorReporter.sol for details).\n     */\n    // @custom:event Emits Redeem event on success\n    // @custom:event Emits Transfer event on success\n    // @custom:event Emits RedeemFee when fee is charged by the treasury\n    function redeem(uint redeemTokens) external returns (uint) {\n        return redeemInternal(msg.sender, msg.sender, redeemTokens);\n    }\n\n    /**\n     * @notice Sender redeems assets on behalf of some other address. This function is only available\n     *   for senders, explicitly marked as delegates of the supplier using `comptroller.updateDelegate`\n     * @dev Accrues interest whether or not the operation succeeds, unless reverted\n     * @param redeemer The user on behalf of whom to redeem\n     * @param redeemTokens The number of vTokens to redeem into underlying\n     * @return uint Returns 0 on success, otherwise returns a failure code (see ErrorReporter.sol for details).\n     */\n    // @custom:event Emits Redeem event on success\n    // @custom:event Emits Transfer event on success\n    // @custom:event Emits RedeemFee when fee is charged by the treasury\n    function redeemBehalf(address redeemer, uint redeemTokens) external returns (uint) {\n        require(comptroller.approvedDelegates(redeemer, msg.sender), \"not an approved delegate\");\n\n        return redeemInternal(redeemer, msg.sender, redeemTokens);\n    }\n\n    /**\n     * @notice Sender redeems vTokens in exchange for a specified amount of underlying asset\n     * @dev Accrues interest whether or not the operation succeeds, unless reverted\n     * @param redeemAmount The amount of underlying to redeem\n     * @return uint Returns 0 on success, otherwise returns a failure code (see ErrorReporter.sol for details).\n     */\n    // @custom:event Emits Redeem event on success\n    // @custom:event Emits Transfer event on success\n    // @custom:event Emits RedeemFee when fee is charged by the treasury\n    function redeemUnderlying(uint redeemAmount) external returns (uint) {\n        return redeemUnderlyingInternal(msg.sender, msg.sender, redeemAmount);\n    }\n\n    /**\n     * @notice Sender redeems underlying assets on behalf of some other address. This function is only available\n     *   for senders, explicitly marked as delegates of the supplier using `comptroller.updateDelegate`\n     * @dev Accrues interest whether or not the operation succeeds, unless reverted\n     * @param redeemer, on behalf of whom to redeem\n     * @param redeemAmount The amount of underlying to receive from redeeming vTokens\n     * @return uint Returns 0 on success, otherwise returns a failure code (see ErrorReporter.sol for details).\n     */\n    // @custom:event Emits Redeem event on success\n    // @custom:event Emits Transfer event on success\n    // @custom:event Emits RedeemFee when fee is charged by the treasury\n    function redeemUnderlyingBehalf(address redeemer, uint redeemAmount) external returns (uint) {\n        require(comptroller.approvedDelegates(redeemer, msg.sender), \"not an approved delegate\");\n\n        return redeemUnderlyingInternal(redeemer, msg.sender, redeemAmount);\n    }\n\n    /**\n     * @notice Sender borrows assets from the protocol to their own address\n     * @param borrowAmount The amount of the underlying asset to borrow\n     * @return uint Returns 0 on success, otherwise returns a failure code (see ErrorReporter.sol for details).\n     */\n    // @custom:event Emits Borrow event on success\n    function borrow(uint borrowAmount) external returns (uint) {\n        return borrowInternal(msg.sender, msg.sender, borrowAmount);\n    }\n\n    /**\n     * @notice Sender borrows assets on behalf of some other address. This function is only available\n     *   for senders, explicitly marked as delegates of the borrower using `comptroller.updateDelegate`\n     * @param borrower The borrower, on behalf of whom to borrow.\n     * @param borrowAmount The amount of the underlying asset to borrow\n     * @return uint Returns 0 on success, otherwise returns a failure code (see ErrorReporter.sol for details).\n     */\n    // @custom:event Emits Borrow event on success\n    function borrowBehalf(address borrower, uint borrowAmount) external returns (uint) {\n        require(comptroller.approvedDelegates(borrower, msg.sender), \"not an approved delegate\");\n        return borrowInternal(borrower, msg.sender, borrowAmount);\n    }\n\n    /**\n     * @notice Sender repays their own borrow\n     * @param repayAmount The amount to repay\n     * @return uint Returns 0 on success, otherwise returns a failure code (see ErrorReporter.sol for details).\n     */\n    // @custom:event Emits RepayBorrow event on success\n    function repayBorrow(uint repayAmount) external returns (uint) {\n        (uint err, ) = repayBorrowInternal(repayAmount);\n        return err;\n    }\n\n    /**\n     * @notice Sender repays a borrow belonging to another borrowing account\n     * @param borrower The account with the debt being payed off\n     * @param repayAmount The amount to repay\n     * @return uint Returns 0 on success, otherwise returns a failure code (see ErrorReporter.sol for details).\n     */\n    // @custom:event Emits RepayBorrow event on success\n    function repayBorrowBehalf(address borrower, uint repayAmount) external returns (uint) {\n        (uint err, ) = repayBorrowBehalfInternal(borrower, repayAmount);\n        return err;\n    }\n\n    /**\n     * @notice The sender liquidates the borrowers collateral.\n     *  The collateral seized is transferred to the liquidator.\n     * @param borrower The borrower of this vToken to be liquidated\n     * @param repayAmount The amount of the underlying borrowed asset to repay\n     * @param vTokenCollateral The market in which to seize collateral from the borrower\n     * @return uint Returns 0 on success, otherwise returns a failure code (see ErrorReporter.sol for details).\n     */\n    // @custom:event Emit LiquidateBorrow event on success\n    function liquidateBorrow(\n        address borrower,\n        uint repayAmount,\n        VTokenInterfaceR1 vTokenCollateral\n    ) external returns (uint) {\n        (uint err, ) = liquidateBorrowInternal(borrower, repayAmount, vTokenCollateral);\n        return err;\n    }\n\n    /**\n     * @notice The sender adds to reserves.\n     * @param addAmount The amount of underlying tokens to add as reserves\n     * @return uint Returns 0 on success, otherwise returns a failure code (see ErrorReporter.sol for details).\n     */\n    // @custom:event Emits ReservesAdded event\n    function _addReserves(uint addAmount) external returns (uint) {\n        return _addReservesInternal(addAmount);\n    }\n\n    /**\n     * @notice Initialize the new money market\n     * @param underlying_ The address of the underlying asset\n     * @param comptroller_ The address of the Comptroller\n     * @param interestRateModel_ The address of the interest rate model\n     * @param initialExchangeRateMantissa_ The initial exchange rate, scaled by 1e18\n     * @param name_ BEP-20 name of this token\n     * @param symbol_ BEP-20 symbol of this token\n     * @param decimals_ BEP-20 decimal precision of this token\n     */\n    function initialize(\n        address underlying_,\n        ComptrollerInterface comptroller_,\n        InterestRateModel interestRateModel_,\n        uint initialExchangeRateMantissa_,\n        string memory name_,\n        string memory symbol_,\n        uint8 decimals_\n    ) public {\n        // VToken initialize does the bulk of the work\n        super.initialize(comptroller_, interestRateModel_, initialExchangeRateMantissa_, name_, symbol_, decimals_);\n\n        // Set underlying and sanity check it\n        underlying = underlying_;\n        EIP20Interface(underlying).totalSupply();\n    }\n\n    /*** Safe Token ***/\n\n    /**\n     * @dev Similar to EIP20 transfer, except it handles a False result from `transferFrom` and reverts in that case.\n     *      This will revert due to insufficient balance or insufficient allowance.\n     *      This function returns the actual amount received,\n     *      which may be less than `amount` if there is a fee attached to the transfer.\n     *\n     *      Note: This wrapper safely handles non-standard BEP-20 tokens that do not return a value.\n     *            See here: https://medium.com/coinmonks/missing-return-value-bug-at-least-130-tokens-affected-d67bf08521ca\n     */\n    function doTransferIn(address from, uint amount) internal returns (uint) {\n        uint balanceBefore = EIP20Interface(underlying).balanceOf(address(this));\n        EIP20NonStandardInterface(underlying).transferFrom(from, address(this), amount);\n\n        bool success;\n        assembly {\n            switch returndatasize()\n            case 0 {\n                // This is a non-standard BEP-20\n                success := not(0) // set success to true\n            }\n            case 32 {\n                // This is a compliant BEP-20\n                returndatacopy(0, 0, 32)\n                success := mload(0) // Set `success = returndata` of external call\n            }\n            default {\n                // This is an excessively non-compliant BEP-20, revert.\n                revert(0, 0)\n            }\n        }\n        require(success, \"TOKEN_TRANSFER_IN_FAILED\");\n\n        // Calculate the amount that was *actually* transferred\n        uint balanceAfter = EIP20Interface(underlying).balanceOf(address(this));\n        require(balanceAfter >= balanceBefore, \"TOKEN_TRANSFER_IN_OVERFLOW\");\n        return balanceAfter - balanceBefore; // underflow already checked above, just subtract\n    }\n\n    /**\n     * @dev Similar to EIP20 transfer, except it handles a False success from `transfer` and returns an explanatory\n     *      error code rather than reverting. If caller has not called checked protocol's balance, this may revert due to\n     *      insufficient cash held in this contract. If caller has checked protocol's balance prior to this call, and verified\n     *      it is >= amount, this should not revert in normal conditions.\n     *\n     *      Note: This wrapper safely handles non-standard BEP-20 tokens that do not return a value.\n     *            See here: https://medium.com/coinmonks/missing-return-value-bug-at-least-130-tokens-affected-d67bf08521ca\n     */\n    function doTransferOut(address payable to, uint amount) internal {\n        EIP20NonStandardInterface(underlying).transfer(to, amount);\n\n        bool success;\n        assembly {\n            switch returndatasize()\n            case 0 {\n                // This is a non-standard BEP-20\n                success := not(0) // set success to true\n            }\n            case 32 {\n                // This is a compliant BEP-20\n                returndatacopy(0, 0, 32)\n                success := mload(0) // Set `success = returndata` of external call\n            }\n            default {\n                // This is an excessively non-compliant BEP-20, revert.\n                revert(0, 0)\n            }\n        }\n        require(success, \"TOKEN_TRANSFER_OUT_FAILED\");\n    }\n\n    /**\n     * @notice Gets balance of this contract in terms of the underlying\n     * @dev This excludes the value of the current message, if any\n     * @return The quantity of underlying tokens owned by this contract\n     */\n    function getCashPrior() internal view returns (uint) {\n        return EIP20Interface(underlying).balanceOf(address(this));\n    }\n}\n"
+    },
+    "contracts/Tokens/VTokens/legacy/VTokenInterfaceR1.sol": {
+      "content": "pragma solidity ^0.5.16;\n\nimport \"./ComptrollerInterface.sol\";\nimport \"../../../InterestRateModels/InterestRateModel.sol\";\nimport { VTokenStorageR1 } from \"./VTokenStorageR1.sol\";\n\ncontract VTokenInterfaceR1 is VTokenStorageR1 {\n    /**\n     * @notice Indicator that this is a vToken contract (for inspection)\n     */\n    bool public constant isVToken = true;\n\n    /*** Market Events ***/\n\n    /**\n     * @notice Event emitted when interest is accrued\n     */\n    event AccrueInterest(uint cashPrior, uint interestAccumulated, uint borrowIndex, uint totalBorrows);\n\n    /**\n     * @notice Event emitted when tokens are minted\n     */\n    event Mint(address minter, uint mintAmount, uint mintTokens);\n\n    /**\n     * @notice Event emitted when tokens are minted behalf by payer to receiver\n     */\n    event MintBehalf(address payer, address receiver, uint mintAmount, uint mintTokens);\n\n    /**\n     * @notice Event emitted when tokens are redeemed\n     */\n    event Redeem(address redeemer, uint redeemAmount, uint redeemTokens);\n\n    /**\n     * @notice Event emitted when tokens are redeemed and fee is transferred\n     */\n    event RedeemFee(address redeemer, uint feeAmount, uint redeemTokens);\n\n    /**\n     * @notice Event emitted when underlying is borrowed\n     */\n    event Borrow(address borrower, uint borrowAmount, uint accountBorrows, uint totalBorrows);\n\n    /**\n     * @notice Event emitted when a borrow is repaid\n     */\n    event RepayBorrow(address payer, address borrower, uint repayAmount, uint accountBorrows, uint totalBorrows);\n\n    /**\n     * @notice Event emitted when a borrow is liquidated\n     */\n    event LiquidateBorrow(\n        address liquidator,\n        address borrower,\n        uint repayAmount,\n        address vTokenCollateral,\n        uint seizeTokens\n    );\n\n    /*** Admin Events ***/\n\n    /**\n     * @notice Event emitted when pendingAdmin is changed\n     */\n    event NewPendingAdmin(address oldPendingAdmin, address newPendingAdmin);\n\n    /**\n     * @notice Event emitted when pendingAdmin is accepted, which means admin has been updated\n     */\n    event NewAdmin(address oldAdmin, address newAdmin);\n\n    /**\n     * @notice Event emitted when comptroller is changed\n     */\n    event NewComptroller(ComptrollerInterface oldComptroller, ComptrollerInterface newComptroller);\n\n    /**\n     * @notice Event emitted when interestRateModel is changed\n     */\n    event NewMarketInterestRateModel(InterestRateModel oldInterestRateModel, InterestRateModel newInterestRateModel);\n\n    /**\n     * @notice Event emitted when the reserve factor is changed\n     */\n    event NewReserveFactor(uint oldReserveFactorMantissa, uint newReserveFactorMantissa);\n\n    /**\n     * @notice Event emitted when the reserves are added\n     */\n    event ReservesAdded(address benefactor, uint addAmount, uint newTotalReserves);\n\n    /**\n     * @notice Event emitted when the reserves are reduced\n     */\n    event ReservesReduced(address protocolShareReserve, uint reduceAmount, uint newTotalReserves);\n\n    /**\n     * @notice EIP20 Transfer event\n     */\n    event Transfer(address indexed from, address indexed to, uint amount);\n\n    /**\n     * @notice EIP20 Approval event\n     */\n    event Approval(address indexed owner, address indexed spender, uint amount);\n\n    /**\n     * @notice Event emitted when block delta for reduce reserves get updated\n     */\n    event NewReduceReservesBlockDelta(uint256 oldReduceReservesBlockDelta, uint256 newReduceReservesBlockDelta);\n\n    /**\n     * @notice Event emitted when address of ProtocolShareReserve contract get updated\n     */\n    event NewProtocolShareReserve(address indexed oldProtocolShareReserve, address indexed newProtocolShareReserve);\n\n    /**\n     * @notice Failure event\n     */\n    event Failure(uint error, uint info, uint detail);\n\n    /// @notice Emitted when access control address is changed by admin\n    event NewAccessControlManager(address oldAccessControlAddress, address newAccessControlAddress);\n\n    /*** User Interface ***/\n\n    function transfer(address dst, uint amount) external returns (bool);\n\n    function transferFrom(address src, address dst, uint amount) external returns (bool);\n\n    function approve(address spender, uint amount) external returns (bool);\n\n    function balanceOfUnderlying(address owner) external returns (uint);\n\n    function totalBorrowsCurrent() external returns (uint);\n\n    function borrowBalanceCurrent(address account) external returns (uint);\n\n    function seize(address liquidator, address borrower, uint seizeTokens) external returns (uint);\n\n    /*** Admin Function ***/\n    function _setPendingAdmin(address payable newPendingAdmin) external returns (uint);\n\n    /*** Admin Function ***/\n    function _acceptAdmin() external returns (uint);\n\n    /*** Admin Function ***/\n    function _setReserveFactor(uint newReserveFactorMantissa) external returns (uint);\n\n    /*** Admin Function ***/\n    function _reduceReserves(uint reduceAmount) external returns (uint);\n\n    function balanceOf(address owner) external view returns (uint);\n\n    function allowance(address owner, address spender) external view returns (uint);\n\n    function getAccountSnapshot(address account) external view returns (uint, uint, uint, uint);\n\n    function borrowRatePerBlock() external view returns (uint);\n\n    function supplyRatePerBlock() external view returns (uint);\n\n    function getCash() external view returns (uint);\n\n    function exchangeRateCurrent() public returns (uint);\n\n    function accrueInterest() public returns (uint);\n\n    /*** Admin Function ***/\n    function _setComptroller(ComptrollerInterface newComptroller) public returns (uint);\n\n    /*** Admin Function ***/\n    function _setInterestRateModel(InterestRateModel newInterestRateModel) public returns (uint);\n\n    function borrowBalanceStored(address account) public view returns (uint);\n\n    function exchangeRateStored() public view returns (uint);\n}\n\ninterface VBep20InterfaceR1 {\n    /*** User Interface ***/\n\n    function mint(uint mintAmount) external returns (uint);\n\n    function mintBehalf(address receiver, uint mintAmount) external returns (uint);\n\n    function redeem(uint redeemTokens) external returns (uint);\n\n    function redeemUnderlying(uint redeemAmount) external returns (uint);\n\n    function borrow(uint borrowAmount) external returns (uint);\n\n    function repayBorrow(uint repayAmount) external returns (uint);\n\n    function repayBorrowBehalf(address borrower, uint repayAmount) external returns (uint);\n\n    function liquidateBorrow(\n        address borrower,\n        uint repayAmount,\n        VTokenInterfaceR1 vTokenCollateral\n    ) external returns (uint);\n\n    /*** Admin Functions ***/\n\n    function _addReserves(uint addAmount) external returns (uint);\n}\n\ninterface VDelegatorInterfaceR1 {\n    /**\n     * @notice Emitted when implementation is changed\n     */\n    event NewImplementation(address oldImplementation, address newImplementation);\n\n    /**\n     * @notice Called by the admin to update the implementation of the delegator\n     * @param implementation_ The address of the new implementation for delegation\n     * @param allowResign Flag to indicate whether to call _resignImplementation on the old implementation\n     * @param becomeImplementationData The encoded bytes data to be passed to _becomeImplementation\n     */\n    function _setImplementation(\n        address implementation_,\n        bool allowResign,\n        bytes calldata becomeImplementationData\n    ) external;\n}\n\ninterface VDelegateInterfaceR1 {\n    /**\n     * @notice Called by the delegator on a delegate to initialize it for duty\n     * @dev Should revert if any issues arise which make it unfit for delegation\n     * @param data The encoded bytes data for any initialization\n     */\n    function _becomeImplementation(bytes calldata data) external;\n\n    /**\n     * @notice Called by the delegator on a delegate to forfeit its responsibility\n     */\n    function _resignImplementation() external;\n}\n"
+    },
+    "contracts/Tokens/VTokens/legacy/VTokenR1.sol": {
+      "content": "pragma solidity ^0.5.16;\n\nimport { ComptrollerInterface, IComptroller } from \"./ComptrollerInterface.sol\";\nimport { TokenErrorReporter } from \"./Utils/ErrorReporter.sol\";\nimport { Exponential } from \"./Utils/Exponential.sol\";\nimport { InterestRateModel } from \"../../../InterestRateModels/InterestRateModel.sol\";\nimport { VTokenInterfaceR1 } from \"./VTokenInterfaceR1.sol\";\nimport { IProtocolShareReserveV5 } from \"./IProtocolShareReserveV5.sol\";\nimport { IAccessControlManagerV5 } from \"@venusprotocol/governance-contracts/contracts/Governance/IAccessControlManagerV5.sol\";\n\n/**\n * @title Venus's vToken Contract\n * @notice Abstract base for vTokens\n * @author Venus\n */\ncontract VTokenR1 is VTokenInterfaceR1, Exponential, TokenErrorReporter {\n    struct MintLocalVars {\n        MathError mathErr;\n        uint exchangeRateMantissa;\n        uint mintTokens;\n        uint totalSupplyNew;\n        uint accountTokensNew;\n        uint actualMintAmount;\n    }\n\n    struct RedeemLocalVars {\n        MathError mathErr;\n        uint exchangeRateMantissa;\n        uint redeemTokens;\n        uint redeemAmount;\n        uint totalSupplyNew;\n        uint accountTokensNew;\n    }\n\n    struct BorrowLocalVars {\n        MathError mathErr;\n        uint accountBorrows;\n        uint accountBorrowsNew;\n        uint totalBorrowsNew;\n    }\n\n    struct RepayBorrowLocalVars {\n        Error err;\n        MathError mathErr;\n        uint repayAmount;\n        uint borrowerIndex;\n        uint accountBorrows;\n        uint accountBorrowsNew;\n        uint totalBorrowsNew;\n        uint actualRepayAmount;\n    }\n\n    /*** Reentrancy Guard ***/\n\n    /**\n     * @dev Prevents a contract from calling itself, directly or indirectly.\n     */\n    modifier nonReentrant() {\n        require(_notEntered, \"re-entered\");\n        _notEntered = false;\n        _;\n        _notEntered = true; // get a gas-refund post-Istanbul\n    }\n\n    /**\n     * @notice Transfer `amount` tokens from `msg.sender` to `dst`\n     * @param dst The address of the destination account\n     * @param amount The number of tokens to transfer\n     * @return Whether or not the transfer succeeded\n     */\n    // @custom:event Emits Transfer event\n    function transfer(address dst, uint256 amount) external nonReentrant returns (bool) {\n        return transferTokens(msg.sender, msg.sender, dst, amount) == uint(Error.NO_ERROR);\n    }\n\n    /**\n     * @notice Transfer `amount` tokens from `src` to `dst`\n     * @param src The address of the source account\n     * @param dst The address of the destination account\n     * @param amount The number of tokens to transfer\n     * @return Whether or not the transfer succeeded\n     */\n    // @custom:event Emits Transfer event\n    function transferFrom(address src, address dst, uint256 amount) external nonReentrant returns (bool) {\n        return transferTokens(msg.sender, src, dst, amount) == uint(Error.NO_ERROR);\n    }\n\n    /**\n     * @notice Approve `spender` to transfer up to `amount` from `src`\n     * @dev This will overwrite the approval amount for `spender`\n     *  and is subject to issues noted [here](https://eips.ethereum.org/EIPS/eip-20#approve)\n     * @param spender The address of the account which may transfer tokens\n     * @param amount The number of tokens that are approved (-1 means infinite)\n     * @return Whether or not the approval succeeded\n     */\n    // @custom:event Emits Approval event on successful approve\n    function approve(address spender, uint256 amount) external returns (bool) {\n        transferAllowances[msg.sender][spender] = amount;\n        emit Approval(msg.sender, spender, amount);\n        return true;\n    }\n\n    /**\n     * @notice Get the underlying balance of the `owner`\n     * @dev This also accrues interest in a transaction\n     * @param owner The address of the account to query\n     * @return The amount of underlying owned by `owner`\n     */\n    function balanceOfUnderlying(address owner) external returns (uint) {\n        Exp memory exchangeRate = Exp({ mantissa: exchangeRateCurrent() });\n        (MathError mErr, uint balance) = mulScalarTruncate(exchangeRate, accountTokens[owner]);\n        ensureNoMathError(mErr);\n        return balance;\n    }\n\n    /**\n     * @notice Returns the current total borrows plus accrued interest\n     * @return The total borrows with interest\n     */\n    function totalBorrowsCurrent() external nonReentrant returns (uint) {\n        require(accrueInterest() == uint(Error.NO_ERROR), \"accrue interest failed\");\n        return totalBorrows;\n    }\n\n    /**\n     * @notice Accrue interest to updated borrowIndex and then calculate account's borrow balance using the updated borrowIndex\n     * @param account The address whose balance should be calculated after updating borrowIndex\n     * @return The calculated balance\n     */\n    function borrowBalanceCurrent(address account) external nonReentrant returns (uint) {\n        require(accrueInterest() == uint(Error.NO_ERROR), \"accrue interest failed\");\n        return borrowBalanceStored(account);\n    }\n\n    /**\n     * @notice Transfers collateral tokens (this market) to the liquidator.\n     * @dev Will fail unless called by another vToken during the process of liquidation.\n     *  Its absolutely critical to use msg.sender as the borrowed vToken and not a parameter.\n     * @param liquidator The account receiving seized collateral\n     * @param borrower The account having collateral seized\n     * @param seizeTokens The number of vTokens to seize\n     * @return uint Returns 0 on success, otherwise returns a failure code (see ErrorReporter.sol for details).\n     */\n    // @custom:event Emits Transfer event\n    function seize(address liquidator, address borrower, uint seizeTokens) external nonReentrant returns (uint) {\n        return seizeInternal(msg.sender, liquidator, borrower, seizeTokens);\n    }\n\n    /**\n     * @notice Begins transfer of admin rights. The newPendingAdmin must call `_acceptAdmin` to finalize the transfer.\n     * @dev Admin function to begin change of admin. The newPendingAdmin must call `_acceptAdmin` to finalize the transfer.\n     * @param newPendingAdmin New pending admin.\n     * @return uint Returns 0 on success, otherwise returns a failure code (see ErrorReporter.sol for details).\n     */\n    // @custom:event Emits NewPendingAdmin event with old and new admin addresses\n    function _setPendingAdmin(address payable newPendingAdmin) external returns (uint) {\n        // Check caller = admin\n        ensureAdmin(msg.sender);\n\n        // Save current value, if any, for inclusion in log\n        address oldPendingAdmin = pendingAdmin;\n\n        // Store pendingAdmin with value newPendingAdmin\n        pendingAdmin = newPendingAdmin;\n\n        // Emit NewPendingAdmin(oldPendingAdmin, newPendingAdmin)\n        emit NewPendingAdmin(oldPendingAdmin, newPendingAdmin);\n\n        return uint(Error.NO_ERROR);\n    }\n\n    /**\n     * @notice Accepts transfer of admin rights. msg.sender must be pendingAdmin\n     * @dev Admin function for pending admin to accept role and update admin\n     * @return uint Returns 0 on success, otherwise returns a failure code (see ErrorReporter.sol for details).\n     */\n    // @custom:event Emits NewAdmin event on successful acceptance\n    // @custom:event Emits NewPendingAdmin event with null new pending admin\n    function _acceptAdmin() external returns (uint) {\n        // Check caller is pendingAdmin\n        if (msg.sender != pendingAdmin) {\n            return fail(Error.UNAUTHORIZED, FailureInfo.ACCEPT_ADMIN_PENDING_ADMIN_CHECK);\n        }\n\n        // Save current values for inclusion in log\n        address oldAdmin = admin;\n        address oldPendingAdmin = pendingAdmin;\n\n        // Store admin with value pendingAdmin\n        admin = pendingAdmin;\n\n        // Clear the pending value\n        pendingAdmin = address(0);\n\n        emit NewAdmin(oldAdmin, admin);\n        emit NewPendingAdmin(oldPendingAdmin, pendingAdmin);\n\n        return uint(Error.NO_ERROR);\n    }\n\n    /**\n     * @notice accrues interest and sets a new reserve factor for the protocol using `_setReserveFactorFresh`\n     * @dev Governor function to accrue interest and set a new reserve factor\n     * @return uint Returns 0 on success, otherwise returns a failure code (see ErrorReporter.sol for details).\n     */\n    // @custom:event Emits NewReserveFactor event\n    function _setReserveFactor(uint newReserveFactorMantissa_) external nonReentrant returns (uint) {\n        ensureAllowed(\"_setReserveFactor(uint256)\");\n        uint error = accrueInterest();\n        if (error != uint(Error.NO_ERROR)) {\n            // accrueInterest emits logs on errors, but on top of that we want to log the fact that an attempted reserve factor change failed.\n            return fail(Error(error), FailureInfo.SET_RESERVE_FACTOR_ACCRUE_INTEREST_FAILED);\n        }\n        // _setReserveFactorFresh emits reserve-factor-specific logs on errors, so we don't need to.\n        return _setReserveFactorFresh(newReserveFactorMantissa_);\n    }\n\n    /**\n     * @notice Sets the address of the access control manager of this contract\n     * @dev Admin function to set the access control address\n     * @param newAccessControlManagerAddress New address for the access control\n     * @return uint 0=success, otherwise will revert\n     */\n    function setAccessControlManager(address newAccessControlManagerAddress) external returns (uint) {\n        // Check caller is admin\n        ensureAdmin(msg.sender);\n\n        ensureNonZeroAddress(newAccessControlManagerAddress);\n\n        emit NewAccessControlManager(accessControlManager, newAccessControlManagerAddress);\n        accessControlManager = newAccessControlManagerAddress;\n\n        return uint(Error.NO_ERROR);\n    }\n\n    /**\n     * @notice Accrues interest and reduces reserves by transferring to protocol share reserve\n     * @param reduceAmount_ Amount of reduction to reserves\n     * @return uint Returns 0 on success, otherwise returns a failure code (see ErrorReporter.sol for details).\n     */\n    // @custom:event Emits ReservesReduced event\n    function _reduceReserves(uint reduceAmount_) external nonReentrant returns (uint) {\n        ensureAllowed(\"_reduceReserves(uint256)\");\n        uint error = accrueInterest();\n        if (error != uint(Error.NO_ERROR)) {\n            // accrueInterest emits logs on errors, but on top of that we want to log the fact that an attempted reduce reserves failed.\n            return fail(Error(error), FailureInfo.REDUCE_RESERVES_ACCRUE_INTEREST_FAILED);\n        }\n\n        // If reserves were reduced in accrueInterest\n        if (reduceReservesBlockNumber == block.number) return (uint(Error.NO_ERROR));\n        // _reduceReservesFresh emits reserve-reduction-specific logs on errors, so we don't need to.\n        return _reduceReservesFresh(reduceAmount_);\n    }\n\n    /**\n     * @notice Get the current allowance from `owner` for `spender`\n     * @param owner The address of the account which owns the tokens to be spent\n     * @param spender The address of the account which may transfer tokens\n     * @return The number of tokens allowed to be spent (-1 means infinite)\n     */\n    function allowance(address owner, address spender) external view returns (uint256) {\n        return transferAllowances[owner][spender];\n    }\n\n    /**\n     * @notice Get the token balance of the `owner`\n     * @param owner The address of the account to query\n     * @return The number of tokens owned by `owner`\n     */\n    function balanceOf(address owner) external view returns (uint256) {\n        return accountTokens[owner];\n    }\n\n    /**\n     * @notice Get a snapshot of the account's balances, and the cached exchange rate\n     * @dev This is used by comptroller to more efficiently perform liquidity checks.\n     * @param account Address of the account to snapshot\n     * @return (possible error, token balance, borrow balance, exchange rate mantissa)\n     */\n    function getAccountSnapshot(address account) external view returns (uint, uint, uint, uint) {\n        uint vTokenBalance = accountTokens[account];\n        uint borrowBalance;\n        uint exchangeRateMantissa;\n\n        MathError mErr;\n\n        (mErr, borrowBalance) = borrowBalanceStoredInternal(account);\n        if (mErr != MathError.NO_ERROR) {\n            return (uint(Error.MATH_ERROR), 0, 0, 0);\n        }\n\n        (mErr, exchangeRateMantissa) = exchangeRateStoredInternal();\n        if (mErr != MathError.NO_ERROR) {\n            return (uint(Error.MATH_ERROR), 0, 0, 0);\n        }\n\n        return (uint(Error.NO_ERROR), vTokenBalance, borrowBalance, exchangeRateMantissa);\n    }\n\n    /**\n     * @notice Returns the current per-block supply interest rate for this vToken\n     * @return The supply interest rate per block, scaled by 1e18\n     */\n    function supplyRatePerBlock() external view returns (uint) {\n        return interestRateModel.getSupplyRate(getCashPrior(), totalBorrows, totalReserves, reserveFactorMantissa);\n    }\n\n    /**\n     * @notice Returns the current per-block borrow interest rate for this vToken\n     * @return The borrow interest rate per block, scaled by 1e18\n     */\n    function borrowRatePerBlock() external view returns (uint) {\n        return interestRateModel.getBorrowRate(getCashPrior(), totalBorrows, totalReserves);\n    }\n\n    /**\n     * @notice Get cash balance of this vToken in the underlying asset\n     * @return The quantity of underlying asset owned by this contract\n     */\n    function getCash() external view returns (uint) {\n        return getCashPrior();\n    }\n\n    /**\n     * @notice Governance function to set new threshold of block difference after which funds will be sent to the protocol share reserve\n     * @param newReduceReservesBlockDelta_ block difference value\n     */\n    function setReduceReservesBlockDelta(uint256 newReduceReservesBlockDelta_) external {\n        require(newReduceReservesBlockDelta_ > 0, \"Invalid Input\");\n        ensureAllowed(\"setReduceReservesBlockDelta(uint256)\");\n        emit NewReduceReservesBlockDelta(reduceReservesBlockDelta, newReduceReservesBlockDelta_);\n        reduceReservesBlockDelta = newReduceReservesBlockDelta_;\n    }\n\n    /**\n     * @notice Sets protocol share reserve contract address\n     * @param protcolShareReserve_ The address of protocol share reserve contract\n     */\n    function setProtocolShareReserve(address payable protcolShareReserve_) external {\n        // Check caller is admin\n        ensureAdmin(msg.sender);\n        ensureNonZeroAddress(protcolShareReserve_);\n        emit NewProtocolShareReserve(protocolShareReserve, protcolShareReserve_);\n        protocolShareReserve = protcolShareReserve_;\n    }\n\n    /**\n     * @notice Initialize the money market\n     * @param comptroller_ The address of the Comptroller\n     * @param interestRateModel_ The address of the interest rate model\n     * @param initialExchangeRateMantissa_ The initial exchange rate, scaled by 1e18\n     * @param name_ EIP-20 name of this token\n     * @param symbol_ EIP-20 symbol of this token\n     * @param decimals_ EIP-20 decimal precision of this token\n     */\n    function initialize(\n        ComptrollerInterface comptroller_,\n        InterestRateModel interestRateModel_,\n        uint initialExchangeRateMantissa_,\n        string memory name_,\n        string memory symbol_,\n        uint8 decimals_\n    ) public {\n        ensureAdmin(msg.sender);\n        require(accrualBlockNumber == 0 && borrowIndex == 0, \"market may only be initialized once\");\n\n        // Set initial exchange rate\n        initialExchangeRateMantissa = initialExchangeRateMantissa_;\n        require(initialExchangeRateMantissa > 0, \"initial exchange rate must be greater than zero.\");\n\n        // Set the comptroller\n        uint err = _setComptroller(comptroller_);\n        require(err == uint(Error.NO_ERROR), \"setting comptroller failed\");\n\n        // Initialize block number and borrow index (block number mocks depend on comptroller being set)\n        accrualBlockNumber = block.number;\n        borrowIndex = mantissaOne;\n\n        // Set the interest rate model (depends on block number / borrow index)\n        err = _setInterestRateModelFresh(interestRateModel_);\n        require(err == uint(Error.NO_ERROR), \"setting interest rate model failed\");\n\n        name = name_;\n        symbol = symbol_;\n        decimals = decimals_;\n\n        // The counter starts true to prevent changing it from zero to non-zero (i.e. smaller cost/refund)\n        _notEntered = true;\n    }\n\n    /**\n     * @notice Accrue interest then return the up-to-date exchange rate\n     * @return Calculated exchange rate scaled by 1e18\n     */\n    function exchangeRateCurrent() public nonReentrant returns (uint) {\n        require(accrueInterest() == uint(Error.NO_ERROR), \"accrue interest failed\");\n        return exchangeRateStored();\n    }\n\n    /**\n     * @notice Applies accrued interest to total borrows and reserves\n     * @dev This calculates interest accrued from the last checkpointed block\n     * up to the current block and writes new checkpoint to storage and\n     * reduce spread reserves to protocol share reserve\n     * if currentBlock - reduceReservesBlockNumber >= blockDelta\n     */\n    // @custom:event Emits AccrueInterest event\n    function accrueInterest() public returns (uint) {\n        /* Remember the initial block number */\n        uint currentBlockNumber = block.number;\n        uint accrualBlockNumberPrior = accrualBlockNumber;\n\n        /* Short-circuit accumulating 0 interest */\n        if (accrualBlockNumberPrior == currentBlockNumber) {\n            return uint(Error.NO_ERROR);\n        }\n\n        /* Read the previous values out of storage */\n        uint cashPrior = getCashPrior();\n        uint borrowsPrior = totalBorrows;\n        uint reservesPrior = totalReserves;\n        uint borrowIndexPrior = borrowIndex;\n\n        /* Calculate the current borrow interest rate */\n        uint borrowRateMantissa = interestRateModel.getBorrowRate(cashPrior, borrowsPrior, reservesPrior);\n        require(borrowRateMantissa <= borrowRateMaxMantissa, \"borrow rate is absurdly high\");\n\n        /* Calculate the number of blocks elapsed since the last accrual */\n        (MathError mathErr, uint blockDelta) = subUInt(currentBlockNumber, accrualBlockNumberPrior);\n        ensureNoMathError(mathErr);\n\n        /*\n         * Calculate the interest accumulated into borrows and reserves and the new index:\n         *  simpleInterestFactor = borrowRate * blockDelta\n         *  interestAccumulated = simpleInterestFactor * totalBorrows\n         *  totalBorrowsNew = interestAccumulated + totalBorrows\n         *  totalReservesNew = interestAccumulated * reserveFactor + totalReserves\n         *  borrowIndexNew = simpleInterestFactor * borrowIndex + borrowIndex\n         */\n\n        Exp memory simpleInterestFactor;\n        uint interestAccumulated;\n        uint totalBorrowsNew;\n        uint totalReservesNew;\n        uint borrowIndexNew;\n\n        (mathErr, simpleInterestFactor) = mulScalar(Exp({ mantissa: borrowRateMantissa }), blockDelta);\n        if (mathErr != MathError.NO_ERROR) {\n            return\n                failOpaque(\n                    Error.MATH_ERROR,\n                    FailureInfo.ACCRUE_INTEREST_SIMPLE_INTEREST_FACTOR_CALCULATION_FAILED,\n                    uint(mathErr)\n                );\n        }\n\n        (mathErr, interestAccumulated) = mulScalarTruncate(simpleInterestFactor, borrowsPrior);\n        if (mathErr != MathError.NO_ERROR) {\n            return\n                failOpaque(\n                    Error.MATH_ERROR,\n                    FailureInfo.ACCRUE_INTEREST_ACCUMULATED_INTEREST_CALCULATION_FAILED,\n                    uint(mathErr)\n                );\n        }\n\n        (mathErr, totalBorrowsNew) = addUInt(interestAccumulated, borrowsPrior);\n        if (mathErr != MathError.NO_ERROR) {\n            return\n                failOpaque(\n                    Error.MATH_ERROR,\n                    FailureInfo.ACCRUE_INTEREST_NEW_TOTAL_BORROWS_CALCULATION_FAILED,\n                    uint(mathErr)\n                );\n        }\n\n        (mathErr, totalReservesNew) = mulScalarTruncateAddUInt(\n            Exp({ mantissa: reserveFactorMantissa }),\n            interestAccumulated,\n            reservesPrior\n        );\n        if (mathErr != MathError.NO_ERROR) {\n            return\n                failOpaque(\n                    Error.MATH_ERROR,\n                    FailureInfo.ACCRUE_INTEREST_NEW_TOTAL_RESERVES_CALCULATION_FAILED,\n                    uint(mathErr)\n                );\n        }\n\n        (mathErr, borrowIndexNew) = mulScalarTruncateAddUInt(simpleInterestFactor, borrowIndexPrior, borrowIndexPrior);\n        if (mathErr != MathError.NO_ERROR) {\n            return\n                failOpaque(\n                    Error.MATH_ERROR,\n                    FailureInfo.ACCRUE_INTEREST_NEW_BORROW_INDEX_CALCULATION_FAILED,\n                    uint(mathErr)\n                );\n        }\n\n        /////////////////////////\n        // EFFECTS & INTERACTIONS\n        // (No safe failures beyond this point)\n\n        /* We write the previously calculated values into storage */\n        accrualBlockNumber = currentBlockNumber;\n        borrowIndex = borrowIndexNew;\n        totalBorrows = totalBorrowsNew;\n        totalReserves = totalReservesNew;\n\n        (mathErr, blockDelta) = subUInt(currentBlockNumber, reduceReservesBlockNumber);\n        ensureNoMathError(mathErr);\n        if (blockDelta >= reduceReservesBlockDelta) {\n            reduceReservesBlockNumber = currentBlockNumber;\n            if (cashPrior < totalReservesNew) {\n                _reduceReservesFresh(cashPrior);\n            } else {\n                _reduceReservesFresh(totalReservesNew);\n            }\n        }\n\n        /* We emit an AccrueInterest event */\n        emit AccrueInterest(cashPrior, interestAccumulated, borrowIndexNew, totalBorrowsNew);\n\n        return uint(Error.NO_ERROR);\n    }\n\n    /**\n     * @notice Sets a new comptroller for the market\n     * @dev Admin function to set a new comptroller\n     * @return uint Returns 0 on success, otherwise returns a failure code (see ErrorReporter.sol for details).\n     */\n    // @custom:event Emits NewComptroller event\n    function _setComptroller(ComptrollerInterface newComptroller) public returns (uint) {\n        // Check caller is admin\n        ensureAdmin(msg.sender);\n\n        ComptrollerInterface oldComptroller = comptroller;\n        // Ensure invoke comptroller.isComptroller() returns true\n        require(newComptroller.isComptroller(), \"marker method returned false\");\n\n        // Set market's comptroller to newComptroller\n        comptroller = newComptroller;\n\n        // Emit NewComptroller(oldComptroller, newComptroller)\n        emit NewComptroller(oldComptroller, newComptroller);\n\n        return uint(Error.NO_ERROR);\n    }\n\n    /**\n     * @notice Accrues interest and updates the interest rate model using _setInterestRateModelFresh\n     * @dev Governance function to accrue interest and update the interest rate model\n     * @param newInterestRateModel_ The new interest rate model to use\n     * @return uint Returns 0 on success, otherwise returns a failure code (see ErrorReporter.sol for details).\n     */\n    function _setInterestRateModel(InterestRateModel newInterestRateModel_) public returns (uint) {\n        ensureAllowed(\"_setInterestRateModel(address)\");\n        uint error = accrueInterest();\n        if (error != uint(Error.NO_ERROR)) {\n            // accrueInterest emits logs on errors, but on top of that we want to log the fact that an attempted change of interest rate model failed\n            return fail(Error(error), FailureInfo.SET_INTEREST_RATE_MODEL_ACCRUE_INTEREST_FAILED);\n        }\n        // _setInterestRateModelFresh emits interest-rate-model-update-specific logs on errors, so we don't need to.\n        return _setInterestRateModelFresh(newInterestRateModel_);\n    }\n\n    /**\n     * @notice Calculates the exchange rate from the underlying to the VToken\n     * @dev This function does not accrue interest before calculating the exchange rate\n     * @return Calculated exchange rate scaled by 1e18\n     */\n    function exchangeRateStored() public view returns (uint) {\n        (MathError err, uint result) = exchangeRateStoredInternal();\n        ensureNoMathError(err);\n        return result;\n    }\n\n    /**\n     * @notice Return the borrow balance of account based on stored data\n     * @param account The address whose balance should be calculated\n     * @return The calculated balance\n     */\n    function borrowBalanceStored(address account) public view returns (uint) {\n        (MathError err, uint result) = borrowBalanceStoredInternal(account);\n        ensureNoMathError(err);\n        return result;\n    }\n\n    /**\n     * @notice Transfers `tokens` tokens from `src` to `dst` by `spender`\n     * @dev Called by both `transfer` and `transferFrom` internally\n     * @param spender The address of the account performing the transfer\n     * @param src The address of the source account\n     * @param dst The address of the destination account\n     * @param tokens The number of tokens to transfer\n     * @return Whether or not the transfer succeeded\n     */\n    function transferTokens(address spender, address src, address dst, uint tokens) internal returns (uint) {\n        /* Fail if transfer not allowed */\n        uint allowed = comptroller.transferAllowed(address(this), src, dst, tokens);\n        if (allowed != 0) {\n            return failOpaque(Error.COMPTROLLER_REJECTION, FailureInfo.TRANSFER_COMPTROLLER_REJECTION, allowed);\n        }\n\n        /* Do not allow self-transfers */\n        if (src == dst) {\n            return fail(Error.BAD_INPUT, FailureInfo.TRANSFER_NOT_ALLOWED);\n        }\n\n        /* Get the allowance, infinite for the account owner */\n        uint startingAllowance = 0;\n        if (spender == src) {\n            startingAllowance = uint(-1);\n        } else {\n            startingAllowance = transferAllowances[src][spender];\n        }\n\n        /* Do the calculations, checking for {under,over}flow */\n        MathError mathErr;\n        uint allowanceNew;\n        uint srvTokensNew;\n        uint dstTokensNew;\n\n        (mathErr, allowanceNew) = subUInt(startingAllowance, tokens);\n        if (mathErr != MathError.NO_ERROR) {\n            return fail(Error.MATH_ERROR, FailureInfo.TRANSFER_NOT_ALLOWED);\n        }\n\n        (mathErr, srvTokensNew) = subUInt(accountTokens[src], tokens);\n        if (mathErr != MathError.NO_ERROR) {\n            return fail(Error.MATH_ERROR, FailureInfo.TRANSFER_NOT_ENOUGH);\n        }\n\n        (mathErr, dstTokensNew) = addUInt(accountTokens[dst], tokens);\n        if (mathErr != MathError.NO_ERROR) {\n            return fail(Error.MATH_ERROR, FailureInfo.TRANSFER_TOO_MUCH);\n        }\n\n        /////////////////////////\n        // EFFECTS & INTERACTIONS\n        // (No safe failures beyond this point)\n\n        accountTokens[src] = srvTokensNew;\n        accountTokens[dst] = dstTokensNew;\n\n        /* Eat some of the allowance (if necessary) */\n        if (startingAllowance != uint(-1)) {\n            transferAllowances[src][spender] = allowanceNew;\n        }\n\n        /* We emit a Transfer event */\n        emit Transfer(src, dst, tokens);\n\n        comptroller.transferVerify(address(this), src, dst, tokens);\n\n        return uint(Error.NO_ERROR);\n    }\n\n    /**\n     * @notice Sender supplies assets into the market and receives vTokens in exchange\n     * @dev Accrues interest whether or not the operation succeeds, unless reverted\n     * @param mintAmount The amount of the underlying asset to supply\n     * @return (uint, uint) An error code (0=success, otherwise a failure, see ErrorReporter.sol), and the actual mint amount.\n     */\n    function mintInternal(uint mintAmount) internal nonReentrant returns (uint, uint) {\n        uint error = accrueInterest();\n        if (error != uint(Error.NO_ERROR)) {\n            // accrueInterest emits logs on errors, but we still want to log the fact that an attempted mint failed\n            return (fail(Error(error), FailureInfo.MINT_ACCRUE_INTEREST_FAILED), 0);\n        }\n        // mintFresh emits the actual Mint event if successful and logs on errors, so we don't need to\n        return mintFresh(msg.sender, mintAmount);\n    }\n\n    /**\n     * @notice User supplies assets into the market and receives vTokens in exchange\n     * @dev Assumes interest has already been accrued up to the current block\n     * @param minter The address of the account which is supplying the assets\n     * @param mintAmount The amount of the underlying asset to supply\n     * @return (uint, uint) An error code (0=success, otherwise a failure, see ErrorReporter.sol), and the actual mint amount.\n     */\n    function mintFresh(address minter, uint mintAmount) internal returns (uint, uint) {\n        /* Fail if mint not allowed */\n        uint allowed = comptroller.mintAllowed(address(this), minter, mintAmount);\n        if (allowed != 0) {\n            return (failOpaque(Error.COMPTROLLER_REJECTION, FailureInfo.MINT_COMPTROLLER_REJECTION, allowed), 0);\n        }\n\n        /* Verify market's block number equals current block number */\n        if (accrualBlockNumber != block.number) {\n            return (fail(Error.MARKET_NOT_FRESH, FailureInfo.MINT_FRESHNESS_CHECK), 0);\n        }\n\n        MintLocalVars memory vars;\n\n        (vars.mathErr, vars.exchangeRateMantissa) = exchangeRateStoredInternal();\n        if (vars.mathErr != MathError.NO_ERROR) {\n            return (failOpaque(Error.MATH_ERROR, FailureInfo.MINT_EXCHANGE_RATE_READ_FAILED, uint(vars.mathErr)), 0);\n        }\n\n        /////////////////////////\n        // EFFECTS & INTERACTIONS\n        // (No safe failures beyond this point)\n\n        /*\n         *  We call `doTransferIn` for the minter and the mintAmount.\n         *  Note: The vToken must handle variations between BEP-20 and BNB underlying.\n         *  `doTransferIn` reverts if anything goes wrong, since we can't be sure if\n         *  side-effects occurred. The function returns the amount actually transferred,\n         *  in case of a fee. On success, the vToken holds an additional `actualMintAmount`\n         *  of cash.\n         */\n        vars.actualMintAmount = doTransferIn(minter, mintAmount);\n\n        /*\n         * We get the current exchange rate and calculate the number of vTokens to be minted:\n         *  mintTokens = actualMintAmount / exchangeRate\n         */\n\n        (vars.mathErr, vars.mintTokens) = divScalarByExpTruncate(\n            vars.actualMintAmount,\n            Exp({ mantissa: vars.exchangeRateMantissa })\n        );\n        ensureNoMathError(vars.mathErr);\n\n        /*\n         * We calculate the new total supply of vTokens and minter token balance, checking for overflow:\n         *  totalSupplyNew = totalSupply + mintTokens\n         *  accountTokensNew = accountTokens[minter] + mintTokens\n         */\n        (vars.mathErr, vars.totalSupplyNew) = addUInt(totalSupply, vars.mintTokens);\n        ensureNoMathError(vars.mathErr);\n        (vars.mathErr, vars.accountTokensNew) = addUInt(accountTokens[minter], vars.mintTokens);\n        ensureNoMathError(vars.mathErr);\n\n        /* We write previously calculated values into storage */\n        totalSupply = vars.totalSupplyNew;\n        accountTokens[minter] = vars.accountTokensNew;\n\n        /* We emit a Mint event, and a Transfer event */\n        emit Mint(minter, vars.actualMintAmount, vars.mintTokens);\n        emit Transfer(address(this), minter, vars.mintTokens);\n\n        /* We call the defense and prime accrue interest hook */\n        comptroller.mintVerify(address(this), minter, vars.actualMintAmount, vars.mintTokens);\n\n        return (uint(Error.NO_ERROR), vars.actualMintAmount);\n    }\n\n    /**\n     * @notice Sender supplies assets into the market and receiver receives vTokens in exchange\n     * @dev Accrues interest whether or not the operation succeeds, unless reverted\n     * @param receiver The address of the account which is receiving the vTokens\n     * @param mintAmount The amount of the underlying asset to supply\n     * @return (uint, uint) An error code (0=success, otherwise a failure, see ErrorReporter.sol), and the actual mint amount.\n     */\n    function mintBehalfInternal(address receiver, uint mintAmount) internal nonReentrant returns (uint, uint) {\n        uint error = accrueInterest();\n        if (error != uint(Error.NO_ERROR)) {\n            // accrueInterest emits logs on errors, but we still want to log the fact that an attempted mintBehalf failed\n            return (fail(Error(error), FailureInfo.MINT_ACCRUE_INTEREST_FAILED), 0);\n        }\n        // mintBelahfFresh emits the actual Mint event if successful and logs on errors, so we don't need to\n        return mintBehalfFresh(msg.sender, receiver, mintAmount);\n    }\n\n    /**\n     * @notice Payer supplies assets into the market and receiver receives vTokens in exchange\n     * @dev Assumes interest has already been accrued up to the current block\n     * @param payer The address of the account which is paying the underlying token\n     * @param receiver The address of the account which is receiving vToken\n     * @param mintAmount The amount of the underlying asset to supply\n     * @return (uint, uint) An error code (0=success, otherwise a failure, see ErrorReporter.sol), and the actual mint amount.\n     */\n    function mintBehalfFresh(address payer, address receiver, uint mintAmount) internal returns (uint, uint) {\n        ensureNonZeroAddress(receiver);\n        /* Fail if mint not allowed */\n        uint allowed = comptroller.mintAllowed(address(this), receiver, mintAmount);\n        if (allowed != 0) {\n            return (failOpaque(Error.COMPTROLLER_REJECTION, FailureInfo.MINT_COMPTROLLER_REJECTION, allowed), 0);\n        }\n\n        /* Verify market's block number equals current block number */\n        if (accrualBlockNumber != block.number) {\n            return (fail(Error.MARKET_NOT_FRESH, FailureInfo.MINT_FRESHNESS_CHECK), 0);\n        }\n\n        MintLocalVars memory vars;\n\n        (vars.mathErr, vars.exchangeRateMantissa) = exchangeRateStoredInternal();\n        if (vars.mathErr != MathError.NO_ERROR) {\n            return (failOpaque(Error.MATH_ERROR, FailureInfo.MINT_EXCHANGE_RATE_READ_FAILED, uint(vars.mathErr)), 0);\n        }\n\n        /////////////////////////\n        // EFFECTS & INTERACTIONS\n        // (No safe failures beyond this point)\n\n        /*\n         *  We call `doTransferIn` for the payer and the mintAmount.\n         *  Note: The vToken must handle variations between BEP-20 and BNB underlying.\n         *  `doTransferIn` reverts if anything goes wrong, since we can't be sure if\n         *  side-effects occurred. The function returns the amount actually transferred,\n         *  in case of a fee. On success, the vToken holds an additional `actualMintAmount`\n         *  of cash.\n         */\n        vars.actualMintAmount = doTransferIn(payer, mintAmount);\n\n        /*\n         * We get the current exchange rate and calculate the number of vTokens to be minted:\n         *  mintTokens = actualMintAmount / exchangeRate\n         */\n\n        (vars.mathErr, vars.mintTokens) = divScalarByExpTruncate(\n            vars.actualMintAmount,\n            Exp({ mantissa: vars.exchangeRateMantissa })\n        );\n        ensureNoMathError(vars.mathErr);\n\n        /*\n         * We calculate the new total supply of vTokens and receiver token balance, checking for overflow:\n         *  totalSupplyNew = totalSupply + mintTokens\n         *  accountTokensNew = accountTokens[receiver] + mintTokens\n         */\n        (vars.mathErr, vars.totalSupplyNew) = addUInt(totalSupply, vars.mintTokens);\n        ensureNoMathError(vars.mathErr);\n\n        (vars.mathErr, vars.accountTokensNew) = addUInt(accountTokens[receiver], vars.mintTokens);\n        ensureNoMathError(vars.mathErr);\n\n        /* We write previously calculated values into storage */\n        totalSupply = vars.totalSupplyNew;\n        accountTokens[receiver] = vars.accountTokensNew;\n\n        /* We emit a MintBehalf event, and a Transfer event */\n        emit MintBehalf(payer, receiver, vars.actualMintAmount, vars.mintTokens);\n        emit Transfer(address(this), receiver, vars.mintTokens);\n\n        /* We call the defense and prime accrue interest hook */\n        comptroller.mintVerify(address(this), receiver, vars.actualMintAmount, vars.mintTokens);\n\n        return (uint(Error.NO_ERROR), vars.actualMintAmount);\n    }\n\n    /**\n     * @notice Redeemer redeems vTokens in exchange for the underlying assets, transferred to the receiver. Redeemer and receiver can be the same\n     *   address, or different addresses if the receiver was previously approved by the redeemer as a valid delegate (see MarketFacet.updateDelegate)\n     * @dev Accrues interest whether or not the operation succeeds, unless reverted\n     * @param redeemer The address of the account which is redeeming the tokens\n     * @param receiver The receiver of the tokens\n     * @param redeemTokens The number of vTokens to redeem into underlying\n     * @return uint Returns 0 on success, otherwise returns a failure code (see ErrorReporter.sol for details).\n     */\n    function redeemInternal(\n        address redeemer,\n        address payable receiver,\n        uint redeemTokens\n    ) internal nonReentrant returns (uint) {\n        uint error = accrueInterest();\n        if (error != uint(Error.NO_ERROR)) {\n            // accrueInterest emits logs on errors, but we still want to log the fact that an attempted redeem failed\n            return fail(Error(error), FailureInfo.REDEEM_ACCRUE_INTEREST_FAILED);\n        }\n        // redeemFresh emits redeem-specific logs on errors, so we don't need to\n        return redeemFresh(redeemer, receiver, redeemTokens, 0);\n    }\n\n    /**\n     * @notice Sender redeems underlying assets on behalf of some other address. This function is only available\n     *   for senders, explicitly marked as delegates of the supplier using `comptroller.updateDelegate`\n     * @dev Accrues interest whether or not the operation succeeds, unless reverted\n     * @param redeemer The address of the account which is redeeming the tokens\n     * @param receiver The receiver of the tokens, if called by a delegate\n     * @param redeemAmount The amount of underlying to receive from redeeming vTokens\n     * @return uint Returns 0 on success, otherwise returns a failure code (see ErrorReporter.sol for details).\n     */\n    function redeemUnderlyingInternal(\n        address redeemer,\n        address payable receiver,\n        uint redeemAmount\n    ) internal nonReentrant returns (uint) {\n        uint error = accrueInterest();\n        if (error != uint(Error.NO_ERROR)) {\n            // accrueInterest emits logs on errors, but we still want to log the fact that an attempted redeem failed\n            return fail(Error(error), FailureInfo.REDEEM_ACCRUE_INTEREST_FAILED);\n        }\n        // redeemFresh emits redeem-specific logs on errors, so we don't need to\n        return redeemFresh(redeemer, receiver, 0, redeemAmount);\n    }\n\n    /**\n     * @notice Redeemer redeems vTokens in exchange for the underlying assets, transferred to the receiver. Redeemer and receiver can be the same\n     *   address, or different addresses if the receiver was previously approved by the redeemer as a valid delegate (see MarketFacet.updateDelegate)\n     * @dev Assumes interest has already been accrued up to the current block\n     * @param redeemer The address of the account which is redeeming the tokens\n     * @param receiver The receiver of the tokens\n     * @param redeemTokensIn The number of vTokens to redeem into underlying (only one of redeemTokensIn or redeemAmountIn may be non-zero)\n     * @param redeemAmountIn The number of underlying tokens to receive from redeeming vTokens (only one of redeemTokensIn or redeemAmountIn may be non-zero)\n     * @return uint Returns 0 on success, otherwise returns a failure code (see ErrorReporter.sol for details).\n     */\n    // solhint-disable-next-line code-complexity\n    function redeemFresh(\n        address redeemer,\n        address payable receiver,\n        uint redeemTokensIn,\n        uint redeemAmountIn\n    ) internal returns (uint) {\n        require(redeemTokensIn == 0 || redeemAmountIn == 0, \"one of redeemTokensIn or redeemAmountIn must be zero\");\n\n        RedeemLocalVars memory vars;\n\n        /* exchangeRate = invoke Exchange Rate Stored() */\n        (vars.mathErr, vars.exchangeRateMantissa) = exchangeRateStoredInternal();\n        ensureNoMathError(vars.mathErr);\n\n        /* If redeemTokensIn > 0: */\n        if (redeemTokensIn > 0) {\n            /*\n             * We calculate the exchange rate and the amount of underlying to be redeemed:\n             *  redeemTokens = redeemTokensIn\n             *  redeemAmount = redeemTokensIn x exchangeRateCurrent\n             */\n            vars.redeemTokens = redeemTokensIn;\n\n            (vars.mathErr, vars.redeemAmount) = mulScalarTruncate(\n                Exp({ mantissa: vars.exchangeRateMantissa }),\n                redeemTokensIn\n            );\n            ensureNoMathError(vars.mathErr);\n        } else {\n            /*\n             * We get the current exchange rate and calculate the amount to be redeemed:\n             *  redeemTokens = redeemAmountIn / exchangeRate\n             *  redeemAmount = redeemAmountIn\n             */\n\n            (vars.mathErr, vars.redeemTokens) = divScalarByExpTruncate(\n                redeemAmountIn,\n                Exp({ mantissa: vars.exchangeRateMantissa })\n            );\n            ensureNoMathError(vars.mathErr);\n\n            vars.redeemAmount = redeemAmountIn;\n        }\n\n        /* Fail if redeem not allowed */\n        uint allowed = comptroller.redeemAllowed(address(this), redeemer, vars.redeemTokens);\n        if (allowed != 0) {\n            revert(\"math error\");\n        }\n\n        /* Verify market's block number equals current block number */\n        if (accrualBlockNumber != block.number) {\n            revert(\"math error\");\n        }\n\n        /*\n         * We calculate the new total supply and redeemer balance, checking for underflow:\n         *  totalSupplyNew = totalSupply - redeemTokens\n         *  accountTokensNew = accountTokens[redeemer] - redeemTokens\n         */\n        (vars.mathErr, vars.totalSupplyNew) = subUInt(totalSupply, vars.redeemTokens);\n        ensureNoMathError(vars.mathErr);\n\n        (vars.mathErr, vars.accountTokensNew) = subUInt(accountTokens[redeemer], vars.redeemTokens);\n        ensureNoMathError(vars.mathErr);\n\n        /* Fail gracefully if protocol has insufficient cash */\n        if (getCashPrior() < vars.redeemAmount) {\n            revert(\"math error\");\n        }\n\n        /////////////////////////\n        // EFFECTS & INTERACTIONS\n        // (No safe failures beyond this point)\n\n        /* We write previously calculated values into storage */\n        totalSupply = vars.totalSupplyNew;\n        accountTokens[redeemer] = vars.accountTokensNew;\n\n        /*\n         * We invoke doTransferOut for the receiver and the redeemAmount.\n         *  Note: The vToken must handle variations between BEP-20 and BNB underlying.\n         *  On success, the vToken has redeemAmount less of cash.\n         *  doTransferOut reverts if anything goes wrong, since we can't be sure if side effects occurred.\n         */\n\n        uint feeAmount;\n        uint remainedAmount;\n        if (IComptroller(address(comptroller)).treasuryPercent() != 0) {\n            (vars.mathErr, feeAmount) = mulUInt(\n                vars.redeemAmount,\n                IComptroller(address(comptroller)).treasuryPercent()\n            );\n            ensureNoMathError(vars.mathErr);\n\n            (vars.mathErr, feeAmount) = divUInt(feeAmount, 1e18);\n            ensureNoMathError(vars.mathErr);\n\n            (vars.mathErr, remainedAmount) = subUInt(vars.redeemAmount, feeAmount);\n            ensureNoMathError(vars.mathErr);\n\n            doTransferOut(address(uint160(IComptroller(address(comptroller)).treasuryAddress())), feeAmount);\n\n            emit RedeemFee(redeemer, feeAmount, vars.redeemTokens);\n        } else {\n            remainedAmount = vars.redeemAmount;\n        }\n\n        doTransferOut(receiver, remainedAmount);\n\n        /* We emit a Transfer event, and a Redeem event */\n        emit Transfer(redeemer, address(this), vars.redeemTokens);\n        emit Redeem(redeemer, remainedAmount, vars.redeemTokens);\n\n        /* We call the defense and prime accrue interest hook */\n        comptroller.redeemVerify(address(this), redeemer, vars.redeemAmount, vars.redeemTokens);\n\n        return uint(Error.NO_ERROR);\n    }\n\n    /**\n     * @notice Receiver gets the borrow on behalf of the borrower address\n     * @param borrower The borrower, on behalf of whom to borrow\n     * @param receiver The account that would receive the funds (can be the same as the borrower)\n     * @param borrowAmount The amount of the underlying asset to borrow\n     * @return uint Returns 0 on success, otherwise returns a failure code (see ErrorReporter.sol for details).\n     */\n    function borrowInternal(\n        address borrower,\n        address payable receiver,\n        uint borrowAmount\n    ) internal nonReentrant returns (uint) {\n        uint error = accrueInterest();\n        if (error != uint(Error.NO_ERROR)) {\n            // accrueInterest emits logs on errors, but we still want to log the fact that an attempted borrow failed\n            return fail(Error(error), FailureInfo.BORROW_ACCRUE_INTEREST_FAILED);\n        }\n        // borrowFresh emits borrow-specific logs on errors, so we don't need to\n        return borrowFresh(borrower, receiver, borrowAmount);\n    }\n\n    /**\n     * @notice Receiver gets the borrow on behalf of the borrower address\n     * @dev Before calling this function, ensure that the interest has been accrued\n     * @param borrower The borrower, on behalf of whom to borrow\n     * @param receiver The account that would receive the funds (can be the same as the borrower)\n     * @param borrowAmount The amount of the underlying asset to borrow\n     * @return uint Returns 0 on success, otherwise revert (see ErrorReporter.sol for details).\n     */\n    function borrowFresh(address borrower, address payable receiver, uint borrowAmount) internal returns (uint) {\n        /* Revert if borrow not allowed */\n        uint allowed = comptroller.borrowAllowed(address(this), borrower, borrowAmount);\n        if (allowed != 0) {\n            revert(\"math error\");\n        }\n\n        /* Verify market's block number equals current block number */\n        if (accrualBlockNumber != block.number) {\n            revert(\"math error\");\n        }\n\n        /* Revert if protocol has insufficient underlying cash */\n        if (getCashPrior() < borrowAmount) {\n            revert(\"math error\");\n        }\n\n        BorrowLocalVars memory vars;\n\n        /*\n         * We calculate the new borrower and total borrow balances, failing on overflow:\n         *  accountBorrowsNew = accountBorrows + borrowAmount\n         *  totalBorrowsNew = totalBorrows + borrowAmount\n         */\n        (vars.mathErr, vars.accountBorrows) = borrowBalanceStoredInternal(borrower);\n        ensureNoMathError(vars.mathErr);\n\n        (vars.mathErr, vars.accountBorrowsNew) = addUInt(vars.accountBorrows, borrowAmount);\n        ensureNoMathError(vars.mathErr);\n\n        (vars.mathErr, vars.totalBorrowsNew) = addUInt(totalBorrows, borrowAmount);\n        ensureNoMathError(vars.mathErr);\n\n        /////////////////////////\n        // EFFECTS & INTERACTIONS\n        // (No safe failures beyond this point)\n\n        /* We write the previously calculated values into storage */\n        accountBorrows[borrower].principal = vars.accountBorrowsNew;\n        accountBorrows[borrower].interestIndex = borrowIndex;\n        totalBorrows = vars.totalBorrowsNew;\n\n        /*\n         * We invoke doTransferOut for the receiver and the borrowAmount.\n         *  Note: The vToken must handle variations between BEP-20 and BNB underlying.\n         *  On success, the vToken borrowAmount less of cash.\n         *  doTransferOut reverts if anything goes wrong, since we can't be sure if side effects occurred.\n         */\n        doTransferOut(receiver, borrowAmount);\n\n        /* We emit a Borrow event */\n        emit Borrow(borrower, borrowAmount, vars.accountBorrowsNew, vars.totalBorrowsNew);\n\n        /* We call the defense and prime accrue interest hook */\n        comptroller.borrowVerify(address(this), borrower, borrowAmount);\n\n        return uint(Error.NO_ERROR);\n    }\n\n    /**\n     * @notice Sender repays their own borrow\n     * @param repayAmount The amount to repay\n     * @return (uint, uint) An error code (0=success, otherwise a failure, see ErrorReporter.sol), and the actual repayment amount.\n     */\n    function repayBorrowInternal(uint repayAmount) internal nonReentrant returns (uint, uint) {\n        uint error = accrueInterest();\n        if (error != uint(Error.NO_ERROR)) {\n            // accrueInterest emits logs on errors, but we still want to log the fact that an attempted borrow failed\n            return (fail(Error(error), FailureInfo.REPAY_BORROW_ACCRUE_INTEREST_FAILED), 0);\n        }\n        // repayBorrowFresh emits repay-borrow-specific logs on errors, so we don't need to\n        return repayBorrowFresh(msg.sender, msg.sender, repayAmount);\n    }\n\n    /**\n     * @notice Sender repays a borrow belonging to another borrowing account\n     * @param borrower The account with the debt being payed off\n     * @param repayAmount The amount to repay\n     * @return (uint, uint) An error code (0=success, otherwise a failure, see ErrorReporter.sol), and the actual repayment amount.\n     */\n    function repayBorrowBehalfInternal(address borrower, uint repayAmount) internal nonReentrant returns (uint, uint) {\n        uint error = accrueInterest();\n        if (error != uint(Error.NO_ERROR)) {\n            // accrueInterest emits logs on errors, but we still want to log the fact that an attempted borrow failed\n            return (fail(Error(error), FailureInfo.REPAY_BEHALF_ACCRUE_INTEREST_FAILED), 0);\n        }\n        // repayBorrowFresh emits repay-borrow-specific logs on errors, so we don't need to\n        return repayBorrowFresh(msg.sender, borrower, repayAmount);\n    }\n\n    /**\n     * @notice Borrows are repaid by another user (possibly the borrower).\n     * @param payer The account paying off the borrow\n     * @param borrower The account with the debt being payed off\n     * @param repayAmount The amount of undelrying tokens being returned\n     * @return (uint, uint) An error code (0=success, otherwise a failure, see ErrorReporter.sol), and the actual repayment amount.\n     */\n    function repayBorrowFresh(address payer, address borrower, uint repayAmount) internal returns (uint, uint) {\n        /* Fail if repayBorrow not allowed */\n        uint allowed = comptroller.repayBorrowAllowed(address(this), payer, borrower, repayAmount);\n        if (allowed != 0) {\n            return (\n                failOpaque(Error.COMPTROLLER_REJECTION, FailureInfo.REPAY_BORROW_COMPTROLLER_REJECTION, allowed),\n                0\n            );\n        }\n\n        /* Verify market's block number equals current block number */\n        if (accrualBlockNumber != block.number) {\n            return (fail(Error.MARKET_NOT_FRESH, FailureInfo.REPAY_BORROW_FRESHNESS_CHECK), 0);\n        }\n\n        RepayBorrowLocalVars memory vars;\n\n        /* We remember the original borrowerIndex for verification purposes */\n        vars.borrowerIndex = accountBorrows[borrower].interestIndex;\n\n        /* We fetch the amount the borrower owes, with accumulated interest */\n        (vars.mathErr, vars.accountBorrows) = borrowBalanceStoredInternal(borrower);\n        if (vars.mathErr != MathError.NO_ERROR) {\n            return (\n                failOpaque(\n                    Error.MATH_ERROR,\n                    FailureInfo.REPAY_BORROW_ACCUMULATED_BALANCE_CALCULATION_FAILED,\n                    uint(vars.mathErr)\n                ),\n                0\n            );\n        }\n\n        /* If repayAmount == -1, repayAmount = accountBorrows */\n        if (repayAmount == uint(-1)) {\n            vars.repayAmount = vars.accountBorrows;\n        } else {\n            vars.repayAmount = repayAmount;\n        }\n\n        /////////////////////////\n        // EFFECTS & INTERACTIONS\n        // (No safe failures beyond this point)\n\n        /*\n         * We call doTransferIn for the payer and the repayAmount\n         *  Note: The vToken must handle variations between BEP-20 and BNB underlying.\n         *  On success, the vToken holds an additional repayAmount of cash.\n         *  doTransferIn reverts if anything goes wrong, since we can't be sure if side effects occurred.\n         *   it returns the amount actually transferred, in case of a fee.\n         */\n        vars.actualRepayAmount = doTransferIn(payer, vars.repayAmount);\n\n        /*\n         * We calculate the new borrower and total borrow balances, failing on underflow:\n         *  accountBorrowsNew = accountBorrows - actualRepayAmount\n         *  totalBorrowsNew = totalBorrows - actualRepayAmount\n         */\n        (vars.mathErr, vars.accountBorrowsNew) = subUInt(vars.accountBorrows, vars.actualRepayAmount);\n        ensureNoMathError(vars.mathErr);\n\n        (vars.mathErr, vars.totalBorrowsNew) = subUInt(totalBorrows, vars.actualRepayAmount);\n        ensureNoMathError(vars.mathErr);\n\n        /* We write the previously calculated values into storage */\n        accountBorrows[borrower].principal = vars.accountBorrowsNew;\n        accountBorrows[borrower].interestIndex = borrowIndex;\n        totalBorrows = vars.totalBorrowsNew;\n\n        /* We emit a RepayBorrow event */\n        emit RepayBorrow(payer, borrower, vars.actualRepayAmount, vars.accountBorrowsNew, vars.totalBorrowsNew);\n\n        /* We call the defense and prime accrue interest hook */\n        comptroller.repayBorrowVerify(address(this), payer, borrower, vars.actualRepayAmount, vars.borrowerIndex);\n\n        return (uint(Error.NO_ERROR), vars.actualRepayAmount);\n    }\n\n    /**\n     * @notice The sender liquidates the borrowers collateral.\n     *  The collateral seized is transferred to the liquidator.\n     * @param borrower The borrower of this vToken to be liquidated\n     * @param vTokenCollateral The market in which to seize collateral from the borrower\n     * @param repayAmount The amount of the underlying borrowed asset to repay\n     * @return (uint, uint) An error code (0=success, otherwise a failure, see ErrorReporter.sol), and the actual repayment amount.\n     */\n    function liquidateBorrowInternal(\n        address borrower,\n        uint repayAmount,\n        VTokenInterfaceR1 vTokenCollateral\n    ) internal nonReentrant returns (uint, uint) {\n        uint error = accrueInterest();\n        if (error != uint(Error.NO_ERROR)) {\n            // accrueInterest emits logs on errors, but we still want to log the fact that an attempted liquidation failed\n            return (fail(Error(error), FailureInfo.LIQUIDATE_ACCRUE_BORROW_INTEREST_FAILED), 0);\n        }\n\n        error = vTokenCollateral.accrueInterest();\n        if (error != uint(Error.NO_ERROR)) {\n            // accrueInterest emits logs on errors, but we still want to log the fact that an attempted liquidation failed\n            return (fail(Error(error), FailureInfo.LIQUIDATE_ACCRUE_COLLATERAL_INTEREST_FAILED), 0);\n        }\n\n        // liquidateBorrowFresh emits borrow-specific logs on errors, so we don't need to\n        return liquidateBorrowFresh(msg.sender, borrower, repayAmount, vTokenCollateral);\n    }\n\n    /**\n     * @notice The liquidator liquidates the borrowers collateral.\n     *  The collateral seized is transferred to the liquidator.\n     * @param borrower The borrower of this vToken to be liquidated\n     * @param liquidator The address repaying the borrow and seizing collateral\n     * @param vTokenCollateral The market in which to seize collateral from the borrower\n     * @param repayAmount The amount of the underlying borrowed asset to repay\n     * @return (uint, uint) An error code (0=success, otherwise a failure, see ErrorReporter.sol), and the actual repayment amount.\n     */\n    // solhint-disable-next-line code-complexity\n    function liquidateBorrowFresh(\n        address liquidator,\n        address borrower,\n        uint repayAmount,\n        VTokenInterfaceR1 vTokenCollateral\n    ) internal returns (uint, uint) {\n        /* Fail if liquidate not allowed */\n        uint allowed = comptroller.liquidateBorrowAllowed(\n            address(this),\n            address(vTokenCollateral),\n            liquidator,\n            borrower,\n            repayAmount\n        );\n        if (allowed != 0) {\n            return (failOpaque(Error.COMPTROLLER_REJECTION, FailureInfo.LIQUIDATE_COMPTROLLER_REJECTION, allowed), 0);\n        }\n\n        /* Verify market's block number equals current block number */\n        if (accrualBlockNumber != block.number) {\n            return (fail(Error.MARKET_NOT_FRESH, FailureInfo.LIQUIDATE_FRESHNESS_CHECK), 0);\n        }\n\n        /* Verify vTokenCollateral market's block number equals current block number */\n        if (vTokenCollateral.accrualBlockNumber() != block.number) {\n            return (fail(Error.MARKET_NOT_FRESH, FailureInfo.LIQUIDATE_COLLATERAL_FRESHNESS_CHECK), 0);\n        }\n\n        /* Fail if borrower = liquidator */\n        if (borrower == liquidator) {\n            return (fail(Error.INVALID_ACCOUNT_PAIR, FailureInfo.LIQUIDATE_LIQUIDATOR_IS_BORROWER), 0);\n        }\n\n        /* Fail if repayAmount = 0 */\n        if (repayAmount == 0) {\n            return (fail(Error.INVALID_CLOSE_AMOUNT_REQUESTED, FailureInfo.LIQUIDATE_CLOSE_AMOUNT_IS_ZERO), 0);\n        }\n\n        /* Fail if repayAmount = -1 */\n        if (repayAmount == uint(-1)) {\n            return (fail(Error.INVALID_CLOSE_AMOUNT_REQUESTED, FailureInfo.LIQUIDATE_CLOSE_AMOUNT_IS_UINT_MAX), 0);\n        }\n\n        /* Fail if repayBorrow fails */\n        (uint repayBorrowError, uint actualRepayAmount) = repayBorrowFresh(liquidator, borrower, repayAmount);\n        if (repayBorrowError != uint(Error.NO_ERROR)) {\n            return (fail(Error(repayBorrowError), FailureInfo.LIQUIDATE_REPAY_BORROW_FRESH_FAILED), 0);\n        }\n\n        /////////////////////////\n        // EFFECTS & INTERACTIONS\n        // (No safe failures beyond this point)\n\n        /* We calculate the number of collateral tokens that will be seized */\n        (uint amountSeizeError, uint seizeTokens) = comptroller.liquidateCalculateSeizeTokens(\n            address(this),\n            address(vTokenCollateral),\n            actualRepayAmount\n        );\n        require(amountSeizeError == uint(Error.NO_ERROR), \"LIQUIDATE_COMPTROLLER_CALCULATE_AMOUNT_SEIZE_FAILED\");\n\n        /* Revert if borrower collateral token balance < seizeTokens */\n        require(vTokenCollateral.balanceOf(borrower) >= seizeTokens, \"LIQUIDATE_SEIZE_TOO_MUCH\");\n\n        // If this is also the collateral, run seizeInternal to avoid re-entrancy, otherwise make an external call\n        uint seizeError;\n        if (address(vTokenCollateral) == address(this)) {\n            seizeError = seizeInternal(address(this), liquidator, borrower, seizeTokens);\n        } else {\n            seizeError = vTokenCollateral.seize(liquidator, borrower, seizeTokens);\n        }\n\n        /* Revert if seize tokens fails (since we cannot be sure of side effects) */\n        require(seizeError == uint(Error.NO_ERROR), \"token seizure failed\");\n\n        /* We emit a LiquidateBorrow event */\n        emit LiquidateBorrow(liquidator, borrower, actualRepayAmount, address(vTokenCollateral), seizeTokens);\n\n        /* We call the defense and prime accrue interest hook */\n        comptroller.liquidateBorrowVerify(\n            address(this),\n            address(vTokenCollateral),\n            liquidator,\n            borrower,\n            actualRepayAmount,\n            seizeTokens\n        );\n\n        return (uint(Error.NO_ERROR), actualRepayAmount);\n    }\n\n    /**\n     * @notice Transfers collateral tokens (this market) to the liquidator.\n     * @dev Called only during an in-kind liquidation, or by liquidateBorrow during the liquidation of another vToken.\n     *  Its absolutely critical to use msg.sender as the seizer vToken and not a parameter.\n     * @param seizerToken The contract seizing the collateral (i.e. borrowed vToken)\n     * @param liquidator The account receiving seized collateral\n     * @param borrower The account having collateral seized\n     * @param seizeTokens The number of vTokens to seize\n     * @return uint Returns 0 on success, otherwise returns a failure code (see ErrorReporter.sol for details).\n     */\n    function seizeInternal(\n        address seizerToken,\n        address liquidator,\n        address borrower,\n        uint seizeTokens\n    ) internal returns (uint) {\n        /* Fail if seize not allowed */\n        uint allowed = comptroller.seizeAllowed(address(this), seizerToken, liquidator, borrower, seizeTokens);\n        if (allowed != 0) {\n            return failOpaque(Error.COMPTROLLER_REJECTION, FailureInfo.LIQUIDATE_SEIZE_COMPTROLLER_REJECTION, allowed);\n        }\n\n        /* Fail if borrower = liquidator */\n        if (borrower == liquidator) {\n            return fail(Error.INVALID_ACCOUNT_PAIR, FailureInfo.LIQUIDATE_SEIZE_LIQUIDATOR_IS_BORROWER);\n        }\n\n        MathError mathErr;\n        uint borrowerTokensNew;\n        uint liquidatorTokensNew;\n\n        /*\n         * We calculate the new borrower and liquidator token balances, failing on underflow/overflow:\n         *  borrowerTokensNew = accountTokens[borrower] - seizeTokens\n         *  liquidatorTokensNew = accountTokens[liquidator] + seizeTokens\n         */\n        (mathErr, borrowerTokensNew) = subUInt(accountTokens[borrower], seizeTokens);\n        if (mathErr != MathError.NO_ERROR) {\n            return failOpaque(Error.MATH_ERROR, FailureInfo.LIQUIDATE_SEIZE_BALANCE_DECREMENT_FAILED, uint(mathErr));\n        }\n\n        (mathErr, liquidatorTokensNew) = addUInt(accountTokens[liquidator], seizeTokens);\n        if (mathErr != MathError.NO_ERROR) {\n            return failOpaque(Error.MATH_ERROR, FailureInfo.LIQUIDATE_SEIZE_BALANCE_INCREMENT_FAILED, uint(mathErr));\n        }\n\n        /////////////////////////\n        // EFFECTS & INTERACTIONS\n        // (No safe failures beyond this point)\n\n        /* We write the previously calculated values into storage */\n        accountTokens[borrower] = borrowerTokensNew;\n        accountTokens[liquidator] = liquidatorTokensNew;\n\n        /* Emit a Transfer event */\n        emit Transfer(borrower, liquidator, seizeTokens);\n\n        /* We call the defense and prime accrue interest hook */\n        comptroller.seizeVerify(address(this), seizerToken, liquidator, borrower, seizeTokens);\n\n        return uint(Error.NO_ERROR);\n    }\n\n    /**\n     * @notice Sets a new reserve factor for the protocol (requires fresh interest accrual)\n     * @dev Governance function to set a new reserve factor\n     * @return uint Returns 0 on success, otherwise returns a failure code (see ErrorReporter.sol for details).\n     */\n    function _setReserveFactorFresh(uint newReserveFactorMantissa) internal returns (uint) {\n        // Verify market's block number equals current block number\n        if (accrualBlockNumber != block.number) {\n            return fail(Error.MARKET_NOT_FRESH, FailureInfo.SET_RESERVE_FACTOR_FRESH_CHECK);\n        }\n\n        // Check newReserveFactor ≤ maxReserveFactor\n        if (newReserveFactorMantissa > reserveFactorMaxMantissa) {\n            return fail(Error.BAD_INPUT, FailureInfo.SET_RESERVE_FACTOR_BOUNDS_CHECK);\n        }\n\n        uint oldReserveFactorMantissa = reserveFactorMantissa;\n        reserveFactorMantissa = newReserveFactorMantissa;\n\n        emit NewReserveFactor(oldReserveFactorMantissa, newReserveFactorMantissa);\n\n        return uint(Error.NO_ERROR);\n    }\n\n    /**\n     * @notice Accrues interest and adds reserves by transferring from `msg.sender`\n     * @param addAmount Amount of addition to reserves\n     * @return uint Returns 0 on success, otherwise returns a failure code (see ErrorReporter.sol for details).\n     */\n    function _addReservesInternal(uint addAmount) internal nonReentrant returns (uint) {\n        uint error = accrueInterest();\n        if (error != uint(Error.NO_ERROR)) {\n            // accrueInterest emits logs on errors, but on top of that we want to log the fact that an attempted reduce reserves failed.\n            return fail(Error(error), FailureInfo.ADD_RESERVES_ACCRUE_INTEREST_FAILED);\n        }\n\n        // _addReservesFresh emits reserve-addition-specific logs on errors, so we don't need to.\n        (error, ) = _addReservesFresh(addAmount);\n        return error;\n    }\n\n    /**\n     * @notice Add reserves by transferring from caller\n     * @dev Requires fresh interest accrual\n     * @param addAmount Amount of addition to reserves\n     * @return (uint, uint) An error code (0=success, otherwise a failure (see ErrorReporter.sol for details)) and the actual amount added, net token fees\n     */\n    function _addReservesFresh(uint addAmount) internal returns (uint, uint) {\n        // totalReserves + actualAddAmount\n        uint totalReservesNew;\n        uint actualAddAmount;\n\n        // We fail gracefully unless market's block number equals current block number\n        if (accrualBlockNumber != block.number) {\n            return (fail(Error.MARKET_NOT_FRESH, FailureInfo.ADD_RESERVES_FRESH_CHECK), actualAddAmount);\n        }\n\n        /////////////////////////\n        // EFFECTS & INTERACTIONS\n        // (No safe failures beyond this point)\n\n        /*\n         * We call doTransferIn for the caller and the addAmount\n         *  Note: The vToken must handle variations between BEP-20 and BNB underlying.\n         *  On success, the vToken holds an additional addAmount of cash.\n         *  doTransferIn reverts if anything goes wrong, since we can't be sure if side effects occurred.\n         *  it returns the amount actually transferred, in case of a fee.\n         */\n\n        actualAddAmount = doTransferIn(msg.sender, addAmount);\n\n        totalReservesNew = totalReserves + actualAddAmount;\n\n        /* Revert on overflow */\n        require(totalReservesNew >= totalReserves, \"add reserves unexpected overflow\");\n\n        // Store reserves[n+1] = reserves[n] + actualAddAmount\n        totalReserves = totalReservesNew;\n\n        /* Emit NewReserves(admin, actualAddAmount, reserves[n+1]) */\n        emit ReservesAdded(msg.sender, actualAddAmount, totalReservesNew);\n\n        /* Return (NO_ERROR, actualAddAmount) */\n        return (uint(Error.NO_ERROR), actualAddAmount);\n    }\n\n    /**\n     * @notice Reduces reserves by transferring to protocol share reserve contract\n     * @dev Requires fresh interest accrual\n     * @param reduceAmount Amount of reduction to reserves\n     * @return uint Returns 0 on success, otherwise returns a failure code (see ErrorReporter.sol for details).\n     */\n    function _reduceReservesFresh(uint reduceAmount) internal returns (uint) {\n        if (reduceAmount == 0) {\n            return uint(Error.NO_ERROR);\n        }\n\n        // We fail gracefully unless market's block number equals current block number\n        if (accrualBlockNumber != block.number) {\n            return fail(Error.MARKET_NOT_FRESH, FailureInfo.REDUCE_RESERVES_FRESH_CHECK);\n        }\n\n        // Fail gracefully if protocol has insufficient underlying cash\n        if (getCashPrior() < reduceAmount) {\n            return fail(Error.TOKEN_INSUFFICIENT_CASH, FailureInfo.REDUCE_RESERVES_CASH_NOT_AVAILABLE);\n        }\n\n        // Check reduceAmount ≤ reserves[n] (totalReserves)\n        if (reduceAmount > totalReserves) {\n            return fail(Error.BAD_INPUT, FailureInfo.REDUCE_RESERVES_VALIDATION);\n        }\n\n        /////////////////////////\n        // EFFECTS & INTERACTIONS\n        // (No safe failures beyond this point)\n\n        // totalReserves - reduceAmount\n        uint totalReservesNew = totalReserves - reduceAmount;\n\n        // Store reserves[n+1] = reserves[n] - reduceAmount\n        totalReserves = totalReservesNew;\n\n        // doTransferOut reverts if anything goes wrong, since we can't be sure if side effects occurred.\n        doTransferOut(protocolShareReserve, reduceAmount);\n\n        IProtocolShareReserveV5(protocolShareReserve).updateAssetsState(\n            address(comptroller),\n            underlying,\n            IProtocolShareReserveV5.IncomeType.SPREAD\n        );\n\n        emit ReservesReduced(protocolShareReserve, reduceAmount, totalReservesNew);\n\n        return uint(Error.NO_ERROR);\n    }\n\n    /**\n     * @notice updates the interest rate model (requires fresh interest accrual)\n     * @dev Governance function to update the interest rate model\n     * @param newInterestRateModel the new interest rate model to use\n     * @return uint Returns 0 on success, otherwise returns a failure code (see ErrorReporter.sol for details).\n     */\n    function _setInterestRateModelFresh(InterestRateModel newInterestRateModel) internal returns (uint) {\n        // Used to store old model for use in the event that is emitted on success\n        InterestRateModel oldInterestRateModel;\n        // We fail gracefully unless market's block number equals current block number\n        if (accrualBlockNumber != block.number) {\n            return fail(Error.MARKET_NOT_FRESH, FailureInfo.SET_INTEREST_RATE_MODEL_FRESH_CHECK);\n        }\n\n        // Track the market's current interest rate model\n        oldInterestRateModel = interestRateModel;\n\n        // Ensure invoke newInterestRateModel.isInterestRateModel() returns true\n        require(newInterestRateModel.isInterestRateModel(), \"marker method returned false\");\n\n        // Set the interest rate model to newInterestRateModel\n        interestRateModel = newInterestRateModel;\n\n        // Emit NewMarketInterestRateModel(oldInterestRateModel, newInterestRateModel)\n        emit NewMarketInterestRateModel(oldInterestRateModel, newInterestRateModel);\n\n        return uint(Error.NO_ERROR);\n    }\n\n    /*** Safe Token ***/\n\n    /**\n     * @dev Performs a transfer in, reverting upon failure. Returns the amount actually transferred to the protocol, in case of a fee.\n     *  This may revert due to insufficient balance or insufficient allowance.\n     */\n    function doTransferIn(address from, uint amount) internal returns (uint);\n\n    /**\n     * @dev Performs a transfer out, ideally returning an explanatory error code upon failure rather than reverting.\n     *  If caller has not called checked protocol's balance, may revert due to insufficient cash held in the contract.\n     *  If caller has checked protocol's balance, and verified it is >= amount, this should not revert in normal conditions.\n     */\n    function doTransferOut(address payable to, uint amount) internal;\n\n    /**\n     * @notice Return the borrow balance of account based on stored data\n     * @param account The address whose balance should be calculated\n     * @return Tuple of error code and the calculated balance or 0 if error code is non-zero\n     */\n    function borrowBalanceStoredInternal(address account) internal view returns (MathError, uint) {\n        /* Note: we do not assert that the market is up to date */\n        MathError mathErr;\n        uint principalTimesIndex;\n        uint result;\n\n        /* Get borrowBalance and borrowIndex */\n        BorrowSnapshot storage borrowSnapshot = accountBorrows[account];\n\n        /* If borrowBalance = 0 then borrowIndex is likely also 0.\n         * Rather than failing the calculation with a division by 0, we immediately return 0 in this case.\n         */\n        if (borrowSnapshot.principal == 0) {\n            return (MathError.NO_ERROR, 0);\n        }\n\n        /* Calculate new borrow balance using the interest index:\n         *  recentBorrowBalance = borrower.borrowBalance * market.borrowIndex / borrower.borrowIndex\n         */\n        (mathErr, principalTimesIndex) = mulUInt(borrowSnapshot.principal, borrowIndex);\n        if (mathErr != MathError.NO_ERROR) {\n            return (mathErr, 0);\n        }\n\n        (mathErr, result) = divUInt(principalTimesIndex, borrowSnapshot.interestIndex);\n        if (mathErr != MathError.NO_ERROR) {\n            return (mathErr, 0);\n        }\n\n        return (MathError.NO_ERROR, result);\n    }\n\n    /**\n     * @notice Calculates the exchange rate from the underlying to the vToken\n     * @dev This function does not accrue interest before calculating the exchange rate\n     * @return Tuple of error code and calculated exchange rate scaled by 1e18\n     */\n    function exchangeRateStoredInternal() internal view returns (MathError, uint) {\n        uint _totalSupply = totalSupply;\n        if (_totalSupply == 0) {\n            /*\n             * If there are no tokens minted:\n             *  exchangeRate = initialExchangeRate\n             */\n            return (MathError.NO_ERROR, initialExchangeRateMantissa);\n        } else {\n            /*\n             * Otherwise:\n             *  exchangeRate = (totalCash + totalBorrows - totalReserves) / totalSupply\n             */\n            uint totalCash = getCashPrior();\n            uint cashPlusBorrowsMinusReserves;\n            Exp memory exchangeRate;\n            MathError mathErr;\n\n            (mathErr, cashPlusBorrowsMinusReserves) = addThenSubUInt(totalCash, totalBorrows, totalReserves);\n            if (mathErr != MathError.NO_ERROR) {\n                return (mathErr, 0);\n            }\n\n            (mathErr, exchangeRate) = getExp(cashPlusBorrowsMinusReserves, _totalSupply);\n            if (mathErr != MathError.NO_ERROR) {\n                return (mathErr, 0);\n            }\n\n            return (MathError.NO_ERROR, exchangeRate.mantissa);\n        }\n    }\n\n    function ensureAllowed(string memory functionSig) private view {\n        require(\n            IAccessControlManagerV5(accessControlManager).isAllowedToCall(msg.sender, functionSig),\n            \"access denied\"\n        );\n    }\n\n    function ensureAdmin(address caller_) private view {\n        require(caller_ == admin, \"Unauthorized\");\n    }\n\n    function ensureNoMathError(MathError mErr) private pure {\n        require(mErr == MathError.NO_ERROR, \"math error\");\n    }\n\n    function ensureNonZeroAddress(address address_) private pure {\n        require(address_ != address(0), \"zero address\");\n    }\n\n    /*** Safe Token ***/\n\n    /**\n     * @notice Gets balance of this contract in terms of the underlying\n     * @dev This excludes the value of the current message, if any\n     * @return The quantity of underlying owned by this contract\n     */\n    function getCashPrior() internal view returns (uint);\n}\n"
+    },
+    "contracts/Tokens/VTokens/legacy/VTokenStorageR1.sol": {
+      "content": "pragma solidity ^0.5.16;\n\nimport { ComptrollerInterface } from \"./ComptrollerInterface.sol\";\nimport { InterestRateModel } from \"../../../InterestRateModels/InterestRateModel.sol\";\n\ncontract VTokenStorageR1 {\n    /**\n     * @notice Container for borrow balance information\n     * @member principal Total balance (with accrued interest), after applying the most recent balance-changing action\n     * @member interestIndex Global borrowIndex as of the most recent balance-changing action\n     */\n    struct BorrowSnapshot {\n        uint principal;\n        uint interestIndex;\n    }\n\n    /**\n     * @dev Guard variable for re-entrancy checks\n     */\n    bool internal _notEntered;\n\n    /**\n     * @notice EIP-20 token name for this token\n     */\n    string public name;\n\n    /**\n     * @notice EIP-20 token symbol for this token\n     */\n    string public symbol;\n\n    /**\n     * @notice EIP-20 token decimals for this token\n     */\n    uint8 public decimals;\n\n    /**\n     * @notice Maximum borrow rate that can ever be applied (.0005% / block)\n     */\n\n    uint internal constant borrowRateMaxMantissa = 0.0005e16;\n\n    /**\n     * @notice Maximum fraction of interest that can be set aside for reserves\n     */\n    uint internal constant reserveFactorMaxMantissa = 1e18;\n\n    /**\n     * @notice Administrator for this contract\n     */\n    address payable public admin;\n\n    /**\n     * @notice Pending administrator for this contract\n     */\n    address payable public pendingAdmin;\n\n    /**\n     * @notice Contract which oversees inter-vToken operations\n     */\n    ComptrollerInterface public comptroller;\n\n    /**\n     * @notice Model which tells what the current interest rate should be\n     */\n    InterestRateModel public interestRateModel;\n\n    /**\n     * @notice Initial exchange rate used when minting the first VTokens (used when totalSupply = 0)\n     */\n    uint internal initialExchangeRateMantissa;\n\n    /**\n     * @notice Fraction of interest currently set aside for reserves\n     */\n    uint public reserveFactorMantissa;\n\n    /**\n     * @notice Block number that interest was last accrued at\n     */\n    uint public accrualBlockNumber;\n\n    /**\n     * @notice Accumulator of the total earned interest rate since the opening of the market\n     */\n    uint public borrowIndex;\n\n    /**\n     * @notice Total amount of outstanding borrows of the underlying in this market\n     */\n    uint public totalBorrows;\n\n    /**\n     * @notice Total amount of reserves of the underlying held in this market\n     */\n    uint public totalReserves;\n\n    /**\n     * @notice Total number of tokens in circulation\n     */\n    uint public totalSupply;\n\n    /**\n     * @notice Official record of token balances for each account\n     */\n    mapping(address => uint) internal accountTokens;\n\n    /**\n     * @notice Approved token transfer amounts on behalf of others\n     */\n    mapping(address => mapping(address => uint)) internal transferAllowances;\n\n    /**\n     * @notice Mapping of account addresses to outstanding borrow balances\n     */\n    mapping(address => BorrowSnapshot) internal accountBorrows;\n\n    /**\n     * @notice Underlying asset for this VToken\n     */\n    address public underlying;\n\n    /**\n     * @notice Implementation address for this contract\n     */\n    address public implementation;\n\n    /**\n     * @notice delta block after which reserves will be reduced\n     */\n    uint public reduceReservesBlockDelta;\n\n    /**\n     * @notice last block number at which reserves were reduced\n     */\n    uint public reduceReservesBlockNumber;\n\n    /**\n     * @notice address of protocol share reserve contract\n     */\n    address payable public protocolShareReserve;\n\n    /**\n     * @notice address of accessControlManager\n     */\n    address public accessControlManager;\n\n    /**\n     * @dev This empty reserved space is put in place to allow future versions to add new\n     * variables without shifting down storage in the inheritance chain.\n     * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps\n     */\n    uint256[50] private __gap;\n}\n"
+    },
+    "contracts/Tokens/XVS/IXVSVesting.sol": {
+      "content": "pragma solidity ^0.5.16;\n\ninterface IXVSVesting {\n    /// @param _recipient Address of the Vesting. recipient entitled to claim the vested funds\n    /// @param _amount Total number of tokens Vested\n    function deposit(address _recipient, uint256 _amount) external;\n}\n"
+    },
+    "contracts/Tokens/XVS/XVSVesting.sol": {
+      "content": "pragma solidity ^0.5.16;\n\nimport \"../../Utils/IBEP20.sol\";\nimport \"../../Utils/SafeBEP20.sol\";\nimport \"./XVSVestingStorage.sol\";\nimport \"./XVSVestingProxy.sol\";\n\n/**\n * @title Venus's XVSVesting Contract\n * @author Venus\n */\ncontract XVSVesting is XVSVestingStorage {\n    using SafeMath for uint256;\n    using SafeBEP20 for IBEP20;\n\n    /// @notice total vesting period for 1 year in seconds\n    uint256 public constant TOTAL_VESTING_TIME = 365 * 24 * 60 * 60;\n\n    /// @notice decimal precision for XVS\n    uint256 public constant xvsDecimalsMultiplier = 1e18;\n\n    /// @notice Emitted when XVSVested is claimed by recipient\n    event VestedTokensClaimed(address recipient, uint256 amountClaimed);\n\n    /// @notice Emitted when vrtConversionAddress is set\n    event VRTConversionSet(address vrtConversionAddress);\n\n    /// @notice Emitted when XVS is deposited for vesting\n    event XVSVested(address indexed recipient, uint256 startTime, uint256 amount, uint256 withdrawnAmount);\n\n    /// @notice Emitted when XVS is withdrawn by recipient\n    event XVSWithdrawn(address recipient, uint256 amount);\n\n    modifier nonZeroAddress(address _address) {\n        require(_address != address(0), \"Address cannot be Zero\");\n        _;\n    }\n\n    constructor() public {}\n\n    /**\n     * @notice initialize XVSVestingStorage\n     * @param _xvsAddress The XVSToken address\n     */\n    function initialize(address _xvsAddress) public {\n        require(msg.sender == admin, \"only admin may initialize the XVSVesting\");\n        require(initialized == false, \"XVSVesting is already initialized\");\n        require(_xvsAddress != address(0), \"_xvsAddress cannot be Zero\");\n        xvs = IBEP20(_xvsAddress);\n\n        _notEntered = true;\n        initialized = true;\n    }\n\n    modifier isInitialized() {\n        require(initialized == true, \"XVSVesting is not initialized\");\n        _;\n    }\n\n    /**\n     * @notice sets VRTConverter Address\n     * @dev Note: If VRTConverter is not set, then Vesting is not allowed\n     * @param _vrtConversionAddress The VRTConverterProxy Address\n     */\n    function setVRTConverter(address _vrtConversionAddress) public {\n        require(msg.sender == admin, \"only admin may initialize the Vault\");\n        require(_vrtConversionAddress != address(0), \"vrtConversionAddress cannot be Zero\");\n        vrtConversionAddress = _vrtConversionAddress;\n        emit VRTConversionSet(_vrtConversionAddress);\n    }\n\n    modifier onlyAdmin() {\n        require(msg.sender == admin, \"only admin can\");\n        _;\n    }\n\n    modifier onlyVrtConverter() {\n        require(msg.sender == vrtConversionAddress, \"only VRTConversion Address can call the function\");\n        _;\n    }\n\n    modifier vestingExistCheck(address recipient) {\n        require(vestings[recipient].length > 0, \"recipient doesnot have any vestingRecord\");\n        _;\n    }\n\n    /**\n     * @notice Deposit XVS for Vesting\n     * @param recipient The vesting recipient\n     * @param depositAmount XVS amount for deposit\n     */\n    function deposit(\n        address recipient,\n        uint depositAmount\n    ) external isInitialized onlyVrtConverter nonZeroAddress(recipient) {\n        require(depositAmount > 0, \"Deposit amount must be non-zero\");\n\n        VestingRecord[] storage vestingsOfRecipient = vestings[recipient];\n\n        VestingRecord memory vesting = VestingRecord({\n            recipient: recipient,\n            startTime: getCurrentTime(),\n            amount: depositAmount,\n            withdrawnAmount: 0\n        });\n\n        vestingsOfRecipient.push(vesting);\n\n        emit XVSVested(recipient, vesting.startTime, vesting.amount, vesting.withdrawnAmount);\n    }\n\n    /**\n     * @notice Withdraw Vested XVS of recipient\n     */\n    function withdraw() external isInitialized vestingExistCheck(msg.sender) {\n        address recipient = msg.sender;\n        VestingRecord[] storage vestingsOfRecipient = vestings[recipient];\n        uint256 vestingCount = vestingsOfRecipient.length;\n        uint256 totalWithdrawableAmount = 0;\n\n        for (uint i = 0; i < vestingCount; ++i) {\n            VestingRecord storage vesting = vestingsOfRecipient[i];\n            (, uint256 toWithdraw) = calculateWithdrawableAmount(\n                vesting.amount,\n                vesting.startTime,\n                vesting.withdrawnAmount\n            );\n            if (toWithdraw > 0) {\n                totalWithdrawableAmount = totalWithdrawableAmount.add(toWithdraw);\n                vesting.withdrawnAmount = vesting.withdrawnAmount.add(toWithdraw);\n            }\n        }\n\n        if (totalWithdrawableAmount > 0) {\n            uint256 xvsBalance = xvs.balanceOf(address(this));\n            require(xvsBalance >= totalWithdrawableAmount, \"Insufficient XVS for withdrawal\");\n            emit XVSWithdrawn(recipient, totalWithdrawableAmount);\n            xvs.safeTransfer(recipient, totalWithdrawableAmount);\n        }\n    }\n\n    /**\n     * @notice get Withdrawable XVS Amount\n     * @param recipient The vesting recipient\n     * @dev returns A tuple with totalWithdrawableAmount , totalVestedAmount and totalWithdrawnAmount\n     */\n    function getWithdrawableAmount(\n        address recipient\n    )\n        public\n        view\n        isInitialized\n        nonZeroAddress(recipient)\n        vestingExistCheck(recipient)\n        returns (uint256 totalWithdrawableAmount, uint256 totalVestedAmount, uint256 totalWithdrawnAmount)\n    {\n        VestingRecord[] storage vestingsOfRecipient = vestings[recipient];\n        uint256 vestingCount = vestingsOfRecipient.length;\n\n        for (uint i = 0; i < vestingCount; i++) {\n            VestingRecord storage vesting = vestingsOfRecipient[i];\n            (uint256 vestedAmount, uint256 toWithdraw) = calculateWithdrawableAmount(\n                vesting.amount,\n                vesting.startTime,\n                vesting.withdrawnAmount\n            );\n            totalVestedAmount = totalVestedAmount.add(vestedAmount);\n            totalWithdrawableAmount = totalWithdrawableAmount.add(toWithdraw);\n            totalWithdrawnAmount = totalWithdrawnAmount.add(vesting.withdrawnAmount);\n        }\n\n        return (totalWithdrawableAmount, totalVestedAmount, totalWithdrawnAmount);\n    }\n\n    /**\n     * @notice get Withdrawable XVS Amount\n     * @param amount Amount deposited for vesting\n     * @param vestingStartTime time in epochSeconds at the time of vestingDeposit\n     * @param withdrawnAmount XVSAmount withdrawn from VestedAmount\n     * @dev returns A tuple with vestedAmount and withdrawableAmount\n     */\n    function calculateWithdrawableAmount(\n        uint256 amount,\n        uint256 vestingStartTime,\n        uint256 withdrawnAmount\n    ) internal view returns (uint256, uint256) {\n        uint256 vestedAmount = calculateVestedAmount(amount, vestingStartTime, getCurrentTime());\n        uint toWithdraw = vestedAmount.sub(withdrawnAmount);\n        return (vestedAmount, toWithdraw);\n    }\n\n    /**\n     * @notice calculate total vested amount\n     * @param vestingAmount Amount deposited for vesting\n     * @param vestingStartTime time in epochSeconds at the time of vestingDeposit\n     * @param currentTime currentTime in epochSeconds\n     * @return Total XVS amount vested\n     */\n    function calculateVestedAmount(\n        uint256 vestingAmount,\n        uint256 vestingStartTime,\n        uint256 currentTime\n    ) internal view returns (uint256) {\n        if (currentTime < vestingStartTime) {\n            return 0;\n        } else if (currentTime > vestingStartTime.add(TOTAL_VESTING_TIME)) {\n            return vestingAmount;\n        } else {\n            return (vestingAmount.mul(currentTime.sub(vestingStartTime))).div(TOTAL_VESTING_TIME);\n        }\n    }\n\n    /**\n     * @notice current block timestamp\n     * @return blocktimestamp\n     */\n    function getCurrentTime() public view returns (uint256) {\n        return block.timestamp;\n    }\n\n    /*** Admin Functions ***/\n    function _become(XVSVestingProxy xvsVestingProxy) public {\n        require(msg.sender == xvsVestingProxy.admin(), \"only proxy admin can change brains\");\n        xvsVestingProxy._acceptImplementation();\n    }\n}\n"
+    },
+    "contracts/Tokens/XVS/XVSVestingProxy.sol": {
+      "content": "pragma solidity ^0.5.16;\n\nimport \"./XVSVestingStorage.sol\";\n\ncontract XVSVestingProxy is XVSVestingAdminStorage {\n    /**\n     * @notice Emitted when pendingImplementation is changed\n     */\n    event NewPendingImplementation(address oldPendingImplementation, address newPendingImplementation);\n\n    /**\n     * @notice Emitted when pendingImplementation is accepted, which means XVSVesting implementation is updated\n     */\n    event NewImplementation(address oldImplementation, address newImplementation);\n\n    /**\n     * @notice Emitted when pendingAdmin is changed\n     */\n    event NewPendingAdmin(address oldPendingAdmin, address newPendingAdmin);\n\n    /**\n     * @notice Emitted when pendingAdmin is accepted, which means admin is updated\n     */\n    event NewAdmin(address oldAdmin, address newAdmin);\n\n    constructor(\n        address implementation_,\n        address _xvsAddress\n    ) public nonZeroAddress(implementation_) nonZeroAddress(_xvsAddress) {\n        // Creator of the contract is admin during initialization\n        admin = msg.sender;\n\n        // New implementations always get set via the settor (post-initialize)\n        _setImplementation(implementation_);\n\n        // First delegate gets to initialize the delegator (i.e. storage contract)\n        delegateTo(implementation_, abi.encodeWithSignature(\"initialize(address)\", _xvsAddress));\n    }\n\n    modifier nonZeroAddress(address _address) {\n        require(_address != address(0), \"Address cannot be Zero\");\n        _;\n    }\n\n    /**\n     * @notice Called by the admin to update the implementation of the delegator\n     * @param implementation_ The address of the new implementation for delegation\n     */\n    function _setImplementation(address implementation_) public {\n        require(msg.sender == admin, \"XVSVestingProxy::_setImplementation: admin only\");\n        require(implementation_ != address(0), \"XVSVestingProxy::_setImplementation: invalid implementation address\");\n\n        address oldImplementation = implementation;\n        implementation = implementation_;\n\n        emit NewImplementation(oldImplementation, implementation);\n    }\n\n    /**\n     * @notice Internal method to delegate execution to another contract\n     * @dev It returns to the external caller whatever the implementation returns or forwards reverts\n     * @param callee The contract to delegatecall\n     * @param data The raw data to delegatecall\n     * @return The returned bytes from the delegatecall\n     */\n    function delegateTo(address callee, bytes memory data) internal nonZeroAddress(callee) returns (bytes memory) {\n        (bool success, bytes memory returnData) = callee.delegatecall(data);\n        assembly {\n            if eq(success, 0) {\n                revert(add(returnData, 0x20), returndatasize)\n            }\n        }\n        return returnData;\n    }\n\n    /*** Admin Functions ***/\n    function _setPendingImplementation(\n        address newPendingImplementation\n    ) public nonZeroAddress(newPendingImplementation) {\n        require(msg.sender == admin, \"Only admin can set Pending Implementation\");\n\n        address oldPendingImplementation = pendingImplementation;\n\n        pendingImplementation = newPendingImplementation;\n\n        emit NewPendingImplementation(oldPendingImplementation, pendingImplementation);\n    }\n\n    /**\n     * @notice Accepts new implementation of VRT Vault. msg.sender must be pendingImplementation\n     * @dev Admin function for new implementation to accept it's role as implementation\n     */\n    function _acceptImplementation() public {\n        // Check caller is pendingImplementation\n        require(\n            msg.sender == pendingImplementation,\n            \"only address marked as pendingImplementation can accept Implementation\"\n        );\n\n        // Save current values for inclusion in log\n        address oldImplementation = implementation;\n        address oldPendingImplementation = pendingImplementation;\n\n        implementation = pendingImplementation;\n\n        pendingImplementation = address(0);\n\n        emit NewImplementation(oldImplementation, implementation);\n        emit NewPendingImplementation(oldPendingImplementation, pendingImplementation);\n    }\n\n    /**\n     * @notice Begins transfer of admin rights. The newPendingAdmin must call `_acceptAdmin` to finalize the transfer.\n     * @dev Admin function to begin change of admin. The newPendingAdmin must call `_acceptAdmin` to finalize the transfer.\n     * @param newPendingAdmin New pending admin.\n     */\n    function _setPendingAdmin(address newPendingAdmin) public nonZeroAddress(newPendingAdmin) {\n        // Check caller = admin\n        require(msg.sender == admin, \"only admin can set pending admin\");\n        require(newPendingAdmin != pendingAdmin, \"New pendingAdmin can not be same as the previous one\");\n\n        // Save current value, if any, for inclusion in log\n        address oldPendingAdmin = pendingAdmin;\n\n        // Store pendingAdmin with value newPendingAdmin\n        pendingAdmin = newPendingAdmin;\n\n        // Emit NewPendingAdmin(oldPendingAdmin, newPendingAdmin)\n        emit NewPendingAdmin(oldPendingAdmin, newPendingAdmin);\n    }\n\n    /**\n     * @notice Accepts transfer of admin rights. msg.sender must be pendingAdmin\n     * @dev Admin function for pending admin to accept role and update admin\n     */\n    function _acceptAdmin() public {\n        // Check caller is pendingAdmin\n        require(msg.sender == pendingAdmin, \"only address marked as pendingAdmin can accept as Admin\");\n\n        // Save current values for inclusion in log\n        address oldAdmin = admin;\n        address oldPendingAdmin = pendingAdmin;\n\n        // Store admin with value pendingAdmin\n        admin = pendingAdmin;\n\n        // Clear the pending value\n        pendingAdmin = address(0);\n\n        emit NewAdmin(oldAdmin, admin);\n        emit NewPendingAdmin(oldPendingAdmin, pendingAdmin);\n    }\n\n    /**\n     * @dev Delegates execution to an implementation contract.\n     * It returns to the external caller whatever the implementation returns\n     * or forwards reverts.\n     */\n    function() external payable {\n        // delegate all other functions to current implementation\n        (bool success, ) = implementation.delegatecall(msg.data);\n\n        assembly {\n            let free_mem_ptr := mload(0x40)\n            returndatacopy(free_mem_ptr, 0, returndatasize)\n\n            switch success\n            case 0 {\n                revert(free_mem_ptr, returndatasize)\n            }\n            default {\n                return(free_mem_ptr, returndatasize)\n            }\n        }\n    }\n}\n"
+    },
+    "contracts/Tokens/XVS/XVSVestingStorage.sol": {
+      "content": "pragma solidity ^0.5.16;\n\nimport \"../../Utils/SafeMath.sol\";\nimport \"../../Utils/IBEP20.sol\";\n\ncontract XVSVestingAdminStorage {\n    /**\n     * @notice Administrator for this contract\n     */\n    address public admin;\n\n    /**\n     * @notice Pending administrator for this contract\n     */\n    address public pendingAdmin;\n\n    /**\n     * @notice Active brains of XVSVesting\n     */\n    address public implementation;\n\n    /**\n     * @notice Pending brains of XVSVesting\n     */\n    address public pendingImplementation;\n}\n\ncontract XVSVestingStorage is XVSVestingAdminStorage {\n    struct VestingRecord {\n        address recipient;\n        uint256 startTime;\n        uint256 amount;\n        uint256 withdrawnAmount;\n    }\n\n    /// @notice Guard variable for re-entrancy checks\n    bool public _notEntered;\n\n    /// @notice indicator to check if the contract is initialized\n    bool public initialized;\n\n    /// @notice The XVS TOKEN!\n    IBEP20 public xvs;\n\n    /// @notice VRTConversion Contract Address\n    address public vrtConversionAddress;\n\n    /// @notice mapping of VestingRecord(s) for user(s)\n    mapping(address => VestingRecord[]) public vestings;\n}\n"
+    },
+    "contracts/Utils/Address.sol": {
+      "content": "pragma solidity ^0.5.5;\n\n/**\n * @dev Collection of functions related to the address type\n */\nlibrary Address {\n    /**\n     * @dev Returns true if `account` is a contract.\n     *\n     * [IMPORTANT]\n     * ====\n     * It is unsafe to assume that an address for which this function returns\n     * false is an externally-owned account (EOA) and not a contract.\n     *\n     * Among others, `isContract` will return false for the following\n     * types of addresses:\n     *\n     *  - an externally-owned account\n     *  - a contract in construction\n     *  - an address where a contract will be created\n     *  - an address where a contract lived, but was destroyed\n     * ====\n     */\n    function isContract(address account) internal view returns (bool) {\n        // According to EIP-1052, 0x0 is the value returned for not-yet created accounts\n        // and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned\n        // for accounts without code, i.e. `keccak256('')`\n        bytes32 codehash;\n        bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;\n        // solhint-disable-next-line no-inline-assembly\n        assembly {\n            codehash := extcodehash(account)\n        }\n        return (codehash != accountHash && codehash != 0x0);\n    }\n\n    /**\n     * @dev Converts an `address` into `address payable`. Note that this is\n     * simply a type cast: the actual underlying value is not changed.\n     *\n     * _Available since v2.4.0._\n     */\n    function toPayable(address account) internal pure returns (address payable) {\n        return address(uint160(account));\n    }\n\n    /**\n     * @dev Replacement for Solidity's `transfer`: sends `amount` wei to\n     * `recipient`, forwarding all available gas and reverting on errors.\n     *\n     * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost\n     * of certain opcodes, possibly making contracts go over the 2300 gas limit\n     * imposed by `transfer`, making them unable to receive funds via\n     * `transfer`. {sendValue} removes this limitation.\n     *\n     * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].\n     *\n     * IMPORTANT: because control is transferred to `recipient`, care must be\n     * taken to not create reentrancy vulnerabilities. Consider using\n     * {ReentrancyGuard} or the\n     * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].\n     *\n     * _Available since v2.4.0._\n     */\n    function sendValue(address payable recipient, uint256 amount) internal {\n        require(address(this).balance >= amount, \"Address: insufficient balance\");\n\n        // solhint-disable-next-line avoid-call-value\n        // solium-disable-next-line security/no-call-value\n        (bool success, ) = recipient.call.value(amount)(\"\");\n        require(success, \"Address: unable to send value, recipient may have reverted\");\n    }\n}\n"
+    },
+    "contracts/Utils/Context.sol": {
+      "content": "pragma solidity ^0.5.16;\n\n/*\n * @dev Provides information about the current execution context, including the\n * sender of the transaction and its data. While these are generally available\n * via msg.sender and msg.data, they should not be accessed in such a direct\n * manner, since when dealing with GSN meta-transactions the account sending and\n * paying for execution may not be the actual sender (as far as an application\n * is concerned).\n *\n * This contract is only required for intermediate, library-like contracts.\n */\ncontract Context {\n    // Empty internal constructor, to prevent people from mistakenly deploying\n    // an instance of this contract, which should be used via inheritance.\n    constructor() internal {}\n\n    function _msgSender() internal view returns (address payable) {\n        return msg.sender;\n    }\n\n    function _msgData() internal view returns (bytes memory) {\n        this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691\n        return msg.data;\n    }\n}\n"
+    },
+    "contracts/Utils/ECDSA.sol": {
+      "content": "// SPDX-License-Identifier: MIT\n// Adapted from OpenZeppelin Contracts v4.3.2 (utils/cryptography/ECDSA.sol)\n\n// SPDX-Copyright-Text: OpenZeppelin, 2021\n// SPDX-Copyright-Text: Venus, 2021\n\npragma solidity ^0.5.16;\n\n/**\n * @dev Elliptic Curve Digital Signature Algorithm (ECDSA) operations.\n *\n * These functions can be used to verify that a message was signed by the holder\n * of the private keys of a given address.\n */\ncontract ECDSA {\n    enum RecoverError {\n        NoError,\n        InvalidSignature,\n        InvalidSignatureLength,\n        InvalidSignatureS,\n        InvalidSignatureV\n    }\n\n    function _throwError(RecoverError error) private pure {\n        if (error == RecoverError.NoError) {\n            return; // no error: do nothing\n        } else if (error == RecoverError.InvalidSignature) {\n            revert(\"ECDSA: invalid signature\");\n        } else if (error == RecoverError.InvalidSignatureLength) {\n            revert(\"ECDSA: invalid signature length\");\n        } else if (error == RecoverError.InvalidSignatureS) {\n            revert(\"ECDSA: invalid signature 's' value\");\n        } else if (error == RecoverError.InvalidSignatureV) {\n            revert(\"ECDSA: invalid signature 'v' value\");\n        }\n    }\n\n    /**\n     * @dev Returns the address that signed a hashed message (`hash`) with\n     * `signature`. This address can then be used for verification purposes.\n     *\n     * The `ecrecover` EVM opcode allows for malleable (non-unique) signatures:\n     * this function rejects them by requiring the `s` value to be in the lower\n     * half order, and the `v` value to be either 27 or 28.\n     *\n     * IMPORTANT: `hash` _must_ be the result of a hash operation for the\n     * verification to be secure: it is possible to craft signatures that\n     * recover to arbitrary addresses for non-hashed data. A safe way to ensure\n     * this is by receiving a hash of the original message (which may otherwise\n     * be too long), and then calling {toEthSignedMessageHash} on it.\n     */\n    function recover(bytes32 hash, uint8 v, bytes32 r, bytes32 s) internal pure returns (address) {\n        (address recovered, RecoverError error) = tryRecover(hash, v, r, s);\n        _throwError(error);\n        return recovered;\n    }\n\n    /**\n     * @dev Returns the address that signed a hashed message (`hash`) with\n     * `signature` or error string. This address can then be used for verification purposes.\n     *\n     * The `ecrecover` EVM opcode allows for malleable (non-unique) signatures:\n     * this function rejects them by requiring the `s` value to be in the lower\n     * half order, and the `v` value to be either 27 or 28.\n     *\n     * IMPORTANT: `hash` _must_ be the result of a hash operation for the\n     * verification to be secure: it is possible to craft signatures that\n     * recover to arbitrary addresses for non-hashed data. A safe way to ensure\n     * this is by receiving a hash of the original message (which may otherwise\n     * be too long), and then calling {toEthSignedMessageHash} on it.\n     *\n     * Documentation for signature generation:\n     * - with https://web3js.readthedocs.io/en/v1.3.4/web3-eth-accounts.html#sign[Web3.js]\n     * - with https://docs.ethers.io/v5/api/signer/#Signer-signMessage[ethers]\n     *\n     * _Available since v4.3._\n     */\n    function tryRecover(bytes32 hash, uint8 v, bytes32 r, bytes32 s) internal pure returns (address, RecoverError) {\n        // EIP-2 still allows signature malleability for ecrecover(). Remove this possibility and make the signature\n        // unique. Appendix F in the Ethereum Yellow paper (https://ethereum.github.io/yellowpaper/paper.pdf), defines\n        // the valid range for s in (301): 0 < s < secp256k1n ÷ 2 + 1, and for v in (302): v ∈ {27, 28}. Most\n        // signatures from current libraries generate a unique signature with an s-value in the lower half order.\n        //\n        // If your library generates malleable signatures, such as s-values in the upper range, calculate a new s-value\n        // with 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141 - s1 and flip v from 27 to 28 or\n        // vice versa. If your library also generates signatures with 0/1 for v instead 27/28, add 27 to v to accept\n        // these malleable signatures as well.\n        if (uint256(s) > 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF5D576E7357A4501DDFE92F46681B20A0) {\n            return (address(0), RecoverError.InvalidSignatureS);\n        }\n        if (v != 27 && v != 28) {\n            return (address(0), RecoverError.InvalidSignatureV);\n        }\n\n        // If the signature is valid (and not malleable), return the signer address\n        address signer = ecrecover(hash, v, r, s);\n        if (signer == address(0)) {\n            return (address(0), RecoverError.InvalidSignature);\n        }\n\n        return (signer, RecoverError.NoError);\n    }\n}\n"
+    },
+    "contracts/Utils/IBEP20.sol": {
+      "content": "pragma solidity ^0.5.0;\n\n/**\n * @dev Interface of the BEP20 standard as defined in the EIP. Does not include\n * the optional functions; to access them see {BEP20Detailed}.\n */\ninterface IBEP20 {\n    /**\n     * @dev Returns the amount of tokens in existence.\n     */\n    function totalSupply() external view returns (uint256);\n\n    /**\n     * @dev Returns the amount of tokens owned by `account`.\n     */\n    function balanceOf(address account) external view returns (uint256);\n\n    /**\n     * @dev Moves `amount` tokens from the caller's account to `recipient`.\n     *\n     * Returns a boolean value indicating whether the operation succeeded.\n     *\n     * Emits a {Transfer} event.\n     */\n    function transfer(address recipient, uint256 amount) external returns (bool);\n\n    /**\n     * @dev Returns the remaining number of tokens that `spender` will be\n     * allowed to spend on behalf of `owner` through {transferFrom}. This is\n     * zero by default.\n     *\n     * This value changes when {approve} or {transferFrom} are called.\n     */\n    function allowance(address owner, address spender) external view returns (uint256);\n\n    /**\n     * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.\n     *\n     * Returns a boolean value indicating whether the operation succeeded.\n     *\n     * IMPORTANT: Beware that changing an allowance with this method brings the risk\n     * that someone may use both the old and the new allowance by unfortunate\n     * transaction ordering. One possible solution to mitigate this race\n     * condition is to first reduce the spender's allowance to 0 and set the\n     * desired value afterwards:\n     * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729\n     *\n     * Emits an {Approval} event.\n     */\n    function approve(address spender, uint256 amount) external returns (bool);\n\n    /**\n     * @dev Moves `amount` tokens from `sender` to `recipient` using the\n     * allowance mechanism. `amount` is then deducted from the caller's\n     * allowance.\n     *\n     * Returns a boolean value indicating whether the operation succeeded.\n     *\n     * Emits a {Transfer} event.\n     */\n    function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);\n\n    /**\n     * @dev Emitted when `value` tokens are moved from one account (`from`) to\n     * another (`to`).\n     *\n     * Note that `value` may be zero.\n     */\n    event Transfer(address indexed from, address indexed to, uint256 value);\n\n    /**\n     * @dev Emitted when the allowance of a `spender` for an `owner` is set by\n     * a call to {approve}. `value` is the new allowance.\n     */\n    event Approval(address indexed owner, address indexed spender, uint256 value);\n}\n"
+    },
+    "contracts/Utils/Ownable.sol": {
+      "content": "pragma solidity ^0.5.16;\n\nimport \"./Context.sol\";\n\n/**\n * @dev Contract module which provides a basic access control mechanism, where\n * there is an account (an owner) that can be granted exclusive access to\n * specific functions.\n *\n * By default, the owner account will be the one that deploys the contract. This\n * can later be changed with {transferOwnership}.\n *\n * This module is used through inheritance. It will make available the modifier\n * `onlyOwner`, which can be applied to your functions to restrict their use to\n * the owner.\n */\ncontract Ownable is Context {\n    address private _owner;\n\n    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\n\n    /**\n     * @dev Initializes the contract setting the deployer as the initial owner.\n     */\n    constructor() internal {\n        address msgSender = _msgSender();\n        _owner = msgSender;\n        emit OwnershipTransferred(address(0), msgSender);\n    }\n\n    /**\n     * @dev Returns the address of the current owner.\n     */\n    function owner() public view returns (address) {\n        return _owner;\n    }\n\n    /**\n     * @dev Throws if called by any account other than the owner.\n     */\n    modifier onlyOwner() {\n        require(_owner == _msgSender(), \"Ownable: caller is not the owner\");\n        _;\n    }\n\n    /**\n     * @dev Leaves the contract without owner. It will not be possible to call\n     * `onlyOwner` functions anymore. Can only be called by the current owner.\n     *\n     * NOTE: Renouncing ownership will leave the contract without an owner,\n     * thereby removing any functionality that is only available to the owner.\n     */\n    function renounceOwnership() public onlyOwner {\n        emit OwnershipTransferred(_owner, address(0));\n        _owner = address(0);\n    }\n\n    /**\n     * @dev Transfers ownership of the contract to a new account (`newOwner`).\n     * Can only be called by the current owner.\n     */\n    function transferOwnership(address newOwner) public onlyOwner {\n        _transferOwnership(newOwner);\n    }\n\n    /**\n     * @dev Transfers ownership of the contract to a new account (`newOwner`).\n     */\n    function _transferOwnership(address newOwner) internal {\n        require(newOwner != address(0), \"Ownable: new owner is the zero address\");\n        emit OwnershipTransferred(_owner, newOwner);\n        _owner = newOwner;\n    }\n}\n"
+    },
+    "contracts/Utils/SafeBEP20.sol": {
+      "content": "pragma solidity ^0.5.0;\n\nimport \"./SafeMath.sol\";\nimport \"./IBEP20.sol\";\nimport \"./Address.sol\";\n\n/**\n * @title SafeBEP20\n * @dev Wrappers around BEP20 operations that throw on failure (when the token\n * contract returns false). Tokens that return no value (and instead revert or\n * throw on failure) are also supported, non-reverting calls are assumed to be\n * successful.\n * To use this library you can add a `using SafeBEP20 for BEP20;` statement to your contract,\n * which allows you to call the safe operations as `token.safeTransfer(...)`, etc.\n */\nlibrary SafeBEP20 {\n    using SafeMath for uint256;\n    using Address for address;\n\n    function safeTransfer(IBEP20 token, address to, uint256 value) internal {\n        callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));\n    }\n\n    function safeTransferFrom(IBEP20 token, address from, address to, uint256 value) internal {\n        callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));\n    }\n\n    function safeApprove(IBEP20 token, address spender, uint256 value) internal {\n        // safeApprove should only be called when setting an initial allowance,\n        // or when resetting it to zero. To increase and decrease it, use\n        // 'safeIncreaseAllowance' and 'safeDecreaseAllowance'\n        // solhint-disable-next-line max-line-length\n        require(\n            (value == 0) || (token.allowance(address(this), spender) == 0),\n            \"SafeBEP20: approve from non-zero to non-zero allowance\"\n        );\n        callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));\n    }\n\n    function safeIncreaseAllowance(IBEP20 token, address spender, uint256 value) internal {\n        uint256 newAllowance = token.allowance(address(this), spender).add(value);\n        callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));\n    }\n\n    function safeDecreaseAllowance(IBEP20 token, address spender, uint256 value) internal {\n        uint256 newAllowance = token.allowance(address(this), spender).sub(\n            value,\n            \"SafeBEP20: decreased allowance below zero\"\n        );\n        callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));\n    }\n\n    /**\n     * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement\n     * on the return value: the return value is optional (but if data is returned, it must not be false).\n     * @param token The token targeted by the call.\n     * @param data The call data (encoded using abi.encode or one of its variants).\n     */\n    function callOptionalReturn(IBEP20 token, bytes memory data) private {\n        // We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since\n        // we're implementing it ourselves.\n\n        // A Solidity high level call has three parts:\n        //  1. The target address is checked to verify it contains contract code\n        //  2. The call itself is made, and success asserted\n        //  3. The return value is decoded, which in turn checks the size of the returned data.\n        // solhint-disable-next-line max-line-length\n        require(address(token).isContract(), \"SafeBEP20: call to non-contract\");\n\n        // solhint-disable-next-line avoid-low-level-calls\n        (bool success, bytes memory returndata) = address(token).call(data);\n        require(success, \"SafeBEP20: low-level call failed\");\n\n        if (returndata.length > 0) {\n            // Return data is optional\n            // solhint-disable-next-line max-line-length\n            require(abi.decode(returndata, (bool)), \"SafeBEP20: BEP20 operation did not succeed\");\n        }\n    }\n}\n"
+    },
+    "contracts/Utils/SafeCast.sol": {
+      "content": "pragma solidity ^0.5.16;\n\n/**\n * @dev Wrappers over Solidity's uintXX/intXX casting operators with added overflow\n * checks.\n *\n * Downcasting from uint256/int256 in Solidity does not revert on overflow. This can\n * easily result in undesired exploitation or bugs, since developers usually\n * assume that overflows raise errors. `SafeCast` restores this intuition by\n * reverting the transaction when such an operation overflows.\n *\n * Using this library instead of the unchecked operations eliminates an entire\n * class of bugs, so it's recommended to use it always.\n *\n * Can be combined with {SafeMath} and {SignedSafeMath} to extend it to smaller types, by performing\n * all math on `uint256` and `int256` and then downcasting.\n */\nlibrary SafeCast {\n    /**\n     * @dev Returns the downcasted uint128 from uint256, reverting on\n     * overflow (when the input is greater than largest uint128).\n     *\n     * Counterpart to Solidity's `uint128` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 128 bits\n     */\n    function toUint128(uint256 value) internal pure returns (uint128) {\n        require(value < 2 ** 128, \"SafeCast: value doesn't fit in 128 bits\");\n        return uint128(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint64 from uint256, reverting on\n     * overflow (when the input is greater than largest uint64).\n     *\n     * Counterpart to Solidity's `uint64` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 64 bits\n     */\n    function toUint64(uint256 value) internal pure returns (uint64) {\n        require(value < 2 ** 64, \"SafeCast: value doesn't fit in 64 bits\");\n        return uint64(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint32 from uint256, reverting on\n     * overflow (when the input is greater than largest uint32).\n     *\n     * Counterpart to Solidity's `uint32` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 32 bits\n     */\n    function toUint32(uint256 value) internal pure returns (uint32) {\n        require(value < 2 ** 32, \"SafeCast: value doesn't fit in 32 bits\");\n        return uint32(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint16 from uint256, reverting on\n     * overflow (when the input is greater than largest uint16).\n     *\n     * Counterpart to Solidity's `uint16` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 16 bits\n     */\n    function toUint16(uint256 value) internal pure returns (uint16) {\n        require(value < 2 ** 16, \"SafeCast: value doesn't fit in 16 bits\");\n        return uint16(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint8 from uint256, reverting on\n     * overflow (when the input is greater than largest uint8).\n     *\n     * Counterpart to Solidity's `uint8` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 8 bits.\n     */\n    function toUint8(uint256 value) internal pure returns (uint8) {\n        require(value < 2 ** 8, \"SafeCast: value doesn't fit in 8 bits\");\n        return uint8(value);\n    }\n\n    /**\n     * @dev Converts a signed int256 into an unsigned uint256.\n     *\n     * Requirements:\n     *\n     * - input must be greater than or equal to 0.\n     */\n    function toUint256(int256 value) internal pure returns (uint256) {\n        require(value >= 0, \"SafeCast: value must be positive\");\n        return uint256(value);\n    }\n\n    /**\n     * @dev Returns the downcasted int128 from int256, reverting on\n     * overflow (when the input is less than smallest int128 or\n     * greater than largest int128).\n     *\n     * Counterpart to Solidity's `int128` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 128 bits\n     *\n     * _Available since v3.1._\n     */\n    function toInt128(int256 value) internal pure returns (int128) {\n        require(value >= -2 ** 127 && value < 2 ** 127, \"SafeCast: value doesn't fit in 128 bits\");\n        return int128(value);\n    }\n\n    /**\n     * @dev Returns the downcasted int64 from int256, reverting on\n     * overflow (when the input is less than smallest int64 or\n     * greater than largest int64).\n     *\n     * Counterpart to Solidity's `int64` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 64 bits\n     *\n     * _Available since v3.1._\n     */\n    function toInt64(int256 value) internal pure returns (int64) {\n        require(value >= -2 ** 63 && value < 2 ** 63, \"SafeCast: value doesn't fit in 64 bits\");\n        return int64(value);\n    }\n\n    /**\n     * @dev Returns the downcasted int32 from int256, reverting on\n     * overflow (when the input is less than smallest int32 or\n     * greater than largest int32).\n     *\n     * Counterpart to Solidity's `int32` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 32 bits\n     *\n     * _Available since v3.1._\n     */\n    function toInt32(int256 value) internal pure returns (int32) {\n        require(value >= -2 ** 31 && value < 2 ** 31, \"SafeCast: value doesn't fit in 32 bits\");\n        return int32(value);\n    }\n\n    /**\n     * @dev Returns the downcasted int16 from int256, reverting on\n     * overflow (when the input is less than smallest int16 or\n     * greater than largest int16).\n     *\n     * Counterpart to Solidity's `int16` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 16 bits\n     *\n     * _Available since v3.1._\n     */\n    function toInt16(int256 value) internal pure returns (int16) {\n        require(value >= -2 ** 15 && value < 2 ** 15, \"SafeCast: value doesn't fit in 16 bits\");\n        return int16(value);\n    }\n\n    /**\n     * @dev Returns the downcasted int8 from int256, reverting on\n     * overflow (when the input is less than smallest int8 or\n     * greater than largest int8).\n     *\n     * Counterpart to Solidity's `int8` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 8 bits.\n     *\n     * _Available since v3.1._\n     */\n    function toInt8(int256 value) internal pure returns (int8) {\n        require(value >= -2 ** 7 && value < 2 ** 7, \"SafeCast: value doesn't fit in 8 bits\");\n        return int8(value);\n    }\n\n    /**\n     * @dev Converts an unsigned uint256 into a signed int256.\n     *\n     * Requirements:\n     *\n     * - input must be less than or equal to maxInt256.\n     */\n    function toInt256(uint256 value) internal pure returns (int256) {\n        require(value < 2 ** 255, \"SafeCast: value doesn't fit in an int256\");\n        return int256(value);\n    }\n}\n"
+    },
+    "contracts/Utils/SafeMath.sol": {
+      "content": "pragma solidity ^0.5.16;\n\n/**\n * @dev Wrappers over Solidity's arithmetic operations with added overflow\n * checks.\n *\n * Arithmetic operations in Solidity wrap on overflow. This can easily result\n * in bugs, because programmers usually assume that an overflow raises an\n * error, which is the standard behavior in high level programming languages.\n * `SafeMath` restores this intuition by reverting the transaction when an\n * operation overflows.\n *\n * Using this library instead of the unchecked operations eliminates an entire\n * class of bugs, so it's recommended to use it always.\n */\nlibrary SafeMath {\n    /**\n     * @dev Returns the addition of two unsigned integers, reverting on\n     * overflow.\n     *\n     * Counterpart to Solidity's `+` operator.\n     *\n     * Requirements:\n     * - Addition cannot overflow.\n     */\n    function add(uint256 a, uint256 b) internal pure returns (uint256) {\n        return add(a, b, \"SafeMath: addition overflow\");\n    }\n\n    /**\n     * @dev Returns the subtraction of two unsigned integers, reverting with custom message on\n     * overflow (when the result is negative).\n     *\n     * Counterpart to Solidity's `-` operator.\n     *\n     * Requirements:\n     * - Subtraction cannot overflow.\n     */\n    function add(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {\n        uint256 c = a + b;\n        require(c >= a, errorMessage);\n\n        return c;\n    }\n\n    /**\n     * @dev Returns the subtraction of two unsigned integers, reverting on\n     * overflow (when the result is negative).\n     *\n     * Counterpart to Solidity's `-` operator.\n     *\n     * Requirements:\n     * - Subtraction cannot overflow.\n     */\n    function sub(uint256 a, uint256 b) internal pure returns (uint256) {\n        return sub(a, b, \"SafeMath: subtraction overflow\");\n    }\n\n    /**\n     * @dev Returns the subtraction of two unsigned integers, reverting with custom message on\n     * overflow (when the result is negative).\n     *\n     * Counterpart to Solidity's `-` operator.\n     *\n     * Requirements:\n     * - Subtraction cannot overflow.\n     */\n    function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {\n        require(b <= a, errorMessage);\n        uint256 c = a - b;\n\n        return c;\n    }\n\n    /**\n     * @dev Returns the multiplication of two unsigned integers, reverting on\n     * overflow.\n     *\n     * Counterpart to Solidity's `*` operator.\n     *\n     * Requirements:\n     * - Multiplication cannot overflow.\n     */\n    function mul(uint256 a, uint256 b) internal pure returns (uint256) {\n        // Gas optimization: this is cheaper than requiring 'a' not being zero, but the\n        // benefit is lost if 'b' is also tested.\n        // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522\n        if (a == 0) {\n            return 0;\n        }\n\n        uint256 c = a * b;\n        require(c / a == b, \"SafeMath: multiplication overflow\");\n\n        return c;\n    }\n\n    /**\n     * @dev Returns the integer division of two unsigned integers. Reverts on\n     * division by zero. The result is rounded towards zero.\n     *\n     * Counterpart to Solidity's `/` operator. Note: this function uses a\n     * `revert` opcode (which leaves remaining gas untouched) while Solidity\n     * uses an invalid opcode to revert (consuming all remaining gas).\n     *\n     * Requirements:\n     * - The divisor cannot be zero.\n     */\n    function div(uint256 a, uint256 b) internal pure returns (uint256) {\n        return div(a, b, \"SafeMath: division by zero\");\n    }\n\n    /**\n     * @dev Returns the integer division of two unsigned integers. Reverts with custom message on\n     * division by zero. The result is rounded towards zero.\n     *\n     * Counterpart to Solidity's `/` operator. Note: this function uses a\n     * `revert` opcode (which leaves remaining gas untouched) while Solidity\n     * uses an invalid opcode to revert (consuming all remaining gas).\n     *\n     * Requirements:\n     * - The divisor cannot be zero.\n     */\n    function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {\n        // Solidity only automatically asserts when dividing by 0\n        require(b > 0, errorMessage);\n        uint256 c = a / b;\n        // assert(a == b * c + a % b); // There is no case in which this doesn't hold\n\n        return c;\n    }\n\n    /**\n     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),\n     * Reverts when dividing by zero.\n     *\n     * Counterpart to Solidity's `%` operator. This function uses a `revert`\n     * opcode (which leaves remaining gas untouched) while Solidity uses an\n     * invalid opcode to revert (consuming all remaining gas).\n     *\n     * Requirements:\n     * - The divisor cannot be zero.\n     */\n    function mod(uint256 a, uint256 b) internal pure returns (uint256) {\n        return mod(a, b, \"SafeMath: modulo by zero\");\n    }\n\n    /**\n     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),\n     * Reverts with custom message when dividing by zero.\n     *\n     * Counterpart to Solidity's `%` operator. This function uses a `revert`\n     * opcode (which leaves remaining gas untouched) while Solidity uses an\n     * invalid opcode to revert (consuming all remaining gas).\n     *\n     * Requirements:\n     * - The divisor cannot be zero.\n     */\n    function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {\n        require(b != 0, errorMessage);\n        return a % b;\n    }\n}\n"
+    },
+    "contracts/VAIVault/VAIVault.sol": {
+      "content": "pragma solidity 0.5.16;\n\nimport \"../Utils/SafeBEP20.sol\";\nimport \"../Utils/IBEP20.sol\";\nimport \"./VAIVaultStorage.sol\";\nimport \"./VAIVaultErrorReporter.sol\";\nimport \"@venusprotocol/governance-contracts/contracts/Governance/AccessControlledV5.sol\";\nimport { VAIVaultProxy } from \"./VAIVaultProxy.sol\";\n\n/**\n * @title VAI Vault\n * @author Venus\n * @notice The VAI Vault is configured for users to stake VAI And receive XVS as a reward.\n */\ncontract VAIVault is VAIVaultStorage, AccessControlledV5 {\n    using SafeMath for uint256;\n    using SafeBEP20 for IBEP20;\n\n    /// @notice Event emitted when VAI deposit\n    event Deposit(address indexed user, uint256 amount);\n\n    /// @notice Event emitted when VAI withrawal\n    event Withdraw(address indexed user, uint256 amount);\n\n    /// @notice Event emitted when vault is paused\n    event VaultPaused(address indexed admin);\n\n    /// @notice Event emitted when vault is resumed after pause\n    event VaultResumed(address indexed admin);\n\n    constructor() public {\n        admin = msg.sender;\n    }\n\n    modifier onlyAdmin() {\n        require(msg.sender == admin, \"only admin can\");\n        _;\n    }\n\n    /*** Reentrancy Guard ***/\n\n    /**\n     * @dev Prevents a contract from calling itself, directly or indirectly.\n     */\n    modifier nonReentrant() {\n        require(_notEntered, \"re-entered\");\n        _notEntered = false;\n        _;\n        _notEntered = true; // get a gas-refund post-Istanbul\n    }\n\n    /**\n     * @dev Prevents functions to execute when vault is paused.\n     */\n    modifier isActive() {\n        require(!vaultPaused, \"Vault is paused\");\n        _;\n    }\n\n    /**\n     * @notice Pause vault\n     */\n    function pause() external {\n        _checkAccessAllowed(\"pause()\");\n        require(!vaultPaused, \"Vault is already paused\");\n        vaultPaused = true;\n        emit VaultPaused(msg.sender);\n    }\n\n    /**\n     * @notice Resume vault\n     */\n    function resume() external {\n        _checkAccessAllowed(\"resume()\");\n        require(vaultPaused, \"Vault is not paused\");\n        vaultPaused = false;\n        emit VaultResumed(msg.sender);\n    }\n\n    /**\n     * @notice Deposit VAI to VAIVault for XVS allocation\n     * @param _amount The amount to deposit to vault\n     */\n    function deposit(uint256 _amount) external nonReentrant isActive {\n        UserInfo storage user = userInfo[msg.sender];\n\n        updateVault();\n\n        // Transfer pending tokens to user\n        updateAndPayOutPending(msg.sender);\n\n        // Transfer in the amounts from user\n        if (_amount > 0) {\n            vai.safeTransferFrom(address(msg.sender), address(this), _amount);\n            user.amount = user.amount.add(_amount);\n        }\n\n        user.rewardDebt = user.amount.mul(accXVSPerShare).div(1e18);\n        emit Deposit(msg.sender, _amount);\n    }\n\n    /**\n     * @notice Withdraw VAI from VAIVault\n     * @param _amount The amount to withdraw from vault\n     */\n    function withdraw(uint256 _amount) external nonReentrant isActive {\n        _withdraw(msg.sender, _amount);\n    }\n\n    /**\n     * @notice Claim XVS from VAIVault\n     */\n    function claim() external nonReentrant isActive {\n        _withdraw(msg.sender, 0);\n    }\n\n    /**\n     * @notice Claim XVS from VAIVault\n     * @param account The account for which to claim XVS\n     */\n    function claim(address account) external nonReentrant isActive {\n        _withdraw(account, 0);\n    }\n\n    /**\n     * @notice Low level withdraw function\n     * @param account The account to withdraw from vault\n     * @param _amount The amount to withdraw from vault\n     */\n    function _withdraw(address account, uint256 _amount) internal {\n        UserInfo storage user = userInfo[account];\n        require(user.amount >= _amount, \"withdraw: not good\");\n\n        updateVault();\n        updateAndPayOutPending(account); // Update balances of account this is not withdrawal but claiming XVS farmed\n\n        if (_amount > 0) {\n            user.amount = user.amount.sub(_amount);\n            vai.safeTransfer(address(account), _amount);\n        }\n        user.rewardDebt = user.amount.mul(accXVSPerShare).div(1e18);\n\n        emit Withdraw(account, _amount);\n    }\n\n    /**\n     * @notice View function to see pending XVS on frontend\n     * @param _user The user to see pending XVS\n     * @return Amount of XVS the user can claim\n     */\n    function pendingXVS(address _user) public view returns (uint256) {\n        UserInfo storage user = userInfo[_user];\n\n        return user.amount.mul(accXVSPerShare).div(1e18).sub(user.rewardDebt);\n    }\n\n    /**\n     * @notice Update and pay out pending XVS to user\n     * @param account The user to pay out\n     */\n    function updateAndPayOutPending(address account) internal {\n        uint256 pending = pendingXVS(account);\n\n        if (pending > 0) {\n            safeXVSTransfer(account, pending);\n        }\n    }\n\n    /**\n     * @notice Safe XVS transfer function, just in case if rounding error causes pool to not have enough XVS\n     * @param _to The address that XVS to be transfered\n     * @param _amount The amount that XVS to be transfered\n     */\n    function safeXVSTransfer(address _to, uint256 _amount) internal {\n        uint256 xvsBal = xvs.balanceOf(address(this));\n\n        if (_amount > xvsBal) {\n            xvs.transfer(_to, xvsBal);\n            xvsBalance = xvs.balanceOf(address(this));\n        } else {\n            xvs.transfer(_to, _amount);\n            xvsBalance = xvs.balanceOf(address(this));\n        }\n    }\n\n    /**\n     * @notice Function that updates pending rewards\n     */\n    function updatePendingRewards() public isActive {\n        uint256 newRewards = xvs.balanceOf(address(this)).sub(xvsBalance);\n\n        if (newRewards > 0) {\n            xvsBalance = xvs.balanceOf(address(this)); // If there is no change the balance didn't change\n            pendingRewards = pendingRewards.add(newRewards);\n        }\n    }\n\n    /**\n     * @notice Update reward variables to be up-to-date\n     */\n    function updateVault() internal {\n        updatePendingRewards();\n\n        uint256 vaiBalance = vai.balanceOf(address(this));\n        if (vaiBalance == 0) {\n            // avoids division by 0 errors\n            return;\n        }\n\n        accXVSPerShare = accXVSPerShare.add(pendingRewards.mul(1e18).div(vaiBalance));\n        pendingRewards = 0;\n    }\n\n    /*** Admin Functions ***/\n\n    function _become(VAIVaultProxy vaiVaultProxy) external {\n        require(msg.sender == vaiVaultProxy.admin(), \"only proxy admin can change brains\");\n        require(vaiVaultProxy._acceptImplementation() == 0, \"change not authorized\");\n    }\n\n    function setVenusInfo(address _xvs, address _vai) external onlyAdmin {\n        require(_xvs != address(0) && _vai != address(0), \"addresses must not be zero\");\n        require(address(xvs) == address(0) && address(vai) == address(0), \"addresses already set\");\n        xvs = IBEP20(_xvs);\n        vai = IBEP20(_vai);\n\n        _notEntered = true;\n    }\n\n    /**\n     * @notice Sets the address of the access control of this contract\n     * @dev Admin function to set the access control address\n     * @param newAccessControlAddress New address for the access control\n     */\n    function setAccessControl(address newAccessControlAddress) external onlyAdmin {\n        _setAccessControlManager(newAccessControlAddress);\n    }\n}\n"
+    },
+    "contracts/VAIVault/VAIVaultErrorReporter.sol": {
+      "content": "pragma solidity ^0.5.16;\n\ncontract VAIVaultErrorReporter {\n    enum Error {\n        NO_ERROR,\n        UNAUTHORIZED\n    }\n\n    enum FailureInfo {\n        ACCEPT_ADMIN_PENDING_ADMIN_CHECK,\n        ACCEPT_PENDING_IMPLEMENTATION_ADDRESS_CHECK,\n        SET_PENDING_ADMIN_OWNER_CHECK,\n        SET_PENDING_IMPLEMENTATION_OWNER_CHECK\n    }\n\n    /**\n     * @dev `error` corresponds to enum Error; `info` corresponds to enum FailureInfo, and `detail` is an arbitrary\n     * contract-specific code that enables us to report opaque error codes from upgradeable contracts.\n     **/\n    event Failure(uint error, uint info, uint detail);\n\n    /**\n     * @dev use this when reporting a known error from the money market or a non-upgradeable collaborator\n     */\n    function fail(Error err, FailureInfo info) internal returns (uint) {\n        emit Failure(uint(err), uint(info), 0);\n\n        return uint(err);\n    }\n\n    /**\n     * @dev use this when reporting an opaque error from an upgradeable collaborator contract\n     */\n    function failOpaque(Error err, FailureInfo info, uint opaqueError) internal returns (uint) {\n        emit Failure(uint(err), uint(info), opaqueError);\n\n        return uint(err);\n    }\n}\n"
+    },
+    "contracts/VAIVault/VAIVaultProxy.sol": {
+      "content": "pragma solidity ^0.5.16;\n\nimport \"./VAIVaultStorage.sol\";\nimport \"./VAIVaultErrorReporter.sol\";\n\n/**\n * @title VAI Vault Proxy\n * @author Venus\n * @notice Proxy contract for the VAI Vault\n */\ncontract VAIVaultProxy is VAIVaultAdminStorage, VAIVaultErrorReporter {\n    /**\n     * @notice Emitted when pendingVAIVaultImplementation is changed\n     */\n    event NewPendingImplementation(address oldPendingImplementation, address newPendingImplementation);\n\n    /**\n     * @notice Emitted when pendingVAIVaultImplementation is accepted, which means VAI Vault implementation is updated\n     */\n    event NewImplementation(address oldImplementation, address newImplementation);\n\n    /**\n     * @notice Emitted when pendingAdmin is changed\n     */\n    event NewPendingAdmin(address oldPendingAdmin, address newPendingAdmin);\n\n    /**\n     * @notice Emitted when pendingAdmin is accepted, which means admin is updated\n     */\n    event NewAdmin(address oldAdmin, address newAdmin);\n\n    constructor() public {\n        // Set admin to caller\n        admin = msg.sender;\n    }\n\n    /*** Admin Functions ***/\n    function _setPendingImplementation(address newPendingImplementation) public returns (uint) {\n        if (msg.sender != admin) {\n            return fail(Error.UNAUTHORIZED, FailureInfo.SET_PENDING_IMPLEMENTATION_OWNER_CHECK);\n        }\n\n        address oldPendingImplementation = pendingVAIVaultImplementation;\n\n        pendingVAIVaultImplementation = newPendingImplementation;\n\n        emit NewPendingImplementation(oldPendingImplementation, pendingVAIVaultImplementation);\n\n        return uint(Error.NO_ERROR);\n    }\n\n    /**\n     * @notice Accepts new implementation of VAI Vault. msg.sender must be pendingImplementation\n     * @dev Admin function for new implementation to accept it's role as implementation\n     * @return uint 0=success, otherwise a failure (see ErrorReporter.sol for details)\n     */\n    function _acceptImplementation() public returns (uint) {\n        // Check caller is pendingImplementation\n        if (msg.sender != pendingVAIVaultImplementation) {\n            return fail(Error.UNAUTHORIZED, FailureInfo.ACCEPT_PENDING_IMPLEMENTATION_ADDRESS_CHECK);\n        }\n\n        // Save current values for inclusion in log\n        address oldImplementation = vaiVaultImplementation;\n        address oldPendingImplementation = pendingVAIVaultImplementation;\n\n        vaiVaultImplementation = pendingVAIVaultImplementation;\n\n        pendingVAIVaultImplementation = address(0);\n\n        emit NewImplementation(oldImplementation, vaiVaultImplementation);\n        emit NewPendingImplementation(oldPendingImplementation, pendingVAIVaultImplementation);\n\n        return uint(Error.NO_ERROR);\n    }\n\n    /**\n     * @notice Begins transfer of admin rights. The newPendingAdmin must call `_acceptAdmin` to finalize the transfer.\n     * @dev Admin function to begin change of admin. The newPendingAdmin must call `_acceptAdmin` to finalize the transfer.\n     * @param newPendingAdmin New pending admin.\n     * @return uint 0=success, otherwise a failure (see ErrorReporter.sol for details)\n     */\n    function _setPendingAdmin(address newPendingAdmin) public returns (uint) {\n        // Check caller = admin\n        if (msg.sender != admin) {\n            return fail(Error.UNAUTHORIZED, FailureInfo.SET_PENDING_ADMIN_OWNER_CHECK);\n        }\n\n        // Save current value, if any, for inclusion in log\n        address oldPendingAdmin = pendingAdmin;\n\n        // Store pendingAdmin with value newPendingAdmin\n        pendingAdmin = newPendingAdmin;\n\n        // Emit NewPendingAdmin(oldPendingAdmin, newPendingAdmin)\n        emit NewPendingAdmin(oldPendingAdmin, newPendingAdmin);\n\n        return uint(Error.NO_ERROR);\n    }\n\n    /**\n     * @notice Accepts transfer of admin rights. msg.sender must be pendingAdmin\n     * @dev Admin function for pending admin to accept role and update admin\n     * @return uint 0=success, otherwise a failure (see ErrorReporter.sol for details)\n     */\n    function _acceptAdmin() public returns (uint) {\n        // Check caller is pendingAdmin\n        if (msg.sender != pendingAdmin) {\n            return fail(Error.UNAUTHORIZED, FailureInfo.ACCEPT_ADMIN_PENDING_ADMIN_CHECK);\n        }\n\n        // Save current values for inclusion in log\n        address oldAdmin = admin;\n        address oldPendingAdmin = pendingAdmin;\n\n        // Store admin with value pendingAdmin\n        admin = pendingAdmin;\n\n        // Clear the pending value\n        pendingAdmin = address(0);\n\n        emit NewAdmin(oldAdmin, admin);\n        emit NewPendingAdmin(oldPendingAdmin, pendingAdmin);\n\n        return uint(Error.NO_ERROR);\n    }\n\n    /**\n     * @dev Delegates execution to an implementation contract.\n     * It returns to the external caller whatever the implementation returns\n     * or forwards reverts.\n     */\n    function() external payable {\n        // delegate all other functions to current implementation\n        (bool success, ) = vaiVaultImplementation.delegatecall(msg.data);\n\n        assembly {\n            let free_mem_ptr := mload(0x40)\n            returndatacopy(free_mem_ptr, 0, returndatasize)\n\n            switch success\n            case 0 {\n                revert(free_mem_ptr, returndatasize)\n            }\n            default {\n                return(free_mem_ptr, returndatasize)\n            }\n        }\n    }\n}\n"
+    },
+    "contracts/VAIVault/VAIVaultStorage.sol": {
+      "content": "pragma solidity ^0.5.16;\nimport \"../Utils/SafeMath.sol\";\nimport \"../Utils/IBEP20.sol\";\n\ncontract VAIVaultAdminStorage {\n    /**\n     * @notice Administrator for this contract\n     */\n    address public admin;\n\n    /**\n     * @notice Pending administrator for this contract\n     */\n    address public pendingAdmin;\n\n    /**\n     * @notice Active brains of VAI Vault\n     */\n    address public vaiVaultImplementation;\n\n    /**\n     * @notice Pending brains of VAI Vault\n     */\n    address public pendingVAIVaultImplementation;\n}\n\ncontract VAIVaultStorage is VAIVaultAdminStorage {\n    /// @notice The XVS TOKEN!\n    IBEP20 public xvs;\n\n    /// @notice The VAI TOKEN!\n    IBEP20 public vai;\n\n    /// @notice Guard variable for re-entrancy checks\n    bool internal _notEntered;\n\n    /// @notice XVS balance of vault\n    uint256 public xvsBalance;\n\n    /// @notice Accumulated XVS per share\n    uint256 public accXVSPerShare;\n\n    //// pending rewards awaiting anyone to update\n    uint256 public pendingRewards;\n\n    /// @notice Info of each user.\n    struct UserInfo {\n        uint256 amount;\n        uint256 rewardDebt;\n    }\n\n    // Info of each user that stakes tokens.\n    mapping(address => UserInfo) public userInfo;\n\n    /// @notice pause indicator for Vault\n    bool public vaultPaused;\n\n    /**\n     * @dev This empty reserved space is put in place to allow future versions to add new\n     * variables without shifting down storage in the inheritance chain.\n     * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps\n     */\n    uint256[49] private __gap;\n}\n"
+    },
+    "contracts/VRTVault/VRTVault.sol": {
+      "content": "pragma solidity 0.5.16;\n\nimport \"../Utils/SafeBEP20.sol\";\nimport \"../Utils/IBEP20.sol\";\nimport \"./VRTVaultStorage.sol\";\nimport \"@venusprotocol/governance-contracts/contracts/Governance/AccessControlledV5.sol\";\n\ninterface IVRTVaultProxy {\n    function _acceptImplementation() external;\n\n    function admin() external returns (address);\n}\n\ncontract VRTVault is VRTVaultStorage, AccessControlledV5 {\n    using SafeMath for uint256;\n    using SafeBEP20 for IBEP20;\n\n    /// @notice The upper bound for lastAccruingBlock. Close to year 3,000, considering 3 seconds per block. Used to avoid a value absurdly high\n    uint256 public constant MAX_LAST_ACCRUING_BLOCK = 9999999999;\n\n    /// @notice Event emitted when vault is paused\n    event VaultPaused(address indexed admin);\n\n    /// @notice Event emitted when vault is resumed after pause\n    event VaultResumed(address indexed admin);\n\n    /// @notice Event emitted on VRT deposit\n    event Deposit(address indexed user, uint256 amount);\n\n    /// @notice Event emitted when accruedInterest and VRT PrincipalAmount is withrawn\n    event Withdraw(\n        address indexed user,\n        uint256 withdrawnAmount,\n        uint256 totalPrincipalAmount,\n        uint256 accruedInterest\n    );\n\n    /// @notice Event emitted when Admin withdraw BEP20 token from contract\n    event WithdrawToken(address indexed tokenAddress, address indexed receiver, uint256 amount);\n\n    /// @notice Event emitted when accruedInterest is claimed\n    event Claim(address indexed user, uint256 interestAmount);\n\n    /// @notice Event emitted when lastAccruingBlock state variable changes\n    event LastAccruingBlockChanged(uint256 oldLastAccruingBlock, uint256 newLastAccruingBlock);\n\n    constructor() public {\n        admin = msg.sender;\n    }\n\n    modifier onlyAdmin() {\n        require(msg.sender == admin, \"only admin allowed\");\n        _;\n    }\n\n    function initialize(address _vrtAddress, uint256 _interestRatePerBlock) public {\n        require(msg.sender == admin, \"only admin may initialize the Vault\");\n        require(_vrtAddress != address(0), \"vrtAddress cannot be Zero\");\n        require(interestRatePerBlock == 0, \"Vault may only be initialized once\");\n\n        // Set initial exchange rate\n        interestRatePerBlock = _interestRatePerBlock;\n        require(interestRatePerBlock > 0, \"interestRate Per Block must be greater than zero.\");\n\n        // Set the VRT\n        vrt = IBEP20(_vrtAddress);\n        _notEntered = true;\n    }\n\n    modifier isInitialized() {\n        require(interestRatePerBlock > 0, \"Vault is not initialized\");\n        _;\n    }\n\n    modifier isActive() {\n        require(!vaultPaused, \"Vault is paused\");\n        _;\n    }\n\n    /**\n     * @dev Prevents a contract from calling itself, directly or indirectly.\n     */\n    modifier nonReentrant() {\n        require(_notEntered, \"re-entered\");\n        _notEntered = false;\n        _;\n        _notEntered = true; // get a gas-refund post-Istanbul\n    }\n\n    modifier nonZeroAddress(address _address) {\n        require(_address != address(0), \"Address cannot be Zero\");\n        _;\n    }\n\n    modifier userHasPosition(address userAddress) {\n        UserInfo storage user = userInfo[userAddress];\n        require(user.userAddress != address(0), \"User does not have any position in the Vault.\");\n        _;\n    }\n\n    /**\n     * @notice Pause vault\n     */\n    function pause() external {\n        _checkAccessAllowed(\"pause()\");\n        require(!vaultPaused, \"Vault is already paused\");\n        vaultPaused = true;\n        emit VaultPaused(msg.sender);\n    }\n\n    /**\n     * @notice Resume vault\n     */\n    function resume() external {\n        _checkAccessAllowed(\"resume()\");\n        require(vaultPaused, \"Vault is not paused\");\n        vaultPaused = false;\n        emit VaultResumed(msg.sender);\n    }\n\n    /**\n     * @notice Deposit VRT to VRTVault for a fixed-interest-rate\n     * @param depositAmount The amount to deposit to vault\n     */\n    function deposit(uint256 depositAmount) external nonReentrant isInitialized isActive {\n        require(depositAmount > 0, \"Deposit amount must be non-zero\");\n\n        address userAddress = msg.sender;\n        UserInfo storage user = userInfo[userAddress];\n\n        if (user.userAddress == address(0)) {\n            user.userAddress = userAddress;\n            user.totalPrincipalAmount = depositAmount;\n        } else {\n            // accrue Interest and transfer to the user\n            uint256 accruedInterest = computeAccruedInterest(user.totalPrincipalAmount, user.accrualStartBlockNumber);\n\n            user.totalPrincipalAmount = user.totalPrincipalAmount.add(depositAmount);\n\n            if (accruedInterest > 0) {\n                uint256 vrtBalance = vrt.balanceOf(address(this));\n                require(\n                    vrtBalance >= accruedInterest,\n                    \"Failed to transfer accruedInterest, Insufficient VRT in Vault.\"\n                );\n                emit Claim(userAddress, accruedInterest);\n                vrt.safeTransfer(user.userAddress, accruedInterest);\n            }\n        }\n\n        uint256 currentBlock_ = getBlockNumber();\n        if (lastAccruingBlock > currentBlock_) {\n            user.accrualStartBlockNumber = currentBlock_;\n        } else {\n            user.accrualStartBlockNumber = lastAccruingBlock;\n        }\n        emit Deposit(userAddress, depositAmount);\n        vrt.safeTransferFrom(userAddress, address(this), depositAmount);\n    }\n\n    /**\n     * @notice get accruedInterest of the user's VRTDeposits in the Vault\n     * @param userAddress Address of User in the the Vault\n     * @return The interest accrued, in VRT\n     */\n    function getAccruedInterest(\n        address userAddress\n    ) public view nonZeroAddress(userAddress) isInitialized returns (uint256) {\n        UserInfo storage user = userInfo[userAddress];\n        if (user.accrualStartBlockNumber == 0) {\n            return 0;\n        }\n\n        return computeAccruedInterest(user.totalPrincipalAmount, user.accrualStartBlockNumber);\n    }\n\n    /**\n     * @notice get accruedInterest of the user's VRTDeposits in the Vault\n     * @param totalPrincipalAmount of the User\n     * @param accrualStartBlockNumber of the User\n     * @return The interest accrued, in VRT\n     */\n    function computeAccruedInterest(\n        uint256 totalPrincipalAmount,\n        uint256 accrualStartBlockNumber\n    ) internal view isInitialized returns (uint256) {\n        uint256 blockNumber = getBlockNumber();\n        uint256 _lastAccruingBlock = lastAccruingBlock;\n\n        if (blockNumber > _lastAccruingBlock) {\n            blockNumber = _lastAccruingBlock;\n        }\n\n        if (accrualStartBlockNumber == 0 || accrualStartBlockNumber >= blockNumber) {\n            return 0;\n        }\n\n        // Number of blocks since deposit\n        uint256 blockDelta = blockNumber.sub(accrualStartBlockNumber);\n        uint256 accruedInterest = (totalPrincipalAmount.mul(interestRatePerBlock).mul(blockDelta)).div(1e18);\n        return accruedInterest;\n    }\n\n    /**\n     * @notice claim the accruedInterest of the user's VRTDeposits in the Vault\n     */\n    function claim() external nonReentrant isInitialized userHasPosition(msg.sender) isActive {\n        _claim(msg.sender);\n    }\n\n    /**\n     * @notice claim the accruedInterest of the user's VRTDeposits in the Vault\n     * @param account The account for which to claim rewards\n     */\n    function claim(address account) external nonReentrant isInitialized userHasPosition(account) isActive {\n        _claim(account);\n    }\n\n    /**\n     * @notice Low level claim function\n     * @param account The account for which to claim rewards\n     */\n    function _claim(address account) internal {\n        uint256 accruedInterest = getAccruedInterest(account);\n        if (accruedInterest > 0) {\n            UserInfo storage user = userInfo[account];\n            uint256 vrtBalance = vrt.balanceOf(address(this));\n            require(vrtBalance >= accruedInterest, \"Failed to transfer VRT, Insufficient VRT in Vault.\");\n            emit Claim(account, accruedInterest);\n            uint256 currentBlock_ = getBlockNumber();\n            if (lastAccruingBlock > currentBlock_) {\n                user.accrualStartBlockNumber = currentBlock_;\n            } else {\n                user.accrualStartBlockNumber = lastAccruingBlock;\n            }\n            vrt.safeTransfer(user.userAddress, accruedInterest);\n        }\n    }\n\n    /**\n     * @notice withdraw accruedInterest and totalPrincipalAmount of the user's VRTDeposit in the Vault\n     */\n    function withdraw() external nonReentrant isInitialized userHasPosition(msg.sender) isActive {\n        address userAddress = msg.sender;\n        uint256 accruedInterest = getAccruedInterest(userAddress);\n\n        UserInfo storage user = userInfo[userAddress];\n\n        uint256 totalPrincipalAmount = user.totalPrincipalAmount;\n        uint256 vrtForWithdrawal = accruedInterest.add(totalPrincipalAmount);\n        user.totalPrincipalAmount = 0;\n        user.accrualStartBlockNumber = getBlockNumber();\n\n        uint256 vrtBalance = vrt.balanceOf(address(this));\n        require(vrtBalance >= vrtForWithdrawal, \"Failed to transfer VRT, Insufficient VRT in Vault.\");\n\n        emit Withdraw(userAddress, vrtForWithdrawal, totalPrincipalAmount, accruedInterest);\n        vrt.safeTransfer(user.userAddress, vrtForWithdrawal);\n    }\n\n    /**\n     * @notice withdraw BEP20 tokens from the contract to a recipient address.\n     * @param tokenAddress address of the BEP20 token\n     * @param receiver recipient of the BEP20 token\n     * @param amount tokenAmount\n     */\n    function withdrawBep20(\n        address tokenAddress,\n        address receiver,\n        uint256 amount\n    ) external isInitialized nonZeroAddress(tokenAddress) nonZeroAddress(receiver) {\n        _checkAccessAllowed(\"withdrawBep20(address,address,uint256)\");\n        require(amount > 0, \"amount is invalid\");\n        IBEP20 token = IBEP20(tokenAddress);\n        require(amount <= token.balanceOf(address(this)), \"Insufficient amount in Vault\");\n        emit WithdrawToken(tokenAddress, receiver, amount);\n        token.safeTransfer(receiver, amount);\n    }\n\n    function setLastAccruingBlock(uint256 _lastAccruingBlock) external {\n        _checkAccessAllowed(\"setLastAccruingBlock(uint256)\");\n        require(_lastAccruingBlock < MAX_LAST_ACCRUING_BLOCK, \"_lastAccruingBlock is absurdly high\");\n\n        uint256 oldLastAccruingBlock = lastAccruingBlock;\n        uint256 currentBlock = getBlockNumber();\n        if (oldLastAccruingBlock != 0) {\n            require(currentBlock < oldLastAccruingBlock, \"Cannot change at this point\");\n        }\n        if (oldLastAccruingBlock == 0 || _lastAccruingBlock < oldLastAccruingBlock) {\n            // Must be in future\n            require(currentBlock < _lastAccruingBlock, \"Invalid _lastAccruingBlock interest have been accumulated\");\n        }\n        lastAccruingBlock = _lastAccruingBlock;\n        emit LastAccruingBlockChanged(oldLastAccruingBlock, _lastAccruingBlock);\n    }\n\n    function getBlockNumber() public view returns (uint256) {\n        return block.number;\n    }\n\n    /*** Admin Functions ***/\n\n    function _become(IVRTVaultProxy vrtVaultProxy) external {\n        require(msg.sender == vrtVaultProxy.admin(), \"only proxy admin can change brains\");\n        vrtVaultProxy._acceptImplementation();\n    }\n\n    /**\n     * @notice Sets the address of the access control of this contract\n     * @dev Admin function to set the access control address\n     * @param newAccessControlAddress New address for the access control\n     */\n    function setAccessControl(address newAccessControlAddress) external onlyAdmin {\n        _setAccessControlManager(newAccessControlAddress);\n    }\n}\n"
+    },
+    "contracts/VRTVault/VRTVaultProxy.sol": {
+      "content": "pragma solidity ^0.5.16;\n\nimport \"./VRTVaultStorage.sol\";\n\ncontract VRTVaultProxy is VRTVaultAdminStorage {\n    /**\n     * @notice Emitted when pendingImplementation is changed\n     */\n    event NewPendingImplementation(address oldPendingImplementation, address newPendingImplementation);\n\n    /**\n     * @notice Emitted when pendingImplementation is accepted, which means VRT Vault implementation is updated\n     */\n    event NewImplementation(address oldImplementation, address newImplementation);\n\n    /**\n     * @notice Emitted when pendingAdmin is changed\n     */\n    event NewPendingAdmin(address oldPendingAdmin, address newPendingAdmin);\n\n    /**\n     * @notice Emitted when pendingAdmin is accepted, which means admin is updated\n     */\n    event NewAdmin(address oldAdmin, address newAdmin);\n\n    constructor(address implementation_, address vrtAddress_, uint256 interestRatePerBlock_) public {\n        // Creator of the contract is admin during initialization\n        admin = msg.sender;\n\n        // New implementations always get set via the settor (post-initialize)\n        _setImplementation(implementation_);\n\n        // First delegate gets to initialize the delegator (i.e. storage contract)\n        delegateTo(\n            implementation_,\n            abi.encodeWithSignature(\"initialize(address,uint256)\", vrtAddress_, interestRatePerBlock_)\n        );\n    }\n\n    /**\n     * @notice Called by the admin to update the implementation of the delegator\n     * @param implementation_ The address of the new implementation for delegation\n     */\n    function _setImplementation(address implementation_) public {\n        require(msg.sender == admin, \"VRTVaultProxy::_setImplementation: admin only\");\n        require(implementation_ != address(0), \"VRTVaultProxy::_setImplementation: invalid implementation address\");\n\n        address oldImplementation = implementation;\n        implementation = implementation_;\n\n        emit NewImplementation(oldImplementation, implementation);\n    }\n\n    /**\n     * @notice Internal method to delegate execution to another contract\n     * @dev It returns to the external caller whatever the implementation returns or forwards reverts\n     * @param callee The contract to delegatecall\n     * @param data The raw data to delegatecall\n     * @return The returned bytes from the delegatecall\n     */\n    function delegateTo(address callee, bytes memory data) internal returns (bytes memory) {\n        (bool success, bytes memory returnData) = callee.delegatecall(data);\n        assembly {\n            if eq(success, 0) {\n                revert(add(returnData, 0x20), returndatasize)\n            }\n        }\n        return returnData;\n    }\n\n    /*** Admin Functions ***/\n    function _setPendingImplementation(address newPendingImplementation) public {\n        require(msg.sender == admin, \"Only admin can set Pending Implementation\");\n\n        address oldPendingImplementation = pendingImplementation;\n\n        pendingImplementation = newPendingImplementation;\n\n        emit NewPendingImplementation(oldPendingImplementation, pendingImplementation);\n    }\n\n    /**\n     * @notice Accepts new implementation of VRT Vault. msg.sender must be pendingImplementation\n     * @dev Admin function for new implementation to accept it's role as implementation\n     */\n    function _acceptImplementation() public {\n        // Check caller is pendingImplementation\n        require(\n            msg.sender == pendingImplementation,\n            \"only address marked as pendingImplementation can accept Implementation\"\n        );\n\n        // Save current values for inclusion in log\n        address oldImplementation = implementation;\n        address oldPendingImplementation = pendingImplementation;\n\n        implementation = pendingImplementation;\n\n        pendingImplementation = address(0);\n\n        emit NewImplementation(oldImplementation, implementation);\n        emit NewPendingImplementation(oldPendingImplementation, pendingImplementation);\n    }\n\n    /**\n     * @notice Begins transfer of admin rights. The newPendingAdmin must call `_acceptAdmin` to finalize the transfer.\n     * @dev Admin function to begin change of admin. The newPendingAdmin must call `_acceptAdmin` to finalize the transfer.\n     * @param newPendingAdmin New pending admin.\n     */\n    function _setPendingAdmin(address newPendingAdmin) public {\n        // Check caller = admin\n        require(msg.sender == admin, \"only admin can set pending admin\");\n\n        // Save current value, if any, for inclusion in log\n        address oldPendingAdmin = pendingAdmin;\n\n        // Store pendingAdmin with value newPendingAdmin\n        pendingAdmin = newPendingAdmin;\n\n        // Emit NewPendingAdmin(oldPendingAdmin, newPendingAdmin)\n        emit NewPendingAdmin(oldPendingAdmin, newPendingAdmin);\n    }\n\n    /**\n     * @notice Accepts transfer of admin rights. msg.sender must be pendingAdmin\n     * @dev Admin function for pending admin to accept role and update admin\n     * @dev return uint 0=success, otherwise a failure (see ErrorReporter.sol for details)\n     */\n    function _acceptAdmin() public {\n        // Check caller is pendingAdmin\n        require(msg.sender == pendingAdmin, \"only address marked as pendingAdmin can accept as Admin\");\n\n        // Save current values for inclusion in log\n        address oldAdmin = admin;\n        address oldPendingAdmin = pendingAdmin;\n\n        // Store admin with value pendingAdmin\n        admin = pendingAdmin;\n\n        // Clear the pending value\n        pendingAdmin = address(0);\n\n        emit NewAdmin(oldAdmin, admin);\n        emit NewPendingAdmin(oldPendingAdmin, pendingAdmin);\n    }\n\n    /**\n     * @dev Delegates execution to an implementation contract.\n     * It returns to the external caller whatever the implementation returns\n     * or forwards reverts.\n     */\n    function() external payable {\n        // delegate all other functions to current implementation\n        (bool success, ) = implementation.delegatecall(msg.data);\n\n        assembly {\n            let free_mem_ptr := mload(0x40)\n            returndatacopy(free_mem_ptr, 0, returndatasize)\n\n            switch success\n            case 0 {\n                revert(free_mem_ptr, returndatasize)\n            }\n            default {\n                return(free_mem_ptr, returndatasize)\n            }\n        }\n    }\n}\n"
+    },
+    "contracts/VRTVault/VRTVaultStorage.sol": {
+      "content": "pragma solidity ^0.5.16;\nimport \"../Utils/SafeMath.sol\";\nimport \"../Utils/IBEP20.sol\";\n\ncontract VRTVaultAdminStorage {\n    /**\n     * @notice Administrator for this contract\n     */\n    address public admin;\n\n    /**\n     * @notice Pending administrator for this contract\n     */\n    address public pendingAdmin;\n\n    /**\n     * @notice Active brains of VRT Vault\n     */\n    address public implementation;\n\n    /**\n     * @notice Pending brains of VAI Vault\n     */\n    address public pendingImplementation;\n}\n\ncontract VRTVaultStorage is VRTVaultAdminStorage {\n    /// @notice Guard variable for re-entrancy checks\n    bool public _notEntered;\n\n    /// @notice pause indicator for Vault\n    bool public vaultPaused;\n\n    /// @notice The VRT TOKEN!\n    IBEP20 public vrt;\n\n    /// @notice interestRate for accrual - per Block\n    uint256 public interestRatePerBlock;\n\n    /// @notice Info of each user.\n    struct UserInfo {\n        address userAddress;\n        uint256 accrualStartBlockNumber;\n        uint256 totalPrincipalAmount;\n        uint256 lastWithdrawnBlockNumber;\n    }\n\n    // Info of each user that stakes tokens.\n    mapping(address => UserInfo) public userInfo;\n\n    /// @notice block number after which no interest will be accrued\n    uint256 public lastAccruingBlock;\n\n    /**\n     * @dev This empty reserved space is put in place to allow future versions to add new\n     * variables without shifting down storage in the inheritance chain.\n     * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps\n     */\n    uint256[49] private __gap;\n}\n"
+    },
+    "contracts/XVSVault/XVSStore.sol": {
+      "content": "pragma solidity 0.5.16;\nimport \"../Utils/SafeBEP20.sol\";\nimport \"../Utils/IBEP20.sol\";\n\n/**\n * @title XVS Store\n * @author Venus\n * @notice XVS Store responsible for distributing XVS rewards\n */\ncontract XVSStore {\n    using SafeMath for uint256;\n    using SafeBEP20 for IBEP20;\n\n    /// @notice The Admin Address\n    address public admin;\n\n    /// @notice The pending admin address\n    address public pendingAdmin;\n\n    /// @notice The Owner Address\n    address public owner;\n\n    /// @notice The reward tokens\n    mapping(address => bool) public rewardTokens;\n\n    /// @notice Emitted when pendingAdmin is changed\n    event NewPendingAdmin(address oldPendingAdmin, address newPendingAdmin);\n\n    /// @notice Event emitted when admin changed\n    event AdminTransferred(address indexed oldAdmin, address indexed newAdmin);\n\n    /// @notice Event emitted when owner changed\n    event OwnerTransferred(address indexed oldOwner, address indexed newOwner);\n\n    constructor() public {\n        admin = msg.sender;\n    }\n\n    modifier onlyAdmin() {\n        require(msg.sender == admin, \"only admin can\");\n        _;\n    }\n\n    modifier onlyOwner() {\n        require(msg.sender == owner, \"only owner can\");\n        _;\n    }\n\n    /**\n     * @notice Safely transfer rewards. Only active reward tokens can be sent using this function.\n     * Only callable by owner\n     * @dev Safe reward token transfer function, just in case if rounding error causes pool to not have enough tokens.\n     * @param token Reward token to transfer\n     * @param _to Destination address of the reward\n     * @param _amount Amount to transfer\n     */\n    function safeRewardTransfer(address token, address _to, uint256 _amount) external onlyOwner {\n        require(rewardTokens[token] == true, \"only reward token can\");\n\n        if (address(token) != address(0)) {\n            uint256 tokenBalance = IBEP20(token).balanceOf(address(this));\n            if (_amount > tokenBalance) {\n                IBEP20(token).safeTransfer(_to, tokenBalance);\n            } else {\n                IBEP20(token).safeTransfer(_to, _amount);\n            }\n        }\n    }\n\n    /**\n     * @notice Allows the admin to propose a new admin\n     * Only callable admin\n     * @param _admin Propose an account as admin of the XVS store\n     */\n    function setPendingAdmin(address _admin) external onlyAdmin {\n        address oldPendingAdmin = pendingAdmin;\n        pendingAdmin = _admin;\n        emit NewPendingAdmin(oldPendingAdmin, _admin);\n    }\n\n    /**\n     * @notice Allows an account that is pending as admin to accept the role\n     * nly calllable by the pending admin\n     */\n    function acceptAdmin() external {\n        require(msg.sender == pendingAdmin, \"only pending admin\");\n        address oldAdmin = admin;\n        address oldPendingAdmin = pendingAdmin;\n\n        admin = pendingAdmin;\n        pendingAdmin = address(0);\n\n        emit NewPendingAdmin(oldPendingAdmin, pendingAdmin);\n        emit AdminTransferred(oldAdmin, admin);\n    }\n\n    /**\n     * @notice Set the contract owner\n     * @param _owner The address of the owner to set\n     * Only callable admin\n     */\n    function setNewOwner(address _owner) external onlyAdmin {\n        require(_owner != address(0), \"new owner is the zero address\");\n        address oldOwner = owner;\n        owner = _owner;\n        emit OwnerTransferred(oldOwner, _owner);\n    }\n\n    /**\n     * @notice Set or disable a reward token\n     * @param _tokenAddress The address of a token to set as active or inactive\n     * @param status Set whether a reward token is active or not\n     */\n    function setRewardToken(address _tokenAddress, bool status) external {\n        require(msg.sender == admin || msg.sender == owner, \"only admin or owner can\");\n        rewardTokens[_tokenAddress] = status;\n    }\n\n    /**\n     * @notice Security function to allow the owner of the contract to withdraw from the contract\n     * @param _tokenAddress Reward token address to withdraw\n     * @param _amount Amount of token to withdraw\n     */\n    function emergencyRewardWithdraw(address _tokenAddress, uint256 _amount) external onlyOwner {\n        IBEP20(_tokenAddress).safeTransfer(address(msg.sender), _amount);\n    }\n}\n"
+    },
+    "contracts/XVSVault/XVSVault.sol": {
+      "content": "// SPDX-License-Identifier: BSD-3-Clause\n\npragma solidity 0.5.16;\npragma experimental ABIEncoderV2;\n\nimport { ECDSA } from \"../Utils/ECDSA.sol\";\nimport { SafeBEP20 } from \"../Utils/SafeBEP20.sol\";\nimport { IBEP20 } from \"../Utils/IBEP20.sol\";\nimport { XVSVaultStorage } from \"./XVSVaultStorage.sol\";\nimport { IPrimeV5 } from \"../Tokens/Prime/IPrimeV5.sol\";\nimport { SafeCast } from \"../Utils/SafeCast.sol\";\nimport { SafeMath } from \"../Utils/SafeMath.sol\";\n\nimport { AccessControlledV5 } from \"@venusprotocol/governance-contracts/contracts/Governance/AccessControlledV5.sol\";\nimport { TimeManagerV5 } from \"@venusprotocol/solidity-utilities/contracts/TimeManagerV5.sol\";\n\nimport { XVSStore } from \"./XVSStore.sol\";\nimport { XVSVaultProxy } from \"./XVSVaultProxy.sol\";\n\n/**\n * @title XVS Vault\n * @author Venus\n * @notice The XVS Vault allows XVS holders to lock their XVS to recieve voting rights in Venus governance and are rewarded with XVS.\n */\ncontract XVSVault is XVSVaultStorage, ECDSA, AccessControlledV5, TimeManagerV5 {\n    using SafeMath for uint256;\n    using SafeCast for uint256;\n    using SafeBEP20 for IBEP20;\n\n    /// @notice The upper bound for the lock period in a pool, 10 years\n    uint256 public constant MAX_LOCK_PERIOD = 60 * 60 * 24 * 365 * 10;\n\n    /// @notice Event emitted when deposit\n    event Deposit(address indexed user, address indexed rewardToken, uint256 indexed pid, uint256 amount);\n\n    /// @notice Event emitted when execute withrawal\n    event ExecutedWithdrawal(address indexed user, address indexed rewardToken, uint256 indexed pid, uint256 amount);\n\n    /// @notice Event emitted when request withrawal\n    event RequestedWithdrawal(address indexed user, address indexed rewardToken, uint256 indexed pid, uint256 amount);\n\n    /// @notice An event thats emitted when an account changes its delegate\n    event DelegateChangedV2(address indexed delegator, address indexed fromDelegate, address indexed toDelegate);\n\n    /// @notice An event thats emitted when a delegate account's vote balance changes\n    event DelegateVotesChangedV2(address indexed delegate, uint previousBalance, uint newBalance);\n\n    /// @notice An event emitted when the reward store address is updated\n    event StoreUpdated(address oldXvs, address oldStore, address newXvs, address newStore);\n\n    /// @notice An event emitted when the withdrawal locking period is updated for a pool\n    event WithdrawalLockingPeriodUpdated(address indexed rewardToken, uint indexed pid, uint oldPeriod, uint newPeriod);\n\n    /// @notice An event emitted when the reward amount per block or second is modified for a pool\n    event RewardAmountUpdated(address indexed rewardToken, uint oldReward, uint newReward);\n\n    /// @notice An event emitted when a new pool is added\n    event PoolAdded(\n        address indexed rewardToken,\n        uint indexed pid,\n        address indexed token,\n        uint allocPoints,\n        uint rewardPerBlockOrSecond,\n        uint lockPeriod\n    );\n\n    /// @notice An event emitted when a pool allocation points are updated\n    event PoolUpdated(address indexed rewardToken, uint indexed pid, uint oldAllocPoints, uint newAllocPoints);\n\n    /// @notice Event emitted when reward claimed\n    event Claim(address indexed user, address indexed rewardToken, uint256 indexed pid, uint256 amount);\n\n    /// @notice Event emitted when vault is paused\n    event VaultPaused(address indexed admin);\n\n    /// @notice Event emitted when vault is resumed after pause\n    event VaultResumed(address indexed admin);\n\n    /// @notice Event emitted when protocol logs a debt to a user due to insufficient funds for pending reward distribution\n    event VaultDebtUpdated(\n        address indexed rewardToken,\n        address indexed userAddress,\n        uint256 oldOwedAmount,\n        uint256 newOwedAmount\n    );\n\n    /// @notice Emitted when prime token contract address is changed\n    event NewPrimeToken(\n        IPrimeV5 indexed oldPrimeToken,\n        IPrimeV5 indexed newPrimeToken,\n        address oldPrimeRewardToken,\n        address newPrimeRewardToken,\n        uint256 oldPrimePoolId,\n        uint256 newPrimePoolId\n    );\n\n    /**\n     * @notice XVSVault constructor\n     */\n    constructor() public {\n        admin = msg.sender;\n    }\n\n    modifier onlyAdmin() {\n        require(msg.sender == admin, \"only admin can\");\n        _;\n    }\n\n    /**\n     * @dev Prevents a contract from calling itself, directly or indirectly.\n     */\n    modifier nonReentrant() {\n        require(_notEntered, \"re-entered\");\n        _notEntered = false;\n        _;\n        _notEntered = true; // get a gas-refund post-Istanbul\n    }\n\n    /**\n     * @dev Prevents functions to execute when vault is paused.\n     */\n    modifier isActive() {\n        require(!vaultPaused, \"Vault is paused\");\n        _;\n    }\n\n    /**\n     * @notice Pauses vault\n     */\n    function pause() external {\n        _checkAccessAllowed(\"pause()\");\n        require(!vaultPaused, \"Vault is already paused\");\n        vaultPaused = true;\n        emit VaultPaused(msg.sender);\n    }\n\n    /**\n     * @notice Resume vault\n     */\n    function resume() external {\n        _checkAccessAllowed(\"resume()\");\n        require(vaultPaused, \"Vault is not paused\");\n        vaultPaused = false;\n        emit VaultResumed(msg.sender);\n    }\n\n    /**\n     * @notice Returns the number of pools with the specified reward token\n     * @param rewardToken Reward token address\n     * @return Number of pools that distribute the specified token as a reward\n     */\n    function poolLength(address rewardToken) external view returns (uint256) {\n        return poolInfos[rewardToken].length;\n    }\n\n    /**\n     * @notice Returns the number of reward tokens created per block or second\n     * @param _rewardToken Reward token address\n     * @return Number of reward tokens created per block or second\n     */\n    function rewardTokenAmountsPerBlock(address _rewardToken) external view returns (uint256) {\n        return rewardTokenAmountsPerBlockOrSecond[_rewardToken];\n    }\n\n    /**\n     * @notice Add a new token pool\n     * @dev This vault DOES NOT support deflationary tokens — it expects that\n     *   the amount of transferred tokens would equal the actually deposited\n     *   amount. In practice this means that this vault DOES NOT support USDT\n     *   and similar tokens (that do not provide these guarantees).\n     * @param _rewardToken Reward token address\n     * @param _allocPoint Number of allocation points assigned to this pool\n     * @param _token Staked token\n     * @param _rewardPerBlockOrSecond Initial reward per block or second, in terms of _rewardToken\n     * @param _lockPeriod A period between withdrawal request and a moment when it's executable\n     */\n    function add(\n        address _rewardToken,\n        uint256 _allocPoint,\n        IBEP20 _token,\n        uint256 _rewardPerBlockOrSecond,\n        uint256 _lockPeriod\n    ) external {\n        _checkAccessAllowed(\"add(address,uint256,address,uint256,uint256)\");\n        _ensureNonzeroAddress(_rewardToken);\n        _ensureNonzeroAddress(address(_token));\n        require(address(xvsStore) != address(0), \"Store contract address is empty\");\n        require(_allocPoint > 0, \"Alloc points must not be zero\");\n\n        massUpdatePools(_rewardToken);\n\n        PoolInfo[] storage poolInfo = poolInfos[_rewardToken];\n\n        uint256 length = poolInfo.length;\n        for (uint256 pid = 0; pid < length; ++pid) {\n            require(poolInfo[pid].token != _token, \"Pool already added\");\n        }\n\n        // We use balanceOf to get the supply amount, so shouldn't be possible to\n        // configure pools with different reward token but the same staked token\n        require(!isStakedToken[address(_token)], \"Token exists in other pool\");\n\n        totalAllocPoints[_rewardToken] = totalAllocPoints[_rewardToken].add(_allocPoint);\n\n        rewardTokenAmountsPerBlockOrSecond[_rewardToken] = _rewardPerBlockOrSecond;\n\n        poolInfo.push(\n            PoolInfo({\n                token: _token,\n                allocPoint: _allocPoint,\n                lastRewardBlockOrSecond: getBlockNumberOrTimestamp(),\n                accRewardPerShare: 0,\n                lockPeriod: _lockPeriod\n            })\n        );\n        isStakedToken[address(_token)] = true;\n\n        XVSStore(xvsStore).setRewardToken(_rewardToken, true);\n\n        emit PoolAdded(\n            _rewardToken,\n            poolInfo.length - 1,\n            address(_token),\n            _allocPoint,\n            _rewardPerBlockOrSecond,\n            _lockPeriod\n        );\n    }\n\n    /**\n     * @notice Update the given pool's reward allocation point\n     * @param _rewardToken Reward token address\n     * @param _pid Pool index\n     * @param _allocPoint Number of allocation points assigned to this pool\n     */\n    function set(address _rewardToken, uint256 _pid, uint256 _allocPoint) external {\n        _checkAccessAllowed(\"set(address,uint256,uint256)\");\n        _ensureValidPool(_rewardToken, _pid);\n\n        massUpdatePools(_rewardToken);\n\n        PoolInfo[] storage poolInfo = poolInfos[_rewardToken];\n        uint256 newTotalAllocPoints = totalAllocPoints[_rewardToken].sub(poolInfo[_pid].allocPoint).add(_allocPoint);\n        require(newTotalAllocPoints > 0, \"Alloc points per reward token must not be zero\");\n\n        uint256 oldAllocPoints = poolInfo[_pid].allocPoint;\n        poolInfo[_pid].allocPoint = _allocPoint;\n        totalAllocPoints[_rewardToken] = newTotalAllocPoints;\n\n        emit PoolUpdated(_rewardToken, _pid, oldAllocPoints, _allocPoint);\n    }\n\n    /**\n     * @notice Update the given reward token's amount per block or second\n     * @param _rewardToken Reward token address\n     * @param _rewardAmount Number of allocation points assigned to this pool\n     */\n    function setRewardAmountPerBlockOrSecond(address _rewardToken, uint256 _rewardAmount) external {\n        _checkAccessAllowed(\"setRewardAmountPerBlockOrSecond(address,uint256)\");\n        require(XVSStore(xvsStore).rewardTokens(_rewardToken), \"Invalid reward token\");\n        massUpdatePools(_rewardToken);\n        uint256 oldReward = rewardTokenAmountsPerBlockOrSecond[_rewardToken];\n        rewardTokenAmountsPerBlockOrSecond[_rewardToken] = _rewardAmount;\n\n        emit RewardAmountUpdated(_rewardToken, oldReward, _rewardAmount);\n    }\n\n    /**\n     * @notice Update the lock period after which a requested withdrawal can be executed\n     * @param _rewardToken Reward token address\n     * @param _pid Pool index\n     * @param _newPeriod New lock period\n     */\n    function setWithdrawalLockingPeriod(address _rewardToken, uint256 _pid, uint256 _newPeriod) external {\n        _checkAccessAllowed(\"setWithdrawalLockingPeriod(address,uint256,uint256)\");\n        _ensureValidPool(_rewardToken, _pid);\n        require(_newPeriod > 0 && _newPeriod < MAX_LOCK_PERIOD, \"Invalid new locking period\");\n        PoolInfo storage pool = poolInfos[_rewardToken][_pid];\n        uint256 oldPeriod = pool.lockPeriod;\n        pool.lockPeriod = _newPeriod;\n\n        emit WithdrawalLockingPeriodUpdated(_rewardToken, _pid, oldPeriod, _newPeriod);\n    }\n\n    /**\n     * @notice Deposit XVSVault for XVS allocation\n     * @param _rewardToken The Reward Token Address\n     * @param _pid The Pool Index\n     * @param _amount The amount to deposit to vault\n     */\n    function deposit(address _rewardToken, uint256 _pid, uint256 _amount) external nonReentrant isActive {\n        _ensureValidPool(_rewardToken, _pid);\n        PoolInfo storage pool = poolInfos[_rewardToken][_pid];\n        UserInfo storage user = userInfos[_rewardToken][_pid][msg.sender];\n        _updatePool(_rewardToken, _pid);\n        require(pendingWithdrawalsBeforeUpgrade(_rewardToken, _pid, msg.sender) == 0, \"execute pending withdrawal\");\n\n        if (user.amount > 0) {\n            uint256 pending = _computeReward(user, pool);\n            if (pending > 0) {\n                _transferReward(_rewardToken, msg.sender, pending);\n                emit Claim(msg.sender, _rewardToken, _pid, pending);\n            }\n        }\n        pool.token.safeTransferFrom(msg.sender, address(this), _amount);\n        user.amount = user.amount.add(_amount);\n        user.rewardDebt = _cumulativeReward(user, pool);\n\n        // Update Delegate Amount\n        if (address(pool.token) == xvsAddress) {\n            _moveDelegates(address(0), delegates[msg.sender], safe96(_amount, \"XVSVault::deposit: votes overflow\"));\n        }\n\n        if (primeRewardToken == _rewardToken && _pid == primePoolId) {\n            primeToken.xvsUpdated(msg.sender);\n        }\n\n        emit Deposit(msg.sender, _rewardToken, _pid, _amount);\n    }\n\n    /**\n     * @notice Claim rewards for pool\n     * @param _account The account for which to claim rewards\n     * @param _rewardToken The Reward Token Address\n     * @param _pid The Pool Index\n     */\n    function claim(address _account, address _rewardToken, uint256 _pid) external nonReentrant isActive {\n        _ensureValidPool(_rewardToken, _pid);\n        PoolInfo storage pool = poolInfos[_rewardToken][_pid];\n        UserInfo storage user = userInfos[_rewardToken][_pid][_account];\n        _updatePool(_rewardToken, _pid);\n        require(pendingWithdrawalsBeforeUpgrade(_rewardToken, _pid, _account) == 0, \"execute pending withdrawal\");\n\n        if (user.amount > 0) {\n            uint256 pending = _computeReward(user, pool);\n\n            if (pending > 0) {\n                user.rewardDebt = _cumulativeReward(user, pool);\n\n                _transferReward(_rewardToken, _account, pending);\n                emit Claim(_account, _rewardToken, _pid, pending);\n            }\n        }\n    }\n\n    /**\n     * @notice Pushes withdrawal request to the requests array and updates\n     *   the pending withdrawals amount. The requests are always sorted\n     *   by unlock time (descending) so that the earliest to execute requests\n     *   are always at the end of the array.\n     * @param _user The user struct storage pointer\n     * @param _requests The user's requests array storage pointer\n     * @param _amount The amount being requested\n     */\n    function pushWithdrawalRequest(\n        UserInfo storage _user,\n        WithdrawalRequest[] storage _requests,\n        uint _amount,\n        uint _lockedUntil\n    ) internal {\n        uint i = _requests.length;\n        _requests.push(WithdrawalRequest(0, 0, 1));\n        // Keep it sorted so that the first to get unlocked request is always at the end\n        for (; i > 0 && _requests[i - 1].lockedUntil <= _lockedUntil; --i) {\n            _requests[i] = _requests[i - 1];\n        }\n        _requests[i] = WithdrawalRequest(_amount, _lockedUntil.toUint128(), 1);\n        _user.pendingWithdrawals = _user.pendingWithdrawals.add(_amount);\n    }\n\n    /**\n     * @notice Pops the requests with unlock time < now from the requests\n     *   array and deducts the computed amount from the user's pending\n     *   withdrawals counter. Assumes that the requests array is sorted\n     *   by unclock time (descending).\n     * @dev This function **removes** the eligible requests from the requests\n     *   array. If this function is called, the withdrawal should actually\n     *   happen (or the transaction should be reverted).\n     * @param _user The user struct storage pointer\n     * @param _requests The user's requests array storage pointer\n     * @return beforeUpgradeWithdrawalAmount The amount eligible for withdrawal before upgrade (this amount should be\n     *   sent to the user, otherwise the state would be inconsistent).\n     * @return afterUpgradeWithdrawalAmount The amount eligible for withdrawal after upgrade (this amount should be\n     *   sent to the user, otherwise the state would be inconsistent).\n     */\n    function popEligibleWithdrawalRequests(\n        UserInfo storage _user,\n        WithdrawalRequest[] storage _requests\n    ) internal returns (uint beforeUpgradeWithdrawalAmount, uint afterUpgradeWithdrawalAmount) {\n        // Since the requests are sorted by their unlock time, we can just\n        // pop them from the array and stop at the first not-yet-eligible one\n        for (uint i = _requests.length; i > 0 && isUnlocked(_requests[i - 1]); --i) {\n            if (_requests[i - 1].afterUpgrade == 1) {\n                afterUpgradeWithdrawalAmount = afterUpgradeWithdrawalAmount.add(_requests[i - 1].amount);\n            } else {\n                beforeUpgradeWithdrawalAmount = beforeUpgradeWithdrawalAmount.add(_requests[i - 1].amount);\n            }\n\n            _requests.pop();\n        }\n        _user.pendingWithdrawals = _user.pendingWithdrawals.sub(\n            afterUpgradeWithdrawalAmount.add(beforeUpgradeWithdrawalAmount)\n        );\n        return (beforeUpgradeWithdrawalAmount, afterUpgradeWithdrawalAmount);\n    }\n\n    /**\n     * @notice Checks if the request is eligible for withdrawal.\n     * @param _request The request struct storage pointer\n     * @return True if the request is eligible for withdrawal, false otherwise\n     */\n    function isUnlocked(WithdrawalRequest storage _request) private view returns (bool) {\n        return _request.lockedUntil <= block.timestamp;\n    }\n\n    /**\n     * @notice Execute withdrawal to XVSVault for XVS allocation\n     * @param _rewardToken The Reward Token Address\n     * @param _pid The Pool Index\n     */\n    function executeWithdrawal(address _rewardToken, uint256 _pid) external nonReentrant isActive {\n        _ensureValidPool(_rewardToken, _pid);\n        PoolInfo storage pool = poolInfos[_rewardToken][_pid];\n        UserInfo storage user = userInfos[_rewardToken][_pid][msg.sender];\n        WithdrawalRequest[] storage requests = withdrawalRequests[_rewardToken][_pid][msg.sender];\n\n        uint256 beforeUpgradeWithdrawalAmount;\n        uint256 afterUpgradeWithdrawalAmount;\n\n        (beforeUpgradeWithdrawalAmount, afterUpgradeWithdrawalAmount) = popEligibleWithdrawalRequests(user, requests);\n        require(beforeUpgradeWithdrawalAmount > 0 || afterUpgradeWithdrawalAmount > 0, \"nothing to withdraw\");\n\n        // Having both old-style and new-style requests is not allowed and shouldn't be possible\n        require(beforeUpgradeWithdrawalAmount == 0 || afterUpgradeWithdrawalAmount == 0, \"inconsistent state\");\n\n        if (beforeUpgradeWithdrawalAmount > 0) {\n            _updatePool(_rewardToken, _pid);\n            uint256 pending = user.amount.mul(pool.accRewardPerShare).div(1e12).sub(user.rewardDebt);\n            XVSStore(xvsStore).safeRewardTransfer(_rewardToken, msg.sender, pending);\n            user.amount = user.amount.sub(beforeUpgradeWithdrawalAmount);\n            user.rewardDebt = user.amount.mul(pool.accRewardPerShare).div(1e12);\n            pool.token.safeTransfer(address(msg.sender), beforeUpgradeWithdrawalAmount);\n        } else {\n            user.amount = user.amount.sub(afterUpgradeWithdrawalAmount);\n            totalPendingWithdrawals[_rewardToken][_pid] = totalPendingWithdrawals[_rewardToken][_pid].sub(\n                afterUpgradeWithdrawalAmount\n            );\n            pool.token.safeTransfer(address(msg.sender), afterUpgradeWithdrawalAmount);\n        }\n\n        emit ExecutedWithdrawal(\n            msg.sender,\n            _rewardToken,\n            _pid,\n            beforeUpgradeWithdrawalAmount.add(afterUpgradeWithdrawalAmount)\n        );\n    }\n\n    /**\n     * @notice Returns before and after upgrade pending withdrawal amount\n     * @param _requests The user's requests array storage pointer\n     * @return beforeUpgradeWithdrawalAmount The amount eligible for withdrawal before upgrade\n     * @return afterUpgradeWithdrawalAmount The amount eligible for withdrawal after upgrade\n     */\n    function getRequestedWithdrawalAmount(\n        WithdrawalRequest[] storage _requests\n    ) internal view returns (uint beforeUpgradeWithdrawalAmount, uint afterUpgradeWithdrawalAmount) {\n        for (uint i = _requests.length; i > 0; --i) {\n            if (_requests[i - 1].afterUpgrade == 1) {\n                afterUpgradeWithdrawalAmount = afterUpgradeWithdrawalAmount.add(_requests[i - 1].amount);\n            } else {\n                beforeUpgradeWithdrawalAmount = beforeUpgradeWithdrawalAmount.add(_requests[i - 1].amount);\n            }\n        }\n        return (beforeUpgradeWithdrawalAmount, afterUpgradeWithdrawalAmount);\n    }\n\n    /**\n     * @notice Request withdrawal to XVSVault for XVS allocation\n     * @param _rewardToken The Reward Token Address\n     * @param _pid The Pool Index\n     * @param _amount The amount to withdraw from the vault\n     */\n    function requestWithdrawal(address _rewardToken, uint256 _pid, uint256 _amount) external nonReentrant isActive {\n        _ensureValidPool(_rewardToken, _pid);\n        require(_amount > 0, \"requested amount cannot be zero\");\n        UserInfo storage user = userInfos[_rewardToken][_pid][msg.sender];\n        require(user.amount >= user.pendingWithdrawals.add(_amount), \"requested amount is invalid\");\n\n        PoolInfo storage pool = poolInfos[_rewardToken][_pid];\n        WithdrawalRequest[] storage requests = withdrawalRequests[_rewardToken][_pid][msg.sender];\n\n        uint beforeUpgradeWithdrawalAmount;\n\n        (beforeUpgradeWithdrawalAmount, ) = getRequestedWithdrawalAmount(requests);\n        require(beforeUpgradeWithdrawalAmount == 0, \"execute pending withdrawal\");\n\n        _updatePool(_rewardToken, _pid);\n        uint256 pending = _computeReward(user, pool);\n        _transferReward(_rewardToken, msg.sender, pending);\n\n        uint lockedUntil = pool.lockPeriod.add(block.timestamp);\n\n        pushWithdrawalRequest(user, requests, _amount, lockedUntil);\n        totalPendingWithdrawals[_rewardToken][_pid] = totalPendingWithdrawals[_rewardToken][_pid].add(_amount);\n        user.rewardDebt = _cumulativeReward(user, pool);\n\n        // Update Delegate Amount\n        if (address(pool.token) == xvsAddress) {\n            _moveDelegates(\n                delegates[msg.sender],\n                address(0),\n                safe96(_amount, \"XVSVault::requestWithdrawal: votes overflow\")\n            );\n        }\n\n        if (primeRewardToken == _rewardToken && _pid == primePoolId) {\n            primeToken.xvsUpdated(msg.sender);\n        }\n\n        emit Claim(msg.sender, _rewardToken, _pid, pending);\n        emit RequestedWithdrawal(msg.sender, _rewardToken, _pid, _amount);\n    }\n\n    /**\n     * @notice Get unlocked withdrawal amount\n     * @param _rewardToken The Reward Token Address\n     * @param _pid The Pool Index\n     * @param _user The User Address\n     * @return withdrawalAmount Amount that the user can withdraw\n     */\n    function getEligibleWithdrawalAmount(\n        address _rewardToken,\n        uint256 _pid,\n        address _user\n    ) external view returns (uint withdrawalAmount) {\n        _ensureValidPool(_rewardToken, _pid);\n        WithdrawalRequest[] storage requests = withdrawalRequests[_rewardToken][_pid][_user];\n        // Since the requests are sorted by their unlock time, we can take\n        // the entries from the end of the array and stop at the first\n        // not-yet-eligible one\n        for (uint i = requests.length; i > 0 && isUnlocked(requests[i - 1]); --i) {\n            withdrawalAmount = withdrawalAmount.add(requests[i - 1].amount);\n        }\n        return withdrawalAmount;\n    }\n\n    /**\n     * @notice Get requested amount\n     * @param _rewardToken The Reward Token Address\n     * @param _pid The Pool Index\n     * @param _user The User Address\n     * @return Total amount of requested but not yet executed withdrawals (including both executable and locked ones)\n     */\n    function getRequestedAmount(address _rewardToken, uint256 _pid, address _user) external view returns (uint256) {\n        _ensureValidPool(_rewardToken, _pid);\n        UserInfo storage user = userInfos[_rewardToken][_pid][_user];\n        return user.pendingWithdrawals;\n    }\n\n    /**\n     * @notice Returns the array of withdrawal requests that have not been executed yet\n     * @param _rewardToken The Reward Token Address\n     * @param _pid The Pool Index\n     * @param _user The User Address\n     * @return An array of withdrawal requests\n     */\n    function getWithdrawalRequests(\n        address _rewardToken,\n        uint256 _pid,\n        address _user\n    ) external view returns (WithdrawalRequest[] memory) {\n        _ensureValidPool(_rewardToken, _pid);\n        return withdrawalRequests[_rewardToken][_pid][_user];\n    }\n\n    /**\n     * @notice View function to see pending XVSs on frontend\n     * @param _rewardToken Reward token address\n     * @param _pid Pool index\n     * @param _user User address\n     * @return Reward the user is eligible for in this pool, in terms of _rewardToken\n     */\n    function pendingReward(address _rewardToken, uint256 _pid, address _user) external view returns (uint256) {\n        _ensureValidPool(_rewardToken, _pid);\n        PoolInfo storage pool = poolInfos[_rewardToken][_pid];\n        UserInfo storage user = userInfos[_rewardToken][_pid][_user];\n        uint256 accRewardPerShare = pool.accRewardPerShare;\n        uint256 supply = pool.token.balanceOf(address(this)).sub(totalPendingWithdrawals[_rewardToken][_pid]);\n        uint256 curBlockNumberOrSecond = getBlockNumberOrTimestamp();\n        uint256 rewardTokenPerBlockOrSecond = rewardTokenAmountsPerBlockOrSecond[_rewardToken];\n        if (curBlockNumberOrSecond > pool.lastRewardBlockOrSecond && supply != 0) {\n            uint256 multiplier = curBlockNumberOrSecond.sub(pool.lastRewardBlockOrSecond);\n            uint256 reward = multiplier.mul(rewardTokenPerBlockOrSecond).mul(pool.allocPoint).div(\n                totalAllocPoints[_rewardToken]\n            );\n            accRewardPerShare = accRewardPerShare.add(reward.mul(1e12).div(supply));\n        }\n        WithdrawalRequest[] storage requests = withdrawalRequests[_rewardToken][_pid][_user];\n        (, uint256 afterUpgradeWithdrawalAmount) = getRequestedWithdrawalAmount(requests);\n        return user.amount.sub(afterUpgradeWithdrawalAmount).mul(accRewardPerShare).div(1e12).sub(user.rewardDebt);\n    }\n\n    // Update reward variables for all pools. Be careful of gas spending!\n    function massUpdatePools(address _rewardToken) internal {\n        uint256 length = poolInfos[_rewardToken].length;\n        for (uint256 pid = 0; pid < length; ++pid) {\n            _updatePool(_rewardToken, pid);\n        }\n    }\n\n    /**\n     * @notice Update reward variables of the given pool to be up-to-date\n     * @param _rewardToken Reward token address\n     * @param _pid Pool index\n     */\n    function updatePool(address _rewardToken, uint256 _pid) external isActive {\n        _ensureValidPool(_rewardToken, _pid);\n        _updatePool(_rewardToken, _pid);\n    }\n\n    // Update reward variables of the given pool to be up-to-date.\n    function _updatePool(address _rewardToken, uint256 _pid) internal {\n        PoolInfo storage pool = poolInfos[_rewardToken][_pid];\n        if (getBlockNumberOrTimestamp() <= pool.lastRewardBlockOrSecond) {\n            return;\n        }\n        uint256 supply = pool.token.balanceOf(address(this));\n        supply = supply.sub(totalPendingWithdrawals[_rewardToken][_pid]);\n        if (supply == 0) {\n            pool.lastRewardBlockOrSecond = getBlockNumberOrTimestamp();\n            return;\n        }\n        uint256 curBlockNumberOrSecond = getBlockNumberOrTimestamp();\n        uint256 multiplier = curBlockNumberOrSecond.sub(pool.lastRewardBlockOrSecond);\n        uint256 reward = multiplier.mul(rewardTokenAmountsPerBlockOrSecond[_rewardToken]).mul(pool.allocPoint).div(\n            totalAllocPoints[_rewardToken]\n        );\n        pool.accRewardPerShare = pool.accRewardPerShare.add(reward.mul(1e12).div(supply));\n        pool.lastRewardBlockOrSecond = getBlockNumberOrTimestamp();\n    }\n\n    function _ensureValidPool(address rewardToken, uint256 pid) internal view {\n        require(pid < poolInfos[rewardToken].length, \"vault: pool exists?\");\n    }\n\n    /**\n     * @notice Get user info with reward token address and pid\n     * @param _rewardToken Reward token address\n     * @param _pid Pool index\n     * @param _user User address\n     * @return amount Deposited amount\n     * @return rewardDebt Reward debt (technical value used to track past payouts)\n     * @return pendingWithdrawals Requested but not yet executed withdrawals\n     */\n    function getUserInfo(\n        address _rewardToken,\n        uint256 _pid,\n        address _user\n    ) external view returns (uint256 amount, uint256 rewardDebt, uint256 pendingWithdrawals) {\n        _ensureValidPool(_rewardToken, _pid);\n        UserInfo storage user = userInfos[_rewardToken][_pid][_user];\n        amount = user.amount;\n        rewardDebt = user.rewardDebt;\n        pendingWithdrawals = user.pendingWithdrawals;\n    }\n\n    /**\n     * @notice Gets the total pending withdrawal amount of a user before upgrade\n     * @param _rewardToken The Reward Token Address\n     * @param _pid The Pool Index\n     * @param _user The address of the user\n     * @return beforeUpgradeWithdrawalAmount Total pending withdrawal amount in requests made before the vault upgrade\n     */\n    function pendingWithdrawalsBeforeUpgrade(\n        address _rewardToken,\n        uint256 _pid,\n        address _user\n    ) public view returns (uint256 beforeUpgradeWithdrawalAmount) {\n        WithdrawalRequest[] storage requests = withdrawalRequests[_rewardToken][_pid][_user];\n        (beforeUpgradeWithdrawalAmount, ) = getRequestedWithdrawalAmount(requests);\n        return beforeUpgradeWithdrawalAmount;\n    }\n\n    /**\n     * @notice Get the XVS stake balance of an account (excluding the pending withdrawals)\n     * @param account The address of the account to check\n     * @return The balance that user staked\n     */\n    function getStakeAmount(address account) internal view returns (uint96) {\n        require(xvsAddress != address(0), \"XVSVault::getStakeAmount: xvs address is not set\");\n\n        PoolInfo[] storage poolInfo = poolInfos[xvsAddress];\n\n        uint256 length = poolInfo.length;\n        for (uint256 pid = 0; pid < length; ++pid) {\n            if (address(poolInfo[pid].token) == address(xvsAddress)) {\n                UserInfo storage user = userInfos[xvsAddress][pid][account];\n                return safe96(user.amount.sub(user.pendingWithdrawals), \"XVSVault::getStakeAmount: votes overflow\");\n            }\n        }\n        return uint96(0);\n    }\n\n    /**\n     * @notice Delegate votes from `msg.sender` to `delegatee`\n     * @param delegatee The address to delegate votes to\n     */\n    function delegate(address delegatee) external isActive {\n        return _delegate(msg.sender, delegatee);\n    }\n\n    /**\n     * @notice Delegates votes from signatory to `delegatee`\n     * @param delegatee The address to delegate votes to\n     * @param nonce The contract state required to match the signature\n     * @param expiry The time at which to expire the signature\n     * @param v The recovery byte of the signature\n     * @param r Half of the ECDSA signature pair\n     * @param s Half of the ECDSA signature pair\n     */\n    function delegateBySig(\n        address delegatee,\n        uint nonce,\n        uint expiry,\n        uint8 v,\n        bytes32 r,\n        bytes32 s\n    ) external isActive {\n        bytes32 domainSeparator = keccak256(\n            abi.encode(DOMAIN_TYPEHASH, keccak256(bytes(\"XVSVault\")), getChainId(), address(this))\n        );\n        bytes32 structHash = keccak256(abi.encode(DELEGATION_TYPEHASH, delegatee, nonce, expiry));\n        bytes32 digest = keccak256(abi.encodePacked(\"\\x19\\x01\", domainSeparator, structHash));\n        address signatory = ECDSA.recover(digest, v, r, s);\n        require(nonce == nonces[signatory]++, \"XVSVault::delegateBySig: invalid nonce\");\n        require(block.timestamp <= expiry, \"XVSVault::delegateBySig: signature expired\");\n        return _delegate(signatory, delegatee);\n    }\n\n    /**\n     * @notice Gets the current votes balance for `account`\n     * @param account The address to get votes balance\n     * @return The number of current votes for `account`\n     */\n    function getCurrentVotes(address account) external view returns (uint96) {\n        uint32 nCheckpoints = numCheckpoints[account];\n        return nCheckpoints > 0 ? checkpoints[account][nCheckpoints - 1].votes : 0;\n    }\n\n    function _delegate(address delegator, address delegatee) internal {\n        address currentDelegate = delegates[delegator];\n        uint96 delegatorBalance = getStakeAmount(delegator);\n        delegates[delegator] = delegatee;\n\n        emit DelegateChangedV2(delegator, currentDelegate, delegatee);\n\n        _moveDelegates(currentDelegate, delegatee, delegatorBalance);\n    }\n\n    function _moveDelegates(address srcRep, address dstRep, uint96 amount) internal {\n        if (srcRep != dstRep && amount > 0) {\n            if (srcRep != address(0)) {\n                uint32 srcRepNum = numCheckpoints[srcRep];\n                uint96 srcRepOld = srcRepNum > 0 ? checkpoints[srcRep][srcRepNum - 1].votes : 0;\n                uint96 srcRepNew = sub96(srcRepOld, amount, \"XVSVault::_moveVotes: vote amount underflows\");\n                _writeCheckpoint(srcRep, srcRepNum, srcRepOld, srcRepNew);\n            }\n\n            if (dstRep != address(0)) {\n                uint32 dstRepNum = numCheckpoints[dstRep];\n                uint96 dstRepOld = dstRepNum > 0 ? checkpoints[dstRep][dstRepNum - 1].votes : 0;\n                uint96 dstRepNew = add96(dstRepOld, amount, \"XVSVault::_moveVotes: vote amount overflows\");\n                _writeCheckpoint(dstRep, dstRepNum, dstRepOld, dstRepNew);\n            }\n        }\n    }\n\n    function _writeCheckpoint(address delegatee, uint32 nCheckpoints, uint96 oldVotes, uint96 newVotes) internal {\n        uint32 blockNumberOrSecond = safe32(\n            getBlockNumberOrTimestamp(),\n            \"XVSVault::_writeCheckpoint: block number or second exceeds 32 bits\"\n        );\n\n        if (nCheckpoints > 0 && checkpoints[delegatee][nCheckpoints - 1].fromBlockOrSecond == blockNumberOrSecond) {\n            checkpoints[delegatee][nCheckpoints - 1].votes = newVotes;\n        } else {\n            checkpoints[delegatee][nCheckpoints] = Checkpoint(blockNumberOrSecond, newVotes);\n            numCheckpoints[delegatee] = nCheckpoints + 1;\n        }\n\n        emit DelegateVotesChangedV2(delegatee, oldVotes, newVotes);\n    }\n\n    function safe32(uint n, string memory errorMessage) internal pure returns (uint32) {\n        require(n < 2 ** 32, errorMessage);\n        return uint32(n);\n    }\n\n    function safe96(uint n, string memory errorMessage) internal pure returns (uint96) {\n        require(n < 2 ** 96, errorMessage);\n        return uint96(n);\n    }\n\n    function add96(uint96 a, uint96 b, string memory errorMessage) internal pure returns (uint96) {\n        uint96 c = a + b;\n        require(c >= a, errorMessage);\n        return c;\n    }\n\n    function sub96(uint96 a, uint96 b, string memory errorMessage) internal pure returns (uint96) {\n        require(b <= a, errorMessage);\n        return a - b;\n    }\n\n    function getChainId() internal pure returns (uint) {\n        uint256 chainId;\n        assembly {\n            chainId := chainid()\n        }\n        return chainId;\n    }\n\n    /**\n     * @notice Determine the xvs stake balance for an account\n     * @param account The address of the account to check\n     * @param blockNumberOrSecond The block number or second to get the vote balance at\n     * @return The balance that user staked\n     */\n    function getPriorVotes(address account, uint256 blockNumberOrSecond) external view returns (uint96) {\n        require(blockNumberOrSecond < getBlockNumberOrTimestamp(), \"XVSVault::getPriorVotes: not yet determined\");\n\n        uint32 nCheckpoints = numCheckpoints[account];\n        if (nCheckpoints == 0) {\n            return 0;\n        }\n\n        // First check most recent balance\n        if (checkpoints[account][nCheckpoints - 1].fromBlockOrSecond <= blockNumberOrSecond) {\n            return checkpoints[account][nCheckpoints - 1].votes;\n        }\n\n        // Next check implicit zero balance\n        if (checkpoints[account][0].fromBlockOrSecond > blockNumberOrSecond) {\n            return 0;\n        }\n\n        uint32 lower = 0;\n        uint32 upper = nCheckpoints - 1;\n        while (upper > lower) {\n            uint32 center = upper - (upper - lower) / 2; // ceil, avoiding overflow\n            Checkpoint memory cp = checkpoints[account][center];\n            if (cp.fromBlockOrSecond == blockNumberOrSecond) {\n                return cp.votes;\n            } else if (cp.fromBlockOrSecond < blockNumberOrSecond) {\n                lower = center;\n            } else {\n                upper = center - 1;\n            }\n        }\n        return checkpoints[account][lower].votes;\n    }\n\n    /*** Admin Functions ***/\n\n    function _become(XVSVaultProxy xvsVaultProxy) external {\n        require(msg.sender == xvsVaultProxy.admin(), \"only proxy admin can change brains\");\n        require(xvsVaultProxy._acceptImplementation() == 0, \"change not authorized\");\n    }\n\n    function setXvsStore(address _xvs, address _xvsStore) external onlyAdmin {\n        _ensureNonzeroAddress(_xvs);\n        _ensureNonzeroAddress(_xvsStore);\n\n        address oldXvsContract = xvsAddress;\n        address oldStore = xvsStore;\n        require(oldXvsContract == address(0), \"already initialized\");\n\n        xvsAddress = _xvs;\n        xvsStore = _xvsStore;\n\n        _notEntered = true;\n\n        emit StoreUpdated(oldXvsContract, oldStore, _xvs, _xvsStore);\n    }\n\n    /**\n     * @notice Sets the address of the prime token contract\n     * @param _primeToken address of the prime token contract\n     * @param _primeRewardToken address of reward token\n     * @param _primePoolId pool id for reward\n     */\n    function setPrimeToken(IPrimeV5 _primeToken, address _primeRewardToken, uint256 _primePoolId) external onlyAdmin {\n        require(address(_primeToken) != address(0), \"prime token cannot be zero address\");\n        require(_primeRewardToken != address(0), \"reward cannot be zero address\");\n\n        _ensureValidPool(_primeRewardToken, _primePoolId);\n\n        emit NewPrimeToken(primeToken, _primeToken, primeRewardToken, _primeRewardToken, primePoolId, _primePoolId);\n\n        primeToken = _primeToken;\n        primeRewardToken = _primeRewardToken;\n        primePoolId = _primePoolId;\n    }\n\n    /**\n     * @dev Initializes the contract to use either blocks or seconds\n     * @param timeBased_ A boolean indicating whether the contract is based on time or block\n     * If timeBased is true than blocksPerYear_ param is ignored as blocksOrSecondsPerYear is set to SECONDS_PER_YEAR\n     * @param blocksPerYear_ The number of blocks per year\n     */\n    function initializeTimeManager(bool timeBased_, uint256 blocksPerYear_) external onlyAdmin {\n        _initializeTimeManager(timeBased_, blocksPerYear_);\n    }\n\n    /**\n     * @notice Sets the block per year in Time Manager\n     * @param blocksPerYear_ The number of blocks per year\n     */\n    function setBlocksPerYear(uint256 blocksPerYear_) external {\n        _checkAccessAllowed(\"setBlocksPerYear(uint256)\");\n        _setBlocksPerYear(blocksPerYear_);\n    }\n\n    /**\n     * @notice Sets the address of the access control of this contract\n     * @dev Admin function to set the access control address\n     * @param newAccessControlAddress New address for the access control\n     */\n    function setAccessControl(address newAccessControlAddress) external onlyAdmin {\n        _setAccessControlManager(newAccessControlAddress);\n    }\n\n    /**\n     * @dev Reverts if the provided address is a zero address\n     * @param address_ Address to check\n     */\n    function _ensureNonzeroAddress(address address_) internal pure {\n        require(address_ != address(0), \"zero address not allowed\");\n    }\n\n    /**\n     * @dev Transfers the reward to the user, taking into account the rewards store\n     *   balance and the previous debt. If there are not enough rewards in the store,\n     *   transfers the available funds and records the debt amount in pendingRewardTransfers.\n     * @param rewardToken Reward token address\n     * @param userAddress User address\n     * @param amount Reward amount, in reward tokens\n     */\n    function _transferReward(address rewardToken, address userAddress, uint256 amount) internal {\n        address xvsStore_ = xvsStore;\n        uint256 storeBalance = IBEP20(rewardToken).balanceOf(xvsStore_);\n        uint256 debtDueToFailedTransfers = pendingRewardTransfers[rewardToken][userAddress];\n        uint256 fullAmount = amount.add(debtDueToFailedTransfers);\n\n        if (fullAmount <= storeBalance) {\n            if (debtDueToFailedTransfers != 0) {\n                pendingRewardTransfers[rewardToken][userAddress] = 0;\n                emit VaultDebtUpdated(rewardToken, userAddress, debtDueToFailedTransfers, 0);\n            }\n            XVSStore(xvsStore_).safeRewardTransfer(rewardToken, userAddress, fullAmount);\n            return;\n        }\n        // Overflow isn't possible due to the check above\n        uint256 newOwedAmount = fullAmount - storeBalance;\n        pendingRewardTransfers[rewardToken][userAddress] = newOwedAmount;\n        emit VaultDebtUpdated(rewardToken, userAddress, debtDueToFailedTransfers, newOwedAmount);\n        XVSStore(xvsStore_).safeRewardTransfer(rewardToken, userAddress, storeBalance);\n    }\n\n    /**\n     * @dev Computes cumulative reward for all user's shares\n     * @param user UserInfo storage struct\n     * @param pool PoolInfo storage struct\n     */\n    function _cumulativeReward(UserInfo storage user, PoolInfo storage pool) internal view returns (uint256) {\n        return user.amount.sub(user.pendingWithdrawals).mul(pool.accRewardPerShare).div(1e12);\n    }\n\n    /**\n     * @dev Computes the reward for all user's shares\n     * @param user UserInfo storage struct\n     * @param pool PoolInfo storage struct\n     */\n    function _computeReward(UserInfo storage user, PoolInfo storage pool) internal view returns (uint256) {\n        return _cumulativeReward(user, pool).sub(user.rewardDebt);\n    }\n}\n"
+    },
+    "contracts/XVSVault/XVSVaultErrorReporter.sol": {
+      "content": "pragma solidity ^0.5.16;\n\ncontract XVSVaultErrorReporter {\n    enum Error {\n        NO_ERROR,\n        UNAUTHORIZED\n    }\n\n    enum FailureInfo {\n        ACCEPT_ADMIN_PENDING_ADMIN_CHECK,\n        ACCEPT_PENDING_IMPLEMENTATION_ADDRESS_CHECK,\n        SET_PENDING_ADMIN_OWNER_CHECK,\n        SET_PENDING_IMPLEMENTATION_OWNER_CHECK\n    }\n\n    /**\n     * @dev `error` corresponds to enum Error; `info` corresponds to enum FailureInfo, and `detail` is an arbitrary\n     * contract-specific code that enables us to report opaque error codes from upgradeable contracts.\n     **/\n    event Failure(uint error, uint info, uint detail);\n\n    /**\n     * @dev use this when reporting a known error from the money market or a non-upgradeable collaborator\n     */\n    function fail(Error err, FailureInfo info) internal returns (uint) {\n        emit Failure(uint(err), uint(info), 0);\n\n        return uint(err);\n    }\n\n    /**\n     * @dev use this when reporting an opaque error from an upgradeable collaborator contract\n     */\n    function failOpaque(Error err, FailureInfo info, uint opaqueError) internal returns (uint) {\n        emit Failure(uint(err), uint(info), opaqueError);\n\n        return uint(err);\n    }\n}\n"
+    },
+    "contracts/XVSVault/XVSVaultProxy.sol": {
+      "content": "pragma solidity ^0.5.16;\n\nimport \"./XVSVaultStorage.sol\";\nimport \"./XVSVaultErrorReporter.sol\";\n\n/**\n * @title XVS Vault Proxy\n * @author Venus\n * @notice XVS Vault Proxy contract\n */\ncontract XVSVaultProxy is XVSVaultAdminStorage, XVSVaultErrorReporter {\n    /**\n     * @notice Emitted when pendingXVSVaultImplementation is changed\n     */\n    event NewPendingImplementation(address oldPendingImplementation, address newPendingImplementation);\n\n    /**\n     * @notice Emitted when pendingXVSVaultImplementation is accepted, which means XVS Vault implementation is updated\n     */\n    event NewImplementation(address oldImplementation, address newImplementation);\n\n    /**\n     * @notice Emitted when pendingAdmin is changed\n     */\n    event NewPendingAdmin(address oldPendingAdmin, address newPendingAdmin);\n\n    /**\n     * @notice Emitted when pendingAdmin is accepted, which means admin is updated\n     */\n    event NewAdmin(address oldAdmin, address newAdmin);\n\n    constructor() public {\n        // Set admin to caller\n        admin = msg.sender;\n    }\n\n    /*** Admin Functions ***/\n    function _setPendingImplementation(address newPendingImplementation) public returns (uint) {\n        if (msg.sender != admin) {\n            return fail(Error.UNAUTHORIZED, FailureInfo.SET_PENDING_IMPLEMENTATION_OWNER_CHECK);\n        }\n\n        address oldPendingImplementation = pendingXVSVaultImplementation;\n\n        pendingXVSVaultImplementation = newPendingImplementation;\n\n        emit NewPendingImplementation(oldPendingImplementation, pendingXVSVaultImplementation);\n\n        return uint(Error.NO_ERROR);\n    }\n\n    /**\n     * @notice Accepts new implementation of XVS Vault. msg.sender must be pendingImplementation\n     * @dev Admin function for new implementation to accept it's role as implementation\n     * @return uint 0=success, otherwise a failure (see ErrorReporter.sol for details)\n     */\n    function _acceptImplementation() public returns (uint) {\n        // Check caller is pendingImplementation\n        if (msg.sender != pendingXVSVaultImplementation) {\n            return fail(Error.UNAUTHORIZED, FailureInfo.ACCEPT_PENDING_IMPLEMENTATION_ADDRESS_CHECK);\n        }\n\n        // Save current values for inclusion in log\n        address oldImplementation = implementation;\n        address oldPendingImplementation = pendingXVSVaultImplementation;\n\n        implementation = pendingXVSVaultImplementation;\n\n        pendingXVSVaultImplementation = address(0);\n\n        emit NewImplementation(oldImplementation, implementation);\n        emit NewPendingImplementation(oldPendingImplementation, pendingXVSVaultImplementation);\n\n        return uint(Error.NO_ERROR);\n    }\n\n    /**\n     * @notice Begins transfer of admin rights. The newPendingAdmin must call `_acceptAdmin` to finalize the transfer.\n     * @dev Admin function to begin change of admin. The newPendingAdmin must call `_acceptAdmin` to finalize the transfer.\n     * @param newPendingAdmin New pending admin.\n     * @return uint 0=success, otherwise a failure (see ErrorReporter.sol for details)\n     */\n    function _setPendingAdmin(address newPendingAdmin) public returns (uint) {\n        // Check caller = admin\n        if (msg.sender != admin) {\n            return fail(Error.UNAUTHORIZED, FailureInfo.SET_PENDING_ADMIN_OWNER_CHECK);\n        }\n\n        // Save current value, if any, for inclusion in log\n        address oldPendingAdmin = pendingAdmin;\n\n        // Store pendingAdmin with value newPendingAdmin\n        pendingAdmin = newPendingAdmin;\n\n        // Emit NewPendingAdmin(oldPendingAdmin, newPendingAdmin)\n        emit NewPendingAdmin(oldPendingAdmin, newPendingAdmin);\n\n        return uint(Error.NO_ERROR);\n    }\n\n    /**\n     * @notice Accepts transfer of admin rights. msg.sender must be pendingAdmin\n     * @dev Admin function for pending admin to accept role and update admin\n     * @return uint 0=success, otherwise a failure (see ErrorReporter.sol for details)\n     */\n    function _acceptAdmin() public returns (uint) {\n        // Check caller is pendingAdmin\n        if (msg.sender != pendingAdmin) {\n            return fail(Error.UNAUTHORIZED, FailureInfo.ACCEPT_ADMIN_PENDING_ADMIN_CHECK);\n        }\n\n        // Save current values for inclusion in log\n        address oldAdmin = admin;\n        address oldPendingAdmin = pendingAdmin;\n\n        // Store admin with value pendingAdmin\n        admin = pendingAdmin;\n\n        // Clear the pending value\n        pendingAdmin = address(0);\n\n        emit NewAdmin(oldAdmin, admin);\n        emit NewPendingAdmin(oldPendingAdmin, pendingAdmin);\n\n        return uint(Error.NO_ERROR);\n    }\n\n    /**\n     * @dev Delegates execution to an implementation contract.\n     * It returns to the external caller whatever the implementation returns\n     * or forwards reverts.\n     */\n    function() external payable {\n        // delegate all other functions to current implementation\n        (bool success, ) = implementation.delegatecall(msg.data);\n\n        assembly {\n            let free_mem_ptr := mload(0x40)\n            returndatacopy(free_mem_ptr, 0, returndatasize)\n\n            switch success\n            case 0 {\n                revert(free_mem_ptr, returndatasize)\n            }\n            default {\n                return(free_mem_ptr, returndatasize)\n            }\n        }\n    }\n}\n"
+    },
+    "contracts/XVSVault/XVSVaultStorage.sol": {
+      "content": "// SPDX-License-Identifier: BSD-3-Clause\npragma solidity ^0.5.16;\n\nimport { SafeMath } from \"../Utils/SafeMath.sol\";\nimport { IBEP20 } from \"../Utils/IBEP20.sol\";\nimport { IPrimeV5 } from \"../Tokens/Prime/IPrimeV5.sol\";\n\ncontract XVSVaultAdminStorage {\n    /**\n     * @notice Administrator for this contract\n     */\n    address public admin;\n\n    /**\n     * @notice Pending administrator for this contract\n     */\n    address public pendingAdmin;\n\n    /**\n     * @notice Active brains of XVS Vault\n     */\n    address public implementation;\n\n    /**\n     * @notice Pending brains of XVS Vault\n     */\n    address public pendingXVSVaultImplementation;\n}\n\ncontract XVSVaultStorageV1 is XVSVaultAdminStorage {\n    /// @notice Guard variable for re-entrancy checks\n    bool internal _notEntered;\n\n    /// @notice The reward token store\n    address public xvsStore;\n\n    /// @notice The xvs token address\n    address public xvsAddress;\n\n    // Reward tokens created per block or second indentified by reward token address.\n    mapping(address => uint256) public rewardTokenAmountsPerBlockOrSecond;\n\n    /// @notice Info of each user.\n    struct UserInfo {\n        uint256 amount;\n        uint256 rewardDebt;\n        uint256 pendingWithdrawals;\n    }\n\n    // Info of each pool.\n    struct PoolInfo {\n        IBEP20 token; // Address of token contract to stake.\n        uint256 allocPoint; // How many allocation points assigned to this pool.\n        uint256 lastRewardBlockOrSecond; // Last block number or second that reward tokens distribution occurs.\n        uint256 accRewardPerShare; // Accumulated per share, times 1e12. See below.\n        uint256 lockPeriod; // Min time between withdrawal request and its execution.\n    }\n\n    // Infomation about a withdrawal request\n    struct WithdrawalRequest {\n        uint256 amount;\n        uint128 lockedUntil;\n        uint128 afterUpgrade;\n    }\n\n    // Info of each user that stakes tokens.\n    mapping(address => mapping(uint256 => mapping(address => UserInfo))) internal userInfos;\n\n    // Info of each pool.\n    mapping(address => PoolInfo[]) public poolInfos;\n\n    // Total allocation points. Must be the sum of all allocation points in all pools.\n    mapping(address => uint256) public totalAllocPoints;\n\n    // Info of requested but not yet executed withdrawals\n    mapping(address => mapping(uint256 => mapping(address => WithdrawalRequest[]))) internal withdrawalRequests;\n\n    /// @notice DEPRECATED A record of each accounts delegate (before the voting power fix)\n    mapping(address => address) private __oldDelegatesSlot;\n\n    /// @notice A checkpoint for marking number of votes from a given block or second\n    struct Checkpoint {\n        uint32 fromBlockOrSecond;\n        uint96 votes;\n    }\n\n    /// @notice DEPRECATED A record of votes checkpoints for each account, by index (before the voting power fix)\n    mapping(address => mapping(uint32 => Checkpoint)) private __oldCheckpointsSlot;\n\n    /// @notice DEPRECATED The number of checkpoints for each account (before the voting power fix)\n    mapping(address => uint32) private __oldNumCheckpointsSlot;\n\n    /// @notice A record of states for signing / validating signatures\n    mapping(address => uint) public nonces;\n\n    /// @notice The EIP-712 typehash for the contract's domain\n    bytes32 public constant DOMAIN_TYPEHASH =\n        keccak256(\"EIP712Domain(string name,uint256 chainId,address verifyingContract)\");\n\n    /// @notice The EIP-712 typehash for the delegation struct used by the contract\n    bytes32 public constant DELEGATION_TYPEHASH =\n        keccak256(\"Delegation(address delegatee,uint256 nonce,uint256 expiry)\");\n}\n\ncontract XVSVaultStorage is XVSVaultStorageV1 {\n    /// @notice A record of each accounts delegate\n    mapping(address => address) public delegates;\n\n    /// @notice A record of votes checkpoints for each account, by index\n    mapping(address => mapping(uint32 => Checkpoint)) public checkpoints;\n\n    /// @notice The number of checkpoints for each account\n    mapping(address => uint32) public numCheckpoints;\n\n    /// @notice Tracks pending withdrawals for all users for a particular reward token and pool id\n    mapping(address => mapping(uint256 => uint256)) public totalPendingWithdrawals;\n\n    /// @notice pause indicator for Vault\n    bool public vaultPaused;\n\n    /// @notice if the token is added to any of the pools\n    mapping(address => bool) public isStakedToken;\n\n    /// @notice Amount we owe to users because of failed transfer attempts\n    mapping(address => mapping(address => uint256)) public pendingRewardTransfers;\n\n    /// @notice Prime token contract address\n    IPrimeV5 public primeToken;\n\n    /// @notice Reward token for which prime token is issued for staking\n    address public primeRewardToken;\n\n    /// @notice Pool ID for which prime token is issued for staking\n    uint256 public primePoolId;\n\n    /**\n     * @dev This empty reserved space is put in place to allow future versions to add new\n     * variables without shifting down storage in the inheritance chain.\n     * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps\n     */\n    uint256[46] private __gap;\n}\n"
+    }
+  },
+  "settings": {
+    "optimizer": {
+      "enabled": true,
+      "runs": 200
+    },
+    "outputSelection": {
+      "*": {
+        "*": [
+          "storageLayout",
+          "abi",
+          "evm.bytecode",
+          "evm.deployedBytecode",
+          "evm.methodIdentifiers",
+          "metadata",
+          "devdoc",
+          "userdoc",
+          "evm.gasEstimates"
+        ],
+        "": ["ast"]
+      }
+    },
+    "metadata": {
+      "useLiteralContent": true
+    }
+  }
+}