serapath · May 3, 2018 00:44
diff --git a/AwardToken.sol b/AwardToken.sol
 import "github/OpenZeppelin/zeppelin-solidity/contracts/token/ERC20/MintableToken.sol";
 import "gist/Ballot.sol";

 contract AwardToken is MintableToken {
    uint quantity;
    uint ballotPeriod = 7 hours;
    Ballot public currBallot;
    address[] public prevWinners;
    event log (string _msg);
    event winLog (address _win);
    event newBallot (address _addr);
    
    function AwardToken () {
        quantity = 100;
        
    }
    
    function getPreviousWinners() constant returns (address[]) {
      return prevWinners;
    }
    
    // either a name change or it works fine without it
    // function approve(address spender, uint256 value) public returns (bool);
    function startRound() onlyOwner canMint public returns (bool) {
        // if this is the first minting then we should let this go immediately
        if (address(currBallot) == 0x0) {
            currBallot = new Ballot(ballotPeriod);
            newBallot(currBallot);
        } else {
            return false;
        }
    }
    
    function closeRound() onlyOwner {
        //  this can only be done by the owner of the contract
        if (address(currBallot) != 0x0 && currBallot.timeOut()) {
            // get winner
            address winner = currBallot.winningProposal();
            winLog(winner);
            // send to winner - but first make sure the address is valid
            if ( winner == 0x0){
                log("no winner");
            } else {
                winLog(winner);
                super.mint(winner, quantity);
                prevWinners.push(winner);
            }
            delete currBallot;
            // start new round
        }else revert();
    }
    
    function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
        revert();
    }
    
    function approve(address _spender, uint256 _value) public returns (bool) {
        revert();
    }
    
    function increaseApproval(address _spender, uint _addedValue) public returns (bool) {
        revert();
    }
    
    function decreaseApproval(address _spender, uint _subtractedValue) public returns (bool) {
        revert();
    }
    
    function transfer(address _to, uint256 _value) public returns (bool) {
        revert();
    }
    
 }
diff --git a/Ballot.sol b/Ballot.sol
 pragma solidity ^0.4.0;

 contract Ballot {

    uint _duration;
    uint _startTime;
    struct Proposal {
        string description;
        string title;
        uint voteCount;
        address targetAddress;
    }
    event log (string _msg);

    address chairperson;
    mapping(address => mapping (address => uint8)) voters; // map between proposal and voter and votes
    mapping(address => Proposal) public proposals;
    address[] public proposalsSender;
    
    function getProposals() constant returns (address[]) {
      return proposalsSender;
    }

    /// Create a new ballot with $(_numProposals) different proposals.
    function Ballot(uint duration) public {
        chairperson = msg.sender;
        _duration = duration;
        _startTime = now;
    }
    
    // duration issues...
    // add a new proposals
    function addProposal(string desc, string title, address targetAddr) public {
        if (timeOut() || targetAddr == 0x0 || proposals[msg.sender].targetAddress != 0x0){
            revert();
        }
        proposals[msg.sender].description  = desc;
        proposals[msg.sender].title  = title;
        proposals[msg.sender].voteCount  = 0;
        proposals[msg.sender].targetAddress  = targetAddr;
        proposalsSender.push(msg.sender);
    }

    /// Give a single vote to proposal $(toProposal).
    function vote(address proposal) public {
        // is this msg.sender in vote - the voter the proposal or the owner of the contract?
        // apparantly you can't vote more than once
        uint8 vote = voters[proposal][msg.sender];
        // the revert - takes it back to the initial state - but that blows away everyting - I suppose...
        // check on revert();
        if (timeOut()) revert();
        if (vote != 0) {
            revert(); // already voted for this proposal
        } else {
            voters[proposal][msg.sender] = 1;
            proposals[proposal].voteCount += 1;
        }
    }

    // timeOut vs duration in voteCount
    // for use in vote(), addProposal(), 
    function timeOut() public constant returns ( bool timeOver) {
        if (_startTime + _duration > now){
            timeOver = false;
        }else timeOver = true;
    }
    
    function winningProposal() public constant returns (address currLeader) {
        // does this need to be run only by the contract owner?  Currently I think it is not limited
        uint vote = 0;
        if (timeOut()){
            // timeOut - mean that at least the _duration  is over
            // what if there is tie?
            if(proposalsSender.length > 0) {
                for (uint8 k = 0; k < proposalsSender.length; k++) {
                    Proposal proposal = proposals[proposalsSender[k]];
                    if (vote < proposal.voteCount) {
                        vote = proposal.voteCount;
                        currLeader = proposal.targetAddress;
                    }
                }
                if (vote > 0) {
                    return currLeader;
                }else{
                    log("aint no voters!");
                }
            }else{
                log("aint no proposals!");
            }
        }
    }
 }
diff --git a/dependencies.txt b/dependencies.txt
 remix:loadurl https://github.com/OpenZeppelin/zeppelin-solidity/contracts/token/ERC20/MintableToken.sol
 remix:loadurl https://github.com/OpenZeppelin/zeppelin-solidity/contracts/ownership/Ownable.sol
 remix:loadurl https://github.com/OpenZeppelin/zeppelin-solidity/contracts/token/ERC20/StandardToken.sol
 remix:loadurl https://github.com/OpenZeppelin/zeppelin-solidity/contracts/token/ERC20/ERC20.sol
 remix:loadurl https://github.com/OpenZeppelin/zeppelin-solidity/contracts/token/ERC20/BasicToken.sol
 remix:loadurl https://github.com/OpenZeppelin/zeppelin-solidity/contracts/token/ERC20/ERC20Basic.sol
 remix:loadurl https://github.com/OpenZeppelin/zeppelin-solidity/contracts/math/SafeMath.sol
