pragma solidity ^0.4.24; contract Raffle { using SafeMath for uint256; mapping (address => uint256) balances; address owner; address[] entrants; uint256 numEntrants; uint256 entryPrice; uint256 deadline; uint256 threshold; uint256 percentageTaken; // @param _entryPrice - entry price for each participant in wei i.e. 10^-18 eth. // @param _deadline - block number at which you want the crowdsale to end // @param _percentageToken - for example, to take 33% of the total use 3, only use integers constructor(uint256 _entryPrice, uint256 _deadline, uint256 _percentageTaken) public { entryPrice = _entryPrice; deadline = _deadline; percentageTaken = _percentageTaken; } modifier thresholdReached() { require(numEntrants >= threshold); _; } modifier belowThreshold() { require(numEntrants <= threshold); _; } modifier deadlinePassed() { require(now >= deadline); _; } modifier deadlineNotPassed() { require(now <= deadline); _; } modifier onlyOwner() { require(msg.sender == owner); _; } function() public payable { enterRaffle(); } function enterRaffle() public payable deadlineNotPassed { require(msg.value == entryPrice); balances[msg.sender] = balances[msg.sender].add(msg.value); numEntrants = numEntrants.add(1); entrants.push(msg.sender); } function withdrawFunds(uint amount) public deadlinePassed belowThreshold { require(balances[msg.sender] >= amount); balances[msg.sender] = balances[msg.sender].sub(amount); address(this).transfer(amount); } function determineWinner() public onlyOwner deadlinePassed thresholdReached { uint256 blockSeed = uint256(blockhash(block.number - 1)).div(2); uint256 coinbaseSeed = uint256(block.coinbase).div(2); uint256 winnerIndex = blockSeed.add(coinbaseSeed).mod(numEntrants); address winner = entrants[winnerIndex]; uint256 payout = address(this).balance.div(percentageTaken); winner.transfer(payout); owner.transfer(address(this).balance); } } /** * @title SafeMath * @dev Math operations with safety checks that revert on error */ library SafeMath { /** * @dev Multiplies two numbers, reverts on overflow. */ function mul(uint256 a, uint256 b) internal pure returns (uint256) { // Gas optimization: this is cheaper than requiring 'a' not being zero, but the // benefit is lost if 'b' is also tested. // See: https://github.com/OpenZeppelin/openzeppelin-solidity/pull/522 if (a == 0) { return 0; } uint256 c = a * b; require(c / a == b); return c; } /** * @dev Integer division of two numbers truncating the quotient, reverts on division by zero. */ function div(uint256 a, uint256 b) internal pure returns (uint256) { // Solidity only automatically asserts when dividing by 0 require(b > 0); uint256 c = a / b; // assert(a == b * c + a % b); // There is no case in which this doesn't hold return c; } /** * @dev Subtracts two numbers, reverts on overflow (i.e. if subtrahend is greater than minuend). */ function sub(uint256 a, uint256 b) internal pure returns (uint256) { require(b <= a); uint256 c = a - b; return c; } /** * @dev Adds two numbers, reverts on overflow. */ function add(uint256 a, uint256 b) internal pure returns (uint256) { uint256 c = a + b; require(c >= a); return c; } /** * @dev Divides two numbers and returns the remainder (unsigned integer modulo), * reverts when dividing by zero. */ function mod(uint256 a, uint256 b) internal pure returns (uint256) { require(b != 0); return a % b; } }
0.4.24