{"BasicToken.sol":{"content":"pragma solidity ^0.4.23;\n\n\nimport \"./ERC20Basic.sol\";\nimport \"./SafeMath.sol\";\n\n\n/**\n * @title Basic tokens\n * @dev Basic version of StandardToken, with no allowances.\n */\ncontract BasicToken is ERC20Basic {\n    using SafeMath for uint256;\n\n    mapping(address =\u003e uint256) balances;\n\n    uint256 totalSupply_;\n\n    /**\n    * @dev total number of tokens in existence\n    */\n    function totalSupply() public view returns (uint256) {\n        return totalSupply_;\n    }\n\n    /**\n    * @dev transfer tokens for a specified address\n    * @param _to The address to transfer to.\n    * @param _value The amount to be transferred.\n    */\n    function transfer(address _to, uint256 _value) public returns (bool) {\n        require(_to != address(0), \"Trying to transfer tokens to an invalid address\");\n        require(_value \u003c= balances[msg.sender], \"Sender\u0027s balance is too low for this transfer\");\n\n        balances[msg.sender] = balances[msg.sender].sub(_value);\n        balances[_to] = balances[_to].add(_value);\n        emit Transfer(msg.sender, _to, _value);\n        return true;\n    }\n\n    /**\n    * @dev Gets the balance of the specified address.\n    * @param _owner The address to query the the balance of.\n    * @return An uint256 representing the amount owned by the passed address.\n    */\n    function balanceOf(address _owner) public view returns (uint256) {\n        return balances[_owner];\n    }\n\n}\n"},"BurnableToken.sol":{"content":"pragma solidity ^0.4.23;\n\nimport \"./BasicToken.sol\";\n\n\n/**\n * @title Burnable Token\n * @dev Token that can be irreversibly burned (destroyed).\n */\ncontract BurnableToken is BasicToken {\n\n    event Burn(address indexed burner, uint256 value);\n\n    /**\n     * @dev Burns a specific amount of tokens.\n     * @param _value The amount of tokens to be burned.\n     */\n    function burn(uint256 _value) public {\n        _burn(msg.sender, _value);\n    }\n\n    function _burn(address _who, uint256 _value) internal {\n        require(_value \u003c= balances[_who], \"Not enough tokens to burn\");\n        // no need to require value \u003c= totalSupply, since that would imply the\n        // sender\u0027s balance is greater than the totalSupply, which *should* be an assertion failure\n\n        balances[_who] = balances[_who].sub(_value);\n        totalSupply_ = totalSupply_.sub(_value);\n        emit Burn(_who, _value);\n        emit Transfer(_who, address(0), _value);\n    }\n}\n"},"Consts.sol":{"content":"pragma solidity ^0.4.23;\n\ncontract Consts {\n    string constant TOKEN_NAME = \"AI Network\";\n    string constant TOKEN_SYMBOL = \"AIN\";\n    uint8 constant TOKEN_DECIMALS = 18;\n    uint256 constant TOKEN_AMOUNT = 700000000;\n\n    uint256 SALE_HARD_CAP = 30000;  // in ETH\n    uint256 SALE_RATE = 10000;      // 1 ETH = 10,000 AIN\n    uint256 SALE_MIN_ETH = 1 ether;\n    uint256 SALE_MAX_ETH = 1000 ether;\n}\n"},"ERC20.sol":{"content":"pragma solidity ^0.4.23;\n\nimport \"./ERC20Basic.sol\";\n\n\n/**\n * @title ERC20 interface\n * @dev see https://github.com/ethereum/EIPs/issues/20\n */\ncontract ERC20 is ERC20Basic {\n    function allowance(address owner, address spender) public view returns (uint256);\n    function transferFrom(address from, address to, uint256 value) public returns (bool);\n    function approve(address spender, uint256 value) public returns (bool);\n    event Approval(address indexed owner, address indexed spender, uint256 value);\n}\n"},"ERC20Basic.sol":{"content":"pragma solidity ^0.4.23;\n\n\n/**\n * @title ERC20Basic\n * @dev Simpler version of ERC20 interface\n * @dev see https://github.com/ethereum/EIPs/issues/179\n */\ncontract ERC20Basic {\n    function totalSupply() public view returns (uint256);\n    function balanceOf(address who) public view returns (uint256);\n    function transfer(address to, uint256 value) public returns (bool);\n    event Transfer(address indexed from, address indexed to, uint256 value);\n}\n"},"FreezableToken.sol":{"content":"pragma solidity ^0.4.23;\n\nimport \"./Ownable.sol\";\nimport \"./StandardToken.sol\";\n\n\n/**\n * @title FreezableToken\n * @dev Freeze transfer of the specific addresses, if the address is hacked\n */\ncontract FreezableToken is StandardToken, Ownable {\n    mapping (address =\u003e bool) public freezeAddresses;\n\n    event FreezableAddressAdded(address indexed addr);\n    event FreezableAddressRemoved(address indexed addr);\n\n    function addFreezableAddresses(address[] addrs) public onlyOwner returns(bool success) {\n        for (uint256 i = 0; i \u003c addrs.length; i++) {\n            if (addFreezableAddress(addrs[i])) {\n                success = true;\n            }\n        }\n    }\n\n    function addFreezableAddress(address addr) public onlyOwner returns(bool success) {\n        if (!freezeAddresses[addr]) {\n            freezeAddresses[addr] = true;\n            emit FreezableAddressAdded(addr);\n            success = true;\n        }\n    }\n\n    function removeFreezableAddresses(address[] addrs) public onlyOwner returns(bool success) {\n        for (uint256 i = 0; i \u003c addrs.length; i++) {\n            if (removeFreezableAddress(addrs[i])) {\n                success = true;\n            }\n        }\n    }\n\n    function removeFreezableAddress(address addr) public onlyOwner returns(bool success) {\n        if (freezeAddresses[addr]) {\n            freezeAddresses[addr] = false;\n            emit FreezableAddressRemoved(addr);\n            success = true;\n        }\n    }\n\n    /**\n    */\n    function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {\n        require(!freezeAddresses[_from], \"Address to transfer from has been frozen\");\n        return super.transferFrom(_from, _to, _value);\n    }\n\n    /**\n    */\n    function transfer(address _to, uint256 _value) public returns (bool) {\n        require(!freezeAddresses[msg.sender], \"Sender\u0027s address has been frozen\");\n        return super.transfer(_to, _value);\n    }\n}\n"},"MainToken.sol":{"content":"pragma solidity ^0.4.23;\n\n\nimport \"./Consts.sol\";\nimport \"./FreezableToken.sol\";\nimport \"./TransferableToken.sol\";\nimport \"./PausableToken.sol\";\nimport \"./MintableToken.sol\";\nimport \"./BurnableToken.sol\";\n\n\n/**\n * @title MainToken\n */\ncontract MainToken is Consts\n    , FreezableToken\n    , TransferableToken\n    , PausableToken\n    , MintableToken\n    , BurnableToken\n    {\n    string public constant name = TOKEN_NAME; // solium-disable-line uppercase\n    string public constant symbol = TOKEN_SYMBOL; // solium-disable-line uppercase\n    uint8 public constant decimals = TOKEN_DECIMALS; // solium-disable-line uppercase\n\n    uint256 public constant INITIAL_SUPPLY = TOKEN_AMOUNT * (10 ** uint256(decimals));\n\n    constructor() public {\n        totalSupply_ = INITIAL_SUPPLY;\n        balances[msg.sender] = INITIAL_SUPPLY;\n        emit Transfer(0x0, msg.sender, INITIAL_SUPPLY);\n    }\n}\n"},"MintableToken.sol":{"content":"pragma solidity ^0.4.23;\n\nimport \"./Ownable.sol\";\nimport \"./StandardToken.sol\";\n\n\n/**\n * @title Mintable token\n * @dev Simple ERC20 Token example, with mintable token creation\n * @dev Issue: * https://github.com/OpenZeppelin/openzeppelin-solidity/issues/120\n * Based on code by TokenMarketNet: https://github.com/TokenMarketNet/ico/blob/master/contracts/MintableToken.sol\n */\ncontract MintableToken is StandardToken, Ownable {\n    event Mint(address indexed to, uint256 amount);\n    event MintFinished();\n\n    bool public mintingFinished = false;\n\n\n    modifier canMint() {\n        require(!mintingFinished, \"Minting has been finished\");\n        _;\n    }\n\n    /**\n     * @dev Function to mint tokens\n     * @param _to The address that will receive the minted tokens.\n     * @param _amount The amount of tokens to mint.\n     * @return A boolean that indicates if the operation was successful.\n     */\n    function mint(address _to, uint256 _amount) onlyOwner canMint public returns (bool) {\n        totalSupply_ = totalSupply_.add(_amount);\n        balances[_to] = balances[_to].add(_amount);\n        emit Mint(_to, _amount);\n        emit Transfer(address(0), _to, _amount);\n        return true;\n    }\n\n    /**\n     * @dev Function to stop minting new tokens.\n     * @return True if the operation was successful.\n     */\n    function finishMinting() onlyOwner canMint public returns (bool) {\n        mintingFinished = true;\n        emit MintFinished();\n        return true;\n    }\n}\n"},"Ownable.sol":{"content":"pragma solidity ^0.4.23;\n\n\n/**\n * @title Ownable\n * @dev The Ownable contract has an owner address, and provides basic authorization control\n * functions, this simplifies the implementation of \"user permissions\".\n */\ncontract Ownable {\n    address public owner;\n\n\n    event OwnershipRenounced(address indexed previousOwner);\n    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\n\n\n    /**\n     * @dev The Ownable constructor sets the original `owner` of the contract to the sender\n     * account.\n     */\n    constructor() public {\n        owner = msg.sender;\n    }\n\n    /**\n     * @dev Throws if called by any account other than the owner.\n     */\n    modifier onlyOwner() {\n        require(msg.sender == owner, \"Sender is not the 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), \"New owner address is invalid\");\n        emit OwnershipTransferred(owner, newOwner);\n        owner = newOwner;\n    }\n\n    /**\n     * @dev Allows the current owner to relinquish control of the contract.\n     */\n    function renounceOwnership() public onlyOwner {\n        emit OwnershipRenounced(owner);\n        owner = address(0);\n    }\n}\n"},"Pausable.sol":{"content":"pragma solidity ^0.4.23;\n\n\nimport \"./Ownable.sol\";\n\n/**\n * @title Pausable\n * @dev Base contract which allows children to implement an emergency stop mechanism.\n */\ncontract Pausable is Ownable {\n    event Pause();\n    event Unpause();\n\n    bool public paused = false;\n\n\n    /**\n     * @dev Modifier to make a function callable only when the contract is not paused.\n     */\n    modifier whenNotPaused() {\n        require(!paused, \"Contract has been paused\");\n        _;\n    }\n\n    /**\n     * @dev Modifier to makeWhitelist a function callable only when the contract is paused.\n     */\n    modifier whenPaused() {\n        require(paused, \"Contract has not been paused\");\n        _;\n    }\n\n    /**\n     * @dev called by the owner to pause, triggers stopped state\n     */\n    function pause() onlyOwner whenNotPaused public {\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() onlyOwner whenPaused public {\n        paused = false;\n        emit Unpause();\n    }\n}\n"},"PausableToken.sol":{"content":"pragma solidity ^0.4.23;\n\nimport \"./StandardToken.sol\";\nimport \"./Pausable.sol\";\n\n\n/**\n * @title Pausable tokens\n * @dev StandardToken modified with pausable transfers.\n **/\ncontract PausableToken is StandardToken, Pausable {\n\n    function transfer(address _to, uint256 _value) public whenNotPaused returns (bool) {\n        return super.transfer(_to, _value);\n    }\n\n    function transferFrom(address _from, address _to, uint256 _value) public whenNotPaused returns (bool) {\n        return super.transferFrom(_from, _to, _value);\n    }\n\n    function approve(address _spender, uint256 _value) public whenNotPaused returns (bool) {\n        return super.approve(_spender, _value);\n    }\n\n    function increaseApproval(address _spender, uint _addedValue) public whenNotPaused returns (bool success) {\n        return super.increaseApproval(_spender, _addedValue);\n    }\n\n    function decreaseApproval(address _spender, uint _subtractedValue) public whenNotPaused returns (bool success) {\n        return super.decreaseApproval(_spender, _subtractedValue);\n    }\n}\n"},"SafeMath.sol":{"content":"pragma solidity ^0.4.23;\n\n\n/**\n * @title SafeMath\n * @dev Math operations with safety checks that throw on error\n */\nlibrary SafeMath {\n    /**\n      * @dev Multiplies two numbers, throws on overflow.\n      */\n    function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {\n        if (a == 0) {\n            return 0;\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 \u003e 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\u0027t 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 \u003c= 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 \u003e= a);\n        return c;\n    }\n}\n"},"StandardToken.sol":{"content":"pragma solidity ^0.4.23;\n\nimport \"./BasicToken.sol\";\nimport \"./ERC20.sol\";\n\n/**\n * @title Standard ERC20 tokens\n *\n * @dev Implementation of the basic standard tokens.\n * @dev https://github.com/ethereum/EIPs/issues/20\n * @dev Based on code by FirstBlood: https://github.com/Firstbloodio/token/blob/master/smart_contract/FirstBloodToken.sol\n */\ncontract StandardToken is ERC20, BasicToken {\n    mapping (address =\u003e mapping (address =\u003e uint256)) internal allowed;\n\n\n    /**\n     * @dev Transfer tokens from one address to another\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 _value uint256 the amount of tokens to be transferred\n     */\n    function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {\n        require(_to != address(0), \"Address to transfer to is invalid\");\n        require(_value \u003c= balances[_from], \"Not enough balance\");\n        require(_value \u003c= allowed[_from][msg.sender], \"Not enough allowance\");\n\n        balances[_from] = balances[_from].sub(_value);\n        balances[_to] = balances[_to].add(_value);\n        allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);\n        emit Transfer(_from, _to, _value);\n        return true;\n    }\n\n    /**\n     * @dev Approve the passed address to spend the specified amount of tokens on behalf of msg.sender.\n     *\n     * Beware that changing an allowance with this method brings the risk that someone may use both the old\n     * and the new allowance by unfortunate transaction ordering. One possible solution to mitigate this\n     * race condition is to first reduce the spender\u0027s allowance to 0 and set the desired value afterwards:\n     * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729\n     * @param _spender The address which will spend the funds.\n     * @param _value The amount of tokens to be spent.\n     */\n    function approve(address _spender, uint256 _value) public returns (bool) {\n        allowed[msg.sender][_spender] = _value;\n        emit Approval(msg.sender, _spender, _value);\n        return true;\n    }\n\n    /**\n     * @dev Function to check the amount of tokens that an owner allowed to a spender.\n     * @param _owner address The address which owns the funds.\n     * @param _spender address The address which will spend the funds.\n     * @return A uint256 specifying the amount of tokens still available for the spender.\n     */\n    function allowance(address _owner, address _spender) public view returns (uint256) {\n        return allowed[_owner][_spender];\n    }\n\n    /**\n     * @dev Increase the amount of tokens that an owner allowed to a spender.\n     *\n     * approve should be called when allowed[_spender] == 0. To increment\n     * allowed value is better to use this function to avoid 2 calls (and wait until\n     * the first transaction is mined)\n     * From MonolithDAO Token.sol\n     * @param _spender The address which will spend the funds.\n     * @param _addedValue The amount of tokens to increase the allowance by.\n     */\n    function increaseApproval(address _spender, uint _addedValue) public returns (bool) {\n        allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_addedValue);\n        emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);\n        return true;\n    }\n\n    /**\n     * @dev Decrease the amount of tokens that an owner allowed to a spender.\n     *\n     * approve should be called when allowed[_spender] == 0. To decrement\n     * allowed value is better to use this function to avoid 2 calls (and wait until\n     * the first transaction is mined)\n     * From MonolithDAO Token.sol\n     * @param _spender The address which will spend the funds.\n     * @param _subtractedValue The amount of tokens to decrease the allowance by.\n     */\n    function decreaseApproval(address _spender, uint _subtractedValue) public returns (bool) {\n        uint oldValue = allowed[msg.sender][_spender];\n        if (_subtractedValue \u003e oldValue) {\n            allowed[msg.sender][_spender] = 0;\n        } else {\n            allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);\n        }\n        emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);\n        return true;\n    }\n}\n"},"TransferableToken.sol":{"content":"pragma solidity ^0.4.23;\n\nimport \"./Ownable.sol\";\nimport \"./StandardToken.sol\";\n\n\n/**\n * @title TransferableToken\n */\ncontract TransferableToken is StandardToken, Ownable {\n    bool public isLocked;\n\n    mapping (address =\u003e bool) public transferableAddresses;\n    mapping (address =\u003e bool) public receivableAddresses;\n\n    constructor() public {\n        isLocked = true;\n    }\n\n    event Unlock();\n    event TransferableAddressAdded(address indexed addr);\n    event TransferableAddressRemoved(address indexed addr);\n    event ReceivableAddressAdded(address indexed addr);\n    event ReceivableAddressRemoved(address indexed addr);\n\n    function unlock() public onlyOwner {\n        isLocked = false;\n        emit Unlock();\n    }\n\n    function isTransferable(address addr) public view returns(bool) {\n        return !isLocked || transferableAddresses[addr];\n    }\n\n    function isReceivable(address addr) public view returns(bool) {\n        return !isLocked || receivableAddresses[addr];\n    }\n\n    function addTransferableAddresses(address[] addrs) public onlyOwner returns(bool success) {\n        for (uint256 i = 0; i \u003c addrs.length; i++) {\n            if (addTransferableAddress(addrs[i])) {\n                success = true;\n            }\n        }\n    }\n\n    function addReceivableAddresses(address[] addrs) public onlyOwner returns(bool success) {\n        for (uint256 i = 0; i \u003c addrs.length; i++) {\n            if (addReceivableAddress(addrs[i])) {\n                success = true;\n            }\n        }\n    }\n\n    function addTransferableAddress(address addr) public onlyOwner returns(bool success) {\n        if (!transferableAddresses[addr]) {\n            transferableAddresses[addr] = true;\n            emit TransferableAddressAdded(addr);\n            success = true;\n        }\n    }\n\n    function addReceivableAddress(address addr) public onlyOwner returns(bool success) {\n        if (!receivableAddresses[addr]) {\n            receivableAddresses[addr] = true;\n            emit ReceivableAddressAdded(addr);\n            success = true;\n        }\n    }\n\n    function removeTransferableAddresses(address[] addrs) public onlyOwner returns(bool success) {\n        for (uint256 i = 0; i \u003c addrs.length; i++) {\n            if (removeTransferableAddress(addrs[i])) {\n                success = true;\n            }\n        }\n    }\n\n    function removeReceivableAddresses(address[] addrs) public onlyOwner returns(bool success) {\n        for (uint256 i = 0; i \u003c addrs.length; i++) {\n            if (removeReceivableAddress(addrs[i])) {\n                success = true;\n            }\n        }\n    }\n\n    function removeTransferableAddress(address addr) public onlyOwner returns(bool success) {\n        if (transferableAddresses[addr]) {\n            transferableAddresses[addr] = false;\n            emit TransferableAddressRemoved(addr);\n            success = true;\n        }\n    }\n\n    function removeReceivableAddress(address addr) public onlyOwner returns(bool success) {\n        if (receivableAddresses[addr]) {\n            receivableAddresses[addr] = false;\n            emit ReceivableAddressRemoved(addr);\n            success = true;\n        }\n    }\n\n    /**\n    */\n    function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {\n        require(isTransferable(_from) || isReceivable(_to), \"From address not transferable and To address not receivable\");\n        return super.transferFrom(_from, _to, _value);\n    }\n\n    /**\n    */\n    function transfer(address _to, uint256 _value) public returns (bool) {\n        require(isTransferable(msg.sender) || isReceivable(_to), \"Sender not transferable and To address not receivable\");\n        return super.transfer(_to, _value);\n    }\n}\n"}}