diff --git a/TUTORIAL.md b/TUTORIAL.md
	import "github/OpenZeppelin/zeppelin-solidity/contracts/token/ERC20/MintableToken.sol";
	import "gist/Ballot.sol";

	contract AwardToken is MintableToken {
	uint quantity;
	uint ballotPeriod = 7 hours;
	Ballot public currBallot;
	address[] public prevWinners;
	event log (string _msg);
	event winLog (address _win);
	event newBallot (address _addr);

	function AwardToken () {
	quantity = 100;

	}

	function getPreviousWinners() constant returns (address[]) {
	return prevWinners;
	}

	// either a name change or it works fine without it
	// function approve(address spender, uint256 value) public returns (bool);
	function startRound() onlyOwner canMint public returns (bool) {
	// if this is the first minting then we should let this go immediately
	if (address(currBallot) == 0x0) {
	currBallot = new Ballot(ballotPeriod);
	newBallot(currBallot);
	} else {
	return false;
	}
	}

	function closeRound() onlyOwner {
	// this can only be done by the owner of the contract
	if (address(currBallot) != 0x0 && currBallot.timeOut()) {
	// get winner
	address winner = currBallot.winningProposal();
	winLog(winner);
	// send to winner - but first make sure the address is valid
	if ( winner == 0x0){
	log("no winner");
	} else {
	winLog(winner);
	super.mint(winner, quantity);
	prevWinners.push(winner);
	}
	delete currBallot;
	// start new round
	}else revert();
	}

	function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
	revert();
	}

	function approve(address _spender, uint256 _value) public returns (bool) {
	revert();
	}

	function increaseApproval(address _spender, uint _addedValue) public returns (bool) {
	revert();
	}

	function decreaseApproval(address _spender, uint _subtractedValue) public returns (bool) {
	revert();
	}

	function transfer(address _to, uint256 _value) public returns (bool) {
	revert();
	}

	}
	pragma solidity ^0.4.0;

	contract Ballot {

	uint _duration;
	uint _startTime;
	struct Proposal {
	string description;
	string title;
	uint voteCount;
	address targetAddress;
	}
	event log (string _msg);

	address chairperson;
	mapping(address => mapping (address => uint8)) voters; // map between proposal and voter and votes
	mapping(address => Proposal) public proposals;
	address[] public proposalsSender;

	function getProposals() constant returns (address[]) {
	return proposalsSender;
	}

	/// Create a new ballot with $(_numProposals) different proposals.
	function Ballot(uint duration) public {
	chairperson = msg.sender;
	_duration = duration;
	_startTime = now;
	}

	// duration issues...
	// add a new proposals
	function addProposal(string desc, string title, address targetAddr) public {
	if (timeOut() \|\| targetAddr == 0x0 \|\| proposals[msg.sender].targetAddress != 0x0){
	revert();
	}
	proposals[msg.sender].description = desc;
	proposals[msg.sender].title = title;
	proposals[msg.sender].voteCount = 0;
	proposals[msg.sender].targetAddress = targetAddr;
	proposalsSender.push(msg.sender);
	}

	/// Give a single vote to proposal $(toProposal).
	function vote(address proposal) public {
	// is this msg.sender in vote - the voter the proposal or the owner of the contract?
	// apparantly you can't vote more than once
	uint8 vote = voters[proposal][msg.sender];
	// the revert - takes it back to the initial state - but that blows away everyting - I suppose...
	// check on revert();
	if (timeOut()) revert();
	if (vote != 0) {
	revert(); // already voted for this proposal
	} else {
	voters[proposal][msg.sender] = 1;
	proposals[proposal].voteCount += 1;
	}
	}

	// timeOut vs duration in voteCount
	// for use in vote(), addProposal(),
	function timeOut() public constant returns ( bool timeOver) {
	if (_startTime + _duration > now){
	timeOver = false;
	}else timeOver = true;
	}

	function winningProposal() public constant returns (address currLeader) {
	// does this need to be run only by the contract owner? Currently I think it is not limited
	uint vote = 0;
	if (timeOut()){
	// timeOut - mean that at least the _duration is over
	// what if there is tie?
	if(proposalsSender.length > 0) {
	for (uint8 k = 0; k < proposalsSender.length; k++) {
	Proposal proposal = proposals[proposalsSender[k]];
	if (vote < proposal.voteCount) {
	vote = proposal.voteCount;
	currLeader = proposal.targetAddress;
	}
	}
	if (vote > 0) {
	return currLeader;
	}else{
	log("aint no voters!");
	}
	}else{
	log("aint no proposals!");
	}
	}
	}
	}
	remix:loadurl https://github.com/OpenZeppelin/zeppelin-solidity/contracts/token/ERC20/MintableToken.sol
	remix:loadurl https://github.com/OpenZeppelin/zeppelin-solidity/contracts/ownership/Ownable.sol
	remix:loadurl https://github.com/OpenZeppelin/zeppelin-solidity/contracts/token/ERC20/StandardToken.sol
	remix:loadurl https://github.com/OpenZeppelin/zeppelin-solidity/contracts/token/ERC20/ERC20.sol
	remix:loadurl https://github.com/OpenZeppelin/zeppelin-solidity/contracts/token/ERC20/BasicToken.sol
	remix:loadurl https://github.com/OpenZeppelin/zeppelin-solidity/contracts/token/ERC20/ERC20Basic.sol
	remix:loadurl https://github.com/OpenZeppelin/zeppelin-solidity/contracts/math/SafeMath.sol