2020-09-01 21:16:28 +00:00
// Copied from https://github.com/OpenZeppelin/openzeppelin-solidity/blob/a9f910d34f0ab33a1ae5e714f69f9596a02b4d91/contracts/token/ERC20/StandardToken.sol
pragma solidity 0 . 5 . 17 ;
import " ../../lib/os/ERC20.sol " ;
import " ../../lib/os/SafeMath.sol " ;
/**
* @ title Standard ERC20 token
*
* @ dev Implementation of the basic standard token .
* https : //github.com/ethereum/EIPs/blob/master/EIPS/eip-20.md
* Based on code by FirstBlood : https : //github.com/Firstbloodio/token/blob/master/smart_contract/FirstBloodToken.sol
* /
contract StandardTokenMock is ERC20 {
using SafeMath for uint256 ;
mapping ( address => uint256 ) private balances ;
mapping ( address => mapping ( address => uint256 ) ) private allowed ;
uint256 private totalSupply_ ;
constructor ( address initialAccount , uint256 initialBalance ) public {
balances [ initialAccount ] = initialBalance ;
totalSupply_ = initialBalance ;
}
function mint ( address account , uint256 amount ) public {
balances [ account ] = balances [ account ] . add ( amount ) ;
totalSupply_ = totalSupply_ . add ( amount ) ;
}
/**
* @ dev Total number of tokens in existence
* /
function totalSupply ( ) public view returns ( uint256 ) {
return t otalSupply_ ;
}
/**
* @ dev Gets the balance of the specified address .
* @ param _owner The address to query the the balance of .
* @ return An uint256 representing the amount owned by the passed address .
* /
function balanceOf ( address _owner ) public view returns ( 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 .
* /
function allowance (
address _owner ,
address _spender
)
public
view
returns ( 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 .
* /
function transfer ( address _to , uint256 _value ) public returns ( bool ) {
require ( _value <= balances [ msg . sender ] ) ;
require ( _to != address ( 0 ) ) ;
balances [ msg . sender ] = balances [ msg . sender ] . sub ( _value ) ;
balances [ _to ] = balances [ _to ] . add ( _value ) ;
emit Transfer ( msg . sender , _to , _value ) ;
return true ;
}
/**
* @ 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 .
* /
function approve ( address _spender , uint256 _value ) public returns ( bool ) {
allowed [ msg . sender ] [ _spender ] = _value ;
emit Approval ( msg . sender , _spender , _value ) ;
return true ;
}
/**
* @ 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
* /
function transferFrom (
address _from ,
address _to ,
uint256 _value
)
public
returns ( bool )
{
require ( _value <= balances [ _from ] ) ;
require ( _value <= allowed [ _from ] [ msg . sender ] ) ;
require ( _to != address ( 0 ) ) ;
balances [ _from ] = balances [ _from ] . sub ( _value ) ;
balances [ _to ] = balances [ _to ] . add ( _value ) ;
allowed [ _from ] [ msg . sender ] = allowed [ _from ] [ msg . sender ] . sub ( _value ) ;
emit Transfer ( _from , _to , _value ) ;
return true ;
}
/**
* @ 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 .
* /
function increaseApproval (
address _spender ,
uint256 _addedValue
)
public
returns ( bool )
{
allowed [ msg . sender ] [ _spender ] = (
allowed [ msg . sender ] [ _spender ] . add ( _addedValue ) ) ;
emit Approval ( msg . sender , _spender , allowed [ msg . sender ] [ _spender ] ) ;
return true ;
}
/**
* @ 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 .
* /
function decreaseApproval (
address _spender ,
uint256 _subtractedValue
)
public
returns ( bool )
{
uint256 oldValue = allowed [ msg . sender ] [ _spender ] ;
if ( _subtractedValue >= oldValue ) {
allowed [ msg . sender ] [ _spender ] = 0 ;
} else {
allowed [ msg . sender ] [ _spender ] = oldValue . sub ( _subtractedValue ) ;
}
emit Approval ( msg . sender , _spender , allowed [ msg . sender ] [ _spender ] ) ;
return true ;
}
/**
* @ 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 _amount The amount that will be created .
* /
function _mint ( address _account , uint256 _amount ) internal {
require ( _account != address ( 0 ) ) ;
totalSupply_ = totalSupply_ . add ( _amount ) ;
balances [ _account ] = balances [ _account ] . add ( _amount ) ;
emit Transfer ( address ( 0 ) , _account , _amount ) ;
}
/**
* @ dev Internal function that burns an amount of the token of a given
* account .
* @ param _account The account whose tokens will be burnt .
* @ param _amount The amount that will be burnt .
* /
function _burn ( address _account , uint256 _amount ) internal {
require ( _account != address ( 0 ) ) ;
require ( _amount <= balances [ _account ] ) ;
totalSupply_ = totalSupply_ . sub ( _amount ) ;
balances [ _account ] = balances [ _account ] . sub ( _amount ) ;
emit Transfer ( _account , address ( 0 ) , _amount ) ;
}
/**
* @ 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 _amount The amount that will be burnt .
* /
function _burnFrom ( address _account , uint256 _amount ) internal {
require ( _amount <= 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 ( _amount ) ;
_burn ( _account , _amount ) ;
}
2021-08-30 03:14:58 +00:00
// For benchmarks
event TestLog ( address sender , uint i ) ;
function benchmarkLogs ( uint n ) public {
for ( uint i = 0 ; i < n ; i ++ ) {
emit TestLog ( msg . sender , i ) ;
}
}
2020-09-01 21:16:28 +00:00
}