ERC20
This contract is an ERC20 token.
                Name
                
                        GMO JPY
                
            
            
                Symbol
                GYEN
            
            
                Decimals
                6
            
            
                Total Supply
                2,231,321,096 GYEN
            
            
            
        
                About
                    
                        link
                    
                    
                        description
                    
                    
            
            
                GYEN (GYEN) is a cryptocurrency and operates on the Ethereum platform. GYEN has a current supply of 2,231,321,096. The last known price of GYEN is 0.00918962 USD and is up 0.84 over the last 24 hours. It is currently trading on 8 active market(s) with $544,573.00 traded over the last 24 hours. More information can be found at https://stablecoin.z.com/.
            
        Identical Contracts
The following contracts have identical source code.
Stats
                Public Functions
                26
            
            
                Event Types
                16
            
            
                Code Size
                25,584 bytes
            
        Events (16) keyboard_arrow_up
State Variables (20) keyboard_arrow_up
Functions
initializeWiper keyboard_arrow_up
Modifiers help
isNotZeroAddress checks for the following:
Source Code
function initializeWiper(address _account) public isNotZeroAddress(_account) {
  require(wiper == address(0), "the wiper can only be initiated once");
  wiper = _account;
}
                pause keyboard_arrow_up
unpause keyboard_arrow_up
changeMinter keyboard_arrow_up
Modifiers help
onlyMinterAdmin checks for the following:
whenNotPaused checks for the following:
isNotZeroAddress checks for the following:
Source Code
function changeMinter(address _account)
  public
  onlyMinterAdmin
  whenNotPaused
  isNotZeroAddress(_account)
{
  address old = minter;
  minter = _account;
  emit MinterChanged(old, minter, msg.sender);
}
                prohibit keyboard_arrow_up
Modifiers help
onlyProhibiter checks for the following:
whenNotPaused checks for the following:
isNotZeroAddress checks for the following:
onlyNotProhibited checks for the following:
Source Code
function prohibit(address _account)
  public
  onlyProhibiter
  whenNotPaused
  isNotZeroAddress(_account)
  onlyNotProhibited(_account)
{
  prohibiteds[_account] = true;
  emit Prohibition(_account, prohibiteds[_account], msg.sender);
}
                unprohibit keyboard_arrow_up
Modifiers help
onlyProhibiter checks for the following:
whenNotPaused checks for the following:
isNotZeroAddress checks for the following:
onlyProhibited checks for the following:
Source Code
function unprohibit(address _account)
  public
  onlyProhibiter
  whenNotPaused
  isNotZeroAddress(_account)
  onlyProhibited(_account)
{
  prohibiteds[_account] = false;
  emit Prohibition(_account, prohibiteds[_account], msg.sender);
}
                changeCapper keyboard_arrow_up
Modifiers help
onlyAdmin checks for the following:
whenNotPaused checks for the following:
isNotZeroAddress checks for the following:
Source Code
function changeCapper(address _account)
  public
  onlyAdmin
  whenNotPaused
  isNotZeroAddress(_account)
{
  address old = capper;
  capper = _account;
  emit CapperChanged(old, capper, msg.sender);
}
                changePauser keyboard_arrow_up
Modifiers help
onlyAdmin checks for the following:
isNotZeroAddress checks for the following:
Source Code
function changePauser(address _account)
  public
  onlyAdmin
  isNotZeroAddress(_account)
{
  address old = pauser;
  pauser = _account;
  emit PauserChanged(old, pauser, msg.sender);
}
                changeProhibiter keyboard_arrow_up
Modifiers help
onlyAdmin checks for the following:
whenNotPaused checks for the following:
isNotZeroAddress checks for the following:
Source Code
function changeProhibiter(address _account)
  public
  onlyAdmin
  whenNotPaused
  isNotZeroAddress(_account)
{
  address old = prohibiter;
  prohibiter = _account;
  emit ProhibiterChanged(old, prohibiter, msg.sender);
}
                changeOwner keyboard_arrow_up
Modifiers help
onlyOwner checks for the following:
whenNotPaused checks for the following:
isNotZeroAddress checks for the following:
Source Code
function changeOwner(address _account)
  public
  onlyOwner
  whenNotPaused
  isNotZeroAddress(_account)
{
  address old = owner;
  owner = _account;
  emit OwnerChanged(old, owner, msg.sender);
}
                changeAdmin keyboard_arrow_up
Modifiers help
onlyOwner checks for the following:
isNotZeroAddress checks for the following:
Source Code
function changeAdmin(address _account)
  public
  onlyOwner
  isNotZeroAddress(_account)
{
  address old = admin;
  admin = _account;
  emit AdminChanged(old, admin, msg.sender);
}
                changeMinterAdmin keyboard_arrow_up
Modifiers help
onlyOwner checks for the following:
whenNotPaused checks for the following:
isNotZeroAddress checks for the following:
Source Code
function changeMinterAdmin(address _account)
  public
  onlyOwner
  whenNotPaused
  isNotZeroAddress(_account)
{
  address old = minterAdmin;
  minterAdmin = _account;
  emit MinterAdminChanged(old, minterAdmin, msg.sender);
}
                totalSupply keyboard_arrow_up
balanceOf keyboard_arrow_up
transfer keyboard_arrow_up
Modifiers help
whenNotPaused checks for the following:
onlyNotProhibited checks for the following:
isNaturalNumber checks for the following:
Requirements help
Source Code
function transfer(address _recipient, uint256 _amount)
  public
  whenNotPaused
  onlyNotProhibited(msg.sender)
  isNaturalNumber(_amount)
  returns (bool)
{
  _transfer(msg.sender, _recipient, _amount);
  return true;
}
                allowance keyboard_arrow_up
approve keyboard_arrow_up
Requirements help
Source Code
function approve(address spender, uint256 value) public returns (bool) {
  _approve(msg.sender, spender, value);
  return true;
}
                transferFrom keyboard_arrow_up
Modifiers help
whenNotPaused checks for the following:
onlyNotProhibited checks for the following:
isNaturalNumber checks for the following:
Requirements help
Source Code
function transferFrom(
  address _sender,
  address _recipient,
  uint256 _amount
)
  public
  whenNotPaused
  onlyNotProhibited(_sender)
  isNaturalNumber(_amount)
  returns (bool)
{
  return super.transferFrom(_sender, _recipient, _amount);
}
                increaseAllowance keyboard_arrow_up
Requirements help
Source Code
function increaseAllowance(address spender, uint256 addedValue)
  public
  returns (bool)
{
  _approve(
    msg.sender,
    spender,
    _allowances[msg.sender][spender].add(addedValue)
  );
  return true;
}
                decreaseAllowance keyboard_arrow_up
Requirements help
Source Code
function decreaseAllowance(address spender, uint256 subtractedValue)
  public
  returns (bool)
{
  _approve(
    msg.sender,
    spender,
    _allowances[msg.sender][spender].sub(subtractedValue)
  );
  return true;
}
                initialize keyboard_arrow_up
Parameters help
Modifiers help
initializer checks for the following:
Requirements help
Source Code
function initialize(
  string memory _name,
  string memory _symbol,
  uint8 _decimals,
  address _owner,
  address _admin,
  address _capper,
  address _prohibiter,
  address _pauser,
  address _minterAdmin,
  address _minter
) public initializer {
  require(_owner != address(0), "_owner is the zero address");
  require(_admin != address(0), "_admin is the zero address");
  require(_capper != address(0), "_capper is the zero address");
  require(_prohibiter != address(0), "_prohibiter is the zero address");
  require(_pauser != address(0), "_pauser is the zero address");
  require(_minterAdmin != address(0), "_minterAdmin is the zero address");
  require(_minter != address(0), "_minter is the zero address");
  name = _name;
  symbol = _symbol;
  decimals = _decimals;
  owner = _owner;
  admin = _admin;
  capper = _capper;
  prohibiter = _prohibiter;
  pauser = _pauser;
  minterAdmin = _minterAdmin;
  minter = _minter;
}
                cap keyboard_arrow_up
Modifiers help
onlyCapper checks for the following:
whenNotPaused checks for the following:
isNaturalNumber checks for the following:
Requirements help
Source Code
function cap(uint256 _amount)
  public
  onlyCapper
  whenNotPaused
  isNaturalNumber(_amount)
{
  require(
    totalSupply() <= _amount,
    "this amount is less than the totalySupply"
  );
  _cap(_amount);
}
                mint keyboard_arrow_up
Modifiers help
onlyMinter checks for the following:
whenNotPaused checks for the following:
notMoreThanCapacity checks for the following:
isNaturalNumber checks for the following:
Source Code
function mint(address _account, uint256 _amount)
  public
  onlyMinter
  whenNotPaused
  notMoreThanCapacity(totalSupply().add(_amount))
  isNaturalNumber(_amount)
{
  _mint(_account, _amount);
  emit Mint(_account, _amount, msg.sender);
}
                burn keyboard_arrow_up
Requirements help
Source Code
function burn(uint256 _amount) public isNaturalNumber(_amount) {
  _burn(msg.sender, _amount);
  emit Burn(msg.sender, _amount, msg.sender);
}
                changeWiper keyboard_arrow_up
Modifiers help
onlyAdmin checks for the following:
whenNotPaused checks for the following:
isNotZeroAddress checks for the following:
Source Code
function changeWiper(address _account)
  public
  onlyAdmin
  whenNotPaused
  isNotZeroAddress(_account)
{
  address old = wiper;
  wiper = _account;
  emit WiperChanged(old, wiper, msg.sender);
}
                wipe keyboard_arrow_up
Modifiers help
whenNotPaused checks for the following:
onlyWiper checks for the following:
onlyProhibited checks for the following:
Requirements help
Source Code
function wipe(address _account)
  public
  whenNotPaused
  onlyWiper
  onlyProhibited(_account)
{
  uint256 _balance = balanceOf(_account);
  _burn(_account, _balance);
  emit Wipe(_account, _balance);
}
                Internal Functions
Internal functions are parts of the contract that can't be used directly, but instead are used by the public functions listed above.
internal Initializable.isConstructor keyboard_arrow_up
Parameters help
This function has no parameters.
Source Code
function isConstructor() private view returns (bool) {
  // extcodesize checks the size of the code stored in an address, and
  // address returns the current address. Since the code is still not
  // deployed when running a constructor, any checks on its code size will
  // yield zero, making it an effective way to detect if a contract is
  // under construction or not.
  uint256 cs;
  assembly {
    cs := extcodesize(address)
  }
  return cs == 0;
}
                internal ERC20._transfer keyboard_arrow_up
Requirements help
Source Code
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);
}
                internal ERC20._mint keyboard_arrow_up
Source Code
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);
}
                internal ERC20._burn keyboard_arrow_up
Requirements help
Source Code
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);
}
                internal ERC20._approve keyboard_arrow_up
Requirements help
Source Code
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);
}
                internal ERC20._burnFrom keyboard_arrow_up
Requirements help
Source Code
function _burnFrom(address account, uint256 amount) internal {
  _burn(account, amount);
  _approve(account, msg.sender, _allowances[account][msg.sender].sub(amount));
}
                
        
    



