{"sources":{"null":{"content":"/**\n *Submitted for verification at polygonscan.com on 2022-03-31\n*/\n\n// File: openzeppelin-solidity/contracts/math/SafeMath.sol\n\npragma solidity ^0.4.24;\n\n\n/**\n * @title SafeMath\n * @dev Math operations with safety checks that throw on error\n */\nlibrary SafeMath {\n\n  /**\n  * @dev Multiplies two numbers, throws on overflow.\n  */\n  function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {\n    // Gas optimization: this is cheaper than asserting 'a' not being zero, but the\n    // benefit is lost if 'b' is also tested.\n    // See: https://github.com/OpenZeppelin/openzeppelin-solidity/pull/522\n    if (a == 0) {\n      return 0;\n    }\n\n    c = a * b;\n    assert(c / a == b);\n    return c;\n  }\n\n  /**\n  * @dev Integer division of two numbers, truncating the quotient.\n  */\n  function div(uint256 a, uint256 b) internal pure returns (uint256) {\n    // assert(b > 0); // Solidity automatically throws when dividing by 0\n    // uint256 c = a / b;\n    // assert(a == b * c + a % b); // There is no case in which this doesn't hold\n    return a / b;\n  }\n\n  /**\n  * @dev Subtracts two numbers, throws on overflow (i.e. if subtrahend is greater than minuend).\n  */\n  function sub(uint256 a, uint256 b) internal pure returns (uint256) {\n    assert(b <= a);\n    return a - b;\n  }\n\n  /**\n  * @dev Adds two numbers, throws on overflow.\n  */\n  function add(uint256 a, uint256 b) internal pure returns (uint256 c) {\n    c = a + b;\n    assert(c >= a);\n    return c;\n  }\n}\n\n// File: contracts/Ownable.sol\n\n/**\n* Copyright CENTRE SECZ 2018\n* Copyright (c) 2020 Xfers Pte. Ltd.\n*\n* Permission is hereby granted, free of charge, to any person obtaining a copy\n* of this software and associated documentation files (the \"Software\"), to deal\n* in the Software without restriction, including without limitation the rights\n* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n* copies of the Software, and to permit persons to whom the Software is furnished to\n* do so, subject to the following conditions:\n*\n* The above copyright notice and this permission notice shall be included in all\n* copies or substantial portions of the Software.\n*\n* THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,\n* WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN\n* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.\n*/\n\npragma solidity ^0.4.24;\n\ncontract Ownable {\n\n  address private _owner;\n\n  /**\n  * @dev Event to show ownership has been transferred\n  * @param previousOwner representing the address of the previous owner\n  * @param newOwner representing the address of the new owner\n  */\n  event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\n\n  /**\n  * @dev The constructor sets the original owner of the contract to the sender account.\n  */\n  constructor() internal {\n    setOwner(msg.sender);\n    emit OwnershipTransferred(address(0), _owner);\n  }\n\n  /**\n   * @dev Sets a new owner address\n   */\n  function setOwner(address newOwner) internal {\n    _owner = newOwner;\n  }\n\n  /**\n   * @dev Tells the address of the owner\n   * @return the address of the owner\n   */\n  function owner() public view returns (address) {\n    return _owner;\n  }\n\n  /**\n  * @dev Throws if called by any account other than the owner.\n  */\n  modifier onlyOwner() {\n    require(msg.sender == owner(), \"onlyOwner: not owner\");\n    _;\n  }\n\n  /**\n   * @dev Allows the current owner to transfer control of the contract to a newOwner.\n   * @param newOwner The address to transfer ownership to.\n   */\n  function transferOwnership(address newOwner) public onlyOwner {\n    require(newOwner != address(0), \"transferOwnership: 0x0 invalid\");\n    require(newOwner != owner(), \"transferOwnership: same address\");\n    emit OwnershipTransferred(owner(), newOwner);\n    setOwner(newOwner);\n  }\n}\n\n// File: contracts/Blacklistable.sol\n\n/**\n* Copyright CENTRE SECZ 2018\n* Copyright (c) 2020 Xfers Pte. Ltd.\n*\n* Permission is hereby granted, free of charge, to any person obtaining a copy\n* of this software and associated documentation files (the \"Software\"), to deal\n* in the Software without restriction, including without limitation the rights\n* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n* copies of the Software, and to permit persons to whom the Software is furnished to\n* do so, subject to the following conditions:\n*\n* The above copyright notice and this permission notice shall be included in all\n* copies or substantial portions of the Software.\n*\n* THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,\n* WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN\n* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.\n*/\n\npragma solidity ^0.4.24;\n\n/**\n * @title Blacklistable Token\n * @dev Allows accounts to be blacklisted by a \"blacklister\" role\n*/\ncontract Blacklistable is Ownable {\n\n    address public blacklister;\n    mapping(address => bool) internal blacklisted;\n\n    event Blacklisted(address indexed _account);\n    event UnBlacklisted(address indexed _account);\n    event BlacklisterChanged(address indexed newBlacklister);\n\n    /**\n     * @dev Throws if called by any account other than the blacklister\n    */\n    modifier onlyBlacklister() {\n        require(msg.sender == blacklister, \"not blacklister\");\n        _;\n    }\n\n    /**\n     * @dev Throws if argument account is blacklisted\n     * @param _account The address to check\n    */\n    modifier notBlacklisted(address _account) {\n        require(blacklisted[_account] == false, \"notBlacklisted: is blacklisted\");\n        _;\n    }\n\n    /**\n     * @dev Checks if account is blacklisted\n     * @param _account The address to check\n    */\n    function isBlacklisted(address _account) public view returns (bool) {\n        return blacklisted[_account];\n    }\n\n    /**\n     * @dev Adds account to blacklist\n     * @param _account The address to blacklist\n    */\n    function blacklist(address _account) public onlyBlacklister {\n        require(_account != address(0), \"blacklist: 0x0 invalid\");\n        require(!isBlacklisted(_account), \"blacklist: already blacklisted\");\n        blacklisted[_account] = true;\n        emit Blacklisted(_account);\n    }\n\n    /**\n     * @dev Removes account from blacklist\n     * @param _account The address to remove from the blacklist\n    */\n    function unBlacklist(address _account) public onlyBlacklister {\n        require(_account != address(0), \"unBlacklist: 0x0 invalid\");\n        require(isBlacklisted(_account), \"unBlacklist: not blacklisted\");\n        blacklisted[_account] = false;\n        emit UnBlacklisted(_account);\n    }\n\n    function updateBlacklister(address _newBlacklister) public onlyOwner {\n        require(_newBlacklister != address(0), \"updateBlacklister: 0x0 invalid\");\n        require(_newBlacklister != blacklister, \"updateBlacklister: same address\");\n        blacklister = _newBlacklister;\n        emit BlacklisterChanged(blacklister);\n    }\n}\n\n// File: contracts/Pausable.sol\n\n/**\n* Copyright CENTRE SECZ 2018\n* Copyright (c) 2020 Xfers Pte. Ltd.\n*\n* Permission is hereby granted, free of charge, to any person obtaining a copy\n* of this software and associated documentation files (the \"Software\"), to deal\n* in the Software without restriction, including without limitation the rights\n* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n* copies of the Software, and to permit persons to whom the Software is furnished to\n* do so, subject to the following conditions:\n*\n* The above copyright notice and this permission notice shall be included in all\n* copies or substantial portions of the Software.\n*\n* THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,\n* WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN\n* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.\n*/\n\npragma solidity ^0.4.24;\n\n/**\n * @title Pausable\n * @dev Base contract which allows children to implement an emergency stop mechanism.\n * Based on openzeppelin tag v1.10.0 commit: feb665136c0dae9912e08397c1a21c4af3651ef3\n * Modifications:\n * 1) Added pauser role, switched pause/unpause to be onlyPauser (6/14/2018)\n * 2) Removed whenNotPause/whenPaused from pause/unpause (6/14/2018)\n * 3) Removed whenPaused (6/14/2018)\n * 4) Switches ownable library to use zeppelinos (7/12/18)\n * 5) Remove constructor (7/13/18)\n */\ncontract Pausable is Ownable {\n  event Pause();\n  event Unpause();\n  event PauserChanged(address indexed newAddress);\n\n\n  address public pauser;\n  bool public paused = false;\n\n  /**\n   * @dev Modifier to make a function callable only when the contract is not paused.\n   */\n  modifier whenNotPaused() {\n    require(!paused, \"whenNotPaused: contract paused\");\n    _;\n  }\n\n  /**\n   * @dev throws if called by any account other than the pauser\n   */\n  modifier onlyPauser() {\n    require(msg.sender == pauser, \"pauser only\");\n    _;\n  }\n\n  /**\n   * @dev called by the owner to pause, triggers stopped state\n   */\n  function pause() public onlyPauser {\n    paused = true;\n    emit Pause();\n  }\n\n  /**\n   * @dev called by the owner to unpause, returns to normal state\n   */\n  function unpause() public onlyPauser {\n    paused = false;\n    emit Unpause();\n  }\n\n  /**\n   * @dev update the pauser role\n   */\n  function updatePauser(address _newPauser) public onlyOwner {\n    require(_newPauser != address(0), \"updatePauser: 0x0 invalid\");\n    require(_newPauser != pauser, \"updatePauser: same address\");\n    pauser = _newPauser;\n    emit PauserChanged(pauser);\n  }\n\n}\n\n// File: contracts/ERC20Recovery.sol\n\n/**\n* Copyright (c) 2020 Xfers Pte. Ltd.\n*\n* Permission is hereby granted, free of charge, to any person obtaining a copy\n* of this software and associated documentation files (the \"Software\"), to deal\n* in the Software without restriction, including without limitation the rights\n* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n* copies of the Software, and to permit persons to whom the Software is furnished to\n* do so, subject to the following conditions:\n*\n* The above copyright notice and this permission notice shall be included in all\n* copies or substantial portions of the Software.\n*\n* THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,\n* WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN\n* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.\n*/\n\npragma solidity ^0.4.24;\n\n/**\n * @title ERC20Recovery\n * @dev Minimal version of ERC20 interface required to allow ERC20 locked tokens recovery\n */\n\ncontract ERC20Recovery {\n  function balanceOf(address account) public view returns (uint256);\n  function transfer(address to, uint256 value) public returns (bool);\n}\n\n// File: contracts/FiatTokenV1.sol\n\n/**\n* Copyright CENTRE SECZ 2018\n* Copyright (c) 2020 Xfers Pte. Ltd.\n*\n* Permission is hereby granted, free of charge, to any person obtaining a copy\n* of this software and associated documentation files (the \"Software\"), to deal\n* in the Software without restriction, including without limitation the rights\n* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n* copies of the Software, and to permit persons to whom the Software is furnished to\n* do so, subject to the following conditions:\n*\n* The above copyright notice and this permission notice shall be included in all\n* copies or substantial portions of the Software.\n*\n* THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,\n* WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN\n* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.\n*/\n\npragma solidity ^0.4.24;\n\n\n\n\n\n/**\n * @title FiatToken\n * @dev Token backed by fiat reserves\n */\ncontract FiatTokenV1 is Ownable, Pausable, Blacklistable {\n    using SafeMath for uint256;\n\n    string public name;\n    string public symbol;\n    uint8 public decimals;\n    address public masterMinter;\n\n    bool internal initialized;\n    mapping(address => uint256) internal balances;\n    mapping(address => mapping(address => uint256)) internal allowed;\n    uint256 internal totalSupply_ = 0;\n    mapping(address => bool) internal minters;\n    mapping(address => uint256) internal minterAllowed;\n\n    event Mint(address indexed minter, address indexed to, uint256 amount);\n    event Transfer(address indexed from, address indexed to, uint256 amount);\n    event Burn(address indexed burner, uint256 amount);\n    event Approval(\n        address indexed owner,\n        address indexed spender,\n        uint256 amount\n    );\n    event MinterConfigured(address indexed minter, uint256 minterAllowedAmount);\n    event MinterRemoved(address indexed oldMinter);\n    event MasterMinterChanged(address indexed newMasterMinter);\n\n    /**\n     * @dev Throws if called by any account other than a minter\n    */\n    modifier onlyMinters() {\n        require(minters[msg.sender] == true, \"minters only\");\n        _;\n    }\n\n    /**\n     * @dev Throws if called by any account other than the masterMinter\n    */\n    modifier onlyMasterMinter() {\n        require(msg.sender == masterMinter, \"master minter only\");\n        _;\n    }\n\n    /**\n     * @dev Function to initialise contract\n     * @param _name string Token name\n     * @param _symbol string Token symbol\n     * @param _decimals uint8 Token decimals\n     * @param _masterMinter address Address of the master minter\n     * @param _pauser address Address of the pauser\n     * @param _blacklister address Address of the blacklister\n     * @param _owner address Address of the owner\n    */\n    function initialize(\n        string _name,\n        string _symbol,\n        uint8 _decimals,\n        address _masterMinter,\n        address _pauser,\n        address _blacklister,\n        address _owner\n    ) public {\n        require(!initialized, \"already initialized!\");\n        require(_masterMinter != address(0), \"master minter can't be 0x0\");\n        require(_pauser != address(0), \"pauser can't be 0x0\");\n        require(_blacklister != address(0), \"blacklister can't be 0x0\");\n        require(_owner != address(0), \"owner can't be 0x0\");\n\n        name = _name;\n        symbol = _symbol;\n        decimals = _decimals;\n        masterMinter = _masterMinter;\n        pauser = _pauser;\n        blacklister = _blacklister;\n        setOwner(_owner);\n        initialized = true;\n    }\n\n    /**\n     * @dev Function to mint tokens\n     * Validates that the contract is not paused\n     * only minters can call this function\n     * minter and the address that will received the minted tokens are not blacklisted\n     * @param _to address The address that will receive the minted tokens.\n     * @param _amount uint256 The amount of tokens to mint. Must be less than or equal to the minterAllowance of the caller.\n     * @return True if the operation was successful.\n    */\n    function mint(address _to, uint256 _amount)\n        public\n        whenNotPaused\n        onlyMinters\n        notBlacklisted(msg.sender)\n        notBlacklisted(_to)\n        returns (bool)\n    {\n        require(_to != address(0), \"can't mint to 0x0\");\n        require(_amount > 0, \"amount to mint has to be > 0\");\n\n        uint256 mintingAllowedAmount = minterAllowance(msg.sender);\n        require(_amount <= mintingAllowedAmount, \"minter allowance too low\");\n\n        totalSupply_ = totalSupply_.add(_amount);\n        balances[_to] = balances[_to].add(_amount);\n        minterAllowed[msg.sender] = mintingAllowedAmount.sub(_amount);\n        if (minterAllowance(msg.sender) == 0) {\n            minters[msg.sender] = false;\n            emit MinterRemoved(msg.sender);\n        }\n        emit Mint(msg.sender, _to, _amount);\n        emit Transfer(0x0, _to, _amount);\n        return true;\n    }\n\n    /**\n     * @dev Function to get minter allowance of an address\n     * @param _minter address The address of check minter allowance of\n     * @return The minter allowance of the address\n    */\n    function minterAllowance(address _minter) public view returns (uint256) {\n        return minterAllowed[_minter];\n    }\n\n    /**\n     * @dev Function to check if an address is a minter\n     * @param _address The address to check\n     * @return A boolean value to indicates if an address is a minter\n    */\n    function isMinter(address _address) public view returns (bool) {\n        return minters[_address];\n    }\n\n    /**\n     * @dev Function to get total supply of token\n     * @return The total supply of the token\n    */\n    function totalSupply() public view returns (uint256) {\n        return totalSupply_;\n    }\n\n    /**\n     * @dev Function to get token balance of an address\n     * @param _address address The account\n     * @return The token balance of an address\n    */\n    function balanceOf(address _address) public view returns (uint256) {\n        return balances[_address];\n    }\n\n    /**\n     * @dev Function to approves a spender to spend up to a certain amount of tokens\n     * Validates that the contract is not paused\n     * the owner and spender are not blacklisted\n     * Avoid calling this function if possible (https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729)\n     * @param _spender address The Address of the spender\n     * @param _amount uint256 The amount of tokens that the spender is approved to spend\n     * @return True if the operation was successful.\n    */\n    function approve(address _spender, uint256 _amount)\n        public\n        whenNotPaused\n        notBlacklisted(msg.sender)\n        notBlacklisted(_spender)\n        returns (bool)\n    {\n        return _approve(_spender, _amount);\n    }\n\n    /**\n     * @dev Alternative function to the approve function\n     * Increases the allowance of the spender\n     * Validates that the contract is not paused\n     * the owner and spender are not blacklisted\n     * @param _spender address The Address of the spender\n     * @param _addedValue uint256 The amount of tokens to be added to a spender's allowance\n     * @return True if the operation was successful.\n    */\n    function increaseAllowance(address _spender, uint256 _addedValue)\n        public\n        whenNotPaused\n        notBlacklisted(msg.sender)\n        notBlacklisted(_spender)\n        returns (bool)\n    {\n        uint256 updatedAllowance = allowed[msg.sender][_spender].add(\n            _addedValue\n        );\n        return _approve(_spender, updatedAllowance);\n    }\n\n    /**\n     * @dev Alternative function to the approve function\n     * Decreases the allowance of the spender\n     * Validates that the contract is not paused\n     * the owner and spender are not blacklisted\n     * @param _spender address The Address of the spender\n     * @param _subtractedValue uint256 The amount of tokens to be subtracted from a spender's allowance\n     * @return True if the operation was successful.\n    */\n    function decreaseAllowance(address _spender, uint256 _subtractedValue)\n        public\n        whenNotPaused\n        notBlacklisted(msg.sender)\n        notBlacklisted(_spender)\n        returns (bool)\n    {\n        uint256 updatedAllowance = allowed[msg.sender][_spender].sub(\n            _subtractedValue\n        );\n        return _approve(_spender, updatedAllowance);\n    }\n\n    /**\n     * @dev Function to approves a spender to spend up to a certain amount of tokens\n     * @param _spender address The Address of the spender\n     * @param _amount uint256 The amount of tokens that the spender is approved to spend\n    */\n    function _approve(address _spender, uint256 _amount)\n        internal\n        returns (bool)\n    {\n        allowed[msg.sender][_spender] = _amount;\n        emit Approval(msg.sender, _spender, _amount);\n        return true;\n    }\n\n    /**\n     * @dev Function to get token allowance given to a spender by the owner\n     * @param _owner address The address of the owner\n     * @param _spender address The address of the spender\n     * @return The number of tokens that a spender can spend on behalf of the owner\n    */\n    function allowance(address _owner, address _spender)\n        public\n        view\n        returns (uint256)\n    {\n        return allowed[_owner][_spender];\n    }\n\n    /**\n     * @dev Function to transfer tokens from one address to another.\n     * Validates that the contract is not paused\n     * the caller, sender and receiver of the tokens are not blacklisted\n     * @param _from address The address which you want to send tokens from\n     * @param _to address The address which you want to transfer to\n     * @param _amount uint256 the amount of tokens to be transferred\n     * @return True if the operation was successful.\n    */\n    function transferFrom(address _from, address _to, uint256 _amount)\n        public\n        whenNotPaused\n        notBlacklisted(_to)\n        notBlacklisted(msg.sender)\n        notBlacklisted(_from)\n        returns (bool)\n    {\n        require(_to != address(0), \"can't transfer to 0x0\");\n        require(_amount <= balances[_from], \"insufficient balance\");\n        require(\n            _amount <= allowed[_from][msg.sender],\n            \"token allowance is too low\"\n        );\n\n        balances[_from] = balances[_from].sub(_amount);\n        balances[_to] = balances[_to].add(_amount);\n        allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_amount);\n        emit Transfer(_from, _to, _amount);\n        return true;\n    }\n\n    /**\n     * @dev Function to transfer token to a specified address\n     * Validates that the contract is not paused\n     * The sender and receiver are not blacklisted\n     * @param _to The address to transfer to.\n     * @param _amount The amount of tokens to be transferred.\n     * @return True if the operation is successful\n    */\n    function transfer(address _to, uint256 _amount)\n        public\n        whenNotPaused\n        notBlacklisted(msg.sender)\n        notBlacklisted(_to)\n        returns (bool)\n    {\n        require(_to != address(0), \"can't transfer to 0x0\");\n        require(_amount <= balances[msg.sender], \"insufficient balance\");\n\n        balances[msg.sender] = balances[msg.sender].sub(_amount);\n        balances[_to] = balances[_to].add(_amount);\n        emit Transfer(msg.sender, _to, _amount);\n        return true;\n    }\n\n    /**\n    * @dev Function to increase minter allowance of a minter\n    * Validates that only the master minter can call this function\n    * @param _minter address The address of the minter\n    * @param _increasedAmount uint256 The amount of to be added to a minter's allowance\n    */\n    function increaseMinterAllowance(address _minter, uint256 _increasedAmount)\n        public\n        onlyMasterMinter\n    {\n        require(_minter != address(0), \"minter can't be 0x0\");\n        uint256 updatedAllowance = minterAllowance(_minter).add(\n            _increasedAmount\n        );\n        minterAllowed[_minter] = updatedAllowance;\n        minters[_minter] = true;\n        emit MinterConfigured(_minter, updatedAllowance);\n    }\n\n    /**\n    * @dev Function to decrease minter allowance of a minter\n    * Validates that only the master minter can call this function\n    * @param _minter address The address of the minter\n    * @param _decreasedAmount uint256 The amount of allowance to be subtracted from a minter's allowance\n    */\n    function decreaseMinterAllowance(address _minter, uint256 _decreasedAmount)\n        public\n        onlyMasterMinter\n    {\n        require(_minter != address(0), \"minter can't be 0x0\");\n        require(minters[_minter], \"not a minter\");\n\n        uint256 updatedAllowance = minterAllowance(_minter).sub(\n            _decreasedAmount\n        );\n        minterAllowed[_minter] = updatedAllowance;\n        if (minterAllowance(_minter) > 0) {\n            emit MinterConfigured(_minter, updatedAllowance);\n        } else {\n            minters[_minter] = false;\n            emit MinterRemoved(_minter);\n\n        }\n    }\n\n    /**\n     * @dev Function to allow a minter to burn some of its own tokens\n     * Validates that the contract is not paused\n     * caller is a minter and is not blacklisted\n     * amount is less than or equal to the minter's mint allowance balance\n     * @param _amount uint256 the amount of tokens to be burned\n    */\n    function burn(uint256 _amount)\n        public\n        whenNotPaused\n        onlyMinters\n        notBlacklisted(msg.sender)\n    {\n        uint256 balance = balances[msg.sender];\n        require(_amount > 0, \"burn amount has to be > 0\");\n        require(balance >= _amount, \"balance in minter is < amount to burn\");\n\n        totalSupply_ = totalSupply_.sub(_amount);\n        balances[msg.sender] = balance.sub(_amount);\n        emit Burn(msg.sender, _amount);\n        emit Transfer(msg.sender, address(0), _amount);\n    }\n\n    /**\n     * @dev Function to allow the blacklister to burn entire balance of tokens from a blacklisted address\n     * Validates that contract is not paused\n     * caller is the blacklister\n     * address to burn tokens from is a blacklisted address\n     * @param _from address the address to burn tokens from\n    */\n    function lawEnforcementWipingBurn(address _from)\n        public\n        whenNotPaused\n        onlyBlacklister\n    {\n        require(\n            isBlacklisted(_from),\n            \"Can't wipe balances of a non blacklisted address\"\n        );\n        uint256 balance = balances[_from];\n        totalSupply_ = totalSupply_.sub(balance);\n        balances[_from] = 0;\n        emit Burn(_from, balance);\n        emit Transfer(_from, address(0), balance);\n    }\n\n    /**\n     * @dev Function to update the masterMinter role\n     * Validates that the caller is the owner\n     */\n    function updateMasterMinter(address _newMasterMinter) public onlyOwner {\n        require(_newMasterMinter != address(0), \"master minter can't be 0x0\");\n        require(_newMasterMinter != masterMinter, \"master minter is the same\");\n        masterMinter = _newMasterMinter;\n        emit MasterMinterChanged(masterMinter);\n    }\n\n    /**\n      * @dev Function to reject all EIP223 compatible tokens\n      * @param _from address The address that is transferring the tokens\n      * @param _value uint256 the amount of the specified token\n      * @param _data bytes The data passed from the caller\n      */\n    function tokenFallback(address _from, uint256 _value, bytes _data)\n        external\n        pure\n    {\n        revert(\"reject EIP223 token transfers\");\n    }\n\n    /**\n     * @dev Function to reclaim all ERC20Recovery compatible tokens\n     * Validates that the caller is the owner\n     * @param _tokenAddress address The address of the token contract\n     */\n    function reclaimToken(address _tokenAddress) external onlyOwner {\n        require(_tokenAddress != address(0), \"token can't be 0x0\");\n        ERC20Recovery token = ERC20Recovery(_tokenAddress);\n        uint256 balance = token.balanceOf(this);\n        require(token.transfer(owner(), balance), \"reclaim token failed\");\n    }\n}"}},"matchId":"7470783","creationMatch":"match","runtimeMatch":"match","verifiedAt":"2025-07-15T03:36:19Z","match":"match","chainId":"137","address":"0x735e27546C7d2fE3c097F880E258C96eA66597b7"}