``` /** *Submitted for verification at Etherscan.io on 2019-03-22 */ pragma solidity 0.4.24; contract owned { address public owner; modifier onlyOwner { require(msg.sender == owner); _; } function transferOwnership(address newOwner) onlyOwner public { owner = newOwner; } } interface tokenRecipient { function receiveApproval(address _from, uint256 _value, address _token, bytes _extraData) external; } contract GTFToken is owned { // Public variables of the token string public name; string public symbol; uint8 public decimals = 8; // 18 decimals is the strongly suggested default, avoid changing it uint256 public totalSupply; // This creates an array with all balances mapping (address => uint256) public balanceOf; mapping (address => mapping (address => uint256)) public allowance; // This creates an array with freeze balances mapping (address => uint256) public freezeOf; // Suspend trading bool suspendTrading; // This generates a public event on the blockchain that will notify clients event Transfer(address indexed from, address indexed to, uint256 value); // This notifies clients about the amount burnt event Burn(address indexed from, uint256 value); // This notifies clients about the amount unfreeze event UnFreezeFunds(address target, uint256 value); // This notifies clients about the amount freeze event FreezeFunds(address target, uint256 value); // This generates a public event on the blockchain that will notify clients event Approval(address indexed _owner, address indexed _spender, uint256 _value); /** * Constrctor function * * Initializes contract with initial supply tokens to the creator of the contract */ constructor( ) public { totalSupply = 0 * 10 ** uint256(decimals); // Update total supply with the decimal amount balanceOf[msg.sender] = totalSupply; // Give the creator all initial tokens name = "GoldTrustFoundation"; // Set the name for display purposes symbol = "GTF"; // Set the symbol for display purposes owner = 0x1c983db24f6f16a91b38172a6fd20620bb67092b; } /** * set suspendTrading */ function setSuspendTrading(bool _state) public onlyOwner { suspendTrading = _state; } /** * Internal transfer, only can be called by this contract */ function _transfer(address _from, address _to, uint _value) internal { require(suspendTrading == false); // Prevent transfer to 0x0 address. Use burn() instead require(_to != address(0x0)); // Check if the sender has enough require(balanceOf[_from] >= freezeOf[_from]); require(balanceOf[_from] - freezeOf[_from] >= _value); // Check for overflows require(balanceOf[_to] + _value > balanceOf[_to]); // Save this for an assertion in the future uint previousBalances = balanceOf[_from] + balanceOf[_to]; // Subtract from the sender balanceOf[_from] -= _value; // Add the same to the recipient balanceOf[_to] += _value; emit Transfer(_from, _to, _value); // Asserts are used to use static analysis to find bugs in your code. They should never fail assert(balanceOf[_from] + balanceOf[_to] == previousBalances); } /** * Transfer tokens * * Send `_value` tokens to `_to` from your account * * @param _to The address of the recipient * @param _value the amount to send */ function transfer(address _to, uint256 _value) public returns (bool success) { _transfer(msg.sender, _to, _value); return true; } /** * Transfer tokens from other address * * Send `_value` tokens to `_to` in behalf of `_from` * * @param _from The address of the sender * @param _to The address of the recipient * @param _value the amount to send */ function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) { require(_value <= allowance[_from][msg.sender]); // Check allowance allowance[_from][msg.sender] -= _value; _transfer(_from, _to, _value); return true; } /** * Set allowance for other address * * Allows `_spender` to spend no more than `_value` tokens in your behalf * * @param _spender The address authorized to spend * @param _value the max amount they can spend */ function approve(address _spender, uint256 _value) public returns (bool success) { require((_value == 0) || allowance[msg.sender][_spender] == 0); allowance[msg.sender][_spender] = _value; emit Approval(msg.sender, _spender, _value); return true; } /** * Set allowance for other address and notify * * Allows `_spender` to spend no more than `_value` tokens in your behalf, and then ping the contract about it * * @param _spender The address authorized to spend * @param _value the max amount they can spend * @param _extraData some extra information to send to the approved contract */ function approveAndCall(address _spender, uint256 _value, bytes memory _extraData) public returns (bool success) { tokenRecipient spender = tokenRecipient(_spender); if (approve(_spender, _value)) { spender.receiveApproval(msg.sender, _value, address(this), _extraData); return true; } } /** * multiTransfer tokens * * Send `_value` tokens to `_to` from your account * * @param _to The address of the recipient * @param _value the amount to send */ function multiTransfer(address[] memory _to, uint256[] memory _value) public returns (bool success) { uint256 i = 0; while (i < _to.length) { transfer(_to[i], _value[i]); i += 1; } return true; } /** * Destroy tokens * * Remove `_value` tokens from the system irreversibly * * @param _value the amount of money to burn */ function burn(uint256 _value) public onlyOwner returns (bool success) { require(balanceOf[msg.sender] >= _value); // Check if the sender has enough balanceOf[msg.sender] -= _value; // Subtract from the sender totalSupply -= _value; // Updates totalSupply emit Burn(msg.sender, _value); return true; } /** * Destroy tokens from other account * * Remove `_value` tokens from the system irreversibly on behalf of `_from`. * * @param _from the address of the sender * @param _value the amount of money to burn */ function burnFrom(address _from, uint256 _value) public onlyOwner returns (bool success) { require(balanceOf[_from] >= freezeOf[_from]); require(balanceOf[_from] - freezeOf[_from] >= _value); // Check if the targeted balance is enough balanceOf[_from] -= _value; // Subtract from the targeted balance totalSupply -= _value; // Update totalSupply emit Burn(_from, _value); return true; } /** * Destroy tokens from other accounts * * Remove `_value` tokens from the system irreversibly on behalf of `_from`. * * @param _from the address of the sender * @param _value the amount of money to burn */ function multiBurnFrom(address[] memory _from, uint256[] memory _value) public onlyOwner returns (bool success) { uint256 i = 0; while (i < _from.length) { burnFrom(_from[i], _value[i]); i += 1; } return true; } /// @notice Create `mintedAmount` tokens and send it to `target` /// @param target Address to receive the tokens /// @param mintedAmount the amount of tokens it will receive function mintToken(address target, uint256 mintedAmount) onlyOwner public { require(totalSupply + mintedAmount < 10000000000 * 10 ** uint256(decimals)); balanceOf[target] += mintedAmount; totalSupply += mintedAmount; emit Transfer(address(0), address(this), mintedAmount); emit Transfer(address(this), target, mintedAmount); } /** * mint tokens * * mint `_value` tokens from the system irreversibly on behalf of `_from`. * * @param _from the address of the sender * @param _value the amount of money to mint */ function multiMintToken(address[] memory _from, uint256[] memory _value) public onlyOwner returns (bool success) { uint256 i = 0; while (i < _from.length) { mintToken(_from[i], _value[i]); i += 1; } return true; } /// @notice `freeze? Prevent | Allow` `target` from sending & receiving tokens /// @param target Address to be frozen /// @param _value value of target Address to be frozen function freezeToken(address target, uint256 _value) onlyOwner public { require(balanceOf[target] -freezeOf[target]>= _value); freezeOf[target] += _value; emit FreezeFunds(target, _value); } /// @notice `freeze? Prevent | Allow` `target` from sending & receiving tokens /// @param target Address to be frozen /// @param _value value of target Address to be frozen function unfreezeToken(address target, uint256 _value) onlyOwner public { require(freezeOf[target] >= _value); freezeOf[target] -= _value; emit UnFreezeFunds(target, _value); } } ```