Payday Source Code (ATS Compliant Token)

pragma solidity 0.4.15;

library SafeMath {
    function mul(uint128 _a, uint128 _b) internal constant returns (uint128 c) {
        if (_a == 0) {
            return 0;
        }
        c = _a * _b;
        require(c / _a == _b);
        return c;
    }

    function div(uint128 _a, uint128 _b) internal constant returns (uint128) {
        require(_b > 0);
        return _a / _b;
    }

    function sub(uint128 _a, uint128 _b) internal constant returns (uint128) {
        require(_b <= _a);
        return _a - _b;
    }

    function add(uint128 _a, uint128 _b) internal constant returns (uint128 c) {
        c = _a + _b;
        require(c >= _a);
        return c;
    }
}

interface ATS {
    function name() public constant returns (string);
    function symbol() public constant returns (string);
    function totalSupply() public constant returns (uint128);
    function liquidSupply() public constant returns (uint128);
    function balanceOf(address owner) public constant returns (uint128);
    function granularity() public constant returns (uint128);
    function isOperatorFor(address operator, address tokenHolder) public constant returns (bool);
    function authorizeOperator(address operator) public;
    function revokeOperator(address operator) public;

    function send(address to, uint128 amount, bytes holderData) public;
    function operatorSend(address from, address to, uint128 amount, bytes holderData, bytes operatorData) public;
    function burn(uint128 amount, bytes holderData) public;
    function operatorBurn(address from, uint128 amount, bytes holderData, bytes operatorData) public;
    function thaw(address localRecipient, uint128 amount, bytes32 bridgeId, bytes bridgeData,
                   bytes32 remoteSender, bytes32 remoteBridgeId, bytes remoteData) public;
    function freeze(bytes32 remoteRecipient, uint128 amount, bytes32 bridgeId, bytes localData) public;
    function operatorFreeze(address localSender, bytes32 remoteRecipient, uint128 amount, bytes32 bridgeId,
                             bytes localData) public;

    event Created(
        uint128 indexed     _totalSupply,
        address indexed     _creator);

    event Sent(
        address indexed     _operator,
        address indexed     _from,
        address indexed     _to,
        uint128             _amount,
        bytes               _holderData,
        bytes               _operatorData);

    event Thawed(
        address indexed localRecipient,
        uint128 amount,
        bytes32 indexed bridgeId,
        bytes bridgeData,
        bytes32 indexed remoteSender,
        bytes32 remoteBridgeId,
        bytes remoteData);

    event Froze(
        address indexed localSender,
        bytes32 indexed remoteRecipient,
        uint128 amount,
        bytes32 indexed bridgeId,
        bytes localData);

    event Minted(
        address indexed     _operator,
        address indexed     _to,
        uint128             _amount,
        bytes               _operatorData);

    event Burned(
        address indexed     _operator,
        address indexed     _from,
        uint128             _amount,
        bytes               _holderData,
        bytes               _operatorData);

    event AuthorizedOperator(
        address indexed     _Eoperator,
        address indexed     _tokenHolder);

    event RevokedOperator(
        address indexed     _operator,
        address indexed     _tokenHolder);
}

contract ERC20 {
    function totalSupply() public constant returns (uint128);
    function balanceOf(address _who) public constant returns (uint128);
    function allowance(address _owner, address _spender) public constant returns (uint128);
    function transfer(address _to, uint128 _value) public returns (bool);
    function approve(address _spender, uint128 _value) public returns (bool);
    function transferFrom(address _from, address _to, uint128 _value) public returns (bool);

    event Transfer(
        address indexed from,
        address indexed to,
        uint128 value
    );

    event Approval(
        address indexed owner,
        address indexed spender,
        uint128 value
    );
}

contract AionInterfaceRegistry {
    function getManager(address target) public constant returns(address);
    function setManager(address target, address manager) public;
    function getInterfaceDelegate(address target, bytes32 interfaceHash) public constant returns (address);
    function setInterfaceDelegate(address target, bytes32 interfaceHash, address delegate) public;
}

contract AionInterfaceImplementer {
    AionInterfaceRegistry air=AionInterfaceRegistry(0xa0d270e7759e8fc020df5f1352bf4d329342c1bcdfe9297ef594fa352c7cab26);

    function setInterfaceDelegate(string _interfaceLabel, address impl) internal {
        bytes32 interfaceHash = sha3(_interfaceLabel);
        air.setInterfaceDelegate(this, interfaceHash, impl);
    }

    function getInterfaceDelegate(address addr, string _interfaceLabel) internal constant returns(address) {
        bytes32 interfaceHash = sha3(_interfaceLabel);
        return air.getInterfaceDelegate(addr, interfaceHash);
    }

    function setDelegateManager(address _newManager) internal {
        air.setManager(this, _newManager);
    }
}

