{{
"language": "Solidity",
"sources": {
"ValasToken.sol": {
"content": "pragma solidity 0.7.6;\n\n// SPDX-License-Identifier: MIT\n\nimport \"SafeMath.sol\";\nimport \"IERC20.sol\";\n\ncontract ValasToken is IERC20 {\n\n using SafeMath for uint256;\n\n string public constant symbol = \"VALAS\";\n string public constant name = \"Valas Finance Protocol Token\";\n uint8 public constant decimals = 18;\n uint256 public override totalSupply;\n uint256 public immutable maxTotalSupply;\n address public minter;\n uint256 public immutable startTime;\n\n address public treasury;\n uint256 public immutable maxTreasuryMintable;\n uint256 public treasuryMintedTokens;\n\n mapping(address => uint256) public override balanceOf;\n mapping(address => mapping(address => uint256)) public override allowance;\n\n constructor(uint256 _maxTotalSupply, uint256 _maxTreasuryMintable, uint256 _startTime) {\n maxTotalSupply = _maxTotalSupply;\n startTime = _startTime;\n treasury = msg.sender;\n maxTreasuryMintable = _maxTreasuryMintable;\n emit Transfer(address(0), msg.sender, 0);\n }\n\n function setMinter(address _minter) external returns (bool) {\n require(minter == address(0));\n minter = _minter;\n return true;\n }\n\n function approve(address _spender, uint256 _value) external override returns (bool) {\n allowance[msg.sender][_spender] = _value;\n emit Approval(msg.sender, _spender, _value);\n return true;\n }\n\n /** shared logic for transfer and transferFrom */\n function _transfer(address _from, address _to, uint256 _value) internal {\n if (block.timestamp < startTime) {\n require(_from == treasury, \"Cannot transfer before startTime\");\n }\n require(balanceOf[_from] >= _value, \"Insufficient balance\");\n balanceOf[_from] = balanceOf[_from].sub(_value);\n balanceOf[_to] = balanceOf[_to].add(_value);\n emit Transfer(_from, _to, _value);\n }\n\n /**\n @notice Transfer tokens to a specified address\n @param _to The address to transfer to\n @param _value The amount to be transferred\n @return Success boolean\n */\n function transfer(address _to, uint256 _value) public override returns (bool) {\n _transfer(msg.sender, _to, _value);\n return true;\n }\n\n /**\n @notice Transfer tokens from one address to another\n @param _from The address which you want to send tokens from\n @param _to The address which you want to transfer to\n @param _value The amount of tokens to be transferred\n @return Success boolean\n */\n function transferFrom(\n address _from,\n address _to,\n uint256 _value\n )\n public\n override\n returns (bool)\n {\n uint256 allowed = allowance[_from][msg.sender];\n require(allowed >= _value, \"Insufficient allowance\");\n if (allowed != uint(-1)) {\n allowance[_from][msg.sender] = allowed.sub(_value);\n }\n _transfer(_from, _to, _value);\n return true;\n }\n\n function burn(uint256 _value) external returns (bool) {\n require(balanceOf[msg.sender] >= _value, \"Insufficient balance\");\n balanceOf[msg.sender] = balanceOf[msg.sender].sub(_value);\n totalSupply = totalSupply.sub(_value);\n emit Transfer(msg.sender, address(0), _value);\n return true;\n }\n\n function mint(address _to, uint256 _value) external returns (bool) {\n if (msg.sender != minter) {\n require(msg.sender == treasury);\n treasuryMintedTokens = treasuryMintedTokens.add(_value);\n require(treasuryMintedTokens <= maxTreasuryMintable);\n }\n balanceOf[_to] = balanceOf[_to].add(_value);\n totalSupply = totalSupply.add(_value);\n require(maxTotalSupply >= totalSupply);\n emit Transfer(address(0), _to, _value);\n return true;\n }\n\n function setTreasury(address _treasury) external {\n require(msg.sender == treasury);\n treasury = _treasury;\n }\n\n}\n"
},
"SafeMath.sol": {
"content": "// SPDX-License-Identifier: agpl-3.0\npragma solidity 0.7.6;\n\n/**\n * @dev Wrappers over Solidity's arithmetic operations with added overflow\n * checks.\n *\n * Arithmetic operations in Solidity wrap on overflow. This can easily result\n * in bugs, because programmers usually assume that an overflow raises an\n * error, which is the standard behavior in high level programming languages.\n * `SafeMath` restores this intuition by reverting the transaction when an\n * operation overflows.\n *\n * Using this library instead of the unchecked operations eliminates an entire\n * class of bugs, so it's recommended to use it always.\n */\nlibrary SafeMath {\n /**\n * @dev Returns the addition of two unsigned integers, reverting on\n * overflow.\n *\n * Counterpart to Solidity's ` ` operator.\n *\n * Requirements:\n * - Addition cannot overflow.\n */\n function add(uint256 a, uint256 b) internal pure returns (uint256) {\n uint256 c = a b;\n require(c >= a, 'SafeMath: addition overflow');\n\n return c;\n }\n\n /**\n * @dev Returns the subtraction of two unsigned integers, reverting on\n * overflow (when the result is negative).\n *\n * Counterpart to Solidity's `-` operator.\n *\n * Requirements:\n * - Subtraction cannot overflow.\n */\n function sub(uint256 a, uint256 b) internal pure returns (uint256) {\n return sub(a, b, 'SafeMath: subtraction overflow');\n }\n\n /**\n * @dev Returns the subtraction of two unsigned integers, reverting with custom message on\n * overflow (when the result is negative).\n *\n * Counterpart to Solidity's `-` operator.\n *\n * Requirements:\n * - Subtraction cannot overflow.\n */\n function sub(\n uint256 a,\n uint256 b,\n string memory errorMessage\n ) internal pure returns (uint256) {\n require(b <= a, errorMessage);\n uint256 c = a - b;\n\n return c;\n }\n\n /**\n * @dev Returns the multiplication of two unsigned integers, reverting on\n * overflow.\n *\n * Counterpart to Solidity's `*` operator.\n *\n * Requirements:\n * - Multiplication cannot overflow.\n */\n function mul(uint256 a, uint256 b) internal pure returns (uint256) {\n // Gas optimization: this is cheaper than requiring 'a' not being zero, but the\n // benefit is lost if 'b' is also tested.\n // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522\n if (a == 0) {\n return 0;\n }\n\n uint256 c = a * b;\n require(c / a == b, 'SafeMath: multiplication overflow');\n\n return c;\n }\n\n /**\n * @dev Returns the integer division of two unsigned integers. Reverts on\n * division by zero. The result is rounded towards zero.\n *\n * Counterpart to Solidity's `/` operator. Note: this function uses a\n * `revert` opcode (which leaves remaining gas untouched) while Solidity\n * uses an invalid opcode to revert (consuming all remaining gas).\n *\n * Requirements:\n * - The divisor cannot be zero.\n */\n function div(uint256 a, uint256 b) internal pure returns (uint256) {\n return div(a, b, 'SafeMath: division by zero');\n }\n\n /**\n * @dev Returns the integer division of two unsigned integers. Reverts with custom message on\n * division by zero. The result is rounded towards zero.\n *\n * Counterpart to Solidity's `/` operator. Note: this function uses a\n * `revert` opcode (which leaves remaining gas untouched) while Solidity\n * uses an invalid opcode to revert (consuming all remaining gas).\n *\n * Requirements:\n * - The divisor cannot be zero.\n */\n function div(\n uint256 a,\n uint256 b,\n string memory errorMessage\n ) internal pure returns (uint256) {\n // Solidity only automatically asserts when dividing by 0\n require(b > 0, errorMessage);\n uint256 c = a / b;\n // assert(a == b * c a % b); // There is no case in which this doesn't hold\n\n return c;\n }\n\n /**\n * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),\n * Reverts when dividing by zero.\n *\n * Counterpart to Solidity's `%` operator. This function uses a `revert`\n * opcode (which leaves remaining gas untouched) while Solidity uses an\n * invalid opcode to revert (consuming all remaining gas).\n *\n * Requirements:\n * - The divisor cannot be zero.\n */\n function mod(uint256 a, uint256 b) internal pure returns (uint256) {\n return mod(a, b, 'SafeMath: modulo by zero');\n }\n\n /**\n * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),\n * Reverts with custom message when dividing by zero.\n *\n * Counterpart to Solidity's `%` operator. This function uses a `revert`\n * opcode (which leaves remaining gas untouched) while Solidity uses an\n * invalid opcode to revert (consuming all remaining gas).\n *\n * Requirements:\n * - The divisor cannot be zero.\n */\n function mod(\n uint256 a,\n uint256 b,\n string memory errorMessage\n ) internal pure returns (uint256) {\n require(b != 0, errorMessage);\n return a % b;\n }\n}\n"
},
"IERC20.sol": {
"content": "// SPDX-License-Identifier: agpl-3.0\npragma solidity 0.7.6;\n\n/**\n * @dev Interface of the ERC20 standard as defined in the EIP.\n */\ninterface IERC20 {\n /**\n * @dev Returns the amount of tokens in existence.\n */\n function totalSupply() external view returns (uint256);\n\n /**\n * @dev Returns the amount of tokens owned by `account`.\n */\n function balanceOf(address account) external view returns (uint256);\n\n /**\n * @dev Moves `amount` tokens from the caller's account to `recipient`.\n *\n * Returns a boolean value indicating whether the operation succeeded.\n *\n * Emits a {Transfer} event.\n */\n function transfer(address recipient, uint256 amount) external returns (bool);\n\n /**\n * @dev Returns the remaining number of tokens that `spender` will be\n * allowed to spend on behalf of `owner` through {transferFrom}. This is\n * zero by default.\n *\n * This value changes when {approve} or {transferFrom} are called.\n */\n function allowance(address owner, address spender) external view returns (uint256);\n\n /**\n * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.\n *\n * Returns a boolean value indicating whether the operation succeeded.\n *\n * IMPORTANT: Beware that changing an allowance with this method brings the risk\n * that someone may use both the old and the new allowance by unfortunate\n * transaction ordering. One possible solution to mitigate this race\n * condition is to first reduce the spender's allowance to 0 and set the\n * desired value afterwards:\n * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729\n *\n * Emits an {Approval} event.\n */\n function approve(address spender, uint256 amount) external returns (bool);\n\n /**\n * @dev Moves `amount` tokens from `sender` to `recipient` using the\n * allowance mechanism. `amount` is then deducted from the caller's\n * allowance.\n *\n * Returns a boolean value indicating whether the operation succeeded.\n *\n * Emits a {Transfer} event.\n */\n function transferFrom(\n address sender,\n address recipient,\n uint256 amount\n ) external returns (bool);\n\n /**\n * @dev Emitted when `value` tokens are moved from one account (`from`) to\n * another (`to`).\n *\n * Note that `value` may be zero.\n */\n event Transfer(address indexed from, address indexed to, uint256 value);\n\n /**\n * @dev Emitted when the allowance of a `spender` for an `owner` is set by\n * a call to {approve}. `value` is the new allowance.\n */\n event Approval(address indexed owner, address indexed spender, uint256 value);\n}\n"
}
},
"settings": {
"evmVersion": "istanbul",
"optimizer": {
"enabled": true,
"runs": 200
},
"libraries": {
"ValasToken.sol": {}
},
"outputSelection": {
"*": {
"*": [
"evm.bytecode",
"evm.deployedBytecode",
"devdoc",
"userdoc",
"metadata",
"abi"
]
}
}
}
}}