Contract Source Code:
File 1 of 1 : Token
// Copyright (c) 2017, 2018 EtherJack.io. All rights reserved.
// This code is disclosed only to be used for inspection and audit purposes.
// Code modification and use for any purpose other than security audit
// is prohibited. Creation of derived works or unauthorized deployment
// of the code or any its portion to a blockchain is prohibited.
pragma solidity ^0.4.19;
contract HouseOwned {
address house;
modifier onlyHouse {
require(msg.sender == house);
_;
}
/// @dev Contract constructor
function HouseOwned() public {
house = msg.sender;
}
}
// SafeMath is a part of Zeppelin Solidity library
// licensed under MIT License
// https://github.com/OpenZeppelin/zeppelin-solidity/blob/master/LICENSE
/**
* @title SafeMath
* @dev Math operations with safety checks that throw on error
*/
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
// ----------------------------------------------------------------------------
// ERC Token Standard #20 Interface
// https://github.com/ethereum/EIPs/blob/master/EIPS/eip-20-token-standard.md
// ----------------------------------------------------------------------------
contract ERC20Interface {
function totalSupply() public constant returns (uint);
function balanceOf(address _owner) public constant returns (uint balance);
function allowance(address _owner, address _spender) public constant returns (uint remaining);
function transfer(address _to, uint _value) public returns (bool success);
function approve(address _spender, uint _value) public returns (bool success);
function transferFrom(address _from, address _to, uint _value) public returns (bool success);
event Transfer(address indexed from, address indexed to, uint value);
event Approval(address indexed tokenOwner, address indexed spender, uint value);
}
contract Token is HouseOwned, ERC20Interface {
using SafeMath for uint;
// Public variables of the token
string public name;
string public symbol;
uint8 public constant decimals = 0;
uint256 public supply;
// Trusted addresses
Jackpot public jackpot;
address public croupier;
// All users' balances
mapping (address => uint256) internal balances;
// Users' deposits with Croupier
mapping (address => uint256) public depositOf;
// Total amount of deposits
uint256 public totalDeposit;
// Total amount of "Frozen Deposit Pool" -- the tokens for sale at Croupier
uint256 public frozenPool;
// Allowance mapping
mapping (address => mapping (address => uint256)) internal allowed;
//////
/// @title Modifiers
//
/// @dev Only Croupier
modifier onlyCroupier {
require(msg.sender == croupier);
_;
}
/// @dev Only Jackpot
modifier onlyJackpot {
require(msg.sender == address(jackpot));
_;
}
/// @dev Protection from short address attack
modifier onlyPayloadSize(uint size) {
assert(msg.data.length == size + 4);
_;
}
//////
/// @title Events
//
/// @dev Fired when a token is burned (bet made)
event Burn(address indexed from, uint256 value);
/// @dev Fired when a deposit is made or withdrawn
/// direction == 0: deposit
/// direction == 1: withdrawal
event Deposit(address indexed from, uint256 value, uint8 direction, uint256 newDeposit);
/// @dev Fired when a deposit with Croupier is frozen (set for sale)
event DepositFrozen(address indexed from, uint256 value);
/// @dev Fired when a deposit with Croupier is unfrozen (removed from sale)
// Value is the resulting deposit, NOT the unfrozen amount
event DepositUnfrozen(address indexed from, uint256 value);
//////
/// @title Constructor and Initialization
//
/// @dev Initializes contract with initial supply tokens to the creator of the contract
function Token() HouseOwned() public {
name = "JACK Token";
symbol = "JACK";
supply = 1000000;
}
/// @dev Function to set address of Jackpot contract once after creation
/// @param _jackpot Address of the Jackpot contract
function setJackpot(address _jackpot) onlyHouse public {
require(address(jackpot) == 0x0);
require(_jackpot != address(this)); // Protection from admin's mistake
jackpot = Jackpot(_jackpot);
uint256 bountyPortion = supply / 40; // 2.5% is the bounty portion for marketing expenses
balances[house] = bountyPortion; // House receives the bounty tokens
balances[jackpot] = supply - bountyPortion; // Jackpot gets the rest
croupier = jackpot.croupier();
}
//////
/// @title Public Methods
//
/// @dev Croupier invokes this method to return deposits to players
/// @param _to The address of the recipient
/// @param _extra Additional off-chain credit (AirDrop support), so that croupier can return more than the user has actually deposited
function returnDeposit(address _to, uint256 _extra) onlyCroupier public {
require(depositOf[_to] > 0 || _extra > 0);
uint256 amount = depositOf[_to];
depositOf[_to] = 0;
totalDeposit = totalDeposit.sub(amount);
_transfer(croupier, _to, amount.add(_extra));
Deposit(_to, amount, 1, 0);
}
/// @dev Gets the balance of the specified address.
/// @param _owner The address
function balanceOf(address _owner) public view returns (uint256 balance) {
return balances[_owner];
}
function totalSupply() public view returns (uint256) {
return supply;
}
/// @dev Send `_value` tokens to `_to`
/// @param _to The address of the recipient
/// @param _value the amount to send
function transfer(address _to, uint256 _value) onlyPayloadSize(2 * 32) public returns (bool) {
require(address(jackpot) != 0x0);
require(croupier != 0x0);
if (_to == address(jackpot)) {
// It is a token bet. Ignoring _value, only using 1 token
_burnFromAccount(msg.sender, 1);
jackpot.betToken(msg.sender);
return true;
}
if (_to == croupier && msg.sender != house) {
// It's a deposit to Croupier. In addition to transferring the token,
// mark it in the deposits table
// House can't make deposits. If House is transferring something to
// Croupier, it's just a transfer, nothing more
depositOf[msg.sender] += _value;
totalDeposit = totalDeposit.add(_value);
Deposit(msg.sender, _value, 0, depositOf[msg.sender]);
}
// In all cases but Jackpot transfer (which is terminated by a return), actually
// do perform the transfer
return _transfer(msg.sender, _to, _value);
}
/// @dev Transfer tokens from one address to another
/// @param _from address The address which you want to send tokens from
/// @param _to address The address which you want to transfer to
/// @param _value uint256 the amount of tokens to be transferred
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[_from]);
require(_value <= allowed[_from][msg.sender]);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
Transfer(_from, _to, _value);
return true;
}
/// @dev Approve the passed address to spend the specified amount of tokens on behalf of msg.sender.
/// @param _spender The address which will spend the funds.
/// @param _value The amount of tokens to be spent.
function approve(address _spender, uint256 _value) public returns (bool) {
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
/// @dev Function to check the amount of tokens that an owner allowed to a spender.
/// @param _owner address The address which owns the funds.
/// @param _spender address The address which will spend the funds.
/// @return A uint256 specifying the amount of tokens still available for the spender.
function allowance(address _owner, address _spender) public view returns (uint256) {
return allowed[_owner][_spender];
}
/// @dev Increase the amount of tokens that an owner allowed to a spender.
/// @param _spender The address which will spend the funds.
/// @param _addedValue The amount of tokens to increase the allowance by.
function increaseApproval(address _spender, uint _addedValue) public returns (bool) {
allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_addedValue);
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
/// @dev Decrease the amount of tokens that an owner allowed to a spender.
/// @param _spender The address which will spend the funds.
/// @param _subtractedValue The amount of tokens to decrease the allowance by.
function decreaseApproval(address _spender, uint _subtractedValue) public returns (bool) {
uint oldValue = allowed[msg.sender][_spender];
if (_subtractedValue > oldValue) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
}
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
/// @dev Croupier uses this method to set deposited credits of a player for sale
/// @param _user The address of the user
/// @param _extra Additional off-chain credit (AirDrop support), so that croupier could have frozen more than the user had invested
function freezeDeposit(address _user, uint256 _extra) onlyCroupier public {
require(depositOf[_user] > 0 || _extra > 0);
uint256 deposit = depositOf[_user];
depositOf[_user] = depositOf[_user].sub(deposit);
totalDeposit = totalDeposit.sub(deposit);
uint256 depositWithExtra = deposit.add(_extra);
frozenPool = frozenPool.add(depositWithExtra);
DepositFrozen(_user, depositWithExtra);
}
/// @dev Croupier uses this method stop selling user's tokens and return them to normal deposit
/// @param _user The user whose deposit is being unfrozen
/// @param _value The value to unfreeze according to Croupier's records (off-chain sale data)
function unfreezeDeposit(address _user, uint256 _value) onlyCroupier public {
require(_value > 0);
require(frozenPool >= _value);
depositOf[_user] = depositOf[_user].add(_value);
totalDeposit = totalDeposit.add(_value);
frozenPool = frozenPool.sub(_value);
DepositUnfrozen(_user, depositOf[_user]);
}
/// @dev The Jackpot contract invokes this method when selling tokens from Croupier
/// @param _to The recipient of the tokens
/// @param _value The amount
function transferFromCroupier(address _to, uint256 _value) onlyJackpot public {
require(_value > 0);
require(frozenPool >= _value);
frozenPool = frozenPool.sub(_value);
_transfer(croupier, _to, _value);
}
//////
/// @title Internal Methods
//
/// @dev Internal transfer function
/// @param _from From address
/// @param _to To address
/// @param _value The value to transfer
/// @return success
function _transfer(address _from, address _to, uint256 _value) internal returns (bool) {
require(_to != address(0)); // Prevent transfer to 0x0 address
require(balances[_from] >= _value); // Check if the sender has enough
balances[_from] = balances[_from].sub(_value); // Subtract from the sender
balances[_to] = balances[_to].add(_value); // Add the same to the recipient
Transfer(_from, _to, _value);
return true;
}
/// @dev Internal function for burning tokens
/// @param _sender The token sender (whose tokens are being burned)
/// @param _value The amount of tokens to burn
function _burnFromAccount(address _sender, uint256 _value) internal {
require(balances[_sender] >= _value); // Check if the sender has enough
balances[_sender] = balances[_sender].sub(_value); // Subtract from the sender
supply = supply.sub(_value); // Updates totalSupply
Burn(_sender, _value);
}
}
contract Jackpot is HouseOwned {
using SafeMath for uint;
enum Stages {
InitialOffer, // ICO stage: forming the jackpot fund
GameOn, // The game is running
GameOver, // The jackpot is won, paying out the jackpot
Aborted // ICO aborted, refunding investments
}
uint256 constant initialIcoTokenPrice = 4 finney;
uint256 constant initialBetAmount = 10 finney;
uint constant gameStartJackpotThreshold = 333 ether;
uint constant icoTerminationTimeout = 48 hours;
// These variables hold the values needed for minor prize checking:
// - when they were last won (once the number reaches the corresponding amount, the
// minor prize is won, and it should be reset)
// - how much ether was bet since it was last won
// `etherSince*` variables start with value of 1 and always have +1 in their value
// so that the variables never go 0, for gas consumption consistency
uint32 public totalBets = 0;
uint256 public etherSince20 = 1;
uint256 public etherSince50 = 1;
uint256 public etherSince100 = 1;
uint256 public pendingEtherForCroupier = 0;
// ICO status
uint32 public icoSoldTokens;
uint256 public icoEndTime;
// Jackpot status
address public lastBetUser;
uint256 public terminationTime;
address public winner;
uint256 public pendingJackpotForHouse;
uint256 public pendingJackpotForWinner;
// General configuration and stage
address public croupier;
Token public token;
Stages public stage = Stages.InitialOffer;
// Price state
uint256 public currentIcoTokenPrice = initialIcoTokenPrice;
uint256 public currentBetAmount = initialBetAmount;
// Investment tracking for emergency ICO termination
mapping (address => uint256) public investmentOf;
uint256 public abortTime;
//////
/// @title Modifiers
//
/// @dev Only Token
modifier onlyToken {
require(msg.sender == address(token));
_;
}
/// @dev Only Croupier
modifier onlyCroupier {
require(msg.sender == address(croupier));
_;
}
//////
/// @title Events
//
/// @dev Fired when tokens are sold for Ether in ICO
event EtherIco(address indexed from, uint256 value, uint256 tokens);
/// @dev Fired when a bid with Ether is made
event EtherBet(address indexed from, uint256 value, uint256 dividends);
/// @dev Fired when a bid with a Token is made
event TokenBet(address indexed from);
/// @dev Fired when a bidder wins a minor prize
/// Type: 1: 20, 2: 50, 3: 100
event MinorPrizePayout(address indexed from, uint256 value, uint8 prizeType);
/// @dev Fired when as a result of ether bid, tokens are sold from the Croupier's pool
/// The parameters are who bought them, how many tokens, and for how much Ether they were sold
event SoldTokensFromCroupier(address indexed from, uint256 value, uint256 tokens);
/// @dev Fired when the jackpot is won
event JackpotWon(address indexed from, uint256 value);
//////
/// @title Constructor and Initialization
//
/// @dev The contract constructor
/// @param _croupier The address of the trusted Croupier bot's account
function Jackpot(address _croupier)
HouseOwned()
public
{
require(_croupier != 0x0);
croupier = _croupier;
// There are no bets (it even starts in ICO stage), so initialize
// lastBetUser, just so that value is not zero and is meaningful
// The game can't end until at least one bid is made, and once
// a bid is made, this value is permanently overwritten.
lastBetUser = _croupier;
}
/// @dev Function to set address of Token contract once after creation
/// @param _token Address of the Token contract (JACK Token)
function setToken(address _token) onlyHouse public {
require(address(token) == 0x0);
require(_token != address(this)); // Protection from admin's mistake
token = Token(_token);
}
//////
/// @title Default Function
//
/// @dev The fallback function for receiving ether (bets)
/// Action depends on stages:
/// - ICO: just sell the tokens
/// - Game: accept bets, award tokens, award minor (20, 50, 100) prizes
/// - Game Over: pay out jackpot
/// - Aborted: fail
function() payable public {
require(croupier != 0x0);
require(address(token) != 0x0);
require(stage != Stages.Aborted);
uint256 tokens;
if (stage == Stages.InitialOffer) {
// First, check if the ICO is over. If it is, trigger the events and
// refund sent ether
bool started = checkGameStart();
if (started) {
// Refund ether without failing the transaction
// (because side-effect is needed)
msg.sender.transfer(msg.value);
return;
}
require(msg.value >= currentIcoTokenPrice);
// THE PLAN
// 1. [CHECK + EFFECT] Calculate how much times price, the investment amount is,
// calculate how many tokens the investor is going to get
// 2. [EFFECT] Log and count
// 3. [EFFECT] Check game start conditions and maybe start the game
// 4. [INT] Award the tokens
// 5. [INT] Transfer 20% to house
// 1. [CHECK + EFFECT] Checking the amount
tokens = _icoTokensForEther(msg.value);
// 2. [EFFECT] Log
// Log the ICO event and count investment
EtherIco(msg.sender, msg.value, tokens);
investmentOf[msg.sender] = investmentOf[msg.sender].add(
msg.value.sub(msg.value / 5)
);
// 3. [EFFECT] Game start
// Check if we have accumulated the jackpot amount required for game start
if (icoEndTime == 0 && this.balance >= gameStartJackpotThreshold) {
icoEndTime = now + icoTerminationTimeout;
}
// 4. [INT] Awarding tokens
// Award the deserved tokens (if any)
if (tokens > 0) {
token.transfer(msg.sender, tokens);
}
// 5. [INT] House
// House gets 20% of ICO according to the rules
house.transfer(msg.value / 5);
} else if (stage == Stages.GameOn) {
// First, check if the game is over. If it is, trigger the events and
// refund sent ether
bool terminated = checkTermination();
if (terminated) {
// Refund ether without failing the transaction
// (because side-effect is needed)
msg.sender.transfer(msg.value);
return;
}
// Now processing an Ether bid
require(msg.value >= currentBetAmount);
// THE PLAN
// 1. [CHECK] Calculate how much times min-bet, the bet amount is,
// calculate how many tokens the player is going to get
// 2. [CHECK] Check how much is sold from the Croupier's pool, and how much from Jackpot
// 3. [EFFECT] Deposit 25% to the Croupier (for dividends and house's benefit)
// 4. [EFFECT] Log and mark bid
// 6. [INT] Check and reward (if won) minor (20, 100, 1000) prizes
// 7. [EFFECT] Update bet amount
// 8. [INT] Award the tokens
// 1. [CHECK + EFFECT] Checking the bet amount and token reward
tokens = _betTokensForEther(msg.value);
// 2. [CHECK] Check how much is sold from the Croupier's pool, and how much from Jackpot
// The priority is (1) Croupier, (2) Jackpot
uint256 sellingFromJackpot = 0;
uint256 sellingFromCroupier = 0;
if (tokens > 0) {
uint256 croupierPool = token.frozenPool();
uint256 jackpotPool = token.balanceOf(this);
if (croupierPool == 0) {
// Simple case: only Jackpot is selling
sellingFromJackpot = tokens;
if (sellingFromJackpot > jackpotPool) {
sellingFromJackpot = jackpotPool;
}
} else if (jackpotPool == 0 || tokens <= croupierPool) {
// Simple case: only Croupier is selling
// either because Jackpot has 0, or because Croupier takes over
// by priority and has enough tokens in its pool
sellingFromCroupier = tokens;
if (sellingFromCroupier > croupierPool) {
sellingFromCroupier = croupierPool;
}
} else {
// Complex case: both are selling now
sellingFromCroupier = croupierPool; // (tokens > croupierPool) is guaranteed at this point
sellingFromJackpot = tokens.sub(sellingFromCroupier);
if (sellingFromJackpot > jackpotPool) {
sellingFromJackpot = jackpotPool;
}
}
}
// 3. [EFFECT] Croupier deposit
// Transfer a portion to the Croupier for dividend payout and house benefit
// Dividends are a sum of:
// + 25% of bet
// + 50% of price of tokens sold from Jackpot (or just anything other than the bet and Croupier payment)
// + 0% of price of tokens sold from Croupier
// (that goes in SoldTokensFromCroupier instead)
uint256 tokenValue = msg.value.sub(currentBetAmount);
uint256 croupierSaleRevenue = 0;
if (sellingFromCroupier > 0) {
croupierSaleRevenue = tokenValue.div(
sellingFromJackpot.add(sellingFromCroupier)
).mul(sellingFromCroupier);
}
uint256 jackpotSaleRevenue = tokenValue.sub(croupierSaleRevenue);
uint256 dividends = (currentBetAmount.div(4)).add(jackpotSaleRevenue.div(2));
// 100% of money for selling from Croupier still goes to Croupier
// so that it's later paid out to the selling user
pendingEtherForCroupier = pendingEtherForCroupier.add(dividends.add(croupierSaleRevenue));
// 4. [EFFECT] Log and mark bid
// Log the bet with actual amount charged (value less change)
EtherBet(msg.sender, msg.value, dividends);
lastBetUser = msg.sender;
terminationTime = now + _terminationDuration();
// If anything was sold from Croupier, log it appropriately
if (croupierSaleRevenue > 0) {
SoldTokensFromCroupier(msg.sender, croupierSaleRevenue, sellingFromCroupier);
}
// 5. [INT] Minor prizes
// Check for winning minor prizes
_checkMinorPrizes(msg.sender, currentBetAmount);
// 6. [EFFECT] Update bet amount
_updateBetAmount();
// 7. [INT] Awarding tokens
if (sellingFromJackpot > 0) {
token.transfer(msg.sender, sellingFromJackpot);
}
if (sellingFromCroupier > 0) {
token.transferFromCroupier(msg.sender, sellingFromCroupier);
}
} else if (stage == Stages.GameOver) {
require(msg.sender == winner || msg.sender == house);
if (msg.sender == winner) {
require(pendingJackpotForWinner > 0);
uint256 winnersPay = pendingJackpotForWinner;
pendingJackpotForWinner = 0;
msg.sender.transfer(winnersPay);
} else if (msg.sender == house) {
require(pendingJackpotForHouse > 0);
uint256 housePay = pendingJackpotForHouse;
pendingJackpotForHouse = 0;
msg.sender.transfer(housePay);
}
}
}
// Croupier will call this function when the jackpot is won
// If Croupier fails to call the function for any reason, house and winner
// still can claim their jackpot portion by sending ether to Jackpot
function payOutJackpot() onlyCroupier public {
require(winner != 0x0);
if (pendingJackpotForHouse > 0) {
uint256 housePay = pendingJackpotForHouse;
pendingJackpotForHouse = 0;
house.transfer(housePay);
}
if (pendingJackpotForWinner > 0) {
uint256 winnersPay = pendingJackpotForWinner;
pendingJackpotForWinner = 0;
winner.transfer(winnersPay);
}
}
//////
/// @title Public Functions
//
/// @dev View function to check whether the game should be terminated
/// Used as internal function by checkTermination, as well as by the
/// Croupier bot, to check whether it should call checkTermination
/// @return Whether the game should be terminated by timeout
function shouldBeTerminated() public view returns (bool should) {
return stage == Stages.GameOn && terminationTime != 0 && now > terminationTime;
}
/// @dev Check whether the game should be terminated, and if it should, terminate it
/// @return Whether the game was terminated as the result
function checkTermination() public returns (bool terminated) {
if (shouldBeTerminated()) {
stage = Stages.GameOver;
winner = lastBetUser;
// Flush amount due for Croupier immediately
_flushEtherToCroupier();
// The rest should be claimed by the winner (except what house gets)
JackpotWon(winner, this.balance);
uint256 jackpot = this.balance;
pendingJackpotForHouse = jackpot.div(5);
pendingJackpotForWinner = jackpot.sub(pendingJackpotForHouse);
return true;
}
return false;
}
/// @dev View function to check whether the game should be started
/// Used as internal function by `checkGameStart`, as well as by the
/// Croupier bot, to check whether it should call `checkGameStart`
/// @return Whether the game should be started
function shouldBeStarted() public view returns (bool should) {
return stage == Stages.InitialOffer && icoEndTime != 0 && now > icoEndTime;
}
/// @dev Check whether the game should be started, and if it should, start it
/// @return Whether the game was started as the result
function checkGameStart() public returns (bool started) {
if (shouldBeStarted()) {
stage = Stages.GameOn;
return true;
}
return false;
}
/// @dev Bet 1 token in the game
/// The token has already been burned having passed all checks, so
/// just process the bet of 1 token
function betToken(address _user) onlyToken public {
// Token bets can only be accepted in the game stage
require(stage == Stages.GameOn);
bool terminated = checkTermination();
if (terminated) {
return;
}
TokenBet(_user);
lastBetUser = _user;
terminationTime = now + _terminationDuration();
// Check for winning minor prizes
_checkMinorPrizes(_user, 0);
}
/// @dev Allows House to terminate ICO as an emergency measure
function abort() onlyHouse public {
require(stage == Stages.InitialOffer);
stage = Stages.Aborted;
abortTime = now;
}
/// @dev In case the ICO is emergency-terminated by House, allows investors
/// to pull back the investments
function claimRefund() public {
require(stage == Stages.Aborted);
require(investmentOf[msg.sender] > 0);
uint256 payment = investmentOf[msg.sender];
investmentOf[msg.sender] = 0;
msg.sender.transfer(payment);
}
/// @dev In case the ICO was terminated, allows House to kill the contract in 2 months
/// after the termination date
function killAborted() onlyHouse public {
require(stage == Stages.Aborted);
require(now > abortTime + 60 days);
selfdestruct(house);
}
//////
/// @title Internal Functions
//
/// @dev Get current bid timer duration
/// @return duration The duration
function _terminationDuration() internal view returns (uint256 duration) {
return (5 + 19200 / (100 + totalBets)) * 1 minutes;
}
/// @dev Updates the current ICO price according to the rules
function _updateIcoPrice() internal {
uint256 newIcoTokenPrice = currentIcoTokenPrice;
if (icoSoldTokens < 10000) {
newIcoTokenPrice = 4 finney;
} else if (icoSoldTokens < 20000) {
newIcoTokenPrice = 5 finney;
} else if (icoSoldTokens < 30000) {
newIcoTokenPrice = 5.3 finney;
} else if (icoSoldTokens < 40000) {
newIcoTokenPrice = 5.7 finney;
} else {
newIcoTokenPrice = 6 finney;
}
if (newIcoTokenPrice != currentIcoTokenPrice) {
currentIcoTokenPrice = newIcoTokenPrice;
}
}
/// @dev Updates the current bid price according to the rules
function _updateBetAmount() internal {
uint256 newBetAmount = 10 finney + (totalBets / 100) * 6 finney;
if (newBetAmount != currentBetAmount) {
currentBetAmount = newBetAmount;
}
}
/// @dev Calculates how many tokens a user should get with a given Ether bid
/// @param value The bid amount
/// @return tokens The number of tokens
function _betTokensForEther(uint256 value) internal view returns (uint256 tokens) {
// One bet amount is for the bet itself, for the rest we will sell
// tokens
tokens = (value / currentBetAmount) - 1;
if (tokens >= 1000) {
tokens = tokens + tokens / 4; // +25%
} else if (tokens >= 300) {
tokens = tokens + tokens / 5; // +20%
} else if (tokens >= 100) {
tokens = tokens + tokens / 7; // ~ +14.3%
} else if (tokens >= 50) {
tokens = tokens + tokens / 10; // +10%
} else if (tokens >= 20) {
tokens = tokens + tokens / 20; // +5%
}
}
/// @dev Calculates how many tokens a user should get with a given ICO transfer
/// @param value The transfer amount
/// @return tokens The number of tokens
function _icoTokensForEther(uint256 value) internal returns (uint256 tokens) {
// How many times the input is greater than current token price
tokens = value / currentIcoTokenPrice;
if (tokens >= 10000) {
tokens = tokens + tokens / 4; // +25%
} else if (tokens >= 5000) {
tokens = tokens + tokens / 5; // +20%
} else if (tokens >= 1000) {
tokens = tokens + tokens / 7; // ~ +14.3%
} else if (tokens >= 500) {
tokens = tokens + tokens / 10; // +10%
} else if (tokens >= 200) {
tokens = tokens + tokens / 20; // +5%
}
// Checking if Jackpot has the tokens in reserve
if (tokens > token.balanceOf(this)) {
tokens = token.balanceOf(this);
}
icoSoldTokens += (uint32)(tokens);
_updateIcoPrice();
}
/// @dev Flush the currently pending Ether to Croupier
function _flushEtherToCroupier() internal {
if (pendingEtherForCroupier > 0) {
uint256 willTransfer = pendingEtherForCroupier;
pendingEtherForCroupier = 0;
croupier.transfer(willTransfer);
}
}
/// @dev Count the bid towards minor prize fund, check if the user
/// wins a minor prize, and if they did, transfer the prize to them
/// @param user The user in question
/// @param value The bid value
function _checkMinorPrizes(address user, uint256 value) internal {
// First and foremost, increment the counters and ether counters
totalBets ++;
if (value > 0) {
etherSince20 = etherSince20.add(value);
etherSince50 = etherSince50.add(value);
etherSince100 = etherSince100.add(value);
}
// Now actually check if the bets won
uint256 etherPayout;
if ((totalBets + 30) % 100 == 0) {
// Won 100th
etherPayout = (etherSince100 - 1) / 10;
etherSince100 = 1;
MinorPrizePayout(user, etherPayout, 3);
user.transfer(etherPayout);
return;
}
if ((totalBets + 5) % 50 == 0) {
// Won 100th
etherPayout = (etherSince50 - 1) / 10;
etherSince50 = 1;
MinorPrizePayout(user, etherPayout, 2);
user.transfer(etherPayout);
return;
}
if (totalBets % 20 == 0) {
// Won 20th
etherPayout = (etherSince20 - 1) / 10;
etherSince20 = 1;
_flushEtherToCroupier();
MinorPrizePayout(user, etherPayout, 1);
user.transfer(etherPayout);
return;
}
return;
}
}