interface ATSTokenRecipient {
    function tokensReceived(
        address operator,
        address from,
        address to,
        uint128 amount,
        bytes userData,
        bytes operatorData
    ) public;
}

interface ATSTokenSender {
    function tokensToSend(
        address operator,
        address from,
        address to,
        uint128 amount,
        bytes userData,
        bytes operatorData
    ) public;
}



  ///////////////////////////////////////////////////
 ////////////// Contract Begins Here ///////////////
///////////////////////////////////////////////////

contract ATSImpl is ATS, ERC20, AionInterfaceImplementer {
    using SafeMath for uint128;
    address constant internal addressTypeMask = 0xFF00000000000000000000000000000000000000000000000000000000000000;
    address constant internal zeroAddress = 0x0000000000000000000000000000000000000000000000000000000000000000;

    string internal mName;
    string internal mSymbol;
    uint128 internal mGranularity;
    uint128 internal mTotalSupply;
    uint128 internal transaction;
    uint128 internal pool=0;
    uint128 internal burnRate = 1;
    uint128 internal prizeRate = 24;

    mapping(address => uint128) internal mBalances;
    mapping(address => mapping(address => bool)) internal mAuthorized;
    mapping(address => mapping(address => uint128)) internal mAllowed;


    //ATS Constructor Function
    function ATSImpl() {

        mName = "Payday";
        mSymbol = "PAY";
        mTotalSupply = 500000*10**18; //500k initial supply
        mGranularity = 1;
        require(mGranularity >= 1);
        initialize(mTotalSupply);

        // register onto CIR
        setInterfaceDelegate("AIP004Token", this);
    }


    function initialize(uint128 _totalSupply) internal {
        mBalances[msg.sender] = _totalSupply;
        Created(_totalSupply, msg.sender);
        transaction = 0;
        pool = 0;
    }


      ///////////////////////////////////////////////////
     /////////////// ERC-777 Compliance ////////////////
    ///////////////////////////////////////////////////
    function name() public constant returns (string) { return mName; }
    function symbol() public constant returns (string) { return mSymbol; }
    function granularity() public constant returns (uint128) { return mGranularity; }
    function totalSupply() public constant returns (uint128) { return mTotalSupply; }
    function balanceOf(address _tokenHolder) public constant returns (uint128) { return mBalances[_tokenHolder]; }

    function send(address _to, uint128 _amount, bytes _userData) public {
        doSend(msg.sender, msg.sender, _to, _amount, _userData, "", true);
    }

    function authorizeOperator(address _operator) public {
        require(_operator != msg.sender);
        mAuthorized[_operator][msg.sender] = true;
        AuthorizedOperator(_operator, msg.sender);
    }

    function revokeOperator(address _operator) public {
        require(_operator != msg.sender);
        mAuthorized[_operator][msg.sender] = false;
        RevokedOperator(_operator, msg.sender);
    }

    function isOperatorFor(address _operator, address _tokenHolder) public constant returns (bool) {
        return (_operator == _tokenHolder || mAuthorized[_operator][_tokenHolder]);
    }

    function operatorSend(address _from, address _to, uint128 _amount, bytes _userData, bytes _operatorData) public {
        require(isOperatorFor(msg.sender, _from));
        doSend(msg.sender, _from, _to, _amount, _userData, _operatorData, true);
    }

    function burn(uint128 _amount, bytes _holderData) public {
        doBurn(msg.sender, msg.sender, _amount, _holderData, "");
    }

    function operatorBurn(address _tokenHolder, uint128 _amount, bytes _holderData, bytes _operatorData) public {
        require(isOperatorFor(msg.sender, _tokenHolder));
        doBurn(msg.sender, _tokenHolder, _amount, _holderData, _operatorData);
    }

      ///////////////////////////////////////////////////
     //////////////// Helper Functions /////////////////
    ///////////////////////////////////////////////////
    function requireMultiple(uint128 _amount) internal constant {
        require(_amount.div(mGranularity).mul(mGranularity) == _amount);
    }

    function isRegularAddress(address _addr) internal constant returns (bool) {
        return true;
    }

    function doSend(
        address _operator,
        address _from,
        address _to,
        uint128 _amount,
        bytes _userData,
        bytes _operatorData,
        bool _preventLocking
    )

    internal    {
        requireMultiple(_amount);

        callSender(_operator, _from, _to, _amount, _userData, _operatorData);

        require(_to != address(0));             // forbid sending to 0x0 (=burning)
        require(_to != address(this));          // forbid sending to the contract itself
        require(mBalances[_from] >= _amount);   // ensure enough funds
        pool = pool.add(_amount*24/100);

        // Increments tx counter
        transaction = transaction+1;
        // Removes tx from sender's address
        mBalances[_from] = mBalances[_from].sub(_amount);
        // Shrinks Supply by 1% of tx
        mTotalSupply = mTotalSupply.sub(_amount/100);
        // Sends 99% of the tx to recipient
        mBalances[_to] = mBalances[_to].add(_amount*75/100);

        // Checks to see if sender is the lucky 10th sender
        if (transaction==10) {
            //Rewards prize pool to lucky winner and resets tx counter.
            mBalances[_from] = mBalances[_from].add(pool);
            transaction=0;
        }

        callRecipient(_operator, _from, _to, _amount, _userData, _operatorData, _preventLocking);

        Sent(_operator, _from, _to, _amount, _userData, _operatorData);
    }


    function doBurn(address _operator, address _tokenHolder, uint128 _amount, bytes _holderData, bytes _operatorData)

    internal {
        requireMultiple(_amount);
        require(balanceOf(_tokenHolder) >= _amount);

        mBalances[_tokenHolder] = mBalances[_tokenHolder].sub(_amount);
        mTotalSupply = mTotalSupply.sub(_amount);

        callSender(_operator, _tokenHolder, 0x0, _amount, _holderData, _operatorData);
        Burned(_operator, _tokenHolder, _amount, _holderData, _operatorData);
    }


    function callRecipient(
        address _operator,
        address _from,
        address _to,
        uint128 _amount,
        bytes _userData,
        bytes _operatorData,
        bool _preventLocking
    )

    internal {
        address recipientImplementation = getInterfaceDelegate(_to, "AIP004TokenRecipient");
        if (recipientImplementation != 0) {
            ATSTokenRecipient(recipientImplementation).tokensReceived(
                _operator, _from, _to, _amount, _userData, _operatorData);
        } else if (_preventLocking) {
            require(isRegularAddress(_to));
        }
    }


    function callSender(
        address _operator,
        address _from,
        address _to,
        uint128 _amount,
        bytes _userData,
        bytes _operatorData
    )

    internal {
        address senderImplementation = getInterfaceDelegate(_from, "AIP004TokenSender");
        if (senderImplementation == 0) { return; }
        ATSTokenSender(senderImplementation).tokensToSend(_operator, _from, _to, _amount, _userData, _operatorData);
    }


    function liquidSupply() public constant returns (uint128) {
        return mTotalSupply.sub(balanceOf(this));
    }


      ///////////////////////////////////////////////////
     ///////////// Cross-Chain Compliance //////////////
    ///////////////////////////////////////////////////
    function thaw(
        address localRecipient,
        uint128 amount,
        bytes32 bridgeId,
        bytes bridgeData,
        bytes32 remoteSender,
        bytes32 remoteBridgeId,
        bytes remoteData)
    public {

    }

    function freeze(
        bytes32 remoteRecipient,
        uint128 amount,
        bytes32 bridgeId,
        bytes localData)
    public {

    }

    function operatorFreeze(address localSender,
        bytes32 remoteRecipient,
        uint128 amount,
        bytes32 bridgeId,
        bytes localData)
    public {

    }

      ///////////////////////////////////////////////////
     /////////////// ERC-20 Compliance /////////////////
    ///////////////////////////////////////////////////
    function decimals() public constant returns (uint8) {
        return uint8(18);
    }

    function transfer(address _to, uint128 _amount) public returns (bool success) {
        doSend(msg.sender, msg.sender, _to, _amount, "", "", false);
        return true;
    }

    function transferFrom(address _from, address _to, uint128 _amount) public returns (bool success) {
        require(_amount <= mAllowed[_from][msg.sender]);

        mAllowed[_from][msg.sender] = mAllowed[_from][msg.sender].sub(_amount);
        doSend(msg.sender, _from, _to, _amount, "", "", false);
        return true;
    }

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

    function allowance(address _owner, address _spender) public constant returns (uint128 remaining) {
        return mAllowed[_owner][_spender];
    }
}