Polybius Token

0x0affa06e7fbe5bc9a764c979aa66e8256a631f02

_forwardApprove keyboard_arrow_up

    function _forwardApprove(address _spender, uint _value, address _sender) onlyImplementationFor(_sender) returns(bool) {
        return etoken2.proxyApprove(_spender, _value, etoken2Symbol, _sender);
    }

_forwardTransferFromWithReference keyboard_arrow_up

    function _forwardTransferFromWithReference(address _from, address _to, uint _value, string _reference, address _sender) onlyImplementationFor(_sender) returns(bool) {
        return etoken2.proxyTransferFromWithReference(_from, _to, _value, etoken2Symbol, _reference, _sender);
    }

_forwardTransferFromToICAPWithReference keyboard_arrow_up

    function _forwardTransferFromToICAPWithReference(address _from, bytes32 _icap, uint _value, string _reference, address _sender) onlyImplementationFor(_sender) returns(bool) {
        return etoken2.proxyTransferFromToICAPWithReference(_from, _icap, _value, _reference, _sender);
    }

totalSupply keyboard_arrow_up

    function totalSupply() constant returns(uint) {
        return etoken2.totalSupply(etoken2Symbol);
    }

balanceOf keyboard_arrow_up

    function balanceOf(address _owner) constant returns(uint) {
        return etoken2.balanceOf(_owner, etoken2Symbol);
    }

transfer keyboard_arrow_up

    function transfer(address _to, uint256 _value) returns(bool success);

transferFrom keyboard_arrow_up

    function transferFrom(address _from, address _to, uint256 _value) returns(bool success);

approve keyboard_arrow_up

    function approve(address _spender, uint256 _value) returns(bool success);

allowance keyboard_arrow_up

    function allowance(address _from, address _spender) constant returns(uint) {
        return etoken2.allowance(_from, _spender, etoken2Symbol);
    }

decimals keyboard_arrow_up

    function decimals() constant returns(uint8) {
        return etoken2.baseUnit(etoken2Symbol);
    }

init keyboard_arrow_up

    function init(EToken2 _etoken2, string _symbol, string _name) returns(bool) {
        if (address(etoken2) != 0x0) {
            return false;
        }
        etoken2 = _etoken2;
        etoken2Symbol = _bytes32(_symbol);
        name = _name;
        symbol = _symbol;
        return true;
    }

recoverTokens keyboard_arrow_up

    function recoverTokens(uint _value) onlyAssetOwner() returns(bool) {
        return this.transferWithReference(msg.sender, _value, 'Tokens recovery');
    }

transfer keyboard_arrow_up

    function transfer(address _to, uint _value) returns(bool) {
        return transferWithReference(_to, _value, '');
    }

transferWithReference keyboard_arrow_up

    function transferWithReference(address _to, uint _value, string _reference) returns(bool) {
        return _getAsset()._performTransferWithReference(_to, _value, _reference, msg.sender);
    }

transferToICAP keyboard_arrow_up

    function transferToICAP(bytes32 _icap, uint _value) returns(bool) {
        return transferToICAPWithReference(_icap, _value, '');
    }

transferToICAPWithReference keyboard_arrow_up

    function transferToICAPWithReference(bytes32 _icap, uint _value, string _reference) returns(bool) {
        return _getAsset()._performTransferToICAPWithReference(_icap, _value, _reference, msg.sender);
    }

transferFrom keyboard_arrow_up

    function transferFrom(address _from, address _to, uint _value) returns(bool) {
        return transferFromWithReference(_from, _to, _value, '');
    }

transferFromWithReference keyboard_arrow_up

    function transferFromWithReference(address _from, address _to, uint _value, string _reference) returns(bool) {
        return _getAsset()._performTransferFromWithReference(_from, _to, _value, _reference, msg.sender);
    }

transferFromToICAP keyboard_arrow_up

    function transferFromToICAP(address _from, bytes32 _icap, uint _value) returns(bool) {
        return transferFromToICAPWithReference(_from, _icap, _value, '');
    }

transferFromToICAPWithReference keyboard_arrow_up

    function transferFromToICAPWithReference(address _from, bytes32 _icap, uint _value, string _reference) returns(bool) {
        return _getAsset()._performTransferFromToICAPWithReference(_from, _icap, _value, _reference, msg.sender);
    }

approve keyboard_arrow_up

    function approve(address _spender, uint _value) returns(bool) {
        return _getAsset()._performApprove(_spender, _value, msg.sender);
    }

emitTransfer keyboard_arrow_up

    function emitTransfer(address _from, address _to, uint _value) onlyEToken2() {
        Transfer(_from, _to, _value);
    }

emitApprove keyboard_arrow_up

    function emitApprove(address _from, address _spender, uint _value) onlyEToken2() {
        Approval(_from, _spender, _value);
    }

constructor keyboard_arrow_up

    function () payable {
        bytes32 result = _getAsset()._performGeneric.value(msg.value)(msg.data, msg.sender);
        assembly {
            mstore(0, result)
            return(0, 32)
        }
    }

getVersionFor keyboard_arrow_up

    function getVersionFor(address _sender) constant returns(address) {
        return userOptOutVersion[_sender] == 0 ? latestVersion : userOptOutVersion[_sender];
    }

getLatestVersion keyboard_arrow_up

    function getLatestVersion() constant returns(address) {
        return latestVersion;
    }

getPendingVersion keyboard_arrow_up

    function getPendingVersion() constant returns(address) {
        return pendingVersion;
    }

getPendingVersionTimestamp keyboard_arrow_up

    function getPendingVersionTimestamp() constant returns(uint) {
        return pendingVersionTimestamp;
    }

proposeUpgrade keyboard_arrow_up

    function proposeUpgrade(address _newVersion) onlyAssetOwner() returns(bool) {
        // Should not already be in the upgrading process.
        if (pendingVersion != 0x0) {
            return false;
        }
        // New version address should be other than 0x0.
        if (_newVersion == 0x0) {
            return false;
        }
        // Don't apply freeze-time for the initial setup.
        if (latestVersion == 0x0) {
            latestVersion = _newVersion;
            return true;
        }
        pendingVersion = _newVersion;
        pendingVersionTimestamp = now;
        UpgradeProposal(_newVersion);
        return true;
    }

purgeUpgrade keyboard_arrow_up

    function purgeUpgrade() onlyAssetOwner() returns(bool) {
        if (pendingVersion == 0x0) {
            return false;
        }
        delete pendingVersion;
        delete pendingVersionTimestamp;
        return true;
    }

commitUpgrade keyboard_arrow_up

    function commitUpgrade() returns(bool) {
        if (pendingVersion == 0x0) {
            return false;
        }
        if (pendingVersionTimestamp + UPGRADE_FREEZE_TIME > now) {
            return false;
        }
        latestVersion = pendingVersion;
        delete pendingVersion;
        delete pendingVersionTimestamp;
        return true;
    }

optOut keyboard_arrow_up

    function optOut() returns(bool) {
        if (userOptOutVersion[msg.sender] != 0x0) {
            return false;
        }
        userOptOutVersion[msg.sender] = latestVersion;
        return true;
    }

optIn keyboard_arrow_up

    function optIn() returns(bool) {
        delete userOptOutVersion[msg.sender];
        return true;
    }

multiAsset keyboard_arrow_up

    function multiAsset() constant returns(EToken2) {
        return etoken2;
    }