-
-
Save RideSolo/ab90f1c3a8808fd1ab7f286d4152fc76 to your computer and use it in GitHub Desktop.
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
pragma solidity ^0.5.7; | |
interface ERC20 { | |
function balanceOf(address who) external view returns (uint256); | |
function transfer(address to, uint256 value) external returns (bool); | |
function allowance(address owner, address spender) external view returns (uint256); | |
function transferFrom(address from, address to, uint256 value) external returns (bool); | |
function approve(address spender, uint256 value) external returns (bool); | |
event Transfer(address indexed from, address indexed to, uint256 value); | |
event Approval(address indexed owner, address indexed spender, uint256 value); | |
} | |
interface ERC223 { | |
function transfer(address to, uint value, bytes calldata data) external; | |
event Transfer(address indexed from, address indexed to, uint value, bytes indexed data); | |
} | |
contract ERC223ReceivingContract { | |
function tokenFallback(address _from, uint _value, bytes memory _data) public; | |
} | |
/** | |
* @title SafeMath | |
* @dev Unsigned math operations with safety checks that revert on error. | |
*/ | |
library SafeMath { | |
/** | |
* @dev Multiplies two unsigned integers, reverts on 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-solidity/pull/522 | |
if (a == 0) { | |
return 0; | |
} | |
uint256 c = a * b; | |
require(c / a == b); | |
return c; | |
} | |
/** | |
* @dev Integer division of two unsigned integers truncating the quotient, reverts on division by zero. | |
*/ | |
function div(uint256 a, uint256 b) internal pure returns (uint256) { | |
// Solidity only automatically asserts when dividing by 0 | |
require(b > 0); | |
uint256 c = a / b; | |
// assert(a == b * c + a % b); // There is no case in which this doesn't hold | |
return c; | |
} | |
/** | |
* @dev Subtracts two unsigned integers, reverts on overflow (i.e. if subtrahend is greater than minuend). | |
*/ | |
function sub(uint256 a, uint256 b) internal pure returns (uint256) { | |
require(b <= a); | |
uint256 c = a - b; | |
return c; | |
} | |
/** | |
* @dev Adds two unsigned integers, reverts on overflow. | |
*/ | |
function add(uint256 a, uint256 b) internal pure returns (uint256) { | |
uint256 c = a + b; | |
require(c >= a); | |
return c; | |
} | |
/** | |
* @dev Divides two unsigned integers and returns the remainder (unsigned integer modulo), | |
* reverts when dividing by zero. | |
*/ | |
function mod(uint256 a, uint256 b) internal pure returns (uint256) { | |
require(b != 0); | |
return a % b; | |
} | |
} | |
contract StandardToken is ERC20, ERC223 { | |
uint256 public totalSupply; | |
using SafeMath for uint; | |
mapping (address => uint256) internal balances; | |
mapping (address => mapping (address => uint256)) internal allowed; | |
function transfer(address _to, uint256 _value) public returns (bool) { | |
require(_to != address(0)); | |
require(_value <= balances[msg.sender]); | |
balances[msg.sender] = SafeMath.sub(balances[msg.sender], _value); | |
balances[_to] = SafeMath.add(balances[_to], _value); | |
emit Transfer(msg.sender, _to, _value); | |
return true; | |
} | |
function balanceOf(address _owner) public view returns (uint256 balance) { | |
return balances[_owner]; | |
} | |
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) { | |
require(_to != address(0)); | |
require(_value <= balances[_from]); | |
require(_value <= allowed[_from][msg.sender]); | |
balances[_from] = SafeMath.sub(balances[_from], _value); | |
balances[_to] = SafeMath.add(balances[_to], _value); | |
allowed[_from][msg.sender] = SafeMath.sub(allowed[_from][msg.sender], _value); | |
emit Transfer(_from, _to, _value); | |
return true; | |
} | |
function approve(address _spender, uint256 _value) public returns (bool) { | |
allowed[msg.sender][_spender] = _value; | |
emit Approval(msg.sender, _spender, _value); | |
return true; | |
} | |
function allowance(address _owner, address _spender) public view returns (uint256) { | |
return allowed[_owner][_spender]; | |
} | |
function increaseApproval(address _spender, uint _addedValue) public returns (bool) { | |
allowed[msg.sender][_spender] = SafeMath.add(allowed[msg.sender][_spender], _addedValue); | |
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]); | |
return true; | |
} | |
function decreaseApproval(address _spender, uint _subtractedValue) public returns (bool) { | |
uint oldValue = allowed[msg.sender][_spender]; | |
if (_subtractedValue > oldValue) { | |
allowed[msg.sender][_spender] = 0; | |
} else { | |
allowed[msg.sender][_spender] = SafeMath.sub(oldValue, _subtractedValue); | |
} | |
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]); | |
return true; | |
} | |
function transfer(address _to, uint _value, bytes memory _data) public { | |
require(_value > 0 ); | |
if(isContract(_to)) { | |
ERC223ReceivingContract receiver = ERC223ReceivingContract(_to); | |
receiver.tokenFallback(msg.sender, _value, _data); | |
} | |
balances[msg.sender] = balances[msg.sender].sub(_value); | |
balances[_to] = balances[_to].add(_value); | |
emit Transfer(msg.sender, _to, _value, _data); | |
} | |
function isContract(address _addr) private view returns (bool is_contract) { | |
uint length; | |
assembly { | |
//retrieve the size of the code on target address, this needs assembly | |
length := extcodesize(_addr) | |
} | |
return (length>0); | |
} | |
} | |
contract crad is StandardToken { | |
string public constant name = "CRAD CASH"; | |
string public constant symbol = "CRAD"; | |
uint8 public constant decimals = 18; | |
uint256 public constant initialSupply = 100000000 * 10 ** uint256(decimals); | |
address public burnaddr = 0x0000000000000000000000000000000000000000; | |
address payable owner; | |
constructor() public { | |
owner = msg.sender; | |
totalSupply = initialSupply; | |
balances[owner] = initialSupply; | |
} | |
function () external payable { | |
owner.transfer(msg.value); | |
} | |
function burn(uint256 _value) public returns (bool success) { | |
require(balances[msg.sender] >= _value); | |
balances[msg.sender] -= _value; | |
totalSupply -= _value; | |
emit Transfer(msg.sender, burnaddr, _value); | |
return true; | |
} | |
} |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment