Commit
This commit does not belong to any branch on this repository, and may belong to a fork outside of the repository.
Token
- Loading branch information
0 parents
commit 7e59e68
{{ message }}
Token
7e59e68There was a problem hiding this comment.
Choose a reason for hiding this comment
The reason will be displayed to describe this comment to others. Learn more.
pragma solidity ^0.5.0;
/**
@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.
SafeMathrestores this intuition by reverting the transaction when anoperation 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:
*/
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:
*/
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a, "SafeMath: subtraction overflow");
uint256 c = a - b;
return c;
}
/**
@dev Returns the multiplication of two unsigned integers, reverting on
overflow.
Counterpart to Solidity's
*operator.Requirements:
*/
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: improve mul performance and reduce gas cost OpenZeppelin/openzeppelin-contracts#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 arevertopcode (which leaves remaining gas untouched) while Solidityuses an invalid opcode to revert (consuming all remaining gas).
Requirements:
*/
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// Solidity only automatically asserts when dividing by 0
require(b > 0, "SafeMath: division by zero");
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
/**
%operator. This function uses arevert*/
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0, "SafeMath: modulo by zero");
return a % b;
}
}
pragma solidity ^0.5.0;
/**
@dev Interface of the ERC20 standard as defined in the EIP. Does not include
the optional functions; to access them see {ERC20Detailed}.
/
interface IERC20 {
/*
*/
function totalSupply() external view returns (uint256);
/**
account.*/
function balanceOf(address account) external view returns (uint256);
/**
amounttokens from the caller's account torecipient.*/
function transfer(address recipient, uint256 amount) external returns (bool);
/**
spenderwill beownerthrough {transferFrom}. This is*/
function allowance(address owner, address spender) external view returns (uint256);
/**
amountas the allowance ofspenderover the caller's tokens.*/
function approve(address spender, uint256 amount) external returns (bool);
/**
amounttokens fromsendertorecipientusing theamountis then deducted from the caller's*/
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
/**
valuetokens are moved from one account (from) toto).valuemay be zero.*/
event Transfer(address indexed from, address indexed to, uint256 value);
/**
spenderfor anowneris set byvalueis the new allowance.*/
event Approval(address indexed owner, address indexed spender, uint256 value);
}
pragma solidity ^0.5.0;
import "./IERC20.sol";
/**
@dev Optional functions from the ERC20 standard.
*/
contract ERC20Detailed is IERC20 {
string private _name;
string private _symbol;
uint8 private _decimals;
/**
name,symbol, anddecimals. All three of*/
constructor (string memory name, string memory symbol, uint8 decimals) public {
_name = name;
_symbol = symbol;
_decimals = decimals;
}
/**
*/
function name() public view returns (string memory) {
return _name;
}
/**
*/
function symbol() public view returns (string memory) {
return _symbol;
}
/**
decimalsequals2, a balance of505tokens should5,05(505 / 10 ** 2).*/
function decimals() public view returns (uint8) {
return _decimals;
}
}
pragma solidity ^0.5.0;
import "./IERC20.sol";
import "./SafeMath.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
falseon failure. This behavior is nonetheless conventionaland 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 IERC20 {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
/**
*/
function totalSupply() public view returns (uint256) {
return _totalSupply;
}
/**
*/
function balanceOf(address account) public view returns (uint256) {
return _balances[account];
}
/**
recipientcannot be the zero address.amount.*/
function transfer(address recipient, uint256 amount) public returns (bool) {
_transfer(msg.sender, recipient, amount);
return true;
}
/**
*/
function allowance(address owner, address spender) public view returns (uint256) {
return _allowances[owner][spender];
}
/**
spendercannot be the zero address.*/
function approve(address spender, uint256 value) public returns (bool) {
_approve(msg.sender, spender, value);
return true;
}
/**
senderandrecipientcannot be the zero address.sendermust have a balance of at leastvalue.sender's tokens of at leastamount.*/
function transferFrom(address sender, address recipient, uint256 amount) public returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, msg.sender, _allowances[sender][msg.sender].sub(amount));
return true;
}
/**
spenderby the caller.spendercannot be the zero address.*/
function increaseAllowance(address spender, uint256 addedValue) public returns (bool) {
_approve(msg.sender, spender, _allowances[msg.sender][spender].add(addedValue));
return true;
}
/**
spenderby the caller.spendercannot be the zero address.spendermust have allowance for the caller of at leastsubtractedValue.*/
function decreaseAllowance(address spender, uint256 subtractedValue) public returns (bool) {
_approve(msg.sender, spender, _allowances[msg.sender][spender].sub(subtractedValue));
return true;
}
/**
@dev Moves tokens
amountfromsendertorecipient.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:
sendercannot be the zero address.recipientcannot be the zero address.sendermust have a balance of at leastamount.*/
function _transfer(address sender, address recipient, uint256 amount) internal {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_balances[sender] = _balances[sender].sub(amount);
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
/** @dev Creates
amounttokens and assigns them toaccount, increasingthe total supply.
Emits a {Transfer} event with
fromset to the zero address.Requirements
tocannot be the zero address.*/
function _mint(address account, uint256 amount) internal {
require(account != address(0), "ERC20: mint to the zero address");
_totalSupply = _totalSupply.add(amount);
_balances[account] = _balances[account].add(amount);
emit Transfer(address(0), account, amount);
}
/**
@dev Destroys
amounttokens fromaccount, reducing thetotal supply.
Emits a {Transfer} event with
toset to the zero address.Requirements
accountcannot be the zero address.accountmust have at leastamounttokens.*/
function _burn(address account, uint256 value) internal {
require(account != address(0), "ERC20: burn from the zero address");
_totalSupply = _totalSupply.sub(value);
_balances[account] = _balances[account].sub(value);
emit Transfer(account, address(0), value);
}
/**
@dev Sets
amountas the allowance ofspenderover theowners tokens.This is internal function is equivalent to
approve, and can be used toe.g. set automatic allowances for certain subsystems, etc.
Emits an {Approval} event.
Requirements:
ownercannot be the zero address.spendercannot be the zero address.*/
function _approve(address owner, address spender, uint256 value) internal {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = value;
emit Approval(owner, spender, value);
}
/**
amounttokens fromaccount.amountis then deducted*/
function _burnFrom(address account, uint256 amount) internal {
_burn(account, amount);
_approve(account, msg.sender, _allowances[account][msg.sender].sub(amount));
}
}