Topic: [ANN][ICO] AUTORIA: Best Currency with Automated Mining, Claim Your Mining Well - page 4. (Read 10751 times)

pragma solidity ^0.4.11;

contract SafeMath {
  function safeMul(uint a, uint b) internal returns (uint) {
    uint c = a * b;
    assert(a == 0 || c / a == b);
    return c;
  }
  function safeSub(uint a, uint b) internal returns (uint) {
    assert(b <= a);
    return a - b;
  }
  function safeAdd(uint a, uint b) internal returns (uint) {
    uint c = a + b;
    assert(c>=a && c>=b);
    return c;
  }
  function assert(bool assertion) internal {
    if (!assertion) throw;
  }
}
 
contract Autoria is SafeMath {
    // ERC20 variables
    string public constant symbol = "AUT";
    string public constant name = "Autorium";
    uint8 public constant decimals = 18;
    uint256 public _totalSupply = 100000000000000000000000000;

    // Autoria specific variables
    uint256 creationTime = now;
    uint256 gensisBlock = block.number;
    uint256 blocksUntilExhaustion = 2102666;
    
    uint256 public earlySalePrice = 1000000000000000000;
    uint256 public regularSalePrice = 1300000000000000000;
    uint256 public exchangeRate = 17500;
    uint256 public freeTokenSupply = _totalSupply;
    uint256 public retainedSupplyPercentage = 30;
    
    // Owner of this contract
    address issuer;
    
    event Transfer(address indexed _from, address indexed _to, uint256 _value);
    event Approval(address indexed _owner, address indexed _spender, uint256 _value);
 
    // Balances and aquifers for each account
    mapping(address => uint256) public balances;
    mapping(address => uint256) public aquifers;
    mapping(address => uint256) public initialStake;
    
    // Flag for whether or not address is a well
    mapping (address => bool) public isWell;
 
    // Owner of account approves the transfer of an amount to another account
    mapping(address => mapping (address => uint256)) allowed;
 
    // Functions with this modifier can only be executed by the owner
    // modifiers for permissions on functions
    modifier onlyIssuer() { if (msg.sender == issuer) _; }
    modifier onlyInvestor() { if (msg.sender != issuer) _; }
 
    function aquiferOf(address _owner) public constant returns (uint256 tokens) { return aquifers[_owner]; }
    function getIssuerAddress() public constant returns(address issuerAddress) { return issuer; }
    function getFreeTokenSupply() public constant returns(uint256 tokens) { return freeTokenSupply; }
    function getRetainedSupplyPercentage() public constant returns(uint256 percentage) { return retainedSupplyPercentage; }
    function getCreationTime() public constant returns(uint256 time) { return creationTime; }
    function getGensisBlock() public constant returns(uint256 block) { return gensisBlock; }
    function getBlocksUntilExhaustion() public constant returns(uint256 blocks) { return blocksUntilExhaustion; }
    function getCurrentBlock() public returns(uint256 blocks) { return block.number; }
    
    // Constructor
    function Autoria() {
        // Establish the Issuer
        issuer = msg.sender;
        balances[msg.sender] += 30000000000000000000000000;
        aquifers[msg.sender] = 0;
        freeTokenSupply -= 30000000000000000000000000;
        // Send retainer coins to Issuer
    }

    // ICO Methods
    function paymentProcessor() onlyInvestor payable returns(uint256 tokens){
        
        // see if ICO is still running
        if (freeTokenSupply <= 0) { return 0; }
        if (isWell[msg.sender]) { return 0; }
        // determine exchange rate of AUT (increases if over 1 week after inception)
        uint price = earlySale() ? earlySalePrice : regularSalePrice;

        // set up some basic mapping stuff that we know will exist
        isWell[msg.sender] = true;

        uint requestedTokens = (msg.value / price) * exchangeRate;
        if (requestedTokens > freeTokenSupply) {
            return 0;
        }
        else {
            // send tokents to user
            aquifers[msg.sender] += requestedTokens;
            initialStake[msg.sender] += requestedTokens;
            // send eth to issuer
            issuer.transfer(msg.value);
            // update free token supply
            freeTokenSupply -= requestedTokens;
            return(requestedTokens);
        }
    }

    function earlySale() constant returns (bool ifSo) {
        if ((now - creationTime) > 1 weeks) return false;
        return true;
    }

    // ERC20 Methods
    function totalSupply() constant returns (uint256 totalSupply) {
        totalSupply = _totalSupply;
        return totalSupply;
    }
    
    function balanceOf(address _owner) constant returns (uint256 balance) {
        return balances[_owner];
    }

    function transfer(address _to, uint256 _amount) returns (bool success) {
        if (balances[msg.sender] >= _amount
            && _amount > 0
            && balances[_to] + _amount > balances[_to]) {
            balances[msg.sender] -= _amount;
            balances[_to] += _amount;
            Transfer(msg.sender, _to, _amount);
            return true;
        } else {
            return false;
        }
    }

    function transferFrom(
        address _from,
        address _to,
        uint256 _amount
    ) public returns (bool success) {
        if (balances[_from] >= _amount
            && allowed[_from][msg.sender] >= _amount
            && _amount > 0
            && balances[_to] + _amount > balances[_to]) {
            balances[_from] -= _amount;
            allowed[_from][msg.sender] -= _amount;
            balances[_to] += _amount;
            Transfer(_from, _to, _amount);
            return true;
        } else {
            return false;
        }
    }

    function approve(address _spender, uint256 _amount) public returns (bool success) {
        allowed[msg.sender][_spender] = _amount;
        Approval(msg.sender, _spender, _amount);
        return true;
    }

    function allowance(address _owner, address _spender) public constant returns (uint256 remaining) {
        return allowed[_owner][_spender];
    }
    
    // Autoria specific methods
    
    function availableDraw(address _owner) constant returns(uint256) {
        uint256 x = (initialStake[_owner] / blocksUntilExhaustion) * (block.number - gensisBlock);
        return aquifers[_owner] - (initialStake[_owner] - x);
    }
    
    function drawWell(address _owner) returns(bool) {
        if (isWell[_owner]) {
            //initial aquifer amount - initial aquifer amount
            uint256 draw = availableDraw(_owner);
            if (draw > 0 && aquifers[_owner] > 0) {
                balances[_owner] += draw;
                aquifers[_owner] -= draw;
            }
            return true;
        }
        return false;
    }
    
}