{{ "language": "Solidity", "sources": { "contracts/DEUS/DEUS.sol": { "content": "// Be name Khoda\n// Bime Abolfazl\n\n// SPDX-License-Identifier: GPL-2.0-or-later\npragma solidity ^0.8.0;\n\n// =================================================================================================================\n// _|_|_| _|_|_|_| _| _| _|_|_| _|_|_|_| _| |\n// _| _| _| _| _| _| _| _|_|_| _|_|_| _|_|_| _|_|_| _|_| |\n// _| _| _|_|_| _| _| _|_| _|_|_| _| _| _| _| _| _| _| _| _|_|_|_| |\n// _| _| _| _| _| _| _| _| _| _| _| _| _| _| _| _| |\n// _|_|_| _|_|_|_| _|_| _|_|_| _| _| _| _| _|_|_| _| _| _|_|_| _|_|_| |\n// =================================================================================================================\n// ========================= DEUS (DEUS) =========================\n// ===============================================================\n// DEUS Finance: https://github.com/DeusFinance\n\n// Primary Author(s)\n// Travis Moore: https://github.com/FortisFortuna\n// Jason Huan: https://github.com/jasonhuan\n// Sam Kazemian: https://github.com/samkazemian\n// Vahid Gh: https://github.com/vahid-dev\n// SAYaghoubnejad: https://github.com/SAYaghoubnejad\n\n// Reviewer(s) / Contributor(s)\n// Sam Sun: https://github.com/samczsun\n\nimport \"../Common/Context.sol\";\nimport \"../ERC20/ERC20Custom.sol\";\nimport \"../ERC20/IERC20.sol\";\nimport \"../DEI/DEI.sol\";\nimport \"../Governance/AccessControl.sol\";\n\ncontract DEUSToken is ERC20Custom, AccessControl {\n\n /* ========== STATE VARIABLES ========== */\n\n string public symbol;\n string public name;\n uint8 public constant decimals = 18;\n\n uint256 public constant genesis_supply = 166670e18; // 166670 is printed upon genesis\n\n DEIStablecoin private DEI;\n\n bool public trackingVotes = true; // Tracking votes (only change if need to disable votes)\n\n // A checkpoint for marking number of votes from a given block\n struct Checkpoint {\n uint32 fromBlock;\n uint96 votes;\n }\n\n // A record of votes checkpoints for each account, by index\n mapping(address => mapping(uint32 => Checkpoint)) public checkpoints;\n\n // The number of checkpoints for each account\n mapping(address => uint32) public numCheckpoints;\n\n bytes32 public constant TRUSTY_ROLE = keccak256(\"TRUSTY_ROLE\");\n bytes32 public constant MINTER_ROLE = keccak256(\"MINTER_ROLE\");\n\n /* ========== MODIFIERS ========== */\n\n modifier onlyPoolsOrMinters() {\n require(\n DEI.dei_pools(msg.sender) == true || hasRole(MINTER_ROLE, msg.sender),\n \"DEUS: Only dei pools or minters are allowed to do this operation\"\n );\n _;\n }\n\n modifier onlyPools() {\n require(\n DEI.dei_pools(msg.sender) == true,\n \"DEUS: Only dei pools are allowed to do this operation\"\n );\n _;\n }\n\n modifier onlyByTrusty() {\n require(hasRole(TRUSTY_ROLE, msg.sender), \"DEUS: You are not trusty\");\n _;\n }\n\n /* ========== CONSTRUCTOR ========== */\n\n constructor(\n string memory _name,\n string memory _symbol,\n address _creator_address,\n address _trusty_address\n ) {\n require(_creator_address != address(0), \"DEUS::constructor: zero address detected\"); \n name = _name;\n symbol = _symbol;\n _setupRole(DEFAULT_ADMIN_ROLE, _trusty_address);\n _setupRole(TRUSTY_ROLE, _trusty_address);\n _mint(_creator_address, genesis_supply);\n\n // Do a checkpoint for the owner\n _writeCheckpoint(_creator_address, 0, 0, uint96(genesis_supply));\n }\n\n /* ========== RESTRICTED FUNCTIONS ========== */\n\n function setDEIAddress(address dei_contract_address)\n external\n onlyByTrusty\n {\n require(dei_contract_address != address(0), \"DEUS::setDEIAddress: Zero address detected\");\n\n DEI = DEIStablecoin(dei_contract_address);\n\n emit DEIAddressSet(dei_contract_address);\n }\n\n function mint(address to, uint256 amount) public onlyPoolsOrMinters {\n _mint(to, amount);\n }\n\n // This function is what other dei pools will call to mint new DEUS (similar to the DEI mint) and staking contracts can call this function too.\n function pool_mint(address m_address, uint256 m_amount) external onlyPoolsOrMinters {\n if (trackingVotes) {\n uint32 srcRepNum = numCheckpoints[address(this)];\n uint96 srcRepOld = srcRepNum > 0\n ? checkpoints[address(this)][srcRepNum - 1].votes\n : 0;\n uint96 srcRepNew = add96(\n srcRepOld,\n uint96(m_amount),\n \"DEUS::pool_mint: new votes overflows\"\n );\n _writeCheckpoint(address(this), srcRepNum, srcRepOld, srcRepNew); // mint new votes\n trackVotes(address(this), m_address, uint96(m_amount));\n }\n\n super._mint(m_address, m_amount);\n emit DEUSMinted(address(this), m_address, m_amount);\n }\n\n // This function is what other dei pools will call to burn DEUS\n function pool_burn_from(address b_address, uint256 b_amount)\n external\n onlyPools\n {\n if (trackingVotes) {\n trackVotes(b_address, address(this), uint96(b_amount));\n uint32 srcRepNum = numCheckpoints[address(this)];\n uint96 srcRepOld = srcRepNum > 0\n ? checkpoints[address(this)][srcRepNum - 1].votes\n : 0;\n uint96 srcRepNew = sub96(\n srcRepOld,\n uint96(b_amount),\n \"DEUS::pool_burn_from: new votes underflows\"\n );\n _writeCheckpoint(address(this), srcRepNum, srcRepOld, srcRepNew); // burn votes\n }\n\n super._burnFrom(b_address, b_amount);\n emit DEUSBurned(b_address, address(this), b_amount);\n }\n\n function toggleVotes() external onlyByTrusty {\n trackingVotes = !trackingVotes;\n }\n\n /* ========== OVERRIDDEN PUBLIC FUNCTIONS ========== */\n\n function transfer(address recipient, uint256 amount)\n public\n virtual\n override\n returns (bool)\n {\n if (trackingVotes) {\n // Transfer votes\n trackVotes(_msgSender(), recipient, uint96(amount));\n }\n\n _transfer(_msgSender(), recipient, amount);\n return true;\n }\n\n function transferFrom(\n address sender,\n address recipient,\n uint256 amount\n ) public virtual override returns (bool) {\n if (trackingVotes) {\n // Transfer votes\n trackVotes(sender, recipient, uint96(amount));\n }\n\n _transfer(sender, recipient, amount);\n _approve(\n sender,\n _msgSender(),\n _allowances[sender][_msgSender()] - amount\n );\n\n return true;\n }\n\n /* ========== PUBLIC FUNCTIONS ========== */\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 /**\n * @notice Determine the prior number of votes for an account as of a block number\n * @dev Block number must be a finalized block or else this function will revert to prevent misinformation.\n * @param account The address of the account to check\n * @param blockNumber The block number to get the vote balance at\n * @return The number of votes the account had as of the given block\n */\n function getPriorVotes(address account, uint256 blockNumber)\n public\n view\n returns (uint96)\n {\n require(\n blockNumber < block.number,\n \"DEUS::getPriorVotes: not yet determined\"\n );\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].fromBlock <= blockNumber) {\n return checkpoints[account][nCheckpoints - 1].votes;\n }\n\n // Next check implicit zero balance\n if (checkpoints[account][0].fromBlock > blockNumber) {\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.fromBlock == blockNumber) {\n return cp.votes;\n } else if (cp.fromBlock < blockNumber) {\n lower = center;\n } else {\n upper = center - 1;\n }\n }\n return checkpoints[account][lower].votes;\n }\n\n /* ========== INTERNAL FUNCTIONS ========== */\n\n // From compound's _moveDelegates\n // Keep track of votes. \"Delegates\" is a misnomer here\n function trackVotes(\n address srcRep,\n address dstRep,\n uint96 amount\n ) internal {\n if (srcRep != dstRep && amount > 0) {\n if (srcRep != address(0)) {\n uint32 srcRepNum = numCheckpoints[srcRep];\n uint96 srcRepOld = srcRepNum > 0\n ? checkpoints[srcRep][srcRepNum - 1].votes\n : 0;\n uint96 srcRepNew = sub96(\n srcRepOld,\n amount,\n \"DEUS::_moveVotes: vote amount underflows\"\n );\n _writeCheckpoint(srcRep, srcRepNum, srcRepOld, srcRepNew);\n }\n\n if (dstRep != address(0)) {\n uint32 dstRepNum = numCheckpoints[dstRep];\n uint96 dstRepOld = dstRepNum > 0\n ? checkpoints[dstRep][dstRepNum - 1].votes\n : 0;\n uint96 dstRepNew = add96(\n dstRepOld,\n amount,\n \"DEUS::_moveVotes: vote amount overflows\"\n );\n _writeCheckpoint(dstRep, dstRepNum, dstRepOld, dstRepNew);\n }\n }\n }\n\n function _writeCheckpoint(\n address voter,\n uint32 nCheckpoints,\n uint96 oldVotes,\n uint96 newVotes\n ) internal {\n uint32 blockNumber = safe32(\n block.number,\n \"DEUS::_writeCheckpoint: block number exceeds 32 bits\"\n );\n\n if (\n nCheckpoints > 0 &&\n checkpoints[voter][nCheckpoints - 1].fromBlock == blockNumber\n ) {\n checkpoints[voter][nCheckpoints - 1].votes = newVotes;\n } else {\n checkpoints[voter][nCheckpoints] = Checkpoint(\n blockNumber,\n newVotes\n );\n numCheckpoints[voter] = nCheckpoints + 1;\n }\n\n emit VoterVotesChanged(voter, oldVotes, newVotes);\n }\n\n function safe32(uint256 n, string memory errorMessage)\n internal\n pure\n returns (uint32)\n {\n require(n < 2**32, errorMessage);\n return uint32(n);\n }\n\n function safe96(uint256 n, string memory errorMessage)\n internal\n pure\n returns (uint96)\n {\n require(n < 2**96, errorMessage);\n return uint96(n);\n }\n\n function add96(\n uint96 a,\n uint96 b,\n string memory errorMessage\n ) internal pure returns (uint96) {\n uint96 c = a + b;\n require(c >= a, errorMessage);\n return c;\n }\n\n function sub96(\n uint96 a,\n uint96 b,\n string memory errorMessage\n ) internal pure returns (uint96) {\n require(b <= a, errorMessage);\n return a - b;\n }\n\n /* ========== EVENTS ========== */\n\n /// @notice An event thats emitted when a voters account's vote balance changes\n event VoterVotesChanged(\n address indexed voter,\n uint256 previousBalance,\n uint256 newBalance\n );\n // Track DEUS burned\n event DEUSBurned(address indexed from, address indexed to, uint256 amount);\n // Track DEUS minted\n event DEUSMinted(address indexed from, address indexed to, uint256 amount);\n event DEIAddressSet(address addr);\n}\n\n//Dar panah khoda" }, "contracts/Common/Context.sol": { "content": "// SPDX-License-Identifier: MIT\npragma solidity >=0.6.11;\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 */\nabstract contract Context {\n function _msgSender() internal view virtual returns (address payable) {\n return payable(msg.sender);\n }\n\n function _msgData() internal view virtual 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}" }, "contracts/ERC20/ERC20Custom.sol": { "content": "// SPDX-License-Identifier: MIT\npragma solidity >=0.6.11;\n\nimport \"../Common/Context.sol\";\nimport \"./IERC20.sol\";\nimport \"../Math/SafeMath.sol\";\nimport \"../Utils/Address.sol\";\n\n// Due to compiling issues, _name, _symbol, and _decimals were removed\n\n\n/**\n * @dev Implementation of the {IERC20} interface.\n *\n * This implementation is agnostic to the way tokens are created. This means\n * that a supply mechanism has to be added in a derived contract using {_mint}.\n * For a generic mechanism see {ERC20Mintable}.\n *\n * TIP: For a detailed writeup see our guide\n * https://forum.zeppelin.solutions/t/how-to-implement-erc20-supply-mechanisms/226[How\n * to implement supply mechanisms].\n *\n * We have followed general OpenZeppelin guidelines: functions revert instead\n * of returning `false` on failure. This behavior is nonetheless conventional\n * and does not conflict with the expectations of ERC20 applications.\n *\n * Additionally, an {Approval} event is emitted on calls to {transferFrom}.\n * This allows applications to reconstruct the allowance for all accounts just\n * by listening to said events. Other implementations of the EIP may not emit\n * these events, as it isn't required by the specification.\n *\n * Finally, the non-standard {decreaseAllowance} and {increaseAllowance}\n * functions have been added to mitigate the well-known issues around setting\n * allowances. See {IERC20-approve}.\n */\ncontract ERC20Custom is Context, IERC20 {\n using SafeMath for uint256;\n\n mapping (address => uint256) internal _balances;\n\n mapping (address => mapping (address => uint256)) internal _allowances;\n\n uint256 private _totalSupply;\n\n /**\n * @dev See {IERC20-totalSupply}.\n */\n function totalSupply() public view override returns (uint256) {\n return _totalSupply;\n }\n\n /**\n * @dev See {IERC20-balanceOf}.\n */\n function balanceOf(address account) public view override returns (uint256) {\n return _balances[account];\n }\n\n /**\n * @dev See {IERC20-transfer}.\n *\n * Requirements:\n *\n * - `recipient` cannot be the zero address.\n * - the caller must have a balance of at least `amount`.\n */\n function transfer(address recipient, uint256 amount) public virtual override returns (bool) {\n _transfer(_msgSender(), recipient, amount);\n return true;\n }\n\n /**\n * @dev See {IERC20-allowance}.\n */\n function allowance(address owner, address spender) public view virtual override returns (uint256) {\n return _allowances[owner][spender];\n }\n\n /**\n * @dev See {IERC20-approve}.\n *\n * Requirements:\n *\n * - `spender` cannot be the zero address.approve(address spender, uint256 amount)\n */\n function approve(address spender, uint256 amount) public virtual override returns (bool) {\n _approve(_msgSender(), spender, amount);\n return true;\n }\n\n /**\n * @dev See {IERC20-transferFrom}.\n *\n * Emits an {Approval} event indicating the updated allowance. This is not\n * required by the EIP. See the note at the beginning of {ERC20};\n *\n * Requirements:\n * - `sender` and `recipient` cannot be the zero address.\n * - `sender` must have a balance of at least `amount`.\n * - the caller must have allowance for `sender`'s tokens of at least\n * `amount`.\n */\n function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {\n _transfer(sender, recipient, amount);\n _approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, \"ERC20: transfer amount exceeds allowance\"));\n return true;\n }\n\n /**\n * @dev Atomically increases the allowance granted to `spender` by the caller.\n *\n * This is an alternative to {approve} that can be used as a mitigation for\n * problems described in {IERC20-approve}.\n *\n * Emits an {Approval} event indicating the updated allowance.\n *\n * Requirements:\n *\n * - `spender` cannot be the zero address.\n */\n function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {\n _approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));\n return true;\n }\n\n /**\n * @dev Atomically decreases the allowance granted to `spender` by the caller.\n *\n * This is an alternative to {approve} that can be used as a mitigation for\n * problems described in {IERC20-approve}.\n *\n * Emits an {Approval} event indicating the updated allowance.\n *\n * Requirements:\n *\n * - `spender` cannot be the zero address.\n * - `spender` must have allowance for the caller of at least\n * `subtractedValue`.\n */\n function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {\n _approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, \"ERC20: decreased allowance below zero\"));\n return true;\n }\n\n /**\n * @dev Moves tokens `amount` from `sender` to `recipient`.\n *\n * This is internal function is equivalent to {transfer}, and can be used to\n * e.g. implement automatic token fees, slashing mechanisms, etc.\n *\n * Emits a {Transfer} event.\n *\n * Requirements:\n *\n * - `sender` cannot be the zero address.\n * - `recipient` cannot be the zero address.\n * - `sender` must have a balance of at least `amount`.\n */\n function _transfer(address sender, address recipient, uint256 amount) internal virtual {\n require(sender != address(0), \"ERC20: transfer from the zero address\");\n require(recipient != address(0), \"ERC20: transfer to the zero address\");\n\n _beforeTokenTransfer(sender, recipient, amount);\n\n _balances[sender] = _balances[sender].sub(amount, \"ERC20: transfer amount exceeds balance\");\n _balances[recipient] = _balances[recipient].add(amount);\n emit Transfer(sender, recipient, amount);\n }\n\n /** @dev Creates `amount` tokens and assigns them to `account`, increasing\n * the total supply.\n *\n * Emits a {Transfer} event with `from` set to the zero address.\n *\n * Requirements\n *\n * - `to` cannot be the zero address.\n */\n function _mint(address account, uint256 amount) internal virtual {\n require(account != address(0), \"ERC20: mint to the zero address\");\n\n _beforeTokenTransfer(address(0), account, amount);\n\n _totalSupply = _totalSupply.add(amount);\n _balances[account] = _balances[account].add(amount);\n emit Transfer(address(0), account, amount);\n }\n\n /**\n * @dev Destroys `amount` tokens from the caller.\n *\n * See {ERC20-_burn}.\n */\n function burn(uint256 amount) public virtual {\n _burn(_msgSender(), amount);\n }\n\n /**\n * @dev Destroys `amount` tokens from `account`, deducting from the caller's\n * allowance.\n *\n * See {ERC20-_burn} and {ERC20-allowance}.\n *\n * Requirements:\n *\n * - the caller must have allowance for `accounts`'s tokens of at least\n * `amount`.\n */\n function burnFrom(address account, uint256 amount) public virtual {\n uint256 decreasedAllowance = allowance(account, _msgSender()).sub(amount, \"ERC20: burn amount exceeds allowance\");\n\n _approve(account, _msgSender(), decreasedAllowance);\n _burn(account, amount);\n }\n\n\n /**\n * @dev Destroys `amount` tokens from `account`, reducing the\n * total supply.\n *\n * Emits a {Transfer} event with `to` set to the zero address.\n *\n * Requirements\n *\n * - `account` cannot be the zero address.\n * - `account` must have at least `amount` tokens.\n */\n function _burn(address account, uint256 amount) internal virtual {\n require(account != address(0), \"ERC20: burn from the zero address\");\n\n _beforeTokenTransfer(account, address(0), amount);\n\n _balances[account] = _balances[account].sub(amount, \"ERC20: burn amount exceeds balance\");\n _totalSupply = _totalSupply.sub(amount);\n emit Transfer(account, address(0), amount);\n }\n\n /**\n * @dev Sets `amount` as the allowance of `spender` over the `owner`s tokens.\n *\n * This is internal function is equivalent to `approve`, and can be used to\n * e.g. set automatic allowances for certain subsystems, etc.\n *\n * Emits an {Approval} event.\n *\n * Requirements:\n *\n * - `owner` cannot be the zero address.\n * - `spender` cannot be the zero address.\n */\n function _approve(address owner, address spender, uint256 amount) internal virtual {\n require(owner != address(0), \"ERC20: approve from the zero address\");\n require(spender != address(0), \"ERC20: approve to the zero address\");\n\n _allowances[owner][spender] = amount;\n emit Approval(owner, spender, amount);\n }\n\n /**\n * @dev Destroys `amount` tokens from `account`.`amount` is then deducted\n * from the caller's allowance.\n *\n * See {_burn} and {_approve}.\n */\n function _burnFrom(address account, uint256 amount) internal virtual {\n _burn(account, amount);\n _approve(account, _msgSender(), _allowances[account][_msgSender()].sub(amount, \"ERC20: burn amount exceeds allowance\"));\n }\n\n /**\n * @dev Hook that is called before any transfer of tokens. This includes\n * minting and burning.\n *\n * Calling conditions:\n *\n * - when `from` and `to` are both non-zero, `amount` of `from`'s tokens\n * will be to transferred to `to`.\n * - when `from` is zero, `amount` tokens will be minted for `to`.\n * - when `to` is zero, `amount` of `from`'s tokens will be burned.\n * - `from` and `to` are never both zero.\n *\n * To learn more about hooks, head to xref:ROOT:using-hooks.adoc[Using Hooks].\n */\n function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual { }\n}" }, "contracts/ERC20/IERC20.sol": { "content": "// SPDX-License-Identifier: MIT\npragma solidity >=0.6.11;\n\nimport \"../Common/Context.sol\";\nimport \"../Math/SafeMath.sol\";\n\n/**\n * @dev Interface of the ERC20 standard as defined in the EIP. Does not include\n * the optional functions; to access them see {ERC20Detailed}.\n */\ninterface IERC20 {\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\n" }, "contracts/DEI/DEI.sol": { "content": "// Be name Khoda\n// Bime Abolfazl\n\n// SPDX-License-Identifier: GPL-2.0-or-later\npragma solidity ^0.8.0;\n\n// =================================================================================================================\n// _|_|_| _|_|_|_| _| _| _|_|_| _|_|_|_| _| |\n// _| _| _| _| _| _| _| _|_|_| _|_|_| _|_|_| _|_|_| _|_| |\n// _| _| _|_|_| _| _| _|_| _|_|_| _| _| _| _| _| _| _| _| _|_|_|_| |\n// _| _| _| _| _| _| _| _| _| _| _| _| _| _| _| _| |\n// _|_|_| _|_|_|_| _|_| _|_|_| _| _| _| _| _|_|_| _| _| _|_|_| _|_|_| |\n// =================================================================================================================\n// ======================= DEIStablecoin (DEI) ======================\n// ====================================================================\n// DEUS Finance: https://github.com/DeusFinance\n\n// Primary Author(s)\n// Travis Moore: https://github.com/FortisFortuna\n// Jason Huan: https://github.com/jasonhuan\n// Sam Kazemian: https://github.com/samkazemian\n// Vahid: https://github.com/vahid-dev\n// SAYaghoubnejad: https://github.com/SAYaghoubnejad\n\n// Reviewer(s) / Contributor(s)\n// Sam Sun: https://github.com/samczsun\n\nimport \"../Common/Context.sol\";\nimport \"../ERC20/IERC20.sol\";\nimport \"../ERC20/ERC20Custom.sol\";\nimport \"../ERC20/ERC20.sol\";\nimport \"../Staking/Owned.sol\";\nimport \"../DEUS/DEUS.sol\";\nimport \"./Pools/DEIPool.sol\";\nimport \"../Oracle/Oracle.sol\";\nimport \"../Oracle/ReserveTracker.sol\";\nimport \"@openzeppelin/contracts/utils/cryptography/ECDSA.sol\";\n\ncontract DEIStablecoin is ERC20Custom, AccessControl {\n\tusing ECDSA for bytes32;\n\n\t/* ========== STATE VARIABLES ========== */\n\tenum PriceChoice {\n\t\tDEI,\n\t\tDEUS\n\t}\n\taddress public oracle;\n\tstring public symbol;\n\tstring public name;\n\tuint8 public constant decimals = 18;\n\taddress public creator_address;\n\taddress public deus_address;\n\tuint256 public constant genesis_supply = 10000e18; // genesis supply is 10k on Mainnet. This is to help with establishing the Uniswap pools, as they need liquidity\n\taddress public reserve_tracker_address;\n\n\t// The addresses in this array are added by the oracle and these contracts are able to mint DEI\n\taddress[] public dei_pools_array;\n\n\t// Mapping is also used for faster verification\n\tmapping(address => bool) public dei_pools;\n\n\t// Constants for various precisions\n\tuint256 private constant PRICE_PRECISION = 1e6;\n\n\tuint256 public global_collateral_ratio; // 6 decimals of precision, e.g. 924102 = 0.924102\n\tuint256 public dei_step; // Amount to change the collateralization ratio by upon refreshCollateralRatio()\n\tuint256 public refresh_cooldown; // Seconds to wait before being able to run refreshCollateralRatio() again\n\t// uint256 public price_target; // The price of DEI at which the collateral ratio will respond to; this value is only used for the collateral ratio mechanism and not for minting and redeeming which are hardcoded at $1\n\tuint256 public price_band; // The bound above and below the price target at which the refreshCollateralRatio() will not change the collateral ratio\n\n\tbytes32 public constant COLLATERAL_RATIO_PAUSER = keccak256(\"COLLATERAL_RATIO_PAUSER\");\n\tbytes32 public constant TRUSTY_ROLE = keccak256(\"TRUSTY_ROLE\");\n\tbytes32 public constant MINTER_ROLE = keccak256(\"MINTER_ROLE\");\n\tbool public collateral_ratio_paused = false;\n\n\n\t// 6 decimals of precision\n\tuint256 public growth_ratio;\n\tuint256 public GR_top_band;\n\tuint256 public GR_bottom_band;\n\n\t// Bands\n\tuint256 public DEI_top_band;\n\tuint256 public DEI_bottom_band;\n\n\t// Booleans\n\t// bool public is_active;\n\tbool public use_growth_ratio;\n\tbool public FIP_6;\n\n\n\t/* ========== MODIFIERS ========== */\n\n\tmodifier onlyCollateralRatioPauser() {\n\t\trequire(hasRole(COLLATERAL_RATIO_PAUSER, msg.sender), \"DEI: you are not the collateral ratio pauser\");\n\t\t_;\n\t}\n\n\tmodifier onlyPoolsOrMinters() {\n\t\trequire(\n\t\t\tdei_pools[msg.sender] == true ||\n\t\t\thasRole(MINTER_ROLE, msg.sender),\n\t\t\t\"DEI: you are not minter\"\n\t\t);\n\t\t_;\n\t}\n\n\tmodifier onlyPools() {\n\t\trequire(\n\t\t\tdei_pools[msg.sender] == true,\n\t\t\t\"DEI: only dei pools can call this function\"\n\t\t);\n\t\t_;\n\t}\n\n\tmodifier onlyByTrusty() {\n\t\trequire(\n\t\t\thasRole(TRUSTY_ROLE, msg.sender),\n\t\t\t\"DEI: you are not the owner\"\n\t\t);\n\t\t_;\n\t}\n\n\t/* ========== CONSTRUCTOR ========== */\n\n\tconstructor(\n\t\tstring memory _name,\n\t\tstring memory _symbol,\n\t\taddress _creator_address,\n\t\taddress _trusty_address\n\t){\n\t\trequire(\n\t\t\t_creator_address != address(0),\n\t\t\t\"DEI: zero address detected.\"\n\t\t);\n\t\tname = _name;\n\t\tsymbol = _symbol;\n\t\tcreator_address = _creator_address;\n\t\t_setupRole(DEFAULT_ADMIN_ROLE, _trusty_address);\n\t\t_mint(creator_address, genesis_supply);\n\t\t_setupRole(COLLATERAL_RATIO_PAUSER, creator_address);\n\t\tdei_step = 2500; // 6 decimals of precision, equal to 0.25%\n\t\tglobal_collateral_ratio = 800000; // Dei system starts off fully collateralized (6 decimals of precision)\n\t\trefresh_cooldown = 300; // Refresh cooldown period is set to 5 minutes (300 seconds) at genesis\n\t\tprice_band = 5000; // Collateral ratio will not adjust if between $0.995 and $1.005 at genesis\n\t\t_setupRole(TRUSTY_ROLE, _trusty_address);\n\n\t\t// Upon genesis, if GR changes by more than 1% percent, enable change of collateral ratio\n\t\tGR_top_band = 1000;\n\t\tGR_bottom_band = 1000; \n\t}\n\n\t/* ========== VIEWS ========== */\n\n\t// Verify X DEUS or X DEI = 1 USD or ...\n\tfunction verify_price(bytes32 sighash, bytes[] calldata sigs)\n\t\tpublic\n\t\tview\n\t\treturns (bool)\n\t{\n\t\treturn Oracle(oracle).verify(sighash.toEthSignedMessageHash(), sigs);\n\t}\n\n\t// This is needed to avoid costly repeat calls to different getter functions\n\t// It is cheaper gas-wise to just dump everything and only use some of the info\n\tfunction dei_info(uint256[] memory collat_usd_price)\n\t\tpublic\n\t\tview\n\t\treturns (\n\t\t\tuint256,\n\t\t\tuint256,\n\t\t\tuint256\n\t\t)\n\t{\n\t\treturn (\n\t\t\ttotalSupply(), // totalSupply()\n\t\t\tglobal_collateral_ratio, // global_collateral_ratio()\n\t\t\tglobalCollateralValue(collat_usd_price) // globalCollateralValue\n\t\t);\n\t}\n\n\t// Iterate through all dei pools and calculate all value of collateral in all pools globally\n\tfunction globalCollateralValue(uint256[] memory collat_usd_price) public view returns (uint256) {\n\t\tuint256 total_collateral_value_d18 = 0;\n\n\t\tfor (uint256 i = 0; i < dei_pools_array.length; i++) {\n\t\t\t// Exclude null addresses\n\t\t\tif (dei_pools_array[i] != address(0)) {\n\t\t\t\ttotal_collateral_value_d18 = total_collateral_value_d18 + DEIPool(dei_pools_array[i]).collatDollarBalance(collat_usd_price[i]);\n\t\t\t}\n\t\t}\n\t\treturn total_collateral_value_d18;\n\t}\n\n\tfunction getChainID() public view returns (uint256) {\n uint256 id;\n assembly {\n id := chainid()\n }\n return id;\n }\n\n\t/* ========== PUBLIC FUNCTIONS ========== */\n\n\t// There needs to be a time interval that this can be called. Otherwise it can be called multiple times per expansion.\n\tuint256 public last_call_time; // Last time the refreshCollateralRatio function was called\n\n\t// Note: New function to refresh collateral ratio\n\tfunction refreshCollateralRatio(uint deus_price, uint dei_price, uint256 expire_block, bytes[] calldata sigs) external {\n\t\trequire(collateral_ratio_paused == false, \"DEI::Collateral Ratio has been paused\");\n\t\tuint256 time_elapsed = (block.timestamp) - last_call_time;\n\t\trequire(time_elapsed >= refresh_cooldown, \"DEI::Internal cooldown not passed\");\n\t\tuint256 deus_reserves = ReserveTracker(reserve_tracker_address).getDEUSReserves();\n\n\t\tbytes32 sighash = keccak256(abi.encodePacked(\n\t\t\t\t\t\t\t\t\t\tdeus_address,\n\t\t\t\t\t\t\t\t\t\tdeus_price,\n\t\t\t\t\t\t\t\t\t\taddress(this),\n\t\t\t\t\t\t\t\t\t\tdei_price,\n\t\t\t\t\t\t\t\t\t\texpire_block,\n \tgetChainID()\n ));\n\n\t\tverify_price(sighash, sigs);\n\n\t\tuint256 deus_liquidity = deus_reserves * deus_price; // Has 6 decimals of precision\n\n\t\tuint256 dei_supply = totalSupply();\n\n\t\tuint256 new_growth_ratio = deus_liquidity / dei_supply; // (E18 + E6) / E18\n\n\t\tif(FIP_6){\n\t\t\trequire(dei_price > DEI_top_band || dei_price < DEI_bottom_band, \"DEI::Use refreshCollateralRatio when DEI is outside of peg\");\n\t\t}\n\n\t\t// First, check if the price is out of the band\n\t\tif(dei_price > DEI_top_band){\n\t\t\tglobal_collateral_ratio = global_collateral_ratio - dei_step;\n\t\t} else if (dei_price < DEI_bottom_band){\n\t\t\tglobal_collateral_ratio = global_collateral_ratio + dei_step;\n\n\t\t// Else, check if the growth ratio has increased or decreased since last update\n\t\t} else if(use_growth_ratio){\n\t\t\tif(new_growth_ratio > growth_ratio * (1e6 + GR_top_band) / 1e6){\n\t\t\t\tglobal_collateral_ratio = global_collateral_ratio - dei_step;\n\t\t\t} else if (new_growth_ratio < growth_ratio * (1e6 - GR_bottom_band) / 1e6){\n\t\t\t\tglobal_collateral_ratio = global_collateral_ratio + dei_step;\n\t\t\t}\n\t\t}\n\n\t\tgrowth_ratio = new_growth_ratio;\n\t\tlast_call_time = block.timestamp;\n\n\t\t// No need for checking CR under 0 as the last_collateral_ratio.sub(dei_step) will throw \n\t\t// an error above in that case\n\t\tif(global_collateral_ratio > 1e6){\n\t\t\tglobal_collateral_ratio = 1e6;\n\t\t}\n\n\t\temit CollateralRatioRefreshed(global_collateral_ratio);\n\n\t}\n\n\tfunction useGrowthRatio(bool _use_growth_ratio) external onlyByTrusty {\n\t\tuse_growth_ratio = _use_growth_ratio;\n\n\t\temit UseGrowthRatioSet(_use_growth_ratio);\n\t}\n\n\tfunction setGrowthRatioBands(uint256 _GR_top_band, uint256 _GR_bottom_band) external onlyByTrusty {\n\t\tGR_top_band = _GR_top_band;\n\t\tGR_bottom_band = _GR_bottom_band;\n\t\temit GrowthRatioBandSet( _GR_top_band, _GR_bottom_band);\n\t}\n\n\tfunction setPriceBands(uint256 _top_band, uint256 _bottom_band) external onlyByTrusty {\n\t\tDEI_top_band = _top_band;\n\t\tDEI_bottom_band = _bottom_band;\n\n\t\temit PriceBandSet(_top_band, _bottom_band);\n\t}\n\n\tfunction activateFIP6(bool _activate) external onlyByTrusty {\n\t\tFIP_6 = _activate;\n\n\t\temit FIP_6Set(_activate);\n\t}\n\n\t// Used by pools when user redeems\n\tfunction pool_burn_from(address b_address, uint256 b_amount)\n\t\tpublic\n\t\tonlyPools\n\t{\n\t\tsuper._burnFrom(b_address, b_amount);\n\t\temit DEIBurned(b_address, msg.sender, b_amount);\n\t}\n\n\t// This function is what other dei pools will call to mint new DEI\n\tfunction pool_mint(address m_address, uint256 m_amount) public onlyPoolsOrMinters {\n\t\tsuper._mint(m_address, m_amount);\n\t\temit DEIMinted(msg.sender, m_address, m_amount);\n\t}\n\n\t// Adds collateral addresses supported, such as tether and busd, must be ERC20\n\tfunction addPool(address pool_address)\n\t\tpublic\n\t\tonlyByTrusty\n\t{\n\t\trequire(pool_address != address(0), \"DEI::addPool: Zero address detected\");\n\t\trequire(dei_pools[pool_address] == false, \"DEI::addPool: Address already exists\");\n\n\t\tdei_pools[pool_address] = true;\n\t\tdei_pools_array.push(pool_address);\n\n\t\temit PoolAdded(pool_address);\n\t}\n\n\t// Remove a pool\n\tfunction removePool(address pool_address)\n\t\tpublic\n\t\tonlyByTrusty\n\t{\n\t\trequire(pool_address != address(0), \"DEI::removePool: Zero address detected\");\n\n\t\trequire(dei_pools[pool_address] == true, \"DEI::removePool: Address nonexistant\");\n\n\t\t// Delete from the mapping\n\t\tdelete dei_pools[pool_address];\n\n\t\t// 'Delete' from the array by setting the address to 0x0\n\t\tfor (uint256 i = 0; i < dei_pools_array.length; i++) {\n\t\t\tif (dei_pools_array[i] == pool_address) {\n\t\t\t\tdei_pools_array[i] = address(0); // This will leave a null in the array and keep the indices the same\n\t\t\t\tbreak;\n\t\t\t}\n\t\t}\n\n\t\temit PoolRemoved(pool_address);\n\t}\n\t\n\tfunction setOracle(address _oracle)\n\t\tpublic\n\t\tonlyByTrusty\n\t{\n\t\toracle = _oracle;\n\n\t\temit OracleSet(_oracle);\n\t}\n\n\tfunction setDEIStep(uint256 _new_step)\n\t\tpublic\n\t\tonlyByTrusty\n\t{\n\t\tdei_step = _new_step;\n\n\t\temit DEIStepSet(_new_step);\n\t}\n\n\tfunction setReserveTracker(address _reserve_tracker_address)\n\t\texternal\n\t\tonlyByTrusty\n\t{\t\t\n\t\treserve_tracker_address = _reserve_tracker_address;\n\n\t\temit ReserveTrackerSet(_reserve_tracker_address);\n\t}\n\n\tfunction setRefreshCooldown(uint256 _new_cooldown)\n\t\tpublic\n\t\tonlyByTrusty\n\t{\n\t\trefresh_cooldown = _new_cooldown;\n\n\t\temit RefreshCooldownSet(_new_cooldown);\n\t}\n\n\tfunction setDEUSAddress(address _deus_address)\n\t\tpublic\n\t\tonlyByTrusty\n\t{\n\t\trequire(_deus_address != address(0), \"DEI::setDEUSAddress: Zero address detected\");\n\n\t\tdeus_address = _deus_address;\n\n\t\temit DEUSAddressSet(_deus_address);\n\t}\n\n\tfunction toggleCollateralRatio()\n\t\tpublic\n\t\tonlyCollateralRatioPauser \n\t{\n\t\tcollateral_ratio_paused = !collateral_ratio_paused;\n\n\t\temit CollateralRatioToggled(collateral_ratio_paused);\n\t}\n\n\t/* ========== EVENTS ========== */\n\n\t// Track DEI burned\n\tevent DEIBurned(address indexed from, address indexed to, uint256 amount);\n\t// Track DEI minted\n\tevent DEIMinted(address indexed from, address indexed to, uint256 amount);\n\tevent CollateralRatioRefreshed(uint256 global_collateral_ratio);\n\tevent PoolAdded(address pool_address);\n\tevent PoolRemoved(address pool_address);\n\tevent DEIStepSet(uint256 new_step);\n\tevent RefreshCooldownSet(uint256 new_cooldown);\n\tevent DEUSAddressSet(address deus_address);\n\tevent PriceBandSet(uint256 top_band, uint256 bottom_band);\n\tevent CollateralRatioToggled(bool collateral_ratio_paused);\n\tevent OracleSet(address oracle);\n\tevent ReserveTrackerSet(address reserve_tracker_address);\n\tevent UseGrowthRatioSet( bool use_growth_ratio);\n\tevent FIP_6Set(bool activate);\n\tevent GrowthRatioBandSet(uint256 GR_top_band, uint256 GR_bottom_band);\n}\n\n//Dar panah khoda\n" }, "contracts/Governance/AccessControl.sol": { "content": "// SPDX-License-Identifier: MIT\n\npragma solidity >=0.6.11;\n\nimport \"../Utils/EnumerableSet.sol\";\nimport \"../Utils/Address.sol\";\nimport \"../Common/Context.sol\";\n\n/**\n * @dev Contract module that allows children to implement role-based access\n * control mechanisms.\n *\n * Roles are referred to by their `bytes32` identifier. These should be exposed\n * in the external API and be unique. The best way to achieve this is by\n * using `public constant` hash digests:\n *\n * ```\n * bytes32 public constant MY_ROLE = keccak256(\"MY_ROLE\");\n * ```\n *\n * Roles can be used to represent a set of permissions. To restrict access to a\n * function call, use {hasRole}:\n *\n * ```\n * function foo() public {\n * require(hasRole(MY_ROLE, msg.sender));\n * ...\n * }\n * ```\n *\n * Roles can be granted and revoked dynamically via the {grantRole} and\n * {revokeRole} functions. Each role has an associated admin role, and only\n * accounts that have a role's admin role can call {grantRole} and {revokeRole}.\n *\n * By default, the admin role for all roles is `DEFAULT_ADMIN_ROLE`, which means\n * that only accounts with this role will be able to grant or revoke other\n * roles. More complex role relationships can be created by using\n * {_setRoleAdmin}.\n *\n * WARNING: The `DEFAULT_ADMIN_ROLE` is also its own admin: it has permission to\n * grant and revoke this role. Extra precautions should be taken to secure\n * accounts that have been granted it.\n */\nabstract contract AccessControl is Context {\n using EnumerableSet for EnumerableSet.AddressSet;\n using Address for address;\n\n struct RoleData {\n EnumerableSet.AddressSet members;\n bytes32 adminRole;\n }\n\n mapping (bytes32 => RoleData) private _roles;\n\n bytes32 public constant DEFAULT_ADMIN_ROLE = 0x00; //bytes32(uint256(0x4B437D01b575618140442A4975db38850e3f8f5f) << 96);\n\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 * _Available since v3.1._\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 {_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) public view returns (bool) {\n return _roles[role].members.contains(account);\n }\n\n /**\n * @dev Returns the number of accounts that have `role`. Can be used\n * together with {getRoleMember} to enumerate all bearers of a role.\n */\n function getRoleMemberCount(bytes32 role) public view returns (uint256) {\n return _roles[role].members.length();\n }\n\n /**\n * @dev Returns one of the accounts that have `role`. `index` must be a\n * value between 0 and {getRoleMemberCount}, non-inclusive.\n *\n * Role bearers are not sorted in any particular way, and their ordering may\n * change at any point.\n *\n * WARNING: When using {getRoleMember} and {getRoleMemberCount}, make sure\n * you perform all queries on the same block. See the following\n * https://forum.openzeppelin.com/t/iterating-over-elements-on-enumerableset-in-openzeppelin-contracts/2296[forum post]\n * for more information.\n */\n function getRoleMember(bytes32 role, uint256 index) public view returns (address) {\n return _roles[role].members.at(index);\n }\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 {_setRoleAdmin}.\n */\n function getRoleAdmin(bytes32 role) public view returns (bytes32) {\n return _roles[role].adminRole;\n }\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) public virtual {\n require(hasRole(_roles[role].adminRole, _msgSender()), \"AccessControl: sender must be an admin to grant\");\n\n _grantRole(role, account);\n }\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) public virtual {\n require(hasRole(_roles[role].adminRole, _msgSender()), \"AccessControl: sender must be an admin to revoke\");\n\n _revokeRole(role, account);\n }\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) public virtual {\n require(account == _msgSender(), \"AccessControl: can only renounce roles for self\");\n\n _revokeRole(role, account);\n }\n\n /**\n * @dev Grants `role` to `account`.\n *\n * If `account` had not been already granted `role`, emits a {RoleGranted}\n * event. Note that unlike {grantRole}, this function doesn't perform any\n * checks on the calling account.\n *\n * [WARNING]\n * ====\n * This function should only be called from the constructor when setting\n * up the initial roles for the system.\n *\n * Using this function in any other way is effectively circumventing the admin\n * system imposed by {AccessControl}.\n * ====\n */\n function _setupRole(bytes32 role, address account) internal virtual {\n _grantRole(role, account);\n }\n\n /**\n * @dev Sets `adminRole` as ``role``'s admin role.\n *\n * Emits a {RoleAdminChanged} event.\n */\n function _setRoleAdmin(bytes32 role, bytes32 adminRole) internal virtual {\n emit RoleAdminChanged(role, _roles[role].adminRole, adminRole);\n _roles[role].adminRole = adminRole;\n }\n\n function _grantRole(bytes32 role, address account) private {\n if (_roles[role].members.add(account)) {\n emit RoleGranted(role, account, _msgSender());\n }\n }\n\n function _revokeRole(bytes32 role, address account) private {\n if (_roles[role].members.remove(account)) {\n emit RoleRevoked(role, account, _msgSender());\n }\n }\n}\n" }, "contracts/Math/SafeMath.sol": { "content": "// SPDX-License-Identifier: MIT\npragma solidity >=0.6.11;\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 uint256 c = a + b;\n require(c >= a, \"SafeMath: addition overflow\");\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 * _Available since v2.4.0._\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 * _Available since v2.4.0._\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 * _Available since v2.4.0._\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}" }, "contracts/Utils/Address.sol": { "content": "// SPDX-License-Identifier: MIT\npragma solidity >=0.6.11 <0.9.0;\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 // This method relies on extcodesize, which returns 0 for contracts in\n // construction, since the code is only stored at the end of the\n // constructor execution.\n\n uint256 size;\n // solhint-disable-next-line no-inline-assembly\n assembly { size := extcodesize(account) }\n return size > 0;\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 function sendValue(address payable recipient, uint256 amount) internal {\n require(address(this).balance >= amount, \"Address: insufficient balance\");\n\n // solhint-disable-next-line avoid-low-level-calls, avoid-call-value\n (bool success, ) = recipient.call{ value: amount }(\"\");\n require(success, \"Address: unable to send value, recipient may have reverted\");\n }\n\n /**\n * @dev Performs a Solidity function call using a low level `call`. A\n * plain`call` is an unsafe replacement for a function call: use this\n * function instead.\n *\n * If `target` reverts with a revert reason, it is bubbled up by this\n * function (like regular Solidity function calls).\n *\n * Returns the raw returned data. To convert to the expected return value,\n * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].\n *\n * Requirements:\n *\n * - `target` must be a contract.\n * - calling `target` with `data` must not revert.\n *\n * _Available since v3.1._\n */\n function functionCall(address target, bytes memory data) internal returns (bytes memory) {\n return functionCall(target, data, \"Address: low-level call failed\");\n }\n\n /**\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with\n * `errorMessage` as a fallback revert reason when `target` reverts.\n *\n * _Available since v3.1._\n */\n function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {\n return functionCallWithValue(target, data, 0, errorMessage);\n }\n\n /**\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\n * but also transferring `value` wei to `target`.\n *\n * Requirements:\n *\n * - the calling contract must have an ETH balance of at least `value`.\n * - the called Solidity function must be `payable`.\n *\n * _Available since v3.1._\n */\n function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {\n return functionCallWithValue(target, data, value, \"Address: low-level call with value failed\");\n }\n\n /**\n * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but\n * with `errorMessage` as a fallback revert reason when `target` reverts.\n *\n * _Available since v3.1._\n */\n function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {\n require(address(this).balance >= value, \"Address: insufficient balance for call\");\n require(isContract(target), \"Address: call to non-contract\");\n\n // solhint-disable-next-line avoid-low-level-calls\n (bool success, bytes memory returndata) = target.call{ value: value }(data);\n return _verifyCallResult(success, returndata, errorMessage);\n }\n\n /**\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\n * but performing a static call.\n *\n * _Available since v3.3._\n */\n function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {\n return functionStaticCall(target, data, \"Address: low-level static call failed\");\n }\n\n /**\n * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\n * but performing a static call.\n *\n * _Available since v3.3._\n */\n function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) {\n require(isContract(target), \"Address: static call to non-contract\");\n\n // solhint-disable-next-line avoid-low-level-calls\n (bool success, bytes memory returndata) = target.staticcall(data);\n return _verifyCallResult(success, returndata, errorMessage);\n }\n\n /**\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\n * but performing a delegate call.\n *\n * _Available since v3.4._\n */\n function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {\n return functionDelegateCall(target, data, \"Address: low-level delegate call failed\");\n }\n\n /**\n * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\n * but performing a delegate call.\n *\n * _Available since v3.4._\n */\n function functionDelegateCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {\n require(isContract(target), \"Address: delegate call to non-contract\");\n\n // solhint-disable-next-line avoid-low-level-calls\n (bool success, bytes memory returndata) = target.delegatecall(data);\n return _verifyCallResult(success, returndata, errorMessage);\n }\n\n function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) {\n if (success) {\n return returndata;\n } else {\n // Look for revert reason and bubble it up if present\n if (returndata.length > 0) {\n // The easiest way to bubble the revert reason is using memory via assembly\n\n // solhint-disable-next-line no-inline-assembly\n assembly {\n let returndata_size := mload(returndata)\n revert(add(32, returndata), returndata_size)\n }\n } else {\n revert(errorMessage);\n }\n }\n }\n}" }, "contracts/ERC20/ERC20.sol": { "content": "// SPDX-License-Identifier: MIT\npragma solidity >=0.6.11;\n\nimport \"../Common/Context.sol\";\nimport \"./IERC20.sol\";\nimport \"../Math/SafeMath.sol\";\nimport \"../Utils/Address.sol\";\n\n\n/**\n * @dev Implementation of the {IERC20} interface.\n *\n * This implementation is agnostic to the way tokens are created. This means\n * that a supply mechanism has to be added in a derived contract using {_mint}.\n * For a generic mechanism see {ERC20Mintable}.\n *\n * TIP: For a detailed writeup see our guide\n * https://forum.zeppelin.solutions/t/how-to-implement-erc20-supply-mechanisms/226[How\n * to implement supply mechanisms].\n *\n * We have followed general OpenZeppelin guidelines: functions revert instead\n * of returning `false` on failure. This behavior is nonetheless conventional\n * and does not conflict with the expectations of ERC20 applications.\n *\n * Additionally, an {Approval} event is emitted on calls to {transferFrom}.\n * This allows applications to reconstruct the allowance for all accounts just\n * by listening to said events. Other implementations of the EIP may not emit\n * these events, as it isn't required by the specification.\n *\n * Finally, the non-standard {decreaseAllowance} and {increaseAllowance}\n * functions have been added to mitigate the well-known issues around setting\n * allowances. See {IERC20-approve}.\n */\n \ncontract ERC20 is Context, IERC20 {\n using SafeMath for uint256;\n\n mapping (address => uint256) private _balances;\n\n mapping (address => mapping (address => uint256)) private _allowances;\n\n uint256 private _totalSupply;\n\n string private _name;\n string private _symbol;\n uint8 private _decimals;\n \n /**\n * @dev Sets the values for {name} and {symbol}, initializes {decimals} with\n * a default value of 18.\n *\n * To select a different value for {decimals}, use {_setupDecimals}.\n *\n * All three of these values are immutable: they can only be set once during\n * construction.\n */\n constructor (string memory __name, string memory __symbol) public {\n _name = __name;\n _symbol = __symbol;\n _decimals = 18;\n }\n\n /**\n * @dev Returns the name of the token.\n */\n function name() public view returns (string memory) {\n return _name;\n }\n\n /**\n * @dev Returns the symbol of the token, usually a shorter version of the\n * name.\n */\n function symbol() public view returns (string memory) {\n return _symbol;\n }\n\n /**\n * @dev Returns the number of decimals used to get its user representation.\n * For example, if `decimals` equals `2`, a balance of `505` tokens should\n * be displayed to a user as `5,05` (`505 / 10 ** 2`).\n *\n * Tokens usually opt for a value of 18, imitating the relationship between\n * Ether and Wei. This is the value {ERC20} uses, unless {_setupDecimals} is\n * called.\n *\n * NOTE: This information is only used for _display_ purposes: it in\n * no way affects any of the arithmetic of the contract, including\n * {IERC20-balanceOf} and {IERC20-transfer}.\n */\n function decimals() public view returns (uint8) {\n return _decimals;\n }\n\n /**\n * @dev See {IERC20-totalSupply}.\n */\n function totalSupply() public view override returns (uint256) {\n return _totalSupply;\n }\n\n /**\n * @dev See {IERC20-balanceOf}.\n */\n function balanceOf(address account) public view override returns (uint256) {\n return _balances[account];\n }\n\n /**\n * @dev See {IERC20-transfer}.\n *\n * Requirements:\n *\n * - `recipient` cannot be the zero address.\n * - the caller must have a balance of at least `amount`.\n */\n function transfer(address recipient, uint256 amount) public virtual override returns (bool) {\n _transfer(_msgSender(), recipient, amount);\n return true;\n }\n\n /**\n * @dev See {IERC20-allowance}.\n */\n function allowance(address owner, address spender) public view virtual override returns (uint256) {\n return _allowances[owner][spender];\n }\n\n /**\n * @dev See {IERC20-approve}.\n *\n * Requirements:\n *\n * - `spender` cannot be the zero address.approve(address spender, uint256 amount)\n */\n function approve(address spender, uint256 amount) public virtual override returns (bool) {\n _approve(_msgSender(), spender, amount);\n return true;\n }\n\n /**\n * @dev See {IERC20-transferFrom}.\n *\n * Emits an {Approval} event indicating the updated allowance. This is not\n * required by the EIP. See the note at the beginning of {ERC20};\n *\n * Requirements:\n * - `sender` and `recipient` cannot be the zero address.\n * - `sender` must have a balance of at least `amount`.\n * - the caller must have allowance for `sender`'s tokens of at least\n * `amount`.\n */\n function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {\n _transfer(sender, recipient, amount);\n _approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, \"ERC20: transfer amount exceeds allowance\"));\n return true;\n }\n\n /**\n * @dev Atomically increases the allowance granted to `spender` by the caller.\n *\n * This is an alternative to {approve} that can be used as a mitigation for\n * problems described in {IERC20-approve}.\n *\n * Emits an {Approval} event indicating the updated allowance.\n *\n * Requirements:\n *\n * - `spender` cannot be the zero address.\n */\n function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {\n _approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));\n return true;\n }\n\n /**\n * @dev Atomically decreases the allowance granted to `spender` by the caller.\n *\n * This is an alternative to {approve} that can be used as a mitigation for\n * problems described in {IERC20-approve}.\n *\n * Emits an {Approval} event indicating the updated allowance.\n *\n * Requirements:\n *\n * - `spender` cannot be the zero address.\n * - `spender` must have allowance for the caller of at least\n * `subtractedValue`.\n */\n function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {\n _approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, \"ERC20: decreased allowance below zero\"));\n return true;\n }\n\n /**\n * @dev Moves tokens `amount` from `sender` to `recipient`.\n *\n * This is internal function is equivalent to {transfer}, and can be used to\n * e.g. implement automatic token fees, slashing mechanisms, etc.\n *\n * Emits a {Transfer} event.\n *\n * Requirements:\n *\n * - `sender` cannot be the zero address.\n * - `recipient` cannot be the zero address.\n * - `sender` must have a balance of at least `amount`.\n */\n function _transfer(address sender, address recipient, uint256 amount) internal virtual {\n require(sender != address(0), \"ERC20: transfer from the zero address\");\n require(recipient != address(0), \"ERC20: transfer to the zero address\");\n\n _beforeTokenTransfer(sender, recipient, amount);\n\n _balances[sender] = _balances[sender].sub(amount, \"ERC20: transfer amount exceeds balance\");\n _balances[recipient] = _balances[recipient].add(amount);\n emit Transfer(sender, recipient, amount);\n }\n\n /** @dev Creates `amount` tokens and assigns them to `account`, increasing\n * the total supply.\n *\n * Emits a {Transfer} event with `from` set to the zero address.\n *\n * Requirements\n *\n * - `to` cannot be the zero address.\n */\n function _mint(address account, uint256 amount) internal virtual {\n require(account != address(0), \"ERC20: mint to the zero address\");\n\n _beforeTokenTransfer(address(0), account, amount);\n\n _totalSupply = _totalSupply.add(amount);\n _balances[account] = _balances[account].add(amount);\n emit Transfer(address(0), account, amount);\n }\n\n /**\n * @dev Destroys `amount` tokens from the caller.\n *\n * See {ERC20-_burn}.\n */\n function burn(uint256 amount) public virtual {\n _burn(_msgSender(), amount);\n }\n\n /**\n * @dev Destroys `amount` tokens from `account`, deducting from the caller's\n * allowance.\n *\n * See {ERC20-_burn} and {ERC20-allowance}.\n *\n * Requirements:\n *\n * - the caller must have allowance for `accounts`'s tokens of at least\n * `amount`.\n */\n function burnFrom(address account, uint256 amount) public virtual {\n uint256 decreasedAllowance = allowance(account, _msgSender()).sub(amount, \"ERC20: burn amount exceeds allowance\");\n\n _approve(account, _msgSender(), decreasedAllowance);\n _burn(account, amount);\n }\n\n\n /**\n * @dev Destroys `amount` tokens from `account`, reducing the\n * total supply.\n *\n * Emits a {Transfer} event with `to` set to the zero address.\n *\n * Requirements\n *\n * - `account` cannot be the zero address.\n * - `account` must have at least `amount` tokens.\n */\n function _burn(address account, uint256 amount) internal virtual {\n require(account != address(0), \"ERC20: burn from the zero address\");\n\n _beforeTokenTransfer(account, address(0), amount);\n\n _balances[account] = _balances[account].sub(amount, \"ERC20: burn amount exceeds balance\");\n _totalSupply = _totalSupply.sub(amount);\n emit Transfer(account, address(0), amount);\n }\n\n /**\n * @dev Sets `amount` as the allowance of `spender` over the `owner`s tokens.\n *\n * This is internal function is equivalent to `approve`, and can be used to\n * e.g. set automatic allowances for certain subsystems, etc.\n *\n * Emits an {Approval} event.\n *\n * Requirements:\n *\n * - `owner` cannot be the zero address.\n * - `spender` cannot be the zero address.\n */\n function _approve(address owner, address spender, uint256 amount) internal virtual {\n require(owner != address(0), \"ERC20: approve from the zero address\");\n require(spender != address(0), \"ERC20: approve to the zero address\");\n\n _allowances[owner][spender] = amount;\n emit Approval(owner, spender, amount);\n }\n\n /**\n * @dev Destroys `amount` tokens from `account`.`amount` is then deducted\n * from the caller's allowance.\n *\n * See {_burn} and {_approve}.\n */\n function _burnFrom(address account, uint256 amount) internal virtual {\n _burn(account, amount);\n _approve(account, _msgSender(), _allowances[account][_msgSender()].sub(amount, \"ERC20: burn amount exceeds allowance\"));\n }\n\n /**\n * @dev Hook that is called before any transfer of tokens. This includes\n * minting and burning.\n *\n * Calling conditions:\n *\n * - when `from` and `to` are both non-zero, `amount` of `from`'s tokens\n * will be to transferred to `to`.\n * - when `from` is zero, `amount` tokens will be minted for `to`.\n * - when `to` is zero, `amount` of `from`'s tokens will be burned.\n * - `from` and `to` are never both zero.\n *\n * To learn more about hooks, head to xref:ROOT:using-hooks.adoc[Using Hooks].\n */\n function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual { }\n}\n" }, "contracts/Staking/Owned.sol": { "content": "// SPDX-License-Identifier: GPL-2.0-or-later\npragma solidity >=0.6.11;\n\n// https://docs.synthetix.io/contracts/Owned\ncontract Owned {\n address public owner;\n address public nominatedOwner;\n\n constructor(address _owner) public {\n require(_owner != address(0), \"Owner address cannot be 0\");\n owner = _owner;\n emit OwnerChanged(address(0), _owner);\n }\n\n function nominateNewOwner(address _owner) external onlyOwner {\n nominatedOwner = _owner;\n emit OwnerNominated(_owner);\n }\n\n function acceptOwnership() external {\n require(msg.sender == nominatedOwner, \"You must be nominated before you can accept ownership\");\n emit OwnerChanged(owner, nominatedOwner);\n owner = nominatedOwner;\n nominatedOwner = address(0);\n }\n\n modifier onlyOwner {\n require(msg.sender == owner, \"Only the contract owner may perform this action\");\n _;\n }\n\n event OwnerNominated(address newOwner);\n event OwnerChanged(address oldOwner, address newOwner);\n}" }, "contracts/DEI/Pools/DEIPool.sol": { "content": "// Be name Khoda\n// Bime Abolfazl\n\n// SPDX-License-Identifier: GPL-2.0-or-later\npragma solidity ^0.8.0;\npragma abicoder v2;\n// =================================================================================================================\n// _|_|_| _|_|_|_| _| _| _|_|_| _|_|_|_| _| |\n// _| _| _| _| _| _| _| _|_|_| _|_|_| _|_|_| _|_|_| _|_| |\n// _| _| _|_|_| _| _| _|_| _|_|_| _| _| _| _| _| _| _| _| _|_|_|_| |\n// _| _| _| _| _| _| _| _| _| _| _| _| _| _| _| _| |\n// _|_|_| _|_|_|_| _|_| _|_|_| _| _| _| _| _|_|_| _| _| _|_|_| _|_|_| |\n// =================================================================================================================\n// ============================= DEIPool =============================\n// ====================================================================\n// DEUS Finance: https://github.com/DeusFinance\n\n// Primary Author(s)\n// Travis Moore: https://github.com/FortisFortuna\n// Jason Huan: https://github.com/jasonhuan\n// Sam Kazemian: https://github.com/samkazemian\n// Vahid Gh: https://github.com/vahid-dev\n// SAYaghoubnejad: https://github.com/SAYaghoubnejad\n\n// Reviewer(s) / Contributor(s)\n// Sam Sun: https://github.com/samczsun\n\nimport \"../../Uniswap/TransferHelper.sol\";\nimport \"../../DEUS/IDEUS.sol\";\nimport \"../../DEI/IDEI.sol\";\nimport \"../../ERC20/ERC20.sol\";\nimport \"../../Governance/AccessControl.sol\";\nimport \"./DEIPoolLibrary.sol\";\n\ncontract DEIPool is AccessControl {\n\n struct RecollateralizeDEI {\n\t\tuint256 collateral_amount;\n\t\tuint256 pool_collateral_price;\n\t\tuint256[] collateral_price;\n\t\tuint256 deus_current_price;\n\t\tuint256 expireBlock;\n\t\tbytes[] sigs;\n }\n\n\t/* ========== STATE VARIABLES ========== */\n\n\tERC20 private collateral_token;\n\taddress private collateral_address;\n\n\taddress private dei_contract_address;\n\taddress private deus_contract_address;\n\n\tuint256 public minting_fee;\n\tuint256 public redemption_fee;\n\tuint256 public buyback_fee;\n\tuint256 public recollat_fee;\n\n\tmapping(address => uint256) public redeemDEUSBalances;\n\tmapping(address => uint256) public redeemCollateralBalances;\n\tuint256 public unclaimedPoolCollateral;\n\tuint256 public unclaimedPoolDEUS;\n\tmapping(address => uint256) public lastRedeemed;\n\n\t// Constants for various precisions\n\tuint256 private constant PRICE_PRECISION = 1e6;\n\tuint256 private constant COLLATERAL_RATIO_PRECISION = 1e6;\n\tuint256 private constant COLLATERAL_RATIO_MAX = 1e6;\n\n\t// Number of decimals needed to get to 18\n\tuint256 private immutable missing_decimals;\n\n\t// Pool_ceiling is the total units of collateral that a pool contract can hold\n\tuint256 public pool_ceiling = 0;\n\n\t// Stores price of the collateral, if price is paused\n\tuint256 public pausedPrice = 0;\n\n\t// Bonus rate on DEUS minted during recollateralizeDEI(); 6 decimals of precision, set to 0.75% on genesis\n\tuint256 public bonus_rate = 7500;\n\n\t// Number of blocks to wait before being able to collectRedemption()\n\tuint256 public redemption_delay = 2;\n\n\t// Minting/Redeeming fees goes to daoWallet\n\tuint256 public daoShare = 0;\n\n\tDEIPoolLibrary poolLibrary;\n\n\t// AccessControl Roles\n\tbytes32 private constant MINT_PAUSER = keccak256(\"MINT_PAUSER\");\n\tbytes32 private constant REDEEM_PAUSER = keccak256(\"REDEEM_PAUSER\");\n\tbytes32 private constant BUYBACK_PAUSER = keccak256(\"BUYBACK_PAUSER\");\n\tbytes32 private constant RECOLLATERALIZE_PAUSER = keccak256(\"RECOLLATERALIZE_PAUSER\");\n bytes32 public constant TRUSTY_ROLE = keccak256(\"TRUSTY_ROLE\");\n\tbytes32 public constant DAO_SHARE_COLLECTOR = keccak256(\"DAO_SHARE_COLLECTOR\");\n\tbytes32 public constant PARAMETER_SETTER_ROLE = keccak256(\"PARAMETER_SETTER_ROLE\");\n\n\t// AccessControl state variables\n\tbool public mintPaused = false;\n\tbool public redeemPaused = false;\n\tbool public recollateralizePaused = false;\n\tbool public buyBackPaused = false;\n\n\t/* ========== MODIFIERS ========== */\n\n\tmodifier onlyByTrusty() {\n\t\trequire(\n\t\t\thasRole(TRUSTY_ROLE, msg.sender),\n\t\t\t\"POOL::you are not trusty\"\n\t\t);\n\t\t_;\n\t}\n\n\tmodifier notRedeemPaused() {\n\t\trequire(redeemPaused == false, \"POOL::Redeeming is paused\");\n\t\t_;\n\t}\n\n\tmodifier notMintPaused() {\n\t\trequire(mintPaused == false, \"POOL::Minting is paused\");\n\t\t_;\n\t}\n\n\t/* ========== CONSTRUCTOR ========== */\n\n\tconstructor(\n\t\taddress _dei_contract_address,\n\t\taddress _deus_contract_address,\n\t\taddress _collateral_address,\n\t\taddress _trusty_address,\n\t\taddress _admin_address,\n\t\tuint256 _pool_ceiling,\n\t\taddress _library\n\t) {\n\t\trequire(\n\t\t\t(_dei_contract_address != address(0)) &&\n\t\t\t\t(_deus_contract_address != address(0)) &&\n\t\t\t\t(_collateral_address != address(0)) &&\n\t\t\t\t(_trusty_address != address(0)) &&\n\t\t\t\t(_admin_address != address(0)) &&\n\t\t\t\t(_library != address(0)),\n\t\t\t\"POOL::Zero address detected\"\n\t\t);\n\t\tpoolLibrary = DEIPoolLibrary(_library);\n\t\tdei_contract_address = _dei_contract_address;\n\t\tdeus_contract_address = _deus_contract_address;\n\t\tcollateral_address = _collateral_address;\n\t\tcollateral_token = ERC20(_collateral_address);\n\t\tpool_ceiling = _pool_ceiling;\n\t\tmissing_decimals = uint256(18) - collateral_token.decimals();\n\n\t\t_setupRole(DEFAULT_ADMIN_ROLE, _admin_address);\n\t\t_setupRole(MINT_PAUSER, _trusty_address);\n\t\t_setupRole(REDEEM_PAUSER, _trusty_address);\n\t\t_setupRole(RECOLLATERALIZE_PAUSER, _trusty_address);\n\t\t_setupRole(BUYBACK_PAUSER, _trusty_address);\n _setupRole(TRUSTY_ROLE, _trusty_address);\n _setupRole(TRUSTY_ROLE, _trusty_address);\n _setupRole(PARAMETER_SETTER_ROLE, _trusty_address);\n\t}\n\n\t/* ========== VIEWS ========== */\n\n\t// Returns dollar value of collateral held in this DEI pool\n\tfunction collatDollarBalance(uint256 collat_usd_price) public view returns (uint256) {\n\t\treturn ((collateral_token.balanceOf(address(this)) - unclaimedPoolCollateral) * (10**missing_decimals) * collat_usd_price) / (PRICE_PRECISION);\n\t}\n\n\t// Returns the value of excess collateral held in this DEI pool, compared to what is needed to maintain the global collateral ratio\n\tfunction availableExcessCollatDV(uint256[] memory collat_usd_price) public view returns (uint256) {\n\t\tuint256 total_supply = IDEIStablecoin(dei_contract_address).totalSupply();\n\t\tuint256 global_collateral_ratio = IDEIStablecoin(dei_contract_address).global_collateral_ratio();\n\t\tuint256 global_collat_value = IDEIStablecoin(dei_contract_address).globalCollateralValue(collat_usd_price);\n\n\t\tif (global_collateral_ratio > COLLATERAL_RATIO_PRECISION)\n\t\t\tglobal_collateral_ratio = COLLATERAL_RATIO_PRECISION; // Handles an overcollateralized contract with CR > 1\n\t\tuint256 required_collat_dollar_value_d18 = (total_supply * global_collateral_ratio) / (COLLATERAL_RATIO_PRECISION); // Calculates collateral needed to back each 1 DEI with $1 of collateral at current collat ratio\n\t\tif (global_collat_value > required_collat_dollar_value_d18)\n\t\t\treturn global_collat_value - required_collat_dollar_value_d18;\n\t\telse return 0;\n\t}\n\n\tfunction getChainID() public view returns (uint256) {\n uint256 id;\n assembly {\n id := chainid()\n }\n return id;\n }\n\n\t/* ========== PUBLIC FUNCTIONS ========== */\n\n\t// We separate out the 1t1, fractional and algorithmic minting functions for gas efficiency\n\tfunction mint1t1DEI(uint256 collateral_amount, uint256 collateral_price, uint256 expireBlock, bytes[] calldata sigs)\n\t\texternal\n\t\tnotMintPaused\n\t\treturns (uint256 dei_amount_d18)\n\t{\n\n\t\trequire(\n\t\t\tIDEIStablecoin(dei_contract_address).global_collateral_ratio() >= COLLATERAL_RATIO_MAX,\n\t\t\t\"Collateral ratio must be >= 1\"\n\t\t);\n\t\trequire(\n\t\t\tcollateral_token.balanceOf(address(this)) - unclaimedPoolCollateral + collateral_amount <= pool_ceiling,\n\t\t\t\"[Pool's Closed]: Ceiling reached\"\n\t\t);\n\n\t\trequire(expireBlock >= block.number, \"POOL::mint1t1DEI: signature is expired\");\n bytes32 sighash = keccak256(abi.encodePacked(collateral_address, collateral_price, expireBlock, getChainID()));\n\t\trequire(IDEIStablecoin(dei_contract_address).verify_price(sighash, sigs), \"POOL::mint1t1DEI: invalid signatures\");\n\n\t\tuint256 collateral_amount_d18 = collateral_amount * (10**missing_decimals);\n\t\tdei_amount_d18 = poolLibrary.calcMint1t1DEI(\n\t\t\tcollateral_price,\n\t\t\tcollateral_amount_d18\n\t\t); //1 DEI for each $1 worth of collateral\n\n\t\tdei_amount_d18 = (dei_amount_d18 * (uint256(1e6) - minting_fee)) / 1e6; //remove precision at the end\n\n\t\tTransferHelper.safeTransferFrom(\n\t\t\taddress(collateral_token),\n\t\t\tmsg.sender,\n\t\t\taddress(this),\n\t\t\tcollateral_amount\n\t\t);\n\n\t\tdaoShare += dei_amount_d18 * minting_fee / 1e6;\n\t\tIDEIStablecoin(dei_contract_address).pool_mint(msg.sender, dei_amount_d18);\n\t}\n\n\t// 0% collateral-backed\n\tfunction mintAlgorithmicDEI(\n\t\tuint256 deus_amount_d18,\n\t\tuint256 deus_current_price,\n\t\tuint256 expireBlock,\n\t\tbytes[] calldata sigs\n\t) external notMintPaused returns (uint256 dei_amount_d18) {\n\t\trequire(\n\t\t\tIDEIStablecoin(dei_contract_address).global_collateral_ratio() == 0,\n\t\t\t\"Collateral ratio must be 0\"\n\t\t);\n\t\trequire(expireBlock >= block.number, \"POOL::mintAlgorithmicDEI: signature is expired.\");\n\t\tbytes32 sighash = keccak256(abi.encodePacked(deus_contract_address, deus_current_price, expireBlock, getChainID()));\n\t\trequire(IDEIStablecoin(dei_contract_address).verify_price(sighash, sigs), \"POOL::mintAlgorithmicDEI: invalid signatures\");\n\n\t\tdei_amount_d18 = poolLibrary.calcMintAlgorithmicDEI(\n\t\t\tdeus_current_price, // X DEUS / 1 USD\n\t\t\tdeus_amount_d18\n\t\t);\n\n\t\tdei_amount_d18 = (dei_amount_d18 * (uint256(1e6) - (minting_fee))) / (1e6);\n\t\tdaoShare += dei_amount_d18 * minting_fee / 1e6;\n\n\t\tIDEUSToken(deus_contract_address).pool_burn_from(msg.sender, deus_amount_d18);\n\t\tIDEIStablecoin(dei_contract_address).pool_mint(msg.sender, dei_amount_d18);\n\t}\n\n\t// Will fail if fully collateralized or fully algorithmic\n\t// > 0% and < 100% collateral-backed\n\tfunction mintFractionalDEI(\n\t\tuint256 collateral_amount,\n\t\tuint256 deus_amount,\n\t\tuint256 collateral_price,\n\t\tuint256 deus_current_price,\n\t\tuint256 expireBlock,\n\t\tbytes[] calldata sigs\n\t) external notMintPaused returns (uint256 mint_amount) {\n\t\tuint256 global_collateral_ratio = IDEIStablecoin(dei_contract_address).global_collateral_ratio();\n\t\trequire(\n\t\t\tglobal_collateral_ratio < COLLATERAL_RATIO_MAX && global_collateral_ratio > 0,\n\t\t\t\"Collateral ratio needs to be between .000001 and .999999\"\n\t\t);\n\t\trequire(\n\t\t\tcollateral_token.balanceOf(address(this)) - unclaimedPoolCollateral + collateral_amount <= pool_ceiling,\n\t\t\t\"Pool ceiling reached, no more DEI can be minted with this collateral\"\n\t\t);\n\n\t\trequire(expireBlock >= block.number, \"POOL::mintFractionalDEI: signature is expired.\");\n\t\tbytes32 sighash = keccak256(abi.encodePacked(collateral_address, collateral_price, deus_contract_address, deus_current_price, expireBlock, getChainID()));\n\t\trequire(IDEIStablecoin(dei_contract_address).verify_price(sighash, sigs), \"POOL::mintFractionalDEI: invalid signatures\");\n\n\t\tDEIPoolLibrary.MintFD_Params memory input_params;\n\n\t\t// Blocking is just for solving stack depth problem\n\t\t{\n\t\t\tuint256 collateral_amount_d18 = collateral_amount * (10**missing_decimals);\n\t\t\tinput_params = DEIPoolLibrary.MintFD_Params(\n\t\t\t\t\t\t\t\t\t\t\tdeus_current_price,\n\t\t\t\t\t\t\t\t\t\t\tcollateral_price,\n\t\t\t\t\t\t\t\t\t\t\tcollateral_amount_d18,\n\t\t\t\t\t\t\t\t\t\t\tglobal_collateral_ratio\n\t\t\t\t\t\t\t\t\t\t);\n\t\t}\t\t\t\t\t\t\n\n\t\tuint256 deus_needed;\n\t\t(mint_amount, deus_needed) = poolLibrary.calcMintFractionalDEI(input_params);\n\t\trequire(deus_needed <= deus_amount, \"Not enough DEUS inputted\");\n\t\t\n\t\tmint_amount = (mint_amount * (uint256(1e6) - minting_fee)) / (1e6);\n\n\t\tIDEUSToken(deus_contract_address).pool_burn_from(msg.sender, deus_needed);\n\t\tTransferHelper.safeTransferFrom(\n\t\t\taddress(collateral_token),\n\t\t\tmsg.sender,\n\t\t\taddress(this),\n\t\t\tcollateral_amount\n\t\t);\n\n\t\tdaoShare += mint_amount * minting_fee / 1e6;\n\t\tIDEIStablecoin(dei_contract_address).pool_mint(msg.sender, mint_amount);\n\t}\n\n\t// Redeem collateral. 100% collateral-backed\n\tfunction redeem1t1DEI(uint256 DEI_amount, uint256 collateral_price, uint256 expireBlock, bytes[] calldata sigs)\n\t\texternal\n\t\tnotRedeemPaused\n\t{\n\t\trequire(\n\t\t\tIDEIStablecoin(dei_contract_address).global_collateral_ratio() == COLLATERAL_RATIO_MAX,\n\t\t\t\"Collateral ratio must be == 1\"\n\t\t);\n\n\t\trequire(expireBlock >= block.number, \"POOL::mintAlgorithmicDEI: signature is expired.\");\n bytes32 sighash = keccak256(abi.encodePacked(collateral_address, collateral_price, expireBlock, getChainID()));\n\t\trequire(IDEIStablecoin(dei_contract_address).verify_price(sighash, sigs), \"POOL::redeem1t1DEI: invalid signatures\");\n\n\t\t// Need to adjust for decimals of collateral\n\t\tuint256 DEI_amount_precision = DEI_amount / (10**missing_decimals);\n\t\tuint256 collateral_needed = poolLibrary.calcRedeem1t1DEI(\n\t\t\tcollateral_price,\n\t\t\tDEI_amount_precision\n\t\t);\n\n\t\tcollateral_needed = (collateral_needed * (uint256(1e6) - redemption_fee)) / (1e6);\n\t\trequire(\n\t\t\tcollateral_needed <= collateral_token.balanceOf(address(this)) - unclaimedPoolCollateral,\n\t\t\t\"Not enough collateral in pool\"\n\t\t);\n\n\t\tredeemCollateralBalances[msg.sender] = redeemCollateralBalances[msg.sender] + collateral_needed;\n\t\tunclaimedPoolCollateral = unclaimedPoolCollateral + collateral_needed;\n\t\tlastRedeemed[msg.sender] = block.number;\n\n\t\tdaoShare += DEI_amount * redemption_fee / 1e6;\n\t\t// Move all external functions to the end\n\t\tIDEIStablecoin(dei_contract_address).pool_burn_from(msg.sender, DEI_amount);\n\t}\n\n\t// Will fail if fully collateralized or algorithmic\n\t// Redeem DEI for collateral and DEUS. > 0% and < 100% collateral-backed\n\tfunction redeemFractionalDEI(\n\t\tuint256 DEI_amount,\n\t\tuint256 collateral_price, \n\t\tuint256 deus_current_price,\n\t\tuint256 expireBlock,\n\t\tbytes[] calldata sigs\n\t) external notRedeemPaused {\n\t\tuint256 global_collateral_ratio = IDEIStablecoin(dei_contract_address).global_collateral_ratio();\n\t\trequire(\n\t\t\tglobal_collateral_ratio < COLLATERAL_RATIO_MAX && global_collateral_ratio > 0,\n\t\t\t\"POOL::redeemFractionalDEI: Collateral ratio needs to be between .000001 and .999999\"\n\t\t);\n\n\t\trequire(expireBlock >= block.number, \"DEI::redeemFractionalDEI: signature is expired\");\n\t\tbytes32 sighash = keccak256(abi.encodePacked(collateral_address, collateral_price, deus_contract_address, deus_current_price, expireBlock, getChainID()));\n\t\trequire(IDEIStablecoin(dei_contract_address).verify_price(sighash, sigs), \"POOL::redeemFractionalDEI: invalid signatures\");\n\n\t\t// Blocking is just for solving stack depth problem\n\t\tuint256 deus_amount;\n\t\tuint256 collateral_amount;\n\t\t{\n\t\t\tuint256 col_price_usd = collateral_price;\n\n\t\t\tuint256 DEI_amount_post_fee = (DEI_amount * (uint256(1e6) - redemption_fee)) / (PRICE_PRECISION);\n\n\t\t\tuint256 deus_dollar_value_d18 = DEI_amount_post_fee - ((DEI_amount_post_fee * global_collateral_ratio) / (PRICE_PRECISION));\n\t\t\tdeus_amount = deus_dollar_value_d18 * (PRICE_PRECISION) / (deus_current_price);\n\n\t\t\t// Need to adjust for decimals of collateral\n\t\t\tuint256 DEI_amount_precision = DEI_amount_post_fee / (10**missing_decimals);\n\t\t\tuint256 collateral_dollar_value = (DEI_amount_precision * global_collateral_ratio) / PRICE_PRECISION;\n\t\t\tcollateral_amount = (collateral_dollar_value * PRICE_PRECISION) / (col_price_usd);\n\t\t}\n\t\trequire(\n\t\t\tcollateral_amount <= collateral_token.balanceOf(address(this)) - unclaimedPoolCollateral,\n\t\t\t\"Not enough collateral in pool\"\n\t\t);\n\n\t\tredeemCollateralBalances[msg.sender] = redeemCollateralBalances[msg.sender] + collateral_amount;\n\t\tunclaimedPoolCollateral = unclaimedPoolCollateral + collateral_amount;\n\n\t\tredeemDEUSBalances[msg.sender] = redeemDEUSBalances[msg.sender] + deus_amount;\n\t\tunclaimedPoolDEUS = unclaimedPoolDEUS + deus_amount;\n\n\t\tlastRedeemed[msg.sender] = block.number;\n\n\t\tdaoShare += DEI_amount * redemption_fee / 1e6;\n\t\t// Move all external functions to the end\n\t\tIDEIStablecoin(dei_contract_address).pool_burn_from(msg.sender, DEI_amount);\n\t\tIDEUSToken(deus_contract_address).pool_mint(address(this), deus_amount);\n\t}\n\n\t// Redeem DEI for DEUS. 0% collateral-backed\n\tfunction redeemAlgorithmicDEI(\n\t\tuint256 DEI_amount,\n\t\tuint256 deus_current_price,\n\t\tuint256 expireBlock,\n\t\tbytes[] calldata sigs\n\t) external notRedeemPaused {\n\t\trequire(IDEIStablecoin(dei_contract_address).global_collateral_ratio() == 0, \"POOL::redeemAlgorithmicDEI: Collateral ratio must be 0\");\n\n\t\trequire(expireBlock >= block.number, \"DEI::redeemAlgorithmicDEI: signature is expired.\");\n\t\tbytes32 sighash = keccak256(abi.encodePacked(deus_contract_address, deus_current_price, expireBlock, getChainID()));\n\t\trequire(IDEIStablecoin(dei_contract_address).verify_price(sighash, sigs), \"POOL::redeemAlgorithmicDEI: invalid signatures\");\n\n\t\tuint256 deus_dollar_value_d18 = DEI_amount;\n\n\t\tdeus_dollar_value_d18 = (deus_dollar_value_d18 * (uint256(1e6) - redemption_fee)) / 1e6; //apply fees\n\n\t\tuint256 deus_amount = (deus_dollar_value_d18 * (PRICE_PRECISION)) / deus_current_price;\n\n\t\tredeemDEUSBalances[msg.sender] = redeemDEUSBalances[msg.sender] + deus_amount;\n\t\tunclaimedPoolDEUS = unclaimedPoolDEUS + deus_amount;\n\n\t\tlastRedeemed[msg.sender] = block.number;\n\n\t\tdaoShare += DEI_amount * redemption_fee / 1e6;\n\t\t// Move all external functions to the end\n\t\tIDEIStablecoin(dei_contract_address).pool_burn_from(msg.sender, DEI_amount);\n\t\tIDEUSToken(deus_contract_address).pool_mint(address(this), deus_amount);\n\t}\n\n\t// After a redemption happens, transfer the newly minted DEUS and owed collateral from this pool\n\t// contract to the user. Redemption is split into two functions to prevent flash loans from being able\n\t// to take out DEI/collateral from the system, use an AMM to trade the new price, and then mint back into the system.\n\tfunction collectRedemption() external {\n\t\trequire(\n\t\t\t(lastRedeemed[msg.sender] + redemption_delay) <= block.number,\n\t\t\t\"POOL::collectRedemption: Must wait for redemption_delay blocks before collecting redemption\"\n\t\t);\n\t\tbool sendDEUS = false;\n\t\tbool sendCollateral = false;\n\t\tuint256 DEUSAmount = 0;\n\t\tuint256 CollateralAmount = 0;\n\n\t\t// Use Checks-Effects-Interactions pattern\n\t\tif (redeemDEUSBalances[msg.sender] > 0) {\n\t\t\tDEUSAmount = redeemDEUSBalances[msg.sender];\n\t\t\tredeemDEUSBalances[msg.sender] = 0;\n\t\t\tunclaimedPoolDEUS = unclaimedPoolDEUS - DEUSAmount;\n\n\t\t\tsendDEUS = true;\n\t\t}\n\n\t\tif (redeemCollateralBalances[msg.sender] > 0) {\n\t\t\tCollateralAmount = redeemCollateralBalances[msg.sender];\n\t\t\tredeemCollateralBalances[msg.sender] = 0;\n\t\t\tunclaimedPoolCollateral = unclaimedPoolCollateral - CollateralAmount;\n\t\t\tsendCollateral = true;\n\t\t}\n\n\t\tif (sendDEUS) {\n\t\t\tTransferHelper.safeTransfer(address(deus_contract_address), msg.sender, DEUSAmount);\n\t\t}\n\t\tif (sendCollateral) {\n\t\t\tTransferHelper.safeTransfer(\n\t\t\t\taddress(collateral_token),\n\t\t\t\tmsg.sender,\n\t\t\t\tCollateralAmount\n\t\t\t);\n\t\t}\n\t}\n\n\t// When the protocol is recollateralizing, we need to give a discount of DEUS to hit the new CR target\n\t// Thus, if the target collateral ratio is higher than the actual value of collateral, minters get DEUS for adding collateral\n\t// This function simply rewards anyone that sends collateral to a pool with the same amount of DEUS + the bonus rate\n\t// Anyone can call this function to recollateralize the protocol and take the extra DEUS value from the bonus rate as an arb opportunity\n\tfunction recollateralizeDEI(RecollateralizeDEI memory inputs) external {\n\t\trequire(recollateralizePaused == false, \"POOL::recollateralizeDEI: Recollateralize is paused\");\n\n\t\trequire(inputs.expireBlock >= block.number, \"POOL::recollateralizeDEI: signature is expired.\");\n\t\tbytes32 sighash = keccak256(abi.encodePacked(\n collateral_address, \n inputs.collateral_price,\n deus_contract_address, \n inputs.deus_current_price, \n inputs.expireBlock,\n\t\t\t\t\t\t\t\t\t\tgetChainID()\n ));\n\t\trequire(IDEIStablecoin(dei_contract_address).verify_price(sighash, inputs.sigs), \"POOL::recollateralizeDEI: invalid signatures\");\n\n\t\tuint256 collateral_amount_d18 = inputs.collateral_amount * (10**missing_decimals);\n\n\t\tuint256 dei_total_supply = IDEIStablecoin(dei_contract_address).totalSupply();\n\t\tuint256 global_collateral_ratio = IDEIStablecoin(dei_contract_address).global_collateral_ratio();\n\t\tuint256 global_collat_value = IDEIStablecoin(dei_contract_address).globalCollateralValue(inputs.collateral_price);\n\n\t\t(uint256 collateral_units, uint256 amount_to_recollat) = poolLibrary.calcRecollateralizeDEIInner(\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\tcollateral_amount_d18,\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\tinputs.collateral_price[inputs.collateral_price.length - 1], // pool collateral price exist in last index\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\tglobal_collat_value,\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\tdei_total_supply,\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\tglobal_collateral_ratio\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t);\n\n\t\tuint256 collateral_units_precision = collateral_units / (10**missing_decimals);\n\n\t\tuint256 deus_paid_back = (amount_to_recollat * (uint256(1e6) + bonus_rate - recollat_fee)) / inputs.deus_current_price;\n\n\t\tTransferHelper.safeTransferFrom(\n\t\t\taddress(collateral_token),\n\t\t\tmsg.sender,\n\t\t\taddress(this),\n\t\t\tcollateral_units_precision\n\t\t);\n\t\tIDEUSToken(deus_contract_address).pool_mint(msg.sender, deus_paid_back);\n\t}\n\n\t// Function can be called by an DEUS holder to have the protocol buy back DEUS with excess collateral value from a desired collateral pool\n\t// This can also happen if the collateral ratio > 1\n\tfunction buyBackDEUS(\n\t\tuint256 DEUS_amount,\n\t\tuint256[] memory collateral_price,\n\t\tuint256 deus_current_price,\n\t\tuint256 expireBlock,\n\t\tbytes[] calldata sigs\n\t) external {\n\t\trequire(buyBackPaused == false, \"POOL::buyBackDEUS: Buyback is paused\");\n\t\trequire(expireBlock >= block.number, \"DEI::buyBackDEUS: signature is expired.\");\n\t\tbytes32 sighash = keccak256(abi.encodePacked(\n\t\t\t\t\t\t\t\t\t\tcollateral_address,\n\t\t\t\t\t\t\t\t\t\tcollateral_price,\n\t\t\t\t\t\t\t\t\t\tdeus_contract_address,\n\t\t\t\t\t\t\t\t\t\tdeus_current_price,\n\t\t\t\t\t\t\t\t\t\texpireBlock,\n\t\t\t\t\t\t\t\t\t\tgetChainID()));\n\t\trequire(IDEIStablecoin(dei_contract_address).verify_price(sighash, sigs), \"POOL::buyBackDEUS: invalid signatures\");\n\n\t\tDEIPoolLibrary.BuybackDEUS_Params memory input_params = DEIPoolLibrary.BuybackDEUS_Params(\n\t\t\t\t\t\t\t\t\t\t\t\t\tavailableExcessCollatDV(collateral_price),\n\t\t\t\t\t\t\t\t\t\t\t\t\tdeus_current_price,\n\t\t\t\t\t\t\t\t\t\t\t\t\tcollateral_price[collateral_price.length - 1], // pool collateral price exist in last index\n\t\t\t\t\t\t\t\t\t\t\t\t\tDEUS_amount\n\t\t\t\t\t\t\t\t\t\t\t\t);\n\n\t\tuint256 collateral_equivalent_d18 = (poolLibrary.calcBuyBackDEUS(input_params) * (uint256(1e6) - buyback_fee)) / (1e6);\n\t\tuint256 collateral_precision = collateral_equivalent_d18 / (10**missing_decimals);\n\n\t\t// Give the sender their desired collateral and burn the DEUS\n\t\tIDEUSToken(deus_contract_address).pool_burn_from(msg.sender, DEUS_amount);\n\t\tTransferHelper.safeTransfer(\n\t\t\taddress(collateral_token),\n\t\t\tmsg.sender,\n\t\t\tcollateral_precision\n\t\t);\n\t}\n\n\t/* ========== RESTRICTED FUNCTIONS ========== */\n\n\tfunction collectDaoShare(uint256 amount, address to) external {\n\t\trequire(hasRole(DAO_SHARE_COLLECTOR, msg.sender));\n\t\trequire(amount <= daoShare, \"amount<=daoShare\");\n\t\tIDEIStablecoin(dei_contract_address).pool_mint(to, amount);\n\t\tdaoShare -= amount;\n\n\t\temit daoShareCollected(amount, to);\n\t}\n\n\tfunction emergencyWithdrawERC20(address token, uint amount, address to) external onlyByTrusty {\n\t\tIERC20(token).transfer(to, amount);\n\t}\n\n\tfunction toggleMinting() external {\n\t\trequire(hasRole(MINT_PAUSER, msg.sender));\n\t\tmintPaused = !mintPaused;\n\n\t\temit MintingToggled(mintPaused);\n\t}\n\n\tfunction toggleRedeeming() external {\n\t\trequire(hasRole(REDEEM_PAUSER, msg.sender));\n\t\tredeemPaused = !redeemPaused;\n\n\t\temit RedeemingToggled(redeemPaused);\n\t}\n\n\tfunction toggleRecollateralize() external {\n\t\trequire(hasRole(RECOLLATERALIZE_PAUSER, msg.sender));\n\t\trecollateralizePaused = !recollateralizePaused;\n\n\t\temit RecollateralizeToggled(recollateralizePaused);\n\t}\n\n\tfunction toggleBuyBack() external {\n\t\trequire(hasRole(BUYBACK_PAUSER, msg.sender));\n\t\tbuyBackPaused = !buyBackPaused;\n\n\t\temit BuybackToggled(buyBackPaused);\n\t}\n\n\t// Combined into one function due to 24KiB contract memory limit\n\tfunction setPoolParameters(\n\t\tuint256 new_ceiling,\n\t\tuint256 new_bonus_rate,\n\t\tuint256 new_redemption_delay,\n\t\tuint256 new_mint_fee,\n\t\tuint256 new_redeem_fee,\n\t\tuint256 new_buyback_fee,\n\t\tuint256 new_recollat_fee\n\t) external {\n\t\trequire(hasRole(PARAMETER_SETTER_ROLE, msg.sender), \"POOL: Caller is not PARAMETER_SETTER_ROLE\");\n\t\tpool_ceiling = new_ceiling;\n\t\tbonus_rate = new_bonus_rate;\n\t\tredemption_delay = new_redemption_delay;\n\t\tminting_fee = new_mint_fee;\n\t\tredemption_fee = new_redeem_fee;\n\t\tbuyback_fee = new_buyback_fee;\n\t\trecollat_fee = new_recollat_fee;\n\n\t\temit PoolParametersSet(\n\t\t\tnew_ceiling,\n\t\t\tnew_bonus_rate,\n\t\t\tnew_redemption_delay,\n\t\t\tnew_mint_fee,\n\t\t\tnew_redeem_fee,\n\t\t\tnew_buyback_fee,\n\t\t\tnew_recollat_fee\n\t\t);\n\t}\n\n\t/* ========== EVENTS ========== */\n\n\tevent PoolParametersSet(\n\t\tuint256 new_ceiling,\n\t\tuint256 new_bonus_rate,\n\t\tuint256 new_redemption_delay,\n\t\tuint256 new_mint_fee,\n\t\tuint256 new_redeem_fee,\n\t\tuint256 new_buyback_fee,\n\t\tuint256 new_recollat_fee\n\t);\n\tevent daoShareCollected(uint256 daoShare, address to);\n\tevent MintingToggled(bool toggled);\n\tevent RedeemingToggled(bool toggled);\n\tevent RecollateralizeToggled(bool toggled);\n\tevent BuybackToggled(bool toggled);\n}\n\n//Dar panah khoda" }, "contracts/Oracle/Oracle.sol": { "content": "// Be name Khoda\n// Bime Abolfazl\n\npragma solidity >=0.6.12;\n\nimport \"../Governance/AccessControl.sol\";\nimport \"@openzeppelin/contracts/utils/cryptography/ECDSA.sol\";\n\ncontract Oracle is AccessControl {\n\tusing ECDSA for bytes32;\n\n\t// role\n\tbytes32 public constant ORACLE_ROLE = keccak256(\"ORACLE_ROLE\");\n\tbytes32 public constant TRUSTY_ROLE = keccak256(\"TRUSTY_ROLE\");\n\n\tuint256 minimumRequiredSignature;\n\n\tevent MinimumRequiredSignatureSet(uint256 minimumRequiredSignature);\n\n\tconstructor(address _admin, uint256 _minimumRequiredSignature, address _trusty_address) {\n\t\trequire(_admin != address(0), \"ORACLE::constructor: Zero address detected\");\n\t\t_setupRole(DEFAULT_ADMIN_ROLE, _admin);\n\t\t_setupRole(TRUSTY_ROLE, _trusty_address);\n\t\tminimumRequiredSignature = _minimumRequiredSignature;\n\t}\n\n\tfunction verify(bytes32 hash, bytes[] calldata sigs)\n\t\tpublic\n\t\tview\n\t\treturns (bool)\n\t{\n\t\taddress lastOracle;\n\t\tfor (uint256 index = 0; index < minimumRequiredSignature; ++index) {\n\t\t\taddress oracle = hash.recover(sigs[index]);\n\t\t\trequire(hasRole(ORACLE_ROLE, oracle), \"ORACLE::verify: Signer is not valid\");\n\t\t\trequire(oracle > lastOracle, \"ORACLE::verify: Signers are same\");\n\t\t\tlastOracle = oracle;\n\t\t}\n\t\treturn true;\n\t}\n\n\tfunction setMinimumRequiredSignature(uint256 _minimumRequiredSignature)\n\t\tpublic\n\t{\n\t\trequire(\n\t\t\thasRole(TRUSTY_ROLE, msg.sender),\n\t\t\t\"ORACLE::setMinimumRequiredSignature: You are not a setter\"\n\t\t);\n\t\tminimumRequiredSignature = _minimumRequiredSignature;\n\n\t\temit MinimumRequiredSignatureSet(_minimumRequiredSignature);\n\t}\n}\n\n//Dar panah khoda" }, "contracts/Oracle/ReserveTracker.sol": { "content": "// Be name Khoda\n// Bime Abolfazl\n\n// SPDX-License-Identifier: GPL-2.0-or-later\npragma solidity ^0.8.7;\n\n// =================================================================================================================\n// _|_|_| _|_|_|_| _| _| _|_|_| _|_|_|_| _| |\n// _| _| _| _| _| _| _| _|_|_| _|_|_| _|_|_| _|_|_| _|_| |\n// _| _| _|_|_| _| _| _|_| _|_|_| _| _| _| _| _| _| _| _| _|_|_|_| |\n// _| _| _| _| _| _| _| _| _| _| _| _| _| _| _| _| |\n// _|_|_| _|_|_|_| _|_| _|_|_| _| _| _| _| _|_|_| _| _| _|_|_| _|_|_| | \n// =================================================================================================================\n// ====================================================================\n// =========================== ReserveTracker =========================\n// ====================================================================\n// Deus Finance: https://github.com/DeusFinance\n\n// Primary Author(s)\n// Jason Huan: https://github.com/jasonhuan\n// Sam Kazemian: https://github.com/samkazemian\n// Vahid: https://github.com/vahid-dev\n// SAYaghoubnejad: https://github.com/SAYaghoubnejad\n\n// Reviewer(s) / Contributor(s)\n// Travis Moore: https://github.com/FortisFortuna\n\nimport \"../Math/SafeMath.sol\";\nimport \"../Math/Math.sol\";\nimport \"../Uniswap/Interfaces/IUniswapV2Pair.sol\";\nimport \"../Governance/AccessControl.sol\";\n\ncontract ReserveTracker is AccessControl {\n\n\t// Roles\n bytes32 public constant OWNER_ROLE = keccak256(\"OWNER_ROLE\");\n\n\t// Various precisions\n\tuint256 private PRICE_PRECISION = 1e6;\n\n\t// Contract addresses\n\taddress private dei_contract_address;\n\taddress private deus_contract_address;\n\n\t// Array of pairs for DEUS\n\taddress[] public deus_pairs_array;\n\n\t// Mapping is also used for faster verification\n\tmapping(address => bool) public deus_pairs;\n\n\tuint256 public deus_reserves;\n\n\t// ========== MODIFIERS ==========\n\n\tmodifier onlyByOwnerOrGovernance() {\n\t\trequire(hasRole(OWNER_ROLE, msg.sender), \"Caller is not owner\");\n\t\t_;\n\t}\n\n\t// ========== CONSTRUCTOR ==========\n\n\tconstructor(\n\t\taddress _dei_contract_address,\n\t\taddress _deus_contract_address\n\t) {\n\t\tdei_contract_address = _dei_contract_address;\n\t\tdeus_contract_address = _deus_contract_address;\n\t\t_setupRole(DEFAULT_ADMIN_ROLE, msg.sender);\n\t\t_setupRole(OWNER_ROLE, msg.sender);\n\t}\n\n\t// ========== VIEWS ==========\n\n\tfunction getDEUSReserves() public view returns (uint256) {\n\t\tuint256 total_deus_reserves = 0;\n\n\t\tfor (uint i = 0; i < deus_pairs_array.length; i++){ \n\t\t\t// Exclude null addresses\n\t\t\tif (deus_pairs_array[i] != address(0)){\n\t\t\t\tif(IUniswapV2Pair(deus_pairs_array[i]).token0() == deus_contract_address) {\n\t\t\t\t\t(uint reserves0, , ) = IUniswapV2Pair(deus_pairs_array[i]).getReserves();\n\t\t\t\t\ttotal_deus_reserves = total_deus_reserves + reserves0;\n\t\t\t\t} else if (IUniswapV2Pair(deus_pairs_array[i]).token1() == deus_contract_address) {\n\t\t\t\t\t( , uint reserves1, ) = IUniswapV2Pair(deus_pairs_array[i]).getReserves();\n\t\t\t\t\ttotal_deus_reserves = total_deus_reserves + reserves1;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\treturn total_deus_reserves;\n\t}\n\n\t// Adds collateral addresses supported, such as tether and busd, must be ERC20 \n\tfunction addDEUSPair(address pair_address) public onlyByOwnerOrGovernance {\n\t\trequire(deus_pairs[pair_address] == false, \"Address already exists\");\n\t\tdeus_pairs[pair_address] = true; \n\t\tdeus_pairs_array.push(pair_address);\n\t}\n\n\t// Remove a pool \n\tfunction removeDEUSPair(address pair_address) public onlyByOwnerOrGovernance {\n\t\trequire(deus_pairs[pair_address] == true, \"Address nonexistant\");\n\t\t\n\t\t// Delete from the mapping\n\t\tdelete deus_pairs[pair_address];\n\n\t\t// 'Delete' from the array by setting the address to 0x0\n\t\tfor (uint i = 0; i < deus_pairs_array.length; i++){ \n\t\t\tif (deus_pairs_array[i] == pair_address) {\n\t\t\t\tdeus_pairs_array[i] = address(0); // This will leave a null in the array and keep the indices the same\n\t\t\t\tbreak;\n\t\t\t}\n\t\t}\n\t}\n}\n\n//Dar panah khoda" }, "@openzeppelin/contracts/utils/cryptography/ECDSA.sol": { "content": "// SPDX-License-Identifier: MIT\n\npragma solidity ^0.8.0;\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 */\nlibrary ECDSA {\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 * 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 function recover(bytes32 hash, bytes memory signature) internal pure returns (address) {\n // Check the signature length\n // - case 65: r,s,v signature (standard)\n // - case 64: r,vs signature (cf https://eips.ethereum.org/EIPS/eip-2098) _Available since v4.1._\n if (signature.length == 65) {\n bytes32 r;\n bytes32 s;\n uint8 v;\n // ecrecover takes the signature parameters, and the only way to get them\n // currently is to use assembly.\n assembly {\n r := mload(add(signature, 0x20))\n s := mload(add(signature, 0x40))\n v := byte(0, mload(add(signature, 0x60)))\n }\n return recover(hash, v, r, s);\n } else if (signature.length == 64) {\n bytes32 r;\n bytes32 vs;\n // ecrecover takes the signature parameters, and the only way to get them\n // currently is to use assembly.\n assembly {\n r := mload(add(signature, 0x20))\n vs := mload(add(signature, 0x40))\n }\n return recover(hash, r, vs);\n } else {\n revert(\"ECDSA: invalid signature length\");\n }\n }\n\n /**\n * @dev Overload of {ECDSA-recover} that receives the `r` and `vs` short-signature fields separately.\n *\n * See https://eips.ethereum.org/EIPS/eip-2098[EIP-2098 short signatures]\n *\n * _Available since v4.2._\n */\n function recover(\n bytes32 hash,\n bytes32 r,\n bytes32 vs\n ) internal pure returns (address) {\n bytes32 s;\n uint8 v;\n assembly {\n s := and(vs, 0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff)\n v := add(shr(255, vs), 27)\n }\n return recover(hash, v, r, s);\n }\n\n /**\n * @dev Overload of {ECDSA-recover} that receives the `v`, `r` and `s` signature fields separately.\n */\n function recover(\n bytes32 hash,\n uint8 v,\n bytes32 r,\n bytes32 s\n ) internal pure returns (address) {\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 (281): 0 < s < secp256k1n ÷ 2 + 1, and for v in (282): 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 require(\n uint256(s) <= 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF5D576E7357A4501DDFE92F46681B20A0,\n \"ECDSA: invalid signature 's' value\"\n );\n require(v == 27 || v == 28, \"ECDSA: invalid signature 'v' value\");\n\n // If the signature is valid (and not malleable), return the signer address\n address signer = ecrecover(hash, v, r, s);\n require(signer != address(0), \"ECDSA: invalid signature\");\n\n return signer;\n }\n\n /**\n * @dev Returns an Ethereum Signed Message, created from a `hash`. This\n * produces hash corresponding to the one signed with the\n * https://eth.wiki/json-rpc/API#eth_sign[`eth_sign`]\n * JSON-RPC method as part of EIP-191.\n *\n * See {recover}.\n */\n function toEthSignedMessageHash(bytes32 hash) internal pure returns (bytes32) {\n // 32 is the length in bytes of hash,\n // enforced by the type signature above\n return keccak256(abi.encodePacked(\"\\x19Ethereum Signed Message:\\n32\", hash));\n }\n\n /**\n * @dev Returns an Ethereum Signed Typed Data, created from a\n * `domainSeparator` and a `structHash`. This produces hash corresponding\n * to the one signed with the\n * https://eips.ethereum.org/EIPS/eip-712[`eth_signTypedData`]\n * JSON-RPC method as part of EIP-712.\n *\n * See {recover}.\n */\n function toTypedDataHash(bytes32 domainSeparator, bytes32 structHash) internal pure returns (bytes32) {\n return keccak256(abi.encodePacked(\"\\x19\\x01\", domainSeparator, structHash));\n }\n}\n" }, "contracts/Utils/EnumerableSet.sol": { "content": "// SPDX-License-Identifier: MIT\n\npragma solidity >=0.6.11;\n\n/**\n * @dev Library for managing\n * https://en.wikipedia.org/wiki/Set_(abstract_data_type)[sets] of primitive\n * types.\n *\n * Sets have the following properties:\n *\n * - Elements are added, removed, and checked for existence in constant time\n * (O(1)).\n * - Elements are enumerated in O(n). No guarantees are made on the ordering.\n *\n * ```\n * contract Example {\n * // Add the library methods\n * using EnumerableSet for EnumerableSet.AddressSet;\n *\n * // Declare a set state variable\n * EnumerableSet.AddressSet private mySet;\n * }\n * ```\n *\n * As of v3.0.0, only sets of type `address` (`AddressSet`) and `uint256`\n * (`UintSet`) are supported.\n */\nlibrary EnumerableSet {\n // To implement this library for multiple types with as little code\n // repetition as possible, we write it in terms of a generic Set type with\n // bytes32 values.\n // The Set implementation uses private functions, and user-facing\n // implementations (such as AddressSet) are just wrappers around the\n // underlying Set.\n // This means that we can only create new EnumerableSets for types that fit\n // in bytes32.\n\n struct Set {\n // Storage of set values\n bytes32[] _values;\n\n // Position of the value in the `values` array, plus 1 because index 0\n // means a value is not in the set.\n mapping (bytes32 => uint256) _indexes;\n }\n\n /**\n * @dev Add a value to a set. O(1).\n *\n * Returns true if the value was added to the set, that is if it was not\n * already present.\n */\n function _add(Set storage set, bytes32 value) private returns (bool) {\n if (!_contains(set, value)) {\n set._values.push(value);\n // The value is stored at length-1, but we add 1 to all indexes\n // and use 0 as a sentinel value\n set._indexes[value] = set._values.length;\n return true;\n } else {\n return false;\n }\n }\n\n /**\n * @dev Removes a value from a set. O(1).\n *\n * Returns true if the value was removed from the set, that is if it was\n * present.\n */\n function _remove(Set storage set, bytes32 value) private returns (bool) {\n // We read and store the value's index to prevent multiple reads from the same storage slot\n uint256 valueIndex = set._indexes[value];\n\n if (valueIndex != 0) { // Equivalent to contains(set, value)\n // To delete an element from the _values array in O(1), we swap the element to delete with the last one in\n // the array, and then remove the last element (sometimes called as 'swap and pop').\n // This modifies the order of the array, as noted in {at}.\n\n uint256 toDeleteIndex = valueIndex - 1;\n uint256 lastIndex = set._values.length - 1;\n\n // When the value to delete is the last one, the swap operation is unnecessary. However, since this occurs\n // so rarely, we still do the swap anyway to avoid the gas cost of adding an 'if' statement.\n\n bytes32 lastvalue = set._values[lastIndex];\n\n // Move the last value to the index where the value to delete is\n set._values[toDeleteIndex] = lastvalue;\n // Update the index for the moved value\n set._indexes[lastvalue] = toDeleteIndex + 1; // All indexes are 1-based\n\n // Delete the slot where the moved value was stored\n set._values.pop();\n\n // Delete the index for the deleted slot\n delete set._indexes[value];\n\n return true;\n } else {\n return false;\n }\n }\n\n /**\n * @dev Returns true if the value is in the set. O(1).\n */\n function _contains(Set storage set, bytes32 value) private view returns (bool) {\n return set._indexes[value] != 0;\n }\n\n /**\n * @dev Returns the number of values on the set. O(1).\n */\n function _length(Set storage set) private view returns (uint256) {\n return set._values.length;\n }\n\n /**\n * @dev Returns the value stored at position `index` in the set. O(1).\n *\n * Note that there are no guarantees on the ordering of values inside the\n * array, and it may change when more values are added or removed.\n *\n * Requirements:\n *\n * - `index` must be strictly less than {length}.\n */\n function _at(Set storage set, uint256 index) private view returns (bytes32) {\n require(set._values.length > index, \"EnumerableSet: index out of bounds\");\n return set._values[index];\n }\n\n // AddressSet\n\n struct AddressSet {\n Set _inner;\n }\n\n /**\n * @dev Add a value to a set. O(1).\n *\n * Returns true if the value was added to the set, that is if it was not\n * already present.\n */\n function add(AddressSet storage set, address value) internal returns (bool) {\n return _add(set._inner, bytes32(bytes20(value)));\n }\n\n /**\n * @dev Removes a value from a set. O(1).\n *\n * Returns true if the value was removed from the set, that is if it was\n * present.\n */\n function remove(AddressSet storage set, address value) internal returns (bool) {\n return _remove(set._inner, bytes32(bytes20(value)));\n }\n\n /**\n * @dev Returns true if the value is in the set. O(1).\n */\n function contains(AddressSet storage set, address value) internal view returns (bool) {\n return _contains(set._inner, bytes32(bytes20(value)));\n }\n\n /**\n * @dev Returns the number of values in the set. O(1).\n */\n function length(AddressSet storage set) internal view returns (uint256) {\n return _length(set._inner);\n }\n\n /**\n * @dev Returns the value stored at position `index` in the set. O(1).\n *\n * Note that there are no guarantees on the ordering of values inside the\n * array, and it may change when more values are added or removed.\n *\n * Requirements:\n *\n * - `index` must be strictly less than {length}.\n */\n function at(AddressSet storage set, uint256 index) internal view returns (address) {\n return address(bytes20(_at(set._inner, index)));\n }\n\n\n // UintSet\n\n struct UintSet {\n Set _inner;\n }\n\n /**\n * @dev Add a value to a set. O(1).\n *\n * Returns true if the value was added to the set, that is if it was not\n * already present.\n */\n function add(UintSet storage set, uint256 value) internal returns (bool) {\n return _add(set._inner, bytes32(value));\n }\n\n /**\n * @dev Removes a value from a set. O(1).\n *\n * Returns true if the value was removed from the set, that is if it was\n * present.\n */\n function remove(UintSet storage set, uint256 value) internal returns (bool) {\n return _remove(set._inner, bytes32(value));\n }\n\n /**\n * @dev Returns true if the value is in the set. O(1).\n */\n function contains(UintSet storage set, uint256 value) internal view returns (bool) {\n return _contains(set._inner, bytes32(value));\n }\n\n /**\n * @dev Returns the number of values on the set. O(1).\n */\n function length(UintSet storage set) internal view returns (uint256) {\n return _length(set._inner);\n }\n\n /**\n * @dev Returns the value stored at position `index` in the set. O(1).\n *\n * Note that there are no guarantees on the ordering of values inside the\n * array, and it may change when more values are added or removed.\n *\n * Requirements:\n *\n * - `index` must be strictly less than {length}.\n */\n function at(UintSet storage set, uint256 index) internal view returns (uint256) {\n return uint256(_at(set._inner, index));\n }\n}\n" }, "contracts/Uniswap/TransferHelper.sol": { "content": "// SPDX-License-Identifier: MIT\npragma solidity >=0.6.11;\n\n// helper methods for interacting with ERC20 tokens and sending ETH that do not consistently return true/false\nlibrary TransferHelper {\n function safeApprove(address token, address to, uint value) internal {\n // bytes4(keccak256(bytes('approve(address,uint256)')));\n (bool success, bytes memory data) = token.call(abi.encodeWithSelector(0x095ea7b3, to, value));\n require(success && (data.length == 0 || abi.decode(data, (bool))), 'TransferHelper: APPROVE_FAILED');\n }\n\n function safeTransfer(address token, address to, uint value) internal {\n // bytes4(keccak256(bytes('transfer(address,uint256)')));\n (bool success, bytes memory data) = token.call(abi.encodeWithSelector(0xa9059cbb, to, value));\n require(success && (data.length == 0 || abi.decode(data, (bool))), 'TransferHelper: TRANSFER_FAILED');\n }\n\n function safeTransferFrom(address token, address from, address to, uint value) internal {\n // bytes4(keccak256(bytes('transferFrom(address,address,uint256)')));\n (bool success, bytes memory data) = token.call(abi.encodeWithSelector(0x23b872dd, from, to, value));\n require(success && (data.length == 0 || abi.decode(data, (bool))), 'TransferHelper: TRANSFER_FROM_FAILED');\n }\n\n function safeTransferETH(address to, uint value) internal {\n (bool success,) = to.call{value:value}(new bytes(0));\n require(success, 'TransferHelper: ETH_TRANSFER_FAILED');\n }\n}" }, "contracts/DEUS/IDEUS.sol": { "content": "// Be name Khoda\n// Bime Abolfazl\n\n// SPDX-License-Identifier: GPL-2.0-or-later\n\ninterface IDEUSToken {\n function setDEIAddress(address dei_contract_address) external;\n function mint(address to, uint256 amount) external;\n\n // This function is what other dei pools will call to mint new DEUS (similar to the DEI mint)\n function pool_mint(address m_address, uint256 m_amount) external;\n\n // This function is what other dei pools will call to burn DEUS\n function pool_burn_from(address b_address, uint256 b_amount) external;\n\n function toggleVotes() external;\n\n /* ========== OVERRIDDEN PUBLIC FUNCTIONS ========== */\n\n function transfer(address recipient, uint256 amount) external returns (bool);\n\n function transferFrom(\n address sender,\n address recipient,\n uint256 amount\n ) external returns (bool);\n\n /* ========== PUBLIC FUNCTIONS ========== */\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\n /**\n * @notice Determine the prior number of votes for an account as of a block number\n * @dev Block number must be a finalized block or else this function will revert to prevent misinformation.\n * @param account The address of the account to check\n * @param blockNumber The block number to get the vote balance at\n * @return The number of votes the account had as of the given block\n */\n function getPriorVotes(address account, uint256 blockNumber)\n external\n view\n returns (uint96);\n}\n\n//Dar panah khoda" }, "contracts/DEI/IDEI.sol": { "content": "// Be name Khoda\n// Bime Abolfazl\n\n// SPDX-License-Identifier: GPL-2.0-or-later\n\ninterface IDEIStablecoin {\n\n function totalSupply() external view returns (uint256);\n\n function global_collateral_ratio() external view returns (uint256);\n\t\n function verify_price(bytes32 sighash, bytes[] calldata sigs) external view returns (bool);\n\n\tfunction dei_info(uint256 eth_usd_price, uint256 eth_collat_price)\n\t\texternal\n\t\tview\n\t\treturns (\n\t\t\tuint256,\n\t\t\tuint256,\n\t\t\tuint256\n\t\t);\n\n\tfunction globalCollateralValue(uint256[] memory collat_usd_price) external view returns (uint256);\n\n\tfunction refreshCollateralRatio(uint256 dei_price_cur, uint256 expireBlock, bytes[] calldata sigs) external;\n\n\tfunction pool_burn_from(address b_address, uint256 b_amount) external;\n\n\tfunction pool_mint(address m_address, uint256 m_amount) external;\n\n\tfunction addPool(address pool_address) external;\n\n\tfunction removePool(address pool_address) external;\n\n\tfunction setDEIStep(uint256 _new_step) external;\n\n\tfunction setPriceTarget(uint256 _new_price_target) external;\n\n\tfunction setRefreshCooldown(uint256 _new_cooldown) external;\n\n\tfunction setDEUSAddress(address _deus_address) external;\n\n\tfunction setPriceBand(uint256 _price_band) external;\n\t\n function toggleCollateralRatio() external;\n}\n\n//Dar panah khoda" }, "contracts/DEI/Pools/DEIPoolLibrary.sol": { "content": "// Be name Khoda\n// Bime Abolfazl\n\n// SPDX-License-Identifier: GPL-2.0-or-later\npragma solidity >=0.8.0;\n\ncontract DEIPoolLibrary {\n\n // Constants for various precisions\n uint256 private constant PRICE_PRECISION = 1e6;\n\n constructor() {}\n\n // ================ Structs ================\n // Needed to lower stack size\n struct MintFD_Params {\n uint256 deus_price_usd; \n uint256 col_price_usd;\n uint256 collateral_amount;\n uint256 col_ratio;\n }\n\n struct BuybackDEUS_Params {\n uint256 excess_collateral_dollar_value_d18;\n uint256 deus_price_usd;\n uint256 col_price_usd;\n uint256 DEUS_amount;\n }\n\n // ================ Functions ================\n\n function calcMint1t1DEI(uint256 col_price, uint256 collateral_amount_d18) public pure returns (uint256) {\n return (collateral_amount_d18 * col_price) / (1e6);\n }\n\n function calcMintAlgorithmicDEI(uint256 deus_price_usd, uint256 deus_amount_d18) public pure returns (uint256) {\n return (deus_amount_d18 * deus_price_usd) / (1e6);\n }\n\n // Must be internal because of the struct\n function calcMintFractionalDEI(MintFD_Params memory params) public pure returns (uint256, uint256) {\n // Since solidity truncates division, every division operation must be the last operation in the equation to ensure minimum error\n // The contract must check the proper ratio was sent to mint DEI. We do this by seeing the minimum mintable DEI based on each amount \n uint256 c_dollar_value_d18;\n \n // Scoping for stack concerns\n { \n // USD amounts of the collateral and the DEUS\n c_dollar_value_d18 = (params.collateral_amount * params.col_price_usd) / (1e6);\n\n }\n uint calculated_deus_dollar_value_d18 = ((c_dollar_value_d18 * (1e6)) / params.col_ratio) - c_dollar_value_d18;\n\n uint calculated_deus_needed = (calculated_deus_dollar_value_d18 * (1e6)) / params.deus_price_usd;\n\n return (\n c_dollar_value_d18 + calculated_deus_dollar_value_d18,\n calculated_deus_needed\n );\n }\n\n function calcRedeem1t1DEI(uint256 col_price_usd, uint256 DEI_amount) public pure returns (uint256) {\n return (DEI_amount * (1e6)) / col_price_usd;\n }\n\n // Must be internal because of the struct\n function calcBuyBackDEUS(BuybackDEUS_Params memory params) public pure returns (uint256) {\n // If the total collateral value is higher than the amount required at the current collateral ratio then buy back up to the possible DEUS with the desired collateral\n require(params.excess_collateral_dollar_value_d18 > 0, \"No excess collateral to buy back!\");\n\n // Make sure not to take more than is available\n uint256 deus_dollar_value_d18 = (params.DEUS_amount * (params.deus_price_usd)) / (1e6);\n require(deus_dollar_value_d18 <= params.excess_collateral_dollar_value_d18, \"You are trying to buy back more than the excess!\");\n\n // Get the equivalent amount of collateral based on the market value of DEUS provided \n uint256 collateral_equivalent_d18 = (deus_dollar_value_d18 * (1e6)) / params.col_price_usd;\n //collateral_equivalent_d18 = collateral_equivalent_d18.sub((collateral_equivalent_d18.mul(params.buyback_fee)).div(1e6));\n\n return collateral_equivalent_d18;\n\n }\n\n\n // Returns value of collateral that must increase to reach recollateralization target (if 0 means no recollateralization)\n function recollateralizeAmount(uint256 total_supply, uint256 global_collateral_ratio, uint256 global_collat_value) public pure returns (uint256) {\n uint256 target_collat_value = (total_supply * global_collateral_ratio) / (1e6); // We want 18 decimals of precision so divide by 1e6; total_supply is 1e18 and global_collateral_ratio is 1e6\n // Subtract the current value of collateral from the target value needed, if higher than 0 then system needs to recollateralize\n return target_collat_value - global_collat_value; // If recollateralization is not needed, throws a subtraction underflow\n // return(recollateralization_left);\n }\n\n function calcRecollateralizeDEIInner(\n uint256 collateral_amount, \n uint256 col_price,\n uint256 global_collat_value,\n uint256 dei_total_supply,\n uint256 global_collateral_ratio\n ) public pure returns (uint256, uint256) {\n uint256 collat_value_attempted = (collateral_amount * col_price) / (1e6);\n uint256 effective_collateral_ratio = (global_collat_value * (1e6)) / dei_total_supply; //returns it in 1e6\n uint256 recollat_possible = (global_collateral_ratio * dei_total_supply - (dei_total_supply * effective_collateral_ratio)) / (1e6);\n\n uint256 amount_to_recollat;\n if(collat_value_attempted <= recollat_possible){\n amount_to_recollat = collat_value_attempted;\n } else {\n amount_to_recollat = recollat_possible;\n }\n\n return ((amount_to_recollat * (1e6)) / col_price, amount_to_recollat);\n\n }\n\n}\n\n//Dar panah khoda" }, "contracts/Math/Math.sol": { "content": "// SPDX-License-Identifier: MIT\npragma solidity >=0.6.11;\n\n/**\n * @dev Standard math utilities missing in the Solidity language.\n */\nlibrary Math {\n /**\n * @dev Returns the largest of two numbers.\n */\n function max(uint256 a, uint256 b) internal pure returns (uint256) {\n return a >= b ? a : b;\n }\n\n /**\n * @dev Returns the smallest of two numbers.\n */\n function min(uint256 a, uint256 b) internal pure returns (uint256) {\n return a < b ? a : b;\n }\n\n /**\n * @dev Returns the average of two numbers. The result is rounded towards\n * zero.\n */\n function average(uint256 a, uint256 b) internal pure returns (uint256) {\n // (a + b) / 2 can overflow, so we distribute\n return (a / 2) + (b / 2) + ((a % 2 + b % 2) / 2);\n }\n\n // babylonian method (https://en.wikipedia.org/wiki/Methods_of_computing_square_roots#Babylonian_method)\n function sqrt(uint y) internal pure returns (uint z) {\n if (y > 3) {\n z = y;\n uint x = y / 2 + 1;\n while (x < z) {\n z = x;\n x = (y / x + x) / 2;\n }\n } else if (y != 0) {\n z = 1;\n }\n }\n}" }, "contracts/Uniswap/Interfaces/IUniswapV2Pair.sol": { "content": "// SPDX-License-Identifier: MIT\npragma solidity >=0.6.11;\n\ninterface IUniswapV2Pair {\n event Approval(address indexed owner, address indexed spender, uint value);\n event Transfer(address indexed from, address indexed to, uint value);\n\n function name() external pure returns (string memory);\n function symbol() external pure returns (string memory);\n function decimals() external pure returns (uint8);\n function totalSupply() external view returns (uint);\n function balanceOf(address owner) external view returns (uint);\n function allowance(address owner, address spender) external view returns (uint);\n\n function approve(address spender, uint value) external returns (bool);\n function transfer(address to, uint value) external returns (bool);\n function transferFrom(address from, address to, uint value) external returns (bool);\n\n function DOMAIN_SEPARATOR() external view returns (bytes32);\n function PERMIT_TYPEHASH() external pure returns (bytes32);\n function nonces(address owner) external view returns (uint);\n\n function permit(address owner, address spender, uint value, uint deadline, uint8 v, bytes32 r, bytes32 s) external;\n\n event Mint(address indexed sender, uint amount0, uint amount1);\n event Burn(address indexed sender, uint amount0, uint amount1, address indexed to);\n event Swap(\n address indexed sender,\n uint amount0In,\n uint amount1In,\n uint amount0Out,\n uint amount1Out,\n address indexed to\n );\n event Sync(uint112 reserve0, uint112 reserve1);\n\n function MINIMUM_LIQUIDITY() external pure returns (uint);\n function factory() external view returns (address);\n function token0() external view returns (address);\n function token1() external view returns (address);\n function getReserves() external view returns (uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast);\n function price0CumulativeLast() external view returns (uint);\n function price1CumulativeLast() external view returns (uint);\n function kLast() external view returns (uint);\n\n function mint(address to) external returns (uint liquidity);\n function burn(address to) external returns (uint amount0, uint amount1);\n function swap(uint amount0Out, uint amount1Out, address to, bytes calldata data) external;\n function skim(address to) external;\n function sync() external;\n\n function initialize(address, address) external;\n\n\n\n\n\n\n\n\n\n\n\n\n \n}\n" } }, "settings": { "optimizer": { "enabled": true, "runs": 100000 }, "outputSelection": { "*": { "*": [ "evm.bytecode", "evm.deployedBytecode", "abi" ] } }, "metadata": { "useLiteralContent": true }, "libraries": {} } }}

DEUS Finance

Start building on QuickNode

Source code: