W GREEN PAY

0xdd94842c15abfe4c9bafe4222ade02896beb064c

totalSupply keyboard_arrow_up

    function totalSupply() public view returns (uint256) {
        return _totalsupply;
    }

balanceOf keyboard_arrow_up

    function balanceOf(address investor) public view returns (uint256) {
        return balances[investor];
    }

allowance keyboard_arrow_up

    function allowance(address _from, address _spender) public view returns (uint256) {
        return allowed[_from][_spender];
    }

transferFrom keyboard_arrow_up

    function transferFrom( address _from, address _to, uint256 _amount ) public onlyFinishedICO onlyUnlockToken returns (bool)  {
        require( _to != address(0), "Receiver can not be 0x0");
        require(balances[_from] >= _amount, "Source's balance is not enough");
        require(allowed[_from][msg.sender] >= _amount, "Allowance is not enough");
        require(!locked[_from], "From address is locked");
        require(!locked[_to], "Receiver address is locked");
        balances[_from] = (balances[_from]).sub(_amount);
        allowed[_from][msg.sender] = (allowed[_from][msg.sender]).sub(_amount);
        balances[_to] = (balances[_to]).add(_amount);
        emit Transfer(_from, _to, _amount);
        return true;
    }

approve keyboard_arrow_up

    function approve(address _spender, uint256 _amount) public onlyFinishedICO onlyUnlockToken returns (bool)  {
        require( _spender != address(0), "Address can not be 0x0");
        require(balances[msg.sender] >= _amount, "Balance does not have enough tokens");
        require(!locked[msg.sender], "Sender address is locked");
        require(!locked[_spender], "Spender address is locked");
        allowed[msg.sender][_spender] = _amount;
        emit Approval(msg.sender, _spender, _amount);
        return true;
    }

transfer keyboard_arrow_up

    function transfer(address _to, uint256 _amount) public onlyFinishedICO onlyUnlockToken returns (bool) {
        require( _to != address(0), "Receiver can not be 0x0");
        require(balances[msg.sender] >= _amount, "Balance does not have enough tokens");
        require(!locked[msg.sender], "Sender address is locked");
        require(!locked[_to], "Receiver address is locked");
        balances[msg.sender] = (balances[msg.sender]).sub(_amount);
        balances[_to] = (balances[_to]).add(_amount);
        emit Transfer(msg.sender, _to, _amount);
        return true;
    }

name keyboard_arrow_up

    function name() public pure returns (string memory) {
        return _name;
    }

symbol keyboard_arrow_up

    function symbol() public pure returns (string memory) {
        return _symbol;
    }

decimals keyboard_arrow_up

    function decimals() public pure returns (uint8) {
        return _decimals;
    }

maxCap keyboard_arrow_up

    function maxCap() public pure returns (uint256) {
        return _maxCap;
    }

owner keyboard_arrow_up

    function owner() public view returns (address) {
        return _owner;
    }

ethFundMain keyboard_arrow_up

    function ethFundMain() public view returns (address) {
        return _ethFundMain;
    }

icoStartDate keyboard_arrow_up

    function icoStartDate() public view returns (uint256) {
        return _icoStartDate;
    }

icoEndDate keyboard_arrow_up

    function icoEndDate() public view returns (uint256) {
        return _icoEndDate;
    }

lockToken keyboard_arrow_up

    function lockToken() public view returns (bool) {
        return _lockToken;
    }

allowICO keyboard_arrow_up

    function allowICO() public view returns (bool) {
        return _allowICO;
    }

lockStatusOf keyboard_arrow_up

    function lockStatusOf(address investor) public view returns (bool) {
        return locked[investor];
    }

burn keyboard_arrow_up

    function burn(uint256 _value) public onlyOwner returns (bool) {
        require(balances[msg.sender] >= _value, "Balance does not have enough tokens");   
        balances[msg.sender] = (balances[msg.sender]).sub(_value);            
        _totalsupply = _totalsupply.sub(_value);                     
        emit Burn(msg.sender, _value);
        return true;
    }

stopTransferToken keyboard_arrow_up

    function stopTransferToken() external onlyOwner onlyFinishedICO {
        _lockToken = true;
        emit ChangeTokenLockStatus(true);
    }

startTransferToken keyboard_arrow_up

    function startTransferToken() external onlyOwner onlyFinishedICO {
        _lockToken = false;
        emit ChangeTokenLockStatus(false);
    }

constructor keyboard_arrow_up

    function () external payable onlyICO onlyAllowICO {
        
    }

manualMint keyboard_arrow_up

    function manualMint(address receiver, uint256 _value) public onlyOwner{
        uint256 value = _value.mul(10 ** 18);
        mint(_owner, receiver, value);
    }

haltCrowdSale keyboard_arrow_up

    function haltCrowdSale() external onlyOwner {
        _allowICO = false;
        emit ChangeAllowICOStatus(false);
    }

resumeCrowdSale keyboard_arrow_up

    function resumeCrowdSale() external onlyOwner {
        _allowICO = true;
        emit ChangeAllowICOStatus(true);
    }

changeReceiveWallet keyboard_arrow_up

    function changeReceiveWallet(address payable newAddress) external onlyOwner {
        require(newAddress != address(0), "Address can not be 0x0");
        _ethFundMain = newAddress;
        emit ChangeReceiveWallet(newAddress);
    }

assignOwnership keyboard_arrow_up

	function assignOwnership(address newOwner) external onlyOwner {
	    require(newOwner != address(0), "Address can not be 0x0");
	    _owner = newOwner;
	    emit ChangeOwnerShip(newOwner);
	}

forwardFunds keyboard_arrow_up

    function forwardFunds() external onlyOwner {
        require(_ethFundMain != address(0));
        _ethFundMain.transfer(address(this).balance);
    }

haltTokenTransferFromAddress keyboard_arrow_up

    function haltTokenTransferFromAddress(address investor) external onlyOwner {
        locked[investor] = true;
        emit ChangeLockStatusFrom(investor, true);
    }

resumeTokenTransferFromAddress keyboard_arrow_up

    function resumeTokenTransferFromAddress(address investor) external onlyOwner {
        locked[investor] = false;
        emit ChangeLockStatusFrom(investor, false);
    }