pragmasolidity ^0.5.0;import"./IERC20.sol";
import"./SafeMath.sol";
/**
* @title Standard ERC20 token
*
* @dev Implementation of the basic standard token.
* https://github.com/ethereum/EIPs/blob/master/EIPS/eip-20.md
* Originally based on code by FirstBlood: https://github.com/Firstbloodio/token/blob/master/smart_contract/FirstBloodToken.sol
*/contractERC20isIERC20{
usingSafeMathforuint256;
mapping (address=>uint256) private _balances;
mapping (address=>mapping (address=>uint256)) private _allowed;
uint256private _totalSupply;
/**
* @dev Total number of tokens in existence
*/functiontotalSupply() publicviewreturns (uint256) {
return _totalSupply;
}
/**
* @dev Gets the balance of the specified address.
* @param owner The address to query the balance of.
* @return An uint256 representing the amount owned by the passed address.
*/functionbalanceOf(address owner) publicviewreturns (uint256) {
return _balances[owner];
}
/**
* @dev Function to check the amount of tokens that an owner allowed to a spender.
* @param owner address The address which owns the funds.
* @param spender address The address which will spend the funds.
* @return A uint256 specifying the amount of tokens still available for the spender.
*/functionallowance(address owner,
address spender
)
publicviewreturns (uint256)
{
return _allowed[owner][spender];
}
/**
* @dev Transfer token for a specified address
* @param to The address to transfer to.
* @param value The amount to be transferred.
*/functiontransfer(address to, uint256 value) publicreturns (bool) {
_transfer(msg.sender, to, value);
returntrue;
}
/**
* @dev Approve the passed address to spend the specified amount of tokens on behalf of msg.sender.
* 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
* @param spender The address which will spend the funds.
* @param value The amount of tokens to be spent.
*/functionapprove(address spender, uint256 value) publicreturns (bool) {
require(spender !=address(0));
_allowed[msg.sender][spender] = value;
emit Approval(msg.sender, spender, value);
returntrue;
}
/**
* @dev Transfer tokens from one address to another
* @param from address The address which you want to send tokens from
* @param to address The address which you want to transfer to
* @param value uint256 the amount of tokens to be transferred
*/functiontransferFrom(addressfrom,
address to,
uint256 value
)
publicreturns (bool)
{
require(value <= _allowed[from][msg.sender]);
_allowed[from][msg.sender] = _allowed[from][msg.sender].sub(value);
_transfer(from, to, value);
returntrue;
}
/**
* @dev Increase the amount of tokens that an owner allowed to a spender.
* approve should be called when allowed_[_spender] == 0. To increment
* allowed value is better to use this function to avoid 2 calls (and wait until
* the first transaction is mined)
* From MonolithDAO Token.sol
* @param spender The address which will spend the funds.
* @param addedValue The amount of tokens to increase the allowance by.
*/functionincreaseAllowance(address spender,
uint256 addedValue
)
publicreturns (bool)
{
require(spender !=address(0));
_allowed[msg.sender][spender] = (
_allowed[msg.sender][spender].add(addedValue));
emit Approval(msg.sender, spender, _allowed[msg.sender][spender]);
returntrue;
}
/**
* @dev Decrease the amount of tokens that an owner allowed to a spender.
* approve should be called when allowed_[_spender] == 0. To decrement
* allowed value is better to use this function to avoid 2 calls (and wait until
* the first transaction is mined)
* From MonolithDAO Token.sol
* @param spender The address which will spend the funds.
* @param subtractedValue The amount of tokens to decrease the allowance by.
*/functiondecreaseAllowance(address spender,
uint256 subtractedValue
)
publicreturns (bool)
{
require(spender !=address(0));
_allowed[msg.sender][spender] = (
_allowed[msg.sender][spender].sub(subtractedValue));
emit Approval(msg.sender, spender, _allowed[msg.sender][spender]);
returntrue;
}
/**
* @dev Transfer token for a specified addresses
* @param from The address to transfer from.
* @param to The address to transfer to.
* @param value The amount to be transferred.
*/function_transfer(addressfrom, address to, uint256 value) internal{
require(value <= _balances[from]);
require(to !=address(0));
_balances[from] = _balances[from].sub(value);
_balances[to] = _balances[to].add(value);
emit Transfer(from, to, value);
}
/**
* @dev Internal function that mints an amount of the token and assigns it to
* an account. This encapsulates the modification of balances such that the
* proper events are emitted.
* @param account The account that will receive the created tokens.
* @param value The amount that will be created.
*/function_mint(address account, uint256 value) internal{
require(account !=address(0));
_totalSupply = _totalSupply.add(value);
_balances[account] = _balances[account].add(value);
emit Transfer(address(0), account, value);
}
/**
* @dev Internal function that burns an amount of the token of a given
* account.
* @param account The account whose tokens will be burnt.
* @param value The amount that will be burnt.
*/function_burn(address account, uint256 value) internal{
require(account !=address(0));
require(value <= _balances[account]);
_totalSupply = _totalSupply.sub(value);
_balances[account] = _balances[account].sub(value);
emit Transfer(account, address(0), value);
}
/**
* @dev Internal function that burns an amount of the token of a given
* account, deducting from the sender's allowance for said account. Uses the
* internal burn function.
* @param account The account whose tokens will be burnt.
* @param value The amount that will be burnt.
*/function_burnFrom(address account, uint256 value) internal{
require(value <= _allowed[account][msg.sender]);
// Should https://github.com/OpenZeppelin/zeppelin-solidity/issues/707 be accepted,// this function needs to emit an event with the updated approval.
_allowed[account][msg.sender] = _allowed[account][msg.sender].sub(
value);
_burn(account, value);
}
}
Contract Source Code
File 2 of 8: ERC20Burnable.sol
pragmasolidity ^0.5.0;import"./ERC20.sol";
/**
* @title Burnable Token
* @dev Token that can be irreversibly burned (destroyed).
*/contractERC20BurnableisERC20{
/**
* @dev Burns a specific amount of tokens.
* @param value The amount of token to be burned.
*/functionburn(uint256 value) public{
_burn(msg.sender, value);
}
/**
* @dev Burns a specific amount of tokens from the target address and decrements allowance
* @param from address The address which you want to send tokens from
* @param value uint256 The amount of token to be burned
*//*
--Do not use
function burnFrom(address from, uint256 value) public {
_burnFrom(from, value);
//Only the owner's address can be burned. @ejkang
}
*/
}
Contract Source Code
File 3 of 8: ERC20Detailed.sol
pragmasolidity ^0.5.0;import"./IERC20.sol";
/**
* @title ERC20Detailed token
* @dev The decimals are only for visualization purposes.
* All the operations are done using the smallest and indivisible token unit,
* just as on Ethereum all the operations are done in wei.
*/contractERC20DetailedisIERC20{
stringprivate _name;
stringprivate _symbol;
uint8private _decimals;
constructor(stringmemory name, stringmemory symbol, uint8 decimals) public{
_name = name;
_symbol = symbol;
_decimals = decimals;
}
/**
* @return the name of the token.
*/functionname() publicviewreturns(stringmemory) {
return _name;
}
/**
* @return the symbol of the token.
*/functionsymbol() publicviewreturns(stringmemory) {
return _symbol;
}
/**
* @return the number of decimals of the token.
*/functiondecimals() publicviewreturns(uint8) {
return _decimals;
}
}
Contract Source Code
File 4 of 8: IERC20.sol
pragmasolidity ^0.5.0;/**
* @title ERC20 interface
* @dev see https://github.com/ethereum/EIPs/issues/20
*/interfaceIERC20{
functiontotalSupply() externalviewreturns (uint256);
functionbalanceOf(address who) externalviewreturns (uint256);
functionallowance(address owner, address spender)
externalviewreturns (uint256);
functiontransfer(address to, uint256 value) externalreturns (bool);
functionapprove(address spender, uint256 value)
externalreturns (bool);
functiontransferFrom(addressfrom, address to, uint256 value)
externalreturns (bool);
eventTransfer(addressindexedfrom,
addressindexed to,
uint256 value
);
eventApproval(addressindexed owner,
addressindexed spender,
uint256 value
);
}
Contract Source Code
File 5 of 8: LFToken.sol
pragmasolidity ^0.5.0;import"./ERC20Detailed.sol";
import"./ERC20Burnable.sol";
import"./Stopable.sol";
/// @author /// @title Token contractcontractLFTokenisERC20Detailed, ERC20Burnable, Stoppable{
constructor (stringmemory name,
stringmemory symbol,
uint256 totalSupply,
uint8 decimals
) ERC20Detailed(name, symbol, decimals)
public{
_mint(owner(), totalSupply *10**uint(decimals));
}
// Don't accept ETHfunction () payableexternal{
revert();
}
//------------------------// Lock account transfer mapping (address=>uint256) private _lockTimes;
mapping (address=>uint256) private _lockAmounts;
eventLockChanged(addressindexed account, uint256 releaseTime, uint256 amount);
/// Lock user amount. (run only owner)/// @param account account to lock/// @param releaseTime Time to release from lock state./// @param amount amount to lock./// @return BooleanfunctionsetLock(address account, uint256 releaseTime, uint256 amount) onlyOwnerpublic{
//require(now < releaseTime, "ERC20 : Current time is greater than release time");require(block.timestamp< releaseTime, "ERC20 : Current time is greater than release time");
require(amount !=0, "ERC20: Amount error");
_lockTimes[account] = releaseTime;
_lockAmounts[account] = amount;
emit LockChanged( account, releaseTime, amount );
}
/// Get Lock information (run anyone)/// @param account user acount/// @return lokced time and locked amount.functiongetLock(address account) publicviewreturns (uint256 lockTime, uint256 lockAmount) {
return (_lockTimes[account], _lockAmounts[account]);
}
/// Check lock state (run anyone)/// @param account user acount/// @param amount amount to check./// @return Boolean : Don't use balance (true)function_isLocked(address account, uint256 amount) internalviewreturns (bool) {
return _lockAmounts[account] !=0&&
_lockTimes[account] >block.timestamp&&
(
balanceOf(account) <= _lockAmounts[account] ||
balanceOf(account).sub(_lockAmounts[account]) < amount
);
}
/// Transfer token (run anyone)/// @param recipient Token trasfer destination acount./// @param amount Token transfer amount./// @return Boolean functiontransfer(address recipient, uint256 amount) enabledpublicreturns (bool) {
require( !_isLocked( msg.sender, amount ) , "ERC20: Locked balance");
returnsuper.transfer(recipient, amount);
}
/// Transfer token (run anyone)/// @param sender Token trasfer source acount./// @param recipient Token transfer destination acount./// @param amount Token transfer amount./// @return Boolean functiontransferFrom(address sender, address recipient, uint256 amount) enabledpublicreturns (bool) {
require( !_isLocked( sender, amount ) , "ERC20: Locked balance");
returnsuper.transferFrom(sender, recipient, amount);
}
/// Decrease token balance (run only owner)/// @param value Amount to decrease.functionburn(uint256 value) onlyOwnerpublic{
require( !_isLocked( msg.sender, value ) , "ERC20: Locked balance");
super.burn(value);
}
}
Contract Source Code
File 6 of 8: Ownable.sol
pragmasolidity ^0.5.0;/**
* @title Ownable
* @dev The Ownable contract has an owner address, and provides basic authorization control
* functions, this simplifies the implementation of "user permissions".
*/contractOwnable{
addressprivate _owner;
eventOwnershipTransferred(addressindexed previousOwner,
addressindexed newOwner
);
/**
* @dev The Ownable constructor sets the original `owner` of the contract to the sender
* account.
*/constructor() internal{
_owner =msg.sender;
emit OwnershipTransferred(address(0), _owner);
}
/**
* @return the address of the owner.
*/functionowner() publicviewreturns(address) {
return _owner;
}
/**
* @dev Throws if called by any account other than the owner.
*/modifieronlyOwner() {
require(isOwner());
_;
}
/**
* @return true if `msg.sender` is the owner of the contract.
*/functionisOwner() publicviewreturns(bool) {
returnmsg.sender== _owner;
}
/**
* @dev Allows the current owner to transfer control of the contract to a newOwner.
* @param newOwner The address to transfer ownership to.
*/functiontransferOwnership(address newOwner) publiconlyOwner{
_transferOwnership(newOwner);
}
/**
* @dev Transfers control of the contract to a newOwner.
* @param newOwner The address to transfer ownership to.
*/function_transferOwnership(address newOwner) internal{
require(newOwner !=address(0));
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
Contract Source Code
File 7 of 8: SafeMath.sol
pragmasolidity ^0.5.0;/**
* @title SafeMath
* @dev Math operations with safety checks that revert on error
*/librarySafeMath{
/**
* @dev Multiplies two numbers, reverts on overflow.
*/functionmul(uint256 a, uint256 b) internalpurereturns (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/522if (a ==0) {
return0;
}
uint256 c = a * b;
require(c / a == b);
return c;
}
/**
* @dev Integer division of two numbers truncating the quotient, reverts on division by zero.
*/functiondiv(uint256 a, uint256 b) internalpurereturns (uint256) {
require(b >0); // Solidity only automatically asserts when dividing by 0uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't holdreturn c;
}
/**
* @dev Subtracts two numbers, reverts on overflow (i.e. if subtrahend is greater than minuend).
*/functionsub(uint256 a, uint256 b) internalpurereturns (uint256) {
require(b <= a);
uint256 c = a - b;
return c;
}
/**
* @dev Adds two numbers, reverts on overflow.
*/functionadd(uint256 a, uint256 b) internalpurereturns (uint256) {
uint256 c = a + b;
require(c >= a);
return c;
}
/**
* @dev Divides two numbers and returns the remainder (unsigned integer modulo),
* reverts when dividing by zero.
*/functionmod(uint256 a, uint256 b) internalpurereturns (uint256) {
require(b !=0);
return a % b;
}
}
Contract Source Code
File 8 of 8: Stopable.sol
pragmasolidity ^0.5.0;import"./Ownable.sol";
/**
* @title Stoppable
* @dev Change status public value for contract operation.
*/contractStoppableisOwnable{
boolpublic stopped =false;
modifierenabled{
require (!stopped);
_;
}
/**
* @dev Run only owner. For vaalue change
*/functionstop() externalonlyOwner{
stopped =true;
}
/**
* @dev Run only owner. For vaalue change
*/functionstart() externalonlyOwner{
stopped =false;
}
}