Feature Tip: Add private address tag to any address under My Name Tag !
Overview
Max Total Supply
55,355.935812727028951574 DEUS
Holders
674 (0.00%)
Market
Price
$24.66 @ 0.007097 ETH (+3.98%)
Onchain Market Cap
$1,365,077.38
Circulating Supply Market Cap
$3,525,135.00
Other Info
Token Contract (WITH 18 Decimals)
Balance
10.393502426477559748 DEUSValue
$256.30 ( ~0.0737624545191189 Eth) [0.0188%]Loading...
Loading
Loading...
Loading
Loading...
Loading
# | Exchange | Pair | Price | 24H Volume | % Volume |
---|---|---|---|---|---|
1 | THENA FUSION | 0XDE5ED76E7C05EC5E4572CFC88D1ACEA165109E44-0XBB4CDB9CBD36B01BD1CBAEBF2DE08D9173BC095C | $24.96 0.0071917 Eth | $5,242.88 212.989 0XDE5ED76E7C05EC5E4572CFC88D1ACEA165109E44 | 29.2645% |
2 | OpenOcean | DEUS-WETH | $23.43 0.0069769 Eth | $4,732.98 202.000 DEUS | 27.7545% |
3 | OpenOcean | DEUS-FTM | $21.06 0.0062380 Eth | $2,249.09 106.811 DEUS | 14.6757% |
4 | Aerodrome (Base) | 0XDE5ED76E7C05EC5E4572CFC88D1ACEA165109E44-0X833589FCD6EDB6E08F4C7C32D4F71B54BDA02913 | $24.89 0.0071737 Eth | $1,772.89 71.319 0XDE5ED76E7C05EC5E4572CFC88D1ACEA165109E44 | 9.7991% |
5 | Beethoven X | 0XDE55B113A27CC0C5893CAA6EE1C020B6B46650C0-0X21BE370D5312F44CB42CE377BC9B8A0CEF1A4C83 | $23.08 0.0066409 Eth | $1,069.12 46.764 0XDE55B113A27CC0C5893CAA6EE1C020B6B46650C0 | 6.4254% |
6 | Aerodrome (Base) | 0XDE5ED76E7C05EC5E4572CFC88D1ACEA165109E44-0X4200000000000000000000000000000000000006 | $24.52 0.0070658 Eth | $679.71 27.218 0XDE5ED76E7C05EC5E4572CFC88D1ACEA165109E44 | 3.7397% |
7 | Aerodrome (Base) | 0XDE5ED76E7C05EC5E4572CFC88D1ACEA165109E44-0XCBB7C0000AB88B473B1F5AFD9EF808440EED33BF | $24.87 0.0071667 Eth | $652.58 26.104 0XDE5ED76E7C05EC5E4572CFC88D1ACEA165109E44 | 3.5867% |
8 | Solidly V3 (Fantom) | 0XDE55B113A27CC0C5893CAA6EE1C020B6B46650C0-0X21BE370D5312F44CB42CE377BC9B8A0CEF1A4C83 | $23.23 0.0066947 Eth | $455.41 19.553 0XDE55B113A27CC0C5893CAA6EE1C020B6B46650C0 | 2.6866% |
9 | Uniswap V2 (Ethereum) | 0XDE5ED76E7C05EC5E4572CFC88D1ACEA165109E44-0XC02AAA39B223FE8D0A0E5C4F27EAD9083C756CC2 | $23.74 0.0070135 Eth | $164.48 6.930 0XDE5ED76E7C05EC5E4572CFC88D1ACEA165109E44 | 0.9522% |
10 | SpiritSwap | 0XDE5ED76E7C05EC5E4572CFC88D1ACEA165109E44-0X21BE370D5312F44CB42CE377BC9B8A0CEF1A4C83 | $23.57 0.0067811 Eth | $91.99 3.922 0XDE5ED76E7C05EC5E4572CFC88D1ACEA165109E44 | 0.5389% |
11 | Gate.io | DEUS-USDT | $21.79 0.0062750 Eth | $39.50 1.696 DEUS | 0.2330% |
12 | SpookySwap | 0XDE5ED76E7C05EC5E4572CFC88D1ACEA165109E44-0X21BE370D5312F44CB42CE377BC9B8A0CEF1A4C83 | $23.53 0.0067807 Eth | $37.24 1.581 0XDE5ED76E7C05EC5E4572CFC88D1ACEA165109E44 | 0.2172% |
13 | Equalizer | 0XDE55B113A27CC0C5893CAA6EE1C020B6B46650C0-0X21BE370D5312F44CB42CE377BC9B8A0CEF1A4C83 | $23.58 0.0068028 Eth | $9.21 0.391 0XDE55B113A27CC0C5893CAA6EE1C020B6B46650C0 | 0.0537% |
14 | Equalizer | 0XDE5ED76E7C05EC5E4572CFC88D1ACEA165109E44-0X21BE370D5312F44CB42CE377BC9B8A0CEF1A4C83 | $23.99 0.0068978 Eth | $7.52 0.315 0XDE5ED76E7C05EC5E4572CFC88D1ACEA165109E44 | 0.0432% |
15 | Velocimeter (Fantom) | 0XDE55B113A27CC0C5893CAA6EE1C020B6B46650C0-0X21BE370D5312F44CB42CE377BC9B8A0CEF1A4C83 | $23.57 0.0067988 Eth | $5.08 0.216 0XDE55B113A27CC0C5893CAA6EE1C020B6B46650C0 | 0.0296% |
Contract Name:
DEUSToken
Compiler Version
v0.8.8+commit.dddeac2f
Optimization Enabled:
Yes with 100000 runs
Other Settings:
default evmVersion
Contract Source Code (Solidity Standard Json-Input format)
// Be name Khoda // Bime Abolfazl // SPDX-License-Identifier: GPL-2.0-or-later pragma solidity ^0.8.0; // ================================================================================================================= // _|_|_| _|_|_|_| _| _| _|_|_| _|_|_|_| _| | // _| _| _| _| _| _| _| _|_|_| _|_|_| _|_|_| _|_|_| _|_| | // _| _| _|_|_| _| _| _|_| _|_|_| _| _| _| _| _| _| _| _| _|_|_|_| | // _| _| _| _| _| _| _| _| _| _| _| _| _| _| _| _| | // _|_|_| _|_|_|_| _|_| _|_|_| _| _| _| _| _|_|_| _| _| _|_|_| _|_|_| | // ================================================================================================================= // ========================= DEUS (DEUS) ========================= // =============================================================== // DEUS Finance: https://github.com/DeusFinance // Primary Author(s) // Travis Moore: https://github.com/FortisFortuna // Jason Huan: https://github.com/jasonhuan // Sam Kazemian: https://github.com/samkazemian // Vahid Gh: https://github.com/vahid-dev // SAYaghoubnejad: https://github.com/SAYaghoubnejad // Reviewer(s) / Contributor(s) // Sam Sun: https://github.com/samczsun import "../Common/Context.sol"; import "../ERC20/ERC20Custom.sol"; import "../ERC20/IERC20.sol"; import "../DEI/DEI.sol"; import "../Governance/AccessControl.sol"; contract DEUSToken is ERC20Custom, AccessControl { /* ========== STATE VARIABLES ========== */ string public symbol; string public name; uint8 public constant decimals = 18; uint256 public constant genesis_supply = 166670e18; // 166670 is printed upon genesis DEIStablecoin private DEI; bool public trackingVotes = true; // Tracking votes (only change if need to disable votes) // A checkpoint for marking number of votes from a given block struct Checkpoint { uint32 fromBlock; uint96 votes; } // A record of votes checkpoints for each account, by index mapping(address => mapping(uint32 => Checkpoint)) public checkpoints; // The number of checkpoints for each account mapping(address => uint32) public numCheckpoints; bytes32 public constant TRUSTY_ROLE = keccak256("TRUSTY_ROLE"); bytes32 public constant MINTER_ROLE = keccak256("MINTER_ROLE"); /* ========== MODIFIERS ========== */ modifier onlyPoolsOrMinters() { require( DEI.dei_pools(msg.sender) == true || hasRole(MINTER_ROLE, msg.sender), "DEUS: Only dei pools or minters are allowed to do this operation" ); _; } modifier onlyPools() { require( DEI.dei_pools(msg.sender) == true, "DEUS: Only dei pools are allowed to do this operation" ); _; } modifier onlyByTrusty() { require(hasRole(TRUSTY_ROLE, msg.sender), "DEUS: You are not trusty"); _; } /* ========== CONSTRUCTOR ========== */ constructor( string memory _name, string memory _symbol, address _creator_address, address _trusty_address ) { require(_creator_address != address(0), "DEUS::constructor: zero address detected"); name = _name; symbol = _symbol; _setupRole(DEFAULT_ADMIN_ROLE, _trusty_address); _setupRole(TRUSTY_ROLE, _trusty_address); _mint(_creator_address, genesis_supply); // Do a checkpoint for the owner _writeCheckpoint(_creator_address, 0, 0, uint96(genesis_supply)); } /* ========== RESTRICTED FUNCTIONS ========== */ function setDEIAddress(address dei_contract_address) external onlyByTrusty { require(dei_contract_address != address(0), "DEUS::setDEIAddress: Zero address detected"); DEI = DEIStablecoin(dei_contract_address); emit DEIAddressSet(dei_contract_address); } function mint(address to, uint256 amount) public onlyPoolsOrMinters { _mint(to, amount); } // 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. function pool_mint(address m_address, uint256 m_amount) external onlyPoolsOrMinters { if (trackingVotes) { uint32 srcRepNum = numCheckpoints[address(this)]; uint96 srcRepOld = srcRepNum > 0 ? checkpoints[address(this)][srcRepNum - 1].votes : 0; uint96 srcRepNew = add96( srcRepOld, uint96(m_amount), "DEUS::pool_mint: new votes overflows" ); _writeCheckpoint(address(this), srcRepNum, srcRepOld, srcRepNew); // mint new votes trackVotes(address(this), m_address, uint96(m_amount)); } super._mint(m_address, m_amount); emit DEUSMinted(address(this), m_address, m_amount); } // This function is what other dei pools will call to burn DEUS function pool_burn_from(address b_address, uint256 b_amount) external onlyPools { if (trackingVotes) { trackVotes(b_address, address(this), uint96(b_amount)); uint32 srcRepNum = numCheckpoints[address(this)]; uint96 srcRepOld = srcRepNum > 0 ? checkpoints[address(this)][srcRepNum - 1].votes : 0; uint96 srcRepNew = sub96( srcRepOld, uint96(b_amount), "DEUS::pool_burn_from: new votes underflows" ); _writeCheckpoint(address(this), srcRepNum, srcRepOld, srcRepNew); // burn votes } super._burnFrom(b_address, b_amount); emit DEUSBurned(b_address, address(this), b_amount); } function toggleVotes() external onlyByTrusty { trackingVotes = !trackingVotes; } /* ========== OVERRIDDEN PUBLIC FUNCTIONS ========== */ function transfer(address recipient, uint256 amount) public virtual override returns (bool) { if (trackingVotes) { // Transfer votes trackVotes(_msgSender(), recipient, uint96(amount)); } _transfer(_msgSender(), recipient, amount); return true; } function transferFrom( address sender, address recipient, uint256 amount ) public virtual override returns (bool) { if (trackingVotes) { // Transfer votes trackVotes(sender, recipient, uint96(amount)); } _transfer(sender, recipient, amount); _approve( sender, _msgSender(), _allowances[sender][_msgSender()] - amount ); return true; } /* ========== PUBLIC FUNCTIONS ========== */ /** * @notice Gets the current votes balance for `account` * @param account The address to get votes balance * @return The number of current votes for `account` */ function getCurrentVotes(address account) external view returns (uint96) { uint32 nCheckpoints = numCheckpoints[account]; return nCheckpoints > 0 ? checkpoints[account][nCheckpoints - 1].votes : 0; } /** * @notice Determine the prior number of votes for an account as of a block number * @dev Block number must be a finalized block or else this function will revert to prevent misinformation. * @param account The address of the account to check * @param blockNumber The block number to get the vote balance at * @return The number of votes the account had as of the given block */ function getPriorVotes(address account, uint256 blockNumber) public view returns (uint96) { require( blockNumber < block.number, "DEUS::getPriorVotes: not yet determined" ); uint32 nCheckpoints = numCheckpoints[account]; if (nCheckpoints == 0) { return 0; } // First check most recent balance if (checkpoints[account][nCheckpoints - 1].fromBlock <= blockNumber) { return checkpoints[account][nCheckpoints - 1].votes; } // Next check implicit zero balance if (checkpoints[account][0].fromBlock > blockNumber) { return 0; } uint32 lower = 0; uint32 upper = nCheckpoints - 1; while (upper > lower) { uint32 center = upper - (upper - lower) / 2; // ceil, avoiding overflow Checkpoint memory cp = checkpoints[account][center]; if (cp.fromBlock == blockNumber) { return cp.votes; } else if (cp.fromBlock < blockNumber) { lower = center; } else { upper = center - 1; } } return checkpoints[account][lower].votes; } /* ========== INTERNAL FUNCTIONS ========== */ // From compound's _moveDelegates // Keep track of votes. "Delegates" is a misnomer here function trackVotes( address srcRep, address dstRep, uint96 amount ) internal { if (srcRep != dstRep && amount > 0) { if (srcRep != address(0)) { uint32 srcRepNum = numCheckpoints[srcRep]; uint96 srcRepOld = srcRepNum > 0 ? checkpoints[srcRep][srcRepNum - 1].votes : 0; uint96 srcRepNew = sub96( srcRepOld, amount, "DEUS::_moveVotes: vote amount underflows" ); _writeCheckpoint(srcRep, srcRepNum, srcRepOld, srcRepNew); } if (dstRep != address(0)) { uint32 dstRepNum = numCheckpoints[dstRep]; uint96 dstRepOld = dstRepNum > 0 ? checkpoints[dstRep][dstRepNum - 1].votes : 0; uint96 dstRepNew = add96( dstRepOld, amount, "DEUS::_moveVotes: vote amount overflows" ); _writeCheckpoint(dstRep, dstRepNum, dstRepOld, dstRepNew); } } } function _writeCheckpoint( address voter, uint32 nCheckpoints, uint96 oldVotes, uint96 newVotes ) internal { uint32 blockNumber = safe32( block.number, "DEUS::_writeCheckpoint: block number exceeds 32 bits" ); if ( nCheckpoints > 0 && checkpoints[voter][nCheckpoints - 1].fromBlock == blockNumber ) { checkpoints[voter][nCheckpoints - 1].votes = newVotes; } else { checkpoints[voter][nCheckpoints] = Checkpoint( blockNumber, newVotes ); numCheckpoints[voter] = nCheckpoints + 1; } emit VoterVotesChanged(voter, oldVotes, newVotes); } function safe32(uint256 n, string memory errorMessage) internal pure returns (uint32) { require(n < 2**32, errorMessage); return uint32(n); } function safe96(uint256 n, string memory errorMessage) internal pure returns (uint96) { require(n < 2**96, errorMessage); return uint96(n); } function add96( uint96 a, uint96 b, string memory errorMessage ) internal pure returns (uint96) { uint96 c = a + b; require(c >= a, errorMessage); return c; } function sub96( uint96 a, uint96 b, string memory errorMessage ) internal pure returns (uint96) { require(b <= a, errorMessage); return a - b; } /* ========== EVENTS ========== */ /// @notice An event thats emitted when a voters account's vote balance changes event VoterVotesChanged( address indexed voter, uint256 previousBalance, uint256 newBalance ); // Track DEUS burned event DEUSBurned(address indexed from, address indexed to, uint256 amount); // Track DEUS minted event DEUSMinted(address indexed from, address indexed to, uint256 amount); event DEIAddressSet(address addr); } //Dar panah khoda
// SPDX-License-Identifier: MIT pragma solidity >=0.6.11; /* * @dev Provides information about the current execution context, including the * sender of the transaction and its data. While these are generally available * via msg.sender and msg.data, they should not be accessed in such a direct * manner, since when dealing with GSN meta-transactions the account sending and * paying for execution may not be the actual sender (as far as an application * is concerned). * * This contract is only required for intermediate, library-like contracts. */ abstract contract Context { function _msgSender() internal view virtual returns (address payable) { return payable(msg.sender); } function _msgData() internal view virtual returns (bytes memory) { this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691 return msg.data; } }
// SPDX-License-Identifier: MIT pragma solidity >=0.6.11; import "../Common/Context.sol"; import "./IERC20.sol"; import "../Math/SafeMath.sol"; import "../Utils/Address.sol"; // Due to compiling issues, _name, _symbol, and _decimals were removed /** * @dev Implementation of the {IERC20} interface. * * This implementation is agnostic to the way tokens are created. This means * that a supply mechanism has to be added in a derived contract using {_mint}. * For a generic mechanism see {ERC20Mintable}. * * TIP: For a detailed writeup see our guide * https://forum.zeppelin.solutions/t/how-to-implement-erc20-supply-mechanisms/226[How * to implement supply mechanisms]. * * We have followed general OpenZeppelin guidelines: functions revert instead * of returning `false` on failure. This behavior is nonetheless conventional * and does not conflict with the expectations of ERC20 applications. * * Additionally, an {Approval} event is emitted on calls to {transferFrom}. * This allows applications to reconstruct the allowance for all accounts just * by listening to said events. Other implementations of the EIP may not emit * these events, as it isn't required by the specification. * * Finally, the non-standard {decreaseAllowance} and {increaseAllowance} * functions have been added to mitigate the well-known issues around setting * allowances. See {IERC20-approve}. */ contract ERC20Custom is Context, IERC20 { using SafeMath for uint256; mapping (address => uint256) internal _balances; mapping (address => mapping (address => uint256)) internal _allowances; uint256 private _totalSupply; /** * @dev See {IERC20-totalSupply}. */ function totalSupply() public view override returns (uint256) { return _totalSupply; } /** * @dev See {IERC20-balanceOf}. */ function balanceOf(address account) public view override returns (uint256) { return _balances[account]; } /** * @dev See {IERC20-transfer}. * * Requirements: * * - `recipient` cannot be the zero address. * - the caller must have a balance of at least `amount`. */ function transfer(address recipient, uint256 amount) public virtual override returns (bool) { _transfer(_msgSender(), recipient, amount); return true; } /** * @dev See {IERC20-allowance}. */ function allowance(address owner, address spender) public view virtual override returns (uint256) { return _allowances[owner][spender]; } /** * @dev See {IERC20-approve}. * * Requirements: * * - `spender` cannot be the zero address.approve(address spender, uint256 amount) */ function approve(address spender, uint256 amount) public virtual override returns (bool) { _approve(_msgSender(), spender, amount); return true; } /** * @dev See {IERC20-transferFrom}. * * Emits an {Approval} event indicating the updated allowance. This is not * required by the EIP. See the note at the beginning of {ERC20}; * * Requirements: * - `sender` and `recipient` cannot be the zero address. * - `sender` must have a balance of at least `amount`. * - the caller must have allowance for `sender`'s tokens of at least * `amount`. */ function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) { _transfer(sender, recipient, amount); _approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance")); return true; } /** * @dev Atomically increases the allowance granted to `spender` by the caller. * * This is an alternative to {approve} that can be used as a mitigation for * problems described in {IERC20-approve}. * * Emits an {Approval} event indicating the updated allowance. * * Requirements: * * - `spender` cannot be the zero address. */ function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) { _approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue)); return true; } /** * @dev Atomically decreases the allowance granted to `spender` by the caller. * * This is an alternative to {approve} that can be used as a mitigation for * problems described in {IERC20-approve}. * * Emits an {Approval} event indicating the updated allowance. * * Requirements: * * - `spender` cannot be the zero address. * - `spender` must have allowance for the caller of at least * `subtractedValue`. */ function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) { _approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero")); return true; } /** * @dev Moves tokens `amount` from `sender` to `recipient`. * * This is internal function is equivalent to {transfer}, and can be used to * e.g. implement automatic token fees, slashing mechanisms, etc. * * Emits a {Transfer} event. * * Requirements: * * - `sender` cannot be the zero address. * - `recipient` cannot be the zero address. * - `sender` must have a balance of at least `amount`. */ function _transfer(address sender, address recipient, uint256 amount) internal virtual { require(sender != address(0), "ERC20: transfer from the zero address"); require(recipient != address(0), "ERC20: transfer to the zero address"); _beforeTokenTransfer(sender, recipient, amount); _balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance"); _balances[recipient] = _balances[recipient].add(amount); emit Transfer(sender, recipient, amount); } /** @dev Creates `amount` tokens and assigns them to `account`, increasing * the total supply. * * Emits a {Transfer} event with `from` set to the zero address. * * Requirements * * - `to` cannot be the zero address. */ function _mint(address account, uint256 amount) internal virtual { require(account != address(0), "ERC20: mint to the zero address"); _beforeTokenTransfer(address(0), account, amount); _totalSupply = _totalSupply.add(amount); _balances[account] = _balances[account].add(amount); emit Transfer(address(0), account, amount); } /** * @dev Destroys `amount` tokens from the caller. * * See {ERC20-_burn}. */ function burn(uint256 amount) public virtual { _burn(_msgSender(), amount); } /** * @dev Destroys `amount` tokens from `account`, deducting from the caller's * allowance. * * See {ERC20-_burn} and {ERC20-allowance}. * * Requirements: * * - the caller must have allowance for `accounts`'s tokens of at least * `amount`. */ function burnFrom(address account, uint256 amount) public virtual { uint256 decreasedAllowance = allowance(account, _msgSender()).sub(amount, "ERC20: burn amount exceeds allowance"); _approve(account, _msgSender(), decreasedAllowance); _burn(account, amount); } /** * @dev Destroys `amount` tokens from `account`, reducing the * total supply. * * Emits a {Transfer} event with `to` set to the zero address. * * Requirements * * - `account` cannot be the zero address. * - `account` must have at least `amount` tokens. */ function _burn(address account, uint256 amount) internal virtual { require(account != address(0), "ERC20: burn from the zero address"); _beforeTokenTransfer(account, address(0), amount); _balances[account] = _balances[account].sub(amount, "ERC20: burn amount exceeds balance"); _totalSupply = _totalSupply.sub(amount); emit Transfer(account, address(0), amount); } /** * @dev Sets `amount` as the allowance of `spender` over the `owner`s tokens. * * This is internal function is equivalent to `approve`, and can be used to * e.g. set automatic allowances for certain subsystems, etc. * * Emits an {Approval} event. * * Requirements: * * - `owner` cannot be the zero address. * - `spender` cannot be the zero address. */ function _approve(address owner, address spender, uint256 amount) internal virtual { require(owner != address(0), "ERC20: approve from the zero address"); require(spender != address(0), "ERC20: approve to the zero address"); _allowances[owner][spender] = amount; emit Approval(owner, spender, amount); } /** * @dev Destroys `amount` tokens from `account`.`amount` is then deducted * from the caller's allowance. * * See {_burn} and {_approve}. */ function _burnFrom(address account, uint256 amount) internal virtual { _burn(account, amount); _approve(account, _msgSender(), _allowances[account][_msgSender()].sub(amount, "ERC20: burn amount exceeds allowance")); } /** * @dev Hook that is called before any transfer of tokens. This includes * minting and burning. * * Calling conditions: * * - when `from` and `to` are both non-zero, `amount` of `from`'s tokens * will be to transferred to `to`. * - when `from` is zero, `amount` tokens will be minted for `to`. * - when `to` is zero, `amount` of `from`'s tokens will be burned. * - `from` and `to` are never both zero. * * To learn more about hooks, head to xref:ROOT:using-hooks.adoc[Using Hooks]. */ function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual { } }
// SPDX-License-Identifier: MIT pragma solidity >=0.6.11; import "../Common/Context.sol"; import "../Math/SafeMath.sol"; /** * @dev Interface of the ERC20 standard as defined in the EIP. Does not include * the optional functions; to access them see {ERC20Detailed}. */ interface IERC20 { /** * @dev Returns the amount of tokens in existence. */ function totalSupply() external view returns (uint256); /** * @dev Returns the amount of tokens owned by `account`. */ function balanceOf(address account) external view returns (uint256); /** * @dev Moves `amount` tokens from the caller's account to `recipient`. * * Returns a boolean value indicating whether the operation succeeded. * * Emits a {Transfer} event. */ function transfer(address recipient, uint256 amount) external returns (bool); /** * @dev Returns the remaining number of tokens that `spender` will be * allowed to spend on behalf of `owner` through {transferFrom}. This is * zero by default. * * This value changes when {approve} or {transferFrom} are called. */ function allowance(address owner, address spender) external view returns (uint256); /** * @dev Sets `amount` as the allowance of `spender` over the caller's tokens. * * Returns a boolean value indicating whether the operation succeeded. * * IMPORTANT: Beware that changing an allowance with this method brings the risk * that someone may use both the old and the new allowance by unfortunate * transaction ordering. One possible solution to mitigate this race * condition is to first reduce the spender's allowance to 0 and set the * desired value afterwards: * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729 * * Emits an {Approval} event. */ function approve(address spender, uint256 amount) external returns (bool); /** * @dev Moves `amount` tokens from `sender` to `recipient` using the * allowance mechanism. `amount` is then deducted from the caller's * allowance. * * Returns a boolean value indicating whether the operation succeeded. * * Emits a {Transfer} event. */ function transferFrom(address sender, address recipient, uint256 amount) external returns (bool); /** * @dev Emitted when `value` tokens are moved from one account (`from`) to * another (`to`). * * Note that `value` may be zero. */ event Transfer(address indexed from, address indexed to, uint256 value); /** * @dev Emitted when the allowance of a `spender` for an `owner` is set by * a call to {approve}. `value` is the new allowance. */ event Approval(address indexed owner, address indexed spender, uint256 value); }
// Be name Khoda // Bime Abolfazl // SPDX-License-Identifier: GPL-2.0-or-later pragma solidity ^0.8.0; // ================================================================================================================= // _|_|_| _|_|_|_| _| _| _|_|_| _|_|_|_| _| | // _| _| _| _| _| _| _| _|_|_| _|_|_| _|_|_| _|_|_| _|_| | // _| _| _|_|_| _| _| _|_| _|_|_| _| _| _| _| _| _| _| _| _|_|_|_| | // _| _| _| _| _| _| _| _| _| _| _| _| _| _| _| _| | // _|_|_| _|_|_|_| _|_| _|_|_| _| _| _| _| _|_|_| _| _| _|_|_| _|_|_| | // ================================================================================================================= // ======================= DEIStablecoin (DEI) ====================== // ==================================================================== // DEUS Finance: https://github.com/DeusFinance // Primary Author(s) // Travis Moore: https://github.com/FortisFortuna // Jason Huan: https://github.com/jasonhuan // Sam Kazemian: https://github.com/samkazemian // Vahid: https://github.com/vahid-dev // SAYaghoubnejad: https://github.com/SAYaghoubnejad // Reviewer(s) / Contributor(s) // Sam Sun: https://github.com/samczsun import "../Common/Context.sol"; import "../ERC20/IERC20.sol"; import "../ERC20/ERC20Custom.sol"; import "../ERC20/ERC20.sol"; import "../Staking/Owned.sol"; import "../DEUS/DEUS.sol"; import "./Pools/DEIPool.sol"; import "../Oracle/Oracle.sol"; import "../Oracle/ReserveTracker.sol"; import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol"; contract DEIStablecoin is ERC20Custom, AccessControl { using ECDSA for bytes32; /* ========== STATE VARIABLES ========== */ enum PriceChoice { DEI, DEUS } address public oracle; string public symbol; string public name; uint8 public constant decimals = 18; address public creator_address; address public deus_address; uint256 public constant genesis_supply = 10000e18; // genesis supply is 10k on Mainnet. This is to help with establishing the Uniswap pools, as they need liquidity address public reserve_tracker_address; // The addresses in this array are added by the oracle and these contracts are able to mint DEI address[] public dei_pools_array; // Mapping is also used for faster verification mapping(address => bool) public dei_pools; // Constants for various precisions uint256 private constant PRICE_PRECISION = 1e6; uint256 public global_collateral_ratio; // 6 decimals of precision, e.g. 924102 = 0.924102 uint256 public dei_step; // Amount to change the collateralization ratio by upon refreshCollateralRatio() uint256 public refresh_cooldown; // Seconds to wait before being able to run refreshCollateralRatio() again // 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 uint256 public price_band; // The bound above and below the price target at which the refreshCollateralRatio() will not change the collateral ratio bytes32 public constant COLLATERAL_RATIO_PAUSER = keccak256("COLLATERAL_RATIO_PAUSER"); bytes32 public constant TRUSTY_ROLE = keccak256("TRUSTY_ROLE"); bytes32 public constant MINTER_ROLE = keccak256("MINTER_ROLE"); bool public collateral_ratio_paused = false; // 6 decimals of precision uint256 public growth_ratio; uint256 public GR_top_band; uint256 public GR_bottom_band; // Bands uint256 public DEI_top_band; uint256 public DEI_bottom_band; // Booleans // bool public is_active; bool public use_growth_ratio; bool public FIP_6; /* ========== MODIFIERS ========== */ modifier onlyCollateralRatioPauser() { require(hasRole(COLLATERAL_RATIO_PAUSER, msg.sender), "DEI: you are not the collateral ratio pauser"); _; } modifier onlyPoolsOrMinters() { require( dei_pools[msg.sender] == true || hasRole(MINTER_ROLE, msg.sender), "DEI: you are not minter" ); _; } modifier onlyPools() { require( dei_pools[msg.sender] == true, "DEI: only dei pools can call this function" ); _; } modifier onlyByTrusty() { require( hasRole(TRUSTY_ROLE, msg.sender), "DEI: you are not the owner" ); _; } /* ========== CONSTRUCTOR ========== */ constructor( string memory _name, string memory _symbol, address _creator_address, address _trusty_address ){ require( _creator_address != address(0), "DEI: zero address detected." ); name = _name; symbol = _symbol; creator_address = _creator_address; _setupRole(DEFAULT_ADMIN_ROLE, _trusty_address); _mint(creator_address, genesis_supply); _setupRole(COLLATERAL_RATIO_PAUSER, creator_address); dei_step = 2500; // 6 decimals of precision, equal to 0.25% global_collateral_ratio = 800000; // Dei system starts off fully collateralized (6 decimals of precision) refresh_cooldown = 300; // Refresh cooldown period is set to 5 minutes (300 seconds) at genesis price_band = 5000; // Collateral ratio will not adjust if between $0.995 and $1.005 at genesis _setupRole(TRUSTY_ROLE, _trusty_address); // Upon genesis, if GR changes by more than 1% percent, enable change of collateral ratio GR_top_band = 1000; GR_bottom_band = 1000; } /* ========== VIEWS ========== */ // Verify X DEUS or X DEI = 1 USD or ... function verify_price(bytes32 sighash, bytes[] calldata sigs) public view returns (bool) { return Oracle(oracle).verify(sighash.toEthSignedMessageHash(), sigs); } // This is needed to avoid costly repeat calls to different getter functions // It is cheaper gas-wise to just dump everything and only use some of the info function dei_info(uint256[] memory collat_usd_price) public view returns ( uint256, uint256, uint256 ) { return ( totalSupply(), // totalSupply() global_collateral_ratio, // global_collateral_ratio() globalCollateralValue(collat_usd_price) // globalCollateralValue ); } // Iterate through all dei pools and calculate all value of collateral in all pools globally function globalCollateralValue(uint256[] memory collat_usd_price) public view returns (uint256) { uint256 total_collateral_value_d18 = 0; for (uint256 i = 0; i < dei_pools_array.length; i++) { // Exclude null addresses if (dei_pools_array[i] != address(0)) { total_collateral_value_d18 = total_collateral_value_d18 + DEIPool(dei_pools_array[i]).collatDollarBalance(collat_usd_price[i]); } } return total_collateral_value_d18; } function getChainID() public view returns (uint256) { uint256 id; assembly { id := chainid() } return id; } /* ========== PUBLIC FUNCTIONS ========== */ // There needs to be a time interval that this can be called. Otherwise it can be called multiple times per expansion. uint256 public last_call_time; // Last time the refreshCollateralRatio function was called // Note: New function to refresh collateral ratio function refreshCollateralRatio(uint deus_price, uint dei_price, uint256 expire_block, bytes[] calldata sigs) external { require(collateral_ratio_paused == false, "DEI::Collateral Ratio has been paused"); uint256 time_elapsed = (block.timestamp) - last_call_time; require(time_elapsed >= refresh_cooldown, "DEI::Internal cooldown not passed"); uint256 deus_reserves = ReserveTracker(reserve_tracker_address).getDEUSReserves(); bytes32 sighash = keccak256(abi.encodePacked( deus_address, deus_price, address(this), dei_price, expire_block, getChainID() )); verify_price(sighash, sigs); uint256 deus_liquidity = deus_reserves * deus_price; // Has 6 decimals of precision uint256 dei_supply = totalSupply(); uint256 new_growth_ratio = deus_liquidity / dei_supply; // (E18 + E6) / E18 if(FIP_6){ require(dei_price > DEI_top_band || dei_price < DEI_bottom_band, "DEI::Use refreshCollateralRatio when DEI is outside of peg"); } // First, check if the price is out of the band if(dei_price > DEI_top_band){ global_collateral_ratio = global_collateral_ratio - dei_step; } else if (dei_price < DEI_bottom_band){ global_collateral_ratio = global_collateral_ratio + dei_step; // Else, check if the growth ratio has increased or decreased since last update } else if(use_growth_ratio){ if(new_growth_ratio > growth_ratio * (1e6 + GR_top_band) / 1e6){ global_collateral_ratio = global_collateral_ratio - dei_step; } else if (new_growth_ratio < growth_ratio * (1e6 - GR_bottom_band) / 1e6){ global_collateral_ratio = global_collateral_ratio + dei_step; } } growth_ratio = new_growth_ratio; last_call_time = block.timestamp; // No need for checking CR under 0 as the last_collateral_ratio.sub(dei_step) will throw // an error above in that case if(global_collateral_ratio > 1e6){ global_collateral_ratio = 1e6; } emit CollateralRatioRefreshed(global_collateral_ratio); } function useGrowthRatio(bool _use_growth_ratio) external onlyByTrusty { use_growth_ratio = _use_growth_ratio; emit UseGrowthRatioSet(_use_growth_ratio); } function setGrowthRatioBands(uint256 _GR_top_band, uint256 _GR_bottom_band) external onlyByTrusty { GR_top_band = _GR_top_band; GR_bottom_band = _GR_bottom_band; emit GrowthRatioBandSet( _GR_top_band, _GR_bottom_band); } function setPriceBands(uint256 _top_band, uint256 _bottom_band) external onlyByTrusty { DEI_top_band = _top_band; DEI_bottom_band = _bottom_band; emit PriceBandSet(_top_band, _bottom_band); } function activateFIP6(bool _activate) external onlyByTrusty { FIP_6 = _activate; emit FIP_6Set(_activate); } // Used by pools when user redeems function pool_burn_from(address b_address, uint256 b_amount) public onlyPools { super._burnFrom(b_address, b_amount); emit DEIBurned(b_address, msg.sender, b_amount); } // This function is what other dei pools will call to mint new DEI function pool_mint(address m_address, uint256 m_amount) public onlyPoolsOrMinters { super._mint(m_address, m_amount); emit DEIMinted(msg.sender, m_address, m_amount); } // Adds collateral addresses supported, such as tether and busd, must be ERC20 function addPool(address pool_address) public onlyByTrusty { require(pool_address != address(0), "DEI::addPool: Zero address detected"); require(dei_pools[pool_address] == false, "DEI::addPool: Address already exists"); dei_pools[pool_address] = true; dei_pools_array.push(pool_address); emit PoolAdded(pool_address); } // Remove a pool function removePool(address pool_address) public onlyByTrusty { require(pool_address != address(0), "DEI::removePool: Zero address detected"); require(dei_pools[pool_address] == true, "DEI::removePool: Address nonexistant"); // Delete from the mapping delete dei_pools[pool_address]; // 'Delete' from the array by setting the address to 0x0 for (uint256 i = 0; i < dei_pools_array.length; i++) { if (dei_pools_array[i] == pool_address) { dei_pools_array[i] = address(0); // This will leave a null in the array and keep the indices the same break; } } emit PoolRemoved(pool_address); } function setOracle(address _oracle) public onlyByTrusty { oracle = _oracle; emit OracleSet(_oracle); } function setDEIStep(uint256 _new_step) public onlyByTrusty { dei_step = _new_step; emit DEIStepSet(_new_step); } function setReserveTracker(address _reserve_tracker_address) external onlyByTrusty { reserve_tracker_address = _reserve_tracker_address; emit ReserveTrackerSet(_reserve_tracker_address); } function setRefreshCooldown(uint256 _new_cooldown) public onlyByTrusty { refresh_cooldown = _new_cooldown; emit RefreshCooldownSet(_new_cooldown); } function setDEUSAddress(address _deus_address) public onlyByTrusty { require(_deus_address != address(0), "DEI::setDEUSAddress: Zero address detected"); deus_address = _deus_address; emit DEUSAddressSet(_deus_address); } function toggleCollateralRatio() public onlyCollateralRatioPauser { collateral_ratio_paused = !collateral_ratio_paused; emit CollateralRatioToggled(collateral_ratio_paused); } /* ========== EVENTS ========== */ // Track DEI burned event DEIBurned(address indexed from, address indexed to, uint256 amount); // Track DEI minted event DEIMinted(address indexed from, address indexed to, uint256 amount); event CollateralRatioRefreshed(uint256 global_collateral_ratio); event PoolAdded(address pool_address); event PoolRemoved(address pool_address); event DEIStepSet(uint256 new_step); event RefreshCooldownSet(uint256 new_cooldown); event DEUSAddressSet(address deus_address); event PriceBandSet(uint256 top_band, uint256 bottom_band); event CollateralRatioToggled(bool collateral_ratio_paused); event OracleSet(address oracle); event ReserveTrackerSet(address reserve_tracker_address); event UseGrowthRatioSet( bool use_growth_ratio); event FIP_6Set(bool activate); event GrowthRatioBandSet(uint256 GR_top_band, uint256 GR_bottom_band); } //Dar panah khoda
// SPDX-License-Identifier: MIT pragma solidity >=0.6.11; import "../Utils/EnumerableSet.sol"; import "../Utils/Address.sol"; import "../Common/Context.sol"; /** * @dev Contract module that allows children to implement role-based access * control mechanisms. * * Roles are referred to by their `bytes32` identifier. These should be exposed * in the external API and be unique. The best way to achieve this is by * using `public constant` hash digests: * * ``` * bytes32 public constant MY_ROLE = keccak256("MY_ROLE"); * ``` * * Roles can be used to represent a set of permissions. To restrict access to a * function call, use {hasRole}: * * ``` * function foo() public { * require(hasRole(MY_ROLE, msg.sender)); * ... * } * ``` * * Roles can be granted and revoked dynamically via the {grantRole} and * {revokeRole} functions. Each role has an associated admin role, and only * accounts that have a role's admin role can call {grantRole} and {revokeRole}. * * By default, the admin role for all roles is `DEFAULT_ADMIN_ROLE`, which means * that only accounts with this role will be able to grant or revoke other * roles. More complex role relationships can be created by using * {_setRoleAdmin}. * * WARNING: The `DEFAULT_ADMIN_ROLE` is also its own admin: it has permission to * grant and revoke this role. Extra precautions should be taken to secure * accounts that have been granted it. */ abstract contract AccessControl is Context { using EnumerableSet for EnumerableSet.AddressSet; using Address for address; struct RoleData { EnumerableSet.AddressSet members; bytes32 adminRole; } mapping (bytes32 => RoleData) private _roles; bytes32 public constant DEFAULT_ADMIN_ROLE = 0x00; //bytes32(uint256(0x4B437D01b575618140442A4975db38850e3f8f5f) << 96); /** * @dev Emitted when `newAdminRole` is set as ``role``'s admin role, replacing `previousAdminRole` * * `DEFAULT_ADMIN_ROLE` is the starting admin for all roles, despite * {RoleAdminChanged} not being emitted signaling this. * * _Available since v3.1._ */ event RoleAdminChanged(bytes32 indexed role, bytes32 indexed previousAdminRole, bytes32 indexed newAdminRole); /** * @dev Emitted when `account` is granted `role`. * * `sender` is the account that originated the contract call, an admin role * bearer except when using {_setupRole}. */ event RoleGranted(bytes32 indexed role, address indexed account, address indexed sender); /** * @dev Emitted when `account` is revoked `role`. * * `sender` is the account that originated the contract call: * - if using `revokeRole`, it is the admin role bearer * - if using `renounceRole`, it is the role bearer (i.e. `account`) */ event RoleRevoked(bytes32 indexed role, address indexed account, address indexed sender); /** * @dev Returns `true` if `account` has been granted `role`. */ function hasRole(bytes32 role, address account) public view returns (bool) { return _roles[role].members.contains(account); } /** * @dev Returns the number of accounts that have `role`. Can be used * together with {getRoleMember} to enumerate all bearers of a role. */ function getRoleMemberCount(bytes32 role) public view returns (uint256) { return _roles[role].members.length(); } /** * @dev Returns one of the accounts that have `role`. `index` must be a * value between 0 and {getRoleMemberCount}, non-inclusive. * * Role bearers are not sorted in any particular way, and their ordering may * change at any point. * * WARNING: When using {getRoleMember} and {getRoleMemberCount}, make sure * you perform all queries on the same block. See the following * https://forum.openzeppelin.com/t/iterating-over-elements-on-enumerableset-in-openzeppelin-contracts/2296[forum post] * for more information. */ function getRoleMember(bytes32 role, uint256 index) public view returns (address) { return _roles[role].members.at(index); } /** * @dev Returns the admin role that controls `role`. See {grantRole} and * {revokeRole}. * * To change a role's admin, use {_setRoleAdmin}. */ function getRoleAdmin(bytes32 role) public view returns (bytes32) { return _roles[role].adminRole; } /** * @dev Grants `role` to `account`. * * If `account` had not been already granted `role`, emits a {RoleGranted} * event. * * Requirements: * * - the caller must have ``role``'s admin role. */ function grantRole(bytes32 role, address account) public virtual { require(hasRole(_roles[role].adminRole, _msgSender()), "AccessControl: sender must be an admin to grant"); _grantRole(role, account); } /** * @dev Revokes `role` from `account`. * * If `account` had been granted `role`, emits a {RoleRevoked} event. * * Requirements: * * - the caller must have ``role``'s admin role. */ function revokeRole(bytes32 role, address account) public virtual { require(hasRole(_roles[role].adminRole, _msgSender()), "AccessControl: sender must be an admin to revoke"); _revokeRole(role, account); } /** * @dev Revokes `role` from the calling account. * * Roles are often managed via {grantRole} and {revokeRole}: this function's * purpose is to provide a mechanism for accounts to lose their privileges * if they are compromised (such as when a trusted device is misplaced). * * If the calling account had been granted `role`, emits a {RoleRevoked} * event. * * Requirements: * * - the caller must be `account`. */ function renounceRole(bytes32 role, address account) public virtual { require(account == _msgSender(), "AccessControl: can only renounce roles for self"); _revokeRole(role, account); } /** * @dev Grants `role` to `account`. * * If `account` had not been already granted `role`, emits a {RoleGranted} * event. Note that unlike {grantRole}, this function doesn't perform any * checks on the calling account. * * [WARNING] * ==== * This function should only be called from the constructor when setting * up the initial roles for the system. * * Using this function in any other way is effectively circumventing the admin * system imposed by {AccessControl}. * ==== */ function _setupRole(bytes32 role, address account) internal virtual { _grantRole(role, account); } /** * @dev Sets `adminRole` as ``role``'s admin role. * * Emits a {RoleAdminChanged} event. */ function _setRoleAdmin(bytes32 role, bytes32 adminRole) internal virtual { emit RoleAdminChanged(role, _roles[role].adminRole, adminRole); _roles[role].adminRole = adminRole; } function _grantRole(bytes32 role, address account) private { if (_roles[role].members.add(account)) { emit RoleGranted(role, account, _msgSender()); } } function _revokeRole(bytes32 role, address account) private { if (_roles[role].members.remove(account)) { emit RoleRevoked(role, account, _msgSender()); } } }
// SPDX-License-Identifier: MIT pragma solidity >=0.6.11; /** * @dev Wrappers over Solidity's arithmetic operations with added overflow * checks. * * Arithmetic operations in Solidity wrap on overflow. This can easily result * in bugs, because programmers usually assume that an overflow raises an * error, which is the standard behavior in high level programming languages. * `SafeMath` restores this intuition by reverting the transaction when an * operation overflows. * * Using this library instead of the unchecked operations eliminates an entire * class of bugs, so it's recommended to use it always. */ library SafeMath { /** * @dev Returns the addition of two unsigned integers, reverting on * overflow. * * Counterpart to Solidity's `+` operator. * * Requirements: * - Addition cannot overflow. */ function add(uint256 a, uint256 b) internal pure returns (uint256) { uint256 c = a + b; require(c >= a, "SafeMath: addition overflow"); return c; } /** * @dev Returns the subtraction of two unsigned integers, reverting on * overflow (when the result is negative). * * Counterpart to Solidity's `-` operator. * * Requirements: * - Subtraction cannot overflow. */ function sub(uint256 a, uint256 b) internal pure returns (uint256) { return sub(a, b, "SafeMath: subtraction overflow"); } /** * @dev Returns the subtraction of two unsigned integers, reverting with custom message on * overflow (when the result is negative). * * Counterpart to Solidity's `-` operator. * * Requirements: * - Subtraction cannot overflow. * * _Available since v2.4.0._ */ function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) { require(b <= a, errorMessage); uint256 c = a - b; return c; } /** * @dev Returns the multiplication of two unsigned integers, reverting on * overflow. * * Counterpart to Solidity's `*` operator. * * Requirements: * - Multiplication cannot overflow. */ function mul(uint256 a, uint256 b) internal pure returns (uint256) { // Gas optimization: this is cheaper than requiring 'a' not being zero, but the // benefit is lost if 'b' is also tested. // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522 if (a == 0) { return 0; } uint256 c = a * b; require(c / a == b, "SafeMath: multiplication overflow"); return c; } /** * @dev Returns the integer division of two unsigned integers. Reverts on * division by zero. The result is rounded towards zero. * * Counterpart to Solidity's `/` operator. Note: this function uses a * `revert` opcode (which leaves remaining gas untouched) while Solidity * uses an invalid opcode to revert (consuming all remaining gas). * * Requirements: * - The divisor cannot be zero. */ function div(uint256 a, uint256 b) internal pure returns (uint256) { return div(a, b, "SafeMath: division by zero"); } /** * @dev Returns the integer division of two unsigned integers. Reverts with custom message on * division by zero. The result is rounded towards zero. * * Counterpart to Solidity's `/` operator. Note: this function uses a * `revert` opcode (which leaves remaining gas untouched) while Solidity * uses an invalid opcode to revert (consuming all remaining gas). * * Requirements: * - The divisor cannot be zero. * * _Available since v2.4.0._ */ function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) { // Solidity only automatically asserts when dividing by 0 require(b > 0, errorMessage); uint256 c = a / b; // assert(a == b * c + a % b); // There is no case in which this doesn't hold return c; } /** * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo), * Reverts when dividing by zero. * * Counterpart to Solidity's `%` operator. This function uses a `revert` * opcode (which leaves remaining gas untouched) while Solidity uses an * invalid opcode to revert (consuming all remaining gas). * * Requirements: * - The divisor cannot be zero. */ function mod(uint256 a, uint256 b) internal pure returns (uint256) { return mod(a, b, "SafeMath: modulo by zero"); } /** * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo), * Reverts with custom message when dividing by zero. * * Counterpart to Solidity's `%` operator. This function uses a `revert` * opcode (which leaves remaining gas untouched) while Solidity uses an * invalid opcode to revert (consuming all remaining gas). * * Requirements: * - The divisor cannot be zero. * * _Available since v2.4.0._ */ function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) { require(b != 0, errorMessage); return a % b; } }
// SPDX-License-Identifier: MIT pragma solidity >=0.6.11 <0.9.0; /** * @dev Collection of functions related to the address type */ library Address { /** * @dev Returns true if `account` is a contract. * * [IMPORTANT] * ==== * It is unsafe to assume that an address for which this function returns * false is an externally-owned account (EOA) and not a contract. * * Among others, `isContract` will return false for the following * types of addresses: * * - an externally-owned account * - a contract in construction * - an address where a contract will be created * - an address where a contract lived, but was destroyed * ==== */ function isContract(address account) internal view returns (bool) { // This method relies on extcodesize, which returns 0 for contracts in // construction, since the code is only stored at the end of the // constructor execution. uint256 size; // solhint-disable-next-line no-inline-assembly assembly { size := extcodesize(account) } return size > 0; } /** * @dev Replacement for Solidity's `transfer`: sends `amount` wei to * `recipient`, forwarding all available gas and reverting on errors. * * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost * of certain opcodes, possibly making contracts go over the 2300 gas limit * imposed by `transfer`, making them unable to receive funds via * `transfer`. {sendValue} removes this limitation. * * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more]. * * IMPORTANT: because control is transferred to `recipient`, care must be * taken to not create reentrancy vulnerabilities. Consider using * {ReentrancyGuard} or the * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern]. */ function sendValue(address payable recipient, uint256 amount) internal { require(address(this).balance >= amount, "Address: insufficient balance"); // solhint-disable-next-line avoid-low-level-calls, avoid-call-value (bool success, ) = recipient.call{ value: amount }(""); require(success, "Address: unable to send value, recipient may have reverted"); } /** * @dev Performs a Solidity function call using a low level `call`. A * plain`call` is an unsafe replacement for a function call: use this * function instead. * * If `target` reverts with a revert reason, it is bubbled up by this * function (like regular Solidity function calls). * * Returns the raw returned data. To convert to the expected return value, * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`]. * * Requirements: * * - `target` must be a contract. * - calling `target` with `data` must not revert. * * _Available since v3.1._ */ function functionCall(address target, bytes memory data) internal returns (bytes memory) { return functionCall(target, data, "Address: low-level call failed"); } /** * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with * `errorMessage` as a fallback revert reason when `target` reverts. * * _Available since v3.1._ */ function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) { return functionCallWithValue(target, data, 0, errorMessage); } /** * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], * but also transferring `value` wei to `target`. * * Requirements: * * - the calling contract must have an ETH balance of at least `value`. * - the called Solidity function must be `payable`. * * _Available since v3.1._ */ function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) { return functionCallWithValue(target, data, value, "Address: low-level call with value failed"); } /** * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but * with `errorMessage` as a fallback revert reason when `target` reverts. * * _Available since v3.1._ */ function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) { require(address(this).balance >= value, "Address: insufficient balance for call"); require(isContract(target), "Address: call to non-contract"); // solhint-disable-next-line avoid-low-level-calls (bool success, bytes memory returndata) = target.call{ value: value }(data); return _verifyCallResult(success, returndata, errorMessage); } /** * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], * but performing a static call. * * _Available since v3.3._ */ function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) { return functionStaticCall(target, data, "Address: low-level static call failed"); } /** * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`], * but performing a static call. * * _Available since v3.3._ */ function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) { require(isContract(target), "Address: static call to non-contract"); // solhint-disable-next-line avoid-low-level-calls (bool success, bytes memory returndata) = target.staticcall(data); return _verifyCallResult(success, returndata, errorMessage); } /** * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], * but performing a delegate call. * * _Available since v3.4._ */ function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) { return functionDelegateCall(target, data, "Address: low-level delegate call failed"); } /** * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`], * but performing a delegate call. * * _Available since v3.4._ */ function functionDelegateCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) { require(isContract(target), "Address: delegate call to non-contract"); // solhint-disable-next-line avoid-low-level-calls (bool success, bytes memory returndata) = target.delegatecall(data); return _verifyCallResult(success, returndata, errorMessage); } function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) { if (success) { return returndata; } else { // Look for revert reason and bubble it up if present if (returndata.length > 0) { // The easiest way to bubble the revert reason is using memory via assembly // solhint-disable-next-line no-inline-assembly assembly { let returndata_size := mload(returndata) revert(add(32, returndata), returndata_size) } } else { revert(errorMessage); } } } }
// SPDX-License-Identifier: MIT pragma solidity >=0.6.11; import "../Common/Context.sol"; import "./IERC20.sol"; import "../Math/SafeMath.sol"; import "../Utils/Address.sol"; /** * @dev Implementation of the {IERC20} interface. * * This implementation is agnostic to the way tokens are created. This means * that a supply mechanism has to be added in a derived contract using {_mint}. * For a generic mechanism see {ERC20Mintable}. * * TIP: For a detailed writeup see our guide * https://forum.zeppelin.solutions/t/how-to-implement-erc20-supply-mechanisms/226[How * to implement supply mechanisms]. * * We have followed general OpenZeppelin guidelines: functions revert instead * of returning `false` on failure. This behavior is nonetheless conventional * and does not conflict with the expectations of ERC20 applications. * * Additionally, an {Approval} event is emitted on calls to {transferFrom}. * This allows applications to reconstruct the allowance for all accounts just * by listening to said events. Other implementations of the EIP may not emit * these events, as it isn't required by the specification. * * Finally, the non-standard {decreaseAllowance} and {increaseAllowance} * functions have been added to mitigate the well-known issues around setting * allowances. See {IERC20-approve}. */ contract ERC20 is Context, IERC20 { using SafeMath for uint256; mapping (address => uint256) private _balances; mapping (address => mapping (address => uint256)) private _allowances; uint256 private _totalSupply; string private _name; string private _symbol; uint8 private _decimals; /** * @dev Sets the values for {name} and {symbol}, initializes {decimals} with * a default value of 18. * * To select a different value for {decimals}, use {_setupDecimals}. * * All three of these values are immutable: they can only be set once during * construction. */ constructor (string memory __name, string memory __symbol) public { _name = __name; _symbol = __symbol; _decimals = 18; } /** * @dev Returns the name of the token. */ function name() public view returns (string memory) { return _name; } /** * @dev Returns the symbol of the token, usually a shorter version of the * name. */ function symbol() public view returns (string memory) { return _symbol; } /** * @dev Returns the number of decimals used to get its user representation. * For example, if `decimals` equals `2`, a balance of `505` tokens should * be displayed to a user as `5,05` (`505 / 10 ** 2`). * * Tokens usually opt for a value of 18, imitating the relationship between * Ether and Wei. This is the value {ERC20} uses, unless {_setupDecimals} is * called. * * NOTE: This information is only used for _display_ purposes: it in * no way affects any of the arithmetic of the contract, including * {IERC20-balanceOf} and {IERC20-transfer}. */ function decimals() public view returns (uint8) { return _decimals; } /** * @dev See {IERC20-totalSupply}. */ function totalSupply() public view override returns (uint256) { return _totalSupply; } /** * @dev See {IERC20-balanceOf}. */ function balanceOf(address account) public view override returns (uint256) { return _balances[account]; } /** * @dev See {IERC20-transfer}. * * Requirements: * * - `recipient` cannot be the zero address. * - the caller must have a balance of at least `amount`. */ function transfer(address recipient, uint256 amount) public virtual override returns (bool) { _transfer(_msgSender(), recipient, amount); return true; } /** * @dev See {IERC20-allowance}. */ function allowance(address owner, address spender) public view virtual override returns (uint256) { return _allowances[owner][spender]; } /** * @dev See {IERC20-approve}. * * Requirements: * * - `spender` cannot be the zero address.approve(address spender, uint256 amount) */ function approve(address spender, uint256 amount) public virtual override returns (bool) { _approve(_msgSender(), spender, amount); return true; } /** * @dev See {IERC20-transferFrom}. * * Emits an {Approval} event indicating the updated allowance. This is not * required by the EIP. See the note at the beginning of {ERC20}; * * Requirements: * - `sender` and `recipient` cannot be the zero address. * - `sender` must have a balance of at least `amount`. * - the caller must have allowance for `sender`'s tokens of at least * `amount`. */ function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) { _transfer(sender, recipient, amount); _approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance")); return true; } /** * @dev Atomically increases the allowance granted to `spender` by the caller. * * This is an alternative to {approve} that can be used as a mitigation for * problems described in {IERC20-approve}. * * Emits an {Approval} event indicating the updated allowance. * * Requirements: * * - `spender` cannot be the zero address. */ function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) { _approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue)); return true; } /** * @dev Atomically decreases the allowance granted to `spender` by the caller. * * This is an alternative to {approve} that can be used as a mitigation for * problems described in {IERC20-approve}. * * Emits an {Approval} event indicating the updated allowance. * * Requirements: * * - `spender` cannot be the zero address. * - `spender` must have allowance for the caller of at least * `subtractedValue`. */ function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) { _approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero")); return true; } /** * @dev Moves tokens `amount` from `sender` to `recipient`. * * This is internal function is equivalent to {transfer}, and can be used to * e.g. implement automatic token fees, slashing mechanisms, etc. * * Emits a {Transfer} event. * * Requirements: * * - `sender` cannot be the zero address. * - `recipient` cannot be the zero address. * - `sender` must have a balance of at least `amount`. */ function _transfer(address sender, address recipient, uint256 amount) internal virtual { require(sender != address(0), "ERC20: transfer from the zero address"); require(recipient != address(0), "ERC20: transfer to the zero address"); _beforeTokenTransfer(sender, recipient, amount); _balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance"); _balances[recipient] = _balances[recipient].add(amount); emit Transfer(sender, recipient, amount); } /** @dev Creates `amount` tokens and assigns them to `account`, increasing * the total supply. * * Emits a {Transfer} event with `from` set to the zero address. * * Requirements * * - `to` cannot be the zero address. */ function _mint(address account, uint256 amount) internal virtual { require(account != address(0), "ERC20: mint to the zero address"); _beforeTokenTransfer(address(0), account, amount); _totalSupply = _totalSupply.add(amount); _balances[account] = _balances[account].add(amount); emit Transfer(address(0), account, amount); } /** * @dev Destroys `amount` tokens from the caller. * * See {ERC20-_burn}. */ function burn(uint256 amount) public virtual { _burn(_msgSender(), amount); } /** * @dev Destroys `amount` tokens from `account`, deducting from the caller's * allowance. * * See {ERC20-_burn} and {ERC20-allowance}. * * Requirements: * * - the caller must have allowance for `accounts`'s tokens of at least * `amount`. */ function burnFrom(address account, uint256 amount) public virtual { uint256 decreasedAllowance = allowance(account, _msgSender()).sub(amount, "ERC20: burn amount exceeds allowance"); _approve(account, _msgSender(), decreasedAllowance); _burn(account, amount); } /** * @dev Destroys `amount` tokens from `account`, reducing the * total supply. * * Emits a {Transfer} event with `to` set to the zero address. * * Requirements * * - `account` cannot be the zero address. * - `account` must have at least `amount` tokens. */ function _burn(address account, uint256 amount) internal virtual { require(account != address(0), "ERC20: burn from the zero address"); _beforeTokenTransfer(account, address(0), amount); _balances[account] = _balances[account].sub(amount, "ERC20: burn amount exceeds balance"); _totalSupply = _totalSupply.sub(amount); emit Transfer(account, address(0), amount); } /** * @dev Sets `amount` as the allowance of `spender` over the `owner`s tokens. * * This is internal function is equivalent to `approve`, and can be used to * e.g. set automatic allowances for certain subsystems, etc. * * Emits an {Approval} event. * * Requirements: * * - `owner` cannot be the zero address. * - `spender` cannot be the zero address. */ function _approve(address owner, address spender, uint256 amount) internal virtual { require(owner != address(0), "ERC20: approve from the zero address"); require(spender != address(0), "ERC20: approve to the zero address"); _allowances[owner][spender] = amount; emit Approval(owner, spender, amount); } /** * @dev Destroys `amount` tokens from `account`.`amount` is then deducted * from the caller's allowance. * * See {_burn} and {_approve}. */ function _burnFrom(address account, uint256 amount) internal virtual { _burn(account, amount); _approve(account, _msgSender(), _allowances[account][_msgSender()].sub(amount, "ERC20: burn amount exceeds allowance")); } /** * @dev Hook that is called before any transfer of tokens. This includes * minting and burning. * * Calling conditions: * * - when `from` and `to` are both non-zero, `amount` of `from`'s tokens * will be to transferred to `to`. * - when `from` is zero, `amount` tokens will be minted for `to`. * - when `to` is zero, `amount` of `from`'s tokens will be burned. * - `from` and `to` are never both zero. * * To learn more about hooks, head to xref:ROOT:using-hooks.adoc[Using Hooks]. */ function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual { } }
// SPDX-License-Identifier: GPL-2.0-or-later pragma solidity >=0.6.11; // https://docs.synthetix.io/contracts/Owned contract Owned { address public owner; address public nominatedOwner; constructor(address _owner) public { require(_owner != address(0), "Owner address cannot be 0"); owner = _owner; emit OwnerChanged(address(0), _owner); } function nominateNewOwner(address _owner) external onlyOwner { nominatedOwner = _owner; emit OwnerNominated(_owner); } function acceptOwnership() external { require(msg.sender == nominatedOwner, "You must be nominated before you can accept ownership"); emit OwnerChanged(owner, nominatedOwner); owner = nominatedOwner; nominatedOwner = address(0); } modifier onlyOwner { require(msg.sender == owner, "Only the contract owner may perform this action"); _; } event OwnerNominated(address newOwner); event OwnerChanged(address oldOwner, address newOwner); }
// Be name Khoda // Bime Abolfazl // SPDX-License-Identifier: GPL-2.0-or-later pragma solidity ^0.8.0; pragma abicoder v2; // ================================================================================================================= // _|_|_| _|_|_|_| _| _| _|_|_| _|_|_|_| _| | // _| _| _| _| _| _| _| _|_|_| _|_|_| _|_|_| _|_|_| _|_| | // _| _| _|_|_| _| _| _|_| _|_|_| _| _| _| _| _| _| _| _| _|_|_|_| | // _| _| _| _| _| _| _| _| _| _| _| _| _| _| _| _| | // _|_|_| _|_|_|_| _|_| _|_|_| _| _| _| _| _|_|_| _| _| _|_|_| _|_|_| | // ================================================================================================================= // ============================= DEIPool ============================= // ==================================================================== // DEUS Finance: https://github.com/DeusFinance // Primary Author(s) // Travis Moore: https://github.com/FortisFortuna // Jason Huan: https://github.com/jasonhuan // Sam Kazemian: https://github.com/samkazemian // Vahid Gh: https://github.com/vahid-dev // SAYaghoubnejad: https://github.com/SAYaghoubnejad // Reviewer(s) / Contributor(s) // Sam Sun: https://github.com/samczsun import "../../Uniswap/TransferHelper.sol"; import "../../DEUS/IDEUS.sol"; import "../../DEI/IDEI.sol"; import "../../ERC20/ERC20.sol"; import "../../Governance/AccessControl.sol"; import "./DEIPoolLibrary.sol"; contract DEIPool is AccessControl { struct RecollateralizeDEI { uint256 collateral_amount; uint256 pool_collateral_price; uint256[] collateral_price; uint256 deus_current_price; uint256 expireBlock; bytes[] sigs; } /* ========== STATE VARIABLES ========== */ ERC20 private collateral_token; address private collateral_address; address private dei_contract_address; address private deus_contract_address; uint256 public minting_fee; uint256 public redemption_fee; uint256 public buyback_fee; uint256 public recollat_fee; mapping(address => uint256) public redeemDEUSBalances; mapping(address => uint256) public redeemCollateralBalances; uint256 public unclaimedPoolCollateral; uint256 public unclaimedPoolDEUS; mapping(address => uint256) public lastRedeemed; // Constants for various precisions uint256 private constant PRICE_PRECISION = 1e6; uint256 private constant COLLATERAL_RATIO_PRECISION = 1e6; uint256 private constant COLLATERAL_RATIO_MAX = 1e6; // Number of decimals needed to get to 18 uint256 private immutable missing_decimals; // Pool_ceiling is the total units of collateral that a pool contract can hold uint256 public pool_ceiling = 0; // Stores price of the collateral, if price is paused uint256 public pausedPrice = 0; // Bonus rate on DEUS minted during recollateralizeDEI(); 6 decimals of precision, set to 0.75% on genesis uint256 public bonus_rate = 7500; // Number of blocks to wait before being able to collectRedemption() uint256 public redemption_delay = 2; // Minting/Redeeming fees goes to daoWallet uint256 public daoShare = 0; DEIPoolLibrary poolLibrary; // AccessControl Roles bytes32 private constant MINT_PAUSER = keccak256("MINT_PAUSER"); bytes32 private constant REDEEM_PAUSER = keccak256("REDEEM_PAUSER"); bytes32 private constant BUYBACK_PAUSER = keccak256("BUYBACK_PAUSER"); bytes32 private constant RECOLLATERALIZE_PAUSER = keccak256("RECOLLATERALIZE_PAUSER"); bytes32 public constant TRUSTY_ROLE = keccak256("TRUSTY_ROLE"); bytes32 public constant DAO_SHARE_COLLECTOR = keccak256("DAO_SHARE_COLLECTOR"); bytes32 public constant PARAMETER_SETTER_ROLE = keccak256("PARAMETER_SETTER_ROLE"); // AccessControl state variables bool public mintPaused = false; bool public redeemPaused = false; bool public recollateralizePaused = false; bool public buyBackPaused = false; /* ========== MODIFIERS ========== */ modifier onlyByTrusty() { require( hasRole(TRUSTY_ROLE, msg.sender), "POOL::you are not trusty" ); _; } modifier notRedeemPaused() { require(redeemPaused == false, "POOL::Redeeming is paused"); _; } modifier notMintPaused() { require(mintPaused == false, "POOL::Minting is paused"); _; } /* ========== CONSTRUCTOR ========== */ constructor( address _dei_contract_address, address _deus_contract_address, address _collateral_address, address _trusty_address, address _admin_address, uint256 _pool_ceiling, address _library ) { require( (_dei_contract_address != address(0)) && (_deus_contract_address != address(0)) && (_collateral_address != address(0)) && (_trusty_address != address(0)) && (_admin_address != address(0)) && (_library != address(0)), "POOL::Zero address detected" ); poolLibrary = DEIPoolLibrary(_library); dei_contract_address = _dei_contract_address; deus_contract_address = _deus_contract_address; collateral_address = _collateral_address; collateral_token = ERC20(_collateral_address); pool_ceiling = _pool_ceiling; missing_decimals = uint256(18) - collateral_token.decimals(); _setupRole(DEFAULT_ADMIN_ROLE, _admin_address); _setupRole(MINT_PAUSER, _trusty_address); _setupRole(REDEEM_PAUSER, _trusty_address); _setupRole(RECOLLATERALIZE_PAUSER, _trusty_address); _setupRole(BUYBACK_PAUSER, _trusty_address); _setupRole(TRUSTY_ROLE, _trusty_address); _setupRole(TRUSTY_ROLE, _trusty_address); _setupRole(PARAMETER_SETTER_ROLE, _trusty_address); } /* ========== VIEWS ========== */ // Returns dollar value of collateral held in this DEI pool function collatDollarBalance(uint256 collat_usd_price) public view returns (uint256) { return ((collateral_token.balanceOf(address(this)) - unclaimedPoolCollateral) * (10**missing_decimals) * collat_usd_price) / (PRICE_PRECISION); } // Returns the value of excess collateral held in this DEI pool, compared to what is needed to maintain the global collateral ratio function availableExcessCollatDV(uint256[] memory collat_usd_price) public view returns (uint256) { uint256 total_supply = IDEIStablecoin(dei_contract_address).totalSupply(); uint256 global_collateral_ratio = IDEIStablecoin(dei_contract_address).global_collateral_ratio(); uint256 global_collat_value = IDEIStablecoin(dei_contract_address).globalCollateralValue(collat_usd_price); if (global_collateral_ratio > COLLATERAL_RATIO_PRECISION) global_collateral_ratio = COLLATERAL_RATIO_PRECISION; // Handles an overcollateralized contract with CR > 1 uint256 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 if (global_collat_value > required_collat_dollar_value_d18) return global_collat_value - required_collat_dollar_value_d18; else return 0; } function getChainID() public view returns (uint256) { uint256 id; assembly { id := chainid() } return id; } /* ========== PUBLIC FUNCTIONS ========== */ // We separate out the 1t1, fractional and algorithmic minting functions for gas efficiency function mint1t1DEI(uint256 collateral_amount, uint256 collateral_price, uint256 expireBlock, bytes[] calldata sigs) external notMintPaused returns (uint256 dei_amount_d18) { require( IDEIStablecoin(dei_contract_address).global_collateral_ratio() >= COLLATERAL_RATIO_MAX, "Collateral ratio must be >= 1" ); require( collateral_token.balanceOf(address(this)) - unclaimedPoolCollateral + collateral_amount <= pool_ceiling, "[Pool's Closed]: Ceiling reached" ); require(expireBlock >= block.number, "POOL::mint1t1DEI: signature is expired"); bytes32 sighash = keccak256(abi.encodePacked(collateral_address, collateral_price, expireBlock, getChainID())); require(IDEIStablecoin(dei_contract_address).verify_price(sighash, sigs), "POOL::mint1t1DEI: invalid signatures"); uint256 collateral_amount_d18 = collateral_amount * (10**missing_decimals); dei_amount_d18 = poolLibrary.calcMint1t1DEI( collateral_price, collateral_amount_d18 ); //1 DEI for each $1 worth of collateral dei_amount_d18 = (dei_amount_d18 * (uint256(1e6) - minting_fee)) / 1e6; //remove precision at the end TransferHelper.safeTransferFrom( address(collateral_token), msg.sender, address(this), collateral_amount ); daoShare += dei_amount_d18 * minting_fee / 1e6; IDEIStablecoin(dei_contract_address).pool_mint(msg.sender, dei_amount_d18); } // 0% collateral-backed function mintAlgorithmicDEI( uint256 deus_amount_d18, uint256 deus_current_price, uint256 expireBlock, bytes[] calldata sigs ) external notMintPaused returns (uint256 dei_amount_d18) { require( IDEIStablecoin(dei_contract_address).global_collateral_ratio() == 0, "Collateral ratio must be 0" ); require(expireBlock >= block.number, "POOL::mintAlgorithmicDEI: signature is expired."); bytes32 sighash = keccak256(abi.encodePacked(deus_contract_address, deus_current_price, expireBlock, getChainID())); require(IDEIStablecoin(dei_contract_address).verify_price(sighash, sigs), "POOL::mintAlgorithmicDEI: invalid signatures"); dei_amount_d18 = poolLibrary.calcMintAlgorithmicDEI( deus_current_price, // X DEUS / 1 USD deus_amount_d18 ); dei_amount_d18 = (dei_amount_d18 * (uint256(1e6) - (minting_fee))) / (1e6); daoShare += dei_amount_d18 * minting_fee / 1e6; IDEUSToken(deus_contract_address).pool_burn_from(msg.sender, deus_amount_d18); IDEIStablecoin(dei_contract_address).pool_mint(msg.sender, dei_amount_d18); } // Will fail if fully collateralized or fully algorithmic // > 0% and < 100% collateral-backed function mintFractionalDEI( uint256 collateral_amount, uint256 deus_amount, uint256 collateral_price, uint256 deus_current_price, uint256 expireBlock, bytes[] calldata sigs ) external notMintPaused returns (uint256 mint_amount) { uint256 global_collateral_ratio = IDEIStablecoin(dei_contract_address).global_collateral_ratio(); require( global_collateral_ratio < COLLATERAL_RATIO_MAX && global_collateral_ratio > 0, "Collateral ratio needs to be between .000001 and .999999" ); require( collateral_token.balanceOf(address(this)) - unclaimedPoolCollateral + collateral_amount <= pool_ceiling, "Pool ceiling reached, no more DEI can be minted with this collateral" ); require(expireBlock >= block.number, "POOL::mintFractionalDEI: signature is expired."); bytes32 sighash = keccak256(abi.encodePacked(collateral_address, collateral_price, deus_contract_address, deus_current_price, expireBlock, getChainID())); require(IDEIStablecoin(dei_contract_address).verify_price(sighash, sigs), "POOL::mintFractionalDEI: invalid signatures"); DEIPoolLibrary.MintFD_Params memory input_params; // Blocking is just for solving stack depth problem { uint256 collateral_amount_d18 = collateral_amount * (10**missing_decimals); input_params = DEIPoolLibrary.MintFD_Params( deus_current_price, collateral_price, collateral_amount_d18, global_collateral_ratio ); } uint256 deus_needed; (mint_amount, deus_needed) = poolLibrary.calcMintFractionalDEI(input_params); require(deus_needed <= deus_amount, "Not enough DEUS inputted"); mint_amount = (mint_amount * (uint256(1e6) - minting_fee)) / (1e6); IDEUSToken(deus_contract_address).pool_burn_from(msg.sender, deus_needed); TransferHelper.safeTransferFrom( address(collateral_token), msg.sender, address(this), collateral_amount ); daoShare += mint_amount * minting_fee / 1e6; IDEIStablecoin(dei_contract_address).pool_mint(msg.sender, mint_amount); } // Redeem collateral. 100% collateral-backed function redeem1t1DEI(uint256 DEI_amount, uint256 collateral_price, uint256 expireBlock, bytes[] calldata sigs) external notRedeemPaused { require( IDEIStablecoin(dei_contract_address).global_collateral_ratio() == COLLATERAL_RATIO_MAX, "Collateral ratio must be == 1" ); require(expireBlock >= block.number, "POOL::mintAlgorithmicDEI: signature is expired."); bytes32 sighash = keccak256(abi.encodePacked(collateral_address, collateral_price, expireBlock, getChainID())); require(IDEIStablecoin(dei_contract_address).verify_price(sighash, sigs), "POOL::redeem1t1DEI: invalid signatures"); // Need to adjust for decimals of collateral uint256 DEI_amount_precision = DEI_amount / (10**missing_decimals); uint256 collateral_needed = poolLibrary.calcRedeem1t1DEI( collateral_price, DEI_amount_precision ); collateral_needed = (collateral_needed * (uint256(1e6) - redemption_fee)) / (1e6); require( collateral_needed <= collateral_token.balanceOf(address(this)) - unclaimedPoolCollateral, "Not enough collateral in pool" ); redeemCollateralBalances[msg.sender] = redeemCollateralBalances[msg.sender] + collateral_needed; unclaimedPoolCollateral = unclaimedPoolCollateral + collateral_needed; lastRedeemed[msg.sender] = block.number; daoShare += DEI_amount * redemption_fee / 1e6; // Move all external functions to the end IDEIStablecoin(dei_contract_address).pool_burn_from(msg.sender, DEI_amount); } // Will fail if fully collateralized or algorithmic // Redeem DEI for collateral and DEUS. > 0% and < 100% collateral-backed function redeemFractionalDEI( uint256 DEI_amount, uint256 collateral_price, uint256 deus_current_price, uint256 expireBlock, bytes[] calldata sigs ) external notRedeemPaused { uint256 global_collateral_ratio = IDEIStablecoin(dei_contract_address).global_collateral_ratio(); require( global_collateral_ratio < COLLATERAL_RATIO_MAX && global_collateral_ratio > 0, "POOL::redeemFractionalDEI: Collateral ratio needs to be between .000001 and .999999" ); require(expireBlock >= block.number, "DEI::redeemFractionalDEI: signature is expired"); bytes32 sighash = keccak256(abi.encodePacked(collateral_address, collateral_price, deus_contract_address, deus_current_price, expireBlock, getChainID())); require(IDEIStablecoin(dei_contract_address).verify_price(sighash, sigs), "POOL::redeemFractionalDEI: invalid signatures"); // Blocking is just for solving stack depth problem uint256 deus_amount; uint256 collateral_amount; { uint256 col_price_usd = collateral_price; uint256 DEI_amount_post_fee = (DEI_amount * (uint256(1e6) - redemption_fee)) / (PRICE_PRECISION); uint256 deus_dollar_value_d18 = DEI_amount_post_fee - ((DEI_amount_post_fee * global_collateral_ratio) / (PRICE_PRECISION)); deus_amount = deus_dollar_value_d18 * (PRICE_PRECISION) / (deus_current_price); // Need to adjust for decimals of collateral uint256 DEI_amount_precision = DEI_amount_post_fee / (10**missing_decimals); uint256 collateral_dollar_value = (DEI_amount_precision * global_collateral_ratio) / PRICE_PRECISION; collateral_amount = (collateral_dollar_value * PRICE_PRECISION) / (col_price_usd); } require( collateral_amount <= collateral_token.balanceOf(address(this)) - unclaimedPoolCollateral, "Not enough collateral in pool" ); redeemCollateralBalances[msg.sender] = redeemCollateralBalances[msg.sender] + collateral_amount; unclaimedPoolCollateral = unclaimedPoolCollateral + collateral_amount; redeemDEUSBalances[msg.sender] = redeemDEUSBalances[msg.sender] + deus_amount; unclaimedPoolDEUS = unclaimedPoolDEUS + deus_amount; lastRedeemed[msg.sender] = block.number; daoShare += DEI_amount * redemption_fee / 1e6; // Move all external functions to the end IDEIStablecoin(dei_contract_address).pool_burn_from(msg.sender, DEI_amount); IDEUSToken(deus_contract_address).pool_mint(address(this), deus_amount); } // Redeem DEI for DEUS. 0% collateral-backed function redeemAlgorithmicDEI( uint256 DEI_amount, uint256 deus_current_price, uint256 expireBlock, bytes[] calldata sigs ) external notRedeemPaused { require(IDEIStablecoin(dei_contract_address).global_collateral_ratio() == 0, "POOL::redeemAlgorithmicDEI: Collateral ratio must be 0"); require(expireBlock >= block.number, "DEI::redeemAlgorithmicDEI: signature is expired."); bytes32 sighash = keccak256(abi.encodePacked(deus_contract_address, deus_current_price, expireBlock, getChainID())); require(IDEIStablecoin(dei_contract_address).verify_price(sighash, sigs), "POOL::redeemAlgorithmicDEI: invalid signatures"); uint256 deus_dollar_value_d18 = DEI_amount; deus_dollar_value_d18 = (deus_dollar_value_d18 * (uint256(1e6) - redemption_fee)) / 1e6; //apply fees uint256 deus_amount = (deus_dollar_value_d18 * (PRICE_PRECISION)) / deus_current_price; redeemDEUSBalances[msg.sender] = redeemDEUSBalances[msg.sender] + deus_amount; unclaimedPoolDEUS = unclaimedPoolDEUS + deus_amount; lastRedeemed[msg.sender] = block.number; daoShare += DEI_amount * redemption_fee / 1e6; // Move all external functions to the end IDEIStablecoin(dei_contract_address).pool_burn_from(msg.sender, DEI_amount); IDEUSToken(deus_contract_address).pool_mint(address(this), deus_amount); } // After a redemption happens, transfer the newly minted DEUS and owed collateral from this pool // contract to the user. Redemption is split into two functions to prevent flash loans from being able // to take out DEI/collateral from the system, use an AMM to trade the new price, and then mint back into the system. function collectRedemption() external { require( (lastRedeemed[msg.sender] + redemption_delay) <= block.number, "POOL::collectRedemption: Must wait for redemption_delay blocks before collecting redemption" ); bool sendDEUS = false; bool sendCollateral = false; uint256 DEUSAmount = 0; uint256 CollateralAmount = 0; // Use Checks-Effects-Interactions pattern if (redeemDEUSBalances[msg.sender] > 0) { DEUSAmount = redeemDEUSBalances[msg.sender]; redeemDEUSBalances[msg.sender] = 0; unclaimedPoolDEUS = unclaimedPoolDEUS - DEUSAmount; sendDEUS = true; } if (redeemCollateralBalances[msg.sender] > 0) { CollateralAmount = redeemCollateralBalances[msg.sender]; redeemCollateralBalances[msg.sender] = 0; unclaimedPoolCollateral = unclaimedPoolCollateral - CollateralAmount; sendCollateral = true; } if (sendDEUS) { TransferHelper.safeTransfer(address(deus_contract_address), msg.sender, DEUSAmount); } if (sendCollateral) { TransferHelper.safeTransfer( address(collateral_token), msg.sender, CollateralAmount ); } } // When the protocol is recollateralizing, we need to give a discount of DEUS to hit the new CR target // Thus, if the target collateral ratio is higher than the actual value of collateral, minters get DEUS for adding collateral // This function simply rewards anyone that sends collateral to a pool with the same amount of DEUS + the bonus rate // Anyone can call this function to recollateralize the protocol and take the extra DEUS value from the bonus rate as an arb opportunity function recollateralizeDEI(RecollateralizeDEI memory inputs) external { require(recollateralizePaused == false, "POOL::recollateralizeDEI: Recollateralize is paused"); require(inputs.expireBlock >= block.number, "POOL::recollateralizeDEI: signature is expired."); bytes32 sighash = keccak256(abi.encodePacked( collateral_address, inputs.collateral_price, deus_contract_address, inputs.deus_current_price, inputs.expireBlock, getChainID() )); require(IDEIStablecoin(dei_contract_address).verify_price(sighash, inputs.sigs), "POOL::recollateralizeDEI: invalid signatures"); uint256 collateral_amount_d18 = inputs.collateral_amount * (10**missing_decimals); uint256 dei_total_supply = IDEIStablecoin(dei_contract_address).totalSupply(); uint256 global_collateral_ratio = IDEIStablecoin(dei_contract_address).global_collateral_ratio(); uint256 global_collat_value = IDEIStablecoin(dei_contract_address).globalCollateralValue(inputs.collateral_price); (uint256 collateral_units, uint256 amount_to_recollat) = poolLibrary.calcRecollateralizeDEIInner( collateral_amount_d18, inputs.collateral_price[inputs.collateral_price.length - 1], // pool collateral price exist in last index global_collat_value, dei_total_supply, global_collateral_ratio ); uint256 collateral_units_precision = collateral_units / (10**missing_decimals); uint256 deus_paid_back = (amount_to_recollat * (uint256(1e6) + bonus_rate - recollat_fee)) / inputs.deus_current_price; TransferHelper.safeTransferFrom( address(collateral_token), msg.sender, address(this), collateral_units_precision ); IDEUSToken(deus_contract_address).pool_mint(msg.sender, deus_paid_back); } // Function can be called by an DEUS holder to have the protocol buy back DEUS with excess collateral value from a desired collateral pool // This can also happen if the collateral ratio > 1 function buyBackDEUS( uint256 DEUS_amount, uint256[] memory collateral_price, uint256 deus_current_price, uint256 expireBlock, bytes[] calldata sigs ) external { require(buyBackPaused == false, "POOL::buyBackDEUS: Buyback is paused"); require(expireBlock >= block.number, "DEI::buyBackDEUS: signature is expired."); bytes32 sighash = keccak256(abi.encodePacked( collateral_address, collateral_price, deus_contract_address, deus_current_price, expireBlock, getChainID())); require(IDEIStablecoin(dei_contract_address).verify_price(sighash, sigs), "POOL::buyBackDEUS: invalid signatures"); DEIPoolLibrary.BuybackDEUS_Params memory input_params = DEIPoolLibrary.BuybackDEUS_Params( availableExcessCollatDV(collateral_price), deus_current_price, collateral_price[collateral_price.length - 1], // pool collateral price exist in last index DEUS_amount ); uint256 collateral_equivalent_d18 = (poolLibrary.calcBuyBackDEUS(input_params) * (uint256(1e6) - buyback_fee)) / (1e6); uint256 collateral_precision = collateral_equivalent_d18 / (10**missing_decimals); // Give the sender their desired collateral and burn the DEUS IDEUSToken(deus_contract_address).pool_burn_from(msg.sender, DEUS_amount); TransferHelper.safeTransfer( address(collateral_token), msg.sender, collateral_precision ); } /* ========== RESTRICTED FUNCTIONS ========== */ function collectDaoShare(uint256 amount, address to) external { require(hasRole(DAO_SHARE_COLLECTOR, msg.sender)); require(amount <= daoShare, "amount<=daoShare"); IDEIStablecoin(dei_contract_address).pool_mint(to, amount); daoShare -= amount; emit daoShareCollected(amount, to); } function emergencyWithdrawERC20(address token, uint amount, address to) external onlyByTrusty { IERC20(token).transfer(to, amount); } function toggleMinting() external { require(hasRole(MINT_PAUSER, msg.sender)); mintPaused = !mintPaused; emit MintingToggled(mintPaused); } function toggleRedeeming() external { require(hasRole(REDEEM_PAUSER, msg.sender)); redeemPaused = !redeemPaused; emit RedeemingToggled(redeemPaused); } function toggleRecollateralize() external { require(hasRole(RECOLLATERALIZE_PAUSER, msg.sender)); recollateralizePaused = !recollateralizePaused; emit RecollateralizeToggled(recollateralizePaused); } function toggleBuyBack() external { require(hasRole(BUYBACK_PAUSER, msg.sender)); buyBackPaused = !buyBackPaused; emit BuybackToggled(buyBackPaused); } // Combined into one function due to 24KiB contract memory limit function setPoolParameters( uint256 new_ceiling, uint256 new_bonus_rate, uint256 new_redemption_delay, uint256 new_mint_fee, uint256 new_redeem_fee, uint256 new_buyback_fee, uint256 new_recollat_fee ) external { require(hasRole(PARAMETER_SETTER_ROLE, msg.sender), "POOL: Caller is not PARAMETER_SETTER_ROLE"); pool_ceiling = new_ceiling; bonus_rate = new_bonus_rate; redemption_delay = new_redemption_delay; minting_fee = new_mint_fee; redemption_fee = new_redeem_fee; buyback_fee = new_buyback_fee; recollat_fee = new_recollat_fee; emit PoolParametersSet( new_ceiling, new_bonus_rate, new_redemption_delay, new_mint_fee, new_redeem_fee, new_buyback_fee, new_recollat_fee ); } /* ========== EVENTS ========== */ event PoolParametersSet( uint256 new_ceiling, uint256 new_bonus_rate, uint256 new_redemption_delay, uint256 new_mint_fee, uint256 new_redeem_fee, uint256 new_buyback_fee, uint256 new_recollat_fee ); event daoShareCollected(uint256 daoShare, address to); event MintingToggled(bool toggled); event RedeemingToggled(bool toggled); event RecollateralizeToggled(bool toggled); event BuybackToggled(bool toggled); } //Dar panah khoda
// Be name Khoda // Bime Abolfazl pragma solidity >=0.6.12; import "../Governance/AccessControl.sol"; import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol"; contract Oracle is AccessControl { using ECDSA for bytes32; // role bytes32 public constant ORACLE_ROLE = keccak256("ORACLE_ROLE"); bytes32 public constant TRUSTY_ROLE = keccak256("TRUSTY_ROLE"); uint256 minimumRequiredSignature; event MinimumRequiredSignatureSet(uint256 minimumRequiredSignature); constructor(address _admin, uint256 _minimumRequiredSignature, address _trusty_address) { require(_admin != address(0), "ORACLE::constructor: Zero address detected"); _setupRole(DEFAULT_ADMIN_ROLE, _admin); _setupRole(TRUSTY_ROLE, _trusty_address); minimumRequiredSignature = _minimumRequiredSignature; } function verify(bytes32 hash, bytes[] calldata sigs) public view returns (bool) { address lastOracle; for (uint256 index = 0; index < minimumRequiredSignature; ++index) { address oracle = hash.recover(sigs[index]); require(hasRole(ORACLE_ROLE, oracle), "ORACLE::verify: Signer is not valid"); require(oracle > lastOracle, "ORACLE::verify: Signers are same"); lastOracle = oracle; } return true; } function setMinimumRequiredSignature(uint256 _minimumRequiredSignature) public { require( hasRole(TRUSTY_ROLE, msg.sender), "ORACLE::setMinimumRequiredSignature: You are not a setter" ); minimumRequiredSignature = _minimumRequiredSignature; emit MinimumRequiredSignatureSet(_minimumRequiredSignature); } } //Dar panah khoda
// Be name Khoda // Bime Abolfazl // SPDX-License-Identifier: GPL-2.0-or-later pragma solidity ^0.8.7; // ================================================================================================================= // _|_|_| _|_|_|_| _| _| _|_|_| _|_|_|_| _| | // _| _| _| _| _| _| _| _|_|_| _|_|_| _|_|_| _|_|_| _|_| | // _| _| _|_|_| _| _| _|_| _|_|_| _| _| _| _| _| _| _| _| _|_|_|_| | // _| _| _| _| _| _| _| _| _| _| _| _| _| _| _| _| | // _|_|_| _|_|_|_| _|_| _|_|_| _| _| _| _| _|_|_| _| _| _|_|_| _|_|_| | // ================================================================================================================= // ==================================================================== // =========================== ReserveTracker ========================= // ==================================================================== // Deus Finance: https://github.com/DeusFinance // Primary Author(s) // Jason Huan: https://github.com/jasonhuan // Sam Kazemian: https://github.com/samkazemian // Vahid: https://github.com/vahid-dev // SAYaghoubnejad: https://github.com/SAYaghoubnejad // Reviewer(s) / Contributor(s) // Travis Moore: https://github.com/FortisFortuna import "../Math/SafeMath.sol"; import "../Math/Math.sol"; import "../Uniswap/Interfaces/IUniswapV2Pair.sol"; import "../Governance/AccessControl.sol"; contract ReserveTracker is AccessControl { // Roles bytes32 public constant OWNER_ROLE = keccak256("OWNER_ROLE"); // Various precisions uint256 private PRICE_PRECISION = 1e6; // Contract addresses address private dei_contract_address; address private deus_contract_address; // Array of pairs for DEUS address[] public deus_pairs_array; // Mapping is also used for faster verification mapping(address => bool) public deus_pairs; uint256 public deus_reserves; // ========== MODIFIERS ========== modifier onlyByOwnerOrGovernance() { require(hasRole(OWNER_ROLE, msg.sender), "Caller is not owner"); _; } // ========== CONSTRUCTOR ========== constructor( address _dei_contract_address, address _deus_contract_address ) { dei_contract_address = _dei_contract_address; deus_contract_address = _deus_contract_address; _setupRole(DEFAULT_ADMIN_ROLE, msg.sender); _setupRole(OWNER_ROLE, msg.sender); } // ========== VIEWS ========== function getDEUSReserves() public view returns (uint256) { uint256 total_deus_reserves = 0; for (uint i = 0; i < deus_pairs_array.length; i++){ // Exclude null addresses if (deus_pairs_array[i] != address(0)){ if(IUniswapV2Pair(deus_pairs_array[i]).token0() == deus_contract_address) { (uint reserves0, , ) = IUniswapV2Pair(deus_pairs_array[i]).getReserves(); total_deus_reserves = total_deus_reserves + reserves0; } else if (IUniswapV2Pair(deus_pairs_array[i]).token1() == deus_contract_address) { ( , uint reserves1, ) = IUniswapV2Pair(deus_pairs_array[i]).getReserves(); total_deus_reserves = total_deus_reserves + reserves1; } } } return total_deus_reserves; } // Adds collateral addresses supported, such as tether and busd, must be ERC20 function addDEUSPair(address pair_address) public onlyByOwnerOrGovernance { require(deus_pairs[pair_address] == false, "Address already exists"); deus_pairs[pair_address] = true; deus_pairs_array.push(pair_address); } // Remove a pool function removeDEUSPair(address pair_address) public onlyByOwnerOrGovernance { require(deus_pairs[pair_address] == true, "Address nonexistant"); // Delete from the mapping delete deus_pairs[pair_address]; // 'Delete' from the array by setting the address to 0x0 for (uint i = 0; i < deus_pairs_array.length; i++){ if (deus_pairs_array[i] == pair_address) { deus_pairs_array[i] = address(0); // This will leave a null in the array and keep the indices the same break; } } } } //Dar panah khoda
// SPDX-License-Identifier: MIT pragma solidity ^0.8.0; /** * @dev Elliptic Curve Digital Signature Algorithm (ECDSA) operations. * * These functions can be used to verify that a message was signed by the holder * of the private keys of a given address. */ library ECDSA { /** * @dev Returns the address that signed a hashed message (`hash`) with * `signature`. This address can then be used for verification purposes. * * The `ecrecover` EVM opcode allows for malleable (non-unique) signatures: * this function rejects them by requiring the `s` value to be in the lower * half order, and the `v` value to be either 27 or 28. * * IMPORTANT: `hash` _must_ be the result of a hash operation for the * verification to be secure: it is possible to craft signatures that * recover to arbitrary addresses for non-hashed data. A safe way to ensure * this is by receiving a hash of the original message (which may otherwise * be too long), and then calling {toEthSignedMessageHash} on it. * * Documentation for signature generation: * - with https://web3js.readthedocs.io/en/v1.3.4/web3-eth-accounts.html#sign[Web3.js] * - with https://docs.ethers.io/v5/api/signer/#Signer-signMessage[ethers] */ function recover(bytes32 hash, bytes memory signature) internal pure returns (address) { // Check the signature length // - case 65: r,s,v signature (standard) // - case 64: r,vs signature (cf https://eips.ethereum.org/EIPS/eip-2098) _Available since v4.1._ if (signature.length == 65) { bytes32 r; bytes32 s; uint8 v; // ecrecover takes the signature parameters, and the only way to get them // currently is to use assembly. assembly { r := mload(add(signature, 0x20)) s := mload(add(signature, 0x40)) v := byte(0, mload(add(signature, 0x60))) } return recover(hash, v, r, s); } else if (signature.length == 64) { bytes32 r; bytes32 vs; // ecrecover takes the signature parameters, and the only way to get them // currently is to use assembly. assembly { r := mload(add(signature, 0x20)) vs := mload(add(signature, 0x40)) } return recover(hash, r, vs); } else { revert("ECDSA: invalid signature length"); } } /** * @dev Overload of {ECDSA-recover} that receives the `r` and `vs` short-signature fields separately. * * See https://eips.ethereum.org/EIPS/eip-2098[EIP-2098 short signatures] * * _Available since v4.2._ */ function recover( bytes32 hash, bytes32 r, bytes32 vs ) internal pure returns (address) { bytes32 s; uint8 v; assembly { s := and(vs, 0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) v := add(shr(255, vs), 27) } return recover(hash, v, r, s); } /** * @dev Overload of {ECDSA-recover} that receives the `v`, `r` and `s` signature fields separately. */ function recover( bytes32 hash, uint8 v, bytes32 r, bytes32 s ) internal pure returns (address) { // EIP-2 still allows signature malleability for ecrecover(). Remove this possibility and make the signature // unique. Appendix F in the Ethereum Yellow paper (https://ethereum.github.io/yellowpaper/paper.pdf), defines // the valid range for s in (281): 0 < s < secp256k1n ÷ 2 + 1, and for v in (282): v ∈ {27, 28}. Most // signatures from current libraries generate a unique signature with an s-value in the lower half order. // // If your library generates malleable signatures, such as s-values in the upper range, calculate a new s-value // with 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141 - s1 and flip v from 27 to 28 or // vice versa. If your library also generates signatures with 0/1 for v instead 27/28, add 27 to v to accept // these malleable signatures as well. require( uint256(s) <= 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF5D576E7357A4501DDFE92F46681B20A0, "ECDSA: invalid signature 's' value" ); require(v == 27 || v == 28, "ECDSA: invalid signature 'v' value"); // If the signature is valid (and not malleable), return the signer address address signer = ecrecover(hash, v, r, s); require(signer != address(0), "ECDSA: invalid signature"); return signer; } /** * @dev Returns an Ethereum Signed Message, created from a `hash`. This * produces hash corresponding to the one signed with the * https://eth.wiki/json-rpc/API#eth_sign[`eth_sign`] * JSON-RPC method as part of EIP-191. * * See {recover}. */ function toEthSignedMessageHash(bytes32 hash) internal pure returns (bytes32) { // 32 is the length in bytes of hash, // enforced by the type signature above return keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n32", hash)); } /** * @dev Returns an Ethereum Signed Typed Data, created from a * `domainSeparator` and a `structHash`. This produces hash corresponding * to the one signed with the * https://eips.ethereum.org/EIPS/eip-712[`eth_signTypedData`] * JSON-RPC method as part of EIP-712. * * See {recover}. */ function toTypedDataHash(bytes32 domainSeparator, bytes32 structHash) internal pure returns (bytes32) { return keccak256(abi.encodePacked("\x19\x01", domainSeparator, structHash)); } }
// SPDX-License-Identifier: MIT pragma solidity >=0.6.11; /** * @dev Library for managing * https://en.wikipedia.org/wiki/Set_(abstract_data_type)[sets] of primitive * types. * * Sets have the following properties: * * - Elements are added, removed, and checked for existence in constant time * (O(1)). * - Elements are enumerated in O(n). No guarantees are made on the ordering. * * ``` * contract Example { * // Add the library methods * using EnumerableSet for EnumerableSet.AddressSet; * * // Declare a set state variable * EnumerableSet.AddressSet private mySet; * } * ``` * * As of v3.0.0, only sets of type `address` (`AddressSet`) and `uint256` * (`UintSet`) are supported. */ library EnumerableSet { // To implement this library for multiple types with as little code // repetition as possible, we write it in terms of a generic Set type with // bytes32 values. // The Set implementation uses private functions, and user-facing // implementations (such as AddressSet) are just wrappers around the // underlying Set. // This means that we can only create new EnumerableSets for types that fit // in bytes32. struct Set { // Storage of set values bytes32[] _values; // Position of the value in the `values` array, plus 1 because index 0 // means a value is not in the set. mapping (bytes32 => uint256) _indexes; } /** * @dev Add a value to a set. O(1). * * Returns true if the value was added to the set, that is if it was not * already present. */ function _add(Set storage set, bytes32 value) private returns (bool) { if (!_contains(set, value)) { set._values.push(value); // The value is stored at length-1, but we add 1 to all indexes // and use 0 as a sentinel value set._indexes[value] = set._values.length; return true; } else { return false; } } /** * @dev Removes a value from a set. O(1). * * Returns true if the value was removed from the set, that is if it was * present. */ function _remove(Set storage set, bytes32 value) private returns (bool) { // We read and store the value's index to prevent multiple reads from the same storage slot uint256 valueIndex = set._indexes[value]; if (valueIndex != 0) { // Equivalent to contains(set, value) // To delete an element from the _values array in O(1), we swap the element to delete with the last one in // the array, and then remove the last element (sometimes called as 'swap and pop'). // This modifies the order of the array, as noted in {at}. uint256 toDeleteIndex = valueIndex - 1; uint256 lastIndex = set._values.length - 1; // When the value to delete is the last one, the swap operation is unnecessary. However, since this occurs // so rarely, we still do the swap anyway to avoid the gas cost of adding an 'if' statement. bytes32 lastvalue = set._values[lastIndex]; // Move the last value to the index where the value to delete is set._values[toDeleteIndex] = lastvalue; // Update the index for the moved value set._indexes[lastvalue] = toDeleteIndex + 1; // All indexes are 1-based // Delete the slot where the moved value was stored set._values.pop(); // Delete the index for the deleted slot delete set._indexes[value]; return true; } else { return false; } } /** * @dev Returns true if the value is in the set. O(1). */ function _contains(Set storage set, bytes32 value) private view returns (bool) { return set._indexes[value] != 0; } /** * @dev Returns the number of values on the set. O(1). */ function _length(Set storage set) private view returns (uint256) { return set._values.length; } /** * @dev Returns the value stored at position `index` in the set. O(1). * * Note that there are no guarantees on the ordering of values inside the * array, and it may change when more values are added or removed. * * Requirements: * * - `index` must be strictly less than {length}. */ function _at(Set storage set, uint256 index) private view returns (bytes32) { require(set._values.length > index, "EnumerableSet: index out of bounds"); return set._values[index]; } // AddressSet struct AddressSet { Set _inner; } /** * @dev Add a value to a set. O(1). * * Returns true if the value was added to the set, that is if it was not * already present. */ function add(AddressSet storage set, address value) internal returns (bool) { return _add(set._inner, bytes32(bytes20(value))); } /** * @dev Removes a value from a set. O(1). * * Returns true if the value was removed from the set, that is if it was * present. */ function remove(AddressSet storage set, address value) internal returns (bool) { return _remove(set._inner, bytes32(bytes20(value))); } /** * @dev Returns true if the value is in the set. O(1). */ function contains(AddressSet storage set, address value) internal view returns (bool) { return _contains(set._inner, bytes32(bytes20(value))); } /** * @dev Returns the number of values in the set. O(1). */ function length(AddressSet storage set) internal view returns (uint256) { return _length(set._inner); } /** * @dev Returns the value stored at position `index` in the set. O(1). * * Note that there are no guarantees on the ordering of values inside the * array, and it may change when more values are added or removed. * * Requirements: * * - `index` must be strictly less than {length}. */ function at(AddressSet storage set, uint256 index) internal view returns (address) { return address(bytes20(_at(set._inner, index))); } // UintSet struct UintSet { Set _inner; } /** * @dev Add a value to a set. O(1). * * Returns true if the value was added to the set, that is if it was not * already present. */ function add(UintSet storage set, uint256 value) internal returns (bool) { return _add(set._inner, bytes32(value)); } /** * @dev Removes a value from a set. O(1). * * Returns true if the value was removed from the set, that is if it was * present. */ function remove(UintSet storage set, uint256 value) internal returns (bool) { return _remove(set._inner, bytes32(value)); } /** * @dev Returns true if the value is in the set. O(1). */ function contains(UintSet storage set, uint256 value) internal view returns (bool) { return _contains(set._inner, bytes32(value)); } /** * @dev Returns the number of values on the set. O(1). */ function length(UintSet storage set) internal view returns (uint256) { return _length(set._inner); } /** * @dev Returns the value stored at position `index` in the set. O(1). * * Note that there are no guarantees on the ordering of values inside the * array, and it may change when more values are added or removed. * * Requirements: * * - `index` must be strictly less than {length}. */ function at(UintSet storage set, uint256 index) internal view returns (uint256) { return uint256(_at(set._inner, index)); } }
// SPDX-License-Identifier: MIT pragma solidity >=0.6.11; // helper methods for interacting with ERC20 tokens and sending ETH that do not consistently return true/false library TransferHelper { function safeApprove(address token, address to, uint value) internal { // bytes4(keccak256(bytes('approve(address,uint256)'))); (bool success, bytes memory data) = token.call(abi.encodeWithSelector(0x095ea7b3, to, value)); require(success && (data.length == 0 || abi.decode(data, (bool))), 'TransferHelper: APPROVE_FAILED'); } function safeTransfer(address token, address to, uint value) internal { // bytes4(keccak256(bytes('transfer(address,uint256)'))); (bool success, bytes memory data) = token.call(abi.encodeWithSelector(0xa9059cbb, to, value)); require(success && (data.length == 0 || abi.decode(data, (bool))), 'TransferHelper: TRANSFER_FAILED'); } function safeTransferFrom(address token, address from, address to, uint value) internal { // bytes4(keccak256(bytes('transferFrom(address,address,uint256)'))); (bool success, bytes memory data) = token.call(abi.encodeWithSelector(0x23b872dd, from, to, value)); require(success && (data.length == 0 || abi.decode(data, (bool))), 'TransferHelper: TRANSFER_FROM_FAILED'); } function safeTransferETH(address to, uint value) internal { (bool success,) = to.call{value:value}(new bytes(0)); require(success, 'TransferHelper: ETH_TRANSFER_FAILED'); } }
// Be name Khoda // Bime Abolfazl // SPDX-License-Identifier: GPL-2.0-or-later interface IDEUSToken { function setDEIAddress(address dei_contract_address) external; function mint(address to, uint256 amount) external; // This function is what other dei pools will call to mint new DEUS (similar to the DEI mint) function pool_mint(address m_address, uint256 m_amount) external; // This function is what other dei pools will call to burn DEUS function pool_burn_from(address b_address, uint256 b_amount) external; function toggleVotes() external; /* ========== OVERRIDDEN PUBLIC FUNCTIONS ========== */ function transfer(address recipient, uint256 amount) external returns (bool); function transferFrom( address sender, address recipient, uint256 amount ) external returns (bool); /* ========== PUBLIC FUNCTIONS ========== */ /** * @notice Gets the current votes balance for `account` * @param account The address to get votes balance * @return The number of current votes for `account` */ function getCurrentVotes(address account) external view returns (uint96); /** * @notice Determine the prior number of votes for an account as of a block number * @dev Block number must be a finalized block or else this function will revert to prevent misinformation. * @param account The address of the account to check * @param blockNumber The block number to get the vote balance at * @return The number of votes the account had as of the given block */ function getPriorVotes(address account, uint256 blockNumber) external view returns (uint96); } //Dar panah khoda
// Be name Khoda // Bime Abolfazl // SPDX-License-Identifier: GPL-2.0-or-later interface IDEIStablecoin { function totalSupply() external view returns (uint256); function global_collateral_ratio() external view returns (uint256); function verify_price(bytes32 sighash, bytes[] calldata sigs) external view returns (bool); function dei_info(uint256 eth_usd_price, uint256 eth_collat_price) external view returns ( uint256, uint256, uint256 ); function globalCollateralValue(uint256[] memory collat_usd_price) external view returns (uint256); function refreshCollateralRatio(uint256 dei_price_cur, uint256 expireBlock, bytes[] calldata sigs) external; function pool_burn_from(address b_address, uint256 b_amount) external; function pool_mint(address m_address, uint256 m_amount) external; function addPool(address pool_address) external; function removePool(address pool_address) external; function setDEIStep(uint256 _new_step) external; function setPriceTarget(uint256 _new_price_target) external; function setRefreshCooldown(uint256 _new_cooldown) external; function setDEUSAddress(address _deus_address) external; function setPriceBand(uint256 _price_band) external; function toggleCollateralRatio() external; } //Dar panah khoda
// Be name Khoda // Bime Abolfazl // SPDX-License-Identifier: GPL-2.0-or-later pragma solidity >=0.8.0; contract DEIPoolLibrary { // Constants for various precisions uint256 private constant PRICE_PRECISION = 1e6; constructor() {} // ================ Structs ================ // Needed to lower stack size struct MintFD_Params { uint256 deus_price_usd; uint256 col_price_usd; uint256 collateral_amount; uint256 col_ratio; } struct BuybackDEUS_Params { uint256 excess_collateral_dollar_value_d18; uint256 deus_price_usd; uint256 col_price_usd; uint256 DEUS_amount; } // ================ Functions ================ function calcMint1t1DEI(uint256 col_price, uint256 collateral_amount_d18) public pure returns (uint256) { return (collateral_amount_d18 * col_price) / (1e6); } function calcMintAlgorithmicDEI(uint256 deus_price_usd, uint256 deus_amount_d18) public pure returns (uint256) { return (deus_amount_d18 * deus_price_usd) / (1e6); } // Must be internal because of the struct function calcMintFractionalDEI(MintFD_Params memory params) public pure returns (uint256, uint256) { // Since solidity truncates division, every division operation must be the last operation in the equation to ensure minimum error // 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 uint256 c_dollar_value_d18; // Scoping for stack concerns { // USD amounts of the collateral and the DEUS c_dollar_value_d18 = (params.collateral_amount * params.col_price_usd) / (1e6); } uint calculated_deus_dollar_value_d18 = ((c_dollar_value_d18 * (1e6)) / params.col_ratio) - c_dollar_value_d18; uint calculated_deus_needed = (calculated_deus_dollar_value_d18 * (1e6)) / params.deus_price_usd; return ( c_dollar_value_d18 + calculated_deus_dollar_value_d18, calculated_deus_needed ); } function calcRedeem1t1DEI(uint256 col_price_usd, uint256 DEI_amount) public pure returns (uint256) { return (DEI_amount * (1e6)) / col_price_usd; } // Must be internal because of the struct function calcBuyBackDEUS(BuybackDEUS_Params memory params) public pure returns (uint256) { // 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 require(params.excess_collateral_dollar_value_d18 > 0, "No excess collateral to buy back!"); // Make sure not to take more than is available uint256 deus_dollar_value_d18 = (params.DEUS_amount * (params.deus_price_usd)) / (1e6); require(deus_dollar_value_d18 <= params.excess_collateral_dollar_value_d18, "You are trying to buy back more than the excess!"); // Get the equivalent amount of collateral based on the market value of DEUS provided uint256 collateral_equivalent_d18 = (deus_dollar_value_d18 * (1e6)) / params.col_price_usd; //collateral_equivalent_d18 = collateral_equivalent_d18.sub((collateral_equivalent_d18.mul(params.buyback_fee)).div(1e6)); return collateral_equivalent_d18; } // Returns value of collateral that must increase to reach recollateralization target (if 0 means no recollateralization) function recollateralizeAmount(uint256 total_supply, uint256 global_collateral_ratio, uint256 global_collat_value) public pure returns (uint256) { 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 // Subtract the current value of collateral from the target value needed, if higher than 0 then system needs to recollateralize return target_collat_value - global_collat_value; // If recollateralization is not needed, throws a subtraction underflow // return(recollateralization_left); } function calcRecollateralizeDEIInner( uint256 collateral_amount, uint256 col_price, uint256 global_collat_value, uint256 dei_total_supply, uint256 global_collateral_ratio ) public pure returns (uint256, uint256) { uint256 collat_value_attempted = (collateral_amount * col_price) / (1e6); uint256 effective_collateral_ratio = (global_collat_value * (1e6)) / dei_total_supply; //returns it in 1e6 uint256 recollat_possible = (global_collateral_ratio * dei_total_supply - (dei_total_supply * effective_collateral_ratio)) / (1e6); uint256 amount_to_recollat; if(collat_value_attempted <= recollat_possible){ amount_to_recollat = collat_value_attempted; } else { amount_to_recollat = recollat_possible; } return ((amount_to_recollat * (1e6)) / col_price, amount_to_recollat); } } //Dar panah khoda
// SPDX-License-Identifier: MIT pragma solidity >=0.6.11; /** * @dev Standard math utilities missing in the Solidity language. */ library Math { /** * @dev Returns the largest of two numbers. */ function max(uint256 a, uint256 b) internal pure returns (uint256) { return a >= b ? a : b; } /** * @dev Returns the smallest of two numbers. */ function min(uint256 a, uint256 b) internal pure returns (uint256) { return a < b ? a : b; } /** * @dev Returns the average of two numbers. The result is rounded towards * zero. */ function average(uint256 a, uint256 b) internal pure returns (uint256) { // (a + b) / 2 can overflow, so we distribute return (a / 2) + (b / 2) + ((a % 2 + b % 2) / 2); } // babylonian method (https://en.wikipedia.org/wiki/Methods_of_computing_square_roots#Babylonian_method) function sqrt(uint y) internal pure returns (uint z) { if (y > 3) { z = y; uint x = y / 2 + 1; while (x < z) { z = x; x = (y / x + x) / 2; } } else if (y != 0) { z = 1; } } }
// SPDX-License-Identifier: MIT pragma solidity >=0.6.11; interface IUniswapV2Pair { event Approval(address indexed owner, address indexed spender, uint value); event Transfer(address indexed from, address indexed to, uint value); function name() external pure returns (string memory); function symbol() external pure returns (string memory); function decimals() external pure returns (uint8); function totalSupply() external view returns (uint); function balanceOf(address owner) external view returns (uint); function allowance(address owner, address spender) external view returns (uint); function approve(address spender, uint value) external returns (bool); function transfer(address to, uint value) external returns (bool); function transferFrom(address from, address to, uint value) external returns (bool); function DOMAIN_SEPARATOR() external view returns (bytes32); function PERMIT_TYPEHASH() external pure returns (bytes32); function nonces(address owner) external view returns (uint); function permit(address owner, address spender, uint value, uint deadline, uint8 v, bytes32 r, bytes32 s) external; event Mint(address indexed sender, uint amount0, uint amount1); event Burn(address indexed sender, uint amount0, uint amount1, address indexed to); event Swap( address indexed sender, uint amount0In, uint amount1In, uint amount0Out, uint amount1Out, address indexed to ); event Sync(uint112 reserve0, uint112 reserve1); function MINIMUM_LIQUIDITY() external pure returns (uint); function factory() external view returns (address); function token0() external view returns (address); function token1() external view returns (address); function getReserves() external view returns (uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast); function price0CumulativeLast() external view returns (uint); function price1CumulativeLast() external view returns (uint); function kLast() external view returns (uint); function mint(address to) external returns (uint liquidity); function burn(address to) external returns (uint amount0, uint amount1); function swap(uint amount0Out, uint amount1Out, address to, bytes calldata data) external; function skim(address to) external; function sync() external; function initialize(address, address) external; }
{ "optimizer": { "enabled": true, "runs": 100000 }, "outputSelection": { "*": { "*": [ "evm.bytecode", "evm.deployedBytecode", "abi" ] } }, "metadata": { "useLiteralContent": true }, "libraries": {} }
Contract Security Audit
- No Contract Security Audit Submitted- Submit Audit Here
[{"inputs":[{"internalType":"string","name":"_name","type":"string"},{"internalType":"string","name":"_symbol","type":"string"},{"internalType":"address","name":"_creator_address","type":"address"},{"internalType":"address","name":"_trusty_address","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"spender","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"addr","type":"address"}],"name":"DEIAddressSet","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"DEUSBurned","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"DEUSMinted","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bytes32","name":"role","type":"bytes32"},{"indexed":true,"internalType":"bytes32","name":"previousAdminRole","type":"bytes32"},{"indexed":true,"internalType":"bytes32","name":"newAdminRole","type":"bytes32"}],"name":"RoleAdminChanged","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bytes32","name":"role","type":"bytes32"},{"indexed":true,"internalType":"address","name":"account","type":"address"},{"indexed":true,"internalType":"address","name":"sender","type":"address"}],"name":"RoleGranted","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bytes32","name":"role","type":"bytes32"},{"indexed":true,"internalType":"address","name":"account","type":"address"},{"indexed":true,"internalType":"address","name":"sender","type":"address"}],"name":"RoleRevoked","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Transfer","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"voter","type":"address"},{"indexed":false,"internalType":"uint256","name":"previousBalance","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"newBalance","type":"uint256"}],"name":"VoterVotesChanged","type":"event"},{"inputs":[],"name":"DEFAULT_ADMIN_ROLE","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"MINTER_ROLE","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"TRUSTY_ROLE","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"spender","type":"address"}],"name":"allowance","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"approve","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"burn","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"burnFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"},{"internalType":"uint32","name":"","type":"uint32"}],"name":"checkpoints","outputs":[{"internalType":"uint32","name":"fromBlock","type":"uint32"},{"internalType":"uint96","name":"votes","type":"uint96"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"decimals","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"subtractedValue","type":"uint256"}],"name":"decreaseAllowance","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"genesis_supply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"getCurrentVotes","outputs":[{"internalType":"uint96","name":"","type":"uint96"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"uint256","name":"blockNumber","type":"uint256"}],"name":"getPriorVotes","outputs":[{"internalType":"uint96","name":"","type":"uint96"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"}],"name":"getRoleAdmin","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"},{"internalType":"uint256","name":"index","type":"uint256"}],"name":"getRoleMember","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"}],"name":"getRoleMemberCount","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"},{"internalType":"address","name":"account","type":"address"}],"name":"grantRole","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"},{"internalType":"address","name":"account","type":"address"}],"name":"hasRole","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"addedValue","type":"uint256"}],"name":"increaseAllowance","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"mint","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"numCheckpoints","outputs":[{"internalType":"uint32","name":"","type":"uint32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"b_address","type":"address"},{"internalType":"uint256","name":"b_amount","type":"uint256"}],"name":"pool_burn_from","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"m_address","type":"address"},{"internalType":"uint256","name":"m_amount","type":"uint256"}],"name":"pool_mint","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"},{"internalType":"address","name":"account","type":"address"}],"name":"renounceRole","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"},{"internalType":"address","name":"account","type":"address"}],"name":"revokeRole","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"dei_contract_address","type":"address"}],"name":"setDEIAddress","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"toggleVotes","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"trackingVotes","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"recipient","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transfer","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"sender","type":"address"},{"internalType":"address","name":"recipient","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transferFrom","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"}]
Contract Creation Code
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
Deployed Bytecode
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
Constructor Arguments (ABI-Encoded and is the last bytes of the Contract Creation Code above)
000000000000000000000000000000000000000000000000000000000000008000000000000000000000000000000000000000000000000000000000000000c0000000000000000000000000fe351f5ed699fd5ea80b906f89dfdad2f885a46c000000000000000000000000fe351f5ed699fd5ea80b906f89dfdad2f885a46c0000000000000000000000000000000000000000000000000000000000000004444555530000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000044445555300000000000000000000000000000000000000000000000000000000
-----Decoded View---------------
Arg [0] : _name (string): DEUS
Arg [1] : _symbol (string): DEUS
Arg [2] : _creator_address (address): 0xfE351F5Ed699fd5eA80b906F89DfdAd2f885A46C
Arg [3] : _trusty_address (address): 0xfE351F5Ed699fd5eA80b906F89DfdAd2f885A46C
-----Encoded View---------------
8 Constructor Arguments found :
Arg [0] : 0000000000000000000000000000000000000000000000000000000000000080
Arg [1] : 00000000000000000000000000000000000000000000000000000000000000c0
Arg [2] : 000000000000000000000000fe351f5ed699fd5ea80b906f89dfdad2f885a46c
Arg [3] : 000000000000000000000000fe351f5ed699fd5ea80b906f89dfdad2f885a46c
Arg [4] : 0000000000000000000000000000000000000000000000000000000000000004
Arg [5] : 4445555300000000000000000000000000000000000000000000000000000000
Arg [6] : 0000000000000000000000000000000000000000000000000000000000000004
Arg [7] : 4445555300000000000000000000000000000000000000000000000000000000
Loading...
Loading
Loading...
Loading
[ Download: CSV Export ]
[ Download: CSV Export ]
A token is a representation of an on-chain or off-chain asset. The token page shows information such as price, total supply, holders, transfers and social links. Learn more about this page in our Knowledge Base.