/** * Source Code first verified at https://etherscan.io on Monday, April 29, 2019 (UTC) */ pragma solidity 0.5.7; /* ___________________________________________________________________ _ _ ______ | | / / / --|-/|-/-----__---/----__----__---_--_----__-------/-------__------ |/ |/ /___) / / ' / ) / / ) /___) / / ) __/__|____(___ _/___(___ _(___/_/_/__/_(___ _____/______(___/__o_o_ █████╗ ███╗ ██╗██████╗ █████╗ ███╗ ███╗ █████╗ ███╗ ██╗ ██████╗ ██████╗ ██╗███╗ ██╗ ██╔══██╗████╗ ██║██╔══██╗██╔══██╗████╗ ████║██╔══██╗████╗ ██║ ██╔════╝██╔═══██╗██║████╗ ██║ ███████║██╔██╗ ██║██║ ██║███████║██╔████╔██║███████║██╔██╗ ██║ ██║ ██║ ██║██║██╔██╗ ██║ ██╔══██║██║╚██╗██║██║ ██║██╔══██║██║╚██╔╝██║██╔══██║██║╚██╗██║ ██║ ██║ ██║██║██║╚██╗██║ ██║ ██║██║ ╚████║██████╔╝██║ ██║██║ ╚═╝ ██║██║ ██║██║ ╚████║ ╚██████╗╚██████╔╝██║██║ ╚████║ ╚═╝ ╚═╝╚═╝ ╚═══╝╚═════╝ ╚═╝ ╚═╝╚═╝ ╚═╝╚═╝ ╚═╝╚═╝ ╚═══╝ ╚═════╝ ╚═════╝ ╚═╝╚═╝ ╚═══╝ // ---------------------------------------------------------------------------- // 'ANM' Token contract with following features // => ERC20 Compliance // => Higher degree of control by owner - safeguard functionality // => selfdestruct ability by owner // => SafeMath implementation // => Burnable and minting // => air drop // // Name : ANDAMAN coin // Symbol : ANM // Total supply: 1,000,000,000 (1 Billion) // Decimals : 18 // // Copyright (c) 2019 onwards Andamaner.com. All rights reserved ( http://andamaner.com ) // Contract designed by EtherAuthority ( https://EtherAuthority.io ) // ---------------------------------------------------------------------------- */ //*******************************************************************// //------------------------ SafeMath Library -------------------------// //*******************************************************************// /** * @title SafeMath * @dev Math operations with safety checks that throw on error */ library SafeMath { function mul(uint256 a, uint256 b) internal pure returns (uint256) { if (a == 0) { return 0; } uint256 c = a * b; assert(c / a == b); return c; } function div(uint256 a, uint256 b) internal pure returns (uint256) { // assert(b > 0); // Solidity automatically throws when dividing by 0 uint256 c = a / b; // assert(a == b * c + a % b); // There is no case in which this doesn't hold return c; } function sub(uint256 a, uint256 b) internal pure returns (uint256) { assert(b <= a); return a - b; } function add(uint256 a, uint256 b) internal pure returns (uint256) { uint256 c = a + b; assert(c >= a); return c; } } //*******************************************************************// //------------------ Contract to Manage Ownership -------------------// //*******************************************************************// contract owned { address payable public owner; constructor () public { owner = msg.sender; } modifier onlyOwner { require(msg.sender == owner); _; } function transferOwnership(address payable newOwner) onlyOwner public { owner = newOwner; } } //***************************************************************// //------------------ ERC20 Standard Template -------------------// //***************************************************************// contract TokenERC20 { // Public variables of the token using SafeMath for uint256; string public name; string public symbol; uint256 public decimals = 18; // 18 decimals is the strongly suggested default, avoid changing it uint256 public totalSupply; bool public safeguard = false; //putting safeguard on will halt all non-owner functions // This creates an array with all balances mapping (address => uint256) public balanceOf; mapping (address => mapping (address => uint256)) public allowance; // 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); /** * Constrctor function * * Initializes contract with initial supply tokens to the creator of the contract */ constructor ( uint256 initialSupply, string memory tokenName, string memory tokenSymbol ) public { totalSupply = initialSupply * (10**decimals); // Update total supply with the decimal amount balanceOf[msg.sender] = totalSupply; name = tokenName; // Set the name for display purposes symbol = tokenSymbol; // Set the symbol for display purposes emit Transfer(address(0), msg.sender, totalSupply);// Emit event to log this transaction } /** * Internal transfer, only can be called by this contract */ function _transfer(address _from, address _to, uint _value) internal { require(!safeguard); // Prevent transfer to 0x0 address. Use burn() instead require(_to != address(0x0)); // Check if the sender has enough require(balanceOf[_from] >= _value); // Check for overflows require(balanceOf[_to].add(_value) > balanceOf[_to]); // Save this for an assertion in the future uint previousBalances = balanceOf[_from].add(balanceOf[_to]); // Subtract from the sender balanceOf[_from] = balanceOf[_from].sub(_value); // Add the same to the recipient balanceOf[_to] = balanceOf[_to].add(_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].add(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(!safeguard); require(_value <= allowance[_from][msg.sender]); // Check allowance allowance[_from][msg.sender] = allowance[_from][msg.sender].sub(_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(!safeguard); allowance[msg.sender][_spender] = _value; return true; } /** * Destroy tokens * * Remove `_value` tokens from the system irreversibly * * @param _value the amount of money to burn */ function burn(uint256 _value) public returns (bool success) { require(!safeguard); require(balanceOf[msg.sender] >= _value); // Check if the sender has enough balanceOf[msg.sender] = balanceOf[msg.sender].sub(_value); // Subtract from the sender totalSupply = totalSupply.sub(_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 returns (bool success) { require(!safeguard); require(balanceOf[_from] >= _value); // Check if the targeted balance is enough require(_value <= allowance[_from][msg.sender]); // Check allowance balanceOf[_from] = balanceOf[_from].sub(_value); // Subtract from the targeted balance allowance[_from][msg.sender] = allowance[_from][msg.sender].sub(_value); // Subtract from the sender's allowance totalSupply = totalSupply.sub(_value); // Update totalSupply emit Burn(_from, _value); return true; } } //****************************************************************************// //--------------------- ANM MAIN CODE STARTS HERE ---------------------// //****************************************************************************// contract AndamanCoin is owned, TokenERC20 { /*********************************/ /* Code for the ERC20 ANM Token */ /*********************************/ /* Public variables of the token */ string private tokenName = "Andaman coin"; string private tokenSymbol = "ANM"; uint256 private initialSupply = 1000000000; //1 Billion /* Records for the fronzen accounts */ mapping (address => bool) public frozenAccount; /* This generates a public event on the blockchain that will notify clients */ event FrozenFunds(address target, bool frozen); /* Initializes contract with initial supply tokens to the creator of the contract */ constructor () TokenERC20(initialSupply, tokenName, tokenSymbol) public { } /* Internal transfer, only can be called by this contract */ function _transfer(address _from, address _to, uint _value) internal { require(!safeguard); require (_to != address(0x0)); // Prevent transfer to 0x0 address. Use burn() instead require (balanceOf[_from] >= _value); // Check if the sender has enough require (balanceOf[_to].add(_value) >= balanceOf[_to]); // Check for overflows require(!frozenAccount[_from]); // Check if sender is frozen require(!frozenAccount[_to]); // Check if recipient is frozen balanceOf[_from] = balanceOf[_from].sub(_value); // Subtract from the sender balanceOf[_to] = balanceOf[_to].add(_value); // Add the same to the recipient emit Transfer(_from, _to, _value); } /// @notice `freeze? Prevent | Allow` `target` from sending & receiving tokens /// @param target Address to be frozen /// @param freeze either to freeze it or not function freezeAccount(address target, bool freeze) onlyOwner public { frozenAccount[target] = freeze; emit FrozenFunds(target, freeze); } /// @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 { balanceOf[target] = balanceOf[target].add(mintedAmount); totalSupply = totalSupply.add(mintedAmount); emit Transfer(address(0), target, mintedAmount); } //Just in rare case, owner wants to transfer Ether from contract to owner address function manualWithdrawEther()onlyOwner public{ address(owner).transfer(address(this).balance); } function manualWithdrawTokens(uint256 tokenAmount) public onlyOwner{ // no need for overflow checking as that will be done in transfer function _transfer(address(this), owner, tokenAmount); } //selfdestruct function. just in case owner decided to destruct this contract. function destructContract()onlyOwner public{ selfdestruct(owner); } /** * Change safeguard status on or off * * When safeguard is true, then all the non-owner functions will stop working. * When safeguard is false, then all the functions will resume working back again! */ function changeSafeguardStatus() onlyOwner public{ if (safeguard == false){ safeguard = true; } else{ safeguard = false; } } /********************************/ /* Code for the Air drop */ /********************************/ /** * Run an Air-Drop * * It requires an array of all the addresses and amount of tokens to distribute * It will only process first 150 recipients. That limit is fixed to prevent gas limit */ function airdrop(address[] memory recipients,uint tokenAmount) public onlyOwner { uint256 addressCount = recipients.length; require(addressCount <= 150); for(uint i = 0; i < addressCount; i++) { //This will loop through all the recipients and send them the specified tokens _transfer(address(this), recipients[i], tokenAmount); } } }