0x19b4343d272da48779ab7a9a7436f95f63249871

// SPDX-License-Identifier: GLWTPL
pragma solidity ^0.8.11;

contract INK_by_TMWSTW{
    string private _name = "INK";
    string private _symbol = "INK";
    uint256 private _totalSupply = 10000000; // 10 million total supply /60k claims to deplete
	uint8[] private supply_array = [0,30,60,90,150];
    address private _creator;

    mapping(address => bool) private all_claim_routers;

    uint _blocks_to_refill = 2000; //around 7 hours

    //initial function
    constructor() {
        _balanceOf[address(this)] = _totalSupply;
        _creator = msg.sender;
    }

    //////////////////////////////////SPECIAL SAUCE
    
    mapping(uint16 => bool) private _faucet_unlocked;
    mapping(uint16 => uint8) private _faucet_daily_supply;
    mapping(uint16 => uint) private _faucet_last_claim_block;


    //claim resource by claim router
    function claim_resource(address _to, uint16 _faucet_id) public {
        require(all_claim_routers[msg.sender]); //only can be called by claim router 
        require(_faucet_unlocked[_faucet_id]==true);  //check if asset unlocked
        require(_faucet_daily_supply[_faucet_id]>0);   //check if faucet not null

        uint _temp_block = _faucet_last_claim_block[_faucet_id] + _blocks_to_refill;
        require(_temp_block < block.number); //check if faucet refilled (aprox daily)

        uint8 init_amount = _faucet_daily_supply[_faucet_id];
		
		//add random bonus
		uint256 _rand_num = uint256(keccak256(abi.encodePacked(block.timestamp, block.difficulty)));
        uint8 random_bonus = uint8(_rand_num % 30);
		
		uint8 _resource_amount = init_amount + random_bonus;
        require(_resource_amount <= _balanceOf[address(this)]); //check contract balance has enough

        _balanceOf[address(this)] -= _resource_amount;  //substract from contract balance
        _balanceOf[_to] += _resource_amount;  //add to player balance
        _faucet_last_claim_block[_faucet_id] = block.number; //set new claim block timestamp

        emit Transfer(address(this), _to, _resource_amount); //emit transfer event
    }


    //unlock faucet by claim router -- aka set random daily supply
    function unlock_faucet(uint16 _faucet_id,uint _rand_seed) public {

        require(all_claim_routers[msg.sender]); //only can be called by claim router 
        require(_faucet_id > 0 && _faucet_id <10001,"wrong faucet id"); //check if faucet is good 
        require(_faucet_unlocked[_faucet_id] == false,"faucet already unlocked"); //check if faucet is locked

        uint256 _rand_num = uint256(keccak256(abi.encodePacked(_rand_seed,block.timestamp, block.difficulty)));
        uint8 rand_255 = uint8(_rand_num % 255);
        if(rand_255 == 127){//highgiver 1/255 -- ~40
            _faucet_daily_supply[_faucet_id] = supply_array[4];
        }
        else if(rand_255<3){ //x3 -- 3/255 - ~120 
            _faucet_daily_supply[_faucet_id] = supply_array[3];
        }
		else if(rand_255<12){ //x9  -- 9/255 -- ~ 360
            _faucet_daily_supply[_faucet_id] = supply_array[2];
        }
		else if(rand_255<30){ //x18 -- 18/255 -- ~720
            _faucet_daily_supply[_faucet_id] = supply_array[1];
        }
		else{
			 _faucet_daily_supply[_faucet_id] = supply_array[0];
		}
        _faucet_last_claim_block[_faucet_id] = 0;  //set last claim block to 0
        _faucet_unlocked[_faucet_id] = true; //set faucet to unlocked

        emit Unlock_Faucet(_faucet_id,_faucet_daily_supply[_faucet_id]);
    }
	
    event Unlock_Faucet(uint16 indexed faucet_id, uint8 daily_supply);

    //return tokens into core
    function return_tokens(uint256 _value) public {
        require(_balanceOf[msg.sender] >= _value); //check if balance is good
        _balanceOf[msg.sender] -= _value;  //sunstract balance of sender
        _balanceOf[address(this)] += _value; //add to balance of receiver
        emit Tokens_returned(msg.sender, _value); //emit transfer event
    }
    event Tokens_returned(address _from,uint256 _value);

    //change CREATOR
    function change_creator(address _this_address)public CREATOR_ONLY{
        _creator = _this_address;
    }
  
    //check balance of contract
    function contract_balance() public view returns (uint256){
        return _balanceOf[address(this)];
    }

    //fillup claim routers array
    function add_remove_claim_routers(bool this_action, address[] calldata those_addresses ) public  CREATOR_ONLY{
        require(those_addresses.length>0,"no input");
        for(uint i = 0; i < those_addresses.length; i++){
            all_claim_routers[those_addresses[i]] = this_action;
        }
    }

    //return token data per faucet
    function check_tokens(uint16 _faucet_id) public view returns(uint){

        if(_faucet_unlocked[_faucet_id]){
            uint _temp_block = _faucet_last_claim_block[_faucet_id] + _blocks_to_refill;
            if(_temp_block < block.number){
                if(_faucet_daily_supply[_faucet_id]<=_balanceOf[address(this)]){
                    return _faucet_daily_supply[_faucet_id]; //return number of tokens to claim
                }
                else{
                    return 700; //contract depleted
                }
            }
            else{
                return 600; //resource depleted for today
            }
        }
        else{
            return 500; //resource locked
        }
    }

    modifier CREATOR_ONLY {
        require(msg.sender == _creator,"must be creator"); //must be creator
        _;
    }


   
    /////////////////////////////////ERC20 CLASSICS

    //mappings
    mapping(address => uint256) private _balanceOf;
    mapping(address => mapping(address => uint256)) private _allowance;

    //events
    event Transfer(address indexed _from, address indexed _to, uint256 _value);  //transfer event
    event Approval(address indexed _owner, address indexed _spender, uint256 _value);  //aproval event

    //transfer tokens
    function transfer(address _to, uint256 _value) public {
        _transfer(msg.sender,_to,_value);
    }

    //internal transfer function
    function _transfer(address _from,address _to, uint256 _value) internal virtual {
        require(_from != address(0)); //ignore null address
        require(_to != address(0)); //ignore null address
        require(_balanceOf[_from] >= _value); //check if balance is good
        _balanceOf[_from] -= _value;  //sunstract balance of sender
        _balanceOf[_to] += _value; //add to balance of receiver
        emit Transfer(_from, _to, _value); //emit transfer event
    }

    //aprove 3rd party to transfer tokens
    function approve(address _spender, uint256 _value) public {
        require(msg.sender != address(0)); //ignore null address
        require(_spender != address(0)); //ignore null address
        _allowance[msg.sender][_spender] = _value; //update allowance array
        emit Approval(msg.sender, _spender, _value); //emit aproval event
    }

    //transfer by 3rd party
    function transferFrom(address _from, address _to, uint256 _value) public {
        uint256 currentAllowance = _allowance[_from][msg.sender];
        if(currentAllowance != type(uint256).max){
            require(_allowance[_from][msg.sender] >= _value); //check if allowance is clear
            _allowance[_from][msg.sender] -= _value; //substract from allowance
        }
        _transfer(_from,_to,_value);
    }

    //check name
    function name() public view returns (string memory){
        return _name;
    }
    //check symbol
    function symbol() public view returns (string memory){
        return _symbol;
    }
    //check supply
    function totalSupply() public view returns (uint256){
        return _totalSupply;
    }
    //check balance
    function balanceOf(address _account) public view returns (uint256){
        return _balanceOf[_account];
    }
    
    //show allowance
    function allowance(address _owner, address _spender) public view returns (uint256){
        return _allowance[_owner][_spender];
    }
    //show decimals
    function decimals() public pure returns (uint8){
        return 0;
    }
}